Share graphics API layer between tests/examples (#603)

The `render-test` project has an in-progress graphics API abstraction layer, and it makes sense to share this code with our examples rather than write a bunch of redundant code between examples and tests.

Most of this change is just moving files from `tools/render-test/*` to a new library project at `tools/slang-graphics/`. The most complicated code change there is renaming from `render_test` to `slang_graphics`.

The existing `hello` example was ported to use the graphics API layer instead of raw D3D11 API calls. It is still hard-coded to use the D3D11 back-end and the `SLANG_DXBC` target, so more work is needed if we want to actually support multiple APIs in the examples.

I also went ahead and implemented an extremely rudimentary set of APIs to abstract over the Windows platform calls that were being made in the example, so that we could potentially run that same example on other platforms. I did *not* port `render-test` to use those APIs, and I also did not implement them for anything but Windows (my assumption is that for most other platforms we would just use SDL2, and require people to ensure it is installed to their machine before building Slang examples).

4 files changed, 334 insertions, 516 deletions

diff --git a/examples/hello/README.md b/examples/hello/README.md
index a571bb274..31a983428 100644
--- a/examples/hello/README.md
+++ b/examples/hello/README.md
@@ -1,9 +1,12 @@
 Slang "Hello World" Example
 ===========================
 
-The goal of this example is to demonstrate an almost minimal application that uses Slang for shading, and D3D11 for rendering.
+The goal of this example is to demonstrate an almost minimal application that uses Slang for shading.
+
+The `hello.slang` file contains simple vertex and fragment shader entry points. The shader code should compile as either Slang or HLSL code (that is, this example does not show off any new Slang language features).
 
-The `hello.slang` file contains simple vertex and fragment shader entry points.
 The `hello.cpp` file contains the C++ application code, showing how to use the Slang C API to load and compile the shader code to DirectX shader bytecode (DXBC).
+The application perform rendering using the D3D11 API, through a platform and graphics API abstraction layer that is implemented in `tools/slang-graphics`.
+Note that this abstraction layer is *not* required in order to work with Slang, and it is just there to help us write example applications more conveniently.
 
-Note that this example is not intended to demonstrate good practices for integrating Slang into a production engine; the goal is merely to use the minimum amount of code possible to demonstrate a complete applicaiton that uses Slang.
+This example is not necessarily representative of best practices for integrating Slang into a production engine; the goal is merely to use the minimum amount of code possible to demonstrate a complete applicaiton that uses Slang.
diff --git a/examples/hello/hello.cpp b/examples/hello/hello.cpp
index aef6b90d1..a5d90a3f4 100644
--- a/examples/hello/hello.cpp
+++ b/examples/hello/hello.cpp
@@ -1,43 +1,192 @@
 // hello.cpp
 
-// In order to use the Slang API, we need to include its header
-
+// This file implements an extremely simple example of loading and
+// executing a Slang shader program.
+//
+// The comments in the file will attempt to explain concepts as
+// they are introduced.
+//
+// Of course, in order to use the Slang API, we need to include
+// its header. We have set up the build options for this project
+// so that it is as simple as:
+//
 #include <slang.h>
+//
+// Other build setups are possible, and Slang doesn't assume that
+// its include directory must be added to your global include
+// path.
+
+// For the purposes of keeping the demo code as simple as possible,
+// while still retaining some level of portability, our examples
+// make use of a small platform and graphics API abstraction layer,
+// which is included in the Slang source distribution under the
+// `tools/` directory.
+//
+// Applications can of course use Slang without ever touching this
+// abstraction layer, so we will not focus on it when explaining
+// examples, except in places where best practices for interacting
+// with Slang may depend on an application/engine making certain
+// design choices in their abstraction layer.
+//
+#include "slang-graphics/render.h"
+#include "slang-graphics/render-d3d11.h"
+#include "slang-graphics/window.h"
+using namespace slang_graphics;
+
+// We will start with a function that will invoke the Slang compiler
+// to generate target-specific code from a shader file, and then
+// use that to initialize an API shader program.
+//
+// Note that `Renderer` and `ShaderProgram` here are types from
+// the graphics API abstraction layer, and *not* part of the
+// Slang API. This function is representative of code that a user
+// might write to integrate Slang into their renderer/engine.
+//
+ShaderProgram* loadShaderProgram(Renderer* renderer)
+{
+    // First, we need to create a "session" for interacting with the Slang
+    // compiler. This scopes all of our application's interactions
+    // with the Slang library. At the moment, creating a session causes
+    // Slang to load and validate its standard library, so this is a
+    // somewhat heavy-weight operation. When possible, an application
+    // should try to re-use the same session across multiple compiles.
+    SlangSession* slangSession = spCreateSession(NULL);
 
-// We will be rendering with Direct3D 11, so we need to include
-// the Windows and D3D11 headers
+    // A compile request represents a single invocation of the compiler,
+    // to process some inputs and produce outputs (or errors).
+    SlangCompileRequest* slangRequest = spCreateCompileRequest(slangSession);
 
-#define WIN32_LEAN_AND_MEAN
-#define NOMINMAX
-#include <Windows.h>
-#undef WIN32_LEAN_AND_MEAN
-#undef NOMINMAX
+    // We would like to request a single target (output) format: DirectX shader bytecode (DXBC)
+    int targetIndex = spAddCodeGenTarget(slangRequest, SLANG_DXBC);
 
-#include <d3d11_2.h>
-#include <d3dcompiler.h>
+    // We will specify the desired "profile" for this one target in terms of the
+    // DirectX "shader model" that should be supported.
+    spSetTargetProfile(slangRequest, targetIndex, spFindProfile(slangSession, "sm_4_0"));
 
-// We will use the C standard library just for printing error messages.
-#include <stdio.h>
+    // A compile request can include one or more "translation units," which more or
+    // less amount to individual source files (think `.c` files, not the `.h` files they
+    // might include).
+    //
+    // For this example, our code will all be in the Slang language. The user may
+    // also specify HLSL input here, but that currently doesn't affect the compiler's
+    // behavior much.
+    int translationUnitIndex = spAddTranslationUnit(slangRequest, SLANG_SOURCE_LANGUAGE_SLANG, nullptr);
 
-#ifdef _MSC_VER
-#include <stddef.h>
-#if (_MSC_VER < 1900)
-#define snprintf sprintf_s
-#endif
-#endif
-//
+    // We will load source code for our translation unit from the file `hello.slang`.
+    // There are also variations of this API for adding source code from application-provided buffers.
+    spAddTranslationUnitSourceFile(slangRequest, translationUnitIndex, "hello.slang");
 
-static int gWindowWidth = 1024;
-static int gWindowHeight = 768;
+    // Next we will specify the entry points we'd like to compile.
+    // It is often convenient to put more than one entry point in the same file,
+    // and the Slang API makes it convenient to use a single run of the compiler
+    // to compile all entry points.
+    //
+    // For each entry point, we need to specify the name of a function, the
+    // translation unit in which that function can be found, and the stage
+    // that we need to compile for (e.g., vertex, fragment, geometry, ...).
+    //
+    char const* vertexEntryPointName    = "vertexMain";
+    char const* fragmentEntryPointName  = "fragmentMain";
+    int vertexIndex   = spAddEntryPoint(slangRequest, translationUnitIndex, vertexEntryPointName,   SLANG_STAGE_VERTEX);
+    int fragmentIndex = spAddEntryPoint(slangRequest, translationUnitIndex, fragmentEntryPointName, SLANG_STAGE_FRAGMENT);
+
+    // Once all of the input options for hte compiler have been specified,
+    // we can invoke `spCompile` to run the compiler and see if any errors
+    // were detected.
+    //
+    int compileErr = spCompile(slangRequest);
+
+    // Even if there were no errors that forced compilation to fail, the
+    // compiler may have produced "diagnostic" output such as warnings.
+    // We will go ahead and print that output here.
+    //
+    if(auto diagnostics = spGetDiagnosticOutput(slangRequest))
+    {
+        reportError("%s", diagnostics);
+    }
+
+    // If compilation failed, there is no point in continuing any further.
+    if(compileErr)
+    {
+        spDestroyCompileRequest(slangRequest);
+        spDestroySession(slangSession);
+        return nullptr;
+    }
+
+    // If compilation was successful, then we will extract the code for
+    // our two entry points as "blobs".
+    //
+    // If you are using a D3D API, then your application may want to
+    // take advantage of the fact taht these blobs are binary compatible
+    // with the `ID3DBlob`, `ID3D10Blob`, etc. interfaces.
+
+    ISlangBlob* vertexShaderBlob = nullptr;
+    spGetEntryPointCodeBlob(slangRequest, vertexIndex, 0, &vertexShaderBlob);
+
+    ISlangBlob* fragmentShaderBlob = nullptr;
+    spGetEntryPointCodeBlob(slangRequest, fragmentIndex, 0, &fragmentShaderBlob);
+
+    // We extract the begin/end pointers to the output code buffers
+    // using operations on the `ISlangBlob` interface.
+    char const* vertexCode = (char const*) vertexShaderBlob->getBufferPointer();
+    char const* vertexCodeEnd = vertexCode + vertexShaderBlob->getBufferSize();
 
+    char const* fragmentCode = (char const*) fragmentShaderBlob->getBufferPointer();
+    char const* fragmentCodeEnd = fragmentCode + fragmentShaderBlob->getBufferSize();
+
+    // Once we have extract the output blobs, it is safe to destroy
+    // the compile request and even the session.
+    //
+    spDestroyCompileRequest(slangRequest);
+    spDestroySession(slangSession);
+
+    // Now we use the operations of the example graphics API abstraction
+    // layer to load shader code into the underlying API.
+    //
+    // Reminder: this section does not involve the Slang API at all.
+    //
+
+    ShaderProgram::KernelDesc kernelDescs[] =
+    {
+        { StageType::Vertex,    vertexCode,     vertexCodeEnd},
+        { StageType::Fragment,  fragmentCode,   fragmentCodeEnd},
+    };
+
+    ShaderProgram::Desc programDesc;
+    programDesc.pipelineType = PipelineType::Graphics;
+    programDesc.kernels = &kernelDescs[0];
+    programDesc.kernelCount = 2;
+
+    ShaderProgram* shaderProgram = renderer->createProgram(programDesc);
+
+    // Once we've used the output blobs from the Slang compiler to initialize
+    // the API-specific shader program, we can release their memory.
+    //
+    vertexShaderBlob->release();
+    fragmentShaderBlob->release();
+
+    return shaderProgram;
+}
+
+//
+// The above function shows the core of what is required to use the
+// Slang API as a simple compiler (e.g., a drop-in replacement for
+// fxc or dxc).
+//
+// The rest of this file implements an extremely simple rendering application
+// that will execute the vertex/fragment shaders loaded with the function
+// we have just defined.
 //
 
+// We will hard-code the size of our rendering window.
 //
+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];
@@ -45,534 +194,191 @@ struct Vertex
 };
 
 static const int kVertexCount = 3;
-static const Vertex kVertexData[kVertexCount] = {
+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} },
 };
 
+// We will define global variables for the various platform and
+// graphics API objects that our application needs:
 //
-
-// 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.
+// As a reminder, *none* of these are Slang API objects. All
+// of them come from the utility library we are using to simplify
+// building an example program.
 //
-HRESULT initialize( ID3D11Device* dxDevice )
+ApplicationContext* gAppContext;
+Window* gWindow;
+Renderer* gRenderer;
+BufferResource* gConstantBuffer;
+InputLayout* gInputLayout;
+BufferResource* gVertexBuffer;
+ShaderProgram* gShaderProgram;
+BindingState* gBindingState;
+
+enum
+{
+    OKAY,
+    FAILURE,
+};
+
+int initialize()
 {
-#if 1
+    // Create a window for our application to render into.
+    WindowDesc windowDesc;
+    windowDesc.title = "Hello, World!";
+    windowDesc.width = gWindowWidth;
+    windowDesc.height = gWindowHeight;
+    gWindow = createWindow(windowDesc);
+
+    // Initialize the rendering layer.
     //
-    // First, we will load and compile our Slang source code.
+    // Note: for now we are hard-coding logic to use the
+    // Direct3D11 back-end for the graphics API abstraction.
+    // A future version of this example may support multiple
+    // platforms/APIs.
     //
+    gRenderer = createD3D11Renderer();
+    Renderer::Desc rendererDesc;
+    rendererDesc.width = gWindowWidth;
+    rendererDesc.height = gWindowHeight;
+    gRenderer->initialize(rendererDesc, getPlatformWindowHandle(gWindow));
 
-    // 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";
-
-    int vertexIndex = spAddEntryPoint(slangRequest, translationUnitIndex, vertexEntryPointName,   spFindProfile(slangSession, vertexProfileName));
-    int fragmentIndex = spAddEntryPoint(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* vertexCode = spGetEntryPointSource(slangRequest, vertexIndex);
-    char const* fragmentCode = spGetEntryPointSource(slangRequest, fragmentIndex);
-
-    // TODO(tfoley): Query the required constant-buffer size
+    // Create a constant buffer for passing the model-view-projection matrix.
+    //
+    // TODO: A future version of this example will show how to
+    // use the Slang reflection API to query the required size
+    // for the data in this constant buffer.
+    //
     int constantBufferSize = 16 * sizeof(float);
 
-    // Compile the generated HLSL code
-    ID3DBlob* dxVertexShaderBlob = compileHLSLShader(vertexCode, vertexEntryPointName, vertexProfileName);
-    if(!dxVertexShaderBlob) return E_FAIL;
+    BufferResource::Desc constantBufferDesc;
+    constantBufferDesc.init(constantBufferSize);
+    constantBufferDesc.setDefaults(Resource::Usage::ConstantBuffer);
+    constantBufferDesc.cpuAccessFlags = Resource::AccessFlag::Write;
 
-    ID3DBlob* dxPixelShaderBlob = compileHLSLShader(fragmentCode, fragmentEntryPointName, fragmentProfileName);
-    if(!dxPixelShaderBlob) return E_FAIL;
+    gConstantBuffer = gRenderer->createBufferResource(
+        Resource::Usage::ConstantBuffer,
+        constantBufferDesc);
+    if(!gConstantBuffer) return FAILURE;
 
-    HRESULT hr = S_OK;
+    // Input Assembler (IA)
 
+    // Input Layout
 
-    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;
+    InputElementDesc inputElements[] = {
+        {"POSITION", 0, Format::RGB_Float32, offsetof(Vertex, position) },
+        {"COLOR",    0, Format::RGB_Float32, offsetof(Vertex, color) },
+    };
+    gInputLayout = gRenderer->createInputLayout(
+        &inputElements[0],
+        2);
+    if(!gInputLayout) return FAILURE;
 
-    hr = dxDevice->CreateBuffer(
-        &dxConstantBufferDesc,
-        NULL,
-        &dxConstantBuffer);
-    if(FAILED(hr)) return hr;
+    // Vertex Buffer
 
-    // 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);
+    BufferResource::Desc vertexBufferDesc;
+    vertexBufferDesc.init(kVertexCount * sizeof(Vertex));
+    vertexBufferDesc.setDefaults(Resource::Usage::VertexBuffer);
 
-    // Input Assembler (IA)
+    gVertexBuffer = gRenderer->createBufferResource(
+        Resource::Usage::VertexBuffer,
+        vertexBufferDesc,
+        &kVertexData[0]);
+    if(!gVertexBuffer) return FAILURE;
 
-    // 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;
+    // Shaders (VS, PS, ...)
 
-    // Vertex Shader (VS)
+    gShaderProgram = loadShaderProgram(gRenderer);
+    if(!gShaderProgram) return FAILURE;
 
-    hr = dxDevice->CreateVertexShader(
-        dxVertexShaderBlob->GetBufferPointer(),
-        dxVertexShaderBlob->GetBufferSize(),
-        NULL,
-        &dxVertexShader);
-    dxVertexShaderBlob->Release();
-    if(FAILED(hr)) return hr;
+    // Resource binding state
 
-    // Pixel Shader (PS)
+    BindingState::Desc bindingStateDesc;
+    bindingStateDesc.addBufferResource(gConstantBuffer, BindingState::RegisterRange::makeSingle(0));
+    gBindingState = gRenderer->createBindingState(bindingStateDesc);
+
+    // Once we've initialized all the graphics API objects,
+    // it is time to show our application window and start rendering.
 
-    hr = dxDevice->CreatePixelShader(
-        dxPixelShaderBlob->GetBufferPointer(),
-        dxPixelShaderBlob->GetBufferSize(),
-        NULL,
-        &dxPixelShader);
-    dxPixelShaderBlob->Release();
-    if(FAILED(hr)) return hr;
-#endif
+    showWindow(gWindow);
 
-    return S_OK;
+    return OKAY;
 }
 
-void renderFrame(ID3D11DeviceContext* dxContext)
+void renderFrame()
 {
+    // Clear our framebuffer (color target only)
+    //
+    static const float kClearColor[] = { 0.25, 0.25, 0.25, 1.0 };
+    gRenderer->setClearColor(kClearColor);
+    gRenderer->clearFrame();
+
+
     // 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))
+    //
+    if(float* data = (float*) gRenderer->map(gConstantBuffer, MapFlavor::WriteDiscard))
     {
-        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 };
+            0, 1, 0, 0,
+            0, 0, 1, 0,
+            0, 0, 0, 1 };
         memcpy(data, kIdentity, sizeof(kIdentity));
 
-        dxContext->Unmap(dxConstantBuffer, 0);
+        gRenderer->unmap(gConstantBuffer);
     }
 
     // Input Assembler (IA)
 
-    dxContext->IASetInputLayout(dxInputLayout);
-    dxContext->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
+    gRenderer->setInputLayout(gInputLayout);
+    gRenderer->setPrimitiveTopology(PrimitiveTopology::TriangleList);
 
-    UINT dxVertexStride = sizeof(Vertex);
-    UINT dxVertexBufferOffset = 0;
-    dxContext->IASetVertexBuffers(0, 1, &dxVertexBuffer, &dxVertexStride, &dxVertexBufferOffset);
+    UInt vertexStride = sizeof(Vertex);
+    UInt vertexBufferOffset = 0;
+    gRenderer->setVertexBuffers(0, 1, &gVertexBuffer, &vertexStride, &vertexBufferOffset);
 
     // 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);
+    gRenderer->setShaderProgram(gShaderProgram);
+    gRenderer->setBindingState(gBindingState);
 
     //
 
-    dxContext->Draw(3, 0);
+    gRenderer->draw(3);
+
+    gRenderer->presentFrame();
 }
 
 void finalize()
 {
+    // TODO: Proper cleanup.
 }
 
+// This "inner" main function is used by the platform abstraction
+// layer to deal with differences in how an entry point needs
+// to be defined for different platforms.
 //
-// Definition of the HLSL-to-bytecode compilation logic.
-//
-ID3DBlob* compileHLSLShader(
-    char const* source,
-    char const* entryPointName,
-    char const* dxProfileName )
+void innerMain(ApplicationContext* context)
 {
-    // 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) )
+    if(initialize() != OKAY)
     {
-        return nullptr;
+        exitApplication(context, 1);
     }
 
-    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)
+    while(dispatchEvents(context))
     {
-    case WM_CLOSE:
-        PostQuitMessage(0);
-        return 0;
+        renderFrame();
     }
 
-    return DefWindowProcW(windowHandle, message, wParam, lParam);
+    finalize();
 }
 
+// This macro instantiates an appropriate main function to
+// invoke the `innerMain` above.
 //
-// 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;
-}
+SG_UI_MAIN(innerMain)
diff --git a/examples/hello/hello.slang b/examples/hello/hello.slang
index f495d12b4..5a68979ce 100644
--- a/examples/hello/hello.slang
+++ b/examples/hello/hello.slang
@@ -1,24 +1,28 @@
 // hello.slang
 
+// This file provides a simple vertex and fragment shader that can be compiled
+// using Slang. This code should also be valid as HLSL, and thus it does not
+// use any of the new language features supported by Slang.
+
 cbuffer Uniforms
 {
-	float4x4 modelViewProjection;
+    float4x4 modelViewProjection;
 }
 
 struct AssembledVertex
 {
-	float3	position;
-	float3	color;
+    float3	position : POSITION;
+    float3	color    : COLOR;
 };
 
 struct CoarseVertex
 {
-	float3	color;
+    float3 color;
 };
 
 struct Fragment
 {
-	float4 color;
+    float4 color;
 };
 
 
@@ -26,48 +30,47 @@ struct Fragment
 
 struct VertexStageInput
 {
-	AssembledVertex assembledVertex	: A;
+    AssembledVertex assembledVertex;
 };
 
 struct VertexStageOutput
 {
-	CoarseVertex	coarseVertex	: CoarseVertex;
-	float4			sv_position		: SV_Position;
+    CoarseVertex    coarseVertex    : CoarseVertex;
+    float4          sv_position     : SV_Position;
 };
 
 VertexStageOutput vertexMain(VertexStageInput input)
 {
-	VertexStageOutput output;
+    VertexStageOutput output;
 
-	float3 position = input.assembledVertex.position;
-	float3 color	= input.assembledVertex.color;
+    float3 position = input.assembledVertex.position;
+    float3 color    = input.assembledVertex.color;
 
-	output.coarseVertex.color = color;
-	output.sv_position = mul(modelViewProjection, float4(position, 1.0));
+    output.coarseVertex.color = color;
+    output.sv_position = mul(modelViewProjection, float4(position, 1.0));
 
-	return output;
+    return output;
 }
 
 // Fragment Shader
 
 struct FragmentStageInput
 {
-	CoarseVertex	coarseVertex	: CoarseVertex;
+    CoarseVertex    coarseVertex    : CoarseVertex;
 };
 
 struct FragmentStageOutput
 {
-	Fragment fragment	: SV_Target;
+    Fragment fragment   : SV_Target;
 };
 
 FragmentStageOutput fragmentMain(FragmentStageInput input)
 {
-	FragmentStageOutput output;
+    FragmentStageOutput output;
 
-	float3 color = input.coarseVertex.color;
+    float3 color = input.coarseVertex.color;
 
-	output.fragment.color = float4(color, 1.0);
+    output.fragment.color = float4(color, 1.0);
 
-	return output;
+    return output;
 }
-
diff --git a/examples/hello/hello.vcxproj b/examples/hello/hello.vcxproj
index 72bedbd72..885c2ff86 100644
--- a/examples/hello/hello.vcxproj
+++ b/examples/hello/hello.vcxproj
@@ -98,7 +98,7 @@
       <PrecompiledHeader>NotUsing</PrecompiledHeader>
       <WarningLevel>Level3</WarningLevel>
       <PreprocessorDefinitions>_DEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <AdditionalIncludeDirectories>..\..;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <AdditionalIncludeDirectories>..\..;..\..\tools;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
       <DebugInformationFormat>EditAndContinue</DebugInformationFormat>
       <Optimization>Disabled</Optimization>
       <RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
@@ -113,7 +113,7 @@
       <PrecompiledHeader>NotUsing</PrecompiledHeader>
       <WarningLevel>Level3</WarningLevel>
       <PreprocessorDefinitions>_DEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <AdditionalIncludeDirectories>..\..;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <AdditionalIncludeDirectories>..\..;..\..\tools;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
       <DebugInformationFormat>EditAndContinue</DebugInformationFormat>
       <Optimization>Disabled</Optimization>
       <RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
@@ -128,7 +128,7 @@
       <PrecompiledHeader>NotUsing</PrecompiledHeader>
       <WarningLevel>Level3</WarningLevel>
       <PreprocessorDefinitions>NDEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <AdditionalIncludeDirectories>..\..;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <AdditionalIncludeDirectories>..\..;..\..\tools;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
       <Optimization>Full</Optimization>
       <FunctionLevelLinking>true</FunctionLevelLinking>
       <IntrinsicFunctions>true</IntrinsicFunctions>
@@ -147,7 +147,7 @@
       <PrecompiledHeader>NotUsing</PrecompiledHeader>
       <WarningLevel>Level3</WarningLevel>
       <PreprocessorDefinitions>NDEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <AdditionalIncludeDirectories>..\..;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <AdditionalIncludeDirectories>..\..;..\..\tools;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
       <Optimization>Full</Optimization>
       <FunctionLevelLinking>true</FunctionLevelLinking>
       <IntrinsicFunctions>true</IntrinsicFunctions>
@@ -171,6 +171,12 @@
     <ProjectReference Include="..\..\source\slang\slang.vcxproj">
       <Project>{DB00DA62-0533-4AFD-B59F-A67D5B3A0808}</Project>
     </ProjectReference>
+    <ProjectReference Include="..\..\source\core\core.vcxproj">
+      <Project>{F9BE7957-8399-899E-0C49-E714FDDD4B65}</Project>
+    </ProjectReference>
+    <ProjectReference Include="..\..\tools\slang-graphics\slang-graphics.vcxproj">
+      <Project>{222F7498-B40C-4F3F-A704-DDEB91A4484A}</Project>
+    </ProjectReference>
   </ItemGroup>
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
   <ImportGroup Label="ExtensionTargets">