Initial import of code.

6 files changed, 1004 insertions, 0 deletions

diff --git a/examples/hello/README.md b/examples/hello/README.md
new file mode 100644
index 000000000..410bbd7bb
--- /dev/null
+++ b/examples/hello/README.md
@@ -0,0 +1,9 @@
+Spire "Hello World" Example
+===========================
+
+The goal of this example is to demonstrate an almost minimal application that uses Spire for shading, and D3D11 for rendering.
+
+The `hello.spire` file contains a simple declaration of a Spire *shader module*, along with a *pipeline declaration* that will be used for mapping shader code to the capabilities of the "engine" (in this case, just vertex and fragment shaders).
+The `hello.cpp` file contains the C++ application code, showing how to use the Spire C API to load and compile the shader code, and construct a (trivial) executable shader from Spire modules.
+
+Note that this example is not intended to demonstrate good practices for integrating Spire into a production engine; the goal is merely to use the minimum amount of code possible to demonstrate a complete applicaiton that uses Spire.
diff --git a/examples/hello/hello.cpp b/examples/hello/hello.cpp
new file mode 100644
index 000000000..c9121b790
--- /dev/null
+++ b/examples/hello/hello.cpp
@@ -0,0 +1,589 @@
+// hello.cpp
+
+// In order to use the Slang API, we need to include its header
+
+#define SLANG_INCLUDE_IMPLEMENTATION
+#include <slang.h>
+
+// We will be rendering with Direct3D 11, so we need to include
+// the Windows and D3D11 headers
+
+#define WIN32_LEAN_AND_MEAN
+#define NOMINMAX
+#include <Windows.h>
+#undef WIN32_LEAN_AND_MEAN
+#undef NOMINMAX
+
+#include <d3d11_2.h>
+#include <d3dcompiler.h>
+
+// We will use the C standard library just for printing error messages.
+#include <stdio.h>
+
+#ifdef _MSC_VER
+#include <stddef.h>
+#if (_MSC_VER < 1900)
+#define snprintf sprintf_s
+#endif
+#endif
+//
+
+static int gWindowWidth = 1024;
+static int gWindowHeight = 768;
+
+//
+
+//
+// For the purposes of a small example, we will define the vertex data for a
+// single triangle directly in the source file. It should be easy to extend
+// this example to load data from an external source, if desired.
+//
+
+struct Vertex
+{
+    float position[3];
+    float color[3];
+};
+
+static const int kVertexCount = 3;
+static const Vertex kVertexData[kVertexCount] = {
+    { { 0,  0, 0.5 }, {1, 0, 0} },
+    { { 0,  1, 0.5 }, {0, 0, 1} },
+    { { 1,  0, 0.5 }, {0, 1, 0} },
+};
+
+//
+
+// Global variabels for the various D3D11 API objects to be used for rendering
+ID3D11Buffer*       dxConstantBuffer;
+ID3D11InputLayout*  dxInputLayout;
+ID3D11Buffer*       dxVertexBuffer;
+ID3D11VertexShader* dxVertexShader;
+ID3D11PixelShader*  dxPixelShader;
+
+// The Slang compiler currently generates HLSL source, so we'll need a utility
+// routine (defined later) to translate that into D3D11 shader bytecode.
+ID3DBlob* compileHLSLShader(
+    char const* source,
+    char const* entryPointName,
+    char const* dxProfileName);
+
+//
+// At initialization time, we are going to load and compile our Slang shader
+// code, and then create the D3D11 API objects we need for rendering.
+//
+HRESULT initialize( ID3D11Device* dxDevice )
+{
+#if 1
+    //
+    // First, we will load and compile our Slang source code.
+    //
+
+    // The argument here is an optional directory where the Slang compiler
+    // can cache files to speed up compilation of many kernels.
+    SlangSession* slangSession = spCreateSession(NULL);
+
+    // A compile request represents a single invocation of the compiler,
+    // to process some inputs and produce outputs (or errors).
+    SlangCompileRequest* slangRequest = spCreateCompileRequest(slangSession);
+
+    // Instruct Slang to generate code as HLSL
+    spSetCodeGenTarget(slangRequest, SLANG_HLSL);
+
+    int translationUnitIndex = spAddTranslationUnit(slangRequest, SLANG_SOURCE_LANGUAGE_SLANG, nullptr);
+
+    spAddTranslationUnitSourceFile(slangRequest, translationUnitIndex, "hello.slang");
+
+    char const* vertexEntryPointName    = "vertexMain";
+    char const* fragmentEntryPointName  = "fragmentMain";
+
+    char const* vertexProfileName   = "vs_4_0";
+    char const* fragmentProfileName = "ps_4_0";
+
+    spAddTranslationUnitEntryPoint(slangRequest, translationUnitIndex, vertexEntryPointName,   spFindProfile(slangSession, vertexProfileName));
+    spAddTranslationUnitEntryPoint(slangRequest, translationUnitIndex, fragmentEntryPointName, spFindProfile(slangSession, fragmentProfileName));
+
+    int compileErr = spCompile(slangRequest);
+    if(auto diagnostics = spGetDiagnosticOutput(slangRequest))
+    {
+        OutputDebugStringA(diagnostics);
+        fprintf(stderr, "%s", diagnostics);
+    }
+    if(compileErr)
+    {
+        return E_FAIL;
+    }
+
+    char const* translatedCode = spGetTranslationUnitSource(slangRequest, translationUnitIndex);
+
+
+    // TODO(tfoley): Query the required constant-buffer size
+    int constantBufferSize = 16 * sizeof(float);
+
+    // Compile the generated HLSL code
+    ID3DBlob* dxVertexShaderBlob = compileHLSLShader(translatedCode, vertexEntryPointName, vertexProfileName);
+    if(!dxVertexShaderBlob) return E_FAIL;
+
+    ID3DBlob* dxPixelShaderBlob = compileHLSLShader(translatedCode, fragmentEntryPointName, fragmentProfileName);
+    if(!dxPixelShaderBlob) return E_FAIL;
+
+    HRESULT hr = S_OK;
+
+
+    D3D11_BUFFER_DESC dxConstantBufferDesc = { 0 };
+    dxConstantBufferDesc.ByteWidth = constantBufferSize;
+    dxConstantBufferDesc.Usage = D3D11_USAGE_DYNAMIC;
+    dxConstantBufferDesc.BindFlags = D3D11_BIND_CONSTANT_BUFFER;
+    dxConstantBufferDesc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
+
+    hr = dxDevice->CreateBuffer(
+        &dxConstantBufferDesc,
+        NULL,
+        &dxConstantBuffer);
+    if(FAILED(hr)) return hr;
+
+    // We clean up the Slang compilation context and result *after*
+    // we have done the HLSL-to-bytecode compilation, because Slang
+    // owns the memory allocation for the generated HLSL, and will
+    // free it when we destroy the compilation result.
+    spDestroyCompileRequest(slangRequest);
+    spDestroySession(slangSession);
+
+    // Input Assembler (IA)
+
+    // In Slang-generated HLSL, all vertex shader inputs have a semantic
+    // like: `A0`, `A1`, `A2`, etc., rather than trying to do by-name
+    // matching. The user is thus responsibile for ensuring that the
+    // order of their "input element descs" here matches the order
+    // in which inputs are declared in the shader code.
+    D3D11_INPUT_ELEMENT_DESC dxInputElements[] = {
+        {"A", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, offsetof(Vertex, position), D3D11_INPUT_PER_VERTEX_DATA, 0 },
+        {"A", 1, DXGI_FORMAT_R32G32B32_FLOAT, 0, offsetof(Vertex, color), D3D11_INPUT_PER_VERTEX_DATA, 0 },
+    };
+    hr = dxDevice->CreateInputLayout(
+        &dxInputElements[0],
+        2,
+        dxVertexShaderBlob->GetBufferPointer(),
+        dxVertexShaderBlob->GetBufferSize(),
+        &dxInputLayout);
+    if(FAILED(hr)) return hr;
+
+    D3D11_BUFFER_DESC dxVertexBufferDesc = { 0 };
+    dxVertexBufferDesc.ByteWidth = kVertexCount * sizeof(Vertex);
+    dxVertexBufferDesc.Usage = D3D11_USAGE_IMMUTABLE;
+    dxVertexBufferDesc.BindFlags = D3D11_BIND_VERTEX_BUFFER;
+
+    D3D11_SUBRESOURCE_DATA dxVertexBufferInitData = { 0 };
+    dxVertexBufferInitData.pSysMem = &kVertexData[0];
+
+    hr = dxDevice->CreateBuffer(
+        &dxVertexBufferDesc,
+        &dxVertexBufferInitData,
+        &dxVertexBuffer);
+    if(FAILED(hr)) return hr;
+
+    // Vertex Shader (VS)
+
+    hr = dxDevice->CreateVertexShader(
+        dxVertexShaderBlob->GetBufferPointer(),
+        dxVertexShaderBlob->GetBufferSize(),
+        NULL,
+        &dxVertexShader);
+    dxVertexShaderBlob->Release();
+    if(FAILED(hr)) return hr;
+
+    // Pixel Shader (PS)
+
+    hr = dxDevice->CreatePixelShader(
+        dxPixelShaderBlob->GetBufferPointer(),
+        dxPixelShaderBlob->GetBufferSize(),
+        NULL,
+        &dxPixelShader);
+    dxPixelShaderBlob->Release();
+    if(FAILED(hr)) return hr;
+#endif
+
+    return S_OK;
+}
+
+void renderFrame(ID3D11DeviceContext* dxContext)
+{
+    // We update our constant buffer per-frame, just for the purposes
+    // of the example, but we don't actually load different data
+    // per-frame (we always use an identity projection).
+    D3D11_MAPPED_SUBRESOURCE mapped;
+    HRESULT hr = dxContext->Map(dxConstantBuffer, 0, D3D11_MAP_WRITE_DISCARD, 0, &mapped);
+    if(!FAILED(hr))
+    {
+        float* data = (float*) mapped.pData;
+
+        static const float kIdentity[] =
+        { 1, 0, 0, 0,
+          0, 1, 0, 0,
+          0, 0, 1, 0,
+          0, 0, 0, 1 };
+        memcpy(data, kIdentity, sizeof(kIdentity));
+
+        dxContext->Unmap(dxConstantBuffer, 0);
+    }
+
+    // Input Assembler (IA)
+
+    dxContext->IASetInputLayout(dxInputLayout);
+    dxContext->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
+
+    UINT dxVertexStride = sizeof(Vertex);
+    UINT dxVertexBufferOffset = 0;
+    dxContext->IASetVertexBuffers(0, 1, &dxVertexBuffer, &dxVertexStride, &dxVertexBufferOffset);
+
+    // Vertex Shader (VS)
+
+    dxContext->VSSetShader(dxVertexShader, NULL, 0);
+    dxContext->VSSetConstantBuffers(0, 1, &dxConstantBuffer);
+
+    // Pixel Shader (PS)
+
+    dxContext->PSSetShader(dxPixelShader, NULL, 0);
+    dxContext->VSSetConstantBuffers(0, 1, &dxConstantBuffer);
+
+    //
+
+    dxContext->Draw(3, 0);
+}
+
+void finalize()
+{
+}
+
+//
+// Definition of the HLSL-to-bytecode compilation logic.
+//
+ID3DBlob* compileHLSLShader(
+    char const* source,
+    char const* entryPointName,
+    char const* dxProfileName )
+{
+    // Rather than statically link against the `d3dcompile` library, we
+    // dynamically load it.
+    //
+    // Note: A more realistic application would compile from HLSL text to D3D
+    // shader bytecode as part of an offline process, rather than doing it
+    // on-the-fly like this
+    //
+    static pD3DCompile D3DCompile_ = nullptr;
+    if( !D3DCompile_ )
+    {
+        // TODO(tfoley): maybe want to search for one of a few versions of the DLL
+        HMODULE d3dcompiler = LoadLibraryA("d3dcompiler_47.dll");
+        if(!d3dcompiler)
+        {
+            fprintf(stderr, "error: failed load 'd3dcompiler_47.dll'\n");
+            exit(1);
+        }
+
+        D3DCompile_ = (pD3DCompile)GetProcAddress(d3dcompiler, "D3DCompile");
+        if( !D3DCompile_ )
+        {
+            fprintf(stderr, "error: failed load symbol 'D3DCompile'\n");
+            exit(1);
+        }
+    }
+
+    // For this example, we turn on debug output, and turn off all
+    // optimization. A real application would only use these flags
+    // when shader debugging is needed.
+    UINT flags = 0;
+    flags |= D3DCOMPILE_DEBUG;
+    flags |= D3DCOMPILE_OPTIMIZATION_LEVEL0 | D3DCOMPILE_SKIP_OPTIMIZATION;
+
+    // The `D3DCompile` entry point takes a bunch of parameters, but we
+    // don't really need most of them for Slang-generated code.
+    ID3DBlob* dxShaderBlob = nullptr;
+    ID3DBlob* dxErrorBlob = nullptr;
+    HRESULT hr = D3DCompile_(
+        source,
+        strlen(source),
+        "slangGeneratedCode", // TODO: proper path for error messages
+        nullptr,
+        nullptr,
+        entryPointName,
+        dxProfileName,
+        flags,
+        0,
+        &dxShaderBlob,
+        &dxErrorBlob);
+
+    // If the HLSL-to-bytecode compilation produced any diagnostic messages
+    // then we will print them out (whether or not the compilation failed).
+    if( dxErrorBlob )
+    {
+        OutputDebugStringA(
+            (char const*)dxErrorBlob->GetBufferPointer());
+        dxErrorBlob->Release();
+    }
+
+    if( FAILED(hr) )
+    {
+        return nullptr;
+    }
+
+    return dxShaderBlob;
+}
+
+
+//
+// We use a bare-minimum window procedure to get things up and running.
+//
+
+static LRESULT CALLBACK windowProc(
+    HWND    windowHandle,
+    UINT    message,
+    WPARAM  wParam,
+    LPARAM  lParam)
+{
+    switch (message)
+    {
+    case WM_CLOSE:
+        PostQuitMessage(0);
+        return 0;
+    }
+
+    return DefWindowProcW(windowHandle, message, wParam, lParam);
+}
+
+//
+// Our `WinMain` handles the basic task of getting a window and rendering
+// context up and running. There should be nothing suprising or interesting
+// here.
+//
+
+int WINAPI WinMain(
+    HINSTANCE instance,
+    HINSTANCE /* prevInstance */,
+    LPSTR     /* commandLine */,
+    int       showCommand)
+{
+    // First we register a window class.
+
+    WNDCLASSEXW windowClassDesc;
+    windowClassDesc.cbSize = sizeof(windowClassDesc);
+    windowClassDesc.style = CS_OWNDC | CS_HREDRAW | CS_VREDRAW;
+    windowClassDesc.lpfnWndProc = &windowProc;
+    windowClassDesc.cbClsExtra = 0;
+    windowClassDesc.cbWndExtra = 0;
+    windowClassDesc.hInstance = instance;
+    windowClassDesc.hIcon = 0;
+    windowClassDesc.hCursor = 0;
+    windowClassDesc.hbrBackground = 0;
+    windowClassDesc.lpszMenuName = 0;
+    windowClassDesc.lpszClassName = L"HelloWorld";
+    windowClassDesc.hIconSm = 0;
+    ATOM windowClassAtom = RegisterClassExW(&windowClassDesc);
+    if(!windowClassAtom)
+    {
+        fprintf(stderr, "error: failed to register window class\n");
+        return 1;
+    }
+
+    // Next, we create a window using that window class.
+
+    DWORD windowExtendedStyle = 0;
+    DWORD windowStyle = 0;
+    LPWSTR windowName = L"Slang Hello World";
+    HWND windowHandle = CreateWindowExW(
+        windowExtendedStyle,
+        (LPWSTR)windowClassAtom,
+        windowName,
+        windowStyle,
+        0, 0, // x, y
+        gWindowWidth, gWindowHeight,
+        NULL, // parent
+        NULL, // menu
+        instance,
+        NULL);
+    if(!windowHandle)
+    {
+        fprintf(stderr, "error: failed to create window\n");
+        return 1;
+    }
+
+
+    // Rather than statically link against D3D, we load it dynamically.
+
+    HMODULE d3d11 = LoadLibraryA("d3d11.dll");
+    if(!d3d11)
+    {
+        fprintf(stderr, "error: failed load 'd3d11.dll'\n");
+        return 1;
+    }
+
+    PFN_D3D11_CREATE_DEVICE_AND_SWAP_CHAIN D3D11CreateDeviceAndSwapChain_ =
+        (PFN_D3D11_CREATE_DEVICE_AND_SWAP_CHAIN)GetProcAddress(
+            d3d11,
+            "D3D11CreateDeviceAndSwapChain");
+    if(!D3D11CreateDeviceAndSwapChain_)
+    {
+        fprintf(stderr,
+            "error: failed load symbol 'D3D11CreateDeviceAndSwapChain'\n");
+        return 1;
+    }
+
+    // We create our device in debug mode, just so that we can check that the
+    // example doesn't trigger warnings.
+    UINT deviceFlags = 0;
+    deviceFlags |= D3D11_CREATE_DEVICE_DEBUG;
+
+    // We will ask for the highest feature level that can be supported.
+
+    D3D_FEATURE_LEVEL featureLevels[] = {
+        D3D_FEATURE_LEVEL_11_1,
+        D3D_FEATURE_LEVEL_11_0,
+        D3D_FEATURE_LEVEL_10_1,
+        D3D_FEATURE_LEVEL_10_0,
+        D3D_FEATURE_LEVEL_9_3,
+        D3D_FEATURE_LEVEL_9_2,
+        D3D_FEATURE_LEVEL_9_1,
+    };
+    D3D_FEATURE_LEVEL dxFeatureLevel = D3D_FEATURE_LEVEL_9_1;
+
+    // Our swap chain uses RGBA8 with sRGB, with double buffering.
+
+    DXGI_SWAP_CHAIN_DESC dxSwapChainDesc = { 0 };
+    dxSwapChainDesc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;
+    dxSwapChainDesc.BufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM_SRGB;
+    dxSwapChainDesc.SampleDesc.Count = 1;
+    dxSwapChainDesc.SampleDesc.Quality = 0;
+    dxSwapChainDesc.BufferCount = 2;
+    dxSwapChainDesc.OutputWindow = windowHandle;
+    dxSwapChainDesc.Windowed = TRUE;
+    dxSwapChainDesc.SwapEffect = DXGI_SWAP_EFFECT_DISCARD;
+    dxSwapChainDesc.Flags = 0;
+
+    // On a machine that does not have an up-to-date version of D3D installed,
+    // the `D3D11CreateDeviceAndSwapChain` call will fail with `E_INVALIDARG`
+    // if you ask for featuer level 11_1. The workaround is to call
+    // `D3D11CreateDeviceAndSwapChain` up to twice: the first time with 11_1
+    // at the start of the list of requested feature levels, and the second
+    // time without it.
+
+    IDXGISwapChain* dxSwapChain = NULL;
+    ID3D11Device* dxDevice = NULL;
+    ID3D11DeviceContext* dxImmediateContext = NULL;
+    HRESULT hr = S_OK;
+    for( int ii = 0; ii < 2; ++ii )
+    {
+        hr = D3D11CreateDeviceAndSwapChain_(
+            NULL,                    // adapter (use default)
+            D3D_DRIVER_TYPE_HARDWARE,
+            NULL,                    // software
+            deviceFlags,
+            &featureLevels[ii],
+            (sizeof(featureLevels) / sizeof(featureLevels[0])) - 1,
+            D3D11_SDK_VERSION,
+            &dxSwapChainDesc,
+            &dxSwapChain,
+            &dxDevice,
+            &dxFeatureLevel,
+            &dxImmediateContext);
+
+        // Failures with `E_INVALIDARG` might be due to feature level 11_1
+        // not being supported. Other failures are real, though.
+        if( hr != E_INVALIDARG )
+            break;
+    }
+    if( FAILED(hr) )
+    {
+        return 1;
+    }
+
+    // After we've created the swap chain, we can request a pointer to the
+    // back buffer as a D3D11 texture, and create a render-target view from it.
+
+    ID3D11Texture2D* dxBackBufferTexture = NULL;
+    static const IID kIID_ID3D11Texture2D = {
+        0x6f15aaf2, 0xd208, 0x4e89, 0x9a, 0xb4, 0x48,
+        0x95, 0x35, 0xd3, 0x4f, 0x9c };
+    dxSwapChain->GetBuffer(
+        0,
+        kIID_ID3D11Texture2D,
+        (void**)&dxBackBufferTexture);
+
+    ID3D11RenderTargetView* dxBackBufferRTV = NULL;
+    dxDevice->CreateRenderTargetView(
+        dxBackBufferTexture,
+        NULL,
+        &dxBackBufferRTV);
+
+    // We immediately bind the back-buffer render target view, and we aren't
+    // going to switch. We don't bother with a depth buffer.
+    dxImmediateContext->OMSetRenderTargets(
+        1,
+        &dxBackBufferRTV,
+        NULL);
+
+    // Similarly, we are going to set up a viewport once, and then never
+    // switch, since this is a simple test app.
+    D3D11_VIEWPORT dxViewport;
+    dxViewport.TopLeftX = 0;
+    dxViewport.TopLeftY = 0;
+    dxViewport.Width = (float) gWindowWidth;
+    dxViewport.Height = (float) gWindowHeight;
+    dxViewport.MaxDepth = 1; // TODO(tfoley): use reversed depth
+    dxViewport.MinDepth = 0;
+    dxImmediateContext->RSSetViewports(1, &dxViewport);
+
+    // Once we've done the general-purpose initialization, we
+    // initialize anything specific to the "hello world" application
+    hr = initialize( dxDevice );
+    if( FAILED(hr) )
+    {
+        exit(1);
+    }
+
+    // Once initialization is all complete, we show the window...
+    ShowWindow(windowHandle, showCommand);
+
+    // ... and enter the event loop:
+    for(;;)
+    {
+        MSG message;
+
+        int result = PeekMessageW(&message, NULL, 0, 0, PM_REMOVE);
+        if (result != 0)
+        {
+            if (message.message == WM_QUIT)
+            {
+                return (int)message.wParam;
+            }
+
+            TranslateMessage(&message);
+            DispatchMessageW(&message);
+        }
+        else
+        {
+            // Whenver we don't have Windows events to process,
+            // we render a frame.
+
+            static const float kClearColor[] = { 0.25, 0.25, 0.25, 1.0 };
+            dxImmediateContext->ClearRenderTargetView(
+                dxBackBufferRTV,
+                kClearColor);
+
+            renderFrame( dxImmediateContext );
+
+            dxSwapChain->Present(0, 0);
+        }
+    }
+
+    return 0;
+}
+
+
+//
+// In order to actually use Slang in our application, we need to link in its
+// implementation. The easiest way to accomplish this is by directly inlcuding
+// the (concatenated) Slang source code into our app.
+//
+
+#define SLANG_INCLUDE_IMPLEMENTATION
+#include <slang.h>
diff --git a/examples/hello/hello.slang b/examples/hello/hello.slang
new file mode 100644
index 000000000..d563aab88
--- /dev/null
+++ b/examples/hello/hello.slang
@@ -0,0 +1,73 @@
+// shaders.spire
+
+cbuffer Uniforms
+{
+	float4x4 modelViewProjection;
+}
+
+struct AssembledVertex
+{
+	float3	position;
+	float3	color;
+};
+
+struct CoarseVertex
+{
+	float3	color;
+};
+
+struct Fragment
+{
+	float4 color;
+};
+
+
+// Vertex  Shader
+
+struct VertexStageInput
+{
+	AssembledVertex assembledVertex	: A;
+};
+
+struct VertexStageOutput
+{
+	CoarseVertex	coarseVertex	: CoarseVertex;
+	float4			sv_position		: SV_Position;
+};
+
+VertexStageOutput vertexMain(VertexStageInput input)
+{
+	VertexStageOutput output;
+
+	float3 position = input.assembledVertex.position;
+	float3 color	= input.assembledVertex.color;
+
+	output.coarseVertex.color = color;
+	output.sv_position = mul(modelViewProjection, float4(position, 1.0));
+
+	return output;
+}
+
+// Fragment Shader
+
+struct FragmentStageInput
+{
+	CoarseVertex	coarseVertex	: CoarseVertex;
+};
+
+struct FragmentStageOutput
+{
+	Fragment fragment	: SV_Target;
+};
+
+FragmentStageOutput fragmentMain(FragmentStageInput input)
+{
+	FragmentStageOutput output;
+
+	float3 color = input.coarseVertex.color;
+
+	output.fragment.color = float4(color, 1.0);
+
+	return output;
+}
+
diff --git a/examples/hello/hello.sln b/examples/hello/hello.sln
new file mode 100644
index 000000000..3ddf262df
--- /dev/null
+++ b/examples/hello/hello.sln
@@ -0,0 +1,28 @@
+
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio 14
+VisualStudioVersion = 14.0.25420.1
+MinimumVisualStudioVersion = 10.0.40219.1
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "hello", "hello.vcxproj", "{E6385042-1649-4803-9EBD-168F8B7EF131}"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|x64 = Debug|x64
+		Debug|x86 = Debug|x86
+		Release|x64 = Release|x64
+		Release|x86 = Release|x86
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{E6385042-1649-4803-9EBD-168F8B7EF131}.Debug|x64.ActiveCfg = Debug|x64
+		{E6385042-1649-4803-9EBD-168F8B7EF131}.Debug|x64.Build.0 = Debug|x64
+		{E6385042-1649-4803-9EBD-168F8B7EF131}.Debug|x86.ActiveCfg = Debug|Win32
+		{E6385042-1649-4803-9EBD-168F8B7EF131}.Debug|x86.Build.0 = Debug|Win32
+		{E6385042-1649-4803-9EBD-168F8B7EF131}.Release|x64.ActiveCfg = Release|x64
+		{E6385042-1649-4803-9EBD-168F8B7EF131}.Release|x64.Build.0 = Release|x64
+		{E6385042-1649-4803-9EBD-168F8B7EF131}.Release|x86.ActiveCfg = Release|Win32
+		{E6385042-1649-4803-9EBD-168F8B7EF131}.Release|x86.Build.0 = Release|Win32
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+EndGlobal
diff --git a/examples/hello/hello.vcxproj b/examples/hello/hello.vcxproj
new file mode 100644
index 000000000..7060da5dc
--- /dev/null
+++ b/examples/hello/hello.vcxproj
@@ -0,0 +1,296 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="14.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Debug_VS2013|Win32">
+      <Configuration>Debug_VS2013</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug_VS2013|x64">
+      <Configuration>Debug_VS2013</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|Win32">
+      <Configuration>Debug</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release_VS2013|Win32">
+      <Configuration>Release_VS2013</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release_VS2013|x64">
+      <Configuration>Release_VS2013</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|Win32">
+      <Configuration>Release</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|x64">
+      <Configuration>Debug</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|x64">
+      <Configuration>Release</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{E6385042-1649-4803-9EBD-168F8B7EF131}</ProjectGuid>
+    <Keyword>Win32Proj</Keyword>
+    <RootNamespace>hello</RootNamespace>
+    <WindowsTargetPlatformVersion>8.1</WindowsTargetPlatformVersion>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <PlatformToolset>v140</PlatformToolset>
+    <CharacterSet>Unicode</CharacterSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug_VS2013|Win32'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <PlatformToolset>v140</PlatformToolset>
+    <CharacterSet>Unicode</CharacterSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <PlatformToolset>v140</PlatformToolset>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+    <CharacterSet>Unicode</CharacterSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release_VS2013|Win32'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <PlatformToolset>v140</PlatformToolset>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+    <CharacterSet>Unicode</CharacterSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <PlatformToolset>v140</PlatformToolset>
+    <CharacterSet>Unicode</CharacterSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug_VS2013|x64'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <PlatformToolset>v120</PlatformToolset>
+    <CharacterSet>Unicode</CharacterSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <PlatformToolset>v140</PlatformToolset>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+    <CharacterSet>Unicode</CharacterSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release_VS2013|x64'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <PlatformToolset>v120</PlatformToolset>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+    <CharacterSet>Unicode</CharacterSet>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <ImportGroup Label="ExtensionSettings">
+  </ImportGroup>
+  <ImportGroup Label="Shared">
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+    <Import Project="..\..\build\slang-build.props" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug_VS2013|Win32'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+    <Import Project="..\..\build\slang-build.props" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+    <Import Project="..\..\build\slang-build.props" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release_VS2013|Win32'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+    <Import Project="..\..\build\slang-build.props" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+    <Import Project="..\..\build\slang-build.props" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug_VS2013|x64'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+    <Import Project="..\..\build\slang-build.props" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+    <Import Project="..\..\build\slang-build.props" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release_VS2013|x64'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+    <Import Project="..\..\build\slang-build.props" />
+  </ImportGroup>
+  <PropertyGroup Label="UserMacros" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <LinkIncremental>true</LinkIncremental>
+    <IncludePath>$(SolutionDir);$(IncludePath)</IncludePath>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug_VS2013|Win32'">
+    <LinkIncremental>true</LinkIncremental>
+    <IncludePath>$(SolutionDir);$(IncludePath)</IncludePath>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <LinkIncremental>true</LinkIncremental>
+    <IncludePath>$(SolutionDir);$(IncludePath)</IncludePath>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug_VS2013|x64'">
+    <LinkIncremental>true</LinkIncremental>
+    <IncludePath>$(SolutionDir);$(IncludePath)</IncludePath>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <LinkIncremental>false</LinkIncremental>
+    <IncludePath>$(SolutionDir);$(IncludePath)</IncludePath>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release_VS2013|Win32'">
+    <LinkIncremental>false</LinkIncremental>
+    <IncludePath>$(SolutionDir);$(IncludePath)</IncludePath>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <LinkIncremental>false</LinkIncremental>
+    <IncludePath>$(SolutionDir);$(IncludePath)</IncludePath>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release_VS2013|x64'">
+    <LinkIncremental>false</LinkIncremental>
+    <IncludePath>$(SolutionDir);$(IncludePath)</IncludePath>
+  </PropertyGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <ClCompile>
+      <PrecompiledHeader>
+      </PrecompiledHeader>
+      <WarningLevel>Level3</WarningLevel>
+      <Optimization>Disabled</Optimization>
+      <PreprocessorDefinitions>WIN32;_DEBUG;_WINDOWS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+    </ClCompile>
+    <Link>
+      <SubSystem>Windows</SubSystem>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug_VS2013|Win32'">
+    <ClCompile>
+      <PrecompiledHeader>
+      </PrecompiledHeader>
+      <WarningLevel>Level3</WarningLevel>
+      <Optimization>Disabled</Optimization>
+      <PreprocessorDefinitions>WIN32;_DEBUG;_WINDOWS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+    </ClCompile>
+    <Link>
+      <SubSystem>Windows</SubSystem>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <ClCompile>
+      <PrecompiledHeader>
+      </PrecompiledHeader>
+      <WarningLevel>Level3</WarningLevel>
+      <Optimization>Disabled</Optimization>
+      <PreprocessorDefinitions>_DEBUG;_WINDOWS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+    </ClCompile>
+    <Link>
+      <SubSystem>Windows</SubSystem>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug_VS2013|x64'">
+    <ClCompile>
+      <PrecompiledHeader>
+      </PrecompiledHeader>
+      <WarningLevel>Level3</WarningLevel>
+      <Optimization>Disabled</Optimization>
+      <PreprocessorDefinitions>_DEBUG;_WINDOWS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
+    </ClCompile>
+    <Link>
+      <SubSystem>Windows</SubSystem>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <PrecompiledHeader>
+      </PrecompiledHeader>
+      <Optimization>MaxSpeed</Optimization>
+      <FunctionLevelLinking>true</FunctionLevelLinking>
+      <IntrinsicFunctions>true</IntrinsicFunctions>
+      <PreprocessorDefinitions>WIN32;NDEBUG;_WINDOWS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+    </ClCompile>
+    <Link>
+      <SubSystem>Windows</SubSystem>
+      <EnableCOMDATFolding>true</EnableCOMDATFolding>
+      <OptimizeReferences>true</OptimizeReferences>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release_VS2013|Win32'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <PrecompiledHeader>
+      </PrecompiledHeader>
+      <Optimization>MaxSpeed</Optimization>
+      <FunctionLevelLinking>true</FunctionLevelLinking>
+      <IntrinsicFunctions>true</IntrinsicFunctions>
+      <PreprocessorDefinitions>WIN32;NDEBUG;_WINDOWS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+    </ClCompile>
+    <Link>
+      <SubSystem>Windows</SubSystem>
+      <EnableCOMDATFolding>true</EnableCOMDATFolding>
+      <OptimizeReferences>true</OptimizeReferences>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <PrecompiledHeader>
+      </PrecompiledHeader>
+      <Optimization>MaxSpeed</Optimization>
+      <FunctionLevelLinking>true</FunctionLevelLinking>
+      <IntrinsicFunctions>true</IntrinsicFunctions>
+      <PreprocessorDefinitions>NDEBUG;_WINDOWS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+    </ClCompile>
+    <Link>
+      <SubSystem>Windows</SubSystem>
+      <EnableCOMDATFolding>true</EnableCOMDATFolding>
+      <OptimizeReferences>true</OptimizeReferences>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release_VS2013|x64'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <PrecompiledHeader>
+      </PrecompiledHeader>
+      <Optimization>MaxSpeed</Optimization>
+      <FunctionLevelLinking>true</FunctionLevelLinking>
+      <IntrinsicFunctions>true</IntrinsicFunctions>
+      <PreprocessorDefinitions>NDEBUG;_WINDOWS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+    </ClCompile>
+    <Link>
+      <SubSystem>Windows</SubSystem>
+      <EnableCOMDATFolding>true</EnableCOMDATFolding>
+      <OptimizeReferences>true</OptimizeReferences>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemGroup>
+    <ClCompile Include="hello.cpp" />
+  </ItemGroup>
+  <ItemGroup>
+    <None Include="hello.spire" />
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <ImportGroup Label="ExtensionTargets">
+  </ImportGroup>
+</Project>
\ No newline at end of file
diff --git a/examples/hello/hello.vcxproj.filters b/examples/hello/hello.vcxproj.filters
new file mode 100644
index 000000000..cedbc9831
--- /dev/null
+++ b/examples/hello/hello.vcxproj.filters
@@ -0,0 +1,9 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup>
+    <ClCompile Include="hello.cpp" />
+  </ItemGroup>
+  <ItemGroup>
+    <None Include="hello.slang" />
+  </ItemGroup>
+</Project>
\ No newline at end of file