Tools/WebGPUAPIStructure/Example/Example.cpp - WebKit - Git at Google

 /*
 * 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;
 }
	/*
	* 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;
	}