demos/tri: allocate vertex buffer

diff --git a/demos/tri.c b/demos/tri.c
index c347136..f0c9cf8 100644 (file)
--- a/demos/tri.c
+++ b/demos/tri.c
@@ -38,6 +38,11 @@ struct demo {
         XGL_IMAGE_VIEW view;
     } textures[DEMO_TEXTURE_COUNT];
 
+    struct {
+        XGL_GPU_MEMORY mem;
+        XGL_MEMORY_VIEW_ATTACH_INFO view;
+    } vertices;
+
     XGL_DESCRIPTOR_SET dset;
 
     XGL_PIPELINE pipeline;
@@ -279,12 +284,57 @@ static void demo_prepare_textures(struct demo *demo)
     }
 }
 
+static void demo_prepare_vertices(struct demo *demo)
+{
+    const float vb[3][5] = {
+        /*      position             texcoord */
+        { -1.0f, -1.0f, -1.0f,      0.0f, 0.0f },
+        {  1.0f, -1.0f, -1.0f,      1.0f, 0.0f },
+        {  0.0f,  1.0f,  1.0f,      0.5f, 1.0f },
+    };
+    const XGL_MEMORY_ALLOC_INFO mem_alloc = {
+        .sType = XGL_STRUCTURE_TYPE_MEMORY_ALLOC_INFO,
+        .pNext = NULL,
+        .allocationSize = sizeof(vb),
+        .alignment = 0,
+        .flags = 0,
+        .heapCount = 1,
+        .heaps[0] = 0,
+        .memPriority = XGL_MEMORY_PRIORITY_NORMAL,
+    };
+    XGL_RESULT err;
+    void *data;
+
+    memset(&demo->vertices, 0, sizeof(demo->vertices));
+
+    err = xglAllocMemory(demo->device, &mem_alloc, &demo->vertices.mem);
+    assert(!err);
+
+    err = xglMapMemory(demo->vertices.mem, 0, &data);
+    assert(!err);
+
+    memcpy(data, vb, sizeof(vb));
+
+    err = xglUnmapMemory(demo->vertices.mem);
+    assert(!err);
+
+    demo->vertices.view.sType = XGL_STRUCTURE_TYPE_MEMORY_VIEW_ATTACH_INFO;
+    demo->vertices.view.pNext = NULL;
+    demo->vertices.view.mem = demo->vertices.mem;
+    demo->vertices.view.offset = 0;
+    demo->vertices.view.range = sizeof(vb);
+    demo->vertices.view.stride = sizeof(vb[0]);
+    demo->vertices.view.format.channelFormat = XGL_CH_FMT_UNDEFINED;
+    demo->vertices.view.format.numericFormat = XGL_NUM_FMT_UNDEFINED;
+    demo->vertices.view.state = XGL_MEMORY_STATE_GRAPHICS_SHADER_READ_ONLY;
+}
+
 static void demo_prepare_descriptor_set(struct demo *demo)
 {
     const XGL_DESCRIPTOR_SET_CREATE_INFO descriptor_set = {
         .sType = XGL_STRUCTURE_TYPE_DESCRIPTOR_SET_CREATE_INFO,
         .pNext = NULL,
-        .slots = DEMO_TEXTURE_COUNT * 2,
+        .slots = DEMO_TEXTURE_COUNT * 2 + 1,
     };
     XGL_RESULT err;
     XGL_UINT i;
@@ -293,7 +343,7 @@ static void demo_prepare_descriptor_set(struct demo *demo)
     assert(!err);
 
     xglBeginDescriptorSetUpdate(demo->dset);
-    xglClearDescriptorSetSlots(demo->dset, 0, DEMO_TEXTURE_COUNT * 2);
+    xglClearDescriptorSetSlots(demo->dset, 0, DEMO_TEXTURE_COUNT * 2 + 1);
 
     for (i = 0; i < DEMO_TEXTURE_COUNT; i++) {
         const XGL_IMAGE_VIEW_ATTACH_INFO image_view = {
@@ -309,6 +359,8 @@ static void demo_prepare_descriptor_set(struct demo *demo)
                 &image_view);
     }
 
+    xglAttachMemoryViewDescriptors(demo->dset, 2 * i, 1, &demo->vertices.view);
+
     xglEndDescriptorSetUpdate(demo->dset);
 }
 
@@ -455,7 +507,8 @@ static void demo_prepare_pipeline(struct demo *demo)
     XGL_PIPELINE_DB_STATE_CREATE_INFO db;
     XGL_PIPELINE_SHADER_STAGE_CREATE_INFO vs;
     XGL_PIPELINE_SHADER_STAGE_CREATE_INFO fs;
-    XGL_DESCRIPTOR_SLOT_INFO fs_slots[DEMO_TEXTURE_COUNT * 2];
+    XGL_DESCRIPTOR_SLOT_INFO vs_slots[DEMO_TEXTURE_COUNT * 2 + 1];
+    XGL_DESCRIPTOR_SLOT_INFO fs_slots[DEMO_TEXTURE_COUNT * 2 + 1];
     XGL_RESULT err;
     XGL_UINT i;
 
@@ -477,23 +530,32 @@ static void demo_prepare_pipeline(struct demo *demo)
     memset(&db, 0, sizeof(db));
     db.sType = XGL_STRUCTURE_TYPE_PIPELINE_DB_STATE_CREATE_INFO;
 
+    memset(&vs_slots, 0, sizeof(vs_slots));
+    vs_slots[2 * DEMO_TEXTURE_COUNT].slotObjectType = XGL_SLOT_SHADER_RESOURCE;
+    vs_slots[2 * DEMO_TEXTURE_COUNT].shaderEntityIndex = 0;
+
+    memset(&fs_slots, 0, sizeof(fs_slots));
+    for (i = 0; i < DEMO_TEXTURE_COUNT; i++) {
+        fs_slots[2 * i].slotObjectType = XGL_SLOT_SHADER_SAMPLER;
+        fs_slots[2 * i].shaderEntityIndex = i;
+        fs_slots[2 * i + 1].slotObjectType = XGL_SLOT_SHADER_RESOURCE;
+        fs_slots[2 * i + 1].shaderEntityIndex = i;
+    }
+
     memset(&vs, 0, sizeof(vs));
     vs.sType = XGL_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
     vs.shader.stage = XGL_SHADER_STAGE_VERTEX;
     vs.shader.shader = demo_prepare_vs(demo);
+    vs.shader.descriptorSetMapping[0].descriptorCount =
+        DEMO_TEXTURE_COUNT * 2 + 1;
+    vs.shader.descriptorSetMapping[0].pDescriptorInfo = vs_slots;
 
     memset(&fs, 0, sizeof(fs));
     fs.sType = XGL_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
     fs.shader.stage = XGL_SHADER_STAGE_FRAGMENT;
     fs.shader.shader = demo_prepare_fs(demo);
-
-    for (i = 0; i < DEMO_TEXTURE_COUNT; i++) {
-        fs_slots[2 * i].slotObjectType = XGL_SLOT_SHADER_SAMPLER;
-        fs_slots[2 * i].shaderEntityIndex = i;
-        fs_slots[2 * i + 1].slotObjectType = XGL_SLOT_SHADER_RESOURCE;
-        fs_slots[2 * i + 1].shaderEntityIndex = i;
-    }
-    fs.shader.descriptorSetMapping[0].descriptorCount = DEMO_TEXTURE_COUNT * 2;
+    fs.shader.descriptorSetMapping[0].descriptorCount =
+        DEMO_TEXTURE_COUNT * 2 + 1;
     fs.shader.descriptorSetMapping[0].pDescriptorInfo = fs_slots;
 
     pipeline.pNext = (const XGL_VOID *) &ia;
@@ -572,6 +634,7 @@ static void demo_prepare(struct demo *demo)
 
     demo_prepare_buffers(demo);
     demo_prepare_textures(demo);
+    demo_prepare_vertices(demo);
     demo_prepare_descriptor_set(demo);
     demo_prepare_pipeline(demo);
     demo_prepare_dynamic_states(demo);
@@ -739,6 +802,8 @@ static void demo_cleanup(struct demo *demo)
 
     xglDestroyObject(demo->dset);
 
+    xglFreeMemory(demo->vertices.mem);
+
     for (i = 0; i < DEMO_TEXTURE_COUNT; i++) {
         xglDestroyObject(demo->textures[i].view);
         xglDestroyObject(demo->textures[i].image);