driver:implement changes for Dynamic State
diff --git a/include/xgl.h b/include/xgl.h
index d68047a..5f90b43 100644
--- a/include/xgl.h
+++ b/include/xgl.h
@@ -92,12 +92,11 @@
XGL_DEFINE_SUBCLASS_HANDLE(XGL_PIPELINE_DELTA, XGL_OBJECT)
XGL_DEFINE_SUBCLASS_HANDLE(XGL_SAMPLER, XGL_OBJECT)
XGL_DEFINE_SUBCLASS_HANDLE(XGL_DESCRIPTOR_SET, XGL_OBJECT)
-XGL_DEFINE_SUBCLASS_HANDLE(XGL_STATE_OBJECT, XGL_OBJECT)
-XGL_DEFINE_SUBCLASS_HANDLE(XGL_VIEWPORT_STATE_OBJECT, XGL_STATE_OBJECT)
-XGL_DEFINE_SUBCLASS_HANDLE(XGL_RASTER_STATE_OBJECT, XGL_STATE_OBJECT)
-XGL_DEFINE_SUBCLASS_HANDLE(XGL_MSAA_STATE_OBJECT, XGL_STATE_OBJECT)
-XGL_DEFINE_SUBCLASS_HANDLE(XGL_COLOR_BLEND_STATE_OBJECT, XGL_STATE_OBJECT)
-XGL_DEFINE_SUBCLASS_HANDLE(XGL_DEPTH_STENCIL_STATE_OBJECT, XGL_STATE_OBJECT)
+XGL_DEFINE_SUBCLASS_HANDLE(XGL_DYNAMIC_STATE_OBJECT, XGL_OBJECT)
+XGL_DEFINE_SUBCLASS_HANDLE(XGL_DYNAMIC_VP_STATE_OBJECT, XGL_DYNAMIC_STATE_OBJECT)
+XGL_DEFINE_SUBCLASS_HANDLE(XGL_DYNAMIC_RS_STATE_OBJECT, XGL_DYNAMIC_STATE_OBJECT)
+XGL_DEFINE_SUBCLASS_HANDLE(XGL_DYNAMIC_CB_STATE_OBJECT, XGL_DYNAMIC_STATE_OBJECT)
+XGL_DEFINE_SUBCLASS_HANDLE(XGL_DYNAMIC_DS_STATE_OBJECT, XGL_DYNAMIC_STATE_OBJECT)
XGL_DEFINE_SUBCLASS_HANDLE(XGL_CMD_BUFFER, XGL_OBJECT)
XGL_DEFINE_SUBCLASS_HANDLE(XGL_FENCE, XGL_OBJECT)
XGL_DEFINE_SUBCLASS_HANDLE(XGL_QUEUE_SEMAPHORE, XGL_OBJECT)
@@ -108,10 +107,6 @@
#define XGL_MAX_PHYSICAL_GPUS 16
#define XGL_MAX_PHYSICAL_GPU_NAME 256
-#define XGL_MAX_MEMORY_HEAPS 8
-#define XGL_MAX_DESCRIPTOR_SETS 2
-#define XGL_MAX_VIEWPORTS 16
-#define XGL_MAX_COLOR_ATTACHMENTS 8
#define XGL_LOD_CLAMP_NONE MAX_FLOAT
#define XGL_LAST_MIP_OR_SLICE 0xffffffff
@@ -343,12 +338,11 @@
{
XGL_STATE_BIND_VIEWPORT = 0x00000000,
XGL_STATE_BIND_RASTER = 0x00000001,
- XGL_STATE_BIND_DEPTH_STENCIL = 0x00000002,
- XGL_STATE_BIND_COLOR_BLEND = 0x00000003,
- XGL_STATE_BIND_MSAA = 0x00000004,
+ XGL_STATE_BIND_COLOR_BLEND = 0x00000002,
+ XGL_STATE_BIND_DEPTH_STENCIL = 0x00000003,
XGL_STATE_BIND_POINT_BEGIN_RANGE = XGL_STATE_BIND_VIEWPORT,
- XGL_STATE_BIND_POINT_END_RANGE = XGL_STATE_BIND_MSAA,
+ XGL_STATE_BIND_POINT_END_RANGE = XGL_STATE_BIND_DEPTH_STENCIL,
XGL_NUM_STATE_BIND_POINT = (XGL_STATE_BIND_POINT_END_RANGE - XGL_STATE_BIND_POINT_BEGIN_RANGE + 1),
XGL_MAX_ENUM(_XGL_STATE_BIND_POINT)
} XGL_STATE_BIND_POINT;
@@ -469,6 +463,39 @@
XGL_MAX_ENUM(_XGL_FACE_ORIENTATION)
} XGL_FACE_ORIENTATION;
+typedef enum _XGL_PROVOKING_VERTEX_CONVENTION
+{
+ XGL_PROVOKING_VERTEX_FIRST = 0x00000000,
+ XGL_PROVOKING_VERTEX_LAST = 0x00000001,
+
+ XGL_PROVOKING_VERTEX_BEGIN_RANGE = XGL_PROVOKING_VERTEX_FIRST,
+ XGL_PROVOKING_VERTEX_END_RANGE = XGL_PROVOKING_VERTEX_LAST,
+ XGL_NUM_PROVOKING_VERTEX_CONVENTION = (XGL_PROVOKING_VERTEX_END_RANGE - XGL_PROVOKING_VERTEX_BEGIN_RANGE + 1),
+ XGL_MAX_ENUM(_XGL_PROVOKING_VERTEX_CONVENTION)
+} XGL_PROVOKING_VERTEX_CONVENTION;
+
+typedef enum _XGL_COORDINATE_ORIGIN
+{
+ XGL_COORDINATE_ORIGIN_UPPER_LEFT = 0x00000000,
+ XGL_COORDINATE_ORIGIN_LOWER_LEFT = 0x00000001,
+
+ XGL_COORDINATE_ORIGIN_BEGIN_RANGE = XGL_COORDINATE_ORIGIN_UPPER_LEFT,
+ XGL_COORDINATE_ORIGIN_END_RANGE = XGL_COORDINATE_ORIGIN_LOWER_LEFT,
+ XGL_NUM_COORDINATE_ORIGIN = (XGL_COORDINATE_ORIGIN_END_RANGE - XGL_COORDINATE_ORIGIN_END_RANGE + 1),
+ XGL_MAX_ENUM(_XGL_COORDINATE_ORIGIN)
+} XGL_COORDINATE_ORIGIN;
+
+typedef enum _XGL_DEPTH_MODE
+{
+ XGL_DEPTH_MODE_ZERO_TO_ONE = 0x00000000,
+ XGL_DEPTH_MODE_NEGATIVE_ONE_TO_ONE = 0x00000001,
+
+ XGL_DEPTH_MODE_BEGIN_RANGE = XGL_DEPTH_MODE_ZERO_TO_ONE,
+ XGL_DEPTH_MODE_END_RANGE = XGL_DEPTH_MODE_NEGATIVE_ONE_TO_ONE,
+ XGL_NUM_DEPTH_MODE = (XGL_DEPTH_MODE_END_RANGE - XGL_DEPTH_MODE_BEGIN_RANGE + 1),
+ XGL_MAX_ENUM(_XGL_DEPTH_MODE)
+} XGL_DEPTH_MODE;
+
typedef enum _XGL_BLEND
{
XGL_BLEND_ZERO = 0x00000000,
@@ -802,17 +829,6 @@
XGL_MAX_ENUM(_XGL_NUM_FORMAT)
} XGL_NUM_FORMAT;
-typedef enum _XGL_PROVOKING_VERTEX_CONVENTION
-{
- XGL_PROVOKING_VERTEX_FIRST = 0,
- XGL_PROVOKING_VERTEX_LAST = 1,
-
- XGL_PROVOKING_VERTEX_BEGIN_RANGE = XGL_PROVOKING_VERTEX_FIRST,
- XGL_PROVOKING_VERTEX_END_RANGE = XGL_PROVOKING_VERTEX_LAST,
- XGL_NUM_PROVOKING_VERTEX_CONVENTIONS = (XGL_PROVOKING_VERTEX_END_RANGE - XGL_PROVOKING_VERTEX_BEGIN_RANGE + 1),
- XGL_MAX_ENUM(_XGL_PROVOKING_VERTEX_CONVENTION)
-} XGL_PROVOKING_VERTEX_CONVENTION;
-
// IMG CHANGE BEGIN - support for vertex input description
typedef enum _XGL_VERTEX_INPUT_STEP_RATE
{
@@ -870,10 +886,10 @@
XGL_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO = 13,
XGL_STRUCTURE_TYPE_SAMPLER_CREATE_INFO = 14,
XGL_STRUCTURE_TYPE_DESCRIPTOR_SET_CREATE_INFO = 15,
- XGL_STRUCTURE_TYPE_RASTER_STATE_CREATE_INFO = 16,
- XGL_STRUCTURE_TYPE_MSAA_STATE_CREATE_INFO = 17,
- XGL_STRUCTURE_TYPE_COLOR_BLEND_STATE_CREATE_INFO = 18,
- XGL_STRUCTURE_TYPE_DEPTH_STENCIL_STATE_CREATE_INFO = 19,
+ XGL_STRUCTURE_TYPE_DYNAMIC_VP_STATE_CREATE_INFO = 16,
+ XGL_STRUCTURE_TYPE_DYNAMIC_RS_STATE_CREATE_INFO = 17,
+ XGL_STRUCTURE_TYPE_DYNAMIC_CB_STATE_CREATE_INFO = 18,
+ XGL_STRUCTURE_TYPE_DYNAMIC_DS_STATE_CREATE_INFO = 19,
XGL_STRUCTURE_TYPE_CMD_BUFFER_CREATE_INFO = 20,
XGL_STRUCTURE_TYPE_EVENT_CREATE_INFO = 21,
XGL_STRUCTURE_TYPE_FENCE_CREATE_INFO = 22,
@@ -882,12 +898,15 @@
XGL_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO = 25,
XGL_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO = 26,
XGL_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO = 27,
- XGL_STRUCTURE_TYPE_PIPELINE_IA_STATE_CREATE_INFO = 28,
- XGL_STRUCTURE_TYPE_PIPELINE_DB_STATE_CREATE_INFO = 29,
- XGL_STRUCTURE_TYPE_PIPELINE_CB_STATE_CREATE_INFO = 30,
- 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_PIPELINE_VERTEX_INPUT_CREATE_INFO = 28,
+ XGL_STRUCTURE_TYPE_PIPELINE_IA_STATE_CREATE_INFO = 29,
+ XGL_STRUCTURE_TYPE_PIPELINE_TESS_STATE_CREATE_INFO = 30,
+ XGL_STRUCTURE_TYPE_PIPELINE_VP_STATE_CREATE_INFO = 31,
+ XGL_STRUCTURE_TYPE_PIPELINE_RS_STATE_CREATE_INFO = 32,
+ XGL_STRUCTURE_TYPE_PIPELINE_MS_STATE_CREATE_INFO = 33,
+ XGL_STRUCTURE_TYPE_PIPELINE_CB_STATE_CREATE_INFO = 34,
+ XGL_STRUCTURE_TYPE_PIPELINE_DS_STATE_CREATE_INFO = 35,
+ XGL_STRUCTURE_TYPE_IMAGE_CREATE_INFO = 36,
XGL_STRUCTURE_TYPE_BUFFER_CREATE_INFO = 37,
XGL_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO = 38,
XGL_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO = 39,
@@ -895,9 +914,6 @@
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 = 90,
-// IMG CHANGE END
XGL_MAX_ENUM(_XGL_STRUCTURE_TYPE)
} XGL_STRUCTURE_TYPE;
@@ -1122,6 +1138,10 @@
XGL_UINT maxThreadGroupSize;
XGL_UINT64 timestampFrequency;
XGL_BOOL multiColorAttachmentClears;
+ XGL_UINT maxMemoryHeaps; // at least 8?
+ XGL_UINT maxDescriptorSets; // at least 2?
+ XGL_UINT maxViewports; // at least 16?
+ XGL_UINT maxColorAttachments; // at least 8?
} XGL_PHYSICAL_GPU_PROPERTIES;
typedef struct _XGL_PHYSICAL_GPU_PERFORMANCE
@@ -1229,7 +1249,7 @@
XGL_GPU_SIZE alignment;
XGL_FLAGS flags; // XGL_MEMORY_ALLOC_FLAGS
XGL_UINT heapCount;
- XGL_UINT heaps[XGL_MAX_MEMORY_HEAPS];
+ const XGL_UINT* pHeaps;
XGL_MEMORY_PRIORITY memPriority;
} XGL_MEMORY_ALLOC_INFO;
@@ -1253,7 +1273,7 @@
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_UINT* pHeaps;
} XGL_MEMORY_REQUIREMENTS;
typedef struct _XGL_FORMAT_PROPERTIES
@@ -1498,7 +1518,8 @@
{
XGL_PIPELINE_SHADER_STAGE stage;
XGL_SHADER shader;
- XGL_DESCRIPTOR_SET_MAPPING descriptorSetMapping[XGL_MAX_DESCRIPTOR_SETS];
+ XGL_UINT descriptorSetMappingCount;
+ XGL_DESCRIPTOR_SET_MAPPING* pDescriptorSetMapping;
XGL_UINT linkConstBufferCount;
const XGL_LINK_CONST_BUFFER* pLinkConstBufferInfo;
XGL_DYNAMIC_BUFFER_VIEW_SLOT_INFO dynamicBufferViewMapping;
@@ -1565,10 +1586,9 @@
XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_PIPELINE_IA_STATE_CREATE_INFO
const XGL_VOID* pNext; // Pointer to next structure
XGL_PRIMITIVE_TOPOLOGY topology;
- XGL_BOOL disableVertexReuse;
- XGL_PROVOKING_VERTEX_CONVENTION provokingVertex;
+ XGL_BOOL disableVertexReuse; //optional
XGL_BOOL primitiveRestartEnable;
- XGL_UINT32 primitiveRestartIndex;
+ XGL_UINT32 primitiveRestartIndex; //optional (GL45)
} XGL_PIPELINE_IA_STATE_CREATE_INFO;
typedef struct _XGL_PIPELINE_TESS_STATE_CREATE_INFO
@@ -1580,19 +1600,51 @@
XGL_FLOAT fixedTessFactor;
} XGL_PIPELINE_TESS_STATE_CREATE_INFO;
+typedef struct _XGL_PIPELINE_VP_STATE_CREATE_INFO
+{
+ XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_PIPELINE_VP_STATE_CREATE_INFO
+ const void* pNext; // Pointer to next structure
+ XGL_UINT numViewports;
+ XGL_UINT scissorEnable;
+ XGL_COORDINATE_ORIGIN clipOrigin; // optional (GL45)
+ XGL_DEPTH_MODE depthMode; // optional (GL45)
+} XGL_PIPELINE_VP_STATE_CREATE_INFO;
+
typedef struct _XGL_PIPELINE_RS_STATE_CREATE_INFO
{
XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_PIPELINE_RS_STATE_CREATE_INFO
const XGL_VOID* pNext; // Pointer to next structure
XGL_BOOL depthClipEnable;
XGL_BOOL rasterizerDiscardEnable;
- XGL_FLOAT pointSize; // Size of points
+ XGL_BOOL programPointSize; // optional (GL45)
+ XGL_COORDINATE_ORIGIN pointOrigin; // optional (GL45)
+ XGL_PROVOKING_VERTEX_CONVENTION provokingVertex; // optional (GL45)
+ XGL_FILL_MODE fillMode; // optional (GL45)
+ XGL_CULL_MODE cullMode;
+ XGL_FACE_ORIENTATION frontFace;
} XGL_PIPELINE_RS_STATE_CREATE_INFO;
+typedef struct _XGL_PIPELINE_MS_STATE_CREATE_INFO
+{
+ XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_PIPELINE_MS_STATE_CREATE_INFO
+ const XGL_VOID* pNext; // Pointer to next structure
+ XGL_UINT samples;
+ XGL_BOOL multisampleEnable; // optional (GL45)
+ XGL_BOOL sampleShadingEnable; // optional (GL45)
+ XGL_FLOAT minSampleShading; // optional (GL45)
+ XGL_SAMPLE_MASK sampleMask;
+} XGL_PIPELINE_MS_STATE_CREATE_INFO;
+
typedef struct _XGL_PIPELINE_CB_ATTACHMENT_STATE
{
XGL_BOOL blendEnable;
XGL_FORMAT format;
+ XGL_BLEND srcBlendColor;
+ XGL_BLEND destBlendColor;
+ XGL_BLEND_FUNC blendFuncColor;
+ XGL_BLEND srcBlendAlpha;
+ XGL_BLEND destBlendAlpha;
+ XGL_BLEND_FUNC blendFuncAlpha;
XGL_UINT8 channelWriteMask;
} XGL_PIPELINE_CB_ATTACHMENT_STATE;
@@ -1601,17 +1653,35 @@
XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_PIPELINE_CB_STATE_CREATE_INFO
const XGL_VOID* pNext; // Pointer to next structure
XGL_BOOL alphaToCoverageEnable;
- XGL_BOOL dualSourceBlendEnable;
+ XGL_BOOL dualSourceBlendEnable; // optional (GL45)
+ XGL_BOOL logicOpEnable;
XGL_LOGIC_OP logicOp;
- XGL_PIPELINE_CB_ATTACHMENT_STATE attachment[XGL_MAX_COLOR_ATTACHMENTS];
-} XGL_PIPELINE_CB_STATE;
+ XGL_UINT attachmentCount; // # of pAttachments
+ XGL_PIPELINE_CB_ATTACHMENT_STATE* pAttachments;
+} XGL_PIPELINE_CB_STATE_CREATE_INFO;
-typedef struct _XGL_PIPELINE_DB_STATE_CREATE_INFO
+typedef struct _XGL_STENCIL_OP_STATE
{
- XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_PIPELINE_DB_STATE_CREATE_INFO
- const XGL_VOID* pNext; // Pointer to next structure
- XGL_FORMAT format;
-} XGL_PIPELINE_DB_STATE_CREATE_INFO;
+ XGL_STENCIL_OP stencilFailOp;
+ XGL_STENCIL_OP stencilPassOp;
+ XGL_STENCIL_OP stencilDepthFailOp;
+ XGL_COMPARE_FUNC stencilFunc;
+} XGL_STENCIL_OP_STATE;
+
+typedef struct _XGL_PIPELINE_DS_STATE_CREATE_INFO
+{
+ XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_PIPELINE_DS_STATE_CREATE_INFO
+ const void* pNext; // Pointer to next structure
+ XGL_FORMAT format;
+ XGL_BOOL depthTestEnable;
+ XGL_BOOL depthWriteEnable;
+ XGL_COMPARE_FUNC depthFunc;
+ XGL_BOOL depthBoundsEnable; // optional (depth_bounds_test)
+ XGL_BOOL stencilTestEnable;
+ XGL_STENCIL_OP_STATE front;
+ XGL_STENCIL_OP_STATE back;
+} XGL_PIPELINE_DS_STATE_CREATE_INFO;
+
typedef struct _XGL_PIPELINE_SHADER_STAGE_CREATE_INFO
{
@@ -1649,7 +1719,7 @@
{
XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_DESCRIPTOR_SET_CREATE_INFO
const XGL_VOID* pNext; // Pointer to next structure
- XGL_UINT slots;
+ XGL_UINT slots;
} XGL_DESCRIPTOR_SET_CREATE_INFO;
typedef struct _XGL_DESCRIPTOR_SET_ATTACH_INFO
@@ -1658,25 +1728,27 @@
XGL_UINT slotOffset;
} XGL_DESCRIPTOR_SET_ATTACH_INFO;
-typedef struct _XGL_VIEWPORT_STATE_CREATE_INFO
+typedef struct _XGL_DYNAMIC_VP_STATE_CREATE_INFO
{
- XGL_UINT viewportCount;
- XGL_BOOL scissorEnable;
- XGL_VIEWPORT viewports[XGL_MAX_VIEWPORTS];
- XGL_RECT scissors[XGL_MAX_VIEWPORTS];
-} XGL_VIEWPORT_STATE_CREATE_INFO;
+ XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_DYNAMIC_VP_STATE_CREATE_INFO
+ const void* pNext; // Pointer to next structure
+ XGL_UINT viewportCount; // number of entries in pViewports
+ XGL_VIEWPORT* pViewports;
+ XGL_UINT scissorCount; // number of entries in pScissors
+ XGL_RECT* pScissors;
+} XGL_DYNAMIC_VP_STATE_CREATE_INFO;
-typedef struct _XGL_RASTER_STATE_CREATE_INFO
+typedef struct _XGL_DYNAMIC_RS_STATE_CREATE_INFO
{
- XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_RASTER_STATE_CREATE_INFO
+ XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_DYNAMIC_RS_STATE_CREATE_INFO
const XGL_VOID* pNext; // Pointer to next structure
- XGL_FILL_MODE fillMode;
- XGL_CULL_MODE cullMode;
- XGL_FACE_ORIENTATION frontFace;
- XGL_INT depthBias;
+ XGL_FLOAT depthBias;
XGL_FLOAT depthBiasClamp;
XGL_FLOAT slopeScaledDepthBias;
-} XGL_RASTER_STATE_CREATE_INFO;
+ XGL_FLOAT pointSize; // optional (GL45) - Size of point
+ XGL_FLOAT pointFadeThreshold; // optional (GL45) - Size of point fade threshold
+ XGL_FLOAT lineWidth; // optional (GL45) - Width of lines
+} XGL_DYNAMIC_RS_STATE_CREATE_INFO;
typedef struct _XGL_MSAA_STATE_CREATE_INFO
{
@@ -1686,50 +1758,24 @@
XGL_SAMPLE_MASK sampleMask;
} XGL_MSAA_STATE_CREATE_INFO;
-typedef struct _XGL_COLOR_ATTACHMENT_BLEND_STATE
+typedef struct _XGL_DYNAMIC_CB_STATE_CREATE_INFO
{
- XGL_BOOL blendEnable;
- XGL_BLEND srcBlendColor;
- XGL_BLEND destBlendColor;
- XGL_BLEND_FUNC blendFuncColor;
- XGL_BLEND srcBlendAlpha;
- XGL_BLEND destBlendAlpha;
- XGL_BLEND_FUNC blendFuncAlpha;
-} XGL_COLOR_ATTACHMENT_BLEND_STATE;
-
-typedef struct _XGL_COLOR_BLEND_STATE_CREATE_INFO
-{
- XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_COLOR_BLEND_STATE_CREATE_INFO
+ XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_DYNAMIC_CB_STATE_CREATE_INFO
const XGL_VOID* pNext; // Pointer to next structure
- XGL_COLOR_ATTACHMENT_BLEND_STATE attachment[XGL_MAX_COLOR_ATTACHMENTS];
XGL_FLOAT blendConst[4];
-} XGL_COLOR_BLEND_STATE_CREATE_INFO;
+} XGL_DYNAMIC_CB_STATE_CREATE_INFO;
-typedef struct _XGL_STENCIL_OP_STATE
+typedef struct _XGL_DYNAMIC_DS_STATE_CREATE_INFO
{
- XGL_STENCIL_OP stencilFailOp;
- XGL_STENCIL_OP stencilPassOp;
- XGL_STENCIL_OP stencilDepthFailOp;
- XGL_COMPARE_FUNC stencilFunc;
- XGL_UINT32 stencilRef;
-} XGL_STENCIL_OP_STATE;
-
-typedef struct _XGL_DEPTH_STENCIL_STATE_CREATE_INFO
-{
- XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_DEPTH_STENCIL_STATE_CREATE_INFO
+ XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_DYNAMIC_DS_STATE_CREATE_INFO
const XGL_VOID* pNext; // Pointer to next structure
- XGL_BOOL depthTestEnable;
- XGL_BOOL depthWriteEnable;
- XGL_COMPARE_FUNC depthFunc;
- XGL_BOOL depthBoundsEnable;
- XGL_FLOAT minDepth;
- XGL_FLOAT maxDepth;
- XGL_BOOL stencilTestEnable;
+ XGL_FLOAT minDepth; // optional (depth_bounds_test)
+ XGL_FLOAT maxDepth; // optional (depth_bounds_test)
XGL_UINT32 stencilReadMask;
XGL_UINT32 stencilWriteMask;
- XGL_STENCIL_OP_STATE front;
- XGL_STENCIL_OP_STATE back;
-} XGL_DEPTH_STENCIL_STATE_CREATE_INFO;
+ XGL_UINT32 stencilFrontRef;
+ XGL_UINT32 stencilBackRef;
+} XGL_DYNAMIC_DS_STATE_CREATE_INFO;
typedef struct _XGL_CMD_BUFFER_CREATE_INFO
{
@@ -1949,18 +1995,17 @@
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);
-typedef XGL_RESULT (XGLAPI *xglCreateRasterStateType)(XGL_DEVICE device, const XGL_RASTER_STATE_CREATE_INFO* pCreateInfo, XGL_RASTER_STATE_OBJECT* pState);
-typedef XGL_RESULT (XGLAPI *xglCreateMsaaStateType)(XGL_DEVICE device, const XGL_MSAA_STATE_CREATE_INFO* pCreateInfo, XGL_MSAA_STATE_OBJECT* pState);
-typedef XGL_RESULT (XGLAPI *xglCreateColorBlendStateType)(XGL_DEVICE device, const XGL_COLOR_BLEND_STATE_CREATE_INFO* pCreateInfo, XGL_COLOR_BLEND_STATE_OBJECT* pState);
-typedef XGL_RESULT (XGLAPI *xglCreateDepthStencilStateType)(XGL_DEVICE device, const XGL_DEPTH_STENCIL_STATE_CREATE_INFO* pCreateInfo, XGL_DEPTH_STENCIL_STATE_OBJECT* pState);
+typedef XGL_RESULT (XGLAPI *xglCreateDynamicViewportStateType)(XGL_DEVICE device, const XGL_DYNAMIC_VP_STATE_CREATE_INFO* pCreateInfo, XGL_DYNAMIC_VP_STATE_OBJECT* pState);
+typedef XGL_RESULT (XGLAPI *xglCreateDynamicRasterStateType)(XGL_DEVICE device, const XGL_DYNAMIC_RS_STATE_CREATE_INFO* pCreateInfo, XGL_DYNAMIC_RS_STATE_OBJECT* pState);
+typedef XGL_RESULT (XGLAPI *xglCreateDynamicColorBlendStateType)(XGL_DEVICE device, const XGL_DYNAMIC_CB_STATE_CREATE_INFO* pCreateInfo, XGL_DYNAMIC_CB_STATE_OBJECT* pState);
+typedef XGL_RESULT (XGLAPI *xglCreateDynamicDepthStencilStateType)(XGL_DEVICE device, const XGL_DYNAMIC_DS_STATE_CREATE_INFO* pCreateInfo, XGL_DYNAMIC_DS_STATE_OBJECT* pState);
typedef XGL_RESULT (XGLAPI *xglCreateCommandBufferType)(XGL_DEVICE device, const XGL_CMD_BUFFER_CREATE_INFO* pCreateInfo, XGL_CMD_BUFFER* pCmdBuffer);
typedef XGL_RESULT (XGLAPI *xglBeginCommandBufferType)(XGL_CMD_BUFFER cmdBuffer, const XGL_CMD_BUFFER_BEGIN_INFO* pBeginInfo);
typedef XGL_RESULT (XGLAPI *xglEndCommandBufferType)(XGL_CMD_BUFFER cmdBuffer);
typedef XGL_RESULT (XGLAPI *xglResetCommandBufferType)(XGL_CMD_BUFFER cmdBuffer);
typedef XGL_VOID (XGLAPI *xglCmdBindPipelineType)(XGL_CMD_BUFFER cmdBuffer, XGL_PIPELINE_BIND_POINT pipelineBindPoint, XGL_PIPELINE pipeline);
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 *xglCmdBindDynamicStateObjectType)(XGL_CMD_BUFFER cmdBuffer, XGL_STATE_BIND_POINT stateBindPoint, XGL_DYNAMIC_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 *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);
@@ -2369,30 +2414,25 @@
// State object functions
-XGL_RESULT XGLAPI xglCreateViewportState(
+XGL_RESULT XGLAPI xglCreateDynamicViewportState(
XGL_DEVICE device,
- const XGL_VIEWPORT_STATE_CREATE_INFO* pCreateInfo,
- XGL_VIEWPORT_STATE_OBJECT* pState);
+ const XGL_DYNAMIC_VP_STATE_CREATE_INFO* pCreateInfo,
+ XGL_DYNAMIC_VP_STATE_OBJECT* pState);
-XGL_RESULT XGLAPI xglCreateRasterState(
+XGL_RESULT XGLAPI xglCreateDynamicRasterState(
XGL_DEVICE device,
- const XGL_RASTER_STATE_CREATE_INFO* pCreateInfo,
- XGL_RASTER_STATE_OBJECT* pState);
+ const XGL_DYNAMIC_RS_STATE_CREATE_INFO* pCreateInfo,
+ XGL_DYNAMIC_RS_STATE_OBJECT* pState);
-XGL_RESULT XGLAPI xglCreateMsaaState(
+XGL_RESULT XGLAPI xglCreateDynamicColorBlendState(
XGL_DEVICE device,
- const XGL_MSAA_STATE_CREATE_INFO* pCreateInfo,
- XGL_MSAA_STATE_OBJECT* pState);
+ const XGL_DYNAMIC_CB_STATE_CREATE_INFO* pCreateInfo,
+ XGL_DYNAMIC_CB_STATE_OBJECT* pState);
-XGL_RESULT XGLAPI xglCreateColorBlendState(
+XGL_RESULT XGLAPI xglCreateDynamicDepthStencilState(
XGL_DEVICE device,
- const XGL_COLOR_BLEND_STATE_CREATE_INFO* pCreateInfo,
- XGL_COLOR_BLEND_STATE_OBJECT* pState);
-
-XGL_RESULT XGLAPI xglCreateDepthStencilState(
- XGL_DEVICE device,
- const XGL_DEPTH_STENCIL_STATE_CREATE_INFO* pCreateInfo,
- XGL_DEPTH_STENCIL_STATE_OBJECT* pState);
+ const XGL_DYNAMIC_DS_STATE_CREATE_INFO* pCreateInfo,
+ XGL_DYNAMIC_DS_STATE_OBJECT* pState);
// Command buffer functions
@@ -2423,10 +2463,10 @@
XGL_PIPELINE_BIND_POINT pipelineBindPoint,
XGL_PIPELINE_DELTA delta);
-XGL_VOID XGLAPI xglCmdBindStateObject(
+XGL_VOID XGLAPI xglCmdBindDynamicStateObject(
XGL_CMD_BUFFER cmdBuffer,
XGL_STATE_BIND_POINT stateBindPoint,
- XGL_STATE_OBJECT state);
+ XGL_DYNAMIC_STATE_OBJECT dynamicState);
XGL_VOID XGLAPI xglCmdBindDescriptorSet(
XGL_CMD_BUFFER cmdBuffer,
diff --git a/include/xglLayer.h b/include/xglLayer.h
index 8c473ba..3803168 100644
--- a/include/xglLayer.h
+++ b/include/xglLayer.h
@@ -90,18 +90,17 @@
xglAttachBufferViewDescriptorsType AttachBufferViewDescriptors;
xglAttachNestedDescriptorsType AttachNestedDescriptors;
xglClearDescriptorSetSlotsType ClearDescriptorSetSlots;
- xglCreateViewportStateType CreateViewportState;
- xglCreateRasterStateType CreateRasterState;
- xglCreateMsaaStateType CreateMsaaState;
- xglCreateColorBlendStateType CreateColorBlendState;
- xglCreateDepthStencilStateType CreateDepthStencilState;
+ xglCreateDynamicViewportStateType CreateDynamicViewportState;
+ xglCreateDynamicRasterStateType CreateDynamicRasterState;
+ xglCreateDynamicColorBlendStateType CreateDynamicColorBlendState;
+ xglCreateDynamicDepthStencilStateType CreateDynamicDepthStencilState;
xglCreateCommandBufferType CreateCommandBuffer;
xglBeginCommandBufferType BeginCommandBuffer;
xglEndCommandBufferType EndCommandBuffer;
xglResetCommandBufferType ResetCommandBuffer;
xglCmdBindPipelineType CmdBindPipeline;
xglCmdBindPipelineDeltaType CmdBindPipelineDelta;
- xglCmdBindStateObjectType CmdBindStateObject;
+ xglCmdBindDynamicStateObjectType CmdBindDynamicStateObject;
xglCmdBindDescriptorSetType CmdBindDescriptorSet;
xglCmdBindDynamicBufferViewType CmdBindDynamicBufferView;
xglCmdBindVertexBufferType CmdBindVertexBuffer;
diff --git a/tests/image_tests.cpp b/tests/image_tests.cpp
index 221c60c..aefe657 100644
--- a/tests/image_tests.cpp
+++ b/tests/image_tests.cpp
@@ -201,13 +201,15 @@
// const XGL_MEMORY_ALLOC_INFO* pAllocInfo,
// XGL_GPU_MEMORY* pMem);
XGL_MEMORY_ALLOC_INFO mem_info;
+ XGL_UINT heapInfo[mem_req.heapCount];
memset(&mem_info, 0, sizeof(mem_info));
mem_info.sType = XGL_STRUCTURE_TYPE_MEMORY_ALLOC_INFO;
mem_info.allocationSize = mem_req.size;
mem_info.alignment = mem_req.alignment;
mem_info.heapCount = mem_req.heapCount;
- memcpy(mem_info.heaps, mem_req.heaps, sizeof(XGL_UINT)*XGL_MAX_MEMORY_HEAPS);
+ mem_info.pHeaps = heapInfo;
+ memcpy(heapInfo, mem_req.pHeaps, sizeof(XGL_UINT)*mem_info.heapCount);
mem_info.memPriority = XGL_MEMORY_PRIORITY_NORMAL;
mem_info.flags = XGL_MEMORY_ALLOC_SHAREABLE_BIT;
err = xglAllocMemory(device(), &mem_info, &m_image_mem);
diff --git a/tests/init.cpp b/tests/init.cpp
index 75ccd5e..a97283e 100644
--- a/tests/init.cpp
+++ b/tests/init.cpp
@@ -159,12 +159,14 @@
XGL_MEMORY_ALLOC_INFO alloc_info = {};
XGL_GPU_MEMORY gpu_mem;
XGL_UINT8 *pData;
+ XGL_UINT localHeap[1] = {0};
alloc_info.sType = XGL_STRUCTURE_TYPE_MEMORY_ALLOC_INFO;
alloc_info.allocationSize = 1024 * 1024; // 1MB
alloc_info.alignment = 0;
alloc_info.heapCount = 1;
- alloc_info.heaps[0] = 0; // TODO: Reference other heaps
+ alloc_info.pHeaps = localHeap;
+
// TODO: Pick heap properties indicated by heap info
alloc_info.flags = XGL_MEMORY_HEAP_CPU_VISIBLE_BIT;
@@ -220,12 +222,14 @@
ASSERT_NE(0, mem_req.size) << "xglGetObjectInfo (Event): Failed - expect events to require memory";
+ XGL_UINT heapInfo[mem_req.heapCount];
memset(&mem_info, 0, sizeof(mem_info));
mem_info.sType = XGL_STRUCTURE_TYPE_MEMORY_ALLOC_INFO;
mem_info.allocationSize = mem_req.size;
mem_info.alignment = mem_req.alignment;
mem_info.heapCount = mem_req.heapCount;
- memcpy(mem_info.heaps, mem_req.heaps, sizeof(XGL_UINT)*XGL_MAX_MEMORY_HEAPS);
+ mem_info.pHeaps = heapInfo;
+ memcpy(heapInfo, mem_req.pHeaps, sizeof(XGL_UINT)*mem_info.heapCount);
mem_info.memPriority = XGL_MEMORY_PRIORITY_NORMAL;
mem_info.flags = XGL_MEMORY_ALLOC_SHAREABLE_BIT;
err = xglAllocMemory(device(), &mem_info, &event_mem);
@@ -352,13 +356,16 @@
XGL_MEMORY_ALLOC_INFO mem_info;
XGL_GPU_MEMORY query_mem;
+ XGL_UINT heapInfo[mem_req.heapCount];
+
memset(&mem_info, 0, sizeof(mem_info));
mem_info.sType = XGL_STRUCTURE_TYPE_MEMORY_ALLOC_INFO;
// TODO: Is a simple multiple all that's needed here?
mem_info.allocationSize = mem_req.size * MAX_QUERY_SLOTS;
mem_info.alignment = mem_req.alignment;
mem_info.heapCount = mem_req.heapCount;
- memcpy(mem_info.heaps, mem_req.heaps, sizeof(XGL_UINT)*XGL_MAX_MEMORY_HEAPS);
+ mem_info.pHeaps = heapInfo;
+ memcpy(heapInfo, mem_req.pHeaps, sizeof(XGL_UINT)*mem_info.heapCount);
mem_info.memPriority = XGL_MEMORY_PRIORITY_NORMAL;
// TODO: are the flags right?
@@ -625,12 +632,14 @@
XGL_MEMORY_ALLOC_INFO mem_info;
XGL_GPU_MEMORY image_mem;
+ XGL_UINT heapInfo[mem_req.heapCount];
memset(&mem_info, 0, sizeof(mem_info));
mem_info.sType = XGL_STRUCTURE_TYPE_MEMORY_ALLOC_INFO;
mem_info.allocationSize = mem_req.size;
mem_info.alignment = mem_req.alignment;
mem_info.heapCount = mem_req.heapCount;
- memcpy(mem_info.heaps, mem_req.heaps, sizeof(XGL_UINT)*XGL_MAX_MEMORY_HEAPS);
+ mem_info.pHeaps = heapInfo;
+ memcpy(heapInfo, mem_req.pHeaps, sizeof(XGL_UINT)*mem_info.heapCount);
mem_info.memPriority = XGL_MEMORY_PRIORITY_NORMAL;
mem_info.flags = XGL_MEMORY_ALLOC_SHAREABLE_BIT;
err = xglAllocMemory(device(), &mem_info, &image_mem);
diff --git a/tests/render_tests.cpp b/tests/render_tests.cpp
index 3773263..fb54b69 100644
--- a/tests/render_tests.cpp
+++ b/tests/render_tests.cpp
@@ -266,7 +266,6 @@
cmdBuffer->BindStateObject(XGL_STATE_BIND_VIEWPORT, m_stateViewport);
cmdBuffer->BindStateObject(XGL_STATE_BIND_COLOR_BLEND, m_colorBlend);
cmdBuffer->BindStateObject(XGL_STATE_BIND_DEPTH_STENCIL, m_stateDepthStencil);
- cmdBuffer->BindStateObject(XGL_STATE_BIND_MSAA, m_stateMsaa);
pipelineobj->CreateXGLPipeline(descriptorSet);
cmdBuffer->BindPipeline(pipelineobj->GetPipelineHandle());
descriptorSet->CreateXGLDescriptorSet();
@@ -372,11 +371,13 @@
ASSERT_XGL_SUCCESS(err);
ASSERT_EQ(mem_reqs_size, sizeof(mem_reqs));
+ XGL_UINT heapInfo[mem_reqs.heapCount];
mem_alloc.allocationSize = mem_reqs.size;
mem_alloc.alignment = mem_reqs.alignment;
mem_alloc.heapCount = mem_reqs.heapCount;
- memcpy(mem_alloc.heaps, mem_reqs.heaps,
- sizeof(mem_reqs.heaps[0]) * mem_reqs.heapCount);
+ mem_alloc.pHeaps = heapInfo;
+ memcpy(heapInfo, mem_reqs.pHeaps,
+ sizeof(mem_reqs.pHeaps) * mem_reqs.heapCount);
/* allocate memory */
err = xglAllocMemory(device(), &mem_alloc, &m_depthStencilMem);
@@ -386,22 +387,17 @@
err = xglBindObjectMemory(m_depthStencilImage, m_depthStencilMem, 0);
ASSERT_XGL_SUCCESS(err);
- XGL_DEPTH_STENCIL_STATE_CREATE_INFO depthStencil = {};
- depthStencil.sType = XGL_STRUCTURE_TYPE_DEPTH_STENCIL_STATE_CREATE_INFO;
- depthStencil.depthTestEnable = XGL_TRUE;
- depthStencil.depthWriteEnable = XGL_TRUE;
- depthStencil.depthFunc = XGL_COMPARE_LESS_EQUAL;
- depthStencil.depthBoundsEnable = XGL_FALSE;
+ XGL_DYNAMIC_DS_STATE_CREATE_INFO depthStencil = {};
+ depthStencil.sType = XGL_STRUCTURE_TYPE_DYNAMIC_DS_STATE_CREATE_INFO;
+
depthStencil.minDepth = 0.f;
depthStencil.maxDepth = 1.f;
- depthStencil.back.stencilDepthFailOp = XGL_STENCIL_OP_KEEP;
- depthStencil.back.stencilFailOp = XGL_STENCIL_OP_KEEP;
- depthStencil.back.stencilPassOp = XGL_STENCIL_OP_KEEP;
- depthStencil.back.stencilRef = 0x00;
- depthStencil.back.stencilFunc = XGL_COMPARE_ALWAYS;
- depthStencil.front = depthStencil.back;
+ depthStencil.stencilBackRef = 0;
+ depthStencil.stencilFrontRef = 0;
+ depthStencil.stencilReadMask = 0xff;
+ depthStencil.stencilWriteMask = 0xff;
- err = xglCreateDepthStencilState( device(), &depthStencil, &m_stateDepthStencil );
+ err = xglCreateDynamicDepthStencilState( device(), &depthStencil, &m_stateDepthStencil );
ASSERT_XGL_SUCCESS( err );
/* create image view */
@@ -858,7 +854,7 @@
att.blendEnable = XGL_FALSE;
att.format = m_render_target_fmt;
att.channelWriteMask = 0xf;
- pipelineobj.SetColorAttachment(1, &att);
+ pipelineobj.AddColorAttachment(1, &att);
XglCommandBufferObj cmdBuffer(m_device);
@@ -1762,6 +1758,21 @@
pipelineobj.AddShader(&vs);
pipelineobj.AddShader(&ps);
+ XGL_PIPELINE_DS_STATE_CREATE_INFO ds_state;
+ ds_state.depthTestEnable = XGL_TRUE;
+ ds_state.depthWriteEnable = XGL_TRUE;
+ ds_state.depthFunc = XGL_COMPARE_LESS_EQUAL;
+ ds_state.depthBoundsEnable = XGL_FALSE;
+ ds_state.stencilTestEnable = XGL_FALSE;
+ ds_state.back.stencilDepthFailOp = XGL_STENCIL_OP_KEEP;
+ ds_state.back.stencilFailOp = XGL_STENCIL_OP_KEEP;
+ ds_state.back.stencilPassOp = XGL_STENCIL_OP_KEEP;
+ ds_state.back.stencilFunc = XGL_COMPARE_ALWAYS;
+ ds_state.format.channelFormat = XGL_CH_FMT_R32;
+ ds_state.format.numericFormat = XGL_NUM_FMT_DS;
+ ds_state.front = ds_state.back;
+ pipelineobj.SetDepthStencil(&ds_state);
+
XglDescriptorSetObj descriptorSet(m_device);
descriptorSet.AttachBufferView(&MVPBuffer);
@@ -2617,6 +2628,21 @@
pipelineobj.AddVertexInputAttribs(vi_attribs,2);
pipelineobj.AddVertexDataBuffer(&meshBuffer,0);
+ XGL_PIPELINE_DS_STATE_CREATE_INFO ds_state;
+ ds_state.depthTestEnable = XGL_TRUE;
+ ds_state.depthWriteEnable = XGL_TRUE;
+ ds_state.depthFunc = XGL_COMPARE_LESS_EQUAL;
+ ds_state.depthBoundsEnable = XGL_FALSE;
+ ds_state.stencilTestEnable = XGL_FALSE;
+ ds_state.back.stencilDepthFailOp = XGL_STENCIL_OP_KEEP;
+ ds_state.back.stencilFailOp = XGL_STENCIL_OP_KEEP;
+ ds_state.back.stencilPassOp = XGL_STENCIL_OP_KEEP;
+ ds_state.back.stencilFunc = XGL_COMPARE_ALWAYS;
+ ds_state.format.channelFormat = XGL_CH_FMT_R32;
+ ds_state.format.numericFormat = XGL_NUM_FMT_DS;
+ ds_state.front = ds_state.back;
+ pipelineobj.SetDepthStencil(&ds_state);
+
ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
XglCommandBufferObj cmdBuffer(m_device);
cmdBuffer.AddRenderTarget(m_renderTargets[0]);
diff --git a/tests/xglrenderframework.cpp b/tests/xglrenderframework.cpp
index c144ac4..ef1a949 100644
--- a/tests/xglrenderframework.cpp
+++ b/tests/xglrenderframework.cpp
@@ -33,7 +33,6 @@
m_colorBlend( XGL_NULL_HANDLE ),
m_stateViewport( XGL_NULL_HANDLE ),
m_stateDepthStencil( XGL_NULL_HANDLE ),
- m_stateMsaa( XGL_NULL_HANDLE ),
m_width( 256.0 ), // default window width
m_height( 256.0 ) // default window height
{
@@ -42,7 +41,6 @@
m_render_target_fmt.channelFormat = XGL_CH_FMT_R8G8B8A8;
m_render_target_fmt.numericFormat = XGL_NUM_FMT_UNORM;
- m_colorBindings[0].view = XGL_NULL_HANDLE;
m_depthStencilBinding.view = XGL_NULL_HANDLE;
}
@@ -67,7 +65,6 @@
void XglRenderFramework::ShutdownFramework()
{
if (m_colorBlend) xglDestroyObject(m_colorBlend);
- if (m_stateMsaa) xglDestroyObject(m_stateMsaa);
if (m_stateDepthStencil) xglDestroyObject(m_stateDepthStencil);
if (m_stateRaster) xglDestroyObject(m_stateRaster);
if (m_cmdBuffer) xglDestroyObject(m_cmdBuffer);
@@ -76,14 +73,6 @@
xglDestroyObject(m_stateViewport);
}
- for (XGL_UINT i = 0; i < m_renderTargetCount; i++) {
- if (m_renderTargets[i]) {
- // TODO: XglImage should be able to destroy itself
-// m_renderTarget->
-// xglDestroyObject(*m_renderTarget);
- }
- }
-
// reset the driver
delete m_device;
xglInitAndEnumerateGpus(&this->app_info, XGL_NULL_HANDLE, 0, &gpu_count, XGL_NULL_HANDLE);
@@ -97,43 +86,26 @@
m_render_target_fmt.numericFormat = XGL_NUM_FMT_UNORM;
// create a raster state (solid, back-face culling)
- XGL_RASTER_STATE_CREATE_INFO raster = {};
- raster.sType = XGL_STRUCTURE_TYPE_RASTER_STATE_CREATE_INFO;
- raster.fillMode = XGL_FILL_SOLID;
- raster.cullMode = XGL_CULL_NONE;
- raster.frontFace = XGL_FRONT_FACE_CCW;
- err = xglCreateRasterState( device(), &raster, &m_stateRaster );
+ XGL_DYNAMIC_RS_STATE_CREATE_INFO raster = {};
+ raster.sType = XGL_STRUCTURE_TYPE_DYNAMIC_RS_STATE_CREATE_INFO;
+ raster.pointSize = 1.0;
+
+ err = xglCreateDynamicRasterState( device(), &raster, &m_stateRaster );
ASSERT_XGL_SUCCESS(err);
- XGL_COLOR_BLEND_STATE_CREATE_INFO blend = {};
- blend.sType = XGL_STRUCTURE_TYPE_COLOR_BLEND_STATE_CREATE_INFO;
- err = xglCreateColorBlendState(device(), &blend, &m_colorBlend);
+ XGL_DYNAMIC_CB_STATE_CREATE_INFO blend = {};
+ blend.sType = XGL_STRUCTURE_TYPE_DYNAMIC_CB_STATE_CREATE_INFO;
+ err = xglCreateDynamicColorBlendState(device(), &blend, &m_colorBlend);
ASSERT_XGL_SUCCESS( err );
- XGL_DEPTH_STENCIL_STATE_CREATE_INFO depthStencil = {};
- depthStencil.sType = XGL_STRUCTURE_TYPE_DEPTH_STENCIL_STATE_CREATE_INFO;
- depthStencil.depthTestEnable = XGL_FALSE;
- depthStencil.depthWriteEnable = XGL_FALSE;
- depthStencil.depthFunc = XGL_COMPARE_LESS_EQUAL;
- depthStencil.depthBoundsEnable = XGL_FALSE;
+ XGL_DYNAMIC_DS_STATE_CREATE_INFO depthStencil = {};
+ depthStencil.sType = XGL_STRUCTURE_TYPE_DYNAMIC_DS_STATE_CREATE_INFO;
depthStencil.minDepth = 0.f;
depthStencil.maxDepth = 1.f;
- depthStencil.back.stencilDepthFailOp = XGL_STENCIL_OP_KEEP;
- depthStencil.back.stencilFailOp = XGL_STENCIL_OP_KEEP;
- depthStencil.back.stencilPassOp = XGL_STENCIL_OP_KEEP;
- depthStencil.back.stencilRef = 0x00;
- depthStencil.back.stencilFunc = XGL_COMPARE_ALWAYS;
- depthStencil.front = depthStencil.back;
+ depthStencil.stencilFrontRef = 0;
+ depthStencil.stencilBackRef = 0;
- err = xglCreateDepthStencilState( device(), &depthStencil, &m_stateDepthStencil );
- ASSERT_XGL_SUCCESS( err );
-
- XGL_MSAA_STATE_CREATE_INFO msaa = {};
- msaa.sType = XGL_STRUCTURE_TYPE_MSAA_STATE_CREATE_INFO;
- msaa.sampleMask = 1;
- msaa.samples = 1;
-
- err = xglCreateMsaaState( device(), &msaa, &m_stateMsaa );
+ err = xglCreateDynamicDepthStencilState( device(), &depthStencil, &m_stateDepthStencil );
ASSERT_XGL_SUCCESS( err );
XGL_CMD_BUFFER_CREATE_INFO cmdInfo = {};
@@ -148,17 +120,21 @@
{
XGL_RESULT err;
- XGL_VIEWPORT_STATE_CREATE_INFO viewport = {};
- viewport.viewportCount = 1;
- viewport.scissorEnable = XGL_FALSE;
- viewport.viewports[0].originX = 0;
- viewport.viewports[0].originY = 0;
- viewport.viewports[0].width = 1.f * width;
- viewport.viewports[0].height = 1.f * height;
- viewport.viewports[0].minDepth = 0.f;
- viewport.viewports[0].maxDepth = 1.f;
+ XGL_VIEWPORT viewport;
- err = xglCreateViewportState( device(), &viewport, &m_stateViewport );
+ XGL_DYNAMIC_VP_STATE_CREATE_INFO viewportCreate = {};
+ viewportCreate.sType = XGL_STRUCTURE_TYPE_DYNAMIC_VP_STATE_CREATE_INFO;
+ viewportCreate.viewportCount = 1;
+ viewportCreate.scissorCount = 0;
+ viewport.originX = 0;
+ viewport.originY = 0;
+ viewport.width = 1.f * width;
+ viewport.height = 1.f * height;
+ viewport.minDepth = 0.f;
+ viewport.maxDepth = 1.f;
+ viewportCreate.pViewports = &viewport;
+
+ err = xglCreateDynamicViewportState( device(), &viewportCreate, &m_stateViewport );
ASSERT_XGL_SUCCESS( err );
m_width = width;
m_height = height;
@@ -178,9 +154,9 @@
img->init(m_width, m_height, m_render_target_fmt,
XGL_IMAGE_USAGE_SHADER_ACCESS_WRITE_BIT |
XGL_IMAGE_USAGE_COLOR_ATTACHMENT_BIT);
- m_renderTargets[i] = img;
- m_colorBindings[i].view = m_renderTargets[i]->targetView();
+ m_colorBindings[i].view = img->targetView();
m_colorBindings[i].colorAttachmentState = XGL_IMAGE_STATE_TARGET_RENDER_ACCESS_OPTIMAL;
+ m_renderTargets.push_back(img);
}
// Create Framebuffer and RenderPass with color attachments and any depth/stencil attachment
XGL_ATTACHMENT_LOAD_OP load_op = XGL_ATTACHMENT_LOAD_OP_LOAD;
@@ -722,14 +698,16 @@
stageInfo->sType = XGL_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
stageInfo->shader.stage = m_stage;
stageInfo->shader.shader = obj();
- stageInfo->shader.descriptorSetMapping[0].descriptorCount = 0;
+ stageInfo->shader.descriptorSetMappingCount = 1;
+ stageInfo->shader.pDescriptorSetMapping = (XGL_DESCRIPTOR_SET_MAPPING *)malloc(sizeof(XGL_DESCRIPTOR_SET_MAPPING));
+ stageInfo->shader.pDescriptorSetMapping->descriptorCount = 0;
stageInfo->shader.linkConstBufferCount = 0;
stageInfo->shader.pLinkConstBufferInfo = XGL_NULL_HANDLE;
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)
+ stageInfo->shader.pDescriptorSetMapping->descriptorCount = descriptorSet->GetTotalSlots();
+ if (stageInfo->shader.pDescriptorSetMapping->descriptorCount)
{
vector<int> allSlots;
vector<XGL_DESCRIPTOR_SET_SLOT_TYPE> allTypes;
@@ -759,7 +737,7 @@
}
slotInfo = descriptorSet->GetSlotInfo(allSlots, allTypes, allObjs);
- stageInfo->shader.descriptorSetMapping[0].pDescriptorInfo = (const XGL_DESCRIPTOR_SLOT_INFO*) slotInfo;
+ stageInfo->shader.pDescriptorSetMapping[0].pDescriptorInfo = (const XGL_DESCRIPTOR_SLOT_INFO*) slotInfo;
}
return stageInfo;
}
@@ -841,7 +819,6 @@
m_ia_state.pNext = XGL_NULL_HANDLE;
m_ia_state.topology = XGL_TOPOLOGY_TRIANGLE_LIST;
m_ia_state.disableVertexReuse = XGL_FALSE;
- m_ia_state.provokingVertex = XGL_PROVOKING_VERTEX_LAST;
m_ia_state.primitiveRestartEnable = XGL_FALSE;
m_ia_state.primitiveRestartIndex = 0;
@@ -849,7 +826,10 @@
m_rs_state.pNext = &m_ia_state;
m_rs_state.depthClipEnable = XGL_FALSE;
m_rs_state.rasterizerDiscardEnable = XGL_FALSE;
- m_rs_state.pointSize = 1.0;
+ m_rs_state.provokingVertex = XGL_PROVOKING_VERTEX_LAST;
+ m_rs_state.fillMode = XGL_FILL_SOLID;
+ m_rs_state.cullMode = XGL_CULL_NONE;
+ m_rs_state.frontFace = XGL_FRONT_FACE_CCW;
memset(&m_cb_state,0,sizeof(m_cb_state));
m_cb_state.sType = XGL_STRUCTURE_TYPE_PIPELINE_CB_STATE_CREATE_INFO;
@@ -858,16 +838,35 @@
m_cb_state.dualSourceBlendEnable = XGL_FALSE;
m_cb_state.logicOp = XGL_LOGIC_OP_COPY;
- m_cb_state.attachment[0].blendEnable = XGL_FALSE;
- m_cb_state.attachment[0].format.channelFormat = XGL_CH_FMT_R8G8B8A8;
- m_cb_state.attachment[0].format.numericFormat = XGL_NUM_FMT_UNORM;
- m_cb_state.attachment[0].channelWriteMask = 0xF;
+ m_ms_state.pNext = &m_cb_state;
+ m_ms_state.sType = XGL_STRUCTURE_TYPE_PIPELINE_MS_STATE_CREATE_INFO;
+ m_ms_state.multisampleEnable = XGL_FALSE;
+ m_ms_state.sampleMask = 1; // Do we have to specify MSAA even just to disable it?
+ m_ms_state.samples = 1;
+ m_ms_state.minSampleShading = 0;
+ m_ms_state.sampleShadingEnable = 0;
- m_db_state.sType = XGL_STRUCTURE_TYPE_PIPELINE_DB_STATE_CREATE_INFO,
- m_db_state.pNext = &m_cb_state,
- m_db_state.format.channelFormat = XGL_CH_FMT_R32;
- m_db_state.format.numericFormat = XGL_NUM_FMT_DS;
+ m_ds_state.sType = XGL_STRUCTURE_TYPE_PIPELINE_DS_STATE_CREATE_INFO;
+ m_ds_state.pNext = &m_ms_state,
+ m_ds_state.format.channelFormat = XGL_CH_FMT_R32;
+ m_ds_state.format.numericFormat = XGL_NUM_FMT_DS;
+ m_ds_state.depthTestEnable = XGL_FALSE;
+ m_ds_state.depthWriteEnable = XGL_FALSE;
+ m_ds_state.depthBoundsEnable = XGL_FALSE;
+ m_ds_state.depthFunc = XGL_COMPARE_LESS_EQUAL;
+ m_ds_state.back.stencilDepthFailOp = XGL_STENCIL_OP_KEEP;
+ m_ds_state.back.stencilFailOp = XGL_STENCIL_OP_KEEP;
+ m_ds_state.back.stencilPassOp = XGL_STENCIL_OP_KEEP;
+ m_ds_state.back.stencilFunc = XGL_COMPARE_ALWAYS;
+ m_ds_state.stencilTestEnable = XGL_FALSE;
+ m_ds_state.front = m_ds_state.back;
+ XGL_PIPELINE_CB_ATTACHMENT_STATE att = {};
+ att.blendEnable = XGL_FALSE;
+ att.format.channelFormat = XGL_CH_FMT_R8G8B8A8;
+ att.format.numericFormat = XGL_NUM_FMT_UNORM;
+ att.channelWriteMask = 0xf;
+ AddColorAttachment(0, &att);
};
@@ -895,14 +894,30 @@
m_vertexBufferCount++;
}
-void XglPipelineObj::SetColorAttachment(XGL_UINT binding, const XGL_PIPELINE_CB_ATTACHMENT_STATE *att)
+void XglPipelineObj::AddColorAttachment(XGL_UINT binding, const XGL_PIPELINE_CB_ATTACHMENT_STATE *att)
{
- m_cb_state.attachment[binding] = *att;
+ if (binding+1 > m_colorAttachments.size())
+ {
+ m_colorAttachments.resize(binding+1);
+ }
+ m_colorAttachments[binding] = *att;
+}
+
+void XglPipelineObj::SetDepthStencil(XGL_PIPELINE_DS_STATE_CREATE_INFO *ds_state)
+{
+ m_ds_state.format = ds_state->format;
+ m_ds_state.depthTestEnable = ds_state->depthTestEnable;
+ m_ds_state.depthWriteEnable = ds_state->depthWriteEnable;
+ m_ds_state.depthBoundsEnable = ds_state->depthBoundsEnable;
+ m_ds_state.depthFunc = ds_state->depthFunc;
+ m_ds_state.stencilTestEnable = ds_state->stencilTestEnable;
+ m_ds_state.back = ds_state->back;
+ m_ds_state.front = ds_state->front;
}
void XglPipelineObj::CreateXGLPipeline(XglDescriptorSetObj *descriptorSet)
{
- XGL_VOID* head_ptr = &m_db_state;
+ XGL_VOID* head_ptr = &m_ds_state;
XGL_GRAPHICS_PIPELINE_CREATE_INFO info = {};
XGL_PIPELINE_SHADER_STAGE_CREATE_INFO* shaderCreateInfo;
@@ -925,6 +940,9 @@
info.pNext = head_ptr;
info.flags = 0;
+ m_cb_state.attachmentCount = m_colorAttachments.size();
+ m_cb_state.pAttachments = &m_colorAttachments[0];
+
init(*m_device, info);
}
@@ -935,7 +953,7 @@
void XglPipelineObj::BindPipelineCommandBuffer(XGL_CMD_BUFFER m_cmdBuffer, XglDescriptorSetObj *descriptorSet)
{
- XGL_VOID* head_ptr = &m_db_state;
+ XGL_VOID* head_ptr = &m_ds_state;
XGL_GRAPHICS_PIPELINE_CREATE_INFO info = {};
XGL_PIPELINE_SHADER_STAGE_CREATE_INFO* shaderCreateInfo;
@@ -1125,9 +1143,9 @@
}
}
-void XglCommandBufferObj::BindStateObject(XGL_STATE_BIND_POINT stateBindPoint, XGL_STATE_OBJECT stateObject)
+void XglCommandBufferObj::BindStateObject(XGL_STATE_BIND_POINT stateBindPoint, XGL_DYNAMIC_STATE_OBJECT stateObject)
{
- xglCmdBindStateObject( obj(), stateBindPoint, stateObject);
+ xglCmdBindDynamicStateObject( obj(), stateBindPoint, stateObject);
}
void XglCommandBufferObj::AddRenderTarget(XglImage *renderTarget)
diff --git a/tests/xglrenderframework.h b/tests/xglrenderframework.h
index 421f79d..13f1eb7 100644
--- a/tests/xglrenderframework.h
+++ b/tests/xglrenderframework.h
@@ -64,24 +64,23 @@
protected:
- XGL_APPLICATION_INFO app_info;
- XGL_PHYSICAL_GPU objs[XGL_MAX_PHYSICAL_GPUS];
- XGL_UINT gpu_count;
- XglDevice *m_device;
- XGL_CMD_BUFFER m_cmdBuffer;
- XGL_RENDER_PASS m_renderPass;
- XGL_MEMORY_REF m_memRefs[5];
- XGL_RASTER_STATE_OBJECT m_stateRaster;
- XGL_COLOR_BLEND_STATE_OBJECT m_colorBlend;
- XGL_VIEWPORT_STATE_OBJECT m_stateViewport;
- XGL_DEPTH_STENCIL_STATE_OBJECT m_stateDepthStencil;
- XGL_MSAA_STATE_OBJECT m_stateMsaa;
- XglImage *m_renderTargets[XGL_MAX_COLOR_ATTACHMENTS];
- XGL_UINT m_renderTargetCount;
- XGL_FLOAT m_width, m_height;
- XGL_FORMAT m_render_target_fmt;
- XGL_COLOR_ATTACHMENT_BIND_INFO m_colorBindings[XGL_MAX_COLOR_ATTACHMENTS];
- XGL_DEPTH_STENCIL_BIND_INFO m_depthStencilBinding;
+ XGL_APPLICATION_INFO app_info;
+ XGL_PHYSICAL_GPU objs[XGL_MAX_PHYSICAL_GPUS];
+ XGL_UINT gpu_count;
+ XglDevice *m_device;
+ XGL_CMD_BUFFER m_cmdBuffer;
+ XGL_RENDER_PASS m_renderPass;
+ XGL_MEMORY_REF m_memRefs[5];
+ XGL_DYNAMIC_RS_STATE_OBJECT m_stateRaster;
+ XGL_DYNAMIC_CB_STATE_OBJECT m_colorBlend;
+ XGL_DYNAMIC_VP_STATE_OBJECT m_stateViewport;
+ XGL_DYNAMIC_DS_STATE_OBJECT m_stateDepthStencil;
+ vector<XglImage*> m_renderTargets;
+ XGL_UINT m_renderTargetCount;
+ XGL_FLOAT m_width, m_height;
+ XGL_FORMAT m_render_target_fmt;
+ XGL_COLOR_ATTACHMENT_BIND_INFO m_colorBindings[8];
+ XGL_DEPTH_STENCIL_BIND_INFO m_depthStencilBinding;
/*
* SetUp and TearDown are called by the Google Test framework
@@ -126,7 +125,7 @@
void BindDescriptorSet(XGL_DESCRIPTOR_SET descriptorSet);
void BindVertexBuffer(XglConstantBufferObj *vertexBuffer, XGL_UINT offset, XGL_UINT binding);
void BindIndexBuffer(XglIndexBufferObj *indexBuffer, XGL_UINT offset);
- void BindStateObject(XGL_STATE_BIND_POINT stateBindPoint, XGL_STATE_OBJECT stateObject);
+ void BindStateObject(XGL_STATE_BIND_POINT stateBindPoint, XGL_DYNAMIC_STATE_OBJECT stateObject);
void Draw(XGL_UINT firstVertex, XGL_UINT vertexCount, XGL_UINT firstInstance, XGL_UINT instanceCount);
void DrawIndexed(XGL_UINT firstIndex, XGL_UINT indexCount, XGL_INT vertexOffset, XGL_UINT firstInstance, XGL_UINT instanceCount);
void QueueCommandBuffer(XGL_MEMORY_REF *memRefs, XGL_UINT32 numMemRefs);
@@ -316,7 +315,8 @@
void AddVertexInputAttribs(XGL_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION* vi_attrib, int count);
void AddVertexInputBindings(XGL_VERTEX_INPUT_BINDING_DESCRIPTION* vi_binding, int count);
void AddVertexDataBuffer(XglConstantBufferObj* vertexDataBuffer, int binding);
- void SetColorAttachment(XGL_UINT binding, const XGL_PIPELINE_CB_ATTACHMENT_STATE *att);
+ void AddColorAttachment(XGL_UINT binding, const XGL_PIPELINE_CB_ATTACHMENT_STATE *att);
+ void SetDepthStencil(XGL_PIPELINE_DS_STATE_CREATE_INFO *);
void CreateXGLPipeline(XglDescriptorSetObj *descriptorSet);
XGL_PIPELINE GetPipelineHandle();
@@ -324,12 +324,14 @@
XGL_PIPELINE_VERTEX_INPUT_CREATE_INFO m_vi_state;
XGL_PIPELINE_IA_STATE_CREATE_INFO m_ia_state;
XGL_PIPELINE_RS_STATE_CREATE_INFO m_rs_state;
- XGL_PIPELINE_CB_STATE m_cb_state;
- XGL_PIPELINE_DB_STATE_CREATE_INFO m_db_state;
+ XGL_PIPELINE_CB_STATE_CREATE_INFO m_cb_state;
+ XGL_PIPELINE_DS_STATE_CREATE_INFO m_ds_state;
+ XGL_PIPELINE_MS_STATE_CREATE_INFO m_ms_state;
XglDevice *m_device;
vector<XglShaderObj*> m_shaderObjs;
vector<XglConstantBufferObj*> m_vertexBufferObjs;
vector<int> m_vertexBufferBindings;
+ vector<XGL_PIPELINE_CB_ATTACHMENT_STATE> m_colorAttachments;
int m_vertexBufferCount;
};
diff --git a/tests/xgltestbinding.cpp b/tests/xgltestbinding.cpp
index b738734..3c2b386 100644
--- a/tests/xgltestbinding.cpp
+++ b/tests/xgltestbinding.cpp
@@ -260,21 +260,25 @@
const std::vector<XGL_MEMORY_REQUIREMENTS> mem_reqs = memory_requirements();
for (int i = 0; i < mem_reqs.size(); i++) {
XGL_MEMORY_ALLOC_INFO info = GpuMemory::alloc_info(mem_reqs[i]);
+ std::vector<uint32_t> heap_ids;
// 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 uint32_t heap = mem_reqs[i].pHeaps[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;
+ heap_ids.push_back(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;
+ heap_ids.push_back(*it);
+
+ info.heapCount = heap_ids.size();
+ info.pHeaps = &heap_ids[0];
primary_mem_ = &internal_mems_[i];
@@ -408,8 +412,6 @@
uint32_t count;
if (!EXPECT(xglGetMemoryHeapCount(obj(), &count) == XGL_SUCCESS && count))
return;
- if (count > XGL_MAX_MEMORY_HEAPS)
- count = XGL_MAX_MEMORY_HEAPS;
heap_props_.reserve(count);
for (uint32_t i = 0; i < count; i++) {
@@ -789,33 +791,27 @@
xglAttachNestedDescriptors(obj(), start_slot, sets.size(), &sets[0]);
}
-void DynamicVpStateObject::init(const Device &dev, const XGL_VIEWPORT_STATE_CREATE_INFO &info)
+void DynamicVpStateObject::init(const Device &dev, const XGL_DYNAMIC_VP_STATE_CREATE_INFO &info)
{
- DERIVED_OBJECT_INIT(xglCreateViewportState, dev.obj(), &info);
+ DERIVED_OBJECT_INIT(xglCreateDynamicViewportState, dev.obj(), &info);
alloc_memory(dev);
}
-void DynamicRsStateObject::init(const Device &dev, const XGL_RASTER_STATE_CREATE_INFO &info)
+void DynamicRsStateObject::init(const Device &dev, const XGL_DYNAMIC_RS_STATE_CREATE_INFO &info)
{
- DERIVED_OBJECT_INIT(xglCreateRasterState, dev.obj(), &info);
+ DERIVED_OBJECT_INIT(xglCreateDynamicRasterState, dev.obj(), &info);
alloc_memory(dev);
}
-void DynamicMsaaStateObject::init(const Device &dev, const XGL_MSAA_STATE_CREATE_INFO &info)
+void DynamicCbStateObject::init(const Device &dev, const XGL_DYNAMIC_CB_STATE_CREATE_INFO &info)
{
- DERIVED_OBJECT_INIT(xglCreateMsaaState, dev.obj(), &info);
+ DERIVED_OBJECT_INIT(xglCreateDynamicColorBlendState, dev.obj(), &info);
alloc_memory(dev);
}
-void DynamicCbStateObject::init(const Device &dev, const XGL_COLOR_BLEND_STATE_CREATE_INFO &info)
+void DynamicDsStateObject::init(const Device &dev, const XGL_DYNAMIC_DS_STATE_CREATE_INFO &info)
{
- DERIVED_OBJECT_INIT(xglCreateColorBlendState, dev.obj(), &info);
- alloc_memory(dev);
-}
-
-void DynamicDsStateObject::init(const Device &dev, const XGL_DEPTH_STENCIL_STATE_CREATE_INFO &info)
-{
- DERIVED_OBJECT_INIT(xglCreateDepthStencilState, dev.obj(), &info);
+ DERIVED_OBJECT_INIT(xglCreateDynamicDepthStencilState, dev.obj(), &info);
alloc_memory(dev);
}
diff --git a/tests/xgltestbinding.h b/tests/xgltestbinding.h
index a06ba16..88f15ae 100644
--- a/tests/xgltestbinding.h
+++ b/tests/xgltestbinding.h
@@ -171,11 +171,11 @@
class DynamicStateObject : public Object {
public:
- const XGL_STATE_OBJECT &obj() const { return reinterpret_cast<const XGL_STATE_OBJECT &>(Object::obj()); }
+ const XGL_DYNAMIC_STATE_OBJECT &obj() const { return reinterpret_cast<const XGL_DYNAMIC_STATE_OBJECT &>(Object::obj()); }
protected:
explicit DynamicStateObject() {}
- explicit DynamicStateObject(XGL_STATE_OBJECT obj) : Object(obj) {}
+ explicit DynamicStateObject(XGL_DYNAMIC_STATE_OBJECT obj) : Object(obj) {}
};
template<typename T, class C>
@@ -542,34 +542,28 @@
XGL_DESCRIPTOR_SET_CREATE_INFO info_;
};
-class DynamicVpStateObject : public DerivedObject<XGL_VIEWPORT_STATE_OBJECT, DynamicStateObject> {
+class DynamicVpStateObject : public DerivedObject<XGL_DYNAMIC_VP_STATE_OBJECT, DynamicStateObject> {
public:
- // xglCreateViewportState()
- void init(const Device &dev, const XGL_VIEWPORT_STATE_CREATE_INFO &info);
+ // xglCreateDynamicViewportState()
+ void init(const Device &dev, const XGL_DYNAMIC_VP_STATE_CREATE_INFO &info);
};
-class DynamicRsStateObject : public DerivedObject<XGL_RASTER_STATE_OBJECT, DynamicStateObject> {
+class DynamicRsStateObject : public DerivedObject<XGL_DYNAMIC_RS_STATE_OBJECT, DynamicStateObject> {
public:
- // xglCreateRasterState()
- void init(const Device &dev, const XGL_RASTER_STATE_CREATE_INFO &info);
+ // xglCreateDynamicRasterState()
+ void init(const Device &dev, const XGL_DYNAMIC_RS_STATE_CREATE_INFO &info);
};
-class DynamicMsaaStateObject : public DerivedObject<XGL_MSAA_STATE_OBJECT, DynamicStateObject> {
+class DynamicCbStateObject : public DerivedObject<XGL_DYNAMIC_CB_STATE_OBJECT, DynamicStateObject> {
public:
- // xglCreateMsaaState()
- void init(const Device &dev, const XGL_MSAA_STATE_CREATE_INFO &info);
+ // xglCreateDynamicColorBlendState()
+ void init(const Device &dev, const XGL_DYNAMIC_CB_STATE_CREATE_INFO &info);
};
-class DynamicCbStateObject : public DerivedObject<XGL_COLOR_BLEND_STATE_OBJECT, DynamicStateObject> {
+class DynamicDsStateObject : public DerivedObject<XGL_DYNAMIC_DS_STATE_OBJECT, DynamicStateObject> {
public:
- // xglCreateColorBlendState()
- void init(const Device &dev, const XGL_COLOR_BLEND_STATE_CREATE_INFO &info);
-};
-
-class DynamicDsStateObject : public DerivedObject<XGL_DEPTH_STENCIL_STATE_OBJECT, DynamicStateObject> {
-public:
- // xglCreateDepthStencilState()
- void init(const Device &dev, const XGL_DEPTH_STENCIL_STATE_CREATE_INFO &info);
+ // xglCreateDynamicDepthStencilState()
+ void init(const Device &dev, const XGL_DYNAMIC_DS_STATE_CREATE_INFO &info);
};
class CmdBuffer : public DerivedObject<XGL_CMD_BUFFER, Object> {
@@ -616,8 +610,7 @@
info.allocationSize = reqs.size;
info.alignment = reqs.alignment;
info.heapCount = reqs.heapCount;
- for (int i = 0; i < reqs.heapCount; i++)
- info.heaps[i] = reqs.heaps[i];
+ info.pHeaps = reqs.pHeaps;
info.memPriority = XGL_MEMORY_PRIORITY_NORMAL;
return info;
}
diff --git a/xgl-layer-generate.py b/xgl-layer-generate.py
index e5656db..85c4a81 100755
--- a/xgl-layer-generate.py
+++ b/xgl-layer-generate.py
@@ -558,11 +558,11 @@
"XGL_IMAGE_VIEW" : "XGL_OBJECT_TYPE_IMAGE_VIEW",
"XGL_COLOR_ATTACHMENT_VIEW" : "XGL_OBJECT_TYPE_COLOR_ATTACHMENT_VIEW",
"XGL_DEPTH_STENCIL_VIEW" : "XGL_OBJECT_TYPE_DEPTH_STENCIL_VIEW",
- "XGL_VIEWPORT_STATE_OBJECT" : "XGL_OBJECT_TYPE_VIEWPORT_STATE",
- "XGL_RASTER_STATE_OBJECT" : "XGL_OBJECT_TYPE_RASTER_STATE",
+ "XGL_DYNAMIC_VP_STATE_OBJECT" : "XGL_OBJECT_TYPE_VIEWPORT_STATE",
+ "XGL_DYNAMIC_RS_STATE_OBJECT" : "XGL_OBJECT_TYPE_RASTER_STATE",
"XGL_MSAA_STATE_OBJECT" : "XGL_OBJECT_TYPE_MSAA_STATE",
- "XGL_COLOR_BLEND_STATE_OBJECT" : "XGL_OBJECT_TYPE_COLOR_BLEND_STATE",
- "XGL_DEPTH_STENCIL_STATE_OBJECT" : "XGL_OBJECT_TYPE_DEPTH_STENCIL_STATE",
+ "XGL_DYNAMIC_CB_STATE_OBJECT" : "XGL_OBJECT_TYPE_COLOR_BLEND_STATE",
+ "XGL_DYNAMIC_DS_STATE_OBJECT" : "XGL_OBJECT_TYPE_DEPTH_STENCIL_STATE",
"XGL_BASE_OBJECT" : "ll_get_obj_type(object)",
"XGL_OBJECT" : "ll_get_obj_type(object)"
}
diff --git a/xgl.py b/xgl.py
index ef59f80..996f84c 100644
--- a/xgl.py
+++ b/xgl.py
@@ -200,12 +200,11 @@
"XGL_PIPELINE_DELTA",
"XGL_SAMPLER",
"XGL_DESCRIPTOR_SET",
- "XGL_STATE_OBJECT",
- "XGL_VIEWPORT_STATE_OBJECT",
- "XGL_RASTER_STATE_OBJECT",
- "XGL_MSAA_STATE_OBJECT",
- "XGL_COLOR_BLEND_STATE_OBJECT",
- "XGL_DEPTH_STENCIL_STATE_OBJECT",
+ "XGL_DYNAMIC_STATE_OBJECT",
+ "XGL_DYNAMIC_VP_STATE_OBJECT",
+ "XGL_DYNAMIC_RS_STATE_OBJECT",
+ "XGL_DYNAMIC_CB_STATE_OBJECT",
+ "XGL_DYNAMIC_DS_STATE_OBJECT",
"XGL_CMD_BUFFER",
"XGL_FENCE",
"XGL_QUEUE_SEMAPHORE",
@@ -542,30 +541,25 @@
Param("XGL_UINT", "startSlot"),
Param("XGL_UINT", "slotCount")]),
- Proto("XGL_RESULT", "CreateViewportState",
+ Proto("XGL_RESULT", "CreateDynamicViewportState",
[Param("XGL_DEVICE", "device"),
- Param("const XGL_VIEWPORT_STATE_CREATE_INFO*", "pCreateInfo"),
- Param("XGL_VIEWPORT_STATE_OBJECT*", "pState")]),
+ Param("const XGL_DYNAMIC_VP_STATE_CREATE_INFO*", "pCreateInfo"),
+ Param("XGL_DYNAMIC_VP_STATE_OBJECT*", "pState")]),
- Proto("XGL_RESULT", "CreateRasterState",
+ Proto("XGL_RESULT", "CreateDynamicRasterState",
[Param("XGL_DEVICE", "device"),
- Param("const XGL_RASTER_STATE_CREATE_INFO*", "pCreateInfo"),
- Param("XGL_RASTER_STATE_OBJECT*", "pState")]),
+ Param("const XGL_DYNAMIC_RS_STATE_CREATE_INFO*", "pCreateInfo"),
+ Param("XGL_DYNAMIC_RS_STATE_OBJECT*", "pState")]),
- Proto("XGL_RESULT", "CreateMsaaState",
+ Proto("XGL_RESULT", "CreateDynamicColorBlendState",
[Param("XGL_DEVICE", "device"),
- Param("const XGL_MSAA_STATE_CREATE_INFO*", "pCreateInfo"),
- Param("XGL_MSAA_STATE_OBJECT*", "pState")]),
+ Param("const XGL_DYNAMIC_CB_STATE_CREATE_INFO*", "pCreateInfo"),
+ Param("XGL_DYNAMIC_CB_STATE_OBJECT*", "pState")]),
- Proto("XGL_RESULT", "CreateColorBlendState",
+ Proto("XGL_RESULT", "CreateDynamicDepthStencilState",
[Param("XGL_DEVICE", "device"),
- Param("const XGL_COLOR_BLEND_STATE_CREATE_INFO*", "pCreateInfo"),
- Param("XGL_COLOR_BLEND_STATE_OBJECT*", "pState")]),
-
- Proto("XGL_RESULT", "CreateDepthStencilState",
- [Param("XGL_DEVICE", "device"),
- Param("const XGL_DEPTH_STENCIL_STATE_CREATE_INFO*", "pCreateInfo"),
- Param("XGL_DEPTH_STENCIL_STATE_OBJECT*", "pState")]),
+ Param("const XGL_DYNAMIC_DS_STATE_CREATE_INFO*", "pCreateInfo"),
+ Param("XGL_DYNAMIC_DS_STATE_OBJECT*", "pState")]),
Proto("XGL_RESULT", "CreateCommandBuffer",
[Param("XGL_DEVICE", "device"),
@@ -592,10 +586,10 @@
Param("XGL_PIPELINE_BIND_POINT", "pipelineBindPoint"),
Param("XGL_PIPELINE_DELTA", "delta")]),
- Proto("XGL_VOID", "CmdBindStateObject",
+ Proto("XGL_VOID", "CmdBindDynamicStateObject",
[Param("XGL_CMD_BUFFER", "cmdBuffer"),
Param("XGL_STATE_BIND_POINT", "stateBindPoint"),
- Param("XGL_STATE_OBJECT", "state")]),
+ Param("XGL_DYNAMIC_STATE_OBJECT", "state")]),
Proto("XGL_VOID", "CmdBindDescriptorSet",
[Param("XGL_CMD_BUFFER", "cmdBuffer"),