struct {
XGL_BUFFER buf;
- XGL_GPU_MEMORY mem;
+ XGL_UINT num_mem;
+ XGL_GPU_MEMORY *mem;
XGL_BUFFER_VIEW view;
XGL_BUFFER_VIEW_ATTACH_INFO attach;
} uniform_data;
mat4x4_rotate(demo->model_matrix, Model, 0.0f, 1.0f, 0.0f, degreesToRadians(demo->spin_angle));
mat4x4_mul(MVP, VP, demo->model_matrix);
- err = xglMapMemory(demo->uniform_data.mem, 0, (XGL_VOID **) &pData);
+ assert(demo->uniform_data.num_mem == 1);
+ err = xglMapMemory(demo->uniform_data.mem[0], 0, (XGL_VOID **) &pData);
assert(!err);
memcpy(pData, (const void*) &MVP[0][0], matrixSize);
- err = xglUnmapMemory(demo->uniform_data.mem);
+ err = xglUnmapMemory(demo->uniform_data.mem[0]);
assert(!err);
}
.usage = XGL_IMAGE_USAGE_DEPTH_STENCIL_BIT,
.flags = 0,
};
+ XGL_MEMORY_ALLOC_IMAGE_INFO img_alloc = {
+ .sType = XGL_STRUCTURE_TYPE_MEMORY_ALLOC_IMAGE_INFO,
+ .pNext = NULL,
+ };
XGL_MEMORY_ALLOC_INFO mem_alloc = {
.sType = XGL_STRUCTURE_TYPE_MEMORY_ALLOC_INFO,
- .pNext = NULL,
+ .pNext = &img_alloc,
.allocationSize = 0,
.alignment = 0,
.flags = 0,
};
XGL_MEMORY_REQUIREMENTS *mem_reqs;
XGL_SIZE mem_reqs_size = sizeof(XGL_MEMORY_REQUIREMENTS);
+ XGL_IMAGE_MEMORY_REQUIREMENTS img_reqs;
+ XGL_SIZE img_reqs_size = sizeof(XGL_IMAGE_MEMORY_REQUIREMENTS);
XGL_RESULT err;
XGL_UINT num_allocations = 0;
XGL_SIZE num_alloc_size = sizeof(num_allocations);
XGL_INFO_TYPE_MEMORY_REQUIREMENTS,
&mem_reqs_size, mem_reqs);
assert(!err && mem_reqs_size == num_allocations * sizeof(XGL_MEMORY_REQUIREMENTS));
-
+ err = xglGetObjectInfo(demo->depth.image,
+ XGL_INFO_TYPE_IMAGE_MEMORY_REQUIREMENTS,
+ &img_reqs_size, &img_reqs);
+ assert(!err && img_reqs_size == sizeof(XGL_IMAGE_MEMORY_REQUIREMENTS));
+ img_alloc.usage = img_reqs.usage;
+ img_alloc.formatClass = img_reqs.formatClass;
+ img_alloc.samples = img_reqs.samples;
for (XGL_UINT i = 0; i < num_allocations; i ++) {
mem_alloc.allocationSize = mem_reqs[i].size;
mem_alloc.alignment = mem_reqs[i].alignment;
.usage = XGL_IMAGE_USAGE_SHADER_ACCESS_READ_BIT,
.flags = 0,
};
+ XGL_MEMORY_ALLOC_IMAGE_INFO img_alloc = {
+ .sType = XGL_STRUCTURE_TYPE_MEMORY_ALLOC_IMAGE_INFO,
+ .pNext = NULL,
+ };
XGL_MEMORY_ALLOC_INFO mem_alloc = {
.sType = XGL_STRUCTURE_TYPE_MEMORY_ALLOC_INFO,
- .pNext = NULL,
+ .pNext = &img_alloc,
.allocationSize = 0,
.alignment = 0,
.flags = 0,
XGL_MEMORY_REQUIREMENTS *mem_reqs;
XGL_SIZE mem_reqs_size = sizeof(XGL_MEMORY_REQUIREMENTS);
+ XGL_IMAGE_MEMORY_REQUIREMENTS img_reqs;
+ XGL_SIZE img_reqs_size = sizeof(XGL_IMAGE_MEMORY_REQUIREMENTS);
XGL_UINT num_allocations = 0;
XGL_SIZE num_alloc_size = sizeof(num_allocations);
XGL_INFO_TYPE_MEMORY_REQUIREMENTS,
&mem_reqs_size, mem_reqs);
assert(!err && mem_reqs_size == num_allocations * sizeof(XGL_MEMORY_REQUIREMENTS));
-
+ err = xglGetObjectInfo(demo->textures[i].image,
+ XGL_INFO_TYPE_IMAGE_MEMORY_REQUIREMENTS,
+ &img_reqs_size, &img_reqs);
+ assert(!err && img_reqs_size == sizeof(XGL_IMAGE_MEMORY_REQUIREMENTS));
+ img_alloc.usage = img_reqs.usage;
+ img_alloc.formatClass = img_reqs.formatClass;
+ img_alloc.samples = img_reqs.samples;
for (XGL_UINT j = 0; j < num_allocations; j ++) {
mem_alloc.allocationSize = mem_reqs[j].size;
mem_alloc.alignment = mem_reqs[j].alignment;
{
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_MEMORY_ALLOC_BUFFER_INFO buf_alloc = {
+ .sType = XGL_STRUCTURE_TYPE_MEMORY_ALLOC_BUFFER_INFO,
+ .pNext = NULL,
+ };
+ XGL_MEMORY_ALLOC_INFO alloc_info = {
+ .sType = XGL_STRUCTURE_TYPE_MEMORY_ALLOC_INFO,
+ .pNext = &buf_alloc,
+ .allocationSize = 0,
+ .alignment = 0,
+ .flags = 0,
+ .heapCount = 0,
+ .memPriority = XGL_MEMORY_PRIORITY_NORMAL,
+ };
+ XGL_MEMORY_REQUIREMENTS *mem_reqs;
XGL_SIZE mem_reqs_size = sizeof(XGL_MEMORY_REQUIREMENTS);
+ XGL_BUFFER_MEMORY_REQUIREMENTS buf_reqs;
+ XGL_SIZE buf_reqs_size = sizeof(XGL_BUFFER_MEMORY_REQUIREMENTS);
+ XGL_UINT num_allocations = 0;
+ XGL_SIZE num_alloc_size = sizeof(num_allocations);
XGL_UINT8 *pData;
int i;
mat4x4 MVP, VP;
err = xglCreateBuffer(demo->device, &buf_info, &demo->uniform_data.buf);
assert(!err);
+ err = xglGetObjectInfo(demo->uniform_data.buf,
+ XGL_INFO_TYPE_MEMORY_ALLOCATION_COUNT,
+ &num_alloc_size, &num_allocations);
+ assert(!err && num_alloc_size == sizeof(num_allocations));
+ mem_reqs = malloc(num_allocations * sizeof(XGL_MEMORY_REQUIREMENTS));
+ demo->uniform_data.mem = malloc(num_allocations * sizeof(XGL_GPU_MEMORY));
+ demo->uniform_data.num_mem = num_allocations;
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 = mem_reqs.size;
- alloc_info.alignment = mem_reqs.alignment;
- alloc_info.heapCount = mem_reqs.heapCount;
- XGL_UINT heapInfo[mem_reqs.heapCount];
- alloc_info.pHeaps = (const XGL_UINT *)heapInfo;
- memcpy(heapInfo, mem_reqs.pHeaps,
- sizeof(mem_reqs.pHeaps[0]) * mem_reqs.heapCount);
- alloc_info.memPriority = XGL_MEMORY_PRIORITY_NORMAL;
-
- err = xglAllocMemory(demo->device, &alloc_info, &demo->uniform_data.mem);
- assert(!err);
+ &mem_reqs_size, mem_reqs);
+ assert(!err && mem_reqs_size == num_allocations * sizeof(*mem_reqs));
+ err = xglGetObjectInfo(demo->uniform_data.buf,
+ XGL_INFO_TYPE_BUFFER_MEMORY_REQUIREMENTS,
+ &buf_reqs_size, &buf_reqs);
+ assert(!err && buf_reqs_size == sizeof(XGL_BUFFER_MEMORY_REQUIREMENTS));
+ buf_alloc.usage = buf_reqs.usage;
+ for (XGL_UINT i = 0; i < num_allocations; i ++) {
+ alloc_info.allocationSize = mem_reqs[i].size;
+ alloc_info.alignment = mem_reqs[i].alignment;
+ alloc_info.heapCount = mem_reqs[i].heapCount;
+ XGL_UINT heapInfo[mem_reqs[i].heapCount];
+ alloc_info.pHeaps = (const XGL_UINT *)heapInfo;
+ memcpy(heapInfo, mem_reqs[i].pHeaps,
+ sizeof(mem_reqs[i].pHeaps[0]) * mem_reqs[i].heapCount);
- err = xglMapMemory(demo->uniform_data.mem, 0, (XGL_VOID **) &pData);
- assert(!err);
+ err = xglAllocMemory(demo->device, &alloc_info, &(demo->uniform_data.mem[i]));
+ assert(!err);
- memcpy(pData, &data, alloc_info.allocationSize);
+ err = xglMapMemory(demo->uniform_data.mem[i], 0, (XGL_VOID **) &pData);
+ assert(!err);
- err = xglUnmapMemory(demo->uniform_data.mem);
- assert(!err);
+ memcpy(pData, &data, alloc_info.allocationSize);
- err = xglBindObjectMemory(demo->uniform_data.buf, 0,
- demo->uniform_data.mem, 0);
- assert(!err);
+ err = xglUnmapMemory(demo->uniform_data.mem[i]);
+ assert(!err);
+
+ err = xglBindObjectMemory(demo->uniform_data.buf, i,
+ demo->uniform_data.mem[i], 0);
+ assert(!err);
+ }
memset(&view_info, 0, sizeof(view_info));
view_info.sType = XGL_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO;
xglDestroyObject(demo->depth.image);
for (j = 0; j < demo->depth.num_mem; j++)
xglFreeMemory(demo->depth.mem[j]);
+ xglDestroyObject(demo->uniform_data.buf);
+ for (j = 0; j < demo->uniform_data.num_mem; j++)
+ xglFreeMemory(demo->uniform_data.mem[j]);
for (i = 0; i < DEMO_BUFFER_COUNT; i++) {
xglDestroyObject(demo->buffers[i].fence);
struct {
XGL_BUFFER buf;
- XGL_GPU_MEMORY mem;
+ XGL_UINT num_mem;
+ XGL_GPU_MEMORY *mem;
XGL_PIPELINE_VERTEX_INPUT_CREATE_INFO vi;
XGL_VERTEX_INPUT_BINDING_DESCRIPTION vi_bindings[1];
err = xglWaitForFences(demo->device, 1, &fence, XGL_TRUE, ~((XGL_UINT64) 0));
assert(err == XGL_SUCCESS || err == XGL_ERROR_UNAVAILABLE);
- static const uint32_t NUM_MEM_REFS = 5;
- XGL_MEMORY_REF memRefs[NUM_MEM_REFS];
- memRefs[0].mem = demo->depth.mem;
- memRefs[0].flags = 0;
- memRefs[1].mem = demo->textures[0].mem;
- memRefs[1].flags = 0;
- memRefs[2].mem = demo->buffers[0].mem;
- memRefs[2].flags = 0;
- memRefs[3].mem = demo->buffers[1].mem;
- memRefs[3].flags = 0;
- memRefs[4].mem = demo->vertices.mem;
- memRefs[4].flags = 0;
+ XGL_UINT i, idx = 0;
+ XGL_MEMORY_REF *memRefs;
+ memRefs = malloc(sizeof(XGL_MEMORY_REF) * (2 + demo->depth.num_mem +
+ demo->textures[0].num_mem + demo->vertices.num_mem));
+ for (i = 0; i < demo->depth.num_mem; i++, idx++) {
+ memRefs[idx].mem = demo->depth.mem[i];
+ memRefs[idx].flags = 0;
+ }
+ for (i = 0; i < demo->textures[0].num_mem; i++, idx++) {
+ memRefs[idx].mem = demo->textures[0].mem[i];
+ memRefs[idx].flags = 0;
+ }
+ memRefs[idx].mem = demo->buffers[0].mem;
+ memRefs[idx++].flags = 0;
+ memRefs[idx].mem = demo->buffers[1].mem;
+ memRefs[idx++].flags = 0;
+ for (i = 0; i < demo->vertices.num_mem; i++, idx++) {
+ memRefs[idx].mem = demo->vertices.mem[i];
+ memRefs[idx].flags = 0;
+ }
err = xglQueueSubmit(demo->queue, 1, &demo->cmd,
- NUM_MEM_REFS, memRefs, XGL_NULL_HANDLE);
+ idx, memRefs, XGL_NULL_HANDLE);
assert(!err);
err = xglWsiX11QueuePresent(demo->queue, &present, fence);
.usage = XGL_IMAGE_USAGE_DEPTH_STENCIL_BIT,
.flags = 0,
};
+ XGL_MEMORY_ALLOC_IMAGE_INFO img_alloc = {
+ .sType = XGL_STRUCTURE_TYPE_MEMORY_ALLOC_IMAGE_INFO,
+ .pNext = NULL,
+ };
XGL_MEMORY_ALLOC_INFO mem_alloc = {
.sType = XGL_STRUCTURE_TYPE_MEMORY_ALLOC_INFO,
- .pNext = NULL,
+ .pNext = &img_alloc,
.allocationSize = 0,
.alignment = 0,
.flags = 0,
XGL_MEMORY_REQUIREMENTS *mem_reqs;
XGL_SIZE mem_reqs_size = sizeof(XGL_MEMORY_REQUIREMENTS);
+ XGL_IMAGE_MEMORY_REQUIREMENTS img_reqs;
+ XGL_SIZE img_reqs_size = sizeof(XGL_IMAGE_MEMORY_REQUIREMENTS);
XGL_RESULT err;
XGL_UINT num_allocations = 0;
XGL_SIZE num_alloc_size = sizeof(num_allocations);
XGL_INFO_TYPE_MEMORY_REQUIREMENTS,
&mem_reqs_size, mem_reqs);
assert(!err && mem_reqs_size == num_allocations * sizeof(XGL_MEMORY_REQUIREMENTS));
-
+ err = xglGetObjectInfo(demo->depth.image,
+ XGL_INFO_TYPE_IMAGE_MEMORY_REQUIREMENTS,
+ &img_reqs_size, &img_reqs);
+ assert(!err && img_reqs_size == sizeof(XGL_IMAGE_MEMORY_REQUIREMENTS));
+ img_alloc.usage = img_reqs.usage;
+ img_alloc.formatClass = img_reqs.formatClass;
+ img_alloc.samples = img_reqs.samples;
for (XGL_UINT i = 0; i < num_allocations; i ++) {
mem_alloc.allocationSize = mem_reqs[i].size;
mem_alloc.alignment = mem_reqs[i].alignment;
.usage = XGL_IMAGE_USAGE_SHADER_ACCESS_READ_BIT,
.flags = 0,
};
+ XGL_MEMORY_ALLOC_IMAGE_INFO img_alloc = {
+ .sType = XGL_STRUCTURE_TYPE_MEMORY_ALLOC_IMAGE_INFO,
+ .pNext = NULL,
+ };
XGL_MEMORY_ALLOC_INFO mem_alloc = {
.sType = XGL_STRUCTURE_TYPE_MEMORY_ALLOC_INFO,
- .pNext = NULL,
+ .pNext = &img_alloc,
.allocationSize = 0,
.alignment = 0,
.flags = 0,
XGL_MEMORY_REQUIREMENTS *mem_reqs;
XGL_SIZE mem_reqs_size = sizeof(XGL_MEMORY_REQUIREMENTS);
+ XGL_IMAGE_MEMORY_REQUIREMENTS img_reqs;
+ XGL_SIZE img_reqs_size = sizeof(XGL_IMAGE_MEMORY_REQUIREMENTS);
XGL_UINT num_allocations = 0;
XGL_SIZE num_alloc_size = sizeof(num_allocations);
XGL_INFO_TYPE_MEMORY_REQUIREMENTS,
&mem_reqs_size, mem_reqs);
assert(!err && mem_reqs_size == num_allocations * sizeof(XGL_MEMORY_REQUIREMENTS));
-
+ err = xglGetObjectInfo(demo->textures[i].image,
+ XGL_INFO_TYPE_IMAGE_MEMORY_REQUIREMENTS,
+ &img_reqs_size, &img_reqs);
+ assert(!err && img_reqs_size == sizeof(XGL_IMAGE_MEMORY_REQUIREMENTS));
+ img_alloc.usage = img_reqs.usage;
+ img_alloc.formatClass = img_reqs.formatClass;
+ img_alloc.samples = img_reqs.samples;
for (XGL_UINT j = 0; j < num_allocations; j ++) {
mem_alloc.allocationSize = mem_reqs[j].size;
mem_alloc.alignment = mem_reqs[j].alignment;
.usage = XGL_BUFFER_USAGE_VERTEX_FETCH_BIT,
.flags = 0,
};
+ XGL_MEMORY_ALLOC_BUFFER_INFO buf_alloc = {
+ .sType = XGL_STRUCTURE_TYPE_MEMORY_ALLOC_BUFFER_INFO,
+ .pNext = NULL,
+ };
XGL_MEMORY_ALLOC_INFO mem_alloc = {
.sType = XGL_STRUCTURE_TYPE_MEMORY_ALLOC_INFO,
- .pNext = NULL,
+ .pNext = &buf_alloc,
.allocationSize = 0,
.alignment = 0,
.flags = 0,
.pHeaps = 0,
.memPriority = XGL_MEMORY_PRIORITY_NORMAL,
};
- XGL_MEMORY_REQUIREMENTS mem_reqs;
+ XGL_MEMORY_REQUIREMENTS *mem_reqs;
XGL_SIZE mem_reqs_size = sizeof(XGL_MEMORY_REQUIREMENTS);
+ XGL_BUFFER_MEMORY_REQUIREMENTS buf_reqs;
+ XGL_SIZE buf_reqs_size = sizeof(XGL_BUFFER_MEMORY_REQUIREMENTS);
+ XGL_UINT num_allocations = 0;
+ XGL_SIZE num_alloc_size = sizeof(num_allocations);
XGL_RESULT err;
void *data;
err = xglCreateBuffer(demo->device, &buf_info, &demo->vertices.buf);
assert(!err);
+ err = xglGetObjectInfo(demo->vertices.buf,
+ XGL_INFO_TYPE_MEMORY_ALLOCATION_COUNT,
+ &num_alloc_size, &num_allocations);
+ assert(!err && num_alloc_size == sizeof(num_allocations));
+ mem_reqs = malloc(num_allocations * sizeof(XGL_MEMORY_REQUIREMENTS));
+ demo->vertices.mem = malloc(num_allocations * sizeof(XGL_GPU_MEMORY));
+ demo->vertices.num_mem = num_allocations;
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;
- mem_alloc.pHeaps = mem_reqs.pHeaps;
- memcpy((XGL_UINT *)mem_alloc.pHeaps, mem_reqs.pHeaps,
- sizeof(mem_reqs.pHeaps[0]) * mem_reqs.heapCount);
-
- err = xglAllocMemory(demo->device, &mem_alloc, &demo->vertices.mem);
- assert(!err);
+ &mem_reqs_size, mem_reqs);
+ assert(!err && mem_reqs_size == sizeof(*mem_reqs));
+ err = xglGetObjectInfo(demo->vertices.buf,
+ XGL_INFO_TYPE_BUFFER_MEMORY_REQUIREMENTS,
+ &buf_reqs_size, &buf_reqs);
+ assert(!err && buf_reqs_size == sizeof(XGL_BUFFER_MEMORY_REQUIREMENTS));
+ buf_alloc.usage = buf_reqs.usage;
+ for (XGL_UINT i = 0; i < num_allocations; i ++) {
+ mem_alloc.allocationSize = mem_reqs[i].size;
+ mem_alloc.alignment = mem_reqs[i].alignment;
+ mem_alloc.heapCount = mem_reqs[i].heapCount;
+ mem_alloc.pHeaps = mem_reqs[i].pHeaps;
+ memcpy(mem_alloc.pHeaps, mem_reqs[i].pHeaps,
+ sizeof(mem_reqs[i].pHeaps[0]) * mem_reqs[i].heapCount);
- err = xglMapMemory(demo->vertices.mem, 0, &data);
- assert(!err);
+ err = xglAllocMemory(demo->device, &mem_alloc, &demo->vertices.mem[i]);
+ assert(!err);
- memcpy(data, vb, sizeof(vb));
+ err = xglMapMemory(demo->vertices.mem[i], 0, &data);
+ assert(!err);
- err = xglUnmapMemory(demo->vertices.mem);
- assert(!err);
+ memcpy(data, vb, sizeof(vb));
- err = xglBindObjectMemory(demo->vertices.buf, 0, demo->vertices.mem, 0);
- assert(!err);
+ err = xglUnmapMemory(demo->vertices.mem[i]);
+ assert(!err);
+
+ err = xglBindObjectMemory(demo->vertices.buf, i, demo->vertices.mem[i], 0);
+ assert(!err);
+ }
demo->vertices.vi.sType = XGL_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_CREATE_INFO;
demo->vertices.vi.pNext = NULL;
xglBindObjectMemory(demo->vertices.buf, 0, XGL_NULL_HANDLE, 0);
xglDestroyObject(demo->vertices.buf);
- xglFreeMemory(demo->vertices.mem);
+ for (j = 0; j < demo->vertices.num_mem; j++)
+ xglFreeMemory(demo->vertices.mem[j]);
for (i = 0; i < DEMO_TEXTURE_COUNT; i++) {
xglDestroyObject(demo->textures[i].view);
return icd_format_table[format.channelFormat].size;
}
+XGL_IMAGE_FORMAT_CLASS icd_format_get_class(XGL_FORMAT format)
+{
+ if (icd_format_is_undef(format))
+ assert(!"undefined format");
+ if (icd_format_is_compressed(format)) {
+ switch (icd_format_get_size(format)) {
+ case 8:
+ return XGL_IMAGE_FORMAT_CLASS_64_BIT_BLOCK;
+ case 16:
+ return XGL_IMAGE_FORMAT_CLASS_128_BIT_BLOCK;
+ default:
+ assert(!"illegal compressed format");
+ }
+ } else if (icd_format_is_ds(format)) {
+ switch (icd_format_get_size(format)) {
+ case 1:
+ return XGL_IMAGE_FORMAT_CLASS_S8;
+ case 2:
+ return XGL_IMAGE_FORMAT_CLASS_D16;
+ case 3:
+ switch (icd_format_get_channel_count(format)) {
+ case 1:
+ return XGL_IMAGE_FORMAT_CLASS_D24;
+ case 2:
+ return XGL_IMAGE_FORMAT_CLASS_D16S8;
+ default:
+ assert(!"illegal depth stencil format channels");
+ }
+ case 4:
+ switch (icd_format_get_channel_count(format)) {
+ case 1:
+ return XGL_IMAGE_FORMAT_CLASS_D32;
+ case 2:
+ return XGL_IMAGE_FORMAT_CLASS_D24S8;
+ default:
+ assert(!"illegal depth stencil format channels");
+ }
+ case 5:
+ return XGL_IMAGE_FORMAT_CLASS_D32S8;
+ default:
+ assert(!"illegal depth stencil format");
+ }
+ } else { /* uncompressed color format */
+ switch (icd_format_get_size(format)) {
+ case 1:
+ return XGL_IMAGE_FORMAT_CLASS_8_BITS;
+ case 2:
+ return XGL_IMAGE_FORMAT_CLASS_16_BITS;
+ case 3:
+ return XGL_IMAGE_FORMAT_CLASS_24_BITS;
+ case 4:
+ return XGL_IMAGE_FORMAT_CLASS_32_BITS;
+ case 6:
+ return XGL_IMAGE_FORMAT_CLASS_48_BITS;
+ case 8:
+ return XGL_IMAGE_FORMAT_CLASS_64_BITS;
+ case 12:
+ return XGL_IMAGE_FORMAT_CLASS_96_BITS;
+ case 16:
+ return XGL_IMAGE_FORMAT_CLASS_128_BITS;
+ default:
+ assert(!"illegal uncompressed color format");
+ }
+ }
+}
+
unsigned int icd_format_get_channel_count(XGL_FORMAT format)
{
return icd_format_table[format.channelFormat].channel_count;
size_t icd_format_get_size(XGL_FORMAT format);
+XGL_IMAGE_FORMAT_CLASS icd_format_get_class(XGL_FORMAT format);
+
unsigned int icd_format_get_channel_count(XGL_FORMAT format);
void icd_format_get_raw_value(XGL_FORMAT format,
XGL_STRUCTURE_TYPE_UPDATE_IMAGES = 51,
XGL_STRUCTURE_TYPE_UPDATE_BUFFERS = 52,
XGL_STRUCTURE_TYPE_UPDATE_AS_COPY = 53,
+ XGL_STRUCTURE_TYPE_MEMORY_ALLOC_BUFFER_INFO = 54,
+ XGL_STRUCTURE_TYPE_MEMORY_ALLOC_IMAGE_INFO = 55,
XGL_MAX_ENUM(_XGL_STRUCTURE_TYPE)
} XGL_STRUCTURE_TYPE;
XGL_MEMORY_ALLOC_SHAREABLE_BIT = 0x00000001,
} XGL_MEMORY_ALLOC_FLAGS;
-// Buffer usage flags
+// Buffer and buffer allocation 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_GENERAL = 0x00000000, // no special usage
+ XGL_BUFFER_USAGE_SHADER_ACCESS_READ_BIT = 0x00000001, // Shader read (e.g. TBO, image buffer, UBO, SSBO)
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_TRANSFER_SOURCE_BIT = 0x00000008, // used as a source for copies
+ XGL_BUFFER_USAGE_TRANSFER_DESTINATION_BIT = 0x00000010, // used as a destination for copies
+ XGL_BUFFER_USAGE_UNIFORM_READ_BIT = 0x00000020, // Uniform read (UBO)
+ XGL_BUFFER_USAGE_INDEX_FETCH_BIT = 0x00000040, // Fixed function index fetch (index buffer)
+ XGL_BUFFER_USAGE_VERTEX_FETCH_BIT = 0x00000080, // Fixed function vertex fetch (VBO)
+ XGL_BUFFER_USAGE_SHADER_STORAGE_BIT = 0x00000100, // Shader storage buffer (SSBO)
+ XGL_BUFFER_USAGE_RAW_BUFFER_BIT = 0x00000200, // used as a raw buffer
+ XGL_BUFFER_USAGE_INDIRECT_PARAMETER_FETCH_BIT = 0x00000400, // Can be the source of indirect parameters (e.g. indirect buffer, parameter buffer)
+ XGL_BUFFER_USAGE_TEXTURE_BUFFER_BIT = 0x00000800, // texture buffer (TBO)
+ XGL_BUFFER_USAGE_IMAGE_BUFFER_BIT = 0x00001000, // image buffer (load/store)
+ XGL_MAX_ENUM(_XGL_BUFFER_USAGE_FLAGS)
} XGL_BUFFER_USAGE_FLAGS;
// Buffer flags
XGL_MAX_ENUM(_XGL_BUFFER_VIEW_TYPE)
} XGL_BUFFER_VIEW_TYPE;
-// Image usage flags
+// Images memory allocations can be used for resources of a given format class.
+typedef enum _XGL_IMAGE_FORMAT_CLASS
+{
+ XGL_IMAGE_FORMAT_CLASS_128_BITS = 1, // color formats
+ XGL_IMAGE_FORMAT_CLASS_96_BITS = 2,
+ XGL_IMAGE_FORMAT_CLASS_64_BITS = 3,
+ XGL_IMAGE_FORMAT_CLASS_48_BITS = 4,
+ XGL_IMAGE_FORMAT_CLASS_32_BITS = 5,
+ XGL_IMAGE_FORMAT_CLASS_24_BITS = 6,
+ XGL_IMAGE_FORMAT_CLASS_16_BITS = 7,
+ XGL_IMAGE_FORMAT_CLASS_8_BITS = 8,
+ XGL_IMAGE_FORMAT_CLASS_128_BIT_BLOCK = 9, // 128-bit block compressed formats
+ XGL_IMAGE_FORMAT_CLASS_64_BIT_BLOCK = 10, // 64-bit block compressed formats
+ XGL_IMAGE_FORMAT_CLASS_D32 = 11, // D32_SFLOAT
+ XGL_IMAGE_FORMAT_CLASS_D24 = 12, // D24_UNORM
+ XGL_IMAGE_FORMAT_CLASS_D16 = 13, // D16_UNORM
+ XGL_IMAGE_FORMAT_CLASS_S8 = 14, // S8_UINT
+ XGL_IMAGE_FORMAT_CLASS_D32S8 = 15, // D32_SFLOAT_S8_UINT
+ XGL_IMAGE_FORMAT_CLASS_D24S8 = 16, // D24_UNORM_S8_UINT
+ XGL_IMAGE_FORMAT_CLASS_D16S8 = 17, // D16_UNORM_S8_UINT
+ XGL_IMAGE_FORMAT_CLASS_LINEAR = 18, // used for pitch-linear (transparent) textures
+ XGL_MAX_ENUM(_XGL_IMAGE_FORMAT_CLASS)
+} XGL_IMAGE_FORMAT_CLASS;
+
+// Image and image allocation 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_SHADER_ACCESS_ATOMIC_BIT = 0x00000004,
- XGL_IMAGE_USAGE_COLOR_ATTACHMENT_BIT = 0x00000008,
- XGL_IMAGE_USAGE_DEPTH_STENCIL_BIT = 0x00000010,
+ XGL_IMAGE_USAGE_GENERAL = 0x00000000, // no special usage
+ 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_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_MAX_ENUM(_XGL_IMAGE_USAGE_FLAGS)
} XGL_IMAGE_USAGE_FLAGS;
// Image flags
XGL_MEMORY_PRIORITY memPriority;
} XGL_MEMORY_ALLOC_INFO;
+// This structure is included in the XGL_MEMORY_ALLOC_INFO chain
+// for memory regions allocated for buffer usage.
+typedef struct _XGL_MEMORY_ALLOC_BUFFER_INFO
+{
+ XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_MEMORY_ALLOC_BUFFER_INFO
+ XGL_VOID* pNext; // Pointer to next structure
+ XGL_FLAGS usage; // XGL_BUFFER_USAGE_FLAGS
+} XGL_MEMORY_ALLOC_BUFFER_INFO;
+
+// This structure is included in the XGL_MEMORY_ALLOC_INFO chain
+// for memory regions allocated for buffer usage.
+typedef struct _XGL_MEMORY_ALLOC_IMAGE_INFO
+{
+ XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_MEMORY_ALLOC_IMAGE_INFO
+ XGL_VOID* pNext; // Pointer to next structure
+ XGL_FLAGS usage; // XGL_IMAGE_USAGE_FLAGS
+ XGL_IMAGE_FORMAT_CLASS formatClass;
+ XGL_UINT samples;
+} XGL_MEMORY_ALLOC_IMAGE_INFO;
+
typedef struct _XGL_MEMORY_OPEN_INFO
{
XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_MEMORY_OPEN_INFO
XGL_UINT* pHeaps;
} XGL_MEMORY_REQUIREMENTS;
+typedef struct _XGL_BUFFER_MEMORY_REQUIREMENTS
+{
+ XGL_FLAGS usage; // XGL_BUFFER_USAGE_FLAGS
+} XGL_BUFFER_MEMORY_REQUIREMENTS;
+
+typedef struct _XGL_IMAGE_MEMORY_REQUIREMENTS
+{
+ XGL_FLAGS usage; // XGL_IMAGE_USAGE_FLAGS
+ XGL_IMAGE_FORMAT_CLASS formatClass;
+ XGL_UINT samples;
+} XGL_IMAGE_MEMORY_REQUIREMENTS;
+
typedef struct _XGL_FORMAT_PROPERTIES
{
XGL_FLAGS linearTilingFeatures; // XGL_FORMAT_FEATURE_FLAGS
projects / platform / upstream / Vulkan-Tools.git / commitdiff