update for buffer object changes

diff --git a/demos/cube.c b/demos/cube.c
index 14c1a5c714bf5fdff258c72436551c643a046875..d42cddc776cf6b4d182bd40a8c38adeeac5ac25f 100644 (file)
--- a/demos/cube.c
+++ b/demos/cube.c
@@ -226,17 +226,10 @@ struct demo {
     } textures[DEMO_TEXTURE_COUNT];
 
     struct {
+        XGL_BUFFER buf;
         XGL_GPU_MEMORY mem;
-        XGL_MEMORY_VIEW_ATTACH_INFO view;
-
-        XGL_PIPELINE_VERTEX_INPUT_CREATE_INFO vi;
-        XGL_VERTEX_INPUT_BINDING_DESCRIPTION vi_bindings[1];
-        XGL_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION vi_attrs[2];
-    } vertices;
-
-    struct {
-        XGL_GPU_MEMORY mem;
-        XGL_MEMORY_VIEW_ATTACH_INFO view;
+        XGL_BUFFER_VIEW view;
+        XGL_BUFFER_VIEW_ATTACH_INFO attach;
     } uniform_data;
 
     XGL_DESCRIPTOR_SET dset;
@@ -800,7 +793,11 @@ static void demo_prepare_textures(struct demo *demo)
 
 void demo_prepare_cube_data_buffer(struct demo *demo)
 {
+    XGL_BUFFER_CREATE_INFO buf_info;
+    XGL_BUFFER_VIEW_CREATE_INFO view_info;
     XGL_MEMORY_ALLOC_INFO alloc_info;
+    XGL_MEMORY_REQUIREMENTS mem_reqs;
+    XGL_SIZE mem_reqs_size = sizeof(XGL_MEMORY_REQUIREMENTS);
     XGL_UINT8 *pData;
     int i;
     mat4x4 MVP, VP;
@@ -823,14 +820,25 @@ void demo_prepare_cube_data_buffer(struct demo *demo)
         data.attr[i][3] = 0;
     }
 
+    memset(&buf_info, 0, sizeof(buf_info));
+    buf_info.sType = XGL_STRUCTURE_TYPE_BUFFER_CREATE_INFO;
+    buf_info.size = sizeof(data);
+    buf_info.usage = XGL_BUFFER_USAGE_UNIFORM_READ_BIT;
+    err = xglCreateBuffer(demo->device, &buf_info, &demo->uniform_data.buf);
+    assert(!err);
+
+    err = xglGetObjectInfo(demo->uniform_data.buf,
+            XGL_INFO_TYPE_MEMORY_REQUIREMENTS,
+            &mem_reqs_size, &mem_reqs);
+    assert(!err && mem_reqs_size == sizeof(mem_reqs));
+
     memset(&alloc_info, 0, sizeof(alloc_info));
     alloc_info.sType = XGL_STRUCTURE_TYPE_MEMORY_ALLOC_INFO;
-    alloc_info.allocationSize = sizeof(data);
-    alloc_info.alignment = 0;
-    alloc_info.heapCount = 1;
-    alloc_info.heaps[0] = 0; // TODO: Use known existing heap
-
-    alloc_info.flags = XGL_MEMORY_HEAP_CPU_VISIBLE_BIT;
+    alloc_info.allocationSize = mem_reqs.size;
+    alloc_info.alignment = mem_reqs.alignment;
+    alloc_info.heapCount = mem_reqs.heapCount;
+    memcpy(alloc_info.heaps, mem_reqs.heaps,
+            sizeof(mem_reqs.heaps[0]) * mem_reqs.heapCount);
     alloc_info.memPriority = XGL_MEMORY_PRIORITY_NORMAL;
 
     err = xglAllocMemory(demo->device, &alloc_info, &demo->uniform_data.mem);
@@ -844,14 +852,31 @@ void demo_prepare_cube_data_buffer(struct demo *demo)
     err = xglUnmapMemory(demo->uniform_data.mem);
     assert(!err);
 
-    // set up the memory view for the constant buffer
-    demo->uniform_data.view.sType = XGL_STRUCTURE_TYPE_MEMORY_VIEW_ATTACH_INFO;
-    demo->uniform_data.view.stride = 16;
-    demo->uniform_data.view.range  = alloc_info.allocationSize;
-    demo->uniform_data.view.offset = 0;
-    demo->uniform_data.view.mem    = demo->uniform_data.mem;
-    demo->uniform_data.view.format.channelFormat = XGL_CH_FMT_R32G32B32A32;
-    demo->uniform_data.view.format.numericFormat = XGL_NUM_FMT_FLOAT;
+    err = xglBindObjectMemory(demo->uniform_data.buf,
+            demo->uniform_data.mem, 0);
+    assert(!err);
+
+    memset(&view_info, 0, sizeof(view_info));
+    view_info.sType = XGL_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO;
+    view_info.buffer = demo->uniform_data.buf;
+    view_info.viewType = XGL_BUFFER_VIEW_TYPED;
+    view_info.stride = 16;
+    view_info.format.channelFormat = XGL_CH_FMT_R32G32B32A32;
+    view_info.format.numericFormat = XGL_NUM_FMT_FLOAT;
+    view_info.channels.r = XGL_CHANNEL_SWIZZLE_R;
+    view_info.channels.g = XGL_CHANNEL_SWIZZLE_G;
+    view_info.channels.b = XGL_CHANNEL_SWIZZLE_B;
+    view_info.channels.a = XGL_CHANNEL_SWIZZLE_A;
+    view_info.offset = 0;
+    view_info.range = sizeof(data);
+
+    err = xglCreateBufferView(demo->device, &view_info, &demo->uniform_data.view);
+    assert(!err);
+
+    demo->uniform_data.attach.sType = XGL_STRUCTURE_TYPE_BUFFER_VIEW_ATTACH_INFO;
+    demo->uniform_data.attach.view = demo->uniform_data.view;
+    // no preparation..
+    demo->uniform_data.attach.state = XGL_BUFFER_STATE_DATA_TRANSFER;
 }
 
 static void demo_prepare_descriptor_set(struct demo *demo)
@@ -871,7 +896,7 @@ static void demo_prepare_descriptor_set(struct demo *demo)
 
 //    xglAttachMemoryViewDescriptors(demo->dset, 0, 1, &demo->vertices.view);
 
-    xglAttachMemoryViewDescriptors(demo->dset, 0, 1, &demo->uniform_data.view);
+    xglAttachBufferViewDescriptors(demo->dset, 0, 1, &demo->uniform_data.attach);
 
     XGL_IMAGE_VIEW_ATTACH_INFO image_view;
 

diff --git a/demos/tri.c b/demos/tri.c
index 6686cd32db0dd6fece21b069f2f43b109af7713a..a4b3656bc047ccd0125787337501ad33fdeb678c 100644 (file)
--- a/demos/tri.c
+++ b/demos/tri.c
@@ -56,6 +56,7 @@ struct demo {
     } textures[DEMO_TEXTURE_COUNT];
 
     struct {
+        XGL_BUFFER buf;
         XGL_GPU_MEMORY mem;
 
         XGL_PIPELINE_VERTEX_INPUT_CREATE_INFO vi;
@@ -152,7 +153,7 @@ static void demo_draw_build_cmd(struct demo *demo)
                                      demo->depth_stencil);
 
 
-    xglCmdBindVertexData(demo->cmd, demo->vertices.mem, 0, 0);
+    xglCmdBindVertexBuffer(demo->cmd, demo->vertices.buf, 0, 0);
 
     clear_range.aspect = XGL_IMAGE_ASPECT_COLOR;
     clear_range.baseMipLevel = 0;
@@ -468,21 +469,43 @@ static void demo_prepare_vertices(struct demo *demo)
         {  1.0f, -1.0f, -0.5f,      1.0f, 0.0f },
         {  0.0f,  1.0f,  1.0f,      0.5f, 1.0f },
     };
-    const XGL_MEMORY_ALLOC_INFO mem_alloc = {
+    const XGL_BUFFER_CREATE_INFO buf_info = {
+        .sType = XGL_STRUCTURE_TYPE_BUFFER_CREATE_INFO,
+        .pNext = NULL,
+        .size = sizeof(vb),
+        .usage = XGL_BUFFER_USAGE_VERTEX_FETCH_BIT,
+        .flags = 0,
+    };
+    XGL_MEMORY_ALLOC_INFO mem_alloc = {
         .sType = XGL_STRUCTURE_TYPE_MEMORY_ALLOC_INFO,
         .pNext = NULL,
-        .allocationSize = sizeof(vb),
+        .allocationSize = 0,
         .alignment = 0,
         .flags = 0,
-        .heapCount = 1,
+        .heapCount = 0,
         .heaps[0] = 0,
         .memPriority = XGL_MEMORY_PRIORITY_NORMAL,
     };
+    XGL_MEMORY_REQUIREMENTS mem_reqs;
+    XGL_SIZE mem_reqs_size = sizeof(XGL_MEMORY_REQUIREMENTS);
     XGL_RESULT err;
     void *data;
 
     memset(&demo->vertices, 0, sizeof(demo->vertices));
 
+    err = xglCreateBuffer(demo->device, &buf_info, &demo->vertices.buf);
+    assert(!err);
+
+    err = xglGetObjectInfo(demo->vertices.buf,
+            XGL_INFO_TYPE_MEMORY_REQUIREMENTS,
+            &mem_reqs_size, &mem_reqs);
+    assert(!err && mem_reqs_size == sizeof(mem_reqs));
+    mem_alloc.allocationSize = mem_reqs.size;
+    mem_alloc.alignment = mem_reqs.alignment;
+    mem_alloc.heapCount = mem_reqs.heapCount;
+    memcpy(mem_alloc.heaps, mem_reqs.heaps,
+            sizeof(mem_reqs.heaps[0]) * mem_reqs.heapCount);
+
     err = xglAllocMemory(demo->device, &mem_alloc, &demo->vertices.mem);
     assert(!err);
 
@@ -494,6 +517,9 @@ static void demo_prepare_vertices(struct demo *demo)
     err = xglUnmapMemory(demo->vertices.mem);
     assert(!err);
 
+    err = xglBindObjectMemory(demo->vertices.buf, demo->vertices.mem, 0);
+    assert(!err);
+
     demo->vertices.vi.sType = XGL_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_CREATE_INFO;
     demo->vertices.vi.pNext = NULL;
     demo->vertices.vi.bindingCount = 1;
@@ -945,18 +971,20 @@ static void demo_cleanup(struct demo *demo)
 
     xglDestroyObject(demo->dset);
 
+    xglBindObjectMemory(demo->vertices.buf, XGL_NULL_HANDLE, 0);
+    xglDestroyObject(demo->vertices.buf);
     xglFreeMemory(demo->vertices.mem);
 
     for (i = 0; i < DEMO_TEXTURE_COUNT; i++) {
         xglDestroyObject(demo->textures[i].view);
-        xglBindObjectMemory(demo->textures[i].image, 0, XGL_NULL_HANDLE);
+        xglBindObjectMemory(demo->textures[i].image, XGL_NULL_HANDLE, 0);
         xglDestroyObject(demo->textures[i].image);
         xglFreeMemory(demo->textures[i].mem);
         xglDestroyObject(demo->textures[i].sampler);
     }
 
     xglDestroyObject(demo->depth.view);
-    xglBindObjectMemory(demo->depth.image, 0, XGL_NULL_HANDLE);
+    xglBindObjectMemory(demo->depth.image, XGL_NULL_HANDLE, 0);
     xglDestroyObject(demo->depth.image);
     xglFreeMemory(demo->depth.mem);
 

diff --git a/demos/xglinfo.c b/demos/xglinfo.c
index 4dec489c410af24bc6896b849cfd27c0ed5bb6c2..2040e762c82dd4ee2d48b6c5712c217888dd7728 100644 (file)
--- a/demos/xglinfo.c
+++ b/demos/xglinfo.c
@@ -519,7 +519,6 @@ static void app_gpu_dump_props(const struct app_gpu *gpu)
     printf("\tgpuType = %s\n",                      xgl_gpu_type_string(props->gpuType));
     printf("\tgpuName = %s\n",                      props->gpuName);
     printf("\tmaxMemRefsPerSubmission = %u\n",      props->maxMemRefsPerSubmission);
-    printf("\tvirtualMemPageSize = %zu\n",          props->virtualMemPageSize);
     printf("\tmaxInlineMemoryUpdateSize = %zu\n",   props->maxInlineMemoryUpdateSize);
     printf("\tmaxBoundDescriptorSets = %u\n",       props->maxBoundDescriptorSets);
     printf("\tmaxThreadGroupSize = %u\n",           props->maxThreadGroupSize);
@@ -576,7 +575,6 @@ static void app_gpu_dump_memory_props(const struct app_gpu *gpu)
     printf("XGL_PHYSICAL_GPU_MEMORY_PROPERTIES\n");
     printf("\tstructSize = %zu\n",                      props->structSize);
     printf("\tsupportsMigration = %u\n",                props->supportsMigration);
-    printf("\tsupportsVirtualMemoryRemapping = %u\n",   props->supportsVirtualMemoryRemapping);
     printf("\tsupportsPinning = %u\n",                  props->supportsPinning);
 }
 

diff --git a/include/xgl.h b/include/xgl.h
index 6c03de699a4bf9d19386c83f2ad9ceedb0aac537..2e40aed8c1160adf5d8f000b3a65ffaa28a674ea 100644 (file)
--- a/include/xgl.h
+++ b/include/xgl.h
@@ -81,6 +81,8 @@ XGL_DEFINE_SUBCLASS_HANDLE(XGL_DEVICE, XGL_BASE_OBJECT)
 XGL_DEFINE_SUBCLASS_HANDLE(XGL_QUEUE, XGL_BASE_OBJECT)
 XGL_DEFINE_SUBCLASS_HANDLE(XGL_GPU_MEMORY, XGL_BASE_OBJECT)
 XGL_DEFINE_SUBCLASS_HANDLE(XGL_OBJECT, XGL_BASE_OBJECT)
+XGL_DEFINE_SUBCLASS_HANDLE(XGL_BUFFER, XGL_OBJECT)
+XGL_DEFINE_SUBCLASS_HANDLE(XGL_BUFFER_VIEW, XGL_OBJECT)
 XGL_DEFINE_SUBCLASS_HANDLE(XGL_IMAGE, XGL_OBJECT)
 XGL_DEFINE_SUBCLASS_HANDLE(XGL_IMAGE_VIEW, XGL_OBJECT)
 XGL_DEFINE_SUBCLASS_HANDLE(XGL_COLOR_ATTACHMENT_VIEW, XGL_OBJECT)
@@ -151,26 +153,26 @@ typedef enum _XGL_MEMORY_PRIORITY
     XGL_NUM_MEMORY_PRIORITY                                 = (XGL_MEMORY_PRIORITY_END_RANGE - XGL_MEMORY_PRIORITY_BEGIN_RANGE + 1),
 } XGL_MEMORY_PRIORITY;
 
-typedef enum _XGL_MEMORY_STATE
-{
-    XGL_MEMORY_STATE_DATA_TRANSFER                          = 0x00000000,
-    XGL_MEMORY_STATE_GRAPHICS_SHADER_READ_ONLY              = 0x00000001,
-    XGL_MEMORY_STATE_GRAPHICS_SHADER_WRITE_ONLY             = 0x00000002,
-    XGL_MEMORY_STATE_GRAPHICS_SHADER_READ_WRITE             = 0x00000003,
-    XGL_MEMORY_STATE_COMPUTE_SHADER_READ_ONLY               = 0x00000004,
-    XGL_MEMORY_STATE_COMPUTE_SHADER_WRITE_ONLY              = 0x00000005,
-    XGL_MEMORY_STATE_COMPUTE_SHADER_READ_WRITE              = 0x00000006,
-    XGL_MEMORY_STATE_MULTI_SHADER_READ_ONLY                 = 0x00000007,
-    XGL_MEMORY_STATE_INDEX_DATA                             = 0x00000008,
-    XGL_MEMORY_STATE_INDIRECT_ARG                           = 0x00000009,
-    XGL_MEMORY_STATE_WRITE_TIMESTAMP                        = 0x0000000A,
-    XGL_MEMORY_STATE_QUEUE_ATOMIC                           = 0x0000000B,
-
-    XGL_MEMORY_STATE_BEGIN_RANGE                            = XGL_MEMORY_STATE_DATA_TRANSFER,
-    XGL_MEMORY_STATE_END_RANGE                              = XGL_MEMORY_STATE_QUEUE_ATOMIC,
-    XGL_NUM_MEMORY_STATE                                    = (XGL_MEMORY_STATE_END_RANGE - XGL_MEMORY_STATE_BEGIN_RANGE + 1),
-    XGL_MAX_ENUM(_XGL_MEMORY_STATE)
-} XGL_MEMORY_STATE;
+typedef enum _XGL_BUFFER_STATE
+{
+    XGL_BUFFER_STATE_DATA_TRANSFER                          = 0x00000000,
+    XGL_BUFFER_STATE_GRAPHICS_SHADER_READ_ONLY              = 0x00000001,
+    XGL_BUFFER_STATE_GRAPHICS_SHADER_WRITE_ONLY             = 0x00000002,
+    XGL_BUFFER_STATE_GRAPHICS_SHADER_READ_WRITE             = 0x00000003,
+    XGL_BUFFER_STATE_COMPUTE_SHADER_READ_ONLY               = 0x00000004,
+    XGL_BUFFER_STATE_COMPUTE_SHADER_WRITE_ONLY              = 0x00000005,
+    XGL_BUFFER_STATE_COMPUTE_SHADER_READ_WRITE              = 0x00000006,
+    XGL_BUFFER_STATE_MULTI_SHADER_READ_ONLY                 = 0x00000007,
+    XGL_BUFFER_STATE_INDEX_DATA                             = 0x00000008,
+    XGL_BUFFER_STATE_INDIRECT_ARG                           = 0x00000009,
+    XGL_BUFFER_STATE_WRITE_TIMESTAMP                        = 0x0000000A,
+    XGL_BUFFER_STATE_QUEUE_ATOMIC                           = 0x0000000B,
+
+    XGL_BUFFER_STATE_BEGIN_RANGE                            = XGL_BUFFER_STATE_DATA_TRANSFER,
+    XGL_BUFFER_STATE_END_RANGE                              = XGL_BUFFER_STATE_QUEUE_ATOMIC,
+    XGL_NUM_BUFFER_STATE                                    = (XGL_BUFFER_STATE_END_RANGE - XGL_BUFFER_STATE_BEGIN_RANGE + 1),
+    XGL_MAX_ENUM(_XGL_BUFFER_STATE)
+} XGL_BUFFER_STATE;
 
 typedef enum _XGL_IMAGE_STATE
 {
@@ -858,9 +860,9 @@ typedef enum _XGL_STRUCTURE_TYPE
     XGL_STRUCTURE_TYPE_MEMORY_ALLOC_INFO                    = 2,
     XGL_STRUCTURE_TYPE_MEMORY_OPEN_INFO                     = 4,
     XGL_STRUCTURE_TYPE_PEER_MEMORY_OPEN_INFO                = 5,
-    XGL_STRUCTURE_TYPE_MEMORY_VIEW_ATTACH_INFO              = 6,
+    XGL_STRUCTURE_TYPE_BUFFER_VIEW_ATTACH_INFO              = 6,
     XGL_STRUCTURE_TYPE_IMAGE_VIEW_ATTACH_INFO               = 7,
-    XGL_STRUCTURE_TYPE_MEMORY_STATE_TRANSITION              = 8,
+    XGL_STRUCTURE_TYPE_BUFFER_STATE_TRANSITION              = 8,
     XGL_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO               = 9,
     XGL_STRUCTURE_TYPE_COLOR_ATTACHMENT_VIEW_CREATE_INFO    = 10,
     XGL_STRUCTURE_TYPE_DEPTH_STENCIL_VIEW_CREATE_INFO       = 11,
@@ -886,14 +888,16 @@ typedef enum _XGL_STRUCTURE_TYPE
     XGL_STRUCTURE_TYPE_PIPELINE_RS_STATE_CREATE_INFO        = 31,
     XGL_STRUCTURE_TYPE_PIPELINE_TESS_STATE_CREATE_INFO      = 32,
     XGL_STRUCTURE_TYPE_IMAGE_CREATE_INFO                    = 33,
-    XGL_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO              = 34,
-    XGL_STRUCTURE_TYPE_CMD_BUFFER_BEGIN_INFO                = 35,
-    XGL_STRUCTURE_TYPE_CMD_BUFFER_GRAPHICS_BEGIN_INFO       = 36,
-    XGL_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO              = 37,
+    XGL_STRUCTURE_TYPE_BUFFER_CREATE_INFO                   = 37,
+    XGL_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO              = 38,
+    XGL_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO              = 39,
+    XGL_STRUCTURE_TYPE_CMD_BUFFER_BEGIN_INFO                = 40,
+    XGL_STRUCTURE_TYPE_CMD_BUFFER_GRAPHICS_BEGIN_INFO       = 41,
+    XGL_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO              = 42,
+    XGL_STRUCTURE_TYPE_LAYER_CREATE_INFO                    = 43,
 // IMG CHANGE BEGIN - support for vertex input description
-    XGL_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_CREATE_INFO    = 38,
+    XGL_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_CREATE_INFO    = 90,
 // IMG CHANGE END
-    XGL_STRUCTURE_TYPE_LAYER_CREATE_INFO                    = 39,
     XGL_MAX_ENUM(_XGL_STRUCTURE_TYPE)
 } XGL_STRUCTURE_TYPE;
 
@@ -930,17 +934,48 @@ typedef enum _XGL_MEMORY_HEAP_FLAGS
 // Memory allocation flags
 typedef enum _XGL_MEMORY_ALLOC_FLAGS
 {
-    XGL_MEMORY_ALLOC_VIRTUAL_BIT                            = 0x00000001,
-    XGL_MEMORY_ALLOC_SHAREABLE_BIT                          = 0x00000002,
+    XGL_MEMORY_ALLOC_SHAREABLE_BIT                          = 0x00000001,
 } XGL_MEMORY_ALLOC_FLAGS;
 
+// Buffer usage flags
+typedef enum _XGL_BUFFER_USAGE_FLAGS
+{
+    XGL_BUFFER_USAGE_SHADER_ACCESS_READ_BIT                 = 0x00000001,   // Shader read (e.g. TBO, image buffer, UBO, SBBO)
+    XGL_BUFFER_USAGE_SHADER_ACCESS_WRITE_BIT                = 0x00000002,   // Shader write (e.g. image buffer, SSBO)
+    XGL_BUFFER_USAGE_SHADER_ACCESS_ATOMIC_BIT               = 0x00000004,   // Shader atomic operations (e.g. image buffer, SSBO)
+    XGL_BUFFER_USAGE_UNIFORM_READ_BIT                       = 0x00000008,   // Uniform read (UBO)
+    XGL_BUFFER_USAGE_INDEX_FETCH_BIT                        = 0x00000010,   // Fixed function index fetch (index buffer)
+    XGL_BUFFER_USAGE_VERTEX_FETCH_BIT                       = 0x00000020,   // Fixed function vertex fetch (VBO)
+    XGL_BUFFER_USAGE_INDIRECT_PARAMETER_FETCH_BIT           = 0x00000040,   // Can be the source of indirect parameters (e.g. indirect buffer, parameter buffer)
+} XGL_BUFFER_USAGE_FLAGS;
+
+// Buffer flags
+typedef enum _XGL_BUFFER_CREATE_FLAGS
+{
+    XGL_BUFFER_CREATE_SHAREABLE_BIT                         = 0x00000001,
+    XGL_BUFFER_CREATE_SPARSE_BIT                            = 0x00000002,
+} XGL_BUFFER_CREATE_FLAGS;
+
+typedef enum _XGL_BUFFER_VIEW_TYPE
+{
+    XGL_BUFFER_VIEW_RAW                                     = 0x00000000,   // Raw buffer without special structure (e.g. UBO, SSBO, indirect and parameter buffers)
+    XGL_BUFFER_VIEW_TYPED                                   = 0x00000001,   // Typed buffer, format and channels are used (TBO, image buffer)
+    XGL_BUFFER_VIEW_STRUCTURED                              = 0x00000002,   // Structured buffer, stride is used (VBO, DX-style structured buffer)
+
+    XGL_BUFFER_VIEW_TYPE_BEGIN_RANGE                         = XGL_BUFFER_VIEW_RAW,
+    XGL_BUFFER_VIEW_TYPE_END_RANGE                           = XGL_BUFFER_VIEW_STRUCTURED,
+    XGL_NUM_BUFFER_VIEW_TYPE                                 = (XGL_BUFFER_VIEW_TYPE_END_RANGE - XGL_BUFFER_VIEW_TYPE_BEGIN_RANGE + 1),
+    XGL_MAX_ENUM(_XGL_BUFFER_VIEW_TYPE)
+} XGL_BUFFER_VIEW_TYPE;
+
 // Image usage flags
 typedef enum _XGL_IMAGE_USAGE_FLAGS
 {
     XGL_IMAGE_USAGE_SHADER_ACCESS_READ_BIT                  = 0x00000001,
     XGL_IMAGE_USAGE_SHADER_ACCESS_WRITE_BIT                 = 0x00000002,
-    XGL_IMAGE_USAGE_COLOR_ATTACHMENT_BIT                    = 0x00000004,
-    XGL_IMAGE_USAGE_DEPTH_STENCIL_BIT                       = 0x00000008,
+    XGL_IMAGE_USAGE_SHADER_ACCESS_ATOMIC_BIT                = 0x00000004,
+    XGL_IMAGE_USAGE_COLOR_ATTACHMENT_BIT                    = 0x00000008,
+    XGL_IMAGE_USAGE_DEPTH_STENCIL_BIT                       = 0x00000010,
 } XGL_IMAGE_USAGE_FLAGS;
 
 // Image flags
@@ -949,6 +984,7 @@ typedef enum _XGL_IMAGE_CREATE_FLAGS
     XGL_IMAGE_CREATE_INVARIANT_DATA_BIT                     = 0x00000001,
     XGL_IMAGE_CREATE_CLONEABLE_BIT                          = 0x00000002,
     XGL_IMAGE_CREATE_SHAREABLE_BIT                          = 0x00000004,
+    XGL_IMAGE_CREATE_SPARSE_BIT                             = 0x00000008,
 } XGL_IMAGE_CREATE_FLAGS;
 
 // Depth-stencil view creation flags
@@ -1063,6 +1099,14 @@ typedef struct _XGL_RECT
     XGL_EXTENT2D                            extent;
 } XGL_RECT;
 
+typedef struct _XGL_CHANNEL_MAPPING
+{
+    XGL_CHANNEL_SWIZZLE                     r;
+    XGL_CHANNEL_SWIZZLE                     g;
+    XGL_CHANNEL_SWIZZLE                     b;
+    XGL_CHANNEL_SWIZZLE                     a;
+} XGL_CHANNEL_MAPPING;
+
 typedef struct _XGL_PHYSICAL_GPU_PROPERTIES
 {
     XGL_SIZE                                structSize;
@@ -1073,7 +1117,6 @@ typedef struct _XGL_PHYSICAL_GPU_PROPERTIES
     XGL_PHYSICAL_GPU_TYPE                   gpuType;
     XGL_CHAR                                gpuName[XGL_MAX_PHYSICAL_GPU_NAME];
     XGL_UINT                                maxMemRefsPerSubmission;
-    XGL_GPU_SIZE                            virtualMemPageSize;
     XGL_GPU_SIZE                            maxInlineMemoryUpdateSize;
     XGL_UINT                                maxBoundDescriptorSets;
     XGL_UINT                                maxThreadGroupSize;
@@ -1162,7 +1205,6 @@ typedef struct _XGL_PHYSICAL_GPU_MEMORY_PROPERTIES
 {
     XGL_SIZE                                structSize;                 // Size of structure in bytes
     XGL_BOOL                                supportsMigration;
-    XGL_BOOL                                supportsVirtualMemoryRemapping;
     XGL_BOOL                                supportsPinning;
 } XGL_PHYSICAL_GPU_MEMORY_PROPERTIES;
 
@@ -1205,19 +1247,11 @@ typedef struct _XGL_PEER_MEMORY_OPEN_INFO
     XGL_GPU_MEMORY                          originalMem;
 } XGL_PEER_MEMORY_OPEN_INFO;
 
-typedef struct _XGL_VIRTUAL_MEMORY_REMAP_RANGE
-{
-    XGL_GPU_MEMORY                          virtualMem;
-    XGL_GPU_SIZE                            virtualStartPage;
-    XGL_GPU_MEMORY                          realMem;
-    XGL_GPU_SIZE                            realStartPage;
-    XGL_GPU_SIZE                            pageCount;
-} XGL_VIRTUAL_MEMORY_REMAP_RANGE;
-
 typedef struct _XGL_MEMORY_REQUIREMENTS
 {
     XGL_GPU_SIZE                            size;                       // Specified in bytes
     XGL_GPU_SIZE                            alignment;                  // Specified in bytes
+    XGL_GPU_SIZE                            granularity;                // Granularity on which xglBindObjectMemoryRange can bind sub-ranges of memory specified in bytes (usually the page size)
     XGL_UINT                                heapCount;
     XGL_UINT                                heaps[XGL_MAX_MEMORY_HEAPS];
 } XGL_MEMORY_REQUIREMENTS;
@@ -1228,17 +1262,13 @@ typedef struct _XGL_FORMAT_PROPERTIES
     XGL_FLAGS                               optimalTilingFeatures;     // XGL_FORMAT_FEATURE_FLAGS
 } XGL_FORMAT_PROPERTIES;
 
-typedef struct _XGL_MEMORY_VIEW_ATTACH_INFO
+typedef struct _XGL_BUFFER_VIEW_ATTACH_INFO
 {
-    XGL_STRUCTURE_TYPE                      sType;                      // Must be XGL_STRUCTURE_TYPE_MEMORY_VIEW_ATTACH_INFO
+    XGL_STRUCTURE_TYPE                      sType;                      // Must be XGL_STRUCTURE_TYPE_BUFFER_VIEW_ATTACH_INFO
     XGL_VOID*                               pNext;                      // Pointer to next structure
-    XGL_GPU_MEMORY                          mem;
-    XGL_GPU_SIZE                            offset;
-    XGL_GPU_SIZE                            range;
-    XGL_GPU_SIZE                            stride;
-    XGL_FORMAT                              format;
-    XGL_MEMORY_STATE                        state;
-} XGL_MEMORY_VIEW_ATTACH_INFO;
+    XGL_BUFFER_VIEW                         view;
+    XGL_BUFFER_STATE                        state;
+} XGL_BUFFER_VIEW_ATTACH_INFO;
 
 typedef struct _XGL_IMAGE_VIEW_ATTACH_INFO
 {
@@ -1248,16 +1278,38 @@ typedef struct _XGL_IMAGE_VIEW_ATTACH_INFO
     XGL_IMAGE_STATE                         state;
 } XGL_IMAGE_VIEW_ATTACH_INFO;
 
-typedef struct _XGL_MEMORY_STATE_TRANSITION
+typedef struct _XGL_BUFFER_STATE_TRANSITION
 {
-    XGL_STRUCTURE_TYPE                      sType;                      // Must be XGL_STRUCTURE_TYPE_MEMORY_STATE_TRANSITION
+    XGL_STRUCTURE_TYPE                      sType;                      // Must be XGL_STRUCTURE_TYPE_BUFFER_STATE_TRANSITION
     XGL_VOID*                               pNext;                      // Pointer to next structure
-    XGL_GPU_MEMORY                          mem;
-    XGL_MEMORY_STATE                        oldState;
-    XGL_MEMORY_STATE                        newState;
+    XGL_BUFFER                              buffer;
+    XGL_BUFFER_STATE                        oldState;
+    XGL_BUFFER_STATE                        newState;
     XGL_GPU_SIZE                            offset;
     XGL_GPU_SIZE                            regionSize;
-} XGL_MEMORY_STATE_TRANSITION;
+} XGL_BUFFER_STATE_TRANSITION;
+
+typedef struct _XGL_BUFFER_CREATE_INFO
+{
+    XGL_STRUCTURE_TYPE                      sType;                      // Must be XGL_STRUCTURE_TYPE_BUFFER_CREATE_INFO
+    const XGL_VOID*                         pNext;                      // Pointer to next structure.
+    XGL_GPU_SIZE                            size;                       // Specified in bytes
+    XGL_FLAGS                               usage;                      // XGL_BUFFER_USAGE_FLAGS
+    XGL_FLAGS                               flags;                      // XGL_BUFFER_CREATE_FLAGS
+} XGL_BUFFER_CREATE_INFO;
+
+typedef struct _XGL_BUFFER_VIEW_CREATE_INFO
+{
+    XGL_STRUCTURE_TYPE                      sType;                      // Must be XGL_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO
+    const XGL_VOID*                         pNext;                      // Pointer to next structure.
+    XGL_BUFFER                              buffer;
+    XGL_BUFFER_VIEW_TYPE                    viewType;
+    XGL_GPU_SIZE                            stride;                     // Optionally specifies stride between elements
+    XGL_FORMAT                              format;                     // Optionally specifies format of elements
+    XGL_CHANNEL_MAPPING                     channels;                   // Optionally specifies format channel mapping
+    XGL_GPU_SIZE                            offset;                     // Specified in bytes
+    XGL_GPU_SIZE                            range;                      // View size specified in bytes
+} XGL_BUFFER_VIEW_CREATE_INFO;
 
 typedef struct _XGL_IMAGE_SUBRESOURCE
 {
@@ -1311,14 +1363,6 @@ typedef struct _XGL_SUBRESOURCE_LAYOUT
     XGL_GPU_SIZE                            depthPitch;             // Specified in bytes
 } XGL_SUBRESOURCE_LAYOUT;
 
-typedef struct _XGL_CHANNEL_MAPPING
-{
-    XGL_CHANNEL_SWIZZLE                     r;
-    XGL_CHANNEL_SWIZZLE                     g;
-    XGL_CHANNEL_SWIZZLE                     b;
-    XGL_CHANNEL_SWIZZLE                     a;
-} XGL_CHANNEL_MAPPING;
-
 typedef struct _XGL_IMAGE_VIEW_CREATE_INFO
 {
     XGL_STRUCTURE_TYPE                      sType;                  // Must be XGL_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO
@@ -1370,12 +1414,19 @@ typedef struct _XGL_DEPTH_STENCIL_BIND_INFO
     XGL_IMAGE_STATE                         stencilState;           // XGL_IMAGE_STATE
 } XGL_DEPTH_STENCIL_BIND_INFO;
 
-typedef struct _XGL_MEMORY_COPY
+typedef struct _XGL_BUFFER_COPY
 {
     XGL_GPU_SIZE                            srcOffset;              // Specified in bytes
     XGL_GPU_SIZE                            destOffset;             // Specified in bytes
     XGL_GPU_SIZE                            copySize;               // Specified in bytes
-} XGL_MEMORY_COPY;
+} XGL_BUFFER_COPY;
+
+typedef struct _XGL_IMAGE_MEMORY_BIND_INFO
+{
+    XGL_IMAGE_SUBRESOURCE                   subresource;
+    XGL_OFFSET3D                            offset;
+    XGL_EXTENT3D                            extent;
+} XGL_IMAGE_MEMORY_BIND_INFO;
 
 typedef struct _XGL_IMAGE_COPY
 {
@@ -1386,13 +1437,13 @@ typedef struct _XGL_IMAGE_COPY
     XGL_EXTENT3D                            extent;
 } XGL_IMAGE_COPY;
 
-typedef struct _XGL_MEMORY_IMAGE_COPY
+typedef struct _XGL_BUFFER_IMAGE_COPY
 {
-    XGL_GPU_SIZE                            memOffset;              // Specified in bytes
+    XGL_GPU_SIZE                            bufferOffset;           // Specified in bytes
     XGL_IMAGE_SUBRESOURCE                   imageSubresource;
     XGL_OFFSET3D                            imageOffset;
     XGL_EXTENT3D                            imageExtent;
-} XGL_MEMORY_IMAGE_COPY;
+} XGL_BUFFER_IMAGE_COPY;
 
 typedef struct _XGL_IMAGE_RESOLVE
 {
@@ -1437,11 +1488,11 @@ typedef struct _XGL_LINK_CONST_BUFFER
     const XGL_VOID*                             pBufferData;
 } XGL_LINK_CONST_BUFFER;
 
-typedef struct _XGL_DYNAMIC_MEMORY_VIEW_SLOT_INFO
+typedef struct _XGL_DYNAMIC_BUFFER_VIEW_SLOT_INFO
 {
     XGL_DESCRIPTOR_SET_SLOT_TYPE            slotObjectType;
     XGL_UINT                                shaderEntityIndex;
-} XGL_DYNAMIC_MEMORY_VIEW_SLOT_INFO;
+} XGL_DYNAMIC_BUFFER_VIEW_SLOT_INFO;
 
 typedef struct _XGL_PIPELINE_SHADER
 {
@@ -1450,7 +1501,7 @@ typedef struct _XGL_PIPELINE_SHADER
     XGL_DESCRIPTOR_SET_MAPPING              descriptorSetMapping[XGL_MAX_DESCRIPTOR_SETS];
     XGL_UINT                                linkConstBufferCount;
     const XGL_LINK_CONST_BUFFER*            pLinkConstBufferInfo;
-    XGL_DYNAMIC_MEMORY_VIEW_SLOT_INFO       dynamicMemoryViewMapping;
+    XGL_DYNAMIC_BUFFER_VIEW_SLOT_INFO       dynamicBufferViewMapping;
 } XGL_PIPELINE_SHADER;
 
 typedef struct _XGL_COMPUTE_PIPELINE_CREATE_INFO
@@ -1853,7 +1904,6 @@ typedef XGL_RESULT (XGLAPI *xglSetMemoryPriorityType)(XGL_GPU_MEMORY mem, XGL_ME
 typedef XGL_RESULT (XGLAPI *xglMapMemoryType)(XGL_GPU_MEMORY mem, XGL_FLAGS flags, XGL_VOID** ppData);
 typedef XGL_RESULT (XGLAPI *xglUnmapMemoryType)(XGL_GPU_MEMORY mem);
 typedef XGL_RESULT (XGLAPI *xglPinSystemMemoryType)(XGL_DEVICE device, const XGL_VOID* pSysMem, XGL_SIZE memSize, XGL_GPU_MEMORY* pMem);
-typedef XGL_RESULT (XGLAPI *xglRemapVirtualMemoryPagesType)(XGL_DEVICE device, XGL_UINT rangeCount, const XGL_VIRTUAL_MEMORY_REMAP_RANGE* pRanges, XGL_UINT preWaitSemaphoreCount, const XGL_QUEUE_SEMAPHORE* pPreWaitSemaphores, XGL_UINT postSignalSemaphoreCount, const XGL_QUEUE_SEMAPHORE* pPostSignalSemaphores);
 typedef XGL_RESULT (XGLAPI *xglGetMultiGpuCompatibilityType)(XGL_PHYSICAL_GPU gpu0, XGL_PHYSICAL_GPU gpu1, XGL_GPU_COMPATIBILITY_INFO* pInfo);
 typedef XGL_RESULT (XGLAPI *xglOpenSharedMemoryType)(XGL_DEVICE device, const XGL_MEMORY_OPEN_INFO* pOpenInfo, XGL_GPU_MEMORY* pMem);
 typedef XGL_RESULT (XGLAPI *xglOpenSharedQueueSemaphoreType)(XGL_DEVICE device, const XGL_QUEUE_SEMAPHORE_OPEN_INFO* pOpenInfo, XGL_QUEUE_SEMAPHORE* pSemaphore);
@@ -1861,7 +1911,9 @@ typedef XGL_RESULT (XGLAPI *xglOpenPeerMemoryType)(XGL_DEVICE device, const XGL_
 typedef XGL_RESULT (XGLAPI *xglOpenPeerImageType)(XGL_DEVICE device, const XGL_PEER_IMAGE_OPEN_INFO* pOpenInfo, XGL_IMAGE* pImage, XGL_GPU_MEMORY* pMem);
 typedef XGL_RESULT (XGLAPI *xglDestroyObjectType)(XGL_OBJECT object);
 typedef XGL_RESULT (XGLAPI *xglGetObjectInfoType)(XGL_BASE_OBJECT object, XGL_OBJECT_INFO_TYPE infoType, XGL_SIZE* pDataSize, XGL_VOID* pData);
-typedef XGL_RESULT (XGLAPI *xglBindObjectMemoryType)(XGL_OBJECT object, XGL_GPU_MEMORY mem, XGL_GPU_SIZE offset);
+typedef XGL_RESULT (XGLAPI *xglBindObjectMemoryType)(XGL_OBJECT object, XGL_GPU_MEMORY mem, XGL_GPU_SIZE memOffset);
+typedef XGL_RESULT (XGLAPI *xglBindObjectMemoryRangeType)(XGL_OBJECT object, XGL_GPU_SIZE rangeOffset, XGL_GPU_SIZE rangeSize, XGL_GPU_MEMORY mem, XGL_GPU_SIZE memOffset);
+typedef XGL_RESULT (XGLAPI *xglBindImageMemoryRangeType)(XGL_IMAGE image, 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);
 typedef XGL_RESULT (XGLAPI *xglWaitForFencesType)(XGL_DEVICE device, XGL_UINT fenceCount, const XGL_FENCE* pFences, XGL_BOOL waitAll, XGL_UINT64 timeout);
@@ -1875,6 +1927,8 @@ typedef XGL_RESULT (XGLAPI *xglResetEventType)(XGL_EVENT event);
 typedef XGL_RESULT (XGLAPI *xglCreateQueryPoolType)(XGL_DEVICE device, const XGL_QUERY_POOL_CREATE_INFO* pCreateInfo, XGL_QUERY_POOL* pQueryPool);
 typedef XGL_RESULT (XGLAPI *xglGetQueryPoolResultsType)(XGL_QUERY_POOL queryPool, XGL_UINT startQuery, XGL_UINT queryCount, XGL_SIZE* pDataSize, XGL_VOID* pData);
 typedef XGL_RESULT (XGLAPI *xglGetFormatInfoType)(XGL_DEVICE device, XGL_FORMAT format, XGL_FORMAT_INFO_TYPE infoType, XGL_SIZE* pDataSize, XGL_VOID* pData);
+typedef XGL_RESULT (XGLAPI *xglCreateBufferType)(XGL_DEVICE device, const XGL_BUFFER_CREATE_INFO* pCreateInfo, XGL_BUFFER* pBuffer);
+typedef XGL_RESULT (XGLAPI *xglCreateBufferViewType)(XGL_DEVICE device, const XGL_BUFFER_VIEW_CREATE_INFO* pCreateInfo, XGL_BUFFER_VIEW* pView);
 typedef XGL_RESULT (XGLAPI *xglCreateImageType)(XGL_DEVICE device, const XGL_IMAGE_CREATE_INFO* pCreateInfo, XGL_IMAGE* pImage);
 typedef XGL_RESULT (XGLAPI *xglGetImageSubresourceInfoType)(XGL_IMAGE image, const XGL_IMAGE_SUBRESOURCE* pSubresource, XGL_SUBRESOURCE_INFO_TYPE infoType, XGL_SIZE* pDataSize, XGL_VOID* pData);
 typedef XGL_RESULT (XGLAPI *xglCreateImageViewType)(XGL_DEVICE device, const XGL_IMAGE_VIEW_CREATE_INFO* pCreateInfo, XGL_IMAGE_VIEW* pView);
@@ -1892,7 +1946,7 @@ typedef XGL_VOID (XGLAPI *xglBeginDescriptorSetUpdateType)(XGL_DESCRIPTOR_SET de
 typedef XGL_VOID (XGLAPI *xglEndDescriptorSetUpdateType)(XGL_DESCRIPTOR_SET descriptorSet);
 typedef XGL_VOID (XGLAPI *xglAttachSamplerDescriptorsType)(XGL_DESCRIPTOR_SET descriptorSet, XGL_UINT startSlot, XGL_UINT slotCount, const XGL_SAMPLER* pSamplers);
 typedef XGL_VOID (XGLAPI *xglAttachImageViewDescriptorsType)(XGL_DESCRIPTOR_SET descriptorSet, XGL_UINT startSlot, XGL_UINT slotCount, const XGL_IMAGE_VIEW_ATTACH_INFO* pImageViews);
-typedef XGL_VOID (XGLAPI *xglAttachMemoryViewDescriptorsType)(XGL_DESCRIPTOR_SET descriptorSet, XGL_UINT startSlot, XGL_UINT slotCount, const XGL_MEMORY_VIEW_ATTACH_INFO* pMemViews);
+typedef XGL_VOID (XGLAPI *xglAttachBufferViewDescriptorsType)(XGL_DESCRIPTOR_SET descriptorSet, XGL_UINT startSlot, XGL_UINT slotCount, const XGL_BUFFER_VIEW_ATTACH_INFO* pBufferViews);
 typedef XGL_VOID (XGLAPI *xglAttachNestedDescriptorsType)(XGL_DESCRIPTOR_SET descriptorSet, XGL_UINT startSlot, XGL_UINT slotCount, const XGL_DESCRIPTOR_SET_ATTACH_INFO* pNestedDescriptorSets);
 typedef XGL_VOID (XGLAPI *xglClearDescriptorSetSlotsType)(XGL_DESCRIPTOR_SET descriptorSet, XGL_UINT startSlot, XGL_UINT slotCount);
 typedef XGL_RESULT (XGLAPI *xglCreateViewportStateType)(XGL_DEVICE device, const XGL_VIEWPORT_STATE_CREATE_INFO* pCreateInfo, XGL_VIEWPORT_STATE_OBJECT* pState);
@@ -1908,38 +1962,38 @@ typedef XGL_VOID (XGLAPI *xglCmdBindPipelineType)(XGL_CMD_BUFFER cmdBuffer, XGL_
 typedef XGL_VOID (XGLAPI *xglCmdBindPipelineDeltaType)(XGL_CMD_BUFFER cmdBuffer, XGL_PIPELINE_BIND_POINT pipelineBindPoint, XGL_PIPELINE_DELTA delta);
 typedef XGL_VOID (XGLAPI *xglCmdBindStateObjectType)(XGL_CMD_BUFFER cmdBuffer, XGL_STATE_BIND_POINT stateBindPoint, XGL_STATE_OBJECT state);
 typedef XGL_VOID (XGLAPI *xglCmdBindDescriptorSetType)(XGL_CMD_BUFFER cmdBuffer, XGL_PIPELINE_BIND_POINT pipelineBindPoint, XGL_UINT index, XGL_DESCRIPTOR_SET descriptorSet, XGL_UINT slotOffset);
-typedef XGL_VOID (XGLAPI *xglCmdBindDynamicMemoryViewType)(XGL_CMD_BUFFER cmdBuffer, XGL_PIPELINE_BIND_POINT pipelineBindPoint, const XGL_MEMORY_VIEW_ATTACH_INFO* pMemView);
-typedef XGL_VOID (XGLAPI *xglCmdBindVertexDataType)(XGL_CMD_BUFFER cmdBuffer, XGL_GPU_MEMORY mem, XGL_GPU_SIZE offset, XGL_UINT binding);
-typedef XGL_VOID (XGLAPI *xglCmdBindIndexDataType)(XGL_CMD_BUFFER cmdBuffer, XGL_GPU_MEMORY mem, XGL_GPU_SIZE offset, XGL_INDEX_TYPE indexType);
-typedef XGL_VOID (XGLAPI *xglCmdPrepareMemoryRegionsType)(XGL_CMD_BUFFER cmdBuffer, XGL_UINT transitionCount, const XGL_MEMORY_STATE_TRANSITION* pStateTransitions);
+typedef XGL_VOID (XGLAPI *xglCmdBindDynamicBufferViewType)(XGL_CMD_BUFFER cmdBuffer, XGL_PIPELINE_BIND_POINT pipelineBindPoint, const XGL_BUFFER_VIEW_ATTACH_INFO* pBufferView);
+typedef XGL_VOID (XGLAPI *xglCmdBindVertexBufferType)(XGL_CMD_BUFFER cmdBuffer, XGL_BUFFER buffer, XGL_GPU_SIZE offset, XGL_UINT binding);
+typedef XGL_VOID (XGLAPI *xglCmdBindIndexBufferType)(XGL_CMD_BUFFER cmdBuffer, XGL_BUFFER buffer, XGL_GPU_SIZE offset, XGL_INDEX_TYPE indexType);
+typedef XGL_VOID (XGLAPI *xglCmdPrepareBufferRegionsType)(XGL_CMD_BUFFER cmdBuffer, XGL_UINT transitionCount, const XGL_BUFFER_STATE_TRANSITION* pStateTransitions);
 typedef XGL_VOID (XGLAPI *xglCmdPrepareImagesType)(XGL_CMD_BUFFER cmdBuffer, XGL_UINT transitionCount, const XGL_IMAGE_STATE_TRANSITION* pStateTransitions);
 typedef XGL_VOID (XGLAPI *xglCmdDrawType)(XGL_CMD_BUFFER cmdBuffer, XGL_UINT firstVertex, XGL_UINT vertexCount, XGL_UINT firstInstance, XGL_UINT instanceCount);
 typedef XGL_VOID (XGLAPI *xglCmdDrawIndexedType)(XGL_CMD_BUFFER cmdBuffer, XGL_UINT firstIndex, XGL_UINT indexCount, XGL_INT vertexOffset, XGL_UINT firstInstance, XGL_UINT instanceCount);
-typedef XGL_VOID (XGLAPI *xglCmdDrawIndirectType)(XGL_CMD_BUFFER cmdBuffer, XGL_GPU_MEMORY mem, XGL_GPU_SIZE offset, XGL_UINT32 count, XGL_UINT32 stride);
-typedef XGL_VOID (XGLAPI *xglCmdDrawIndexedIndirectType)(XGL_CMD_BUFFER cmdBuffer, XGL_GPU_MEMORY mem, XGL_GPU_SIZE offset, XGL_UINT32 count, XGL_UINT32 stride);
+typedef XGL_VOID (XGLAPI *xglCmdDrawIndirectType)(XGL_CMD_BUFFER cmdBuffer, XGL_BUFFER buffer, XGL_GPU_SIZE offset, XGL_UINT32 count, XGL_UINT32 stride);
+typedef XGL_VOID (XGLAPI *xglCmdDrawIndexedIndirectType)(XGL_CMD_BUFFER cmdBuffer, XGL_BUFFER buffer, XGL_GPU_SIZE offset, XGL_UINT32 count, XGL_UINT32 stride);
 typedef XGL_VOID (XGLAPI *xglCmdDispatchType)(XGL_CMD_BUFFER cmdBuffer, XGL_UINT x, XGL_UINT y, XGL_UINT z);
-typedef XGL_VOID (XGLAPI *xglCmdDispatchIndirectType)(XGL_CMD_BUFFER cmdBuffer, XGL_GPU_MEMORY mem, XGL_GPU_SIZE offset);
-typedef XGL_VOID (XGLAPI *xglCmdCopyMemoryType)(XGL_CMD_BUFFER cmdBuffer, XGL_GPU_MEMORY srcMem, XGL_GPU_MEMORY destMem, XGL_UINT regionCount, const XGL_MEMORY_COPY* pRegions);
+typedef XGL_VOID (XGLAPI *xglCmdDispatchIndirectType)(XGL_CMD_BUFFER cmdBuffer, XGL_BUFFER buffer, XGL_GPU_SIZE offset);
+typedef XGL_VOID (XGLAPI *xglCmdCopyBufferType)(XGL_CMD_BUFFER cmdBuffer, XGL_BUFFER srcBuffer, XGL_BUFFER destBuffer, XGL_UINT regionCount, const XGL_BUFFER_COPY* pRegions);
 typedef XGL_VOID (XGLAPI *xglCmdCopyImageType)(XGL_CMD_BUFFER cmdBuffer, XGL_IMAGE srcImage, XGL_IMAGE destImage, XGL_UINT regionCount, const XGL_IMAGE_COPY* pRegions);
-typedef XGL_VOID (XGLAPI *xglCmdCopyMemoryToImageType)(XGL_CMD_BUFFER cmdBuffer, XGL_GPU_MEMORY srcMem, XGL_IMAGE destImage, XGL_UINT regionCount, const XGL_MEMORY_IMAGE_COPY* pRegions);
-typedef XGL_VOID (XGLAPI *xglCmdCopyImageToMemoryType)(XGL_CMD_BUFFER cmdBuffer, XGL_IMAGE srcImage, XGL_GPU_MEMORY destMem, XGL_UINT regionCount, const XGL_MEMORY_IMAGE_COPY* pRegions);
+typedef XGL_VOID (XGLAPI *xglCmdCopyBufferToImageType)(XGL_CMD_BUFFER cmdBuffer, XGL_BUFFER srcBuffer, XGL_IMAGE destImage, XGL_UINT regionCount, const XGL_BUFFER_IMAGE_COPY* pRegions);
+typedef XGL_VOID (XGLAPI *xglCmdCopyImageToBufferType)(XGL_CMD_BUFFER cmdBuffer, XGL_IMAGE srcImage, XGL_BUFFER destBuffer, XGL_UINT regionCount, const XGL_BUFFER_IMAGE_COPY* pRegions);
 typedef XGL_VOID (XGLAPI *xglCmdCloneImageDataType)(XGL_CMD_BUFFER cmdBuffer, XGL_IMAGE srcImage, XGL_IMAGE_STATE srcImageState, XGL_IMAGE destImage, XGL_IMAGE_STATE destImageState);
-typedef XGL_VOID (XGLAPI *xglCmdUpdateMemoryType)(XGL_CMD_BUFFER cmdBuffer, XGL_GPU_MEMORY destMem, XGL_GPU_SIZE destOffset, XGL_GPU_SIZE dataSize, const XGL_UINT32* pData);
-typedef XGL_VOID (XGLAPI *xglCmdFillMemoryType)(XGL_CMD_BUFFER cmdBuffer, XGL_GPU_MEMORY destMem, XGL_GPU_SIZE destOffset, XGL_GPU_SIZE fillSize, XGL_UINT32 data);
+typedef XGL_VOID (XGLAPI *xglCmdUpdateBufferType)(XGL_CMD_BUFFER cmdBuffer, XGL_BUFFER destBuffer, XGL_GPU_SIZE destOffset, XGL_GPU_SIZE dataSize, const XGL_UINT32* pData);
+typedef XGL_VOID (XGLAPI *xglCmdFillBufferType)(XGL_CMD_BUFFER cmdBuffer, XGL_BUFFER destBuffer, XGL_GPU_SIZE destOffset, XGL_GPU_SIZE fillSize, XGL_UINT32 data);
 typedef XGL_VOID (XGLAPI *xglCmdClearColorImageType)(XGL_CMD_BUFFER cmdBuffer, XGL_IMAGE image, const XGL_FLOAT color[4], XGL_UINT rangeCount, const XGL_IMAGE_SUBRESOURCE_RANGE* pRanges);
 typedef XGL_VOID (XGLAPI *xglCmdClearColorImageRawType)(XGL_CMD_BUFFER cmdBuffer, XGL_IMAGE image, const XGL_UINT32 color[4], XGL_UINT rangeCount, const XGL_IMAGE_SUBRESOURCE_RANGE* pRanges);
 typedef XGL_VOID (XGLAPI *xglCmdClearDepthStencilType)(XGL_CMD_BUFFER cmdBuffer, XGL_IMAGE image, XGL_FLOAT depth, XGL_UINT32 stencil, XGL_UINT rangeCount, const XGL_IMAGE_SUBRESOURCE_RANGE* pRanges);
 typedef XGL_VOID (XGLAPI *xglCmdResolveImageType)(XGL_CMD_BUFFER cmdBuffer, XGL_IMAGE srcImage, XGL_IMAGE destImage, XGL_UINT rectCount, const XGL_IMAGE_RESOLVE* pRects);
 typedef XGL_VOID (XGLAPI *xglCmdSetEventType)(XGL_CMD_BUFFER cmdBuffer, XGL_EVENT event);
 typedef XGL_VOID (XGLAPI *xglCmdResetEventType)(XGL_CMD_BUFFER cmdBuffer, XGL_EVENT event);
-typedef XGL_VOID (XGLAPI *xglCmdMemoryAtomicType)(XGL_CMD_BUFFER cmdBuffer, XGL_GPU_MEMORY destMem, XGL_GPU_SIZE destOffset, XGL_UINT64 srcData, XGL_ATOMIC_OP atomicOp);
+typedef XGL_VOID (XGLAPI *xglCmdBufferAtomicType)(XGL_CMD_BUFFER cmdBuffer, XGL_BUFFER destBuffer, XGL_GPU_SIZE destOffset, XGL_UINT64 srcData, XGL_ATOMIC_OP atomicOp);
 typedef XGL_VOID (XGLAPI *xglCmdBeginQueryType)(XGL_CMD_BUFFER cmdBuffer, XGL_QUERY_POOL queryPool, XGL_UINT slot, XGL_FLAGS flags);
 typedef XGL_VOID (XGLAPI *xglCmdEndQueryType)(XGL_CMD_BUFFER cmdBuffer, XGL_QUERY_POOL queryPool, XGL_UINT slot);
 typedef XGL_VOID (XGLAPI *xglCmdResetQueryPoolType)(XGL_CMD_BUFFER cmdBuffer, XGL_QUERY_POOL queryPool, XGL_UINT startQuery, XGL_UINT queryCount);
-typedef XGL_VOID (XGLAPI *xglCmdWriteTimestampType)(XGL_CMD_BUFFER cmdBuffer, XGL_TIMESTAMP_TYPE timestampType, XGL_GPU_MEMORY destMem, XGL_GPU_SIZE destOffset);
+typedef XGL_VOID (XGLAPI *xglCmdWriteTimestampType)(XGL_CMD_BUFFER cmdBuffer, XGL_TIMESTAMP_TYPE timestampType, XGL_BUFFER destBuffer, XGL_GPU_SIZE destOffset);
 typedef XGL_VOID (XGLAPI *xglCmdInitAtomicCountersType)(XGL_CMD_BUFFER cmdBuffer, XGL_PIPELINE_BIND_POINT pipelineBindPoint, XGL_UINT startCounter, XGL_UINT counterCount, const XGL_UINT32* pData);
-typedef XGL_VOID (XGLAPI *xglCmdLoadAtomicCountersType)(XGL_CMD_BUFFER cmdBuffer, XGL_PIPELINE_BIND_POINT pipelineBindPoint, XGL_UINT startCounter, XGL_UINT counterCount, XGL_GPU_MEMORY srcMem, XGL_GPU_SIZE srcOffset);
-typedef XGL_VOID (XGLAPI *xglCmdSaveAtomicCountersType)(XGL_CMD_BUFFER cmdBuffer, XGL_PIPELINE_BIND_POINT pipelineBindPoint, XGL_UINT startCounter, XGL_UINT counterCount, XGL_GPU_MEMORY destMem, XGL_GPU_SIZE destOffset);
+typedef XGL_VOID (XGLAPI *xglCmdLoadAtomicCountersType)(XGL_CMD_BUFFER cmdBuffer, XGL_PIPELINE_BIND_POINT pipelineBindPoint, XGL_UINT startCounter, XGL_UINT counterCount, XGL_BUFFER srcBuffer, XGL_GPU_SIZE srcOffset);
+typedef XGL_VOID (XGLAPI *xglCmdSaveAtomicCountersType)(XGL_CMD_BUFFER cmdBuffer, XGL_PIPELINE_BIND_POINT pipelineBindPoint, XGL_UINT startCounter, XGL_UINT 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);
 
@@ -2055,15 +2109,6 @@ XGL_RESULT XGLAPI xglPinSystemMemory(
     XGL_SIZE                                    memSize,
     XGL_GPU_MEMORY*                             pMem);
 
-XGL_RESULT XGLAPI xglRemapVirtualMemoryPages(
-    XGL_DEVICE                                  device,
-    XGL_UINT                                    rangeCount,
-    const XGL_VIRTUAL_MEMORY_REMAP_RANGE*       pRanges,
-    XGL_UINT                                    preWaitSemaphoreCount,
-    const XGL_QUEUE_SEMAPHORE*                  pPreWaitSemaphores,
-    XGL_UINT                                    postSignalSemaphoreCount,
-    const XGL_QUEUE_SEMAPHORE*                  pPostSignalSemaphores);
-
 // Multi-device functions
 
 XGL_RESULT XGLAPI xglGetMultiGpuCompatibility(
@@ -2106,7 +2151,20 @@ XGL_RESULT XGLAPI xglGetObjectInfo(
 XGL_RESULT XGLAPI xglBindObjectMemory(
     XGL_OBJECT                                  object,
     XGL_GPU_MEMORY                              mem,
-    XGL_GPU_SIZE                                offset);
+    XGL_GPU_SIZE                                memOffset);
+
+XGL_RESULT XGLAPI xglBindObjectMemoryRange(
+    XGL_OBJECT                                  object,
+    XGL_GPU_SIZE                                rangeOffset,
+    XGL_GPU_SIZE                                rangeSize,
+    XGL_GPU_MEMORY                              mem,
+    XGL_GPU_SIZE                                memOffset);
+
+XGL_RESULT XGLAPI xglBindImageMemoryRange(
+    XGL_IMAGE                                   image,
+    const XGL_IMAGE_MEMORY_BIND_INFO*           bindInfo,
+    XGL_GPU_MEMORY                              mem,
+    XGL_GPU_SIZE                                memOffset);
 
 // Fence functions
 
@@ -2179,6 +2237,20 @@ XGL_RESULT XGLAPI xglGetFormatInfo(
     XGL_SIZE*                                   pDataSize,
     XGL_VOID*                                   pData);
 
+// Buffer functions
+
+XGL_RESULT XGLAPI xglCreateBuffer(
+    XGL_DEVICE                                  device,
+    const XGL_BUFFER_CREATE_INFO*               pCreateInfo,
+    XGL_BUFFER*                                 pBuffer);
+
+// Buffer view functions
+
+XGL_RESULT XGLAPI xglCreateBufferView(
+    XGL_DEVICE                                  device,
+    const XGL_BUFFER_VIEW_CREATE_INFO*          pCreateInfo,
+    XGL_BUFFER_VIEW*                            pView);
+
 // Image functions
 
 XGL_RESULT XGLAPI xglCreateImage(
@@ -2278,11 +2350,11 @@ XGL_VOID XGLAPI xglAttachImageViewDescriptors(
     XGL_UINT                                    slotCount,
     const XGL_IMAGE_VIEW_ATTACH_INFO*           pImageViews);
 
-XGL_VOID XGLAPI xglAttachMemoryViewDescriptors(
+XGL_VOID XGLAPI xglAttachBufferViewDescriptors(
     XGL_DESCRIPTOR_SET                          descriptorSet,
     XGL_UINT                                    startSlot,
     XGL_UINT                                    slotCount,
-    const XGL_MEMORY_VIEW_ATTACH_INFO*          pMemViews);
+    const XGL_BUFFER_VIEW_ATTACH_INFO*          pBufferViews);
 
 XGL_VOID XGLAPI xglAttachNestedDescriptors(
     XGL_DESCRIPTOR_SET                          descriptorSet,
@@ -2363,29 +2435,29 @@ XGL_VOID XGLAPI xglCmdBindDescriptorSet(
     XGL_DESCRIPTOR_SET                          descriptorSet,
     XGL_UINT                                    slotOffset);
 
-XGL_VOID XGLAPI xglCmdBindDynamicMemoryView(
+XGL_VOID XGLAPI xglCmdBindDynamicBufferView(
     XGL_CMD_BUFFER                              cmdBuffer,
     XGL_PIPELINE_BIND_POINT                     pipelineBindPoint,
-    const XGL_MEMORY_VIEW_ATTACH_INFO*          pMemView);
+    const XGL_BUFFER_VIEW_ATTACH_INFO*          pBufferView);
 
 // IMG CHANGE BEGIN - support for vertex input description
-XGL_VOID XGLAPI xglCmdBindVertexData(
+XGL_VOID XGLAPI xglCmdBindVertexBuffer(
     XGL_CMD_BUFFER                              cmdBuffer,
-    XGL_GPU_MEMORY                              mem,
+    XGL_BUFFER                                  buffer,
     XGL_GPU_SIZE                                offset,
     XGL_UINT                                    binding);
 // IMG CHANGE END
 
-XGL_VOID XGLAPI xglCmdBindIndexData(
+XGL_VOID XGLAPI xglCmdBindIndexBuffer(
     XGL_CMD_BUFFER                              cmdBuffer,
-    XGL_GPU_MEMORY                              mem,
+    XGL_BUFFER                                  buffer,
     XGL_GPU_SIZE                                offset,
     XGL_INDEX_TYPE                              indexType);
 
-XGL_VOID XGLAPI xglCmdPrepareMemoryRegions(
+XGL_VOID XGLAPI xglCmdPrepareBufferRegions(
     XGL_CMD_BUFFER                              cmdBuffer,
     XGL_UINT                                    transitionCount,
-    const XGL_MEMORY_STATE_TRANSITION*          pStateTransitions);
+    const XGL_BUFFER_STATE_TRANSITION*          pStateTransitions);
 
 XGL_VOID XGLAPI xglCmdPrepareImages(
     XGL_CMD_BUFFER                              cmdBuffer,
@@ -2409,14 +2481,14 @@ XGL_VOID XGLAPI xglCmdDrawIndexed(
 
 XGL_VOID XGLAPI xglCmdDrawIndirect(
     XGL_CMD_BUFFER                              cmdBuffer,
-    XGL_GPU_MEMORY                              mem,
+    XGL_BUFFER                                  buffer,
     XGL_GPU_SIZE                                offset,
     XGL_UINT32                                  count,
     XGL_UINT32                                  stride);
 
 XGL_VOID XGLAPI xglCmdDrawIndexedIndirect(
     XGL_CMD_BUFFER                              cmdBuffer,
-    XGL_GPU_MEMORY                              mem,
+    XGL_BUFFER                                  buffer,
     XGL_GPU_SIZE                                offset,
     XGL_UINT32                                  count,
     XGL_UINT32                                  stride);
@@ -2429,15 +2501,15 @@ XGL_VOID XGLAPI xglCmdDispatch(
 
 XGL_VOID XGLAPI xglCmdDispatchIndirect(
     XGL_CMD_BUFFER                              cmdBuffer,
-    XGL_GPU_MEMORY                              mem,
+    XGL_BUFFER                                  buffer,
     XGL_GPU_SIZE                                offset);
 
-XGL_VOID XGLAPI xglCmdCopyMemory(
+XGL_VOID XGLAPI xglCmdCopyBuffer(
     XGL_CMD_BUFFER                              cmdBuffer,
-    XGL_GPU_MEMORY                              srcMem,
-    XGL_GPU_MEMORY                              destMem,
+    XGL_BUFFER                                  srcBuffer,
+    XGL_BUFFER                                  destBuffer,
     XGL_UINT                                    regionCount,
-    const XGL_MEMORY_COPY*                      pRegions);
+    const XGL_BUFFER_COPY*                      pRegions);
 
 XGL_VOID XGLAPI xglCmdCopyImage(
     XGL_CMD_BUFFER                              cmdBuffer,
@@ -2446,19 +2518,19 @@ XGL_VOID XGLAPI xglCmdCopyImage(
     XGL_UINT                                    regionCount,
     const XGL_IMAGE_COPY*                       pRegions);
 
-XGL_VOID XGLAPI xglCmdCopyMemoryToImage(
+XGL_VOID XGLAPI xglCmdCopyBufferToImage(
     XGL_CMD_BUFFER                              cmdBuffer,
-    XGL_GPU_MEMORY                              srcMem,
+    XGL_BUFFER                                  srcBuffer,
     XGL_IMAGE                                   destImage,
     XGL_UINT                                    regionCount,
-    const XGL_MEMORY_IMAGE_COPY*                pRegions);
+    const XGL_BUFFER_IMAGE_COPY*                pRegions);
 
-XGL_VOID XGLAPI xglCmdCopyImageToMemory(
+XGL_VOID XGLAPI xglCmdCopyImageToBuffer(
     XGL_CMD_BUFFER                              cmdBuffer,
     XGL_IMAGE                                   srcImage,
-    XGL_GPU_MEMORY                              destMem,
+    XGL_BUFFER                                  destBuffer,
     XGL_UINT                                    regionCount,
-    const XGL_MEMORY_IMAGE_COPY*                pRegions);
+    const XGL_BUFFER_IMAGE_COPY*                pRegions);
 
 XGL_VOID XGLAPI xglCmdCloneImageData(
     XGL_CMD_BUFFER                              cmdBuffer,
@@ -2467,16 +2539,16 @@ XGL_VOID XGLAPI xglCmdCloneImageData(
     XGL_IMAGE                                   destImage,
     XGL_IMAGE_STATE                             destImageState);
 
-XGL_VOID XGLAPI xglCmdUpdateMemory(
+XGL_VOID XGLAPI xglCmdUpdateBuffer(
     XGL_CMD_BUFFER                              cmdBuffer,
-    XGL_GPU_MEMORY                              destMem,
+    XGL_BUFFER                                  destBuffer,
     XGL_GPU_SIZE                                destOffset,
     XGL_GPU_SIZE                                dataSize,
     const XGL_UINT32*                           pData);
 
-XGL_VOID XGLAPI xglCmdFillMemory(
+XGL_VOID XGLAPI xglCmdFillBuffer(
     XGL_CMD_BUFFER                              cmdBuffer,
-    XGL_GPU_MEMORY                              destMem,
+    XGL_BUFFER                                  destBuffer,
     XGL_GPU_SIZE                                destOffset,
     XGL_GPU_SIZE                                fillSize,
     XGL_UINT32                                  data);
@@ -2518,9 +2590,9 @@ XGL_VOID XGLAPI xglCmdResetEvent(
     XGL_CMD_BUFFER                              cmdBuffer,
     XGL_EVENT                                   event);
 
-XGL_VOID XGLAPI xglCmdMemoryAtomic(
+XGL_VOID XGLAPI xglCmdBufferAtomic(
     XGL_CMD_BUFFER                              cmdBuffer,
-    XGL_GPU_MEMORY                              destMem,
+    XGL_BUFFER                                  destBuffer,
     XGL_GPU_SIZE                                destOffset,
     XGL_UINT64                                  srcData,
     XGL_ATOMIC_OP                               atomicOp);
@@ -2545,7 +2617,7 @@ XGL_VOID XGLAPI xglCmdResetQueryPool(
 XGL_VOID XGLAPI xglCmdWriteTimestamp(
     XGL_CMD_BUFFER                              cmdBuffer,
     XGL_TIMESTAMP_TYPE                          timestampType,
-    XGL_GPU_MEMORY                              destMem,
+    XGL_BUFFER                                  destBuffer,
     XGL_GPU_SIZE                                destOffset);
 
 XGL_VOID XGLAPI xglCmdInitAtomicCounters(
@@ -2560,7 +2632,7 @@ XGL_VOID XGLAPI xglCmdLoadAtomicCounters(
     XGL_PIPELINE_BIND_POINT                     pipelineBindPoint,
     XGL_UINT                                    startCounter,
     XGL_UINT                                    counterCount,
-    XGL_GPU_MEMORY                              srcMem,
+    XGL_BUFFER                                  srcBuffer,
     XGL_GPU_SIZE                                srcOffset);
 
 XGL_VOID XGLAPI xglCmdSaveAtomicCounters(
@@ -2568,7 +2640,7 @@ XGL_VOID XGLAPI xglCmdSaveAtomicCounters(
     XGL_PIPELINE_BIND_POINT                     pipelineBindPoint,
     XGL_UINT                                    startCounter,
     XGL_UINT                                    counterCount,
-    XGL_GPU_MEMORY                              destMem,
+    XGL_BUFFER                                  destBuffer,
     XGL_GPU_SIZE                                destOffset);
 
 XGL_RESULT XGLAPI xglCreateFramebuffer(
@@ -2619,11 +2691,11 @@ XGL_RESULT XGLAPI xglCreateRenderPass(
     feedback is part of the pipeline, transform feedback binding would be available
     through a new API bind point:
 
-        xglCmdBindTransformFeedbackMemoryView(
+        xglCmdBindTransformFeedbackBufferView(
                 XGL_CMD_BUFFER                              cmdBuffer,
                 XGL_PIPELINE_BIND_POINT                     pipelineBindPoint, // = GRAPHICS
                 XGL_UINT                                    index,
-                const XGL_MEMORY_VIEW_ATTACH_INFO*          pMemView);
+                const XGL_BUFFER_VIEW_ATTACH_INFO*          pBufferView);
 
     2) "Bindless" + support for non-bindless hardware.
 

diff --git a/include/xglDbg.h b/include/xglDbg.h
index 69e39d632d3f2194096041e1138b89a59c1159b9..3ea8448fb101a701fc1e766ebe4cb806886bec6e 100644 (file)
--- a/include/xglDbg.h
+++ b/include/xglDbg.h
@@ -87,6 +87,9 @@ typedef enum _XGL_DBG_OBJECT_TYPE
     XGL_DBG_OBJECT_FRAMEBUFFER            = 0x1d,
     XGL_DBG_OBJECT_RENDER_PASS            = 0x1e,
 
+    XGL_DBG_OBJECT_BUFFER,
+    XGL_DBG_OBJECT_BUFFER_VIEW,
+
     XGL_DBG_OBJECT_TYPE_BEGIN_RANGE = XGL_DBG_OBJECT_UNKNOWN,
     XGL_DBG_OBJECT_TYPE_END_RANGE   = XGL_DBG_OBJECT_RENDER_PASS,
     XGL_NUM_DBG_OBJECT_TYPE         = (XGL_DBG_OBJECT_TYPE_END_RANGE - XGL_DBG_OBJECT_TYPE_BEGIN_RANGE + 1),

diff --git a/include/xglLayer.h b/include/xglLayer.h
index 6061d899fe82a1d2dca39280a39ad6c493897d48..8c473bafc63f8d1d0eac62e5bf9330871bf56c6a 100644 (file)
--- a/include/xglLayer.h
+++ b/include/xglLayer.h
@@ -45,7 +45,6 @@ typedef struct _XGL_LAYER_DISPATCH_TABLE
     xglMapMemoryType MapMemory;
     xglUnmapMemoryType UnmapMemory;
     xglPinSystemMemoryType PinSystemMemory;
-    xglRemapVirtualMemoryPagesType RemapVirtualMemoryPages;
     xglGetMultiGpuCompatibilityType GetMultiGpuCompatibility;
     xglOpenSharedMemoryType OpenSharedMemory;
     xglOpenSharedQueueSemaphoreType OpenSharedQueueSemaphore;
@@ -54,6 +53,8 @@ typedef struct _XGL_LAYER_DISPATCH_TABLE
     xglDestroyObjectType DestroyObject;
     xglGetObjectInfoType GetObjectInfo;
     xglBindObjectMemoryType BindObjectMemory;
+    xglBindObjectMemoryRangeType BindObjectMemoryRange;
+    xglBindImageMemoryRangeType BindImageMemoryRange;
     xglCreateFenceType CreateFence;
     xglGetFenceStatusType GetFenceStatus;
     xglWaitForFencesType WaitForFences;
@@ -67,6 +68,8 @@ typedef struct _XGL_LAYER_DISPATCH_TABLE
     xglCreateQueryPoolType CreateQueryPool;
     xglGetQueryPoolResultsType GetQueryPoolResults;
     xglGetFormatInfoType GetFormatInfo;
+    xglCreateBufferType CreateBuffer;
+    xglCreateBufferViewType CreateBufferView;
     xglCreateImageType CreateImage;
     xglGetImageSubresourceInfoType GetImageSubresourceInfo;
     xglCreateImageViewType CreateImageView;
@@ -84,7 +87,7 @@ typedef struct _XGL_LAYER_DISPATCH_TABLE
     xglEndDescriptorSetUpdateType EndDescriptorSetUpdate;
     xglAttachSamplerDescriptorsType AttachSamplerDescriptors;
     xglAttachImageViewDescriptorsType AttachImageViewDescriptors;
-    xglAttachMemoryViewDescriptorsType AttachMemoryViewDescriptors;
+    xglAttachBufferViewDescriptorsType AttachBufferViewDescriptors;
     xglAttachNestedDescriptorsType AttachNestedDescriptors;
     xglClearDescriptorSetSlotsType ClearDescriptorSetSlots;
     xglCreateViewportStateType CreateViewportState;
@@ -100,10 +103,10 @@ typedef struct _XGL_LAYER_DISPATCH_TABLE
     xglCmdBindPipelineDeltaType CmdBindPipelineDelta;
     xglCmdBindStateObjectType CmdBindStateObject;
     xglCmdBindDescriptorSetType CmdBindDescriptorSet;
-    xglCmdBindDynamicMemoryViewType CmdBindDynamicMemoryView;
-    xglCmdBindVertexDataType CmdBindVertexData;
-    xglCmdBindIndexDataType CmdBindIndexData;
-    xglCmdPrepareMemoryRegionsType CmdPrepareMemoryRegions;
+    xglCmdBindDynamicBufferViewType CmdBindDynamicBufferView;
+    xglCmdBindVertexBufferType CmdBindVertexBuffer;
+    xglCmdBindIndexBufferType CmdBindIndexBuffer;
+    xglCmdPrepareBufferRegionsType CmdPrepareBufferRegions;
     xglCmdPrepareImagesType CmdPrepareImages;
     xglCmdDrawType CmdDraw;
     xglCmdDrawIndexedType CmdDrawIndexed;
@@ -111,20 +114,20 @@ typedef struct _XGL_LAYER_DISPATCH_TABLE
     xglCmdDrawIndexedIndirectType CmdDrawIndexedIndirect;
     xglCmdDispatchType CmdDispatch;
     xglCmdDispatchIndirectType CmdDispatchIndirect;
-    xglCmdCopyMemoryType CmdCopyMemory;
+    xglCmdCopyBufferType CmdCopyBuffer;
     xglCmdCopyImageType CmdCopyImage;
-    xglCmdCopyMemoryToImageType CmdCopyMemoryToImage;
-    xglCmdCopyImageToMemoryType CmdCopyImageToMemory;
+    xglCmdCopyBufferToImageType CmdCopyBufferToImage;
+    xglCmdCopyImageToBufferType CmdCopyImageToBuffer;
     xglCmdCloneImageDataType CmdCloneImageData;
-    xglCmdUpdateMemoryType CmdUpdateMemory;
-    xglCmdFillMemoryType CmdFillMemory;
+    xglCmdUpdateBufferType CmdUpdateBuffer;
+    xglCmdFillBufferType CmdFillBuffer;
     xglCmdClearColorImageType CmdClearColorImage;
     xglCmdClearColorImageRawType CmdClearColorImageRaw;
     xglCmdClearDepthStencilType CmdClearDepthStencil;
     xglCmdResolveImageType CmdResolveImage;
     xglCmdSetEventType CmdSetEvent;
     xglCmdResetEventType CmdResetEvent;
-    xglCmdMemoryAtomicType CmdMemoryAtomic;
+    xglCmdBufferAtomicType CmdBufferAtomic;
     xglCmdBeginQueryType CmdBeginQuery;
     xglCmdEndQueryType CmdEndQuery;
     xglCmdResetQueryPoolType CmdResetQueryPool;

diff --git a/xgl.py b/xgl.py
index 2297f945a2ca51a81f4715e2d7f5994a6c41d8e3..ef59f8051760cea0b0dd71f1ef32bd4f0aee4ba9 100644 (file)
--- a/xgl.py
+++ b/xgl.py
@@ -189,6 +189,8 @@ core = Extension(
         "XGL_QUEUE",
         "XGL_GPU_MEMORY",
         "XGL_OBJECT",
+        "XGL_BUFFER",
+        "XGL_BUFFER_VIEW",
         "XGL_IMAGE",
         "XGL_IMAGE_VIEW",
         "XGL_COLOR_ATTACHMENT_VIEW",
@@ -210,7 +212,7 @@ core = Extension(
         "XGL_EVENT",
         "XGL_QUERY_POOL",
         "XGL_FRAMEBUFFER",
-        "XGL_RENDER_PASS"
+        "XGL_RENDER_PASS",
     ],
     protos=[
         Proto("XGL_RESULT", "InitAndEnumerateGpus",
@@ -312,15 +314,6 @@ core = Extension(
              Param("XGL_SIZE", "memSize"),
              Param("XGL_GPU_MEMORY*", "pMem")]),
 
-        Proto("XGL_RESULT", "RemapVirtualMemoryPages",
-            [Param("XGL_DEVICE", "device"),
-             Param("XGL_UINT", "rangeCount"),
-             Param("const XGL_VIRTUAL_MEMORY_REMAP_RANGE*", "pRanges"),
-             Param("XGL_UINT", "preWaitSemaphoreCount"),
-             Param("const XGL_QUEUE_SEMAPHORE*", "pPreWaitSemaphores"),
-             Param("XGL_UINT", "postSignalSemaphoreCount"),
-             Param("const XGL_QUEUE_SEMAPHORE*", "pPostSignalSemaphores")]),
-
         Proto("XGL_RESULT", "GetMultiGpuCompatibility",
             [Param("XGL_PHYSICAL_GPU", "gpu0"),
              Param("XGL_PHYSICAL_GPU", "gpu1"),
@@ -359,7 +352,20 @@ core = Extension(
         Proto("XGL_RESULT", "BindObjectMemory",
             [Param("XGL_OBJECT", "object"),
              Param("XGL_GPU_MEMORY", "mem"),
-             Param("XGL_GPU_SIZE", "offset")]),
+             Param("XGL_GPU_SIZE", "memOffset")]),
+
+        Proto("XGL_RESULT", "BindObjectMemoryRange",
+            [Param("XGL_OBJECT", "object"),
+             Param("XGL_GPU_SIZE", "rangeOffset"),
+             Param("XGL_GPU_SIZE", "rangeSize"),
+             Param("XGL_GPU_MEMORY", "mem"),
+             Param("XGL_GPU_SIZE", "memOffset")]),
+
+        Proto("XGL_RESULT", "BindImageMemoryRange",
+            [Param("XGL_IMAGE", "image"),
+             Param("const XGL_IMAGE_MEMORY_BIND_INFO*", "bindInfo"),
+             Param("XGL_GPU_MEMORY", "mem"),
+             Param("XGL_GPU_SIZE", "memOffset")]),
 
         Proto("XGL_RESULT", "CreateFence",
             [Param("XGL_DEVICE", "device"),
@@ -422,6 +428,16 @@ core = Extension(
              Param("XGL_SIZE*", "pDataSize"),
              Param("XGL_VOID*", "pData")]),
 
+        Proto("XGL_RESULT", "CreateBuffer",
+            [Param("XGL_DEVICE", "device"),
+             Param("const XGL_BUFFER_CREATE_INFO*", "pCreateInfo"),
+             Param("XGL_BUFFER*", "pBuffer")]),
+
+        Proto("XGL_RESULT", "CreateBufferView",
+            [Param("XGL_DEVICE", "device"),
+             Param("const XGL_BUFFER_VIEW_CREATE_INFO*", "pCreateInfo"),
+             Param("XGL_BUFFER_VIEW*", "pView")]),
+
         Proto("XGL_RESULT", "CreateImage",
             [Param("XGL_DEVICE", "device"),
              Param("const XGL_IMAGE_CREATE_INFO*", "pCreateInfo"),
@@ -509,11 +525,11 @@ core = Extension(
              Param("XGL_UINT", "slotCount"),
              Param("const XGL_IMAGE_VIEW_ATTACH_INFO*", "pImageViews")]),
 
-        Proto("XGL_VOID", "AttachMemoryViewDescriptors",
+        Proto("XGL_VOID", "AttachBufferViewDescriptors",
             [Param("XGL_DESCRIPTOR_SET", "descriptorSet"),
              Param("XGL_UINT", "startSlot"),
              Param("XGL_UINT", "slotCount"),
-             Param("const XGL_MEMORY_VIEW_ATTACH_INFO*", "pMemViews")]),
+             Param("const XGL_BUFFER_VIEW_ATTACH_INFO*", "pBufferViews")]),
 
         Proto("XGL_VOID", "AttachNestedDescriptors",
             [Param("XGL_DESCRIPTOR_SET", "descriptorSet"),
@@ -588,27 +604,27 @@ core = Extension(
              Param("XGL_DESCRIPTOR_SET", "descriptorSet"),
              Param("XGL_UINT", "slotOffset")]),
 
-        Proto("XGL_VOID", "CmdBindDynamicMemoryView",
+        Proto("XGL_VOID", "CmdBindDynamicBufferView",
             [Param("XGL_CMD_BUFFER", "cmdBuffer"),
              Param("XGL_PIPELINE_BIND_POINT", "pipelineBindPoint"),
-             Param("const XGL_MEMORY_VIEW_ATTACH_INFO*", "pMemView")]),
+             Param("const XGL_BUFFER_VIEW_ATTACH_INFO*", "pBufferView")]),
 
-        Proto("XGL_VOID", "CmdBindVertexData",
+        Proto("XGL_VOID", "CmdBindVertexBuffer",
             [Param("XGL_CMD_BUFFER", "cmdBuffer"),
-             Param("XGL_GPU_MEMORY", "mem"),
+             Param("XGL_BUFFER", "buffer"),
              Param("XGL_GPU_SIZE", "offset"),
              Param("XGL_UINT", "binding")]),
 
-        Proto("XGL_VOID", "CmdBindIndexData",
+        Proto("XGL_VOID", "CmdBindIndexBuffer",
             [Param("XGL_CMD_BUFFER", "cmdBuffer"),
-             Param("XGL_GPU_MEMORY", "mem"),
+             Param("XGL_BUFFER", "buffer"),
              Param("XGL_GPU_SIZE", "offset"),
              Param("XGL_INDEX_TYPE", "indexType")]),
 
-        Proto("XGL_VOID", "CmdPrepareMemoryRegions",
+        Proto("XGL_VOID", "CmdPrepareBufferRegions",
             [Param("XGL_CMD_BUFFER", "cmdBuffer"),
              Param("XGL_UINT", "transitionCount"),
-             Param("const XGL_MEMORY_STATE_TRANSITION*", "pStateTransitions")]),
+             Param("const XGL_BUFFER_STATE_TRANSITION*", "pStateTransitions")]),
 
         Proto("XGL_VOID", "CmdPrepareImages",
             [Param("XGL_CMD_BUFFER", "cmdBuffer"),
@@ -632,14 +648,14 @@ core = Extension(
 
         Proto("XGL_VOID", "CmdDrawIndirect",
             [Param("XGL_CMD_BUFFER", "cmdBuffer"),
-             Param("XGL_GPU_MEMORY", "mem"),
+             Param("XGL_BUFFER", "buffer"),
              Param("XGL_GPU_SIZE", "offset"),
              Param("XGL_UINT32", "count"),
              Param("XGL_UINT32", "stride")]),
 
         Proto("XGL_VOID", "CmdDrawIndexedIndirect",
             [Param("XGL_CMD_BUFFER", "cmdBuffer"),
-             Param("XGL_GPU_MEMORY", "mem"),
+             Param("XGL_BUFFER", "buffer"),
              Param("XGL_GPU_SIZE", "offset"),
              Param("XGL_UINT32", "count"),
              Param("XGL_UINT32", "stride")]),
@@ -652,15 +668,15 @@ core = Extension(
 
         Proto("XGL_VOID", "CmdDispatchIndirect",
             [Param("XGL_CMD_BUFFER", "cmdBuffer"),
-             Param("XGL_GPU_MEMORY", "mem"),
+             Param("XGL_BUFFER", "buffer"),
              Param("XGL_GPU_SIZE", "offset")]),
 
-        Proto("XGL_VOID", "CmdCopyMemory",
+        Proto("XGL_VOID", "CmdCopyBuffer",
             [Param("XGL_CMD_BUFFER", "cmdBuffer"),
-             Param("XGL_GPU_MEMORY", "srcMem"),
-             Param("XGL_GPU_MEMORY", "destMem"),
+             Param("XGL_BUFFER", "srcBuffer"),
+             Param("XGL_BUFFER", "destBuffer"),
              Param("XGL_UINT", "regionCount"),
-             Param("const XGL_MEMORY_COPY*", "pRegions")]),
+             Param("const XGL_BUFFER_COPY*", "pRegions")]),
 
         Proto("XGL_VOID", "CmdCopyImage",
             [Param("XGL_CMD_BUFFER", "cmdBuffer"),
@@ -669,19 +685,19 @@ core = Extension(
              Param("XGL_UINT", "regionCount"),
              Param("const XGL_IMAGE_COPY*", "pRegions")]),
 
-        Proto("XGL_VOID", "CmdCopyMemoryToImage",
+        Proto("XGL_VOID", "CmdCopyBufferToImage",
             [Param("XGL_CMD_BUFFER", "cmdBuffer"),
-             Param("XGL_GPU_MEMORY", "srcMem"),
+             Param("XGL_BUFFER", "srcBuffer"),
              Param("XGL_IMAGE", "destImage"),
              Param("XGL_UINT", "regionCount"),
-             Param("const XGL_MEMORY_IMAGE_COPY*", "pRegions")]),
+             Param("const XGL_BUFFER_IMAGE_COPY*", "pRegions")]),
 
-        Proto("XGL_VOID", "CmdCopyImageToMemory",
+        Proto("XGL_VOID", "CmdCopyImageToBuffer",
             [Param("XGL_CMD_BUFFER", "cmdBuffer"),
              Param("XGL_IMAGE", "srcImage"),
-             Param("XGL_GPU_MEMORY", "destMem"),
+             Param("XGL_BUFFER", "destBuffer"),
              Param("XGL_UINT", "regionCount"),
-             Param("const XGL_MEMORY_IMAGE_COPY*", "pRegions")]),
+             Param("const XGL_BUFFER_IMAGE_COPY*", "pRegions")]),
 
         Proto("XGL_VOID", "CmdCloneImageData",
             [Param("XGL_CMD_BUFFER", "cmdBuffer"),
@@ -690,16 +706,16 @@ core = Extension(
              Param("XGL_IMAGE", "destImage"),
              Param("XGL_IMAGE_STATE", "destImageState")]),
 
-        Proto("XGL_VOID", "CmdUpdateMemory",
+        Proto("XGL_VOID", "CmdUpdateBuffer",
             [Param("XGL_CMD_BUFFER", "cmdBuffer"),
-             Param("XGL_GPU_MEMORY", "destMem"),
+             Param("XGL_BUFFER", "destBuffer"),
              Param("XGL_GPU_SIZE", "destOffset"),
              Param("XGL_GPU_SIZE", "dataSize"),
              Param("const XGL_UINT32*", "pData")]),
 
-        Proto("XGL_VOID", "CmdFillMemory",
+        Proto("XGL_VOID", "CmdFillBuffer",
             [Param("XGL_CMD_BUFFER", "cmdBuffer"),
-             Param("XGL_GPU_MEMORY", "destMem"),
+             Param("XGL_BUFFER", "destBuffer"),
              Param("XGL_GPU_SIZE", "destOffset"),
              Param("XGL_GPU_SIZE", "fillSize"),
              Param("XGL_UINT32", "data")]),
@@ -741,9 +757,9 @@ core = Extension(
             [Param("XGL_CMD_BUFFER", "cmdBuffer"),
              Param("XGL_EVENT", "event")]),
 
-        Proto("XGL_VOID", "CmdMemoryAtomic",
+        Proto("XGL_VOID", "CmdBufferAtomic",
             [Param("XGL_CMD_BUFFER", "cmdBuffer"),
-             Param("XGL_GPU_MEMORY", "destMem"),
+             Param("XGL_BUFFER", "destBuffer"),
              Param("XGL_GPU_SIZE", "destOffset"),
              Param("XGL_UINT64", "srcData"),
              Param("XGL_ATOMIC_OP", "atomicOp")]),
@@ -768,7 +784,7 @@ core = Extension(
         Proto("XGL_VOID", "CmdWriteTimestamp",
             [Param("XGL_CMD_BUFFER", "cmdBuffer"),
              Param("XGL_TIMESTAMP_TYPE", "timestampType"),
-             Param("XGL_GPU_MEMORY", "destMem"),
+             Param("XGL_BUFFER", "destBuffer"),
              Param("XGL_GPU_SIZE", "destOffset")]),
 
         Proto("XGL_VOID", "CmdInitAtomicCounters",
@@ -783,7 +799,7 @@ core = Extension(
              Param("XGL_PIPELINE_BIND_POINT", "pipelineBindPoint"),
              Param("XGL_UINT", "startCounter"),
              Param("XGL_UINT", "counterCount"),
-             Param("XGL_GPU_MEMORY", "srcMem"),
+             Param("XGL_BUFFER", "srcBuffer"),
              Param("XGL_GPU_SIZE", "srcOffset")]),
 
         Proto("XGL_VOID", "CmdSaveAtomicCounters",
@@ -791,7 +807,7 @@ core = Extension(
              Param("XGL_PIPELINE_BIND_POINT", "pipelineBindPoint"),
              Param("XGL_UINT", "startCounter"),
              Param("XGL_UINT", "counterCount"),
-             Param("XGL_GPU_MEMORY", "destMem"),
+             Param("XGL_BUFFER", "destBuffer"),
              Param("XGL_GPU_SIZE", "destOffset")]),
 
         Proto("XGL_RESULT", "CreateFramebuffer",