Merge pull request #2 from KhronosGroup/master

Update to head fork.

8 files changed, 185 insertions, 95 deletions

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 4e11532e..01097fdb 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -14,6 +14,7 @@ include(FindPkgConfig)
 
 if (CMAKE_COMPILER_IS_GNUCC)
     set(COMMON_COMPILE_FLAGS "-Wall -Wextra -Wno-sign-compare -Wno-unused-parameter -Wno-missing-field-initializers")
+    set(COMMON_COMPILE_FLAGS "${COMMON_COMPILE_FLAGS} -fno-strict-aliasing -fno-builtin-memcmp")
     set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -std=c99 ${COMMON_COMPILE_FLAGS}")
     set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${COMMON_COMPILE_FLAGS}")
     if (UNIX)
@@ -45,7 +46,5 @@ if (NOT WIN32)
     add_subdirectory(tests)
 endif()
     add_subdirectory(layers)
-if (NOT WIN32)
     add_subdirectory(demos)
-endif()
     add_subdirectory(tools/glave)
diff --git a/demos/CMakeLists.txt b/demos/CMakeLists.txt
index 98c611d4..da3d892d 100644
--- a/demos/CMakeLists.txt
+++ b/demos/CMakeLists.txt
@@ -1,10 +1,14 @@
-find_package(XCB REQUIRED)
-
-if(NOT EXISTS /usr/include/glm/glm.hpp)
-    message(FATAL_ERROR "Necessary libglm-dev headers cannot be found: sudo apt-get install libglm-dev")
+if(NOT WIN32)
+    find_package(XCB REQUIRED)
 endif()
-if(NOT EXISTS /usr/include/png.h)
-    message(FATAL_ERROR "Necessary png12-dev headers cannot be found: sudo apt-get install libpng12-dev")
+
+if(NOT WIN32)
+    if(NOT EXISTS /usr/include/glm/glm.hpp)
+        message(FATAL_ERROR "Necessary libglm-dev headers cannot be found: sudo apt-get install libglm-dev")
+    endif()
+    if(NOT EXISTS /usr/include/png.h)
+        message(FATAL_ERROR "Necessary png12-dev headers cannot be found: sudo apt-get install libpng12-dev")
+    endif()
 endif()
 
 file(GLOB TEXTURES
@@ -14,29 +18,42 @@ file(COPY ${TEXTURES} DESTINATION ${CMAKE_BINARY_DIR}/demos)
 
 set (CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -DXGL_PROTOTYPES")
 
-add_custom_command(OUTPUT ${CMAKE_BINARY_DIR}/demos/cube-vert.bil
-   COMMAND ${GLSLANG_PREFIX}/build/install/bin/glslangValidator -s -b ${PROJECT_SOURCE_DIR}/demos/cube.vert 
-   COMMAND mv vert.bil ${CMAKE_BINARY_DIR}/demos/cube-vert.bil
-   DEPENDS cube.vert ${GLSLANG_PREFIX}/build/install/bin/glslangValidator
-   )
+if(NOT WIN32)
+    add_custom_command(OUTPUT ${CMAKE_BINARY_DIR}/demos/cube-vert.bil
+       COMMAND ${GLSLANG_PREFIX}/build/install/bin/glslangValidator -s -b ${PROJECT_SOURCE_DIR}/demos/cube.vert 
+       COMMAND mv vert.bil ${CMAKE_BINARY_DIR}/demos/cube-vert.bil
+       DEPENDS cube.vert ${GLSLANG_PREFIX}/build/install/bin/glslangValidator
+       )
+
+    add_custom_command(OUTPUT ${CMAKE_BINARY_DIR}/demos/cube-frag.bil
+       COMMAND ${GLSLANG_PREFIX}/build/install/bin/glslangValidator -s -b ${PROJECT_SOURCE_DIR}/demos/cube.frag 
+       COMMAND mv frag.bil ${CMAKE_BINARY_DIR}/demos/cube-frag.bil
+       DEPENDS cube.frag ${GLSLANG_PREFIX}/build/install/bin/glslangValidator
+       )
+endif()
 
-add_custom_command(OUTPUT ${CMAKE_BINARY_DIR}/demos/cube-frag.bil
-   COMMAND ${GLSLANG_PREFIX}/build/install/bin/glslangValidator -s -b ${PROJECT_SOURCE_DIR}/demos/cube.frag 
-   COMMAND mv frag.bil ${CMAKE_BINARY_DIR}/demos/cube-frag.bil
-   DEPENDS cube.frag ${GLSLANG_PREFIX}/build/install/bin/glslangValidator
-   )
+if(NOT WIN32)
+    include_directories (
+       ${XCB_INCLUDE_DIRS}
+       "${PROJECT_SOURCE_DIR}/icd/common"
+       )
 
-include_directories (
-   ${XCB_INCLUDE_DIRS}
-   "${PROJECT_SOURCE_DIR}/icd/common"
-   )
+    link_libraries(${XCB_LIBRARIES} XGL png m)
+endif()
+if(WIN32)
+    include_directories (
+       "${PROJECT_SOURCE_DIR}/icd/common"
+       )
 
-link_libraries(${XCB_LIBRARIES} XGL png m)
+    link_libraries(XGL)
+endif()
 
 add_executable(xglinfo xglinfo.c)
 
 add_executable(tri tri.c)
 target_link_libraries(tri)
 
-add_executable(cube cube.c ${CMAKE_BINARY_DIR}/demos/cube-vert.bil ${CMAKE_BINARY_DIR}/demos/cube-frag.bil)
-target_link_libraries(cube)
+if(NOT WIN32)
+    add_executable(cube cube.c ${CMAKE_BINARY_DIR}/demos/cube-vert.bil ${CMAKE_BINARY_DIR}/demos/cube-frag.bil)
+    target_link_libraries(cube)
+endif()
diff --git a/demos/cube.c b/demos/cube.c
index fdd300c4..00951b5a 100644
--- a/demos/cube.c
+++ b/demos/cube.c
@@ -714,7 +714,8 @@ static void demo_prepare_textures(struct demo *demo)
             .borderColorType = XGL_BORDER_COLOR_OPAQUE_WHITE,
         };
 
-        assert(loadTexture(tex_files[i], NULL, NULL, &tex_width, &tex_height));
+        err = loadTexture(tex_files[i], NULL, NULL, &tex_width, &tex_height);
+        assert(err);
 
         const XGL_IMAGE_CREATE_INFO image = {
             .sType = XGL_STRUCTURE_TYPE_IMAGE_CREATE_INFO,
diff --git a/demos/tri.c b/demos/tri.c
index 5a770f4c..ee2fe341 100644
--- a/demos/tri.c
+++ b/demos/tri.c
@@ -10,10 +10,14 @@
 #include <stdbool.h>
 #include <assert.h>
 
+#if defined(__linux__)
 #include <xcb/xcb.h>
+#endif
 #include <xgl.h>
 #include <xglDbg.h>
+#if defined(__linux__)
 #include <xglWsiX11Ext.h>
+#endif
 
 #include "icd-bil.h"
 
@@ -21,8 +25,10 @@
 #define DEMO_TEXTURE_COUNT 1
 
 struct demo {
+#if defined(__linux__)
     xcb_connection_t *connection;
     xcb_screen_t *screen;
+#endif
 
     XGL_INSTANCE inst;
     XGL_PHYSICAL_GPU gpu;
@@ -81,8 +87,10 @@ struct demo {
     XGL_DESCRIPTOR_REGION desc_region;
     XGL_DESCRIPTOR_SET desc_set;
 
+#if defined(__linux__)
     xcb_window_t window;
     xcb_intern_atom_reply_t *atom_wm_delete_window;
+#endif
 
     bool quit;
     uint32_t current_buffer;
@@ -90,10 +98,12 @@ struct demo {
 
 static void demo_draw_build_cmd(struct demo *demo)
 {
+#if defined(__linux__)
     const XGL_COLOR_ATTACHMENT_BIND_INFO color_attachment = {
         .view = demo->buffers[demo->current_buffer].view,
         .layout = XGL_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
     };
+#endif
     const XGL_DEPTH_STENCIL_BIND_INFO depth_stencil = {
         .view = demo->depth.view,
         .layout = XGL_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL,
@@ -118,7 +128,9 @@ static void demo_draw_build_cmd(struct demo *demo)
          .sType = XGL_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO,
          .pNext = NULL,
          .colorAttachmentCount = 1,
+#if defined(__linux__)
          .pColorAttachments = (XGL_COLOR_ATTACHMENT_BIND_INFO*) &color_attachment,
+#endif
          .pDepthStencilAttachment = (XGL_DEPTH_STENCIL_BIND_INFO*) &depth_stencil,
          .sampleCount = 1,
          .width  = demo->width,
@@ -181,10 +193,12 @@ static void demo_draw_build_cmd(struct demo *demo)
 
 static void demo_draw(struct demo *demo)
 {
+#if defined(__linux__)
     const XGL_WSI_X11_PRESENT_INFO present = {
         .destWindow = demo->window,
         .srcImage = demo->buffers[demo->current_buffer].image,
     };
+#endif
     XGL_FENCE fence = demo->buffers[demo->current_buffer].fence;
     XGL_RESULT err;
 
@@ -217,14 +231,17 @@ static void demo_draw(struct demo *demo)
             idx, memRefs, XGL_NULL_HANDLE);
     assert(!err);
 
+#if defined(__linux__)
     err = xglWsiX11QueuePresent(demo->queue, &present, fence);
     assert(!err);
+#endif
 
     demo->current_buffer = (demo->current_buffer + 1) % DEMO_BUFFER_COUNT;
 }
 
 static void demo_prepare_buffers(struct demo *demo)
 {
+#if defined(__linux__)
     const XGL_WSI_X11_PRESENTABLE_IMAGE_CREATE_INFO presentable_image = {
         .format = demo->format,
         .usage = XGL_IMAGE_USAGE_COLOR_ATTACHMENT_BIT,
@@ -234,6 +251,7 @@ static void demo_prepare_buffers(struct demo *demo)
         },
         .flags = 0,
     };
+#endif
     const XGL_FENCE_CREATE_INFO fence = {
         .sType = XGL_STRUCTURE_TYPE_FENCE_CREATE_INFO,
         .pNext = NULL,
@@ -252,9 +270,14 @@ static void demo_prepare_buffers(struct demo *demo)
             .arraySize = 1,
         };
 
+#if defined(__linux__)
         err = xglWsiX11CreatePresentableImage(demo->device, &presentable_image,
                 &demo->buffers[i].image, &demo->buffers[i].mem);
         assert(!err);
+#else
+        demo->buffers[i].image = NULL;
+        demo->buffers[i].mem = NULL;
+#endif
 
         color_attachment_view.image = demo->buffers[i].image;
 
@@ -915,9 +938,14 @@ static void demo_prepare(struct demo *demo)
     demo_prepare_descriptor_set(demo);
 }
 
+#if defined(__linux__)
 static void demo_handle_event(struct demo *demo,
                               const xcb_generic_event_t *event)
+#else
+static void demo_handle_event(struct demo *demo)
+#endif
 {
+#if defined(__linux__)
     switch (event->response_type & 0x7f) {
     case XCB_EXPOSE:
         demo_draw(demo);
@@ -943,10 +971,15 @@ static void demo_handle_event(struct demo *demo,
     default:
         break;
     }
+#else
+    // Since we don't yet support events, we'll just do a draw
+    demo_draw(demo);
+#endif
 }
 
 static void demo_run(struct demo *demo)
 {
+#if defined(__linux__)
     xcb_flush(demo->connection);
 
     while (!demo->quit) {
@@ -958,10 +991,16 @@ static void demo_run(struct demo *demo)
             free(event);
         }
     }
+#else
+    // Since we don't yet support events, just call demo_handle_event to do a draw
+    demo_handle_event(demo);
+
+#endif
 }
 
 static void demo_create_window(struct demo *demo)
 {
+#if defined(__linux__)
     uint32_t value_mask, value_list[32];
 
     demo->window = xcb_generate_id(demo->connection);
@@ -994,6 +1033,7 @@ static void demo_create_window(struct demo *demo)
     free(reply);
 
     xcb_map_window(demo->connection, demo->window);
+#endif
 }
 
 static void demo_init_xgl(struct demo *demo)
@@ -1007,17 +1047,23 @@ static void demo_init_xgl(struct demo *demo)
         .engineVersion = 0,
         .apiVersion = XGL_MAKE_VERSION(0, 22, 0),
     };
+#if defined(__linux__)
     const XGL_WSI_X11_CONNECTION_INFO connection = {
         .pConnection = demo->connection,
         .root = demo->screen->root,
         .provider = 0,
     };
+#endif
     const XGL_DEVICE_QUEUE_CREATE_INFO queue = {
         .queueNodeIndex = 0,
         .queueCount = 1,
     };
     const char *ext_names[] = {
+#if defined(__linux__)
         "XGL_WSI_X11",
+#else
+        "XGL_WSI_WINDOWS",
+#endif
     };
     const XGL_DEVICE_CREATE_INFO device = {
         .sType = XGL_STRUCTURE_TYPE_DEVICE_CREATE_INFO,
@@ -1043,8 +1089,10 @@ static void demo_init_xgl(struct demo *demo)
         assert(!err);
     }
 
+#if defined(__linux__)
     err = xglWsiX11AssociateConnection(demo->gpu, &connection);
     assert(!err);
+#endif
 
     err = xglCreateDevice(demo->gpu, &device, &demo->device);
     assert(!err);
@@ -1056,6 +1104,7 @@ static void demo_init_xgl(struct demo *demo)
 
 static void demo_init_connection(struct demo *demo)
 {
+#if defined(__linux__)
     const xcb_setup_t *setup;
     xcb_screen_iterator_t iter;
     int scr;
@@ -1068,6 +1117,7 @@ static void demo_init_connection(struct demo *demo)
         xcb_screen_next(&iter);
 
     demo->screen = iter.data;
+#endif
 }
 
 static void demo_init(struct demo *demo)
@@ -1122,14 +1172,18 @@ static void demo_cleanup(struct demo *demo)
     for (i = 0; i < DEMO_BUFFER_COUNT; i++) {
         xglDestroyObject(demo->buffers[i].fence);
         xglDestroyObject(demo->buffers[i].view);
+#if defined(__linux__)
         xglDestroyObject(demo->buffers[i].image);
+#endif
     }
 
     xglDestroyDevice(demo->device);
     xglDestroyInstance(demo->inst);
 
+#if defined(__linux__)
     xcb_destroy_window(demo->connection, demo->window);
     xcb_disconnect(demo->connection);
+#endif
 }
 
 int main(void)
@@ -1144,5 +1198,9 @@ int main(void)
 
     demo_cleanup(&demo);
 
+#if defined(__linux__)
+#else
+    printf("try exitting...\n"); fflush(stdout);
+#endif
     return 0;
 }
diff --git a/include/xgl.h b/include/xgl.h
index 335904ee..968ab232 100644
--- a/include/xgl.h
+++ b/include/xgl.h
@@ -208,7 +208,7 @@ typedef enum _XGL_ATTACHMENT_LOAD_OP
     XGL_ATTACHMENT_LOAD_OP_LOAD                             = 0x00000000,
     XGL_ATTACHMENT_LOAD_OP_CLEAR                            = 0x00000001,
     XGL_ATTACHMENT_LOAD_OP_DONT_CARE                        = 0x00000002,
-
+    
     XGL_ATTACHMENT_LOAD_OP_BEGIN_RANGE                      = XGL_ATTACHMENT_LOAD_OP_LOAD,
     XGL_ATTACHMENT_LOAD_OP_END_RANGE                        = XGL_ATTACHMENT_LOAD_OP_DONT_CARE,
     XGL_NUM_ATTACHMENT_LOAD_OP                              = (XGL_ATTACHMENT_LOAD_OP_END_RANGE - XGL_ATTACHMENT_LOAD_OP_BEGIN_RANGE + 1),
@@ -220,7 +220,7 @@ typedef enum _XGL_ATTACHMENT_STORE_OP
     XGL_ATTACHMENT_STORE_OP_STORE                           = 0x00000000,
     XGL_ATTACHMENT_STORE_OP_RESOLVE_MSAA                    = 0x00000001,
     XGL_ATTACHMENT_STORE_OP_DONT_CARE                       = 0x00000002,
-
+    
     XGL_ATTACHMENT_STORE_OP_BEGIN_RANGE                     = XGL_ATTACHMENT_STORE_OP_STORE,
     XGL_ATTACHMENT_STORE_OP_END_RANGE                       = XGL_ATTACHMENT_STORE_OP_DONT_CARE,
     XGL_NUM_ATTACHMENT_STORE_OP                             = (XGL_ATTACHMENT_STORE_OP_END_RANGE - XGL_ATTACHMENT_STORE_OP_BEGIN_RANGE + 1),
@@ -995,14 +995,14 @@ typedef enum _XGL_PIPELINE_SHADER_STAGE
 
 typedef enum _XGL_SHADER_STAGE_FLAGS
 {
-    XGL_SHADER_STAGE_FLAGS_VERTEX_BIT                       = 0x00000001,
-    XGL_SHADER_STAGE_FLAGS_TESS_CONTROL_BIT                 = 0x00000002,
-    XGL_SHADER_STAGE_FLAGS_TESS_EVALUATION_BIT              = 0x00000004,
-    XGL_SHADER_STAGE_FLAGS_GEOMETRY_BIT                     = 0x00000008,
-    XGL_SHADER_STAGE_FLAGS_FRAGMENT_BIT                     = 0x00000010,
-    XGL_SHADER_STAGE_FLAGS_COMPUTE_BIT                      = 0x00000020,
+    XGL_SHADER_STAGE_FLAGS_VERTEX_BIT                        = 0x00000001,
+    XGL_SHADER_STAGE_FLAGS_TESS_CONTROL_BIT                  = 0x00000002,
+    XGL_SHADER_STAGE_FLAGS_TESS_EVALUATION_BIT               = 0x00000004,
+    XGL_SHADER_STAGE_FLAGS_GEOMETRY_BIT                      = 0x00000008,
+    XGL_SHADER_STAGE_FLAGS_FRAGMENT_BIT                      = 0x00000010,
+    XGL_SHADER_STAGE_FLAGS_COMPUTE_BIT                       = 0x00000020,
 
-    XGL_SHADER_STAGE_FLAGS_ALL                              = 0x7FFFFFFF,
+    XGL_SHADER_STAGE_FLAGS_ALL                               = 0x7FFFFFFF,
     XGL_MAX_ENUM(_XGL_SHADER_STAGE_FLAGS)
 } XGL_SHADER_STAGE_FLAGS;
 
@@ -1193,12 +1193,12 @@ typedef enum _XGL_IMAGE_USAGE_FLAGS
     XGL_IMAGE_USAGE_SHADER_ACCESS_READ_BIT                  = 0x00000001,   // shader read (e.g. texture, image)
     XGL_IMAGE_USAGE_SHADER_ACCESS_WRITE_BIT                 = 0x00000002,   // shader write (e.g. image)
     XGL_IMAGE_USAGE_SHADER_ACCESS_ATOMIC_BIT                = 0x00000004,   // shader atomic operations (e.g. image)
-    XGL_IMAGE_USAGE_TRANSFER_SOURCE_BIT                     = 0x00000008,   // used as a source for copies
+    XGL_IMAGE_USAGE_TRANSFER_SOURCE_BIT                     = 0x00000008,   // used as a source for copies 
     XGL_IMAGE_USAGE_TRANSFER_DESTINATION_BIT                = 0x00000010,   // used as a destination for copies
     XGL_IMAGE_USAGE_TEXTURE_BIT                             = 0x00000020,   // opaque texture (2d, 3d, etc.)
     XGL_IMAGE_USAGE_IMAGE_BIT                               = 0x00000040,   // opaque image (2d, 3d, etc.)
     XGL_IMAGE_USAGE_COLOR_ATTACHMENT_BIT                    = 0x00000080,   // framebuffer color attachment
-    XGL_IMAGE_USAGE_DEPTH_STENCIL_BIT                       = 0x00000100,   // framebuffer depth/stencil
+    XGL_IMAGE_USAGE_DEPTH_STENCIL_BIT                       = 0x00000100,   // framebuffer depth/stencil 
     XGL_MAX_ENUM(_XGL_IMAGE_USAGE_FLAGS)
 } XGL_IMAGE_USAGE_FLAGS;
 
@@ -1530,8 +1530,8 @@ typedef struct _XGL_IMAGE_VIEW_ATTACH_INFO
 
 typedef struct _XGL_UPDATE_SAMPLERS
 {
-    XGL_STRUCTURE_TYPE                      sType;
-    const void*                             pNext;
+    XGL_STRUCTURE_TYPE                      sType;                      // Must be XGL_STRUCTURE_TYPE_UPDATE_SAMPLERS
+    const void*                             pNext;                      // Pointer to next structure
     uint32_t                                index;
     uint32_t                                count;
     const XGL_SAMPLER*                      pSamplers;
@@ -1545,8 +1545,8 @@ typedef struct _XGL_SAMPLER_IMAGE_VIEW_INFO
 
 typedef struct _XGL_UPDATE_SAMPLER_TEXTURES
 {
-    XGL_STRUCTURE_TYPE                       sType;
-    const void*                              pNext;
+    XGL_STRUCTURE_TYPE                       sType;                     // Must be XGL_STRUCTURE_TYPE_UPDATE_SAMPLER_TEXTURES
+    const void*                              pNext;                     // Pointer to next structure
     uint32_t                                 index;
     uint32_t                                 count;
     const XGL_SAMPLER_IMAGE_VIEW_INFO*       pSamplerImageViews;
@@ -1554,8 +1554,8 @@ typedef struct _XGL_UPDATE_SAMPLER_TEXTURES
 
 typedef struct _XGL_UPDATE_IMAGES
 {
-    XGL_STRUCTURE_TYPE                       sType;
-    const void*                              pNext;
+    XGL_STRUCTURE_TYPE                       sType;                     // Must be XGL_STRUCTURE_TYPE_UPDATE_IMAGES
+    const void*                              pNext;                     // Pointer to next structure
     XGL_DESCRIPTOR_TYPE                      descriptorType;
     uint32_t                                 index;
     uint32_t                                 count;
@@ -1564,8 +1564,8 @@ typedef struct _XGL_UPDATE_IMAGES
 
 typedef struct _XGL_UPDATE_BUFFERS
 {
-    XGL_STRUCTURE_TYPE                        sType;
-    const void*                               pNext;
+    XGL_STRUCTURE_TYPE                        sType;                    // Must be XGL_STRUCTURE_TYPE_UPDATE_BUFFERS
+    const void*                               pNext;                    // Pointer to next structure
     XGL_DESCRIPTOR_TYPE                       descriptorType;
     uint32_t                                  index;
     uint32_t                                  count;
@@ -1574,8 +1574,8 @@ typedef struct _XGL_UPDATE_BUFFERS
 
 typedef struct _XGL_UPDATE_AS_COPY
 {
-    XGL_STRUCTURE_TYPE                      sType;
-    const void*                             pNext;
+    XGL_STRUCTURE_TYPE                      sType;                      // Must be XGL_STRUCTURE_TYPE_UPDATE_AS_COPY
+    const void*                             pNext;                      // Pointer to next structure
     XGL_DESCRIPTOR_TYPE                     descriptorType;
     XGL_DESCRIPTOR_SET                      descriptorSet;
     uint32_t                                descriptorIndex;
@@ -1816,8 +1816,8 @@ typedef struct _XGL_SHADER_CREATE_INFO
 
 typedef struct _XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO
 {
-    XGL_STRUCTURE_TYPE                      sType;
-    const void*                             pNext;
+    XGL_STRUCTURE_TYPE                      sType;              // Must be XGL_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO
+    const void*                             pNext;              // Pointer to next structure
     XGL_DESCRIPTOR_TYPE                     descriptorType;
     uint32_t                                count;
     XGL_FLAGS                               stageFlags;         // XGL_SHADER_STAGE_FLAGS
@@ -1832,8 +1832,8 @@ typedef struct _XGL_DESCRIPTOR_TYPE_COUNT
 
 typedef struct _XGL_DESCRIPTOR_REGION_CREATE_INFO
 {
-    XGL_STRUCTURE_TYPE                      sType;
-    const void*                             pNext;
+    XGL_STRUCTURE_TYPE                      sType;              // Must be XGL_STRUCTURE_TYPE_DESCRIPTOR_REGION_CREATE_INFO
+    const void*                             pNext;              // Pointer to next structure
     uint32_t                                count;
     const XGL_DESCRIPTOR_TYPE_COUNT*        pTypeCount;
 } XGL_DESCRIPTOR_REGION_CREATE_INFO;
@@ -2228,7 +2228,7 @@ typedef XGL_RESULT (XGLAPI *xglCreateInstanceType)(const XGL_APPLICATION_INFO* p
 typedef XGL_RESULT (XGLAPI *xglDestroyInstanceType)(XGL_INSTANCE instance);
 typedef XGL_RESULT (XGLAPI *xglEnumerateGpusType)(XGL_INSTANCE instance, uint32_t maxGpus, uint32_t* pGpuCount, XGL_PHYSICAL_GPU* pGpus);
 typedef XGL_RESULT (XGLAPI *xglGetGpuInfoType)(XGL_PHYSICAL_GPU gpu, XGL_PHYSICAL_GPU_INFO_TYPE infoType, size_t* pDataSize, void* pData);
-typedef void * (XGLAPI *xglGetProcAddrType)(XGL_PHYSICAL_GPU gpu, const char * pName);
+typedef void *     (XGLAPI *xglGetProcAddrType)(XGL_PHYSICAL_GPU gpu, const char * pName);
 typedef XGL_RESULT (XGLAPI *xglCreateDeviceType)(XGL_PHYSICAL_GPU gpu, const XGL_DEVICE_CREATE_INFO* pCreateInfo, XGL_DEVICE* pDevice);
 typedef XGL_RESULT (XGLAPI *xglDestroyDeviceType)(XGL_DEVICE device);
 typedef XGL_RESULT (XGLAPI *xglGetExtensionSupportType)(XGL_PHYSICAL_GPU gpu, const char* pExtName);
@@ -2252,7 +2252,7 @@ typedef XGL_RESULT (XGLAPI *xglOpenPeerImageType)(XGL_DEVICE device, const XGL_P
 typedef XGL_RESULT (XGLAPI *xglDestroyObjectType)(XGL_OBJECT object);
 typedef XGL_RESULT (XGLAPI *xglGetObjectInfoType)(XGL_BASE_OBJECT object, XGL_OBJECT_INFO_TYPE infoType, size_t* pDataSize, void* pData);
 typedef XGL_RESULT (XGLAPI *xglBindObjectMemoryType)(XGL_OBJECT object, uint32_t allocationIdx, XGL_GPU_MEMORY mem, XGL_GPU_SIZE offset);
-typedef XGL_RESULT (XGLAPI *xglBindObjectMemoryRangeType)(XGL_OBJECT object, uint32_t allocationIdx, XGL_GPU_SIZE rangeOffset, XGL_GPU_SIZE rangeSize, XGL_GPU_MEMORY mem, XGL_GPU_SIZE memOffset);
+typedef XGL_RESULT (XGLAPI *xglBindObjectMemoryRangeType)(XGL_OBJECT object, uint32_t allocationIdx, XGL_GPU_SIZE rangeOffset,XGL_GPU_SIZE rangeSize, XGL_GPU_MEMORY mem, XGL_GPU_SIZE memOffset);
 typedef XGL_RESULT (XGLAPI *xglBindImageMemoryRangeType)(XGL_IMAGE image, uint32_t allocationIdx, const XGL_IMAGE_MEMORY_BIND_INFO* bindInfo, XGL_GPU_MEMORY mem, XGL_GPU_SIZE memOffset);
 typedef XGL_RESULT (XGLAPI *xglCreateFenceType)(XGL_DEVICE device, const XGL_FENCE_CREATE_INFO* pCreateInfo, XGL_FENCE* pFence);
 typedef XGL_RESULT (XGLAPI *xglGetFenceStatusType)(XGL_FENCE fence);
@@ -2289,8 +2289,8 @@ typedef XGL_RESULT (XGLAPI *xglEndDescriptorRegionUpdateType)(XGL_DEVICE device,
 typedef XGL_RESULT (XGLAPI *xglCreateDescriptorRegionType)(XGL_DEVICE device, XGL_DESCRIPTOR_REGION_USAGE regionUsage, uint32_t maxSets, const XGL_DESCRIPTOR_REGION_CREATE_INFO* pCreateInfo, XGL_DESCRIPTOR_REGION* pDescriptorRegion);
 typedef XGL_RESULT (XGLAPI *xglClearDescriptorRegionType)(XGL_DESCRIPTOR_REGION descriptorRegion);
 typedef XGL_RESULT (XGLAPI *xglAllocDescriptorSetsType)(XGL_DESCRIPTOR_REGION descriptorRegion, XGL_DESCRIPTOR_SET_USAGE setUsage, uint32_t count, const XGL_DESCRIPTOR_SET_LAYOUT* pSetLayouts, XGL_DESCRIPTOR_SET* pDescriptorSets, uint32_t* pCount);
-typedef void (XGLAPI *xglClearDescriptorSetsType)(XGL_DESCRIPTOR_REGION descriptorRegion, uint32_t count, const XGL_DESCRIPTOR_SET* pDescriptorSets);
-typedef void (XGLAPI *xglUpdateDescriptorsType)(XGL_DESCRIPTOR_SET descriptorSet, const void* pUpdateChain);
+typedef void       (XGLAPI *xglClearDescriptorSetsType)(XGL_DESCRIPTOR_REGION descriptorRegion, uint32_t count, const XGL_DESCRIPTOR_SET* pDescriptorSets);
+typedef void       (XGLAPI *xglUpdateDescriptorsType)(XGL_DESCRIPTOR_SET descriptorSet, const void* pUpdateChain);
 typedef XGL_RESULT (XGLAPI *xglCreateDynamicViewportStateType)(XGL_DEVICE device, const XGL_DYNAMIC_VP_STATE_CREATE_INFO* pCreateInfo, XGL_DYNAMIC_VP_STATE_OBJECT* pState);
 typedef XGL_RESULT (XGLAPI *xglCreateDynamicRasterStateType)(XGL_DEVICE device, const XGL_DYNAMIC_RS_STATE_CREATE_INFO* pCreateInfo, XGL_DYNAMIC_RS_STATE_OBJECT* pState);
 typedef XGL_RESULT (XGLAPI *xglCreateDynamicColorBlendStateType)(XGL_DEVICE device, const XGL_DYNAMIC_CB_STATE_CREATE_INFO* pCreateInfo, XGL_DYNAMIC_CB_STATE_OBJECT* pState);
@@ -2299,40 +2299,40 @@ typedef XGL_RESULT (XGLAPI *xglCreateCommandBufferType)(XGL_DEVICE device, const
 typedef XGL_RESULT (XGLAPI *xglBeginCommandBufferType)(XGL_CMD_BUFFER cmdBuffer, const XGL_CMD_BUFFER_BEGIN_INFO* pBeginInfo);
 typedef XGL_RESULT (XGLAPI *xglEndCommandBufferType)(XGL_CMD_BUFFER cmdBuffer);
 typedef XGL_RESULT (XGLAPI *xglResetCommandBufferType)(XGL_CMD_BUFFER cmdBuffer);
-typedef void (XGLAPI *xglCmdBindPipelineType)(XGL_CMD_BUFFER cmdBuffer, XGL_PIPELINE_BIND_POINT pipelineBindPoint, XGL_PIPELINE pipeline);
-typedef void (XGLAPI *xglCmdBindPipelineDeltaType)(XGL_CMD_BUFFER cmdBuffer, XGL_PIPELINE_BIND_POINT pipelineBindPoint, XGL_PIPELINE_DELTA delta);
-typedef void (XGLAPI *xglCmdBindDynamicStateObjectType)(XGL_CMD_BUFFER cmdBuffer, XGL_STATE_BIND_POINT stateBindPoint, XGL_DYNAMIC_STATE_OBJECT state);
-typedef void (XGLAPI *xglCmdBindDescriptorSetType)(XGL_CMD_BUFFER cmdBuffer, XGL_PIPELINE_BIND_POINT pipelineBindPoint, XGL_DESCRIPTOR_SET descriptorSet, const uint32_t* pUserData);
-typedef void (XGLAPI *xglCmdBindVertexBufferType)(XGL_CMD_BUFFER cmdBuffer, XGL_BUFFER buffer, XGL_GPU_SIZE offset, uint32_t binding);
-typedef void (XGLAPI *xglCmdBindIndexBufferType)(XGL_CMD_BUFFER cmdBuffer, XGL_BUFFER buffer, XGL_GPU_SIZE offset, XGL_INDEX_TYPE indexType);
-typedef void (XGLAPI *xglCmdDrawType)(XGL_CMD_BUFFER cmdBuffer, uint32_t firstVertex, uint32_t vertexCount, uint32_t firstInstance, uint32_t instanceCount);
-typedef void (XGLAPI *xglCmdDrawIndexedType)(XGL_CMD_BUFFER cmdBuffer, uint32_t firstIndex, uint32_t indexCount, int32_t vertexOffset, uint32_t firstInstance, uint32_t instanceCount);
-typedef void (XGLAPI *xglCmdDrawIndirectType)(XGL_CMD_BUFFER cmdBuffer, XGL_BUFFER buffer, XGL_GPU_SIZE offset, uint32_t count, uint32_t stride);
-typedef void (XGLAPI *xglCmdDrawIndexedIndirectType)(XGL_CMD_BUFFER cmdBuffer, XGL_BUFFER buffer, XGL_GPU_SIZE offset, uint32_t count, uint32_t stride);
-typedef void (XGLAPI *xglCmdDispatchType)(XGL_CMD_BUFFER cmdBuffer, uint32_t x, uint32_t y, uint32_t z);
-typedef void (XGLAPI *xglCmdDispatchIndirectType)(XGL_CMD_BUFFER cmdBuffer, XGL_BUFFER buffer, XGL_GPU_SIZE offset);
-typedef void (XGLAPI *xglCmdCopyBufferType)(XGL_CMD_BUFFER cmdBuffer, XGL_BUFFER srcBuffer, XGL_BUFFER destBuffer, uint32_t regionCount, const XGL_BUFFER_COPY* pRegions);
-typedef void (XGLAPI *xglCmdCopyImageType)(XGL_CMD_BUFFER cmdBuffer, XGL_IMAGE srcImage, XGL_IMAGE destImage, uint32_t regionCount, const XGL_IMAGE_COPY* pRegions);
-typedef void (XGLAPI *xglCmdCopyBufferToImageType)(XGL_CMD_BUFFER cmdBuffer, XGL_BUFFER srcBuffer, XGL_IMAGE destImage, uint32_t regionCount, const XGL_BUFFER_IMAGE_COPY* pRegions);
-typedef void (XGLAPI *xglCmdCopyImageToBufferType)(XGL_CMD_BUFFER cmdBuffer, XGL_IMAGE srcImage, XGL_BUFFER destBuffer, uint32_t regionCount, const XGL_BUFFER_IMAGE_COPY* pRegions);
-typedef void (XGLAPI *xglCmdCloneImageDataType)(XGL_CMD_BUFFER cmdBuffer, XGL_IMAGE srcImage, XGL_IMAGE_LAYOUT srcImageLayout, XGL_IMAGE destImage, XGL_IMAGE_LAYOUT destImageLayout);
-typedef void (XGLAPI *xglCmdUpdateBufferType)(XGL_CMD_BUFFER cmdBuffer, XGL_BUFFER destBuffer, XGL_GPU_SIZE destOffset, XGL_GPU_SIZE dataSize, const uint32_t* pData);
-typedef void (XGLAPI *xglCmdFillBufferType)(XGL_CMD_BUFFER cmdBuffer, XGL_BUFFER destBuffer, XGL_GPU_SIZE destOffset, XGL_GPU_SIZE fillSize, uint32_t data);
-typedef void (XGLAPI *xglCmdClearColorImageType)(XGL_CMD_BUFFER cmdBuffer, XGL_IMAGE image, const float color[4], uint32_t rangeCount, const XGL_IMAGE_SUBRESOURCE_RANGE* pRanges);
-typedef void (XGLAPI *xglCmdClearColorImageRawType)(XGL_CMD_BUFFER cmdBuffer, XGL_IMAGE image, const uint32_t color[4], uint32_t rangeCount, const XGL_IMAGE_SUBRESOURCE_RANGE* pRanges);
-typedef void (XGLAPI *xglCmdClearDepthStencilType)(XGL_CMD_BUFFER cmdBuffer, XGL_IMAGE image, float depth, uint32_t stencil, uint32_t rangeCount, const XGL_IMAGE_SUBRESOURCE_RANGE* pRanges);
-typedef void (XGLAPI *xglCmdResolveImageType)(XGL_CMD_BUFFER cmdBuffer, XGL_IMAGE srcImage, XGL_IMAGE destImage, uint32_t rectCount, const XGL_IMAGE_RESOLVE* pRects);
-typedef void (XGLAPI *xglCmdSetEventType)(XGL_CMD_BUFFER cmdBuffer, XGL_EVENT event, XGL_SET_EVENT pipeEvent);
-typedef void (XGLAPI *xglCmdResetEventType)(XGL_CMD_BUFFER cmdBuffer, XGL_EVENT event);
-typedef void (XGLAPI *xglCmdWaitEventsType)(XGL_CMD_BUFFER cmdBuffer, const XGL_EVENT_WAIT_INFO* pWaitInfo);
-typedef void (XGLAPI *xglCmdPipelineBarrierType)(XGL_CMD_BUFFER cmdBuffer, const XGL_PIPELINE_BARRIER* pBarrier);
-typedef void (XGLAPI *xglCmdBeginQueryType)(XGL_CMD_BUFFER cmdBuffer, XGL_QUERY_POOL queryPool, uint32_t slot, XGL_FLAGS flags);
-typedef void (XGLAPI *xglCmdEndQueryType)(XGL_CMD_BUFFER cmdBuffer, XGL_QUERY_POOL queryPool, uint32_t slot);
-typedef void (XGLAPI *xglCmdResetQueryPoolType)(XGL_CMD_BUFFER cmdBuffer, XGL_QUERY_POOL queryPool, uint32_t startQuery, uint32_t queryCount);
-typedef void (XGLAPI *xglCmdWriteTimestampType)(XGL_CMD_BUFFER cmdBuffer, XGL_TIMESTAMP_TYPE timestampType, XGL_BUFFER destBuffer, XGL_GPU_SIZE destOffset);
-typedef void (XGLAPI *xglCmdInitAtomicCountersType)(XGL_CMD_BUFFER cmdBuffer, XGL_PIPELINE_BIND_POINT pipelineBindPoint, uint32_t startCounter, uint32_t counterCount, const uint32_t* pData);
-typedef void (XGLAPI *xglCmdLoadAtomicCountersType)(XGL_CMD_BUFFER cmdBuffer, XGL_PIPELINE_BIND_POINT pipelineBindPoint, uint32_t startCounter, uint32_t counterCount, XGL_BUFFER srcBuffer, XGL_GPU_SIZE srcOffset);
-typedef void (XGLAPI *xglCmdSaveAtomicCountersType)(XGL_CMD_BUFFER cmdBuffer, XGL_PIPELINE_BIND_POINT pipelineBindPoint, uint32_t startCounter, uint32_t counterCount, XGL_BUFFER destBuffer, XGL_GPU_SIZE destOffset);
+typedef void       (XGLAPI *xglCmdBindPipelineType)(XGL_CMD_BUFFER cmdBuffer, XGL_PIPELINE_BIND_POINT pipelineBindPoint, XGL_PIPELINE pipeline);
+typedef void       (XGLAPI *xglCmdBindPipelineDeltaType)(XGL_CMD_BUFFER cmdBuffer, XGL_PIPELINE_BIND_POINT pipelineBindPoint, XGL_PIPELINE_DELTA delta);
+typedef void       (XGLAPI *xglCmdBindDynamicStateObjectType)(XGL_CMD_BUFFER cmdBuffer, XGL_STATE_BIND_POINT stateBindPoint, XGL_DYNAMIC_STATE_OBJECT state);
+typedef void       (XGLAPI *xglCmdBindDescriptorSetType)(XGL_CMD_BUFFER cmdBuffer, XGL_PIPELINE_BIND_POINT pipelineBindPoint, XGL_DESCRIPTOR_SET descriptorSet, const uint32_t* pUserData);
+typedef void       (XGLAPI *xglCmdBindIndexBufferType)(XGL_CMD_BUFFER cmdBuffer, XGL_BUFFER buffer, XGL_GPU_SIZE offset, XGL_INDEX_TYPE indexType);
+typedef void       (XGLAPI *xglCmdBindVertexBufferType)(XGL_CMD_BUFFER cmdBuffer, XGL_BUFFER buffer, XGL_GPU_SIZE offset, uint32_t binding);
+typedef void       (XGLAPI *xglCmdDrawType)(XGL_CMD_BUFFER cmdBuffer, uint32_t firstVertex, uint32_t vertexCount, uint32_t firstInstance, uint32_t instanceCount);
+typedef void       (XGLAPI *xglCmdDrawIndexedType)(XGL_CMD_BUFFER cmdBuffer, uint32_t firstIndex, uint32_t indexCount, int32_t vertexOffset, uint32_t firstInstance, uint32_t instanceCount);
+typedef void       (XGLAPI *xglCmdDrawIndirectType)(XGL_CMD_BUFFER cmdBuffer, XGL_BUFFER buffer, XGL_GPU_SIZE offset, uint32_t count, uint32_t stride);
+typedef void       (XGLAPI *xglCmdDrawIndexedIndirectType)(XGL_CMD_BUFFER cmdBuffer, XGL_BUFFER buffer, XGL_GPU_SIZE offset, uint32_t count, uint32_t stride);
+typedef void       (XGLAPI *xglCmdDispatchType)(XGL_CMD_BUFFER cmdBuffer, uint32_t x, uint32_t y, uint32_t z);
+typedef void       (XGLAPI *xglCmdDispatchIndirectType)(XGL_CMD_BUFFER cmdBuffer, XGL_BUFFER buffer, XGL_GPU_SIZE offset);
+typedef void       (XGLAPI *xglCmdCopyBufferType)(XGL_CMD_BUFFER cmdBuffer, XGL_BUFFER srcBuffer, XGL_BUFFER destBuffer, uint32_t regionCount, const XGL_BUFFER_COPY* pRegions);
+typedef void       (XGLAPI *xglCmdCopyImageType)(XGL_CMD_BUFFER cmdBuffer, XGL_IMAGE srcImage, XGL_IMAGE destImage, uint32_t regionCount, const XGL_IMAGE_COPY* pRegions);
+typedef void       (XGLAPI *xglCmdCopyBufferToImageType)(XGL_CMD_BUFFER cmdBuffer, XGL_BUFFER srcBuffer, XGL_IMAGE destImage, uint32_t regionCount, const XGL_BUFFER_IMAGE_COPY* pRegions);
+typedef void       (XGLAPI *xglCmdCopyImageToBufferType)(XGL_CMD_BUFFER cmdBuffer, XGL_IMAGE srcImage, XGL_BUFFER destBuffer, uint32_t regionCount, const XGL_BUFFER_IMAGE_COPY* pRegions);
+typedef void       (XGLAPI *xglCmdCloneImageDataType)(XGL_CMD_BUFFER cmdBuffer, XGL_IMAGE srcImage, XGL_IMAGE_LAYOUT srcImageLayout, XGL_IMAGE destImage, XGL_IMAGE_LAYOUT destImageLayout);
+typedef void       (XGLAPI *xglCmdUpdateBufferType)(XGL_CMD_BUFFER cmdBuffer, XGL_BUFFER destBuffer, XGL_GPU_SIZE destOffset, XGL_GPU_SIZE dataSize, const uint32_t* pData);
+typedef void       (XGLAPI *xglCmdFillBufferType)(XGL_CMD_BUFFER cmdBuffer, XGL_BUFFER destBuffer, XGL_GPU_SIZE destOffset, XGL_GPU_SIZE fillSize, uint32_t data);
+typedef void       (XGLAPI *xglCmdClearColorImageType)(XGL_CMD_BUFFER cmdBuffer, XGL_IMAGE image, const float color[4], uint32_t rangeCount, const XGL_IMAGE_SUBRESOURCE_RANGE* pRanges);
+typedef void       (XGLAPI *xglCmdClearColorImageRawType)(XGL_CMD_BUFFER cmdBuffer, XGL_IMAGE image, const uint32_t color[4], uint32_t rangeCount, const XGL_IMAGE_SUBRESOURCE_RANGE* pRanges);
+typedef void       (XGLAPI *xglCmdClearDepthStencilType)(XGL_CMD_BUFFER cmdBuffer, XGL_IMAGE image, float depth, uint32_t stencil, uint32_t rangeCount, const XGL_IMAGE_SUBRESOURCE_RANGE* pRanges);
+typedef void       (XGLAPI *xglCmdResolveImageType)(XGL_CMD_BUFFER cmdBuffer, XGL_IMAGE srcImage, XGL_IMAGE destImage, uint32_t rectCount, const XGL_IMAGE_RESOLVE* pRects);
+typedef void       (XGLAPI *xglCmdSetEventType)(XGL_CMD_BUFFER cmdBuffer, XGL_EVENT event, XGL_SET_EVENT pipeEvent);
+typedef void       (XGLAPI *xglCmdResetEventType)(XGL_CMD_BUFFER cmdBuffer, XGL_EVENT event);
+typedef void       (XGLAPI *xglCmdWaitEventsType)(XGL_CMD_BUFFER cmdBuffer, const XGL_EVENT_WAIT_INFO* pWaitInfo);
+typedef void       (XGLAPI *xglCmdPipelineBarrierType)(XGL_CMD_BUFFER cmdBuffer, const XGL_PIPELINE_BARRIER* pBarrier);
+typedef void       (XGLAPI *xglCmdBeginQueryType)(XGL_CMD_BUFFER cmdBuffer, XGL_QUERY_POOL queryPool, uint32_t slot, XGL_FLAGS flags);
+typedef void       (XGLAPI *xglCmdEndQueryType)(XGL_CMD_BUFFER cmdBuffer, XGL_QUERY_POOL queryPool, uint32_t slot);
+typedef void       (XGLAPI *xglCmdResetQueryPoolType)(XGL_CMD_BUFFER cmdBuffer, XGL_QUERY_POOL queryPool, uint32_t startQuery, uint32_t queryCount);
+typedef void       (XGLAPI *xglCmdWriteTimestampType)(XGL_CMD_BUFFER cmdBuffer, XGL_TIMESTAMP_TYPE timestampType, XGL_BUFFER destBuffer, XGL_GPU_SIZE destOffset);
+typedef void       (XGLAPI *xglCmdInitAtomicCountersType)(XGL_CMD_BUFFER cmdBuffer, XGL_PIPELINE_BIND_POINT pipelineBindPoint, uint32_t startCounter, uint32_t counterCount, const uint32_t* pData);
+typedef void       (XGLAPI *xglCmdLoadAtomicCountersType)(XGL_CMD_BUFFER cmdBuffer, XGL_PIPELINE_BIND_POINT pipelineBindPoint, uint32_t startCounter, uint32_t counterCount, XGL_BUFFER srcBuffer, XGL_GPU_SIZE srcOffset);
+typedef void       (XGLAPI *xglCmdSaveAtomicCountersType)(XGL_CMD_BUFFER cmdBuffer, XGL_PIPELINE_BIND_POINT pipelineBindPoint, uint32_t startCounter, uint32_t counterCount, XGL_BUFFER destBuffer, XGL_GPU_SIZE destOffset);
 typedef XGL_RESULT (XGLAPI *xglCreateFramebufferType)(XGL_DEVICE device, const XGL_FRAMEBUFFER_CREATE_INFO* pCreateInfo, XGL_FRAMEBUFFER* pFramebuffer);
 typedef XGL_RESULT (XGLAPI *xglCreateRenderPassType)(XGL_DEVICE device, const XGL_RENDER_PASS_CREATE_INFO* pCreateInfo, XGL_RENDER_PASS* pRenderPass);
 typedef void       (XGLAPI *xglCmdBeginRenderPassType)(XGL_CMD_BUFFER cmdBuffer, XGL_RENDER_PASS renderPass);
@@ -3030,11 +3030,11 @@ void XGLAPI xglCmdEndRenderPass(
     feedback is part of the pipeline, transform feedback binding would be available
     through a new API bind point:
 
-        xglCmdBindTransformFeedbackBufferView(
+        xglCmdBindTransformFeedbackMemoryView(
                 XGL_CMD_BUFFER                              cmdBuffer,
                 XGL_PIPELINE_BIND_POINT                     pipelineBindPoint, // = GRAPHICS
                 uint32_t                                    index,
-                const XGL_BUFFER_VIEW_ATTACH_INFO*          pBufferView);
+                const XGL_MEMORY_VIEW_ATTACH_INFO*          pMemView);
 
     2) "Bindless" + support for non-bindless hardware.
 
diff --git a/include/xglPlatform.h b/include/xglPlatform.h
index f0c7a3f6..79f37c93 100644
--- a/include/xglPlatform.h
+++ b/include/xglPlatform.h
@@ -51,7 +51,21 @@ extern "C"
 #endif
 
 #include <stddef.h>
-#include <stdint.h>
+
+#if !defined(XGL_NO_STDINT_H)
+    #if defined(_MSC_VER) && (_MSC_VER < 1600)
+        typedef signed   __int8  int8_t;
+        typedef unsigned __int8  uint8_t;
+        typedef signed   __int16 int16_t;
+        typedef unsigned __int16 uint16_t;
+        typedef signed   __int32 int32_t;
+        typedef unsigned __int32 uint32_t;
+        typedef signed   __int64 int64_t;
+        typedef unsigned __int64 uint64_t;
+    #else
+        #include <stdint.h>
+    #endif
+#endif // !defined(XGL_NO_STDINT_H)
 
 typedef uint64_t   XGL_GPU_SIZE;
 typedef uint32_t   bool32_t;
diff --git a/loader/CMakeLists.txt b/loader/CMakeLists.txt
index 2d2febfe..bbf5799f 100644
--- a/loader/CMakeLists.txt
+++ b/loader/CMakeLists.txt
@@ -15,7 +15,7 @@ include_directories(
 if (WIN32)
     set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -DXGL_PROTOTYPES -D_CRT_SECURE_NO_WARNINGS")
 
-    add_library(XGL SHARED loader.c dirent_on_windows.c dispatch.c table_ops.h)
+    add_library(XGL STATIC loader.c dirent_on_windows.c dispatch.c table_ops.h)
     set_target_properties(XGL PROPERTIES SOVERSION 0)
     target_link_libraries(XGL)
 endif()
diff --git a/loader/loader.c b/loader/loader.c
index 2ea37e71..6dd4013f 100644
--- a/loader/loader.c
+++ b/loader/loader.c
@@ -872,8 +872,9 @@ LOADER_EXPORT XGL_RESULT XGLAPI xglCreateInstance(
         scanned_icds = scanned_icds->next;
     }
 
-    if (ptr_instance->icds == NULL)
-        return res;
+    if (ptr_instance->icds == NULL) {
+        return XGL_ERROR_INCOMPATIBLE_DRIVER;
+    }
 
     *pInstance = (XGL_INSTANCE) ptr_instance;
     return XGL_SUCCESS;