update for buffer object changes
diff --git a/include/xgl.h b/include/xgl.h
index 6c03de6..2e40aed 100644
--- a/include/xgl.h
+++ b/include/xgl.h
@@ -81,6 +81,8 @@
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 @@
XGL_NUM_MEMORY_PRIORITY = (XGL_MEMORY_PRIORITY_END_RANGE - XGL_MEMORY_PRIORITY_BEGIN_RANGE + 1),
} XGL_MEMORY_PRIORITY;
-typedef enum _XGL_MEMORY_STATE
+typedef enum _XGL_BUFFER_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_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_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;
+ 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 @@
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 @@
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 @@
// 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 @@
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 @@
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 @@
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 @@
{
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 *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 *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 *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 *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 *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_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 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_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_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_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 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 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_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_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_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 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_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_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 @@
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 69e39d6..3ea8448 100644
--- a/include/xglDbg.h
+++ b/include/xglDbg.h
@@ -87,6 +87,9 @@
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 6061d89..8c473ba 100644
--- a/include/xglLayer.h
+++ b/include/xglLayer.h
@@ -45,7 +45,6 @@
xglMapMemoryType MapMemory;
xglUnmapMemoryType UnmapMemory;
xglPinSystemMemoryType PinSystemMemory;
- xglRemapVirtualMemoryPagesType RemapVirtualMemoryPages;
xglGetMultiGpuCompatibilityType GetMultiGpuCompatibility;
xglOpenSharedMemoryType OpenSharedMemory;
xglOpenSharedQueueSemaphoreType OpenSharedQueueSemaphore;
@@ -54,6 +53,8 @@
xglDestroyObjectType DestroyObject;
xglGetObjectInfoType GetObjectInfo;
xglBindObjectMemoryType BindObjectMemory;
+ xglBindObjectMemoryRangeType BindObjectMemoryRange;
+ xglBindImageMemoryRangeType BindImageMemoryRange;
xglCreateFenceType CreateFence;
xglGetFenceStatusType GetFenceStatus;
xglWaitForFencesType WaitForFences;
@@ -67,6 +68,8 @@
xglCreateQueryPoolType CreateQueryPool;
xglGetQueryPoolResultsType GetQueryPoolResults;
xglGetFormatInfoType GetFormatInfo;
+ xglCreateBufferType CreateBuffer;
+ xglCreateBufferViewType CreateBufferView;
xglCreateImageType CreateImage;
xglGetImageSubresourceInfoType GetImageSubresourceInfo;
xglCreateImageViewType CreateImageView;
@@ -84,7 +87,7 @@
xglEndDescriptorSetUpdateType EndDescriptorSetUpdate;
xglAttachSamplerDescriptorsType AttachSamplerDescriptors;
xglAttachImageViewDescriptorsType AttachImageViewDescriptors;
- xglAttachMemoryViewDescriptorsType AttachMemoryViewDescriptors;
+ xglAttachBufferViewDescriptorsType AttachBufferViewDescriptors;
xglAttachNestedDescriptorsType AttachNestedDescriptors;
xglClearDescriptorSetSlotsType ClearDescriptorSetSlots;
xglCreateViewportStateType CreateViewportState;
@@ -100,10 +103,10 @@
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 @@
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/tests/blit_tests.cpp b/tests/blit_tests.cpp
index a77764c..3fbc712 100644
--- a/tests/blit_tests.cpp
+++ b/tests/blit_tests.cpp
@@ -29,8 +29,6 @@
namespace xgl_testing {
-typedef GpuMemory Buffer;
-
XGL_SIZE get_format_size(XGL_FORMAT format);
class Environment : public ::testing::Environment {
@@ -54,7 +52,7 @@
class ImageChecker {
public:
- explicit ImageChecker(const XGL_IMAGE_CREATE_INFO &info, const std::vector<XGL_MEMORY_IMAGE_COPY> ®ions)
+ explicit ImageChecker(const XGL_IMAGE_CREATE_INFO &info, const std::vector<XGL_BUFFER_IMAGE_COPY> ®ions)
: info_(info), regions_(regions), pattern_(HASH) {}
explicit ImageChecker(const XGL_IMAGE_CREATE_INFO &info, const std::vector<XGL_IMAGE_SUBRESOURCE_RANGE> &ranges);
explicit ImageChecker(const XGL_IMAGE_CREATE_INFO &info);
@@ -67,7 +65,7 @@
bool check(Buffer &buf) const { return walk(CHECK, buf); }
bool check(Image &img) const { return walk(CHECK, img); }
- const std::vector<XGL_MEMORY_IMAGE_COPY> ®ions() const { return regions_; }
+ const std::vector<XGL_BUFFER_IMAGE_COPY> ®ions() const { return regions_; }
static void hash_salt_generate() { hash_salt_++; }
@@ -83,18 +81,18 @@
};
XGL_SIZE buffer_cpp() const;
- XGL_SUBRESOURCE_LAYOUT buffer_layout(const XGL_MEMORY_IMAGE_COPY ®ion) const;
+ XGL_SUBRESOURCE_LAYOUT buffer_layout(const XGL_BUFFER_IMAGE_COPY ®ion) const;
bool walk(Action action, Buffer &buf) const;
bool walk(Action action, Image &img) const;
- bool walk_region(Action action, const XGL_MEMORY_IMAGE_COPY ®ion, const XGL_SUBRESOURCE_LAYOUT &layout, void *data) const;
+ bool walk_region(Action action, const XGL_BUFFER_IMAGE_COPY ®ion, const XGL_SUBRESOURCE_LAYOUT &layout, void *data) const;
std::vector<uint8_t> pattern_hash(const XGL_IMAGE_SUBRESOURCE &subres, const XGL_OFFSET3D &offset) const;
static uint32_t hash_salt_;
XGL_IMAGE_CREATE_INFO info_;
- std::vector<XGL_MEMORY_IMAGE_COPY> regions_;
+ std::vector<XGL_BUFFER_IMAGE_COPY> regions_;
Pattern pattern_;
std::vector<uint8_t> pattern_solid_;
@@ -179,9 +177,9 @@
// create a region for every mip level in array slice 0
XGL_GPU_SIZE offset = 0;
for (XGL_UINT lv = 0; lv < info_.mipLevels; lv++) {
- XGL_MEMORY_IMAGE_COPY region = {};
+ XGL_BUFFER_IMAGE_COPY region = {};
- region.memOffset = offset;
+ region.bufferOffset = offset;
region.imageSubresource.mipLevel = lv;
region.imageSubresource.arraySlice = 0;
region.imageExtent = Image::extent(info_.extent, lv);
@@ -216,9 +214,9 @@
for (XGL_UINT slice = 1; slice < info_.arraySize; slice++) {
for (XGL_UINT i = 0; i < slice_region_count; i++) {
- XGL_MEMORY_IMAGE_COPY region = regions_[i];
+ XGL_BUFFER_IMAGE_COPY region = regions_[i];
- region.memOffset += slice_pitch * slice;
+ region.bufferOffset += slice_pitch * slice;
region.imageSubresource.arraySlice = slice;
regions_.push_back(region);
}
@@ -234,8 +232,8 @@
it != ranges.end(); it++) {
for (XGL_UINT lv = 0; lv < it->mipLevels; lv++) {
for (XGL_UINT slice = 0; slice < it->arraySize; slice++) {
- XGL_MEMORY_IMAGE_COPY region = {};
- region.memOffset = offset;
+ XGL_BUFFER_IMAGE_COPY region = {};
+ region.bufferOffset = offset;
region.imageSubresource = Image::subresource(*it, lv, slice);
region.imageExtent = Image::extent(info_.extent, lv);
@@ -261,10 +259,10 @@
return get_format_size(info_.format);
}
-XGL_SUBRESOURCE_LAYOUT ImageChecker::buffer_layout(const XGL_MEMORY_IMAGE_COPY ®ion) const
+XGL_SUBRESOURCE_LAYOUT ImageChecker::buffer_layout(const XGL_BUFFER_IMAGE_COPY ®ion) const
{
XGL_SUBRESOURCE_LAYOUT layout = {};
- layout.offset = region.memOffset;
+ layout.offset = region.bufferOffset;
layout.rowPitch = buffer_cpp() * region.imageExtent.width;
layout.depthPitch = layout.rowPitch * region.imageExtent.height;
layout.size = layout.depthPitch * region.imageExtent.depth;
@@ -276,7 +274,7 @@
{
XGL_GPU_SIZE size = 0;
- for (std::vector<XGL_MEMORY_IMAGE_COPY>::const_iterator it = regions_.begin();
+ for (std::vector<XGL_BUFFER_IMAGE_COPY>::const_iterator it = regions_.begin();
it != regions_.end(); it++) {
const XGL_SUBRESOURCE_LAYOUT layout = buffer_layout(*it);
if (size < layout.offset + layout.size)
@@ -286,7 +284,7 @@
return size;
}
-bool ImageChecker::walk_region(Action action, const XGL_MEMORY_IMAGE_COPY ®ion,
+bool ImageChecker::walk_region(Action action, const XGL_BUFFER_IMAGE_COPY ®ion,
const XGL_SUBRESOURCE_LAYOUT &layout, void *data) const
{
for (XGL_INT z = 0; z < region.imageExtent.depth; z++) {
@@ -329,7 +327,7 @@
if (!data)
return false;
- std::vector<XGL_MEMORY_IMAGE_COPY>::const_iterator it;
+ std::vector<XGL_BUFFER_IMAGE_COPY>::const_iterator it;
for (it = regions_.begin(); it != regions_.end(); it++) {
if (!walk_region(action, *it, buffer_layout(*it), data))
break;
@@ -346,7 +344,7 @@
if (!data)
return false;
- std::vector<XGL_MEMORY_IMAGE_COPY>::const_iterator it;
+ std::vector<XGL_BUFFER_IMAGE_COPY>::const_iterator it;
for (it = regions_.begin(); it != regions_.end(); it++) {
if (!walk_region(action, *it, img.subresource_layout(it->imageSubresource), data))
break;
@@ -487,24 +485,6 @@
}
}
- void add_memory_ref(const xgl_testing::GpuMemory &obj, XGL_FLAGS flags)
- {
- std::vector<XGL_MEMORY_REF>::iterator it;
- for (it = mem_refs_.begin(); it != mem_refs_.end(); it++) {
- if (it->mem == obj.obj())
- break;
- }
-
- if (it == mem_refs_.end()) {
- XGL_MEMORY_REF ref = {};
- ref.mem = obj.obj();
- ref.flags = flags;
- mem_refs_.push_back(ref);
- } else {
- it->flags &= flags;
- }
- }
-
xgl_testing::Device &dev_;
xgl_testing::Queue &queue_;
xgl_testing::CmdBuffer cmd_;
@@ -512,9 +492,9 @@
std::vector<XGL_MEMORY_REF> mem_refs_;
};
-typedef XglCmdBlitTest XglCmdFillMemoryTest;
+typedef XglCmdBlitTest XglCmdFillBufferTest;
-TEST_F(XglCmdFillMemoryTest, Basic)
+TEST_F(XglCmdFillBufferTest, Basic)
{
xgl_testing::Buffer buf;
@@ -522,8 +502,8 @@
add_memory_ref(buf, 0);
cmd_.begin();
- xglCmdFillMemory(cmd_.obj(), buf.obj(), 0, 4, 0x11111111);
- xglCmdFillMemory(cmd_.obj(), buf.obj(), 4, 16, 0x22222222);
+ xglCmdFillBuffer(cmd_.obj(), buf.obj(), 0, 4, 0x11111111);
+ xglCmdFillBuffer(cmd_.obj(), buf.obj(), 4, 16, 0x22222222);
cmd_.end();
submit_and_done();
@@ -537,7 +517,7 @@
buf.unmap();
}
-TEST_F(XglCmdFillMemoryTest, Large)
+TEST_F(XglCmdFillBufferTest, Large)
{
const XGL_GPU_SIZE size = 32 * 1024 * 1024;
xgl_testing::Buffer buf;
@@ -546,8 +526,8 @@
add_memory_ref(buf, 0);
cmd_.begin();
- xglCmdFillMemory(cmd_.obj(), buf.obj(), 0, size / 2, 0x11111111);
- xglCmdFillMemory(cmd_.obj(), buf.obj(), size / 2, size / 2, 0x22222222);
+ xglCmdFillBuffer(cmd_.obj(), buf.obj(), 0, size / 2, 0x11111111);
+ xglCmdFillBuffer(cmd_.obj(), buf.obj(), size / 2, size / 2, 0x22222222);
cmd_.end();
submit_and_done();
@@ -561,7 +541,7 @@
buf.unmap();
}
-TEST_F(XglCmdFillMemoryTest, Overlap)
+TEST_F(XglCmdFillBufferTest, Overlap)
{
xgl_testing::Buffer buf;
@@ -569,8 +549,8 @@
add_memory_ref(buf, 0);
cmd_.begin();
- xglCmdFillMemory(cmd_.obj(), buf.obj(), 0, 48, 0x11111111);
- xglCmdFillMemory(cmd_.obj(), buf.obj(), 32, 32, 0x22222222);
+ xglCmdFillBuffer(cmd_.obj(), buf.obj(), 0, 48, 0x11111111);
+ xglCmdFillBuffer(cmd_.obj(), buf.obj(), 32, 32, 0x22222222);
cmd_.end();
submit_and_done();
@@ -584,7 +564,7 @@
buf.unmap();
}
-TEST_F(XglCmdFillMemoryTest, MultiAlignments)
+TEST_F(XglCmdFillBufferTest, MultiAlignments)
{
xgl_testing::Buffer bufs[9];
XGL_GPU_SIZE size = 4;
@@ -593,7 +573,7 @@
for (int i = 0; i < ARRAY_SIZE(bufs); i++) {
bufs[i].init(dev_, size);
add_memory_ref(bufs[i], 0);
- xglCmdFillMemory(cmd_.obj(), bufs[i].obj(), 0, size, 0x11111111);
+ xglCmdFillBuffer(cmd_.obj(), bufs[i].obj(), 0, size, 0x11111111);
size <<= 1;
}
cmd_.end();
@@ -613,9 +593,9 @@
}
}
-typedef XglCmdBlitTest XglCmdCopyMemoryTest;
+typedef XglCmdBlitTest XglCmdCopyBufferTest;
-TEST_F(XglCmdCopyMemoryTest, Basic)
+TEST_F(XglCmdCopyBufferTest, Basic)
{
xgl_testing::Buffer src, dst;
@@ -629,9 +609,9 @@
add_memory_ref(dst, 0);
cmd_.begin();
- XGL_MEMORY_COPY region = {};
+ XGL_BUFFER_COPY region = {};
region.copySize = 4;
- xglCmdCopyMemory(cmd_.obj(), src.obj(), dst.obj(), 1, ®ion);
+ xglCmdCopyBuffer(cmd_.obj(), src.obj(), dst.obj(), 1, ®ion);
cmd_.end();
submit_and_done();
@@ -641,7 +621,7 @@
dst.unmap();
}
-TEST_F(XglCmdCopyMemoryTest, Large)
+TEST_F(XglCmdCopyBufferTest, Large)
{
const XGL_GPU_SIZE size = 32 * 1024 * 1024;
xgl_testing::Buffer src, dst;
@@ -658,9 +638,9 @@
add_memory_ref(dst, 0);
cmd_.begin();
- XGL_MEMORY_COPY region = {};
+ XGL_BUFFER_COPY region = {};
region.copySize = size;
- xglCmdCopyMemory(cmd_.obj(), src.obj(), dst.obj(), 1, ®ion);
+ xglCmdCopyBuffer(cmd_.obj(), src.obj(), dst.obj(), 1, ®ion);
cmd_.end();
submit_and_done();
@@ -671,9 +651,9 @@
dst.unmap();
}
-TEST_F(XglCmdCopyMemoryTest, MultiAlignments)
+TEST_F(XglCmdCopyBufferTest, MultiAlignments)
{
- const XGL_MEMORY_COPY regions[] = {
+ const XGL_BUFFER_COPY regions[] = {
/* well aligned */
{ 0, 0, 256 },
{ 0, 256, 128 },
@@ -702,14 +682,14 @@
add_memory_ref(dst, 0);
cmd_.begin();
- xglCmdCopyMemory(cmd_.obj(), src.obj(), dst.obj(), ARRAY_SIZE(regions), regions);
+ xglCmdCopyBuffer(cmd_.obj(), src.obj(), dst.obj(), ARRAY_SIZE(regions), regions);
cmd_.end();
submit_and_done();
data = static_cast<uint8_t *>(dst.map());
for (int i = 0; i < ARRAY_SIZE(regions); i++) {
- const XGL_MEMORY_COPY &r = regions[i];
+ const XGL_BUFFER_COPY &r = regions[i];
for (int j = 0; j < r.copySize; j++) {
EXPECT_EQ(r.srcOffset + j, data[r.destOffset + j]) <<
@@ -720,7 +700,7 @@
dst.unmap();
}
-TEST_F(XglCmdCopyMemoryTest, RAWHazard)
+TEST_F(XglCmdCopyBufferTest, RAWHazard)
{
xgl_testing::Buffer bufs[3];
@@ -735,21 +715,21 @@
cmd_.begin();
- xglCmdFillMemory(cmd_.obj(), bufs[0].obj(), 0, 4, 0x11111111);
+ xglCmdFillBuffer(cmd_.obj(), bufs[0].obj(), 0, 4, 0x11111111);
// is this necessary?
- XGL_MEMORY_STATE_TRANSITION transition = bufs[0].state_transition(
- XGL_MEMORY_STATE_DATA_TRANSFER, XGL_MEMORY_STATE_DATA_TRANSFER, 0, 4);
- xglCmdPrepareMemoryRegions(cmd_.obj(), 1, &transition);
+ XGL_BUFFER_STATE_TRANSITION transition = bufs[0].state_transition(
+ XGL_BUFFER_STATE_DATA_TRANSFER, XGL_BUFFER_STATE_DATA_TRANSFER, 0, 4);
+ xglCmdPrepareBufferRegions(cmd_.obj(), 1, &transition);
- XGL_MEMORY_COPY region = {};
+ XGL_BUFFER_COPY region = {};
region.copySize = 4;
- xglCmdCopyMemory(cmd_.obj(), bufs[0].obj(), bufs[1].obj(), 1, ®ion);
+ xglCmdCopyBuffer(cmd_.obj(), bufs[0].obj(), bufs[1].obj(), 1, ®ion);
// is this necessary?
transition = bufs[1].state_transition(
- XGL_MEMORY_STATE_DATA_TRANSFER, XGL_MEMORY_STATE_DATA_TRANSFER, 0, 4);
- xglCmdPrepareMemoryRegions(cmd_.obj(), 1, &transition);
+ XGL_BUFFER_STATE_DATA_TRANSFER, XGL_BUFFER_STATE_DATA_TRANSFER, 0, 4);
+ xglCmdPrepareBufferRegions(cmd_.obj(), 1, &transition);
- xglCmdCopyMemory(cmd_.obj(), bufs[1].obj(), bufs[2].obj(), 1, ®ion);
+ xglCmdCopyBuffer(cmd_.obj(), bufs[1].obj(), bufs[2].obj(), 1, ®ion);
cmd_.end();
submit_and_done();
@@ -806,7 +786,7 @@
// copy in and tile
cmd_.begin();
- xglCmdCopyMemoryToImage(cmd_.obj(), in_buf.obj(), img.obj(),
+ xglCmdCopyBufferToImage(cmd_.obj(), in_buf.obj(), img.obj(),
checker.regions().size(), &checker.regions()[0]);
cmd_.end();
@@ -830,7 +810,7 @@
// copy out and linearize
cmd_.begin();
- xglCmdCopyImageToMemory(cmd_.obj(), img.obj(), out_buf.obj(),
+ xglCmdCopyImageToBuffer(cmd_.obj(), img.obj(), out_buf.obj(),
checker.regions().size(), &checker.regions()[0]);
cmd_.end();
@@ -844,7 +824,7 @@
XGL_FORMAT first_optimal_format_;
};
-class XglCmdCopyMemoryToImageTest : public XglCmdBlitImageTest {
+class XglCmdCopyBufferToImageTest : public XglCmdBlitImageTest {
protected:
virtual void SetUp()
{
@@ -866,7 +846,7 @@
add_memory_ref(img, 0);
cmd_.begin();
- xglCmdCopyMemoryToImage(cmd_.obj(), buf.obj(), img.obj(),
+ xglCmdCopyBufferToImage(cmd_.obj(), buf.obj(), img.obj(),
checker.regions().size(), &checker.regions()[0]);
cmd_.end();
@@ -875,7 +855,7 @@
check_dst(img, checker);
}
- void test_copy_memory_to_image(const XGL_IMAGE_CREATE_INFO &img_info, const std::vector<XGL_MEMORY_IMAGE_COPY> ®ions)
+ void test_copy_memory_to_image(const XGL_IMAGE_CREATE_INFO &img_info, const std::vector<XGL_BUFFER_IMAGE_COPY> ®ions)
{
xgl_testing::ImageChecker checker(img_info, regions);
test_copy_memory_to_image(img_info, checker);
@@ -888,7 +868,7 @@
}
};
-TEST_F(XglCmdCopyMemoryToImageTest, Basic)
+TEST_F(XglCmdCopyBufferToImageTest, Basic)
{
for (std::vector<xgl_testing::Device::Format>::const_iterator it = test_formats_.begin();
it != test_formats_.end(); it++) {
@@ -903,7 +883,7 @@
}
}
-class XglCmdCopyImageToMemoryTest : public XglCmdBlitImageTest {
+class XglCmdCopyImageToBufferTest : public XglCmdBlitImageTest {
protected:
virtual void SetUp()
{
@@ -925,7 +905,7 @@
add_memory_ref(buf, 0);
cmd_.begin();
- xglCmdCopyImageToMemory(cmd_.obj(), img.obj(), buf.obj(),
+ xglCmdCopyImageToBuffer(cmd_.obj(), img.obj(), buf.obj(),
checker.regions().size(), &checker.regions()[0]);
cmd_.end();
@@ -934,7 +914,7 @@
checker.check(buf);
}
- void test_copy_image_to_memory(const XGL_IMAGE_CREATE_INFO &img_info, const std::vector<XGL_MEMORY_IMAGE_COPY> ®ions)
+ void test_copy_image_to_memory(const XGL_IMAGE_CREATE_INFO &img_info, const std::vector<XGL_BUFFER_IMAGE_COPY> ®ions)
{
xgl_testing::ImageChecker checker(img_info, regions);
test_copy_image_to_memory(img_info, checker);
@@ -947,7 +927,7 @@
}
};
-TEST_F(XglCmdCopyImageToMemoryTest, Basic)
+TEST_F(XglCmdCopyImageToBufferTest, Basic)
{
for (std::vector<xgl_testing::Device::Format>::const_iterator it = test_formats_.begin();
it != test_formats_.end(); it++) {
@@ -974,19 +954,19 @@
void test_copy_image(const XGL_IMAGE_CREATE_INFO &src_info, const XGL_IMAGE_CREATE_INFO &dst_info,
const std::vector<XGL_IMAGE_COPY> &copies)
{
- // convert XGL_IMAGE_COPY to two sets of XGL_MEMORY_IMAGE_COPY
- std::vector<XGL_MEMORY_IMAGE_COPY> src_regions, dst_regions;
+ // convert XGL_IMAGE_COPY to two sets of XGL_BUFFER_IMAGE_COPY
+ std::vector<XGL_BUFFER_IMAGE_COPY> src_regions, dst_regions;
XGL_GPU_SIZE src_offset = 0, dst_offset = 0;
for (std::vector<XGL_IMAGE_COPY>::const_iterator it = copies.begin(); it != copies.end(); it++) {
- XGL_MEMORY_IMAGE_COPY src_region = {}, dst_region = {};
+ XGL_BUFFER_IMAGE_COPY src_region = {}, dst_region = {};
- src_region.memOffset = src_offset;
+ src_region.bufferOffset = src_offset;
src_region.imageSubresource = it->srcSubresource;
src_region.imageOffset = it->srcOffset;
src_region.imageExtent = it->extent;
src_regions.push_back(src_region);
- dst_region.memOffset = src_offset;
+ dst_region.bufferOffset = src_offset;
dst_region.imageSubresource = it->destSubresource;
dst_region.imageOffset = it->destOffset;
dst_region.imageExtent = it->extent;
diff --git a/tests/render_tests.cpp b/tests/render_tests.cpp
index bcab74c..3773263 100644
--- a/tests/render_tests.cpp
+++ b/tests/render_tests.cpp
@@ -470,14 +470,14 @@
XglShaderObj vs(m_device,vertShaderText,XGL_SHADER_STAGE_VERTEX, this);
XglShaderObj ps(m_device,fragShaderText, XGL_SHADER_STAGE_FRAGMENT, this);
- vs.BindShaderEntitySlotToMemory(0, XGL_SLOT_SHADER_RESOURCE, &constantBuffer);
+ vs.BindShaderEntitySlotToBuffer(0, XGL_SLOT_SHADER_RESOURCE, &constantBuffer);
XglPipelineObj pipelineobj(m_device);
pipelineobj.AddShader(&vs);
pipelineobj.AddShader(&ps);
XglDescriptorSetObj descriptorSet(m_device);
- descriptorSet.AttachMemoryView(&constantBuffer);
+ descriptorSet.AttachBufferView(&constantBuffer);
m_memoryRefManager.AddMemoryRef(&constantBuffer);
ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
@@ -749,7 +749,7 @@
ASSERT_NO_FATAL_FAILURE(InitViewport());
XglConstantBufferObj meshBuffer(m_device,sizeof(g_vbData)/sizeof(g_vbData[0]),sizeof(g_vbData[0]), g_vbData);
- meshBuffer.SetMemoryState(XGL_MEMORY_STATE_GRAPHICS_SHADER_READ_ONLY);
+ meshBuffer.SetBufferState(XGL_BUFFER_STATE_GRAPHICS_SHADER_READ_ONLY);
XglShaderObj vs(m_device,vertShaderText,XGL_SHADER_STAGE_VERTEX, this);
XglShaderObj ps(m_device,fragShaderText, XGL_SHADER_STAGE_FRAGMENT, this);
@@ -759,7 +759,7 @@
pipelineobj.AddShader(&ps);
XglDescriptorSetObj descriptorSet(m_device);
- descriptorSet.AttachMemoryView(&meshBuffer);
+ descriptorSet.AttachBufferView(&meshBuffer);
XGL_VERTEX_INPUT_BINDING_DESCRIPTION vi_binding = {
sizeof(g_vbData[0]), // strideInBytes; Distance between vertices in bytes (0 = no advancement)
@@ -825,7 +825,7 @@
ASSERT_NO_FATAL_FAILURE(InitViewport());
XglConstantBufferObj meshBuffer(m_device, sizeof(vb_data) / sizeof(vb_data[0]), sizeof(vb_data[0]), vb_data);
- meshBuffer.SetMemoryState(XGL_MEMORY_STATE_GRAPHICS_SHADER_READ_ONLY);
+ meshBuffer.SetBufferState(XGL_BUFFER_STATE_GRAPHICS_SHADER_READ_ONLY);
XglShaderObj vs(m_device,vertShaderText,XGL_SHADER_STAGE_VERTEX, this);
XglShaderObj ps(m_device,fragShaderText, XGL_SHADER_STAGE_FRAGMENT, this);
@@ -932,11 +932,11 @@
ASSERT_NO_FATAL_FAILURE(InitViewport());
XglConstantBufferObj meshBuffer(m_device,sizeof(g_vbData)/sizeof(g_vbData[0]),sizeof(g_vbData[0]), g_vbData);
- meshBuffer.SetMemoryState(XGL_MEMORY_STATE_GRAPHICS_SHADER_READ_ONLY);
+ meshBuffer.SetBufferState(XGL_BUFFER_STATE_GRAPHICS_SHADER_READ_ONLY);
XglIndexBufferObj indexBuffer(m_device);
indexBuffer.CreateAndInitBuffer(sizeof(g_idxData)/sizeof(g_idxData[0]), XGL_INDEX_16, g_idxData);
- indexBuffer.SetMemoryState(XGL_MEMORY_STATE_INDEX_DATA);
+ indexBuffer.SetBufferState(XGL_BUFFER_STATE_INDEX_DATA);
XglShaderObj vs(m_device,vertShaderText,XGL_SHADER_STAGE_VERTEX, this);
XglShaderObj ps(m_device,fragShaderText, XGL_SHADER_STAGE_FRAGMENT, this);
@@ -1030,7 +1030,7 @@
ASSERT_NO_FATAL_FAILURE(InitViewport());
XglConstantBufferObj meshBuffer(m_device,sizeof(g_vbData)/sizeof(g_vbData[0]),sizeof(g_vbData[0]), g_vbData);
- meshBuffer.SetMemoryState(XGL_MEMORY_STATE_GRAPHICS_SHADER_READ_ONLY);
+ meshBuffer.SetBufferState(XGL_BUFFER_STATE_GRAPHICS_SHADER_READ_ONLY);
XglShaderObj vs(m_device,vertShaderText,XGL_SHADER_STAGE_VERTEX, this);
XglShaderObj ps(m_device,fragShaderText, XGL_SHADER_STAGE_FRAGMENT, this);
@@ -1040,7 +1040,7 @@
pipelineobj.AddShader(&ps);
XglDescriptorSetObj descriptorSet(m_device);
- descriptorSet.AttachMemoryView(&meshBuffer);
+ descriptorSet.AttachBufferView(&meshBuffer);
XGL_VERTEX_INPUT_BINDING_DESCRIPTION vi_binding = {
sizeof(g_vbData[0]), // strideInBytes; Distance between vertices in bytes (0 = no advancement)
@@ -1124,7 +1124,7 @@
ASSERT_NO_FATAL_FAILURE(InitViewport());
XglConstantBufferObj meshBuffer(m_device,sizeof(g_vbData)/sizeof(g_vbData[0]),sizeof(g_vbData[0]), g_vbData);
- meshBuffer.SetMemoryState(XGL_MEMORY_STATE_GRAPHICS_SHADER_READ_ONLY);
+ meshBuffer.SetBufferState(XGL_BUFFER_STATE_GRAPHICS_SHADER_READ_ONLY);
XglShaderObj vs(m_device,vertShaderText,XGL_SHADER_STAGE_VERTEX, this);
XglShaderObj ps(m_device,fragShaderText, XGL_SHADER_STAGE_FRAGMENT, this);
@@ -1134,7 +1134,7 @@
pipelineobj.AddShader(&ps);
XglDescriptorSetObj descriptorSet(m_device);
- descriptorSet.AttachMemoryView(&meshBuffer);
+ descriptorSet.AttachBufferView(&meshBuffer);
XGL_VERTEX_INPUT_BINDING_DESCRIPTION vi_binding = {
sizeof(g_vbData[0]), // strideInBytes; Distance between vertices in bytes (0 = no advancement)
@@ -1228,7 +1228,7 @@
ASSERT_NO_FATAL_FAILURE(InitViewport());
XglConstantBufferObj meshBuffer(m_device,sizeof(g_vbData)/sizeof(g_vbData[0]),sizeof(g_vbData[0]), g_vbData);
- meshBuffer.SetMemoryState(XGL_MEMORY_STATE_GRAPHICS_SHADER_READ_ONLY);
+ meshBuffer.SetBufferState(XGL_BUFFER_STATE_GRAPHICS_SHADER_READ_ONLY);
XglShaderObj vs(m_device,vertShaderText,XGL_SHADER_STAGE_VERTEX, this);
XglShaderObj ps(m_device,fragShaderText, XGL_SHADER_STAGE_FRAGMENT, this);
@@ -1238,7 +1238,7 @@
pipelineobj.AddShader(&ps);
XglDescriptorSetObj descriptorSet(m_device);
- descriptorSet.AttachMemoryView(&meshBuffer);
+ descriptorSet.AttachBufferView(&meshBuffer);
XGL_VERTEX_INPUT_BINDING_DESCRIPTION vi_binding = {
sizeof(g_vbData[0]), // strideInBytes; Distance between vertices in bytes (0 = no advancement)
@@ -1322,7 +1322,7 @@
ASSERT_NO_FATAL_FAILURE(InitViewport());
XglConstantBufferObj meshBuffer(m_device,sizeof(g_vbData)/sizeof(g_vbData[0]),sizeof(g_vbData[0]), g_vbData);
- meshBuffer.SetMemoryState(XGL_MEMORY_STATE_GRAPHICS_SHADER_READ_ONLY);
+ meshBuffer.SetBufferState(XGL_BUFFER_STATE_GRAPHICS_SHADER_READ_ONLY);
XglShaderObj vs(m_device,vertShaderText,XGL_SHADER_STAGE_VERTEX, this);
XglShaderObj ps(m_device,fragShaderText, XGL_SHADER_STAGE_FRAGMENT, this);
@@ -1332,7 +1332,7 @@
pipelineobj.AddShader(&ps);
XglDescriptorSetObj descriptorSet(m_device);
- descriptorSet.AttachMemoryView(&meshBuffer);
+ descriptorSet.AttachBufferView(&meshBuffer);
XGL_VERTEX_INPUT_BINDING_DESCRIPTION vi_binding = {
sizeof(g_vbData[0]), // strideInBytes; Distance between vertices in bytes (0 = no advancement)
@@ -1417,7 +1417,7 @@
XglShaderObj vs(m_device,vertShaderText,XGL_SHADER_STAGE_VERTEX, this);
XglShaderObj ps(m_device,fragShaderText, XGL_SHADER_STAGE_FRAGMENT, this);
- vs.BindShaderEntitySlotToMemory(0, XGL_SLOT_SHADER_RESOURCE, &MVPBuffer);
+ vs.BindShaderEntitySlotToBuffer(0, XGL_SLOT_SHADER_RESOURCE, &MVPBuffer);
XglPipelineObj pipelineobj(m_device);
pipelineobj.AddShader(&vs);
@@ -1425,7 +1425,7 @@
// Create descriptor set and attach the constant buffer to it
XglDescriptorSetObj descriptorSet(m_device);
- descriptorSet.AttachMemoryView(&MVPBuffer);
+ descriptorSet.AttachBufferView(&MVPBuffer);
m_memoryRefManager.AddMemoryRef(&MVPBuffer);
@@ -1562,7 +1562,7 @@
ASSERT_NO_FATAL_FAILURE(InitViewport());
XglConstantBufferObj meshBuffer(m_device,sizeof(g_vbData)/sizeof(g_vbData[0]),sizeof(g_vbData[0]), g_vbData);
- meshBuffer.SetMemoryState(XGL_MEMORY_STATE_GRAPHICS_SHADER_READ_ONLY);
+ meshBuffer.SetBufferState(XGL_BUFFER_STATE_GRAPHICS_SHADER_READ_ONLY);
XglShaderObj vs(m_device,vertShaderText,XGL_SHADER_STAGE_VERTEX, this);
XglShaderObj ps(m_device,fragShaderText, XGL_SHADER_STAGE_FRAGMENT, this);
@@ -1572,7 +1572,7 @@
pipelineobj.AddShader(&ps);
XglDescriptorSetObj descriptorSet(m_device);
- descriptorSet.AttachMemoryView(&meshBuffer);
+ descriptorSet.AttachBufferView(&meshBuffer);
XGL_VERTEX_INPUT_BINDING_DESCRIPTION vi_binding = {
sizeof(g_vbData[0]), // strideInBytes; Distance between vertices in bytes (0 = no advancement)
@@ -1655,7 +1655,7 @@
ASSERT_NO_FATAL_FAILURE(InitViewport());
XglConstantBufferObj meshBuffer(m_device,sizeof(g_vbData)/sizeof(g_vbData[0]),sizeof(g_vbData[0]), g_vbData);
- meshBuffer.SetMemoryState(XGL_MEMORY_STATE_GRAPHICS_SHADER_READ_ONLY);
+ meshBuffer.SetBufferState(XGL_BUFFER_STATE_GRAPHICS_SHADER_READ_ONLY);
XglShaderObj vs(m_device,vertShaderText,XGL_SHADER_STAGE_VERTEX, this);
XglShaderObj ps(m_device,fragShaderText, XGL_SHADER_STAGE_FRAGMENT, this);
@@ -1665,7 +1665,7 @@
pipelineobj.AddShader(&ps);
XglDescriptorSetObj descriptorSet(m_device);
- descriptorSet.AttachMemoryView(&meshBuffer);
+ descriptorSet.AttachBufferView(&meshBuffer);
XGL_VERTEX_INPUT_BINDING_DESCRIPTION vi_binding = {
sizeof(g_vbData[0]), // strideInBytes; Distance between vertices in bytes (0 = no advancement)
@@ -1756,14 +1756,14 @@
XglShaderObj vs(m_device,vertShaderText,XGL_SHADER_STAGE_VERTEX, this);
XglShaderObj ps(m_device,fragShaderText, XGL_SHADER_STAGE_FRAGMENT, this);
- vs.BindShaderEntitySlotToMemory(0, XGL_SLOT_SHADER_RESOURCE, &MVPBuffer);
+ vs.BindShaderEntitySlotToBuffer(0, XGL_SLOT_SHADER_RESOURCE, &MVPBuffer);
XglPipelineObj pipelineobj(m_device);
pipelineobj.AddShader(&vs);
pipelineobj.AddShader(&ps);
XglDescriptorSetObj descriptorSet(m_device);
- descriptorSet.AttachMemoryView(&MVPBuffer);
+ descriptorSet.AttachBufferView(&MVPBuffer);
m_memoryRefManager.AddMemoryRef(&meshBuffer);
m_memoryRefManager.AddMemoryRef(&MVPBuffer);
@@ -2278,14 +2278,14 @@
1.0, 1.0, 1.0, 1.0 };
XglConstantBufferObj colorBuffer(m_device, valCount, sizeof(bufferVals[0]), (const void*) bufferVals);
- vs.BindShaderEntitySlotToMemory(0, XGL_SLOT_SHADER_RESOURCE, &colorBuffer);
+ vs.BindShaderEntitySlotToBuffer(0, XGL_SLOT_SHADER_RESOURCE, &colorBuffer);
XglPipelineObj pipelineobj(m_device);
pipelineobj.AddShader(&vs);
pipelineobj.AddShader(&ps);
XglDescriptorSetObj descriptorSet(m_device);
- descriptorSet.AttachMemoryView(&colorBuffer);
+ descriptorSet.AttachBufferView(&colorBuffer);
ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
XglCommandBufferObj cmdBuffer(m_device);
@@ -2372,26 +2372,26 @@
const int whiteCount = sizeof(whiteVals) / sizeof(float);
XglConstantBufferObj redBuffer(m_device, redCount, sizeof(redVals[0]), (const void*) redVals);
- ps.BindShaderEntitySlotToMemory(0, XGL_SLOT_SHADER_RESOURCE, &redBuffer);
+ ps.BindShaderEntitySlotToBuffer(0, XGL_SLOT_SHADER_RESOURCE, &redBuffer);
XglConstantBufferObj greenBuffer(m_device, greenCount, sizeof(greenVals[0]), (const void*) greenVals);
- ps.BindShaderEntitySlotToMemory(1, XGL_SLOT_SHADER_RESOURCE, &greenBuffer);
+ ps.BindShaderEntitySlotToBuffer(1, XGL_SLOT_SHADER_RESOURCE, &greenBuffer);
XglConstantBufferObj blueBuffer(m_device, blueCount, sizeof(blueVals[0]), (const void*) blueVals);
- ps.BindShaderEntitySlotToMemory(2, XGL_SLOT_SHADER_RESOURCE, &blueBuffer);
+ ps.BindShaderEntitySlotToBuffer(2, XGL_SLOT_SHADER_RESOURCE, &blueBuffer);
XglConstantBufferObj whiteBuffer(m_device, whiteCount, sizeof(whiteVals[0]), (const void*) whiteVals);
- ps.BindShaderEntitySlotToMemory(18, XGL_SLOT_SHADER_RESOURCE, &whiteBuffer);
+ ps.BindShaderEntitySlotToBuffer(18, XGL_SLOT_SHADER_RESOURCE, &whiteBuffer);
XglPipelineObj pipelineobj(m_device);
pipelineobj.AddShader(&vs);
pipelineobj.AddShader(&ps);
XglDescriptorSetObj descriptorSet(m_device);
- descriptorSet.AttachMemoryView(&redBuffer);
- descriptorSet.AttachMemoryView(&greenBuffer);
- descriptorSet.AttachMemoryView(&blueBuffer);
- descriptorSet.AttachMemoryView(&whiteBuffer);
+ descriptorSet.AttachBufferView(&redBuffer);
+ descriptorSet.AttachBufferView(&greenBuffer);
+ descriptorSet.AttachBufferView(&blueBuffer);
+ descriptorSet.AttachBufferView(&whiteBuffer);
ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
XglCommandBufferObj cmdBuffer(m_device);
@@ -2473,26 +2473,26 @@
const int whiteCount = sizeof(whiteVals) / sizeof(float);
XglConstantBufferObj redBuffer(m_device, redCount, sizeof(redVals[0]), (const void*) redVals);
- ps.BindShaderEntitySlotToMemory(0, XGL_SLOT_SHADER_RESOURCE, &redBuffer);
+ ps.BindShaderEntitySlotToBuffer(0, XGL_SLOT_SHADER_RESOURCE, &redBuffer);
XglConstantBufferObj greenBuffer(m_device, greenCount, sizeof(greenVals[0]), (const void*) greenVals);
- ps.BindShaderEntitySlotToMemory(1, XGL_SLOT_SHADER_RESOURCE, &greenBuffer);
+ ps.BindShaderEntitySlotToBuffer(1, XGL_SLOT_SHADER_RESOURCE, &greenBuffer);
XglConstantBufferObj blueBuffer(m_device, blueCount, sizeof(blueVals[0]), (const void*) blueVals);
- ps.BindShaderEntitySlotToMemory(2, XGL_SLOT_SHADER_RESOURCE, &blueBuffer);
+ ps.BindShaderEntitySlotToBuffer(2, XGL_SLOT_SHADER_RESOURCE, &blueBuffer);
XglConstantBufferObj whiteBuffer(m_device, whiteCount, sizeof(whiteVals[0]), (const void*) whiteVals);
- ps.BindShaderEntitySlotToMemory(18, XGL_SLOT_SHADER_RESOURCE, &whiteBuffer);
+ ps.BindShaderEntitySlotToBuffer(18, XGL_SLOT_SHADER_RESOURCE, &whiteBuffer);
XglPipelineObj pipelineobj(m_device);
pipelineobj.AddShader(&vs);
pipelineobj.AddShader(&ps);
XglDescriptorSetObj descriptorSet(m_device);
- descriptorSet.AttachMemoryView(&redBuffer);
- descriptorSet.AttachMemoryView(&greenBuffer);
- descriptorSet.AttachMemoryView(&blueBuffer);
- descriptorSet.AttachMemoryView(&whiteBuffer);
+ descriptorSet.AttachBufferView(&redBuffer);
+ descriptorSet.AttachBufferView(&greenBuffer);
+ descriptorSet.AttachBufferView(&blueBuffer);
+ descriptorSet.AttachBufferView(&whiteBuffer);
ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
XglCommandBufferObj cmdBuffer(m_device);
@@ -2567,7 +2567,7 @@
XglConstantBufferObj meshBuffer(m_device,sizeof(g_vb_solid_face_colors_Data)/sizeof(g_vb_solid_face_colors_Data[0]),
sizeof(g_vb_solid_face_colors_Data[0]), g_vb_solid_face_colors_Data);
- meshBuffer.SetMemoryState(XGL_MEMORY_STATE_GRAPHICS_SHADER_READ_ONLY);
+ meshBuffer.SetBufferState(XGL_BUFFER_STATE_GRAPHICS_SHADER_READ_ONLY);
const int buf_size = sizeof(MVP) / sizeof(XGL_FLOAT);
@@ -2578,8 +2578,8 @@
XglSamplerObj sampler(m_device);
XglTextureObj texture(m_device);
- // vs.BindShaderEntitySlotToMemory(0, XGL_SLOT_VERTEX_INPUT, (XGL_OBJECT) &meshBuffer.m_constantBufferView);
- vs.BindShaderEntitySlotToMemory(0, XGL_SLOT_SHADER_RESOURCE, &mvpBuffer);
+ // vs.BindShaderEntitySlotToBuffer(0, XGL_SLOT_VERTEX_INPUT, (XGL_OBJECT) &meshBuffer.m_constantBufferView);
+ vs.BindShaderEntitySlotToBuffer(0, XGL_SLOT_SHADER_RESOURCE, &mvpBuffer);
ps.BindShaderEntitySlotToImage(0, XGL_SLOT_SHADER_TEXTURE_RESOURCE, &texture);
ps.BindShaderEntitySlotToSampler(0, &sampler);
@@ -2589,7 +2589,7 @@
XglDescriptorSetObj descriptorSet(m_device);
- descriptorSet.AttachMemoryView(&mvpBuffer);
+ descriptorSet.AttachBufferView(&mvpBuffer);
descriptorSet.AttachImageView(&texture);
descriptorSet.AttachSampler(&sampler);
@@ -2698,16 +2698,16 @@
const int whiteCount = sizeof(whiteVals) / sizeof(float);
XglConstantBufferObj redBuffer(m_device, redCount, sizeof(redVals[0]), (const void*) redVals);
- ps.BindShaderEntitySlotToMemory(10, XGL_SLOT_SHADER_RESOURCE, &redBuffer);
+ ps.BindShaderEntitySlotToBuffer(10, XGL_SLOT_SHADER_RESOURCE, &redBuffer);
XglConstantBufferObj greenBuffer(m_device, greenCount, sizeof(greenVals[0]), (const void*) greenVals);
- ps.BindShaderEntitySlotToMemory(15, XGL_SLOT_SHADER_RESOURCE, &greenBuffer);
+ ps.BindShaderEntitySlotToBuffer(15, XGL_SLOT_SHADER_RESOURCE, &greenBuffer);
XglConstantBufferObj blueBuffer(m_device, blueCount, sizeof(blueVals[0]), (const void*) blueVals);
- ps.BindShaderEntitySlotToMemory(13, XGL_SLOT_SHADER_RESOURCE, &blueBuffer);
+ ps.BindShaderEntitySlotToBuffer(13, XGL_SLOT_SHADER_RESOURCE, &blueBuffer);
XglConstantBufferObj whiteBuffer(m_device, whiteCount, sizeof(whiteVals[0]), (const void*) whiteVals);
- ps.BindShaderEntitySlotToMemory(17, XGL_SLOT_SHADER_RESOURCE, &whiteBuffer);
+ ps.BindShaderEntitySlotToBuffer(17, XGL_SLOT_SHADER_RESOURCE, &whiteBuffer);
XglSamplerObj sampler0(m_device);
XglTextureObj texture0(m_device); // Light Red
@@ -2739,10 +2739,10 @@
pipelineobj.AddShader(&ps);
XglDescriptorSetObj descriptorSet(m_device);
- descriptorSet.AttachMemoryView(&redBuffer);
- descriptorSet.AttachMemoryView(&greenBuffer);
- descriptorSet.AttachMemoryView(&blueBuffer);
- descriptorSet.AttachMemoryView(&whiteBuffer);
+ descriptorSet.AttachBufferView(&redBuffer);
+ descriptorSet.AttachBufferView(&greenBuffer);
+ descriptorSet.AttachBufferView(&blueBuffer);
+ descriptorSet.AttachBufferView(&whiteBuffer);
descriptorSet.AttachImageView(&texture0);
descriptorSet.AttachSampler(&sampler0);
descriptorSet.AttachImageView(&texture2);
@@ -2836,16 +2836,16 @@
const int whiteCount = sizeof(whiteVals) / sizeof(float);
XglConstantBufferObj redBuffer(m_device, redCount, sizeof(redVals[0]), (const void*) redVals);
- ps.BindShaderEntitySlotToMemory(0, XGL_SLOT_SHADER_RESOURCE, &redBuffer);
+ ps.BindShaderEntitySlotToBuffer(0, XGL_SLOT_SHADER_RESOURCE, &redBuffer);
XglConstantBufferObj greenBuffer(m_device, greenCount, sizeof(greenVals[0]), (const void*) greenVals);
- ps.BindShaderEntitySlotToMemory(1, XGL_SLOT_SHADER_RESOURCE, &greenBuffer);
+ ps.BindShaderEntitySlotToBuffer(1, XGL_SLOT_SHADER_RESOURCE, &greenBuffer);
XglConstantBufferObj blueBuffer(m_device, blueCount, sizeof(blueVals[0]), (const void*) blueVals);
- ps.BindShaderEntitySlotToMemory(2, XGL_SLOT_SHADER_RESOURCE, &blueBuffer);
+ ps.BindShaderEntitySlotToBuffer(2, XGL_SLOT_SHADER_RESOURCE, &blueBuffer);
XglConstantBufferObj whiteBuffer(m_device, whiteCount, sizeof(whiteVals[0]), (const void*) whiteVals);
- ps.BindShaderEntitySlotToMemory(3, XGL_SLOT_SHADER_RESOURCE, &whiteBuffer);
+ ps.BindShaderEntitySlotToBuffer(3, XGL_SLOT_SHADER_RESOURCE, &whiteBuffer);
XglSamplerObj sampler0(m_device);
XglTextureObj texture0(m_device); // Light Red
@@ -2874,10 +2874,10 @@
pipelineobj.AddShader(&ps);
XglDescriptorSetObj descriptorSet(m_device);
- descriptorSet.AttachMemoryView(&redBuffer);
- descriptorSet.AttachMemoryView(&greenBuffer);
- descriptorSet.AttachMemoryView(&blueBuffer);
- descriptorSet.AttachMemoryView(&whiteBuffer);
+ descriptorSet.AttachBufferView(&redBuffer);
+ descriptorSet.AttachBufferView(&greenBuffer);
+ descriptorSet.AttachBufferView(&blueBuffer);
+ descriptorSet.AttachBufferView(&whiteBuffer);
descriptorSet.AttachImageView(&texture0);
descriptorSet.AttachSampler(&sampler0);
descriptorSet.AttachImageView(&texture2);
@@ -3136,15 +3136,15 @@
XglShaderObj ps(m_device,fragShaderText, XGL_SHADER_STAGE_FRAGMENT, this);
XglConstantBufferObj mixedBuffer(m_device, constCount, sizeof(mixedVals[0]), (const void*) mixedVals);
- vs.BindShaderEntitySlotToMemory(0, XGL_SLOT_SHADER_RESOURCE, &mixedBuffer);
- ps.BindShaderEntitySlotToMemory(0, XGL_SLOT_SHADER_RESOURCE, &mixedBuffer);
+ vs.BindShaderEntitySlotToBuffer(0, XGL_SLOT_SHADER_RESOURCE, &mixedBuffer);
+ ps.BindShaderEntitySlotToBuffer(0, XGL_SLOT_SHADER_RESOURCE, &mixedBuffer);
XglPipelineObj pipelineobj(m_device);
pipelineobj.AddShader(&vs);
pipelineobj.AddShader(&ps);
XglDescriptorSetObj descriptorSet(m_device);
- descriptorSet.AttachMemoryView(&mixedBuffer);
+ descriptorSet.AttachBufferView(&mixedBuffer);
ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
XglCommandBufferObj cmdBuffer(m_device);
diff --git a/tests/xglrenderframework.cpp b/tests/xglrenderframework.cpp
index b95b8e9..c144ac4 100644
--- a/tests/xglrenderframework.cpp
+++ b/tests/xglrenderframework.cpp
@@ -236,10 +236,10 @@
}
-void XglDescriptorSetObj::AttachMemoryView(XglConstantBufferObj *constantBuffer)
+void XglDescriptorSetObj::AttachBufferView(XglConstantBufferObj *constantBuffer)
{
- m_memoryViews.push_back(&constantBuffer->m_constantBufferView);
- m_memorySlots.push_back(m_nextSlot);
+ m_bufferViews.push_back(&constantBuffer->m_bufferViewInfo);
+ m_bufferSlots.push_back(m_nextSlot);
m_nextSlot++;
}
@@ -264,7 +264,7 @@
vector<XGL_DESCRIPTOR_SET_SLOT_TYPE>types,
vector<void *>objs )
{
- int nSlots = m_memorySlots.size() + m_imageSlots.size() + m_samplerSlots.size();
+ int nSlots = m_bufferSlots.size() + m_imageSlots.size() + m_samplerSlots.size();
m_slotInfo = (XGL_DESCRIPTOR_SLOT_INFO*) malloc( nSlots * sizeof(XGL_DESCRIPTOR_SLOT_INFO) );
memset(m_slotInfo,0,nSlots*sizeof(XGL_DESCRIPTOR_SLOT_INFO));
@@ -275,12 +275,12 @@
for (int i=0; i<slots.size(); i++)
{
- for (int j=0; j<m_memorySlots.size(); j++)
+ for (int j=0; j<m_bufferSlots.size(); j++)
{
- if ( m_memoryViews[j] == objs[i])
+ if ( m_bufferViews[j] == objs[i])
{
- m_slotInfo[m_memorySlots[j]].shaderEntityIndex = slots[i];
- m_slotInfo[m_memorySlots[j]].slotObjectType = types[i];
+ m_slotInfo[m_bufferSlots[j]].shaderEntityIndex = slots[i];
+ m_slotInfo[m_bufferSlots[j]].slotObjectType = types[i];
}
}
for (int j=0; j<m_imageSlots.size(); j++)
@@ -317,9 +317,9 @@
begin();
clear();
- for (int i=0; i<m_memoryViews.size();i++)
+ for (int i=0; i<m_bufferViews.size();i++)
{
- attach(m_memorySlots[i], *m_memoryViews[i]);
+ attach(m_bufferSlots[i], *m_bufferViews[i]);
}
for (int i=0; i<m_samplers.size();i++)
{
@@ -350,9 +350,9 @@
begin();
clear();
- for (int i=0; i<m_memoryViews.size();i++)
+ for (int i=0; i<m_bufferViews.size();i++)
{
- attach(m_memorySlots[i], *m_memoryViews[i]);
+ attach(m_bufferSlots[i], *m_bufferViews[i]);
}
for (int i=0; i<m_samplers.size();i++)
{
@@ -365,7 +365,7 @@
end();
- // bind pipeline, vertex buffer (descriptor set) and WVP (dynamic memory view)
+ // bind pipeline, vertex buffer (descriptor set) and WVP (dynamic buffer view)
xglCmdBindDescriptorSet(commandBuffer, XGL_PIPELINE_BIND_POINT_GRAPHICS, 0, obj(), 0 );
}
@@ -548,7 +548,7 @@
m_device = device;
m_commandBuffer = 0;
- memset(&m_constantBufferView,0,sizeof(m_constantBufferView));
+ memset(&m_bufferViewInfo,0,sizeof(m_bufferViewInfo));
}
XglConstantBufferObj::XglConstantBufferObj(XglDevice *device, int constantCount, int constantSize, const void* data)
@@ -556,7 +556,7 @@
m_device = device;
m_commandBuffer = 0;
- memset(&m_constantBufferView,0,sizeof(m_constantBufferView));
+ memset(&m_bufferViewInfo,0,sizeof(m_bufferViewInfo));
m_numVertices = constantCount;
m_stride = constantSize;
@@ -567,27 +567,38 @@
memcpy(pData, data, allocationSize);
unmap();
- // set up the memory view for the constant buffer
- this->m_constantBufferView.stride = 16;
- this->m_constantBufferView.range = allocationSize;
- this->m_constantBufferView.offset = 0;
- this->m_constantBufferView.mem = obj();
- this->m_constantBufferView.format.channelFormat = XGL_CH_FMT_R32G32B32A32;
- this->m_constantBufferView.format.numericFormat = XGL_NUM_FMT_FLOAT;
- this->m_constantBufferView.state = XGL_MEMORY_STATE_DATA_TRANSFER;
+ // set up the buffer view for the constant buffer
+ XGL_BUFFER_VIEW_CREATE_INFO view_info = {};
+ view_info.sType = XGL_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO;
+ view_info.buffer = obj();
+ 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 = allocationSize;
+ m_bufferView.init(*m_device, view_info);
+
+ this->m_bufferViewInfo.sType = XGL_STRUCTURE_TYPE_BUFFER_VIEW_ATTACH_INFO;
+ this->m_bufferViewInfo.view = m_bufferView.obj();
+ this->m_bufferViewInfo.state = XGL_BUFFER_STATE_DATA_TRANSFER;
}
void XglConstantBufferObj::Bind(XGL_CMD_BUFFER cmdBuffer, XGL_GPU_SIZE offset, XGL_UINT binding)
{
- xglCmdBindVertexData(cmdBuffer, obj(), offset, binding);
+ xglCmdBindVertexBuffer(cmdBuffer, obj(), offset, binding);
}
-void XglConstantBufferObj::SetMemoryState(XGL_MEMORY_STATE newState)
+void XglConstantBufferObj::SetBufferState(XGL_BUFFER_STATE newState)
{
XGL_RESULT err = XGL_SUCCESS;
- if (this->m_constantBufferView.state == newState)
+ if (this->m_bufferViewInfo.state == newState)
return;
if (!m_commandBuffer)
@@ -611,12 +622,12 @@
err = m_commandBuffer->BeginCommandBuffer(&cmd_buf_info);
ASSERT_XGL_SUCCESS(err);
- XGL_MEMORY_STATE_TRANSITION transition =
- state_transition(XGL_MEMORY_STATE_DATA_TRANSFER, newState, 0, m_numVertices * m_stride);
+ XGL_BUFFER_STATE_TRANSITION transition =
+ state_transition(XGL_BUFFER_STATE_DATA_TRANSFER, newState, 0, m_numVertices * m_stride);
// write transition to the command buffer
- m_commandBuffer->PrepareMemoryRegions(1, &transition);
- this->m_constantBufferView.state = newState;
+ m_commandBuffer->PrepareBufferRegions(1, &transition);
+ this->m_bufferViewInfo.state = newState;
// finish recording the command buffer
err = m_commandBuffer->EndCommandBuffer();
@@ -626,7 +637,7 @@
XGL_MEMORY_REF memRefs;
// this command buffer only uses the vertex buffer memory
memRefs.flags = 0;
- memRefs.mem = obj();
+ memRefs.mem = memories()[0];
// submit the command buffer to the universal queue
XGL_CMD_BUFFER bufferArray[1];
@@ -673,19 +684,30 @@
memcpy(pData, data, allocationSize);
unmap();
- // set up the memory view for the constant buffer
- this->m_constantBufferView.stride = m_stride;
- this->m_constantBufferView.range = allocationSize;
- this->m_constantBufferView.offset = 0;
- this->m_constantBufferView.mem = obj();
- this->m_constantBufferView.format.channelFormat = viewFormat.channelFormat;
- this->m_constantBufferView.format.numericFormat = viewFormat.numericFormat;
- this->m_constantBufferView.state = XGL_MEMORY_STATE_DATA_TRANSFER;
+ // set up the buffer view for the constant buffer
+ XGL_BUFFER_VIEW_CREATE_INFO view_info = {};
+ view_info.sType = XGL_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO;
+ view_info.buffer = obj();
+ view_info.viewType = XGL_BUFFER_VIEW_TYPED;
+ view_info.stride = m_stride;
+ view_info.format.channelFormat = viewFormat.channelFormat;
+ view_info.format.numericFormat = viewFormat.numericFormat;
+ 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 = allocationSize;
+ m_bufferView.init(*m_device, view_info);
+
+ this->m_bufferViewInfo.sType = XGL_STRUCTURE_TYPE_BUFFER_VIEW_ATTACH_INFO;
+ this->m_bufferViewInfo.view = m_bufferView.obj();
+ this->m_bufferViewInfo.state = XGL_BUFFER_STATE_DATA_TRANSFER;
}
void XglIndexBufferObj::Bind(XGL_CMD_BUFFER cmdBuffer, XGL_GPU_SIZE offset)
{
- xglCmdBindIndexData(cmdBuffer, obj(), offset, m_indexType);
+ xglCmdBindIndexBuffer(cmdBuffer, obj(), offset, m_indexType);
}
XGL_INDEX_TYPE XglIndexBufferObj::GetIndexType()
@@ -703,8 +725,8 @@
stageInfo->shader.descriptorSetMapping[0].descriptorCount = 0;
stageInfo->shader.linkConstBufferCount = 0;
stageInfo->shader.pLinkConstBufferInfo = XGL_NULL_HANDLE;
- stageInfo->shader.dynamicMemoryViewMapping.slotObjectType = XGL_SLOT_UNUSED;
- stageInfo->shader.dynamicMemoryViewMapping.shaderEntityIndex = 0;
+ stageInfo->shader.dynamicBufferViewMapping.slotObjectType = XGL_SLOT_UNUSED;
+ stageInfo->shader.dynamicBufferViewMapping.shaderEntityIndex = 0;
stageInfo->shader.descriptorSetMapping[0].descriptorCount = descriptorSet->GetTotalSlots();
if (stageInfo->shader.descriptorSetMapping[0].descriptorCount)
@@ -713,15 +735,15 @@
vector<XGL_DESCRIPTOR_SET_SLOT_TYPE> allTypes;
vector<void *> allObjs;
- allSlots.reserve(m_memSlots.size() + m_imageSlots.size() + m_samplerSlots.size());
- allTypes.reserve(m_memTypes.size() + m_imageTypes.size() + m_samplerTypes.size());
- allObjs.reserve(m_memObjs.size() + m_imageObjs.size() + m_samplerObjs.size());
+ allSlots.reserve(m_bufferSlots.size() + m_imageSlots.size() + m_samplerSlots.size());
+ allTypes.reserve(m_bufferTypes.size() + m_imageTypes.size() + m_samplerTypes.size());
+ allObjs.reserve(m_bufferObjs.size() + m_imageObjs.size() + m_samplerObjs.size());
- if (m_memSlots.size())
+ if (m_bufferSlots.size())
{
- allSlots.insert(allSlots.end(), m_memSlots.begin(), m_memSlots.end());
- allTypes.insert(allTypes.end(), m_memTypes.begin(), m_memTypes.end());
- allObjs.insert(allObjs.end(), m_memObjs.begin(), m_memObjs.end());
+ allSlots.insert(allSlots.end(), m_bufferSlots.begin(), m_bufferSlots.end());
+ allTypes.insert(allTypes.end(), m_bufferTypes.begin(), m_bufferTypes.end());
+ allObjs.insert(allObjs.end(), m_bufferObjs.begin(), m_bufferObjs.end());
}
if (m_imageSlots.size())
{
@@ -742,11 +764,11 @@
return stageInfo;
}
-void XglShaderObj::BindShaderEntitySlotToMemory(int slot, XGL_DESCRIPTOR_SET_SLOT_TYPE type, XglConstantBufferObj *constantBuffer)
+void XglShaderObj::BindShaderEntitySlotToBuffer(int slot, XGL_DESCRIPTOR_SET_SLOT_TYPE type, XglConstantBufferObj *constantBuffer)
{
- m_memSlots.push_back(slot);
- m_memTypes.push_back(type);
- m_memObjs.push_back(&constantBuffer->m_constantBufferView);
+ m_bufferSlots.push_back(slot);
+ m_bufferTypes.push_back(type);
+ m_bufferObjs.push_back(&constantBuffer->m_bufferViewInfo);
}
@@ -943,7 +965,7 @@
for (int i=0; i < m_vertexBufferCount; i++)
{
- m_vertexBufferObjs[i]->Bind(m_cmdBuffer, m_vertexBufferObjs[i]->m_constantBufferView.offset, m_vertexBufferBindings[i]);
+ m_vertexBufferObjs[i]->Bind(m_cmdBuffer, 0, m_vertexBufferBindings[i]);
}
}
@@ -952,7 +974,9 @@
}
void XglMemoryRefManager::AddMemoryRef(XglConstantBufferObj *constantBuffer) {
- m_bufferObjs.push_back(constantBuffer->obj());
+ const std::vector<XGL_GPU_MEMORY> mems = constantBuffer->memories();
+ if (!mems.empty())
+ m_bufferObjs.push_back(mems[0]);
}
void XglMemoryRefManager::AddMemoryRef(XglTextureObj *texture) {
@@ -1017,9 +1041,9 @@
return XGL_SUCCESS;
}
-void XglCommandBufferObj::PrepareMemoryRegions(int transitionCount, XGL_MEMORY_STATE_TRANSITION *transitionPtr)
+void XglCommandBufferObj::PrepareBufferRegions(int transitionCount, XGL_BUFFER_STATE_TRANSITION *transitionPtr)
{
- xglCmdPrepareMemoryRegions(obj(), transitionCount, transitionPtr);
+ xglCmdPrepareBufferRegions(obj(), transitionCount, transitionPtr);
}
void XglCommandBufferObj::ClearAllBuffers(XGL_DEPTH_STENCIL_BIND_INFO *depthStencilBinding, XGL_IMAGE depthStencilImage)
@@ -1144,14 +1168,14 @@
void XglCommandBufferObj::BindDescriptorSet(XGL_DESCRIPTOR_SET descriptorSet)
{
- // bind pipeline, vertex buffer (descriptor set) and WVP (dynamic memory view)
+ // bind pipeline, vertex buffer (descriptor set) and WVP (dynamic buffer view)
xglCmdBindDescriptorSet(obj(), XGL_PIPELINE_BIND_POINT_GRAPHICS, 0, descriptorSet, 0 );
}
void XglCommandBufferObj::BindIndexBuffer(XglIndexBufferObj *indexBuffer, XGL_UINT offset)
{
- xglCmdBindIndexData(obj(), indexBuffer->obj(), offset, indexBuffer->GetIndexType());
+ xglCmdBindIndexBuffer(obj(), indexBuffer->obj(), offset, indexBuffer->GetIndexType());
}
void XglCommandBufferObj::BindVertexBuffer(XglConstantBufferObj *vertexBuffer, XGL_UINT offset, XGL_UINT binding)
{
- xglCmdBindVertexData(obj(), vertexBuffer->obj(), offset, binding);
+ xglCmdBindVertexBuffer(obj(), vertexBuffer->obj(), offset, binding);
}
diff --git a/tests/xglrenderframework.h b/tests/xglrenderframework.h
index f17ff4c..421f79d 100644
--- a/tests/xglrenderframework.h
+++ b/tests/xglrenderframework.h
@@ -116,7 +116,7 @@
XGL_RESULT BeginCommandBuffer(XGL_RENDER_PASS renderpass_obj);
XGL_RESULT BeginCommandBuffer();
XGL_RESULT EndCommandBuffer();
- void PrepareMemoryRegions(int transitionCount, XGL_MEMORY_STATE_TRANSITION *transitionPtr);
+ void PrepareBufferRegions(int transitionCount, XGL_BUFFER_STATE_TRANSITION *transitionPtr);
void AddRenderTarget(XglImage *renderTarget);
void AddDepthStencil();
void ClearAllBuffers();
@@ -138,17 +138,19 @@
};
-class XglConstantBufferObj : public xgl_testing::GpuMemory
+class XglConstantBufferObj : public xgl_testing::Buffer
{
public:
XglConstantBufferObj(XglDevice *device);
XglConstantBufferObj(XglDevice *device, int constantCount, int constantSize, const void* data);
- void SetMemoryState(XGL_MEMORY_STATE newState);
+ void SetBufferState(XGL_BUFFER_STATE newState);
void Bind(XGL_CMD_BUFFER cmdBuffer, XGL_GPU_SIZE offset, XGL_UINT binding);
- XGL_MEMORY_VIEW_ATTACH_INFO m_constantBufferView;
+
+ XGL_BUFFER_VIEW_ATTACH_INFO m_bufferViewInfo;
protected:
XglDevice *m_device;
+ xgl_testing::BufferView m_bufferView;
int m_numVertices;
int m_stride;
XglCommandBufferObj *m_commandBuffer;
@@ -258,7 +260,7 @@
{
public:
XglDescriptorSetObj(XglDevice *device);
- void AttachMemoryView(XglConstantBufferObj* constantBuffer);
+ void AttachBufferView(XglConstantBufferObj* constantBuffer);
void AttachSampler( XglSamplerObj* sampler);
void AttachImageView( XglTextureObj* texture);
void BindCommandBuffer(XGL_CMD_BUFFER commandBuffer);
@@ -271,8 +273,8 @@
XglDevice *m_device;
XGL_DESCRIPTOR_SLOT_INFO *m_slotInfo;
int m_nextSlot;
- vector<int> m_memorySlots;
- vector<XGL_MEMORY_VIEW_ATTACH_INFO*> m_memoryViews;
+ vector<int> m_bufferSlots;
+ vector<XGL_BUFFER_VIEW_ATTACH_INFO*> m_bufferViews;
vector<int> m_samplerSlots;
vector<XglSamplerObj*> m_samplers;
vector<int> m_imageSlots;
@@ -285,7 +287,7 @@
public:
XglShaderObj(XglDevice *device, const char * shaderText, XGL_PIPELINE_SHADER_STAGE stage, XglRenderFramework *framework);
XGL_PIPELINE_SHADER_STAGE_CREATE_INFO* GetStageCreateInfo(XglDescriptorSetObj *descriptorSet);
- void BindShaderEntitySlotToMemory(int slot, XGL_DESCRIPTOR_SET_SLOT_TYPE type, XglConstantBufferObj *constantBuffer);
+ void BindShaderEntitySlotToBuffer(int slot, XGL_DESCRIPTOR_SET_SLOT_TYPE type, XglConstantBufferObj *constantBuffer);
void BindShaderEntitySlotToImage(int slot, XGL_DESCRIPTOR_SET_SLOT_TYPE type, XglTextureObj *texture);
void BindShaderEntitySlotToSampler(int slot, XglSamplerObj *sampler);
@@ -293,9 +295,9 @@
XGL_PIPELINE_SHADER_STAGE_CREATE_INFO stage_info;
XGL_PIPELINE_SHADER_STAGE m_stage;
XglDevice *m_device;
- vector<int> m_memSlots;
- vector<XGL_DESCRIPTOR_SET_SLOT_TYPE> m_memTypes;
- vector<XGL_MEMORY_VIEW_ATTACH_INFO*> m_memObjs;
+ vector<int> m_bufferSlots;
+ vector<XGL_DESCRIPTOR_SET_SLOT_TYPE> m_bufferTypes;
+ vector<XGL_BUFFER_VIEW_ATTACH_INFO*> m_bufferObjs;
vector<int> m_samplerSlots;
vector<XGL_DESCRIPTOR_SET_SLOT_TYPE> m_samplerTypes;
vector<XglSamplerObj*> m_samplerObjs;
diff --git a/tests/xgltestbinding.cpp b/tests/xgltestbinding.cpp
index 0417732..b738734 100644
--- a/tests/xgltestbinding.cpp
+++ b/tests/xgltestbinding.cpp
@@ -233,6 +233,12 @@
EXPECT(!alloc_idx && xglBindObjectMemory(obj(), mem.obj(), mem_offset) == XGL_SUCCESS);
}
+void Object::bind_memory(uint32_t alloc_idx, XGL_GPU_SIZE offset, XGL_GPU_SIZE size,
+ const GpuMemory &mem, XGL_GPU_SIZE mem_offset)
+{
+ EXPECT(!alloc_idx && xglBindObjectMemoryRange(obj(), offset, size, mem.obj(), mem_offset) == XGL_SUCCESS);
+}
+
void Object::unbind_memory(uint32_t alloc_idx)
{
EXPECT(!alloc_idx && xglBindObjectMemory(obj(), XGL_NULL_HANDLE, 0) == XGL_SUCCESS);
@@ -255,6 +261,21 @@
for (int i = 0; i < mem_reqs.size(); i++) {
XGL_MEMORY_ALLOC_INFO info = GpuMemory::alloc_info(mem_reqs[i]);
+ // prefer CPU visible heaps
+ std::vector<uint32_t> non_visible_heaps;
+ info.heapCount = 0;
+ for (uint32_t j = 0; j < mem_reqs[i].heapCount; j++) {
+ const uint32_t heap = mem_reqs[i].heaps[j];
+ const XGL_MEMORY_HEAP_PROPERTIES &props = dev.heap_properties()[heap];
+
+ if (props.flags & XGL_MEMORY_HEAP_CPU_VISIBLE_BIT)
+ info.heaps[info.heapCount++] = heap;
+ else
+ non_visible_heaps.push_back(heap);
+ }
+ for (std::vector<uint32_t>::const_iterator it = non_visible_heaps.begin(); it != non_visible_heaps.end(); it++)
+ info.heaps[info.heapCount++] = *it;
+
primary_mem_ = &internal_mems_[i];
internal_mems_[i].init(dev, info);
@@ -496,24 +517,6 @@
DERIVED_OBJECT_INIT(xglAllocMemory, dev.obj(), &info);
}
-void GpuMemory::init(const Device &dev, XGL_GPU_SIZE size)
-{
- XGL_MEMORY_ALLOC_INFO info = {};
- info.sType = XGL_STRUCTURE_TYPE_MEMORY_ALLOC_INFO;
- info.allocationSize = size;
- info.memPriority = XGL_MEMORY_PRIORITY_NORMAL;
-
- // find CPU visible heaps
- for (XGL_UINT id = 0; id < dev.heap_properties().size(); id++) {
- const XGL_MEMORY_HEAP_PROPERTIES &heap = dev.heap_properties()[id];
- if (heap.flags & XGL_MEMORY_HEAP_CPU_VISIBLE_BIT)
- info.heaps[info.heapCount++] = id;
- }
-
- EXPECT(info.heapCount);
- init(dev, info);
-}
-
void GpuMemory::init(const Device &dev, size_t size, const void *data)
{
DERIVED_OBJECT_INIT(xglPinSystemMemory, dev.obj(), data, size);
@@ -610,6 +613,24 @@
return err;
}
+void Buffer::init(const Device &dev, const XGL_BUFFER_CREATE_INFO &info)
+{
+ init_no_mem(dev, info);
+ alloc_memory(dev);
+}
+
+void Buffer::init_no_mem(const Device &dev, const XGL_BUFFER_CREATE_INFO &info)
+{
+ DERIVED_OBJECT_INIT(xglCreateBuffer, dev.obj(), &info);
+ create_info_ = info;
+}
+
+void BufferView::init(const Device &dev, const XGL_BUFFER_VIEW_CREATE_INFO &info)
+{
+ DERIVED_OBJECT_INIT(xglCreateBufferView, dev.obj(), &info);
+ alloc_memory(dev);
+}
+
void Image::init(const Device &dev, const XGL_IMAGE_CREATE_INFO &info)
{
init_no_mem(dev, info);
@@ -645,6 +666,12 @@
}
}
+void Image::bind_memory(uint32_t alloc_idx, const XGL_IMAGE_MEMORY_BIND_INFO &info,
+ const GpuMemory &mem, XGL_GPU_SIZE mem_offset)
+{
+ EXPECT(!alloc_idx && xglBindImageMemoryRange(obj(), &info, mem.obj(), mem_offset) == XGL_SUCCESS);
+}
+
XGL_SUBRESOURCE_LAYOUT Image::subresource_layout(const XGL_IMAGE_SUBRESOURCE &subres) const
{
const XGL_SUBRESOURCE_INFO_TYPE type = XGL_INFO_TYPE_SUBRESOURCE_LAYOUT;
@@ -752,9 +779,9 @@
xglAttachImageViewDescriptors(obj(), start_slot, img_views.size(), &img_views[0]);
}
-void DescriptorSet::attach(uint32_t start_slot, const std::vector<XGL_MEMORY_VIEW_ATTACH_INFO> &mem_views)
+void DescriptorSet::attach(uint32_t start_slot, const std::vector<XGL_BUFFER_VIEW_ATTACH_INFO> &buf_views)
{
- xglAttachMemoryViewDescriptors(obj(), start_slot, mem_views.size(), &mem_views[0]);
+ xglAttachBufferViewDescriptors(obj(), start_slot, buf_views.size(), &buf_views[0]);
}
void DescriptorSet::attach(uint32_t start_slot, const std::vector<XGL_DESCRIPTOR_SET_ATTACH_INFO> &sets)
diff --git a/tests/xgltestbinding.h b/tests/xgltestbinding.h
index 0e9e28a..725cb9d 100644
--- a/tests/xgltestbinding.h
+++ b/tests/xgltestbinding.h
@@ -43,6 +43,8 @@
class QueueSemaphore;
class Event;
class QueryPool;
+class Buffer;
+class BufferView;
class Image;
class ImageView;
class ColorAttachmentView;
@@ -127,6 +129,10 @@
void unbind_memory(uint32_t alloc_idx);
void unbind_memory();
+ // xglBindObjectMemoryRange()
+ void bind_memory(uint32_t alloc_idx, XGL_GPU_SIZE offset, XGL_GPU_SIZE size,
+ const GpuMemory &mem, XGL_GPU_SIZE mem_offset);
+
// Unless an object is initialized with init_no_mem(), memories are
// automatically allocated and bound. These methods can be used to get
// the memories (for XGL_MEMORY_REFs), or to map/unmap the primary memory.
@@ -262,13 +268,10 @@
class GpuMemory : public DerivedObject<XGL_GPU_MEMORY, BaseObject> {
public:
- explicit GpuMemory() {}
- explicit GpuMemory(const Device &dev, XGL_GPU_SIZE size) { init(dev, size); }
~GpuMemory();
// xglAllocMemory()
void init(const Device &dev, const XGL_MEMORY_ALLOC_INFO &info);
- void init(const Device &dev, XGL_GPU_SIZE size);
// xglPinSystemMemory()
void init(const Device &dev, size_t size, const void *data);
// xglOpenSharedMemory()
@@ -290,19 +293,6 @@
// xglUnmapMemory()
void unmap() const;
- XGL_MEMORY_STATE_TRANSITION state_transition(XGL_MEMORY_STATE old_state, XGL_MEMORY_STATE new_state,
- XGL_GPU_SIZE offset, XGL_GPU_SIZE size) const
- {
- XGL_MEMORY_STATE_TRANSITION transition = {};
- transition.sType = XGL_STRUCTURE_TYPE_MEMORY_STATE_TRANSITION;
- transition.mem = obj();
- transition.oldState = old_state;
- transition.newState = new_state;
- transition.offset = offset;
- transition.regionSize = size;
- return transition;
- }
-
static XGL_MEMORY_ALLOC_INFO alloc_info(const XGL_MEMORY_REQUIREMENTS &reqs);
};
@@ -353,6 +343,41 @@
static XGL_QUERY_POOL_CREATE_INFO create_info(XGL_QUERY_TYPE type, uint32_t slot_count);
};
+class Buffer : public DerivedObject<XGL_BUFFER, Object> {
+public:
+ explicit Buffer() {}
+ explicit Buffer(const Device &dev, const XGL_BUFFER_CREATE_INFO &info) { init(dev, info); }
+ explicit Buffer(const Device &dev, XGL_GPU_SIZE size) { init(dev, size); }
+
+ // xglCreateBuffer()
+ void init(const Device &dev, const XGL_BUFFER_CREATE_INFO &info);
+ void init(const Device &dev, XGL_GPU_SIZE size) { init(dev, create_info(size, 0)); }
+ void init_no_mem(const Device &dev, const XGL_BUFFER_CREATE_INFO &info);
+
+ static XGL_BUFFER_CREATE_INFO create_info(XGL_GPU_SIZE size, XGL_FLAGS usage);
+
+ XGL_BUFFER_STATE_TRANSITION state_transition(XGL_BUFFER_STATE old_state, XGL_BUFFER_STATE new_state,
+ XGL_GPU_SIZE offset, XGL_GPU_SIZE size) const
+ {
+ XGL_BUFFER_STATE_TRANSITION transition = {};
+ transition.sType = XGL_STRUCTURE_TYPE_BUFFER_STATE_TRANSITION;
+ transition.buffer = obj();
+ transition.oldState = old_state;
+ transition.newState = new_state;
+ transition.offset = offset;
+ transition.regionSize = size;
+ return transition;
+ }
+private:
+ XGL_BUFFER_CREATE_INFO create_info_;
+};
+
+class BufferView : public DerivedObject<XGL_BUFFER_VIEW, Object> {
+public:
+ // xglCreateBufferView()
+ void init(const Device &dev, const XGL_BUFFER_VIEW_CREATE_INFO &info);
+};
+
class Image : public DerivedObject<XGL_IMAGE, Object> {
public:
explicit Image() : format_features_(0) {}
@@ -364,6 +389,10 @@
// xglOpenPeerImage()
void init(const Device &dev, const XGL_PEER_IMAGE_OPEN_INFO &info, const XGL_IMAGE_CREATE_INFO &original_info);
+ // xglBindImageMemoryRange()
+ void bind_memory(uint32_t alloc_idx, const XGL_IMAGE_MEMORY_BIND_INFO &info,
+ const GpuMemory &mem, XGL_GPU_SIZE mem_offset);
+
// xglGetImageSubresourceInfo()
XGL_SUBRESOURCE_LAYOUT subresource_layout(const XGL_IMAGE_SUBRESOURCE &subres) const;
@@ -483,11 +512,11 @@
attach(start_slot, std::vector<XGL_IMAGE_VIEW_ATTACH_INFO>(1, view));
}
- // xglAttachMemoryViewDescriptors()
- void attach(uint32_t start_slot, const std::vector<XGL_MEMORY_VIEW_ATTACH_INFO> &mem_views);
- void attach(uint32_t start_slot, const XGL_MEMORY_VIEW_ATTACH_INFO &view)
+ // xglAttachBufferViewDescriptors()
+ void attach(uint32_t start_slot, const std::vector<XGL_BUFFER_VIEW_ATTACH_INFO> &buf_views);
+ void attach(uint32_t start_slot, const XGL_BUFFER_VIEW_ATTACH_INFO &view)
{
- attach(start_slot, std::vector<XGL_MEMORY_VIEW_ATTACH_INFO>(1, view));
+ attach(start_slot, std::vector<XGL_BUFFER_VIEW_ATTACH_INFO>(1, view));
}
// xglAttachNestedDescriptors()
@@ -593,6 +622,15 @@
return info;
}
+inline XGL_BUFFER_CREATE_INFO Buffer::create_info(XGL_GPU_SIZE size, XGL_FLAGS usage)
+{
+ XGL_BUFFER_CREATE_INFO info = {};
+ info.sType = XGL_STRUCTURE_TYPE_BUFFER_CREATE_INFO;
+ info.size = size;
+ info.usage = usage;
+ return info;
+}
+
inline XGL_FENCE_CREATE_INFO Fence::create_info(XGL_FLAGS flags)
{
XGL_FENCE_CREATE_INFO info = {};
diff --git a/xgl.py b/xgl.py
index 2297f94..ef59f80 100644
--- a/xgl.py
+++ b/xgl.py
@@ -189,6 +189,8 @@
"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 @@
"XGL_EVENT",
"XGL_QUERY_POOL",
"XGL_FRAMEBUFFER",
- "XGL_RENDER_PASS"
+ "XGL_RENDER_PASS",
],
protos=[
Proto("XGL_RESULT", "InitAndEnumerateGpus",
@@ -312,15 +314,6 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
[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 @@
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 @@
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 @@
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",