/*

* Copyright (C) 2017 Apple Inc. All rights reserved.

*

* Redistribution and use in source and binary forms, with or without

* modification, are permitted provided that the following conditions

* are met:

* 1. Redistributions of source code must retain the above copyright

* notice, this list of conditions and the following disclaimer.

* 2. Redistributions in binary form must reproduce the above copyright

* notice, this list of conditions and the following disclaimer in the

* documentation and/or other materials provided with the distribution.

*

* THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY

* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR

* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR

* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,

* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,

* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR

* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY

* OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

*/

// Example.cpp : Defines the entry point for the application.

//

#include "stdafx.h"

#include "Example.h"

#include <vector>

#include <cstdio>

#include <cassert>

#include <fstream>

#include <queue>

#include <boost/optional.hpp>

#include <WebGPU.h>

#define MAX_LOADSTRING 100

// Global Variables:

HINSTANCE hInst; // current instance

WCHAR szTitle[MAX_LOADSTRING]; // The title bar text

WCHAR szWindowClass[MAX_LOADSTRING]; // the main window class name

HWND hWnd;

std::unique_ptr<WebGPU::Device> device;

WebGPU::Queue* commandQueue = nullptr;

WebGPU::RenderState* renderState = nullptr;

WebGPU::RenderState* renderStateRTT = nullptr;

WebGPU::ComputeState* computeState = nullptr;

std::unique_ptr<WebGPU::BufferHolder> buffer;

std::unique_ptr<WebGPU::TextureHolder> texture;

std::unique_ptr<WebGPU::BufferHolder> vertexBuffer;

std::unique_ptr<WebGPU::BufferHolder> vertexBufferRTT;

std::unique_ptr<WebGPU::SamplerHolder> sampler;

std::queue<boost::unique_future<std::vector<uint8_t>>> futureQueue;

bool initializedBuffers = false;

float t = 0;

// Forward declarations of functions included in this code module:

ATOM MyRegisterClass(HINSTANCE hInstance);

BOOL InitInstance(HINSTANCE, int);

LRESULT CALLBACK WndProc(HWND, UINT, WPARAM, LPARAM);

static std::vector<uint8_t> readFile(const std::string& filename) {

std::ifstream file(filename.c_str(), std::ios::in | std::ios::binary | std::ios::ate);

assert(file.is_open());

auto size = file.tellg();

std::vector<uint8_t> result(size);

file.seekg(0, std::ios::beg);

file.read(reinterpret_cast<char*>(result.data()), size);

assert(file.tellg() == size);

return result;

}

static void drawWebGPU() {

if (!commandQueue || !renderState || !buffer || !vertexBuffer || !vertexBufferRTT || !renderStateRTT || !texture)

return;

WINDOWINFO windowInfo;

auto success = GetWindowInfo(hWnd, &windowInfo);

assert(success);

auto width = windowInfo.rcClient.right - windowInfo.rcClient.left;

auto height = windowInfo.rcClient.bottom - windowInfo.rcClient.top;

while (!futureQueue.empty() && futureQueue.front().is_ready() && futureQueue.front().has_value()) {

const auto& data = futureQueue.front().get();

float t = *reinterpret_cast<const float*>(data.data());

std::ostringstream ss;

ss << "T has value " << t << std::endl;

OutputDebugStringA(ss.str().c_str());

futureQueue.pop();

}

if (!initializedBuffers) {

auto hostAccessPass = commandQueue->createHostAccessPass();

std::vector<uint8_t> bufferContents(sizeof(float));

for (std::size_t i = 0; i < sizeof(float); ++i)

bufferContents[i] = reinterpret_cast<uint8_t*>(&t)[i];

hostAccessPass->overwriteBuffer(buffer->get(), bufferContents);

std::vector<float> vertexBufferContents = { -1, 1, -1, -1, 1, -1, 1, -1, 1, 1, -1, 1 };

std::vector<uint8_t> vertexBufferRawContents(sizeof(float) * 12);

for (std::size_t i = 0; i < vertexBufferContents.size(); ++i) {

float value = vertexBufferContents[i];

for (std::size_t j = 0; j < sizeof(float); ++j)

vertexBufferRawContents[sizeof(float) * i + j] = reinterpret_cast<uint8_t*>(&value)[j];

}

hostAccessPass->overwriteBuffer(vertexBuffer->get(), vertexBufferRawContents);

std::vector<float> vertexBufferContentsRTT = { -0.5, 0.5, 0, -0.5, 0.5, 1.0 };

std::vector<uint8_t> vertexBufferRawContentsRTT(sizeof(float) * 6);

for (std::size_t i = 0; i < vertexBufferContentsRTT.size(); ++i) {

float value = vertexBufferContentsRTT[i];

for (std::size_t j = 0; j < sizeof(float); ++j)

vertexBufferRawContentsRTT[sizeof(float) * i + j] = reinterpret_cast<uint8_t*>(&value)[j];

}

hostAccessPass->overwriteBuffer(vertexBufferRTT->get(), vertexBufferRawContentsRTT);

commandQueue->commitHostAccessPass(std::move(hostAccessPass));

initializedBuffers = true;

}

auto computePass = commandQueue->createComputePass();

computePass->setComputeState(*computeState);

computePass->setResources(0, { WebGPU::ShaderStorageBufferObjectReference(buffer->get()) });

computePass->dispatch(1, 1, 1);

commandQueue->commitComputePass(std::move(computePass));

std::vector<std::reference_wrapper<WebGPU::Texture>> rtt = { texture->get() };

auto renderPass = commandQueue->createRenderPass(&rtt);

renderPass->setRenderState(*renderStateRTT);

renderPass->setVertexAttributeBuffers({ vertexBufferRTT->get() });

renderPass->setResources(0, { WebGPU::UniformBufferObjectReference(buffer->get()) });

renderPass->setViewport(0, 0, width, height);

renderPass->setScissorRect(0, 0, width, height);

renderPass->draw(3);

commandQueue->commitRenderPass(std::move(renderPass));

auto renderPass2 = commandQueue->createRenderPass(nullptr);

renderPass2->setRenderState(*renderState);

renderPass2->setVertexAttributeBuffers({ vertexBuffer->get() });

renderPass2->setResources(0, { WebGPU::UniformBufferObjectReference(buffer->get()), WebGPU::TextureReference(texture->get()), WebGPU::SamplerReference(sampler->get()) });

renderPass2->setViewport(0, 0, width, height);

renderPass2->setScissorRect(0, 0, width, height);

renderPass2->draw(6);

commandQueue->commitRenderPass(std::move(renderPass2));

auto hostAccessPass = commandQueue->createHostAccessPass();

futureQueue.emplace(hostAccessPass->getBufferContents(buffer->get()));

commandQueue->commitHostAccessPass(std::move(hostAccessPass));

commandQueue->present();

}

int APIENTRY wWinMain(_In_ HINSTANCE hInstance,

_In_opt_ HINSTANCE hPrevInstance,

_In_ LPWSTR lpCmdLine,

_In_ int nCmdShow)

{

UNREFERENCED_PARAMETER(hPrevInstance);

UNREFERENCED_PARAMETER(lpCmdLine);

// TODO: Place code here.

// Initialize global strings

LoadStringW(hInstance, IDS_APP_TITLE, szTitle, MAX_LOADSTRING);

LoadStringW(hInstance, IDC_EXAMPLE, szWindowClass, MAX_LOADSTRING);

MyRegisterClass(hInstance);

// Perform application initialization:

if (!InitInstance (hInstance, nCmdShow))

{

return FALSE;

}

/*

#version 460

layout(location = 0) in vec2 position;

layout(std140, binding = 0) uniform buf {

float t;

};

void main() {

float time = t / 10;

vec2 delta = vec2(cos(time), sin(time));

delta = delta * 0.5;

gl_Position = vec4(position + delta, 0.5, 1);

}

glslangValidator -g -o "C:\Users\lithe\Documents\VertexShader.spv" -V -H "C:\Users\lithe\Documents\VertexShader.vert" -S vert

#version 460

layout (location = 0) out vec4 fragColor;

void main() {

fragColor = vec4(1, 0, 0, 1);

}

glslangValidator -g -o "C:\Users\lithe\Documents\FragmentShader.spv" -V -H "C:\Users\lithe\Documents\FragmentShader.frag" -S frag

#version 460

layout(location = 0) in vec2 position;

layout(location = 0) out vec2 texCoord;

layout(std140, binding = 0) uniform buf {

float t;

};

void main() {

texCoord = position;

gl_Position = vec4(position, 0.5, 1);

}

glslangValidator -g -o "C:\Users\lithe\Documents\VertexShader2.spv" -V -H "C:\Users\lithe\Documents\VertexShader2.vert" -S vert

struct Result {

float4 color : SV_Target0;

};

Texture2D<float4> inputTexture : register(t1);

SamplerState inputSampler : register(s2);

Result main(float2 texCoord : TEXCOORD0)

{

Result result;

float4 sampleResult = inputTexture.Sample(inputSampler, texCoord);

result.color = float4(sampleResult.rgb, 1.0f);

return result;

}

dxc.exe -spirv -T ps_6_0 "C:\Users\lithe\Documents\PixelShader.hlsl" -Fo "C:\Users\lithe\Documents\FragmentShader2.spv"

*/

commandQueue = &device->getCommandQueue();

auto vertexShaderRTT = readFile("C:\\Users\\lithe\\Documents\\VertexShader.spv");

auto fragmentShaderRTT = readFile("C:\\Users\\lithe\\Documents\\FragmentShader.spv");

auto computeShader = readFile("C:\\Users\\lithe\\Documents\\ComputeShader.spv");

auto vertexShader = readFile("C:\\Users\\lithe\\Documents\\VertexShader2.spv");

auto fragmentShader = readFile("C:\\Users\\lithe\\Documents\\FragmentShader2.spv");

vertexBufferRTT = std::unique_ptr<WebGPU::BufferHolder>(new WebGPU::BufferHolder(device->getBuffer(static_cast<unsigned int>(sizeof(float) * 6))));

buffer = std::unique_ptr<WebGPU::BufferHolder>(new WebGPU::BufferHolder(device->getBuffer(static_cast<unsigned int>(sizeof(float)))));

vertexBuffer = std::unique_ptr<WebGPU::BufferHolder>(new WebGPU::BufferHolder(device->getBuffer(static_cast<unsigned int>(sizeof(float) * 12))));

sampler = std::unique_ptr<WebGPU::SamplerHolder>(new WebGPU::SamplerHolder(device->getSampler(WebGPU::AddressMode::Repeat, WebGPU::Filter::Linear)));

WINDOWINFO windowInfo;

auto success = GetWindowInfo(hWnd, &windowInfo);

assert(success);

texture = std::unique_ptr<WebGPU::TextureHolder>(new WebGPU::TextureHolder(device->getTexture(windowInfo.rcClient.right - windowInfo.rcClient.left, windowInfo.rcClient.bottom - windowInfo.rcClient.top, WebGPU::PixelFormat::RGBA8)));

std::vector<WebGPU::RenderState::VertexAttribute> vertexAttributes = { {WebGPU::RenderState::VertexFormat::Float2, 0, 0} };

std::vector<WebGPU::PixelFormat> colorPixelFormats = { WebGPU::PixelFormat::RGBA8 };

renderStateRTT = &device->getRenderState(vertexShaderRTT, "main", fragmentShaderRTT, "main", { 8 }, vertexAttributes, { { WebGPU::ResourceType::UniformBufferObject } }, &colorPixelFormats);

renderState = &device->getRenderState(vertexShader, "main", fragmentShader, "main", { 8 }, vertexAttributes, { { WebGPU::ResourceType::UniformBufferObject, WebGPU::ResourceType::Texture, WebGPU::ResourceType::Sampler } }, nullptr);

computeState = &device->getComputeState(computeShader, "main", { { WebGPU::ResourceType::ShaderStorageBufferObject } });

drawWebGPU();

HACCEL hAccelTable = LoadAccelerators(hInstance, MAKEINTRESOURCE(IDC_EXAMPLE));

MSG msg;

// Main message loop:

while (GetMessage(&msg, nullptr, 0, 0))

{

if (!TranslateAccelerator(msg.hwnd, hAccelTable, &msg))

{

TranslateMessage(&msg);

DispatchMessage(&msg);

}

RedrawWindow(hWnd, nullptr, nullptr, RDW_INTERNALPAINT);

}

return (int) msg.wParam;

}

//

// FUNCTION: MyRegisterClass()

//

// PURPOSE: Registers the window class.

//

ATOM MyRegisterClass(HINSTANCE hInstance)

{

WNDCLASSEXW wcex;

wcex.cbSize = sizeof(WNDCLASSEX);

wcex.style = CS_HREDRAW | CS_VREDRAW;

wcex.lpfnWndProc = WndProc;

wcex.cbClsExtra = 0;

wcex.cbWndExtra = 0;

wcex.hInstance = hInstance;

wcex.hIcon = LoadIcon(hInstance, MAKEINTRESOURCE(IDI_EXAMPLE));

wcex.hCursor = LoadCursor(nullptr, IDC_ARROW);

wcex.hbrBackground = (HBRUSH)(COLOR_WINDOW+1);

wcex.lpszMenuName = nullptr;

wcex.lpszClassName = szWindowClass;

wcex.hIconSm = LoadIcon(wcex.hInstance, MAKEINTRESOURCE(IDI_SMALL));

return RegisterClassExW(&wcex);

}

//

// FUNCTION: InitInstance(HINSTANCE, int)

//

// PURPOSE: Saves instance handle and creates main window

//

// COMMENTS:

//

// In this function, we save the instance handle in a global variable and

// create and display the main program window.

//

BOOL InitInstance(HINSTANCE hInstance, int nCmdShow)

{

hInst = hInstance; // Store instance handle in our global variable

hWnd = CreateWindowW(szWindowClass, szTitle, WS_OVERLAPPEDWINDOW,

CW_USEDEFAULT, 0, CW_USEDEFAULT, 0, nullptr, nullptr, hInstance, nullptr);

if (!hWnd)

{

return FALSE;

}

device = WebGPU::Device::create(hInstance, hWnd);

ShowWindow(hWnd, nCmdShow);

UpdateWindow(hWnd);

return TRUE;

}

//

// FUNCTION: WndProc(HWND, UINT, WPARAM, LPARAM)

//

// PURPOSE: Processes messages for the main window.

//

// WM_COMMAND - process the application menu

// WM_PAINT - Paint the main window

// WM_DESTROY - post a quit message and return

//

//

LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)

{

switch (message)

{

case WM_PAINT:

drawWebGPU();

break;

case WM_DESTROY:

PostQuitMessage(0);

break;

default:

return DefWindowProc(hWnd, message, wParam, lParam);

}

return 0;

}