Bug 14406: Add support for front/back stencil reference dynamic state

5 files changed, 359 insertions, 103 deletions

diff --git a/layers/draw_state.cpp b/layers/draw_state.cpp
index c465768b..a05fc659 100644
--- a/layers/draw_state.cpp
+++ b/layers/draw_state.cpp
@@ -68,7 +68,8 @@ unordered_map<uint64_t, VkDynamicViewportStateCreateInfo> dynamicVpStateMap;
 unordered_map<uint64_t, VkDynamicRasterLineStateCreateInfo> dynamicRasterLineStateMap;
 unordered_map<uint64_t, VkDynamicRasterDepthBiasStateCreateInfo> dynamicRasterDepthBiasStateMap;
 unordered_map<uint64_t, VkDynamicColorBlendStateCreateInfo> dynamicCbStateMap;
-unordered_map<uint64_t, VkDynamicDepthStencilStateCreateInfo> dynamicDsStateMap;
+unordered_map<uint64_t, VkDynamicDepthStateCreateInfo> dynamicDepthStateMap;
+unordered_map<uint64_t, std::pair<VkDynamicStencilStateCreateInfo, VkDynamicStencilStateCreateInfo>> dynamicStencilStateMap;
 unordered_map<uint64_t, PIPELINE_NODE*> pipelineMap;
 unordered_map<uint64_t, POOL_NODE*> poolMap;
 unordered_map<uint64_t, SET_NODE*> setMap;
@@ -147,8 +148,10 @@ static string cmdTypeToString(CMD_TYPE cmd)
             return "CMD_BINDDYNAMICRASTERDEPTHBIASSTATE";
         case CMD_BINDDYNAMICCOLORBLENDSTATE:
             return "CMD_BINDDYNAMICCOLORBLENDSTATE";
-        case CMD_BINDDYNAMICDEPTHSTENCILSTATE:
-            return "CMD_BINDDYNAMICDEPTHSTENCILSTATE";
+        case CMD_BINDDYNAMICDEPTHSTATE:
+            return "CMD_BINDDYNAMICDEPTHSTATE";
+        case CMD_BINDDYNAMICSTENCILSTATE:
+            return "CMD_BINDDYNAMICSTENCILSTATE";
         case CMD_BINDDESCRIPTORSETS:
             return "CMD_BINDDESCRIPTORSETS";
         case CMD_BINDINDEXBUFFER:
@@ -263,7 +266,8 @@ static void deleteDynamicState()
     dynamicRasterLineStateMap.clear();
     dynamicRasterDepthBiasStateMap.clear();
     dynamicCbStateMap.clear();
-    dynamicDsStateMap.clear();
+    dynamicDepthStateMap.clear();
+    dynamicStencilStateMap.clear();
 }
 // Free all sampler nodes
 static void deleteSamplers()
@@ -368,8 +372,10 @@ static void* getDynamicStateCreateInfo(const uint64_t handle, const DYNAMIC_STAT
             return (void*)&dynamicRasterDepthBiasStateMap[handle];
         case VK_STATE_BIND_POINT_COLOR_BLEND:
             return (void*)&dynamicCbStateMap[handle];
-        case VK_STATE_BIND_POINT_DEPTH_STENCIL:
-            return (void*)&dynamicDsStateMap[handle];
+        case VK_STATE_BIND_POINT_DEPTH:
+            return (void*)&dynamicDepthStateMap[handle];
+        case VK_STATE_BIND_POINT_STENCIL:
+            return (void*)&dynamicStencilStateMap[handle];
         default:
             return NULL;
     }
@@ -418,7 +424,8 @@ static VkBool32 validate_draw_state_flags(GLOBAL_CB_NODE* pCB, VkBool32 indexedD
     result &= validate_status(pCB, CBSTATUS_NONE, CBSTATUS_RASTER_LINE_BOUND,   CBSTATUS_RASTER_LINE_BOUND,   VK_DBG_REPORT_ERROR_BIT, DRAWSTATE_RASTER_LINE_NOT_BOUND,   "Raster line object not bound to this command buffer");
     result &= validate_status(pCB, CBSTATUS_NONE, CBSTATUS_RASTER_DEPTH_BIAS_BOUND,   CBSTATUS_RASTER_DEPTH_BIAS_BOUND,   VK_DBG_REPORT_ERROR_BIT, DRAWSTATE_RASTER_DEPTH_BIAS_NOT_BOUND,   "Raster depth bias object not bound to this command buffer");
     result &= validate_status(pCB, CBSTATUS_COLOR_BLEND_WRITE_ENABLE, CBSTATUS_COLOR_BLEND_BOUND,   CBSTATUS_COLOR_BLEND_BOUND,   VK_DBG_REPORT_ERROR_BIT,  DRAWSTATE_COLOR_BLEND_NOT_BOUND,   "Color-blend object not bound to this command buffer");
-    result &= validate_status(pCB, CBSTATUS_DEPTH_STENCIL_WRITE_ENABLE, CBSTATUS_DEPTH_STENCIL_BOUND, CBSTATUS_DEPTH_STENCIL_BOUND, VK_DBG_REPORT_ERROR_BIT,  DRAWSTATE_DEPTH_STENCIL_NOT_BOUND, "Depth-stencil object not bound to this command buffer");
+    result &= validate_status(pCB, CBSTATUS_DEPTH_WRITE_ENABLE, CBSTATUS_DEPTH_BOUND, CBSTATUS_DEPTH_BOUND, VK_DBG_REPORT_ERROR_BIT,  DRAWSTATE_DEPTH_NOT_BOUND, "Depth object not bound to this command buffer");
+    result &= validate_status(pCB, CBSTATUS_STENCIL_TEST_ENABLE, CBSTATUS_STENCIL_BOUND, CBSTATUS_STENCIL_BOUND, VK_DBG_REPORT_ERROR_BIT,  DRAWSTATE_STENCIL_NOT_BOUND, "Stencil object not bound to this command buffer");
     if (indexedDraw)
         result &= validate_status(pCB, CBSTATUS_NONE, CBSTATUS_INDEX_BUFFER_BOUND, CBSTATUS_INDEX_BUFFER_BOUND, VK_DBG_REPORT_ERROR_BIT, DRAWSTATE_INDEX_BUFFER_NOT_BOUND, "Index buffer object not bound to this command buffer when Index Draw attempted");
     return result;
@@ -1135,7 +1142,11 @@ static void set_cb_pso_status(GLOBAL_CB_NODE* pCB, const PIPELINE_NODE* pPipe)
         }
     }
     if (pPipe->dsStateCI.depthWriteEnable) {
-        pCB->status |= CBSTATUS_DEPTH_STENCIL_WRITE_ENABLE;
+        pCB->status |= CBSTATUS_DEPTH_WRITE_ENABLE;
+    }
+
+    if (pPipe->dsStateCI.stencilTestEnable) {
+        pCB->status |= CBSTATUS_STENCIL_TEST_ENABLE;
     }
 }
 // Set dyn-state related status bits for an object node
@@ -1148,8 +1159,10 @@ static void set_cb_dyn_status(GLOBAL_CB_NODE* pNode, DYNAMIC_STATE_BIND_POINT st
         pNode->status |= CBSTATUS_RASTER_DEPTH_BIAS_BOUND;
     } else if (stateBindPoint == VK_STATE_BIND_POINT_COLOR_BLEND) {
         pNode->status |= CBSTATUS_COLOR_BLEND_BOUND;
-    } else if (stateBindPoint == VK_STATE_BIND_POINT_DEPTH_STENCIL) {
-        pNode->status |= CBSTATUS_DEPTH_STENCIL_BOUND;
+    } else if (stateBindPoint == VK_STATE_BIND_POINT_DEPTH) {
+        pNode->status |= CBSTATUS_DEPTH_BOUND;
+    } else if (stateBindPoint == VK_STATE_BIND_POINT_STENCIL) {
+        pNode->status |= CBSTATUS_STENCIL_BOUND;
     }
 }
 // Print the last bound Gfx Pipeline
@@ -1635,9 +1648,16 @@ VK_LAYER_EXPORT VkResult VKAPI vkDestroyDynamicColorBlendState(VkDevice device,
     return result;
 }
 
-VK_LAYER_EXPORT VkResult VKAPI vkDestroyDynamicDepthStencilState(VkDevice device, VkDynamicDepthStencilState dynamicDepthStencilState)
+VK_LAYER_EXPORT VkResult VKAPI vkDestroyDynamicDepthState(VkDevice device, VkDynamicDepthState dynamicDepthState)
+{
+    VkResult result = get_dispatch_table(draw_state_device_table_map, device)->DestroyDynamicDepthState(device, dynamicDepthState);
+    // TODO : Clean up any internal data structures using this obj.
+    return result;
+}
+
+VK_LAYER_EXPORT VkResult VKAPI vkDestroyDynamicStencilState(VkDevice device, VkDynamicStencilState dynamicStencilState)
 {
-    VkResult result = get_dispatch_table(draw_state_device_table_map, device)->DestroyDynamicDepthStencilState(device, dynamicDepthStencilState);
+    VkResult result = get_dispatch_table(draw_state_device_table_map, device)->DestroyDynamicStencilState(device, dynamicStencilState);
     // TODO : Clean up any internal data structures using this obj.
     return result;
 }
@@ -1997,12 +2017,28 @@ VK_LAYER_EXPORT VkResult VKAPI vkCreateDynamicColorBlendState(VkDevice device, c
     return result;
 }
 
-VK_LAYER_EXPORT VkResult VKAPI vkCreateDynamicDepthStencilState(VkDevice device, const VkDynamicDepthStencilStateCreateInfo* pCreateInfo, VkDynamicDepthStencilState* pState)
+VK_LAYER_EXPORT VkResult VKAPI vkCreateDynamicDepthState(VkDevice device, const VkDynamicDepthStateCreateInfo* pCreateInfo, VkDynamicDepthState* pState)
+{
+    VkResult result = get_dispatch_table(draw_state_device_table_map, device)->CreateDynamicDepthState(device, pCreateInfo, pState);
+    //insertDynamicState(*pState, (GENERIC_HEADER*)pCreateInfo, VK_STATE_BIND_POINT_DEPTH);
+    loader_platform_thread_lock_mutex(&globalLock);
+    dynamicDepthStateMap[pState->handle] = *pCreateInfo;
+    loader_platform_thread_unlock_mutex(&globalLock);
+    return result;
+}
+
+VK_LAYER_EXPORT VkResult VKAPI vkCreateDynamicStencilState(VkDevice device, const VkDynamicStencilStateCreateInfo* pCreateInfoFront, const VkDynamicStencilStateCreateInfo* pCreateInfoBack, VkDynamicStencilState* pState)
 {
-    VkResult result = get_dispatch_table(draw_state_device_table_map, device)->CreateDynamicDepthStencilState(device, pCreateInfo, pState);
-    //insertDynamicState(*pState, (GENERIC_HEADER*)pCreateInfo, VK_STATE_BIND_POINT_DEPTH_STENCIL);
+    VkResult result = get_dispatch_table(draw_state_device_table_map, device)->CreateDynamicStencilState(device, pCreateInfoFront, pCreateInfoBack, pState);
+    //insertDynamicState(*pState, (GENERIC_HEADER*)pCreateInfo, VK_STATE_BIND_POINT_STENCIL);
     loader_platform_thread_lock_mutex(&globalLock);
-    dynamicDsStateMap[pState->handle] = *pCreateInfo;
+
+    // Bug 14406 - If back is NULL or equal to front, then single sided.
+    // To support NULL case, simply track front twice
+    const VkDynamicStencilStateCreateInfo* pLocalCreateInfoBack = (pCreateInfoBack == NULL) ? pCreateInfoFront : pCreateInfoBack;
+
+    std::pair<VkDynamicStencilStateCreateInfo, VkDynamicStencilStateCreateInfo> infos(*pCreateInfoFront, *pLocalCreateInfoBack);
+    dynamicStencilStateMap[pState->handle] = infos;
     loader_platform_thread_unlock_mutex(&globalLock);
     return result;
 }
@@ -2232,30 +2268,57 @@ VK_LAYER_EXPORT void VKAPI vkCmdBindDynamicColorBlendState(VkCmdBuffer cmdBuffer
         }
     }
 }
-VK_LAYER_EXPORT void VKAPI vkCmdBindDynamicDepthStencilState(VkCmdBuffer cmdBuffer, VkDynamicDepthStencilState dynamicDepthStencilState)
+VK_LAYER_EXPORT void VKAPI vkCmdBindDynamicDepthState(VkCmdBuffer cmdBuffer, VkDynamicDepthState dynamicDepthState)
+{
+    GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
+    if (pCB) {
+        if (pCB->state == CB_UPDATE_ACTIVE) {
+            updateCBTracking(cmdBuffer);
+            addCmd(pCB, CMD_BINDDYNAMICDEPTHSTATE);
+            if (!pCB->activeRenderPass) {
+                log_msg(mdd(pCB->cmdBuffer), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType) 0, 0, 0, DRAWSTATE_NO_ACTIVE_RENDERPASS, "DS",
+                        "Incorrect call to vkCmdBindDynamicDepthState() without an active RenderPass.");
+            }
+            loader_platform_thread_lock_mutex(&globalLock);
+            pCB->status |= CBSTATUS_DEPTH_BOUND;
+            if (dynamicDepthStateMap.find(dynamicDepthState.handle) == dynamicDepthStateMap.end()) {
+                log_msg(mdd(cmdBuffer), VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DYNAMIC_DEPTH_STATE, dynamicDepthState.handle, 0, DRAWSTATE_INVALID_DYNAMIC_STATE_OBJECT, "DS",
+                        "Unable to find VkDynamicDepthState object %#" PRIxLEAST64 ", was it ever created?", dynamicDepthState.handle);
+            } else {
+                pCB->lastBoundDynamicState[VK_STATE_BIND_POINT_DEPTH] = dynamicDepthState.handle;
+                g_lastBoundDynamicState[VK_STATE_BIND_POINT_DEPTH] = dynamicDepthState.handle;
+            }
+            loader_platform_thread_unlock_mutex(&globalLock);
+            get_dispatch_table(draw_state_device_table_map, cmdBuffer)->CmdBindDynamicDepthState(cmdBuffer, dynamicDepthState);
+        } else {
+            report_error_no_cb_begin(cmdBuffer, "vkCmdBindDynamicDepthState()");
+        }
+    }
+}
+VK_LAYER_EXPORT void VKAPI vkCmdBindDynamicStencilState(VkCmdBuffer cmdBuffer, VkDynamicStencilState dynamicStencilState)
 {
     GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
     if (pCB) {
         if (pCB->state == CB_UPDATE_ACTIVE) {
             updateCBTracking(cmdBuffer);
-            addCmd(pCB, CMD_BINDDYNAMICDEPTHSTENCILSTATE);
+            addCmd(pCB, CMD_BINDDYNAMICSTENCILSTATE);
             if (!pCB->activeRenderPass) {
                 log_msg(mdd(pCB->cmdBuffer), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType) 0, 0, 0, DRAWSTATE_NO_ACTIVE_RENDERPASS, "DS",
-                        "Incorrect call to vkCmdBindDynamicDepthStencilState() without an active RenderPass.");
+                        "Incorrect call to vkCmdBindDynamicStencilState() without an active RenderPass.");
             }
             loader_platform_thread_lock_mutex(&globalLock);
-            pCB->status |= CBSTATUS_DEPTH_STENCIL_BOUND;
-            if (dynamicDsStateMap.find(dynamicDepthStencilState.handle) == dynamicDsStateMap.end()) {
-                log_msg(mdd(cmdBuffer), VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DYNAMIC_DEPTH_STENCIL_STATE, dynamicDepthStencilState.handle, 0, DRAWSTATE_INVALID_DYNAMIC_STATE_OBJECT, "DS",
-                        "Unable to find VkDynamicDepthStencilState object %#" PRIxLEAST64 ", was it ever created?", dynamicDepthStencilState.handle);
+            pCB->status |= CBSTATUS_STENCIL_BOUND;
+            if (dynamicStencilStateMap.find(dynamicStencilState.handle) == dynamicStencilStateMap.end()) {
+                log_msg(mdd(cmdBuffer), VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DYNAMIC_STENCIL_STATE, dynamicStencilState.handle, 0, DRAWSTATE_INVALID_DYNAMIC_STATE_OBJECT, "DS",
+                        "Unable to find VkDynamicStencilState object %#" PRIxLEAST64 ", was it ever created?", dynamicStencilState.handle);
             } else {
-                pCB->lastBoundDynamicState[VK_STATE_BIND_POINT_DEPTH_STENCIL] = dynamicDepthStencilState.handle;
-                g_lastBoundDynamicState[VK_STATE_BIND_POINT_DEPTH_STENCIL] = dynamicDepthStencilState.handle;
+                pCB->lastBoundDynamicState[VK_STATE_BIND_POINT_STENCIL] = dynamicStencilState.handle;
+                g_lastBoundDynamicState[VK_STATE_BIND_POINT_STENCIL] = dynamicStencilState.handle;
             }
             loader_platform_thread_unlock_mutex(&globalLock);
-            get_dispatch_table(draw_state_device_table_map, cmdBuffer)->CmdBindDynamicDepthStencilState(cmdBuffer, dynamicDepthStencilState);
+            get_dispatch_table(draw_state_device_table_map, cmdBuffer)->CmdBindDynamicStencilState(cmdBuffer, dynamicStencilState);
         } else {
-            report_error_no_cb_begin(cmdBuffer, "vkCmdBindDynamicDepthStencilState()");
+            report_error_no_cb_begin(cmdBuffer, "vkCmdBindDynamicStencilState()");
         }
     }
 }
@@ -3120,8 +3183,10 @@ VK_LAYER_EXPORT PFN_vkVoidFunction VKAPI vkGetDeviceProcAddr(VkDevice dev, const
         return (PFN_vkVoidFunction) vkDestroyDynamicRasterDepthBiasState;
     if (!strcmp(funcName, "vkDestroyDynamicColorBlendState"))
         return (PFN_vkVoidFunction) vkDestroyDynamicColorBlendState;
-    if (!strcmp(funcName, "vkDestroyDynamicDepthStencilState"))
-        return (PFN_vkVoidFunction) vkDestroyDynamicDepthStencilState;
+    if (!strcmp(funcName, "vkDestroyDynamicDepthState"))
+        return (PFN_vkVoidFunction) vkDestroyDynamicDepthState;
+    if (!strcmp(funcName, "vkDestroyDynamicStencilState"))
+        return (PFN_vkVoidFunction) vkDestroyDynamicStencilState;
     if (!strcmp(funcName, "vkDestroyCommandBuffer"))
         return (PFN_vkVoidFunction) vkDestroyCommandBuffer;
     if (!strcmp(funcName, "vkDestroyFramebuffer"))
@@ -3168,8 +3233,10 @@ VK_LAYER_EXPORT PFN_vkVoidFunction VKAPI vkGetDeviceProcAddr(VkDevice dev, const
         return (PFN_vkVoidFunction) vkCreateDynamicRasterDepthBiasState;
     if (!strcmp(funcName, "vkCreateDynamicColorBlendState"))
         return (PFN_vkVoidFunction) vkCreateDynamicColorBlendState;
-    if (!strcmp(funcName, "vkCreateDynamicDepthStencilState"))
-        return (PFN_vkVoidFunction) vkCreateDynamicDepthStencilState;
+    if (!strcmp(funcName, "vkCreateDynamicDepthState"))
+        return (PFN_vkVoidFunction) vkCreateDynamicDepthState;
+    if (!strcmp(funcName, "vkCreateDynamicStencilState"))
+        return (PFN_vkVoidFunction) vkCreateDynamicStencilState;
     if (!strcmp(funcName, "vkCreateCommandBuffer"))
         return (PFN_vkVoidFunction) vkCreateCommandBuffer;
     if (!strcmp(funcName, "vkBeginCommandBuffer"))
@@ -3188,8 +3255,10 @@ VK_LAYER_EXPORT PFN_vkVoidFunction VKAPI vkGetDeviceProcAddr(VkDevice dev, const
         return (PFN_vkVoidFunction) vkCmdBindDynamicRasterDepthBiasState;
     if (!strcmp(funcName, "vkCmdBindDynamicColorBlendState"))
         return (PFN_vkVoidFunction) vkCmdBindDynamicColorBlendState;
-    if (!strcmp(funcName, "vkCmdBindDynamicDepthStencilState"))
-        return (PFN_vkVoidFunction) vkCmdBindDynamicDepthStencilState;
+    if (!strcmp(funcName, "vkCmdBindDynamicDepthState"))
+        return (PFN_vkVoidFunction) vkCmdBindDynamicDepthState;
+    if (!strcmp(funcName, "vkCmdBindDynamicStencilState"))
+        return (PFN_vkVoidFunction) vkCmdBindDynamicStencilState;
     if (!strcmp(funcName, "vkCmdBindDescriptorSets"))
         return (PFN_vkVoidFunction) vkCmdBindDescriptorSets;
     if (!strcmp(funcName, "vkCmdBindVertexBuffers"))
diff --git a/layers/draw_state.h b/layers/draw_state.h
index 4c7c3555..fe4b03d7 100644
--- a/layers/draw_state.h
+++ b/layers/draw_state.h
@@ -55,7 +55,8 @@ typedef enum _DRAW_STATE_ERROR
     DRAWSTATE_RASTER_LINE_NOT_BOUND,            // Draw submitted with no raster line state object bound
     DRAWSTATE_RASTER_DEPTH_BIAS_NOT_BOUND,      // Draw submitted with no raster depth bias state object bound
     DRAWSTATE_COLOR_BLEND_NOT_BOUND,            // Draw submitted with no color blend state object bound when color write enabled
-    DRAWSTATE_DEPTH_STENCIL_NOT_BOUND,          // Draw submitted with no depth-stencil state object bound when depth write enabled
+    DRAWSTATE_DEPTH_NOT_BOUND,                  // Draw submitted with no depth state object bound when depth enabled
+    DRAWSTATE_STENCIL_NOT_BOUND,                // Draw submitted with no stencil state object bound when stencil enabled
     DRAWSTATE_INDEX_BUFFER_NOT_BOUND,           // Draw submitted with no depth-stencil state object bound when depth write enabled
     DRAWSTATE_PIPELINE_LAYOUT_MISMATCH,         // Draw submitted PSO Pipeline layout that doesn't match layout from BindDescriptorSets
     DRAWSTATE_INVALID_RENDERPASS,               // Use of a NULL or otherwise invalid RenderPass object
@@ -168,7 +169,8 @@ typedef enum _CMD_TYPE
     CMD_BINDDYNAMICRASTERLINESTATE,
     CMD_BINDDYNAMICRASTERDEPTHBIASSTATE,
     CMD_BINDDYNAMICCOLORBLENDSTATE,
-    CMD_BINDDYNAMICDEPTHSTENCILSTATE,
+    CMD_BINDDYNAMICDEPTHSTATE,
+    CMD_BINDDYNAMICSTENCILSTATE,
     CMD_BINDDESCRIPTORSETS,
     CMD_BINDINDEXBUFFER,
     CMD_BINDVERTEXBUFFER,
@@ -231,9 +233,11 @@ typedef enum _CBStatusFlagBits
     CBSTATUS_RASTER_DEPTH_BIAS_BOUND           = 0x00000004, // Raster state object has been bound
     CBSTATUS_COLOR_BLEND_WRITE_ENABLE          = 0x00000008, // PSO w/ CB Enable set has been bound
     CBSTATUS_COLOR_BLEND_BOUND                 = 0x00000010, // CB state object has been bound
-    CBSTATUS_DEPTH_STENCIL_WRITE_ENABLE        = 0x00000020, // PSO w/ DS Enable set has been bound
-    CBSTATUS_DEPTH_STENCIL_BOUND               = 0x00000040, // DS state object has been bound
-    CBSTATUS_INDEX_BUFFER_BOUND                = 0x00000080, // Index buffer has been bound
+    CBSTATUS_DEPTH_WRITE_ENABLE                = 0x00000020, // PSO w/ Depth Enable set has been bound
+    CBSTATUS_STENCIL_TEST_ENABLE               = 0x00000040, // PSO w/ Stencil Enable set has been bound
+    CBSTATUS_DEPTH_BOUND                       = 0x00000080, // Depth state object has been bound
+    CBSTATUS_STENCIL_BOUND                     = 0x00000100, // Stencil state object has been bound
+    CBSTATUS_INDEX_BUFFER_BOUND                = 0x00000200, // Index buffer has been bound
 } CBStatusFlagBits;
 
 // Cmd Buffer Wrapper Struct
diff --git a/layers/layer_common.h b/layers/layer_common.h
index 4cb2ae12..f4579052 100644
--- a/layers/layer_common.h
+++ b/layers/layer_common.h
@@ -29,7 +29,8 @@ typedef enum _DYNAMIC_STATE_BIND_POINT
     VK_STATE_BIND_POINT_RASTER_LINE,
     VK_STATE_BIND_POINT_RASTER_DEPTH_BIAS,
     VK_STATE_BIND_POINT_COLOR_BLEND,
-    VK_STATE_BIND_POINT_DEPTH_STENCIL,
+    VK_STATE_BIND_POINT_DEPTH,
+    VK_STATE_BIND_POINT_STENCIL,
     VK_NUM_STATE_BIND_POINT // Used for array sizing
 } DYNAMIC_STATE_BIND_POINT;
 
@@ -45,8 +46,10 @@ static string string_DYNAMIC_STATE_BIND_POINT(DYNAMIC_STATE_BIND_POINT sbp)
             return "RASTER_DEPTH_BIAS";
         case VK_STATE_BIND_POINT_COLOR_BLEND:
             return "COLOR_BLEND";
-        case VK_STATE_BIND_POINT_DEPTH_STENCIL:
-            return "DEPTH_STENCIL";
+        case VK_STATE_BIND_POINT_DEPTH:
+            return "DEPTH";
+        case VK_STATE_BIND_POINT_STENCIL:
+            return "STENCIL";
         default:
             return "UNKNOWN_DYNAMIC_STATE_BIND_POINT";
     }
@@ -64,8 +67,10 @@ static VkDbgObjectType dynamicStateBindPointToObjType(DYNAMIC_STATE_BIND_POINT s
             return VK_OBJECT_TYPE_DYNAMIC_RASTER_DEPTH_BIAS_STATE;
         case VK_STATE_BIND_POINT_COLOR_BLEND:
             return VK_OBJECT_TYPE_DYNAMIC_COLOR_BLEND_STATE;
-        case VK_STATE_BIND_POINT_DEPTH_STENCIL:
-            return VK_OBJECT_TYPE_DYNAMIC_DEPTH_STENCIL_STATE;
+        case VK_STATE_BIND_POINT_DEPTH:
+            return VK_OBJECT_TYPE_DYNAMIC_DEPTH_STATE;
+        case VK_STATE_BIND_POINT_STENCIL:
+            return VK_OBJECT_TYPE_DYNAMIC_STENCIL_STATE;
         default:
             return VK_OBJECT_TYPE_MAX_ENUM;
     }
diff --git a/layers/mem_tracker.cpp b/layers/mem_tracker.cpp
index 846cc5bc..f7bc3a5b 100644
--- a/layers/mem_tracker.cpp
+++ b/layers/mem_tracker.cpp
@@ -98,7 +98,8 @@ unordered_map<uint64_t, VkDynamicViewportStateCreateInfo>     dynamicViewportSta
 unordered_map<uint64_t, VkDynamicRasterLineStateCreateInfo>   dynamicRasterLineStateMap;
 unordered_map<uint64_t, VkDynamicRasterDepthBiasStateCreateInfo> dynamicRasterDepthBiasStateMap;
 unordered_map<uint64_t, VkDynamicColorBlendStateCreateInfo>   dynamicColorBlendStateMap;
-unordered_map<uint64_t, VkDynamicDepthStencilStateCreateInfo> dynamicDepthStencilStateMap;
+unordered_map<uint64_t, VkDynamicDepthStateCreateInfo> dynamicDepthStateMap;
+unordered_map<uint64_t, VkDynamicStencilStateCreateInfo> dynamicStencilStateMap;
 
 // For a given handle and object type, return a ptr to its CreateInfo struct, or NULL if not found
 static void* get_object_create_info(uint64_t handle, VkDbgObjectType type)
@@ -246,10 +247,17 @@ static void* get_object_create_info(uint64_t handle, VkDbgObjectType type)
                 return (void*)&(*it).second;
             break;
         }
-        case VK_OBJECT_TYPE_DYNAMIC_DEPTH_STENCIL_STATE:
+        case VK_OBJECT_TYPE_DYNAMIC_DEPTH_STATE:
         {
-            auto it = dynamicDepthStencilStateMap.find(handle);
-            if (it != dynamicDepthStencilStateMap.end())
+            auto it = dynamicDepthStateMap.find(handle);
+            if (it != dynamicDepthStateMap.end())
+                return (void*)&(*it).second;
+            break;
+        }
+        case VK_OBJECT_TYPE_DYNAMIC_STENCIL_STATE:
+        {
+            auto it = dynamicStencilStateMap.find(handle);
+            if (it != dynamicStencilStateMap.end())
                 return (void*)&(*it).second;
             break;
         }
@@ -537,10 +545,16 @@ static void add_object_create_info(const uint64_t handle, const VkDbgObjectType
             memcpy(pCI, pCreateInfo, sizeof(VkDynamicColorBlendStateCreateInfo));
             break;
         }
-        case VK_OBJECT_TYPE_DYNAMIC_DEPTH_STENCIL_STATE:
+        case VK_OBJECT_TYPE_DYNAMIC_DEPTH_STATE:
+        {
+            auto pCI = &dynamicDepthStateMap[handle];
+            memcpy(pCI, pCreateInfo, sizeof(VkDynamicDepthStateCreateInfo));
+            break;
+        }
+        case VK_OBJECT_TYPE_DYNAMIC_STENCIL_STATE:
         {
-            auto pCI = &dynamicDepthStencilStateMap[handle];
-            memcpy(pCI, pCreateInfo, sizeof(VkDynamicDepthStencilStateCreateInfo));
+            auto pCI = &dynamicStencilStateMap[handle];
+            memcpy(pCI, pCreateInfo, sizeof(VkDynamicStencilStateCreateInfo));
             break;
         }
         default:
@@ -1153,7 +1167,8 @@ static void print_object_list(
     print_object_map_members(dispObj, dynamicRasterLineStateMap,   VK_OBJECT_TYPE_DYNAMIC_RASTER_LINE_STATE,   "DynamicRasterLineState");
     print_object_map_members(dispObj, dynamicRasterDepthBiasStateMap, VK_OBJECT_TYPE_DYNAMIC_RASTER_DEPTH_BIAS_STATE, "DynamicRasterDepthBiasState");
     print_object_map_members(dispObj, dynamicColorBlendStateMap,   VK_OBJECT_TYPE_DYNAMIC_COLOR_BLEND_STATE,   "DynamicColorBlendState");
-    print_object_map_members(dispObj, dynamicDepthStencilStateMap, VK_OBJECT_TYPE_DYNAMIC_DEPTH_STENCIL_STATE, "DynamicDepthStencilState");
+    print_object_map_members(dispObj, dynamicDepthStateMap,        VK_OBJECT_TYPE_DYNAMIC_DEPTH_STATE,         "DynamicDepthState");
+    print_object_map_members(dispObj, dynamicStencilStateMap,      VK_OBJECT_TYPE_DYNAMIC_STENCIL_STATE,       "DynamicStencilState");
     log_msg(mdd(dispObj), VK_DBG_REPORT_INFO_BIT, VK_OBJECT_TYPE_DEVICE, 0, 0, MEMTRACK_NONE, "MEM", "*** End of Object lists ***");
 }
 
@@ -1873,15 +1888,27 @@ VK_LAYER_EXPORT VkResult VKAPI vkDestroyDynamicColorBlendState(VkDevice device,
     return result;
 }
 
-VK_LAYER_EXPORT VkResult VKAPI vkDestroyDynamicDepthStencilState(VkDevice device, VkDynamicDepthStencilState dynamicDepthStencilState)
+VK_LAYER_EXPORT VkResult VKAPI vkDestroyDynamicDepthState(VkDevice device, VkDynamicDepthState dynamicDepthState)
+{
+    loader_platform_thread_lock_mutex(&globalLock);
+    auto item = dynamicDepthStateMap.find(dynamicDepthState.handle);
+    if (item != dynamicDepthStateMap.end()) {
+        dynamicDepthStateMap.erase(item);
+    }
+    loader_platform_thread_unlock_mutex(&globalLock);
+    VkResult result = get_dispatch_table(mem_tracker_device_table_map, device)->DestroyDynamicDepthState(device, dynamicDepthState);
+    return result;
+}
+
+VK_LAYER_EXPORT VkResult VKAPI vkDestroyDynamicStencilState(VkDevice device, VkDynamicStencilState dynamicStencilState)
 {
     loader_platform_thread_lock_mutex(&globalLock);
-    auto item = dynamicDepthStencilStateMap.find(dynamicDepthStencilState.handle);
-    if (item != dynamicDepthStencilStateMap.end()) {
-        dynamicDepthStencilStateMap.erase(item);
+    auto item = dynamicStencilStateMap.find(dynamicStencilState.handle);
+    if (item != dynamicStencilStateMap.end()) {
+        dynamicStencilStateMap.erase(item);
     }
     loader_platform_thread_unlock_mutex(&globalLock);
-    VkResult result = get_dispatch_table(mem_tracker_device_table_map, device)->DestroyDynamicDepthStencilState(device, dynamicDepthStencilState);
+    VkResult result = get_dispatch_table(mem_tracker_device_table_map, device)->DestroyDynamicStencilState(device, dynamicStencilState);
     return result;
 }
 
@@ -2353,15 +2380,35 @@ VK_LAYER_EXPORT VkResult VKAPI vkCreateDynamicColorBlendState(
     return result;
 }
 
-VK_LAYER_EXPORT VkResult VKAPI vkCreateDynamicDepthStencilState(
+VK_LAYER_EXPORT VkResult VKAPI vkCreateDynamicDepthState(
     VkDevice                          device,
-    const VkDynamicDepthStencilStateCreateInfo *pCreateInfo,
-    VkDynamicDepthStencilState       *pState)
+    const VkDynamicDepthStateCreateInfo *pCreateInfo,
+    VkDynamicDepthState       *pState)
 {
-    VkResult result = get_dispatch_table(mem_tracker_device_table_map, device)->CreateDynamicDepthStencilState(device, pCreateInfo, pState);
+    VkResult result = get_dispatch_table(mem_tracker_device_table_map, device)->CreateDynamicDepthState(device, pCreateInfo, pState);
     if (result == VK_SUCCESS) {
         loader_platform_thread_lock_mutex(&globalLock);
-        add_object_create_info(pState->handle, VK_OBJECT_TYPE_DYNAMIC_DEPTH_STENCIL_STATE, pCreateInfo);
+        add_object_create_info(pState->handle, VK_OBJECT_TYPE_DYNAMIC_DEPTH_STATE, pCreateInfo);
+        loader_platform_thread_unlock_mutex(&globalLock);
+    }
+    return result;
+}
+
+VK_LAYER_EXPORT VkResult VKAPI vkCreateDynamicStencilState(
+    VkDevice                          device,
+    const VkDynamicStencilStateCreateInfo *pCreateInfoFront,
+    const VkDynamicStencilStateCreateInfo *pCreateInfoBack,
+    VkDynamicStencilState       *pState)
+{
+    VkResult result = get_dispatch_table(mem_tracker_device_table_map, device)->CreateDynamicStencilState(device, pCreateInfoFront, pCreateInfoBack, pState);
+    if (result == VK_SUCCESS && pCreateInfoFront != nullptr) {
+        loader_platform_thread_lock_mutex(&globalLock);
+        add_object_create_info(pState->handle, VK_OBJECT_TYPE_DYNAMIC_STENCIL_STATE, pCreateInfoFront);
+        loader_platform_thread_unlock_mutex(&globalLock);
+    }
+    if (result == VK_SUCCESS && pCreateInfoBack != nullptr && pCreateInfoBack != pCreateInfoFront) {
+        loader_platform_thread_lock_mutex(&globalLock);
+        add_object_create_info(pState->handle, VK_OBJECT_TYPE_DYNAMIC_STENCIL_STATE, pCreateInfoBack);
         loader_platform_thread_unlock_mutex(&globalLock);
     }
     return result;
@@ -2542,11 +2589,33 @@ void VKAPI vkCmdBindDynamicColorBlendState(
     get_dispatch_table(mem_tracker_device_table_map, cmdBuffer)->CmdBindDynamicColorBlendState(cmdBuffer, dynamicColorBlendState);
 }
 
-void VKAPI vkCmdBindDynamicDepthStencilState(
+void VKAPI vkCmdBindDynamicDepthState(
+     VkCmdBuffer                                 cmdBuffer,
+     VkDynamicDepthState                  dynamicDepthState)
+{
+    VkDynamicDepthStateCreateInfo* pCI;
+    loader_platform_thread_lock_mutex(&globalLock);
+    MT_CB_INFO *pCmdBuf = get_cmd_buf_info(cmdBuffer);
+    if (!pCmdBuf) {
+        // TODO : Want cmdBuffer to be srcObj here
+        log_msg(mdd(cmdBuffer), VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, 0, 0, MEMTRACK_INVALID_CB, "MEM",
+                "Unable to find command buffer object %p, was it ever created?", (void*)cmdBuffer);
+    }
+    pCI = (VkDynamicDepthStateCreateInfo*)get_object_create_info(dynamicDepthState.handle, VK_OBJECT_TYPE_DYNAMIC_DEPTH_STATE);
+    if (!pCI) {
+         log_msg(mdd(cmdBuffer), VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DYNAMIC_DEPTH_STATE, dynamicDepthState.handle, 0, MEMTRACK_INVALID_OBJECT, "MEM",
+                "Unable to find dynamic raster state object %#" PRIxLEAST64 ", was it ever created?", dynamicDepthState.handle);
+    }
+    pCmdBuf->pLastBoundDynamicState[VK_STATE_BIND_POINT_DEPTH] = dynamicDepthState.handle;
+    loader_platform_thread_unlock_mutex(&globalLock);
+    get_dispatch_table(mem_tracker_device_table_map, cmdBuffer)->CmdBindDynamicDepthState(cmdBuffer, dynamicDepthState);
+}
+
+void VKAPI vkCmdBindDynamicStencilState(
      VkCmdBuffer                                 cmdBuffer,
-     VkDynamicDepthStencilState                  dynamicDepthStencilState)
+     VkDynamicStencilState                       dynamicStencilState)
 {
-    VkDynamicDepthStencilStateCreateInfo* pCI;
+    VkDynamicStencilStateCreateInfo* pCI;
     loader_platform_thread_lock_mutex(&globalLock);
     MT_CB_INFO *pCmdBuf = get_cmd_buf_info(cmdBuffer);
     if (!pCmdBuf) {
@@ -2554,14 +2623,14 @@ void VKAPI vkCmdBindDynamicDepthStencilState(
         log_msg(mdd(cmdBuffer), VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, 0, 0, MEMTRACK_INVALID_CB, "MEM",
                 "Unable to find command buffer object %p, was it ever created?", (void*)cmdBuffer);
     }
-    pCI = (VkDynamicDepthStencilStateCreateInfo*)get_object_create_info(dynamicDepthStencilState.handle, VK_OBJECT_TYPE_DYNAMIC_DEPTH_STENCIL_STATE);
+    pCI = (VkDynamicStencilStateCreateInfo*)get_object_create_info(dynamicStencilState.handle, VK_OBJECT_TYPE_DYNAMIC_STENCIL_STATE);
     if (!pCI) {
-         log_msg(mdd(cmdBuffer), VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DYNAMIC_DEPTH_STENCIL_STATE, dynamicDepthStencilState.handle, 0, MEMTRACK_INVALID_OBJECT, "MEM",
-                "Unable to find dynamic raster state object %#" PRIxLEAST64 ", was it ever created?", dynamicDepthStencilState.handle);
+         log_msg(mdd(cmdBuffer), VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DYNAMIC_STENCIL_STATE, dynamicStencilState.handle, 0, MEMTRACK_INVALID_OBJECT, "MEM",
+                "Unable to find dynamic raster state object %#" PRIxLEAST64 ", was it ever created?", dynamicStencilState.handle);
     }
-    pCmdBuf->pLastBoundDynamicState[VK_STATE_BIND_POINT_DEPTH_STENCIL] = dynamicDepthStencilState.handle;
+    pCmdBuf->pLastBoundDynamicState[VK_STATE_BIND_POINT_STENCIL] = dynamicStencilState.handle;
     loader_platform_thread_unlock_mutex(&globalLock);
-    get_dispatch_table(mem_tracker_device_table_map, cmdBuffer)->CmdBindDynamicDepthStencilState(cmdBuffer, dynamicDepthStencilState);
+    get_dispatch_table(mem_tracker_device_table_map, cmdBuffer)->CmdBindDynamicStencilState(cmdBuffer, dynamicStencilState);
 }
 
 VK_LAYER_EXPORT void VKAPI vkCmdBindDescriptorSets(
@@ -3137,8 +3206,10 @@ VK_LAYER_EXPORT PFN_vkVoidFunction VKAPI vkGetDeviceProcAddr(
         return (PFN_vkVoidFunction) vkDestroyDynamicRasterDepthBiasState;
     if (!strcmp(funcName, "vkDestroyDynamicColorBlendState"))
         return (PFN_vkVoidFunction) vkDestroyDynamicColorBlendState;
-    if (!strcmp(funcName, "vkDestroyDynamicDepthStencilState"))
-        return (PFN_vkVoidFunction) vkDestroyDynamicDepthStencilState;
+    if (!strcmp(funcName, "vkDestroyDynamicDepthState"))
+        return (PFN_vkVoidFunction) vkDestroyDynamicDepthState;
+    if (!strcmp(funcName, "vkDestroyDynamicStencilState"))
+        return (PFN_vkVoidFunction) vkDestroyDynamicStencilState;
     if (!strcmp(funcName, "vkBindBufferMemory"))
         return (PFN_vkVoidFunction) vkBindBufferMemory;
     if (!strcmp(funcName, "vkBindImageMemory"))
@@ -3195,8 +3266,10 @@ VK_LAYER_EXPORT PFN_vkVoidFunction VKAPI vkGetDeviceProcAddr(
         return (PFN_vkVoidFunction) vkCreateDynamicRasterDepthBiasState;
     if (!strcmp(funcName, "vkCreateDynamicColorBlendState"))
         return (PFN_vkVoidFunction) vkCreateDynamicColorBlendState;
-    if (!strcmp(funcName, "vkCreateDynamicDepthStencilState"))
-        return (PFN_vkVoidFunction) vkCreateDynamicDepthStencilState;
+    if (!strcmp(funcName, "vkCreateDynamicDepthState"))
+        return (PFN_vkVoidFunction) vkCreateDynamicDepthState;
+    if (!strcmp(funcName, "vkCreateDynamicStencilState"))
+        return (PFN_vkVoidFunction) vkCreateDynamicStencilState;
     if (!strcmp(funcName, "vkCreateCommandBuffer"))
         return (PFN_vkVoidFunction) vkCreateCommandBuffer;
     if (!strcmp(funcName, "vkBeginCommandBuffer"))
@@ -3215,8 +3288,10 @@ VK_LAYER_EXPORT PFN_vkVoidFunction VKAPI vkGetDeviceProcAddr(
         return (PFN_vkVoidFunction) vkCmdBindDynamicRasterDepthBiasState;
     if (!strcmp(funcName, "vkCmdBindDynamicColorBlendState"))
         return (PFN_vkVoidFunction) vkCmdBindDynamicColorBlendState;
-    if (!strcmp(funcName, "vkCmdBindDynamicDepthStencilState"))
-        return (PFN_vkVoidFunction) vkCmdBindDynamicDepthStencilState;
+    if (!strcmp(funcName, "vkCmdBindDynamicDepthState"))
+        return (PFN_vkVoidFunction) vkCmdBindDynamicDepthState;
+    if (!strcmp(funcName, "vkCmdBindDynamicStencilState"))
+        return (PFN_vkVoidFunction) vkCmdBindDynamicStencilState;
     if (!strcmp(funcName, "vkCmdBindDescriptorSets"))
         return (PFN_vkVoidFunction) vkCmdBindDescriptorSets;
     if (!strcmp(funcName, "vkCmdBindVertexBuffers"))
diff --git a/layers/param_checker.cpp b/layers/param_checker.cpp
index 42e02357..fef0f84f 100644
--- a/layers/param_checker.cpp
+++ b/layers/param_checker.cpp
@@ -6090,16 +6090,16 @@ VK_LAYER_EXPORT VkResult VKAPI vkDestroyDynamicColorBlendState(
     return result;
 }
 
-bool PreCreateDynamicDepthStencilState(
+bool PreCreateDynamicDepthState(
     VkDevice device,
-    const VkDynamicDepthStencilStateCreateInfo* pCreateInfo)
+    const VkDynamicDepthStateCreateInfo* pCreateInfo)
 {
     if(pCreateInfo != nullptr)
     {
-    if(pCreateInfo->sType != VK_STRUCTURE_TYPE_DYNAMIC_DEPTH_STENCIL_STATE_CREATE_INFO)
+    if(pCreateInfo->sType != VK_STRUCTURE_TYPE_DYNAMIC_DEPTH_STATE_CREATE_INFO)
     {
         log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK",
-        "vkCreateDynamicDepthStencilState parameter, VkStructureType pCreateInfo->sType, is an invalid enumerator");
+        "vkCreateDynamicDepthState parameter, VkStructureType pCreateInfo->sType, is an invalid enumerator");
         return false;
     }
     }
@@ -6107,9 +6107,9 @@ bool PreCreateDynamicDepthStencilState(
     return true;
 }
 
-bool PostCreateDynamicDepthStencilState(
+bool PostCreateDynamicDepthState(
     VkDevice device,
-    VkDynamicDepthStencilState* pState,
+    VkDynamicDepthState* pState,
     VkResult result)
 {
 
@@ -6119,7 +6119,7 @@ bool PostCreateDynamicDepthStencilState(
 
     if(result < VK_SUCCESS)
     {
-        std::string reason = "vkCreateDynamicDepthStencilState parameter, VkResult result, is " + EnumeratorString(result);
+        std::string reason = "vkCreateDynamicDepthState parameter, VkResult result, is " + EnumeratorString(result);
         log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", reason.c_str());
         return false;
     }
@@ -6127,30 +6127,117 @@ bool PostCreateDynamicDepthStencilState(
     return true;
 }
 
-VK_LAYER_EXPORT VkResult VKAPI vkCreateDynamicDepthStencilState(
+VK_LAYER_EXPORT VkResult VKAPI vkCreateDynamicDepthState(
     VkDevice device,
-    const VkDynamicDepthStencilStateCreateInfo* pCreateInfo,
-    VkDynamicDepthStencilState* pState)
+    const VkDynamicDepthStateCreateInfo* pCreateInfo,
+    VkDynamicDepthState* pState)
 {
-    PreCreateDynamicDepthStencilState(device, pCreateInfo);
+    PreCreateDynamicDepthState(device, pCreateInfo);
 
-    VkResult result = get_dispatch_table(pc_device_table_map, device)->CreateDynamicDepthStencilState(device, pCreateInfo, pState);
+    VkResult result = get_dispatch_table(pc_device_table_map, device)->CreateDynamicDepthState(device, pCreateInfo, pState);
 
-    PostCreateDynamicDepthStencilState(device, pState, result);
+    PostCreateDynamicDepthState(device, pState, result);
 
     return result;
 }
 
-bool PostDestroyDynamicDepthStencilState(
+bool PostDestroyDynamicDepthState(
     VkDevice device,
-    VkDynamicDepthStencilState dynamicDepthStencilState,
+    VkDynamicDepthState dynamicDepthState,
     VkResult result)
 {
+    if(result < VK_SUCCESS)
+    {
+        std::string reason = "vkDestroyDynamicDepthState parameter, VkResult result, is " + EnumeratorString(result);
+        log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", reason.c_str());
+        return false;
+    }
+
+    return true;
+}
+
+VK_LAYER_EXPORT VkResult VKAPI vkDestroyDynamicDepthState(
+    VkDevice device,
+    VkDynamicDepthState dynamicDepthState)
+{
+    VkResult result = get_dispatch_table(pc_device_table_map, device)->DestroyDynamicDepthState(device, dynamicDepthState);
+
+    PostDestroyDynamicDepthState(device, dynamicDepthState, result);
 
+    return result;
+}
 
+bool PreCreateDynamicStencilState(
+    VkDevice device,
+    const VkDynamicStencilStateCreateInfo* pCreateInfoFront,
+    const VkDynamicStencilStateCreateInfo* pCreateInfoBack)
+{
+    if(pCreateInfoFront != nullptr)
+    {
+    if(pCreateInfoFront->sType != VK_STRUCTURE_TYPE_DYNAMIC_STENCIL_STATE_CREATE_INFO)
+    {
+        log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK",
+        "vkCreateDynamicStencilState parameter, VkStructureType pCreateInfoFront->sType, is an invalid enumerator");
+        return false;
+    }
+    }
+
+    if(pCreateInfoBack != nullptr)
+    {
+    if(pCreateInfoBack->sType != VK_STRUCTURE_TYPE_DYNAMIC_STENCIL_STATE_CREATE_INFO)
+    {
+        log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK",
+        "vkCreateDynamicStencilState parameter, VkStructureType pCreateInfoBack->sType, is an invalid enumerator");
+        return false;
+    }
+    }
+
+    return true;
+}
+
+bool PostCreateDynamicStencilState(
+    VkDevice device,
+    VkDynamicStencilState* pState,
+    VkResult result)
+{
+
+    if(pState != nullptr)
+    {
+    }
+
+    if(result < VK_SUCCESS)
+    {
+        std::string reason = "vkCreateDynamicStencilState parameter, VkResult result, is " + EnumeratorString(result);
+        log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", reason.c_str());
+        return false;
+    }
+
+    return true;
+}
+
+VK_LAYER_EXPORT VkResult VKAPI vkCreateDynamicStencilState(
+    VkDevice device,
+    const VkDynamicStencilStateCreateInfo* pCreateInfoFront,
+    const VkDynamicStencilStateCreateInfo* pCreateInfoBack,
+    VkDynamicStencilState* pState)
+{
+    PreCreateDynamicStencilState(device, pCreateInfoFront, pCreateInfoBack);
+
+    VkResult result = get_dispatch_table(pc_device_table_map, device)->CreateDynamicStencilState(device, pCreateInfoFront, pCreateInfoBack, pState);
+
+    PostCreateDynamicStencilState(device, pState, result);
+
+    return result;
+}
+
+bool PostDestroyDynamicStencilState(
+    VkDevice device,
+    VkDynamicStencilState dynamicStencilState,
+    VkResult result)
+{
     if(result < VK_SUCCESS)
     {
-        std::string reason = "vkDestroyDynamicDepthStencilState parameter, VkResult result, is " + EnumeratorString(result);
+        std::string reason = "vkDestroyDynamicStencilState parameter, VkResult result, is " + EnumeratorString(result);
         log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", reason.c_str());
         return false;
     }
@@ -6158,13 +6245,13 @@ bool PostDestroyDynamicDepthStencilState(
     return true;
 }
 
-VK_LAYER_EXPORT VkResult VKAPI vkDestroyDynamicDepthStencilState(
+VK_LAYER_EXPORT VkResult VKAPI vkDestroyDynamicStencilState(
     VkDevice device,
-    VkDynamicDepthStencilState dynamicDepthStencilState)
+    VkDynamicStencilState dynamicStencilState)
 {
-    VkResult result = get_dispatch_table(pc_device_table_map, device)->DestroyDynamicDepthStencilState(device, dynamicDepthStencilState);
+    VkResult result = get_dispatch_table(pc_device_table_map, device)->DestroyDynamicStencilState(device, dynamicStencilState);
 
-    PostDestroyDynamicDepthStencilState(device, dynamicDepthStencilState, result);
+    PostDestroyDynamicStencilState(device, dynamicStencilState, result);
 
     return result;
 }
@@ -6888,22 +6975,36 @@ VK_LAYER_EXPORT void VKAPI vkCmdBindDynamicColorBlendState(
     PostCmdBindDynamicColorBlendState(cmdBuffer, dynamicColorBlendState);
 }
 
-bool PostCmdBindDynamicDepthStencilState(
+bool PostCmdBindDynamicDepthState(
     VkCmdBuffer cmdBuffer,
-    VkDynamicDepthStencilState dynamicDepthStencilState)
+    VkDynamicDepthState dynamicDepthState)
 {
+    return true;
+}
+
+VK_LAYER_EXPORT void VKAPI vkCmdBindDynamicDepthState(
+    VkCmdBuffer cmdBuffer,
+    VkDynamicDepthState dynamicDepthState)
+{
+    get_dispatch_table(pc_device_table_map, cmdBuffer)->CmdBindDynamicDepthState(cmdBuffer, dynamicDepthState);
 
+    PostCmdBindDynamicDepthState(cmdBuffer, dynamicDepthState);
+}
 
+bool PostCmdBindDynamicStencilState(
+    VkCmdBuffer cmdBuffer,
+    VkDynamicStencilState dynamicStencilState)
+{
     return true;
 }
 
-VK_LAYER_EXPORT void VKAPI vkCmdBindDynamicDepthStencilState(
+VK_LAYER_EXPORT void VKAPI vkCmdBindDynamicStencilState(
     VkCmdBuffer cmdBuffer,
-    VkDynamicDepthStencilState dynamicDepthStencilState)
+    VkDynamicStencilState dynamicStencilState)
 {
-    get_dispatch_table(pc_device_table_map, cmdBuffer)->CmdBindDynamicDepthStencilState(cmdBuffer, dynamicDepthStencilState);
+    get_dispatch_table(pc_device_table_map, cmdBuffer)->CmdBindDynamicStencilState(cmdBuffer, dynamicStencilState);
 
-    PostCmdBindDynamicDepthStencilState(cmdBuffer, dynamicDepthStencilState);
+    PostCmdBindDynamicStencilState(cmdBuffer, dynamicStencilState);
 }
 
 bool PreCmdBindDescriptorSets(
@@ -8375,8 +8476,10 @@ VK_LAYER_EXPORT PFN_vkVoidFunction VKAPI vkGetDeviceProcAddr(VkDevice device, co
         return (PFN_vkVoidFunction) vkCreateDynamicRasterDepthBiasState;
     if (!strcmp(funcName, "vkCreateDynamicColorBlendState"))
         return (PFN_vkVoidFunction) vkCreateDynamicColorBlendState;
-    if (!strcmp(funcName, "vkCreateDynamicDepthStencilState"))
-        return (PFN_vkVoidFunction) vkCreateDynamicDepthStencilState;
+    if (!strcmp(funcName, "vkCreateDynamicDepthState"))
+        return (PFN_vkVoidFunction) vkCreateDynamicDepthState;
+    if (!strcmp(funcName, "vkCreateDynamicStencilState"))
+        return (PFN_vkVoidFunction) vkCreateDynamicStencilState;
     if (!strcmp(funcName, "vkCreateCommandBuffer"))
         return (PFN_vkVoidFunction) vkCreateCommandBuffer;
     if (!strcmp(funcName, "vkBeginCommandBuffer"))