diff --git a/include/vk_debug_report_lunarg.h b/include/vk_debug_report_lunarg.h
index 4e1569c..bafdc87 100644
--- a/include/vk_debug_report_lunarg.h
+++ b/include/vk_debug_report_lunarg.h
@@ -67,18 +67,19 @@
     VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT = 18,
     VK_OBJECT_TYPE_DESCRIPTOR_POOL = 19,
     VK_OBJECT_TYPE_DYNAMIC_VIEWPORT_STATE = 20,
-    VK_OBJECT_TYPE_DYNAMIC_RASTER_STATE = 21,
-    VK_OBJECT_TYPE_DYNAMIC_COLOR_BLEND_STATE = 22,
-    VK_OBJECT_TYPE_DYNAMIC_DEPTH_STENCIL_STATE = 23,
-    VK_OBJECT_TYPE_FENCE = 24,
-    VK_OBJECT_TYPE_SEMAPHORE = 25,
-    VK_OBJECT_TYPE_EVENT = 26,
-    VK_OBJECT_TYPE_QUERY_POOL = 27,
-    VK_OBJECT_TYPE_FRAMEBUFFER = 28,
-    VK_OBJECT_TYPE_RENDER_PASS = 29,
-    VK_OBJECT_TYPE_PIPELINE_CACHE = 30,
-    VK_OBJECT_TYPE_SWAP_CHAIN_WSI = 31,
-    VK_OBJECT_TYPE_CMD_POOL = 32,
+    VK_OBJECT_TYPE_DYNAMIC_RASTER_LINE_STATE = 21,
+    VK_OBJECT_TYPE_DYNAMIC_RASTER_DEPTH_BIAS_STATE = 22,
+    VK_OBJECT_TYPE_DYNAMIC_COLOR_BLEND_STATE = 23,
+    VK_OBJECT_TYPE_DYNAMIC_DEPTH_STENCIL_STATE = 24,
+    VK_OBJECT_TYPE_FENCE = 25,
+    VK_OBJECT_TYPE_SEMAPHORE = 26,
+    VK_OBJECT_TYPE_EVENT = 27,
+    VK_OBJECT_TYPE_QUERY_POOL = 28,
+    VK_OBJECT_TYPE_FRAMEBUFFER = 29,
+    VK_OBJECT_TYPE_RENDER_PASS = 30,
+    VK_OBJECT_TYPE_PIPELINE_CACHE = 31,
+    VK_OBJECT_TYPE_SWAP_CHAIN_WSI = 32,
+    VK_OBJECT_TYPE_CMD_POOL = 33,
     VK_OBJECT_TYPE_BEGIN_RANGE = VK_OBJECT_TYPE_INSTANCE,
     VK_OBJECT_TYPE_END_RANGE = VK_OBJECT_TYPE_CMD_POOL,
     VK_OBJECT_TYPE_NUM = (VK_OBJECT_TYPE_CMD_POOL - VK_OBJECT_TYPE_INSTANCE + 1),
@@ -113,8 +114,10 @@
             return "VK_OBJECT_TYPE_DYNAMIC_COLOR_BLEND_STATE";
         case VK_OBJECT_TYPE_DYNAMIC_DEPTH_STENCIL_STATE:
             return "VK_OBJECT_TYPE_DYNAMIC_DEPTH_STENCIL_STATE";
-        case VK_OBJECT_TYPE_DYNAMIC_RASTER_STATE:
-            return "VK_OBJECT_TYPE_DYNAMIC_RASTER_STATE";
+        case VK_OBJECT_TYPE_DYNAMIC_RASTER_LINE_STATE:
+            return "VK_OBJECT_TYPE_DYNAMIC_RASTER_LINE_STATE";
+        case VK_OBJECT_TYPE_DYNAMIC_RASTER_DEPTH_BIAS_STATE:
+            return "VK_OBJECT_TYPE_DYNAMIC_RASTER_DEPTH_BIAS_STATE";
         case VK_OBJECT_TYPE_DYNAMIC_VIEWPORT_STATE:
             return "VK_OBJECT_TYPE_DYNAMIC_VIEPORT_STATE";
         case VK_OBJECT_TYPE_EVENT:
diff --git a/include/vk_layer.h b/include/vk_layer.h
index afc103e..3c3cbad 100644
--- a/include/vk_layer.h
+++ b/include/vk_layer.h
@@ -104,8 +104,10 @@
     PFN_vkUpdateDescriptorSets UpdateDescriptorSets;
     PFN_vkCreateDynamicViewportState CreateDynamicViewportState;
     PFN_vkDestroyDynamicViewportState DestroyDynamicViewportState;
-    PFN_vkCreateDynamicRasterState CreateDynamicRasterState;
-    PFN_vkDestroyDynamicRasterState DestroyDynamicRasterState;
+    PFN_vkCreateDynamicRasterLineState CreateDynamicRasterLineState;
+    PFN_vkDestroyDynamicRasterLineState DestroyDynamicRasterLineState;
+    PFN_vkCreateDynamicRasterDepthBiasState CreateDynamicRasterDepthBiasState;
+    PFN_vkDestroyDynamicRasterDepthBiasState DestroyDynamicRasterDepthBiasState;
     PFN_vkCreateDynamicColorBlendState CreateDynamicColorBlendState;
     PFN_vkDestroyDynamicColorBlendState DestroyDynamicColorBlendState;
     PFN_vkCreateDynamicDepthStencilState CreateDynamicDepthStencilState;
@@ -125,7 +127,8 @@
     PFN_vkResetCommandBuffer ResetCommandBuffer;
     PFN_vkCmdBindPipeline CmdBindPipeline;
     PFN_vkCmdBindDynamicViewportState CmdBindDynamicViewportState;
-    PFN_vkCmdBindDynamicRasterState CmdBindDynamicRasterState;
+    PFN_vkCmdBindDynamicRasterLineState CmdBindDynamicRasterLineState;
+    PFN_vkCmdBindDynamicRasterDepthBiasState CmdBindDynamicRasterDepthBiasState;
     PFN_vkCmdBindDynamicColorBlendState CmdBindDynamicColorBlendState;
     PFN_vkCmdBindDynamicDepthStencilState CmdBindDynamicDepthStencilState;
     PFN_vkCmdBindDescriptorSets CmdBindDescriptorSets;
diff --git a/include/vulkan.h b/include/vulkan.h
index 067546b..0a802b0 100644
--- a/include/vulkan.h
+++ b/include/vulkan.h
@@ -119,7 +119,8 @@
 VK_DEFINE_NONDISP_HANDLE(VkDescriptorPool)
 VK_DEFINE_NONDISP_HANDLE(VkDescriptorSet)
 VK_DEFINE_NONDISP_HANDLE(VkDynamicViewportState)
-VK_DEFINE_NONDISP_HANDLE(VkDynamicRasterState)
+VK_DEFINE_NONDISP_HANDLE(VkDynamicRasterLineState)
+VK_DEFINE_NONDISP_HANDLE(VkDynamicRasterDepthBiasState)
 VK_DEFINE_NONDISP_HANDLE(VkDynamicColorBlendState)
 VK_DEFINE_NONDISP_HANDLE(VkDynamicDepthStencilState)
 VK_DEFINE_NONDISP_HANDLE(VkFramebuffer)
@@ -199,45 +200,46 @@
     VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO = 8,
     VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO = 9,
     VK_STRUCTURE_TYPE_DYNAMIC_VIEWPORT_STATE_CREATE_INFO = 10,
-    VK_STRUCTURE_TYPE_DYNAMIC_RASTER_STATE_CREATE_INFO = 11,
-    VK_STRUCTURE_TYPE_DYNAMIC_COLOR_BLEND_STATE_CREATE_INFO = 12,
-    VK_STRUCTURE_TYPE_DYNAMIC_DEPTH_STENCIL_STATE_CREATE_INFO = 13,
-    VK_STRUCTURE_TYPE_CMD_BUFFER_CREATE_INFO = 14,
-    VK_STRUCTURE_TYPE_EVENT_CREATE_INFO = 15,
-    VK_STRUCTURE_TYPE_FENCE_CREATE_INFO = 16,
-    VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO = 17,
-    VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO = 18,
-    VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO = 19,
-    VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO = 20,
-    VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO = 21,
-    VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO = 22,
-    VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO = 23,
-    VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO = 24,
-    VK_STRUCTURE_TYPE_PIPELINE_RASTER_STATE_CREATE_INFO = 25,
-    VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO = 26,
-    VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO = 27,
-    VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO = 28,
-    VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO = 29,
-    VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO = 30,
-    VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO = 31,
-    VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO = 32,
-    VK_STRUCTURE_TYPE_CMD_BUFFER_BEGIN_INFO = 33,
-    VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO = 34,
-    VK_STRUCTURE_TYPE_MEMORY_BARRIER = 35,
-    VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER = 36,
-    VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER = 37,
-    VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO = 38,
-    VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET = 39,
-    VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET = 40,
-    VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO = 41,
-    VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO = 42,
-    VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE = 43,
-    VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO = 44,
-    VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION = 45,
-    VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION = 46,
-    VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY = 47,
-    VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO = 48,
-    VK_STRUCTURE_TYPE_CMD_POOL_CREATE_INFO = 49,
+    VK_STRUCTURE_TYPE_DYNAMIC_RASTER_LINE_STATE_CREATE_INFO = 11,
+    VK_STRUCTURE_TYPE_DYNAMIC_RASTER_DEPTH_BIAS_STATE_CREATE_INFO = 12,
+    VK_STRUCTURE_TYPE_DYNAMIC_COLOR_BLEND_STATE_CREATE_INFO = 13,
+    VK_STRUCTURE_TYPE_DYNAMIC_DEPTH_STENCIL_STATE_CREATE_INFO = 14,
+    VK_STRUCTURE_TYPE_CMD_BUFFER_CREATE_INFO = 15,
+    VK_STRUCTURE_TYPE_EVENT_CREATE_INFO = 16,
+    VK_STRUCTURE_TYPE_FENCE_CREATE_INFO = 17,
+    VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO = 18,
+    VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO = 19,
+    VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO = 20,
+    VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO = 21,
+    VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO = 22,
+    VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO = 23,
+    VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO = 24,
+    VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO = 25,
+    VK_STRUCTURE_TYPE_PIPELINE_RASTER_STATE_CREATE_INFO = 26,
+    VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO = 27,
+    VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO = 28,
+    VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO = 29,
+    VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO = 30,
+    VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO = 31,
+    VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO = 32,
+    VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO = 33,
+    VK_STRUCTURE_TYPE_CMD_BUFFER_BEGIN_INFO = 34,
+    VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO = 35,
+    VK_STRUCTURE_TYPE_MEMORY_BARRIER = 36,
+    VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER = 37,
+    VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER = 38,
+    VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO = 39,
+    VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET = 40,
+    VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET = 41,
+    VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO = 42,
+    VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO = 43,
+    VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE = 44,
+    VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO = 45,
+    VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION = 46,
+    VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION = 47,
+    VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY = 48,
+    VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO = 49,
+    VK_STRUCTURE_TYPE_CMD_POOL_CREATE_INFO = 50,
     VK_STRUCTURE_TYPE_BEGIN_RANGE = VK_STRUCTURE_TYPE_APPLICATION_INFO,
     VK_STRUCTURE_TYPE_END_RANGE = VK_STRUCTURE_TYPE_CMD_POOL_CREATE_INFO,
     VK_STRUCTURE_TYPE_NUM = (VK_STRUCTURE_TYPE_CMD_POOL_CREATE_INFO - VK_STRUCTURE_TYPE_APPLICATION_INFO + 1),
@@ -1640,6 +1642,7 @@
     VkFillMode                                  fillMode;
     VkCullMode                                  cullMode;
     VkFrontFace                                 frontFace;
+    VkBool32                                    depthBiasEnable;
 } VkPipelineRasterStateCreateInfo;
 
 typedef struct {
@@ -1848,11 +1851,16 @@
 typedef struct {
     VkStructureType                             sType;
     const void*                                 pNext;
+    float                                       lineWidth;
+} VkDynamicRasterLineStateCreateInfo;
+
+typedef struct {
+    VkStructureType                             sType;
+    const void*                                 pNext;
     float                                       depthBias;
     float                                       depthBiasClamp;
     float                                       slopeScaledDepthBias;
-    float                                       lineWidth;
-} VkDynamicRasterStateCreateInfo;
+} VkDynamicRasterDepthBiasStateCreateInfo;
 
 typedef struct {
     VkStructureType                             sType;
@@ -2179,8 +2187,10 @@
 typedef VkResult (VKAPI *PFN_vkUpdateDescriptorSets)(VkDevice device, uint32_t writeCount, const VkWriteDescriptorSet* pDescriptorWrites, uint32_t copyCount, const VkCopyDescriptorSet* pDescriptorCopies);
 typedef VkResult (VKAPI *PFN_vkCreateDynamicViewportState)(VkDevice device, const VkDynamicViewportStateCreateInfo* pCreateInfo, VkDynamicViewportState* pState);
 typedef VkResult (VKAPI *PFN_vkDestroyDynamicViewportState)(VkDevice device, VkDynamicViewportState dynamicViewportState);
-typedef VkResult (VKAPI *PFN_vkCreateDynamicRasterState)(VkDevice device, const VkDynamicRasterStateCreateInfo* pCreateInfo, VkDynamicRasterState* pState);
-typedef VkResult (VKAPI *PFN_vkDestroyDynamicRasterState)(VkDevice device, VkDynamicRasterState dynamicRasterState);
+typedef VkResult (VKAPI *PFN_vkCreateDynamicRasterLineState)(VkDevice device, const VkDynamicRasterLineStateCreateInfo* pCreateInfo, VkDynamicRasterLineState* pState);
+typedef VkResult (VKAPI *PFN_vkDestroyDynamicRasterLineState)(VkDevice device, VkDynamicRasterLineState dynamicRasterLineState);
+typedef VkResult (VKAPI *PFN_vkCreateDynamicRasterDepthBiasState)(VkDevice device, const VkDynamicRasterDepthBiasStateCreateInfo* pCreateInfo, VkDynamicRasterDepthBiasState* pState);
+typedef VkResult (VKAPI *PFN_vkDestroyDynamicRasterDepthBiasState)(VkDevice device, VkDynamicRasterDepthBiasState dynamicRasterDepthBiasState);
 typedef VkResult (VKAPI *PFN_vkCreateDynamicColorBlendState)(VkDevice device, const VkDynamicColorBlendStateCreateInfo* pCreateInfo, VkDynamicColorBlendState* pState);
 typedef VkResult (VKAPI *PFN_vkDestroyDynamicColorBlendState)(VkDevice device, VkDynamicColorBlendState dynamicColorBlendState);
 typedef VkResult (VKAPI *PFN_vkCreateDynamicDepthStencilState)(VkDevice device, const VkDynamicDepthStencilStateCreateInfo* pCreateInfo, VkDynamicDepthStencilState* pState);
@@ -2200,7 +2210,8 @@
 typedef VkResult (VKAPI *PFN_vkResetCommandBuffer)(VkCmdBuffer cmdBuffer, VkCmdBufferResetFlags flags);
 typedef void (VKAPI *PFN_vkCmdBindPipeline)(VkCmdBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline);
 typedef void (VKAPI *PFN_vkCmdBindDynamicViewportState)(VkCmdBuffer cmdBuffer, VkDynamicViewportState dynamicViewportState);
-typedef void (VKAPI *PFN_vkCmdBindDynamicRasterState)(VkCmdBuffer cmdBuffer, VkDynamicRasterState dynamicRasterState);
+typedef void (VKAPI *PFN_vkCmdBindDynamicRasterLineState)(VkCmdBuffer cmdBuffer, VkDynamicRasterLineState dynamicRasterLineState);
+typedef void (VKAPI *PFN_vkCmdBindDynamicRasterDepthBiasState)(VkCmdBuffer cmdBuffer, VkDynamicRasterDepthBiasState dynamicRasterDepthBiasState);
 typedef void (VKAPI *PFN_vkCmdBindDynamicColorBlendState)(VkCmdBuffer cmdBuffer, VkDynamicColorBlendState dynamicColorBlendState);
 typedef void (VKAPI *PFN_vkCmdBindDynamicDepthStencilState)(VkCmdBuffer cmdBuffer, VkDynamicDepthStencilState dynamicDepthStencilState);
 typedef void (VKAPI *PFN_vkCmdBindDescriptorSets)(VkCmdBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t setCount, const VkDescriptorSet* pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets);
@@ -2696,14 +2707,23 @@
     VkDevice                                    device,
     VkDynamicViewportState                      dynamicViewportState);
 
-VkResult VKAPI vkCreateDynamicRasterState(
-    VkDevice                                    device,
-    const VkDynamicRasterStateCreateInfo*       pCreateInfo,
-    VkDynamicRasterState*                       pState);
+VkResult VKAPI vkCreateDynamicRasterLineState(
+     VkDevice                                    device,
+    const VkDynamicRasterLineStateCreateInfo*   pCreateInfo,
+    VkDynamicRasterLineState*                   pState);
 
-VkResult VKAPI vkDestroyDynamicRasterState(
+VkResult VKAPI vkDestroyDynamicRasterLineState(
+     VkDevice                                    device,
+    VkDynamicRasterLineState                    dynamicRasterLineState);
+
+VkResult VKAPI vkCreateDynamicRasterDepthBiasState(
     VkDevice                                    device,
-    VkDynamicRasterState                        dynamicRasterState);
+    const VkDynamicRasterDepthBiasStateCreateInfo* pCreateInfo,
+    VkDynamicRasterDepthBiasState*              pState);
+
+VkResult VKAPI vkDestroyDynamicRasterDepthBiasState(
+    VkDevice                                    device,
+    VkDynamicRasterDepthBiasState               dynamicRasterDepthBiasState);
 
 VkResult VKAPI vkCreateDynamicColorBlendState(
     VkDevice                                    device,
@@ -2789,9 +2809,13 @@
     VkCmdBuffer                                 cmdBuffer,
     VkDynamicViewportState                      dynamicViewportState);
 
-void VKAPI vkCmdBindDynamicRasterState(
+void VKAPI vkCmdBindDynamicRasterLineState(
     VkCmdBuffer                                 cmdBuffer,
-    VkDynamicRasterState                        dynamicRasterState);
+    VkDynamicRasterLineState                    dynamicRasterLineState);
+
+void VKAPI vkCmdBindDynamicRasterDepthBiasState(
+    VkCmdBuffer                                 cmdBuffer,
+    VkDynamicRasterDepthBiasState               dynamicRasterDepthBiasState);
 
 void VKAPI vkCmdBindDynamicColorBlendState(
     VkCmdBuffer                                 cmdBuffer,
diff --git a/layers/draw_state.cpp b/layers/draw_state.cpp
index a0b867a..c465768 100644
--- a/layers/draw_state.cpp
+++ b/layers/draw_state.cpp
@@ -65,7 +65,8 @@
 unordered_map<uint64_t, VkAttachmentViewCreateInfo> viewMap;
 unordered_map<uint64_t, BUFFER_NODE*> bufferMap;
 unordered_map<uint64_t, VkDynamicViewportStateCreateInfo> dynamicVpStateMap;
-unordered_map<uint64_t, VkDynamicRasterStateCreateInfo> dynamicRsStateMap;
+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, PIPELINE_NODE*> pipelineMap;
@@ -140,8 +141,10 @@
             return "CMD_BINDPIPELINEDELTA";
         case CMD_BINDDYNAMICVIEWPORTSTATE:
             return "CMD_BINDDYNAMICVIEWPORTSTATE";
-        case CMD_BINDDYNAMICRASTERSTATE:
-            return "CMD_BINDDYNAMICRASTERSTATE";
+        case CMD_BINDDYNAMICRASTERLINESTATE:
+            return "CMD_BINDDYNAMICRASTERLINESTATE";
+        case CMD_BINDDYNAMICRASTERDEPTHBIASSTATE:
+            return "CMD_BINDDYNAMICRASTERDEPTHBIASSTATE";
         case CMD_BINDDYNAMICCOLORBLENDSTATE:
             return "CMD_BINDDYNAMICCOLORBLENDSTATE";
         case CMD_BINDDYNAMICDEPTHSTENCILSTATE:
@@ -257,7 +260,8 @@
         delete[] (*ii).second.pViewports;
     }
     dynamicVpStateMap.clear();
-    dynamicRsStateMap.clear();
+    dynamicRasterLineStateMap.clear();
+    dynamicRasterDepthBiasStateMap.clear();
     dynamicCbStateMap.clear();
     dynamicDsStateMap.clear();
 }
@@ -358,8 +362,10 @@
     switch (type) {
         case VK_STATE_BIND_POINT_VIEWPORT:
             return (void*)&dynamicVpStateMap[handle];
-        case VK_STATE_BIND_POINT_RASTER:
-            return (void*)&dynamicRsStateMap[handle];
+        case VK_STATE_BIND_POINT_RASTER_LINE:
+            return (void*)&dynamicRasterLineStateMap[handle];
+        case VK_STATE_BIND_POINT_RASTER_DEPTH_BIAS:
+            return (void*)&dynamicRasterDepthBiasStateMap[handle];
         case VK_STATE_BIND_POINT_COLOR_BLEND:
             return (void*)&dynamicCbStateMap[handle];
         case VK_STATE_BIND_POINT_DEPTH_STENCIL:
@@ -409,7 +415,8 @@
 static VkBool32 validate_draw_state_flags(GLOBAL_CB_NODE* pCB, VkBool32 indexedDraw) {
     VkBool32 result;
     result = validate_status(pCB, CBSTATUS_NONE, CBSTATUS_VIEWPORT_BOUND, CBSTATUS_VIEWPORT_BOUND, VK_DBG_REPORT_ERROR_BIT, DRAWSTATE_VIEWPORT_NOT_BOUND, "Viewport object not bound to this command buffer");
-    result &= validate_status(pCB, CBSTATUS_NONE, CBSTATUS_RASTER_BOUND,   CBSTATUS_RASTER_BOUND,   VK_DBG_REPORT_ERROR_BIT, DRAWSTATE_RASTER_NOT_BOUND,   "Raster object not bound to this command buffer");
+    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");
     if (indexedDraw)
@@ -1135,8 +1142,10 @@
 static void set_cb_dyn_status(GLOBAL_CB_NODE* pNode, DYNAMIC_STATE_BIND_POINT stateBindPoint) {
     if (stateBindPoint == VK_STATE_BIND_POINT_VIEWPORT) {
         pNode->status |= CBSTATUS_VIEWPORT_BOUND;
-    } else if (stateBindPoint == VK_STATE_BIND_POINT_RASTER) {
-        pNode->status |= CBSTATUS_RASTER_BOUND;
+    } else if (stateBindPoint == VK_STATE_BIND_POINT_RASTER_LINE) {
+        pNode->status |= CBSTATUS_RASTER_LINE_BOUND;
+    } else if (stateBindPoint == VK_STATE_BIND_POINT_RASTER_DEPTH_BIAS) {
+        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) {
@@ -1605,9 +1614,16 @@
     return result;
 }
 
-VK_LAYER_EXPORT VkResult VKAPI vkDestroyDynamicRasterState(VkDevice device, VkDynamicRasterState dynamicRasterState)
+VK_LAYER_EXPORT VkResult VKAPI vkDestroyDynamicRasterLineState(VkDevice device, VkDynamicRasterLineState dynamicRasterLineState)
 {
-    VkResult result = get_dispatch_table(draw_state_device_table_map, device)->DestroyDynamicRasterState(device, dynamicRasterState);
+    VkResult result = get_dispatch_table(draw_state_device_table_map, device)->DestroyDynamicRasterLineState(device, dynamicRasterLineState);
+    // TODO : Clean up any internal data structures using this obj.
+    return result;
+}
+
+VK_LAYER_EXPORT VkResult VKAPI vkDestroyDynamicRasterDepthBiasState(VkDevice device, VkDynamicRasterDepthBiasState dynamicRasterDepthBiasState)
+{
+    VkResult result = get_dispatch_table(draw_state_device_table_map, device)->DestroyDynamicRasterDepthBiasState(device, dynamicRasterDepthBiasState);
     // TODO : Clean up any internal data structures using this obj.
     return result;
 }
@@ -1951,12 +1967,22 @@
     return result;
 }
 
-VK_LAYER_EXPORT VkResult VKAPI vkCreateDynamicRasterState(VkDevice device, const VkDynamicRasterStateCreateInfo* pCreateInfo, VkDynamicRasterState* pState)
+VK_LAYER_EXPORT VkResult VKAPI vkCreateDynamicRasterLineState(VkDevice device, const VkDynamicRasterLineStateCreateInfo* pCreateInfo, VkDynamicRasterLineState* pState)
 {
-    VkResult result = get_dispatch_table(draw_state_device_table_map, device)->CreateDynamicRasterState(device, pCreateInfo, pState);
-    //insertDynamicState(*pState, (GENERIC_HEADER*)pCreateInfo, VK_STATE_BIND_POINT_RASTER);
+    VkResult result = get_dispatch_table(draw_state_device_table_map, device)->CreateDynamicRasterLineState(device, pCreateInfo, pState);
+    //insertDynamicState(*pState, (GENERIC_HEADER*)pCreateInfo, VK_STATE_BIND_POINT_RASTER_LINE);
     loader_platform_thread_lock_mutex(&globalLock);
-    dynamicRsStateMap[pState->handle] = *pCreateInfo;
+    dynamicRasterLineStateMap[pState->handle] = *pCreateInfo;
+    loader_platform_thread_unlock_mutex(&globalLock);
+    return result;
+}
+
+VK_LAYER_EXPORT VkResult VKAPI vkCreateDynamicRasterDepthBiasState(VkDevice device, const VkDynamicRasterDepthBiasStateCreateInfo* pCreateInfo, VkDynamicRasterDepthBiasState* pState)
+{
+    VkResult result = get_dispatch_table(draw_state_device_table_map, device)->CreateDynamicRasterDepthBiasState(device, pCreateInfo, pState);
+    //insertDynamicState(*pState, (GENERIC_HEADER*)pCreateInfo, VK_STATE_BIND_POINT_RASTER_DEPTH_BIAS);
+    loader_platform_thread_lock_mutex(&globalLock);
+    dynamicRasterDepthBiasStateMap[pState->handle] = *pCreateInfo;
     loader_platform_thread_unlock_mutex(&globalLock);
     return result;
 }
@@ -2125,30 +2151,57 @@
         }
     }
 }
-VK_LAYER_EXPORT void VKAPI vkCmdBindDynamicRasterState(VkCmdBuffer cmdBuffer, VkDynamicRasterState dynamicRasterState)
+VK_LAYER_EXPORT void VKAPI vkCmdBindDynamicRasterLineState(VkCmdBuffer cmdBuffer, VkDynamicRasterLineState dynamicRasterLineState)
 {
     GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
     if (pCB) {
         if (pCB->state == CB_UPDATE_ACTIVE) {
             updateCBTracking(cmdBuffer);
-            addCmd(pCB, CMD_BINDDYNAMICRASTERSTATE);
+            addCmd(pCB, CMD_BINDDYNAMICRASTERLINESTATE);
             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 vkCmdBindDynamicRasterState() without an active RenderPass.");
+                        "Incorrect call to vkCmdBindDynamicRasterLineState() without an active RenderPass.");
             }
             loader_platform_thread_lock_mutex(&globalLock);
-            pCB->status |= CBSTATUS_RASTER_BOUND;
-            if (dynamicRsStateMap.find(dynamicRasterState.handle) == dynamicRsStateMap.end()) {
-                log_msg(mdd(cmdBuffer), VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DYNAMIC_RASTER_STATE, dynamicRasterState.handle, 0, DRAWSTATE_INVALID_DYNAMIC_STATE_OBJECT, "DS",
-                        "Unable to find VkDynamicRasterState object %#" PRIxLEAST64 ", was it ever created?", dynamicRasterState.handle);
+            pCB->status |= CBSTATUS_RASTER_LINE_BOUND;
+            if (dynamicRasterLineStateMap.find(dynamicRasterLineState.handle) == dynamicRasterLineStateMap.end()) {
+                log_msg(mdd(cmdBuffer), VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DYNAMIC_RASTER_LINE_STATE, dynamicRasterLineState.handle, 0, DRAWSTATE_INVALID_DYNAMIC_STATE_OBJECT, "DS",
+                        "Unable to find VkDynamicRasterLineState object %#" PRIxLEAST64 ", was it ever created?", dynamicRasterLineState.handle);
             } else {
-                pCB->lastBoundDynamicState[VK_STATE_BIND_POINT_RASTER] = dynamicRasterState.handle;
-                g_lastBoundDynamicState[VK_STATE_BIND_POINT_RASTER] = dynamicRasterState.handle;
+                pCB->lastBoundDynamicState[VK_STATE_BIND_POINT_RASTER_LINE] = dynamicRasterLineState.handle;
+                g_lastBoundDynamicState[VK_STATE_BIND_POINT_RASTER_LINE] = dynamicRasterLineState.handle;
             }
             loader_platform_thread_unlock_mutex(&globalLock);
-            get_dispatch_table(draw_state_device_table_map, cmdBuffer)->CmdBindDynamicRasterState(cmdBuffer, dynamicRasterState);
+            get_dispatch_table(draw_state_device_table_map, cmdBuffer)->CmdBindDynamicRasterLineState(cmdBuffer, dynamicRasterLineState);
         } else {
-            report_error_no_cb_begin(cmdBuffer, "vkCmdBindDynamicRasterState()");
+            report_error_no_cb_begin(cmdBuffer, "vkCmdBindDynamicRasterLineState()");
+        }
+    }
+}
+VK_LAYER_EXPORT void VKAPI vkCmdBindDynamicRasterDepthBiasState(VkCmdBuffer cmdBuffer, VkDynamicRasterDepthBiasState dynamicRasterDepthBiasState)
+{
+    GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
+    if (pCB) {
+        if (pCB->state == CB_UPDATE_ACTIVE) {
+            updateCBTracking(cmdBuffer);
+            addCmd(pCB, CMD_BINDDYNAMICRASTERDEPTHBIASSTATE);
+            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 vkCmdBindDynamicRasterDepthBiasState() without an active RenderPass.");
+            }
+            loader_platform_thread_lock_mutex(&globalLock);
+            pCB->status |= CBSTATUS_RASTER_DEPTH_BIAS_BOUND;
+            if (dynamicRasterDepthBiasStateMap.find(dynamicRasterDepthBiasState.handle) == dynamicRasterDepthBiasStateMap.end()) {
+                log_msg(mdd(cmdBuffer), VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DYNAMIC_RASTER_DEPTH_BIAS_STATE, dynamicRasterDepthBiasState.handle, 0, DRAWSTATE_INVALID_DYNAMIC_STATE_OBJECT, "DS",
+                        "Unable to find VkDynamicRasterDepthBiasState object %#" PRIxLEAST64 ", was it ever created?", dynamicRasterDepthBiasState.handle);
+            } else {
+                pCB->lastBoundDynamicState[VK_STATE_BIND_POINT_RASTER_DEPTH_BIAS] = dynamicRasterDepthBiasState.handle;
+                g_lastBoundDynamicState[VK_STATE_BIND_POINT_RASTER_DEPTH_BIAS] = dynamicRasterDepthBiasState.handle;
+            }
+            loader_platform_thread_unlock_mutex(&globalLock);
+            get_dispatch_table(draw_state_device_table_map, cmdBuffer)->CmdBindDynamicRasterDepthBiasState(cmdBuffer, dynamicRasterDepthBiasState);
+        } else {
+            report_error_no_cb_begin(cmdBuffer, "vkCmdBindDynamicRasterDepthBiasState()");
         }
     }
 }
@@ -3061,8 +3114,10 @@
         return (PFN_vkVoidFunction) vkDestroyDescriptorPool;
     if (!strcmp(funcName, "vkDestroyDynamicViewportState"))
         return (PFN_vkVoidFunction) vkDestroyDynamicViewportState;
-    if (!strcmp(funcName, "vkDestroyDynamicRasterState"))
-        return (PFN_vkVoidFunction) vkDestroyDynamicRasterState;
+    if (!strcmp(funcName, "vkDestroyDynamicRasterLineState"))
+        return (PFN_vkVoidFunction) vkDestroyDynamicRasterLineState;
+    if (!strcmp(funcName, "vkDestroyDynamicRasterDepthBiasState"))
+        return (PFN_vkVoidFunction) vkDestroyDynamicRasterDepthBiasState;
     if (!strcmp(funcName, "vkDestroyDynamicColorBlendState"))
         return (PFN_vkVoidFunction) vkDestroyDynamicColorBlendState;
     if (!strcmp(funcName, "vkDestroyDynamicDepthStencilState"))
@@ -3107,8 +3162,10 @@
         return (PFN_vkVoidFunction) vkUpdateDescriptorSets;
     if (!strcmp(funcName, "vkCreateDynamicViewportState"))
         return (PFN_vkVoidFunction) vkCreateDynamicViewportState;
-    if (!strcmp(funcName, "vkCreateDynamicRasterState"))
-        return (PFN_vkVoidFunction) vkCreateDynamicRasterState;
+    if (!strcmp(funcName, "vkCreateDynamicRasterLineState"))
+        return (PFN_vkVoidFunction) vkCreateDynamicRasterLineState;
+    if (!strcmp(funcName, "vkCreateDynamicRasterDepthBiasState"))
+        return (PFN_vkVoidFunction) vkCreateDynamicRasterDepthBiasState;
     if (!strcmp(funcName, "vkCreateDynamicColorBlendState"))
         return (PFN_vkVoidFunction) vkCreateDynamicColorBlendState;
     if (!strcmp(funcName, "vkCreateDynamicDepthStencilState"))
@@ -3125,8 +3182,10 @@
         return (PFN_vkVoidFunction) vkCmdBindPipeline;
     if (!strcmp(funcName, "vkCmdBindDynamicViewportState"))
         return (PFN_vkVoidFunction) vkCmdBindDynamicViewportState;
-    if (!strcmp(funcName, "vkCmdBindDynamicRasterState"))
-        return (PFN_vkVoidFunction) vkCmdBindDynamicRasterState;
+    if (!strcmp(funcName, "vkCmdBindDynamicRasterLineState"))
+        return (PFN_vkVoidFunction) vkCmdBindDynamicRasterLineState;
+    if (!strcmp(funcName, "vkCmdBindDynamicRasterDepthBiasState"))
+        return (PFN_vkVoidFunction) vkCmdBindDynamicRasterDepthBiasState;
     if (!strcmp(funcName, "vkCmdBindDynamicColorBlendState"))
         return (PFN_vkVoidFunction) vkCmdBindDynamicColorBlendState;
     if (!strcmp(funcName, "vkCmdBindDynamicDepthStencilState"))
diff --git a/layers/draw_state.h b/layers/draw_state.h
index ebc60f7..4c7c355 100644
--- a/layers/draw_state.h
+++ b/layers/draw_state.h
@@ -52,7 +52,8 @@
     DRAWSTATE_NO_BEGIN_CMD_BUFFER,              // Binding cmds or calling End on CB that never had vkBeginCommandBuffer() called on it
     DRAWSTATE_CMD_BUFFER_SINGLE_SUBMIT_VIOLATION, // Cmd Buffer created with VK_CMD_BUFFER_OPTIMIZE_ONE_TIME_SUBMIT_BIT flag is submitted multiple times
     DRAWSTATE_VIEWPORT_NOT_BOUND,               // Draw submitted with no viewport state object bound
-    DRAWSTATE_RASTER_NOT_BOUND,                 // Draw submitted with no raster state object bound
+    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_INDEX_BUFFER_NOT_BOUND,           // Draw submitted with no depth-stencil state object bound when depth write enabled
@@ -164,7 +165,8 @@
     CMD_BINDPIPELINE,
     CMD_BINDPIPELINEDELTA,
     CMD_BINDDYNAMICVIEWPORTSTATE,
-    CMD_BINDDYNAMICRASTERSTATE,
+    CMD_BINDDYNAMICRASTERLINESTATE,
+    CMD_BINDDYNAMICRASTERDEPTHBIASSTATE,
     CMD_BINDDYNAMICCOLORBLENDSTATE,
     CMD_BINDDYNAMICDEPTHSTENCILSTATE,
     CMD_BINDDESCRIPTORSETS,
@@ -225,12 +227,13 @@
 {
     CBSTATUS_NONE                              = 0x00000000, // No status is set
     CBSTATUS_VIEWPORT_BOUND                    = 0x00000001, // Viewport state object has been bound
-    CBSTATUS_RASTER_BOUND                      = 0x00000002, // Raster state object has been bound
-    CBSTATUS_COLOR_BLEND_WRITE_ENABLE          = 0x00000004, // PSO w/ CB Enable set has been bound
-    CBSTATUS_COLOR_BLEND_BOUND                 = 0x00000008, // CB state object has been bound
-    CBSTATUS_DEPTH_STENCIL_WRITE_ENABLE        = 0x00000010, // PSO w/ DS Enable set has been bound
-    CBSTATUS_DEPTH_STENCIL_BOUND               = 0x00000020, // DS state object has been bound
-    CBSTATUS_INDEX_BUFFER_BOUND                = 0x00000040, // Index buffer has been bound
+    CBSTATUS_RASTER_LINE_BOUND                 = 0x00000002, // Raster state object has been bound
+    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
 } CBStatusFlagBits;
 
 // Cmd Buffer Wrapper Struct
diff --git a/layers/layer_common.h b/layers/layer_common.h
index 5bfb4f7..4cb2ae1 100644
--- a/layers/layer_common.h
+++ b/layers/layer_common.h
@@ -26,7 +26,8 @@
 typedef enum _DYNAMIC_STATE_BIND_POINT
 {
     VK_STATE_BIND_POINT_VIEWPORT,
-    VK_STATE_BIND_POINT_RASTER,
+    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_NUM_STATE_BIND_POINT // Used for array sizing
@@ -38,8 +39,10 @@
     {
         case VK_STATE_BIND_POINT_VIEWPORT:
             return "VIEWPORT";
-        case VK_STATE_BIND_POINT_RASTER:
-            return "RASTER";
+        case VK_STATE_BIND_POINT_RASTER_LINE:
+            return "RASTER_LINE";
+        case VK_STATE_BIND_POINT_RASTER_DEPTH_BIAS:
+            return "RASTER_DEPTH_BIAS";
         case VK_STATE_BIND_POINT_COLOR_BLEND:
             return "COLOR_BLEND";
         case VK_STATE_BIND_POINT_DEPTH_STENCIL:
@@ -55,8 +58,10 @@
     {
         case VK_STATE_BIND_POINT_VIEWPORT:
             return VK_OBJECT_TYPE_DYNAMIC_VIEWPORT_STATE;
-        case VK_STATE_BIND_POINT_RASTER:
-            return VK_OBJECT_TYPE_DYNAMIC_RASTER_STATE;
+        case VK_STATE_BIND_POINT_RASTER_LINE:
+            return VK_OBJECT_TYPE_DYNAMIC_RASTER_LINE_STATE;
+        case VK_STATE_BIND_POINT_RASTER_DEPTH_BIAS:
+            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:
diff --git a/layers/mem_tracker.cpp b/layers/mem_tracker.cpp
index 510af12..846cc5b 100644
--- a/layers/mem_tracker.cpp
+++ b/layers/mem_tracker.cpp
@@ -95,7 +95,8 @@
 unordered_map<uint64_t, VkFramebufferCreateInfo>         framebufferMap;
 //unordered_map<uint64_t, VkDescriptorSetCreateInfo> descriptorSetMap;
 unordered_map<uint64_t, VkDynamicViewportStateCreateInfo>     dynamicViewportStateMap;
-unordered_map<uint64_t, VkDynamicRasterStateCreateInfo>       dynamicRasterStateMap;
+unordered_map<uint64_t, VkDynamicRasterLineStateCreateInfo>   dynamicRasterLineStateMap;
+unordered_map<uint64_t, VkDynamicRasterDepthBiasStateCreateInfo> dynamicRasterDepthBiasStateMap;
 unordered_map<uint64_t, VkDynamicColorBlendStateCreateInfo>   dynamicColorBlendStateMap;
 unordered_map<uint64_t, VkDynamicDepthStencilStateCreateInfo> dynamicDepthStencilStateMap;
 
@@ -224,10 +225,17 @@
                 return (void*)&(*it).second;
             break;
         }
-        case VK_OBJECT_TYPE_DYNAMIC_RASTER_STATE:
+        case VK_OBJECT_TYPE_DYNAMIC_RASTER_LINE_STATE:
         {
-            auto it = dynamicRasterStateMap.find(handle);
-            if (it != dynamicRasterStateMap.end())
+            auto it = dynamicRasterLineStateMap.find(handle);
+            if (it != dynamicRasterLineStateMap.end())
+                return (void*)&(*it).second;
+            break;
+        }
+        case VK_OBJECT_TYPE_DYNAMIC_RASTER_DEPTH_BIAS_STATE:
+        {
+            auto it = dynamicRasterDepthBiasStateMap.find(handle);
+            if (it != dynamicRasterDepthBiasStateMap.end())
                 return (void*)&(*it).second;
             break;
         }
@@ -511,10 +519,16 @@
             memcpy(pCI, pCreateInfo, sizeof(VkDynamicViewportStateCreateInfo));
             break;
         }
-        case VK_OBJECT_TYPE_DYNAMIC_RASTER_STATE:
+        case VK_OBJECT_TYPE_DYNAMIC_RASTER_LINE_STATE:
         {
-            auto pCI = &dynamicRasterStateMap[handle];
-            memcpy(pCI, pCreateInfo, sizeof(VkDynamicRasterStateCreateInfo));
+            auto pCI = &dynamicRasterLineStateMap[handle];
+            memcpy(pCI, pCreateInfo, sizeof(VkDynamicRasterLineStateCreateInfo));
+            break;
+        }
+        case VK_OBJECT_TYPE_DYNAMIC_RASTER_DEPTH_BIAS_STATE:
+        {
+            auto pCI = &dynamicRasterDepthBiasStateMap[handle];
+            memcpy(pCI, pCreateInfo, sizeof(VkDynamicRasterDepthBiasStateCreateInfo));
             break;
         }
         case VK_OBJECT_TYPE_DYNAMIC_COLOR_BLEND_STATE:
@@ -1136,7 +1150,8 @@
     print_object_map_members(dispObj, renderPassMap,               VK_OBJECT_TYPE_RENDER_PASS,                 "RenderPass");
     print_object_map_members(dispObj, framebufferMap,              VK_OBJECT_TYPE_FRAMEBUFFER,                 "Framebuffer");
     print_object_map_members(dispObj, dynamicViewportStateMap,     VK_OBJECT_TYPE_DYNAMIC_VIEWPORT_STATE,      "DynamicViewportState");
-    print_object_map_members(dispObj, dynamicRasterStateMap,       VK_OBJECT_TYPE_DYNAMIC_RASTER_STATE,        "DynamicRasterState");
+    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");
     log_msg(mdd(dispObj), VK_DBG_REPORT_INFO_BIT, VK_OBJECT_TYPE_DEVICE, 0, 0, MEMTRACK_NONE, "MEM", "*** End of Object lists ***");
@@ -1822,15 +1837,27 @@
     return result;
 }
 
-VK_LAYER_EXPORT VkResult VKAPI vkDestroyDynamicRasterState(VkDevice device, VkDynamicRasterState dynamicRasterState)
+VK_LAYER_EXPORT VkResult VKAPI vkDestroyDynamicRasterLineState(VkDevice device, VkDynamicRasterLineState dynamicRasterLineState)
 {
     loader_platform_thread_lock_mutex(&globalLock);
-    auto item = dynamicRasterStateMap.find(dynamicRasterState.handle);
-    if (item != dynamicRasterStateMap.end()) {
-        dynamicRasterStateMap.erase(item);
+    auto item = dynamicRasterLineStateMap.find(dynamicRasterLineState.handle);
+    if (item != dynamicRasterLineStateMap.end()) {
+        dynamicRasterLineStateMap.erase(item);
     }
     loader_platform_thread_unlock_mutex(&globalLock);
-    VkResult result = get_dispatch_table(mem_tracker_device_table_map, device)->DestroyDynamicRasterState(device, dynamicRasterState);
+    VkResult result = get_dispatch_table(mem_tracker_device_table_map, device)->DestroyDynamicRasterLineState(device, dynamicRasterLineState);
+    return result;
+}
+
+VK_LAYER_EXPORT VkResult VKAPI vkDestroyDynamicRasterDepthBiasState(VkDevice device, VkDynamicRasterDepthBiasState dynamicRasterDepthBiasState)
+{
+    loader_platform_thread_lock_mutex(&globalLock);
+    auto item = dynamicRasterDepthBiasStateMap.find(dynamicRasterDepthBiasState.handle);
+    if (item != dynamicRasterDepthBiasStateMap.end()) {
+        dynamicRasterDepthBiasStateMap.erase(item);
+    }
+    loader_platform_thread_unlock_mutex(&globalLock);
+    VkResult result = get_dispatch_table(mem_tracker_device_table_map, device)->DestroyDynamicRasterDepthBiasState(device, dynamicRasterDepthBiasState);
     return result;
 }
 
@@ -2284,15 +2311,29 @@
     return result;
 }
 
-VK_LAYER_EXPORT VkResult VKAPI vkCreateDynamicRasterState(
+VK_LAYER_EXPORT VkResult VKAPI vkCreateDynamicRasterLineState(
     VkDevice                          device,
-    const VkDynamicRasterStateCreateInfo *pCreateInfo,
-    VkDynamicRasterState             *pState)
+    const VkDynamicRasterLineStateCreateInfo *pCreateInfo,
+    VkDynamicRasterLineState             *pState)
 {
-    VkResult result = get_dispatch_table(mem_tracker_device_table_map, device)->CreateDynamicRasterState(device, pCreateInfo, pState);
+    VkResult result = get_dispatch_table(mem_tracker_device_table_map, device)->CreateDynamicRasterLineState(device, pCreateInfo, pState);
     if (result == VK_SUCCESS) {
         loader_platform_thread_lock_mutex(&globalLock);
-        add_object_create_info(pState->handle, VK_OBJECT_TYPE_DYNAMIC_RASTER_STATE, pCreateInfo);
+        add_object_create_info(pState->handle, VK_OBJECT_TYPE_DYNAMIC_RASTER_LINE_STATE, pCreateInfo);
+        loader_platform_thread_unlock_mutex(&globalLock);
+    }
+    return result;
+}
+
+VK_LAYER_EXPORT VkResult VKAPI vkCreateDynamicRasterDepthBiasState(
+    VkDevice                          device,
+    const VkDynamicRasterDepthBiasStateCreateInfo *pCreateInfo,
+    VkDynamicRasterDepthBiasState             *pState)
+{
+    VkResult result = get_dispatch_table(mem_tracker_device_table_map, device)->CreateDynamicRasterDepthBiasState(device, pCreateInfo, pState);
+    if (result == VK_SUCCESS) {
+        loader_platform_thread_lock_mutex(&globalLock);
+        add_object_create_info(pState->handle, VK_OBJECT_TYPE_DYNAMIC_RASTER_DEPTH_BIAS_STATE, pCreateInfo);
         loader_platform_thread_unlock_mutex(&globalLock);
     }
     return result;
@@ -2435,11 +2476,11 @@
     get_dispatch_table(mem_tracker_device_table_map, cmdBuffer)->CmdBindDynamicViewportState(cmdBuffer, dynamicViewportState);
 }
 
-void VKAPI vkCmdBindDynamicRasterState(
+void VKAPI vkCmdBindDynamicRasterLineState(
      VkCmdBuffer                                 cmdBuffer,
-     VkDynamicRasterState                        dynamicRasterState)
+     VkDynamicRasterLineState                    dynamicRasterLineState)
 {
-    VkDynamicRasterStateCreateInfo* pCI;
+    VkDynamicRasterLineStateCreateInfo* pCI;
     loader_platform_thread_lock_mutex(&globalLock);
     MT_CB_INFO *pCmdBuf = get_cmd_buf_info(cmdBuffer);
     if (!pCmdBuf) {
@@ -2447,14 +2488,36 @@
         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 = (VkDynamicRasterStateCreateInfo*)get_object_create_info(dynamicRasterState.handle, VK_OBJECT_TYPE_DYNAMIC_RASTER_STATE);
+    pCI = (VkDynamicRasterLineStateCreateInfo*)get_object_create_info(dynamicRasterLineState.handle, VK_OBJECT_TYPE_DYNAMIC_RASTER_LINE_STATE);
     if (!pCI) {
-         log_msg(mdd(cmdBuffer), VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DYNAMIC_RASTER_STATE, dynamicRasterState.handle, 0, MEMTRACK_INVALID_OBJECT, "MEM",
-                "Unable to find dynamic raster state object %#" PRIxLEAST64 ", was it ever created?", dynamicRasterState.handle);
+         log_msg(mdd(cmdBuffer), VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DYNAMIC_RASTER_LINE_STATE, dynamicRasterLineState.handle, 0, MEMTRACK_INVALID_OBJECT, "MEM",
+                "Unable to find dynamic raster state object %#" PRIxLEAST64 ", was it ever created?", dynamicRasterLineState.handle);
     }
-    pCmdBuf->pLastBoundDynamicState[VK_STATE_BIND_POINT_RASTER] = dynamicRasterState.handle;
+    pCmdBuf->pLastBoundDynamicState[VK_STATE_BIND_POINT_RASTER_LINE] = dynamicRasterLineState.handle;
     loader_platform_thread_unlock_mutex(&globalLock);
-    get_dispatch_table(mem_tracker_device_table_map, cmdBuffer)->CmdBindDynamicRasterState(cmdBuffer, dynamicRasterState);
+    get_dispatch_table(mem_tracker_device_table_map, cmdBuffer)->CmdBindDynamicRasterLineState(cmdBuffer, dynamicRasterLineState);
+}
+
+void VKAPI vkCmdBindDynamicRasterDepthBiasState(
+     VkCmdBuffer                                 cmdBuffer,
+     VkDynamicRasterDepthBiasState               dynamicRasterDepthBiasState)
+{
+    VkDynamicRasterDepthBiasStateCreateInfo* 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 = (VkDynamicRasterDepthBiasStateCreateInfo*)get_object_create_info(dynamicRasterDepthBiasState.handle, VK_OBJECT_TYPE_DYNAMIC_RASTER_DEPTH_BIAS_STATE);
+    if (!pCI) {
+         log_msg(mdd(cmdBuffer), VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DYNAMIC_RASTER_DEPTH_BIAS_STATE, dynamicRasterDepthBiasState.handle, 0, MEMTRACK_INVALID_OBJECT, "MEM",
+                "Unable to find dynamic raster state object %#" PRIxLEAST64 ", was it ever created?", dynamicRasterDepthBiasState.handle);
+    }
+    pCmdBuf->pLastBoundDynamicState[VK_STATE_BIND_POINT_RASTER_DEPTH_BIAS] = dynamicRasterDepthBiasState.handle;
+    loader_platform_thread_unlock_mutex(&globalLock);
+    get_dispatch_table(mem_tracker_device_table_map, cmdBuffer)->CmdBindDynamicRasterDepthBiasState(cmdBuffer, dynamicRasterDepthBiasState);
 }
 
 void VKAPI vkCmdBindDynamicColorBlendState(
@@ -3068,8 +3131,10 @@
         return (PFN_vkVoidFunction) vkDestroyFramebuffer;
     if (!strcmp(funcName, "vkDestroyDynamicViewportState"))
         return (PFN_vkVoidFunction) vkDestroyDynamicViewportState;
-    if (!strcmp(funcName, "vkDestroyDynamicRasterState"))
-        return (PFN_vkVoidFunction) vkDestroyDynamicRasterState;
+    if (!strcmp(funcName, "vkDestroyDynamicRasterLineState"))
+        return (PFN_vkVoidFunction) vkDestroyDynamicRasterLineState;
+    if (!strcmp(funcName, "vkDestroyDynamicRasterDepthBiasState"))
+        return (PFN_vkVoidFunction) vkDestroyDynamicRasterDepthBiasState;
     if (!strcmp(funcName, "vkDestroyDynamicColorBlendState"))
         return (PFN_vkVoidFunction) vkDestroyDynamicColorBlendState;
     if (!strcmp(funcName, "vkDestroyDynamicDepthStencilState"))
@@ -3124,8 +3189,10 @@
         return (PFN_vkVoidFunction) vkCreateSampler;
     if (!strcmp(funcName, "vkCreateDynamicViewportState"))
         return (PFN_vkVoidFunction) vkCreateDynamicViewportState;
-    if (!strcmp(funcName, "vkCreateDynamicRasterState"))
-        return (PFN_vkVoidFunction) vkCreateDynamicRasterState;
+    if (!strcmp(funcName, "vkCreateDynamicRasterLineState"))
+        return (PFN_vkVoidFunction) vkCreateDynamicRasterLineState;
+    if (!strcmp(funcName, "vkCreateDynamicRasterDepthBiasState"))
+        return (PFN_vkVoidFunction) vkCreateDynamicRasterDepthBiasState;
     if (!strcmp(funcName, "vkCreateDynamicColorBlendState"))
         return (PFN_vkVoidFunction) vkCreateDynamicColorBlendState;
     if (!strcmp(funcName, "vkCreateDynamicDepthStencilState"))
@@ -3142,8 +3209,10 @@
         return (PFN_vkVoidFunction) vkCmdBindPipeline;
     if (!strcmp(funcName, "vkCmdBindDynamicViewportState"))
         return (PFN_vkVoidFunction) vkCmdBindDynamicViewportState;
-    if (!strcmp(funcName, "vkCmdBindDynamicRasterState"))
-        return (PFN_vkVoidFunction) vkCmdBindDynamicRasterState;
+    if (!strcmp(funcName, "vkCmdBindDynamicRasterLineState"))
+        return (PFN_vkVoidFunction) vkCmdBindDynamicRasterLineState;
+    if (!strcmp(funcName, "vkCmdBindDynamicRasterDepthBiasState"))
+        return (PFN_vkVoidFunction) vkCmdBindDynamicRasterDepthBiasState;
     if (!strcmp(funcName, "vkCmdBindDynamicColorBlendState"))
         return (PFN_vkVoidFunction) vkCmdBindDynamicColorBlendState;
     if (!strcmp(funcName, "vkCmdBindDynamicDepthStencilState"))
diff --git a/layers/param_checker.cpp b/layers/param_checker.cpp
index e769f13..27f5524 100644
--- a/layers/param_checker.cpp
+++ b/layers/param_checker.cpp
@@ -5843,16 +5843,16 @@
     return result;
 }
 
-bool PreCreateDynamicRasterState(
+bool PreCreateDynamicRasterLineState(
     VkDevice device,
-    const VkDynamicRasterStateCreateInfo* pCreateInfo)
+    const VkDynamicRasterLineStateCreateInfo* pCreateInfo)
 {
     if(pCreateInfo != nullptr)
     {
-    if(pCreateInfo->sType != VK_STRUCTURE_TYPE_DYNAMIC_RASTER_STATE_CREATE_INFO)
+    if(pCreateInfo->sType != VK_STRUCTURE_TYPE_DYNAMIC_RASTER_LINE_STATE_CREATE_INFO)
     {
         log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK",
-        "vkCreateDynamicRasterState parameter, VkStructureType pCreateInfo->sType, is an invalid enumerator");
+        "vkCreateDynamicRasterLineState parameter, VkStructureType pCreateInfo->sType, is an invalid enumerator");
         return false;
     }
     }
@@ -5860,9 +5860,9 @@
     return true;
 }
 
-bool PostCreateDynamicRasterState(
+bool PostCreateDynamicRasterLineState(
     VkDevice device,
-    VkDynamicRasterState* pState,
+    VkDynamicRasterLineState* pState,
     VkResult result)
 {
 
@@ -5872,7 +5872,7 @@
 
     if(result < VK_SUCCESS)
     {
-        std::string reason = "vkCreateDynamicRasterState parameter, VkResult result, is " + EnumeratorString(result);
+        std::string reason = "vkCreateDynamicRasterLineState 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;
     }
@@ -5880,30 +5880,30 @@
     return true;
 }
 
-VK_LAYER_EXPORT VkResult VKAPI vkCreateDynamicRasterState(
+VK_LAYER_EXPORT VkResult VKAPI vkCreateDynamicRasterLineState(
     VkDevice device,
-    const VkDynamicRasterStateCreateInfo* pCreateInfo,
-    VkDynamicRasterState* pState)
+    const VkDynamicRasterLineStateCreateInfo* pCreateInfo,
+    VkDynamicRasterLineState* pState)
 {
-    PreCreateDynamicRasterState(device, pCreateInfo);
+    PreCreateDynamicRasterLineState(device, pCreateInfo);
 
-    VkResult result = get_dispatch_table(pc_device_table_map, device)->CreateDynamicRasterState(device, pCreateInfo, pState);
+    VkResult result = get_dispatch_table(pc_device_table_map, device)->CreateDynamicRasterLineState(device, pCreateInfo, pState);
 
-    PostCreateDynamicRasterState(device, pState, result);
+    PostCreateDynamicRasterLineState(device, pState, result);
 
     return result;
 }
 
-bool PostDestroyDynamicRasterState(
+bool PostDestroyDynamicRasterLineState(
     VkDevice device,
-    VkDynamicRasterState dynamicRasterState,
+    VkDynamicRasterLineState dynamicRasterLineState,
     VkResult result)
 {
 
 
     if(result < VK_SUCCESS)
     {
-        std::string reason = "vkDestroyDynamicRasterState parameter, VkResult result, is " + EnumeratorString(result);
+        std::string reason = "vkDestroyDynamicRasterLineState 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;
     }
@@ -5911,13 +5911,92 @@
     return true;
 }
 
-VK_LAYER_EXPORT VkResult VKAPI vkDestroyDynamicRasterState(
+VK_LAYER_EXPORT VkResult VKAPI vkDestroyDynamicRasterLineState(
     VkDevice device,
-    VkDynamicRasterState dynamicRasterState)
+    VkDynamicRasterLineState dynamicRasterLineState)
 {
-    VkResult result = get_dispatch_table(pc_device_table_map, device)->DestroyDynamicRasterState(device, dynamicRasterState);
+    VkResult result = get_dispatch_table(pc_device_table_map, device)->DestroyDynamicRasterLineState(device, dynamicRasterLineState);
 
-    PostDestroyDynamicRasterState(device, dynamicRasterState, result);
+    PostDestroyDynamicRasterLineState(device, dynamicRasterLineState, result);
+
+    return result;
+}
+
+bool PreCreateDynamicRasterDepthBiasState(
+    VkDevice device,
+    const VkDynamicRasterDepthBiasStateCreateInfo* pCreateInfo)
+{
+    if(pCreateInfo != nullptr)
+    {
+    if(pCreateInfo->sType != VK_STRUCTURE_TYPE_DYNAMIC_RASTER_DEPTH_BIAS_STATE_CREATE_INFO)
+    {
+        log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK",
+        "vkCreateDynamicRasterDepthBiasState parameter, VkStructureType pCreateInfo->sType, is an invalid enumerator");
+        return false;
+    }
+    }
+
+    return true;
+}
+
+bool PostCreateDynamicRasterDepthBiasState(
+    VkDevice device,
+    VkDynamicRasterDepthBiasState* pState,
+    VkResult result)
+{
+
+    if(pState != nullptr)
+    {
+    }
+
+    if(result < VK_SUCCESS)
+    {
+        std::string reason = "vkCreateDynamicRasterDepthBiasState 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 vkCreateDynamicRasterDepthBiasState(
+    VkDevice device,
+    const VkDynamicRasterDepthBiasStateCreateInfo* pCreateInfo,
+    VkDynamicRasterDepthBiasState* pState)
+{
+    PreCreateDynamicRasterDepthBiasState(device, pCreateInfo);
+
+    VkResult result = get_dispatch_table(pc_device_table_map, device)->CreateDynamicRasterDepthBiasState(device, pCreateInfo, pState);
+
+    PostCreateDynamicRasterDepthBiasState(device, pState, result);
+
+    return result;
+}
+
+bool PostDestroyDynamicRasterDepthBiasState(
+    VkDevice device,
+    VkDynamicRasterDepthBiasState dynamicRasterDepthBiasState,
+    VkResult result)
+{
+
+
+    if(result < VK_SUCCESS)
+    {
+        std::string reason = "vkDestroyDynamicRasterDepthBiasState 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 vkDestroyDynamicRasterDepthBiasState(
+    VkDevice device,
+    VkDynamicRasterDepthBiasState dynamicRasterDepthBiasState)
+{
+    VkResult result = get_dispatch_table(pc_device_table_map, device)->DestroyDynamicRasterDepthBiasState(device, dynamicRasterDepthBiasState);
+
+    PostDestroyDynamicRasterDepthBiasState(device, dynamicRasterDepthBiasState, result);
 
     return result;
 }
@@ -6745,22 +6824,40 @@
     PostCmdBindDynamicViewportState(cmdBuffer, dynamicViewportState);
 }
 
-bool PostCmdBindDynamicRasterState(
+bool PostCmdBindDynamicRasterLineState(
     VkCmdBuffer cmdBuffer,
-    VkDynamicRasterState dynamicRasterState)
+    VkDynamicRasterLineState dynamicRasterLineState)
 {
 
 
     return true;
 }
 
-VK_LAYER_EXPORT void VKAPI vkCmdBindDynamicRasterState(
+VK_LAYER_EXPORT void VKAPI vkCmdBindDynamicRasterLineState(
     VkCmdBuffer cmdBuffer,
-    VkDynamicRasterState dynamicRasterState)
+    VkDynamicRasterLineState dynamicRasterLineState)
 {
-    get_dispatch_table(pc_device_table_map, cmdBuffer)->CmdBindDynamicRasterState(cmdBuffer, dynamicRasterState);
+    get_dispatch_table(pc_device_table_map, cmdBuffer)->CmdBindDynamicRasterLineState(cmdBuffer, dynamicRasterLineState);
 
-    PostCmdBindDynamicRasterState(cmdBuffer, dynamicRasterState);
+    PostCmdBindDynamicRasterLineState(cmdBuffer, dynamicRasterLineState);
+}
+
+bool PostCmdBindDynamicRasterDepthBiasState(
+    VkCmdBuffer cmdBuffer,
+    VkDynamicRasterDepthBiasState dynamicRasterDepthBiasState)
+{
+
+
+    return true;
+}
+
+VK_LAYER_EXPORT void VKAPI vkCmdBindDynamicRasterDepthBiasState(
+    VkCmdBuffer cmdBuffer,
+    VkDynamicRasterDepthBiasState dynamicRasterDepthBiasState)
+{
+    get_dispatch_table(pc_device_table_map, cmdBuffer)->CmdBindDynamicRasterDepthBiasState(cmdBuffer, dynamicRasterDepthBiasState);
+
+    PostCmdBindDynamicRasterDepthBiasState(cmdBuffer, dynamicRasterDepthBiasState);
 }
 
 bool PostCmdBindDynamicColorBlendState(
@@ -8262,8 +8359,10 @@
         return (PFN_vkVoidFunction) vkAllocDescriptorSets;
     if (!strcmp(funcName, "vkCreateDynamicViewportState"))
         return (PFN_vkVoidFunction) vkCreateDynamicViewportState;
-    if (!strcmp(funcName, "vkCreateDynamicRasterState"))
-        return (PFN_vkVoidFunction) vkCreateDynamicRasterState;
+    if (!strcmp(funcName, "vkCreateDynamicRasterLineState"))
+        return (PFN_vkVoidFunction) vkCreateDynamicRasterLineState;
+    if (!strcmp(funcName, "vkCreateDynamicRasterDepthBiasState"))
+        return (PFN_vkVoidFunction) vkCreateDynamicRasterDepthBiasState;
     if (!strcmp(funcName, "vkCreateDynamicColorBlendState"))
         return (PFN_vkVoidFunction) vkCreateDynamicColorBlendState;
     if (!strcmp(funcName, "vkCreateDynamicDepthStencilState"))
diff --git a/loader/gpa_helper.h b/loader/gpa_helper.h
index 96c4f6a..bb79f03 100644
--- a/loader/gpa_helper.h
+++ b/loader/gpa_helper.h
@@ -215,10 +215,14 @@
         return (void*) vkCreateDynamicViewportState;
     if (!strcmp(name, "DestroyDynamicViewportState"))
         return (void*) vkDestroyDynamicViewportState;
-    if (!strcmp(name, "CreateDynamicRasterState"))
-        return (void*) vkCreateDynamicRasterState;
-    if (!strcmp(name, "DestroyDynamicRasterState"))
-        return (void*) vkDestroyDynamicRasterState;
+    if (!strcmp(name, "CreateDynamicRasterLineState"))
+        return (void*) vkCreateDynamicRasterLineState;
+    if (!strcmp(name, "DestroyDynamicRasterLineState"))
+        return (void*) vkDestroyDynamicRasterLineState;
+    if (!strcmp(name, "CreateDynamicRasterDepthBiasState"))
+        return (void*) vkCreateDynamicRasterDepthBiasState;
+    if (!strcmp(name, "DestroyDynamicRasterDepthBiasState"))
+        return (void*) vkDestroyDynamicRasterDepthBiasState;
     if (!strcmp(name, "CreateDynamicColorBlendState"))
         return (void*) vkCreateDynamicColorBlendState;
     if (!strcmp(name, "DestroyDynamicColorBlendState"))
@@ -257,8 +261,10 @@
         return (void*) vkCmdBindPipeline;
     if (!strcmp(name, "CmdBindDynamicViewportState"))
         return (void*) vkCmdBindDynamicViewportState;
-    if (!strcmp(name, "CmdBindDynamicRasterState"))
-        return (void*) vkCmdBindDynamicRasterState;
+    if (!strcmp(name, "CmdBindDynamicRasterLineState"))
+        return (void*) vkCmdBindDynamicRasterLineState;
+    if (!strcmp(name, "CmdBindDynamicRasterDepthBiasState"))
+        return (void*) vkCmdBindDynamicRasterDepthBiasState;
     if (!strcmp(name, "CmdBindDynamicColorBlendState"))
         return (void*) vkCmdBindDynamicColorBlendState;
     if (!strcmp(name, "CmdBindDynamicDepthStencilState"))
diff --git a/loader/table_ops.h b/loader/table_ops.h
index 4003e9c..dbb0ee4 100644
--- a/loader/table_ops.h
+++ b/loader/table_ops.h
@@ -112,8 +112,10 @@
     table->UpdateDescriptorSets = (PFN_vkUpdateDescriptorSets) gpa(dev, "vkUpdateDescriptorSets");
     table->CreateDynamicViewportState = (PFN_vkCreateDynamicViewportState) gpa(dev, "vkCreateDynamicViewportState");
     table->DestroyDynamicViewportState = (PFN_vkDestroyDynamicViewportState) gpa(dev, "vkDestroyDynamicViewportState");
-    table->CreateDynamicRasterState = (PFN_vkCreateDynamicRasterState) gpa(dev, "vkCreateDynamicRasterState");
-    table->DestroyDynamicRasterState = (PFN_vkDestroyDynamicRasterState) gpa(dev, "vkDestroyDynamicRasterState");
+    table->CreateDynamicRasterLineState = (PFN_vkCreateDynamicRasterLineState) gpa(dev, "vkCreateDynamicRasterLineState");
+    table->DestroyDynamicRasterLineState = (PFN_vkDestroyDynamicRasterLineState) gpa(dev, "vkDestroyDynamicRasterLineState");
+    table->CreateDynamicRasterDepthBiasState = (PFN_vkCreateDynamicRasterDepthBiasState) gpa(dev, "vkCreateDynamicRasterDepthBiasState");
+    table->DestroyDynamicRasterDepthBiasState = (PFN_vkDestroyDynamicRasterDepthBiasState) gpa(dev, "vkDestroyDynamicRasterDepthBiasState");
     table->CreateDynamicColorBlendState = (PFN_vkCreateDynamicColorBlendState) gpa(dev, "vkCreateDynamicColorBlendState");
     table->DestroyDynamicColorBlendState = (PFN_vkDestroyDynamicColorBlendState) gpa(dev, "vkDestroyDynamicColorBlendState");
     table->CreateDynamicDepthStencilState = (PFN_vkCreateDynamicDepthStencilState) gpa(dev, "vkCreateDynamicDepthStencilState");
@@ -133,7 +135,8 @@
     table->ResetCommandBuffer = (PFN_vkResetCommandBuffer) gpa(dev, "vkResetCommandBuffer");
     table->CmdBindPipeline = (PFN_vkCmdBindPipeline) gpa(dev, "vkCmdBindPipeline");
     table->CmdBindDynamicViewportState = (PFN_vkCmdBindDynamicViewportState) gpa(dev, "vkCmdBindDynamicViewportState");
-    table->CmdBindDynamicRasterState = (PFN_vkCmdBindDynamicRasterState) gpa(dev, "vkCmdBindDynamicRasterState");
+    table->CmdBindDynamicRasterLineState = (PFN_vkCmdBindDynamicRasterLineState) gpa(dev, "vkCmdBindDynamicRasterLineState");
+    table->CmdBindDynamicRasterDepthBiasState = (PFN_vkCmdBindDynamicRasterDepthBiasState) gpa(dev, "vkCmdBindDynamicRasterDepthBiasState");
     table->CmdBindDynamicColorBlendState = (PFN_vkCmdBindDynamicColorBlendState) gpa(dev, "vkCmdBindDynamicColorBlendState");
     table->CmdBindDynamicDepthStencilState = (PFN_vkCmdBindDynamicDepthStencilState) gpa(dev, "vkCmdBindDynamicDepthStencilState");
     table->CmdBindDescriptorSets = (PFN_vkCmdBindDescriptorSets) gpa(dev, "vkCmdBindDescriptorSets");
@@ -344,10 +347,14 @@
         return (void *) table->CreateDynamicViewportState;
     if (!strcmp(name, "DestroyDynamicViewportState"))
         return (void *) table->DestroyDynamicViewportState;
-    if (!strcmp(name, "CreateDynamicRasterState"))
-        return (void *) table->CreateDynamicRasterState;
-    if (!strcmp(name, "DestroyDynamicRasterState"))
-        return (void *) table->DestroyDynamicRasterState;
+    if (!strcmp(name, "CreateDynamicRasterLineState"))
+        return (void *) table->CreateDynamicRasterLineState;
+    if (!strcmp(name, "DestroyDynamicRasterLineState"))
+        return (void *) table->DestroyDynamicRasterLineState;
+    if (!strcmp(name, "CreateDynamicRasterDepthBiasState"))
+        return (void *) table->CreateDynamicRasterDepthBiasState;
+    if (!strcmp(name, "DestroyDynamicRasterDepthBiasState"))
+        return (void *) table->DestroyDynamicRasterDepthBiasState;
     if (!strcmp(name, "CreateDynamicColorBlendState"))
         return (void *) table->CreateDynamicColorBlendState;
     if (!strcmp(name, "DestroyDynamicColorBlendState"))
@@ -386,8 +393,10 @@
         return (void *) table->CmdBindPipeline;
     if (!strcmp(name, "CmdBindDynamicViewportState"))
         return (void *) table->CmdBindDynamicViewportState;
-    if (!strcmp(name, "CmdBindDynamicRasterState"))
-        return (void *) table->CmdBindDynamicRasterState;
+    if (!strcmp(name, "CmdBindDynamicRasterLineState"))
+        return (void *) table->CmdBindDynamicRasterLineState;
+    if (!strcmp(name, "CmdBindDynamicRasterDepthBiasState"))
+        return (void *) table->CmdBindDynamicRasterDepthBiasState;
     if (!strcmp(name, "CmdBindDynamicColorBlendState"))
         return (void *) table->CmdBindDynamicColorBlendState;
     if (!strcmp(name, "CmdBindDynamicDepthStencilState"))
diff --git a/loader/trampoline.c b/loader/trampoline.c
index 45a9ff7..715fcf7 100644
--- a/loader/trampoline.c
+++ b/loader/trampoline.c
@@ -1016,22 +1016,40 @@
     return disp->DestroyDynamicViewportState(device, dynamicViewportState);
 }
 
-LOADER_EXPORT VkResult VKAPI vkCreateDynamicRasterState(VkDevice device, const VkDynamicRasterStateCreateInfo* pCreateInfo, VkDynamicRasterState* pState)
+LOADER_EXPORT VkResult VKAPI vkCreateDynamicRasterLineState(VkDevice device, const VkDynamicRasterLineStateCreateInfo* pCreateInfo, VkDynamicRasterLineState* pState)
 {
     const VkLayerDispatchTable *disp;
 
     disp = loader_get_dispatch(device);
 
-    return disp->CreateDynamicRasterState(device, pCreateInfo, pState);
+    return disp->CreateDynamicRasterLineState(device, pCreateInfo, pState);
 }
 
-LOADER_EXPORT VkResult VKAPI vkDestroyDynamicRasterState(VkDevice device, VkDynamicRasterState dynamicRasterState)
+LOADER_EXPORT VkResult VKAPI vkDestroyDynamicRasterLineState(VkDevice device, VkDynamicRasterLineState dynamicRasterLineState)
 {
     const VkLayerDispatchTable *disp;
 
     disp = loader_get_dispatch(device);
 
-    return disp->DestroyDynamicRasterState(device, dynamicRasterState);
+    return disp->DestroyDynamicRasterLineState(device, dynamicRasterLineState);
+}
+
+LOADER_EXPORT VkResult VKAPI vkCreateDynamicRasterDepthBiasState(VkDevice device, const VkDynamicRasterDepthBiasStateCreateInfo* pCreateInfo, VkDynamicRasterDepthBiasState* pState)
+{
+    const VkLayerDispatchTable *disp;
+
+    disp = loader_get_dispatch(device);
+
+    return disp->CreateDynamicRasterDepthBiasState(device, pCreateInfo, pState);
+}
+
+LOADER_EXPORT VkResult VKAPI vkDestroyDynamicRasterDepthBiasState(VkDevice device, VkDynamicRasterDepthBiasState dynamicRasterDepthBiasState)
+{
+    const VkLayerDispatchTable *disp;
+
+    disp = loader_get_dispatch(device);
+
+    return disp->DestroyDynamicRasterDepthBiasState(device, dynamicRasterDepthBiasState);
 }
 
 LOADER_EXPORT VkResult VKAPI vkCreateDynamicColorBlendState(VkDevice device, const VkDynamicColorBlendStateCreateInfo* pCreateInfo, VkDynamicColorBlendState* pState)
@@ -1211,13 +1229,22 @@
     disp->CmdBindDynamicViewportState(cmdBuffer, state);
 }
 
-LOADER_EXPORT void VKAPI vkCmdBindDynamicRasterState(VkCmdBuffer cmdBuffer, VkDynamicRasterState state)
+LOADER_EXPORT void VKAPI vkCmdBindDynamicRasterLineState(VkCmdBuffer cmdBuffer, VkDynamicRasterLineState state)
 {
     const VkLayerDispatchTable *disp;
 
     disp = loader_get_dispatch(cmdBuffer);
 
-    disp->CmdBindDynamicRasterState(cmdBuffer, state);
+    disp->CmdBindDynamicRasterLineState(cmdBuffer, state);
+}
+
+LOADER_EXPORT void VKAPI vkCmdBindDynamicRasterDepthBiasState(VkCmdBuffer cmdBuffer, VkDynamicRasterDepthBiasState state)
+{
+    const VkLayerDispatchTable *disp;
+
+    disp = loader_get_dispatch(cmdBuffer);
+
+    disp->CmdBindDynamicRasterDepthBiasState(cmdBuffer, state);
 }
 
 LOADER_EXPORT void VKAPI vkCmdBindDynamicColorBlendState(VkCmdBuffer cmdBuffer, VkDynamicColorBlendState state)
diff --git a/tests/layer_validation_tests.cpp b/tests/layer_validation_tests.cpp
index 6ece510..46dd4d4 100644
--- a/tests/layer_validation_tests.cpp
+++ b/tests/layer_validation_tests.cpp
@@ -27,10 +27,11 @@
 
 typedef enum _BsoFailSelect {
     BsoFailNone                     = 0x00000000,
-    BsoFailRaster                   = 0x00000001,
-    BsoFailViewport                 = 0x00000002,
-    BsoFailColorBlend               = 0x00000004,
-    BsoFailDepthStencil             = 0x00000008,
+    BsoFailRasterLine               = 0x00000001,
+    BsoFailRasterDepthBias          = 0x00000002,
+    BsoFailViewport                 = 0x00000004,
+    BsoFailColorBlend               = 0x00000008,
+    BsoFailDepthStencil             = 0x00000010,
 } BsoFailSelect;
 
 struct vktriangle_vs_uniform {
@@ -307,8 +308,11 @@
     }
 
     cmdBuffer->PrepareAttachments();
-    if ((failMask & BsoFailRaster) != BsoFailRaster) {
-        cmdBuffer->BindDynamicRasterState(m_stateRaster);
+    if ((failMask & BsoFailRasterLine) != BsoFailRasterLine) {
+        cmdBuffer->BindDynamicRasterLineState(m_stateRasterLine);
+    }
+    if ((failMask & BsoFailRasterDepthBias) != BsoFailRasterDepthBias) {
+        cmdBuffer->BindDynamicRasterDepthBiasState(m_stateRasterDepthBias);
     }
     if ((failMask & BsoFailViewport) != BsoFailViewport) {
         cmdBuffer->BindDynamicViewportState(m_stateViewport);
@@ -894,20 +898,37 @@
 #endif
 #endif
 #if OBJ_TRACKER_TESTS
-TEST_F(VkLayerTest, RasterStateNotBound)
+TEST_F(VkLayerTest, RasterLineStateNotBound)
 {
     VkFlags msgFlags;
     std::string msgString;
     ASSERT_NO_FATAL_FAILURE(InitState());
     m_errorMonitor->ClearState();
-    TEST_DESCRIPTION("Simple Draw Call that validates failure when a raster state object is not bound beforehand");
+    TEST_DESCRIPTION("Simple Draw Call that validates failure when a raster line state object is not bound beforehand");
 
-    VKTriangleTest(bindStateVertShaderText, bindStateFragShaderText, BsoFailRaster);
+    VKTriangleTest(bindStateVertShaderText, bindStateFragShaderText, BsoFailRasterLine);
 
     msgFlags = m_errorMonitor->GetState(&msgString);
-    ASSERT_TRUE(0 != (msgFlags & VK_DBG_REPORT_ERROR_BIT)) << "Did not receive an error from Not Binding a Raster State Object";
-    if (!strstr(msgString.c_str(),"Raster object not bound to this command buffer")) {
-        FAIL() << "Error received was not 'Raster object not bound to this command buffer'";
+    ASSERT_TRUE(0 != (msgFlags & VK_DBG_REPORT_ERROR_BIT)) << "Did not receive an error from Not Binding a Raster Line State Object";
+    if (!strstr(msgString.c_str(),"Raster line object not bound to this command buffer")) {
+        FAIL() << "Error received was not 'Raster line object not bound to this command buffer'";
+    }
+}
+
+TEST_F(VkLayerTest, RasterDepthBiasStateNotBound)
+{
+    VkFlags msgFlags;
+    std::string msgString;
+    ASSERT_NO_FATAL_FAILURE(InitState());
+    m_errorMonitor->ClearState();
+    TEST_DESCRIPTION("Simple Draw Call that validates failure when a raster depth bias state object is not bound beforehand");
+
+    VKTriangleTest(bindStateVertShaderText, bindStateFragShaderText, BsoFailRasterDepthBias);
+
+    msgFlags = m_errorMonitor->GetState(&msgString);
+    ASSERT_TRUE(0 != (msgFlags & VK_DBG_REPORT_ERROR_BIT)) << "Did not receive an error from Not Binding a Raster Depth Bias State Object";
+    if (!strstr(msgString.c_str(),"Raster depth bias object not bound to this command buffer")) {
+        FAIL() << "Error received was not 'Raster depth bias object not bound to this command buffer'";
     }
 }
 
diff --git a/tests/render_tests.cpp b/tests/render_tests.cpp
index e2766d0..2d78995 100644
--- a/tests/render_tests.cpp
+++ b/tests/render_tests.cpp
@@ -384,7 +384,8 @@
     }
 
     cmdBuffer->PrepareAttachments();
-    cmdBuffer->BindDynamicRasterState(m_stateRaster);
+    cmdBuffer->BindDynamicRasterLineState(m_stateRasterLine);
+    cmdBuffer->BindDynamicRasterDepthBiasState(m_stateRasterDepthBias);
     cmdBuffer->BindDynamicViewportState(m_stateViewport);
     cmdBuffer->BindDynamicColorBlendState(m_colorBlend);
     cmdBuffer->BindDynamicDepthStencilState(m_stateDepthStencil);
diff --git a/tests/vkrenderframework.cpp b/tests/vkrenderframework.cpp
index 780b71f..d601b8c 100644
--- a/tests/vkrenderframework.cpp
+++ b/tests/vkrenderframework.cpp
@@ -40,7 +40,8 @@
     m_cmdBuffer(),
     m_renderPass(VK_NULL_HANDLE),
     m_framebuffer(VK_NULL_HANDLE),
-    m_stateRaster( VK_NULL_HANDLE ),
+    m_stateRasterLine( VK_NULL_HANDLE ),
+    m_stateRasterDepthBias( VK_NULL_HANDLE ),
     m_colorBlend( VK_NULL_HANDLE ),
     m_stateViewport( VK_NULL_HANDLE ),
     m_stateDepthStencil( VK_NULL_HANDLE ),
@@ -155,7 +156,8 @@
 {
     if (m_colorBlend) vkDestroyDynamicColorBlendState(device(), m_colorBlend);
     if (m_stateDepthStencil) vkDestroyDynamicDepthStencilState(device(), m_stateDepthStencil);
-    if (m_stateRaster) vkDestroyDynamicRasterState(device(), m_stateRaster);
+    if (m_stateRasterLine) vkDestroyDynamicRasterLineState(device(), m_stateRasterLine);
+    if (m_stateRasterDepthBias) vkDestroyDynamicRasterDepthBiasState(device(), m_stateRasterDepthBias);
     if (m_cmdBuffer)
         delete m_cmdBuffer;
     if (m_cmdPool) vkDestroyCommandPool(device(), m_cmdPool);
@@ -211,11 +213,18 @@
     m_render_target_fmt = surfFormats[0].format;
     free(surfFormats);
 
-    // create a raster state (solid, back-face culling)
-    VkDynamicRasterStateCreateInfo raster = {};
-    raster.sType = VK_STRUCTURE_TYPE_DYNAMIC_RASTER_STATE_CREATE_INFO;
+    VkDynamicRasterLineStateCreateInfo rasterLine = {};
+    rasterLine.sType = VK_STRUCTURE_TYPE_DYNAMIC_RASTER_LINE_STATE_CREATE_INFO;
+    rasterLine.lineWidth = 1;
+    err = vkCreateDynamicRasterLineState( device(), &rasterLine, &m_stateRasterLine );
+    ASSERT_VK_SUCCESS(err);
 
-    err = vkCreateDynamicRasterState( device(), &raster, &m_stateRaster );
+    VkDynamicRasterDepthBiasStateCreateInfo rasterDepthBias = {};
+    rasterDepthBias.sType = VK_STRUCTURE_TYPE_DYNAMIC_RASTER_DEPTH_BIAS_STATE_CREATE_INFO;
+    rasterDepthBias.depthBias = 0.0f;
+    rasterDepthBias.depthBiasClamp = 0.0f;
+    rasterDepthBias.slopeScaledDepthBias = 0.0f;
+    err = vkCreateDynamicRasterDepthBiasState( device(), &rasterDepthBias, &m_stateRasterDepthBias );
     ASSERT_VK_SUCCESS(err);
 
     VkDynamicColorBlendStateCreateInfo blend = {};
@@ -1165,6 +1174,7 @@
     m_rs_state.fillMode = VK_FILL_MODE_SOLID;
     m_rs_state.cullMode = VK_CULL_MODE_BACK;
     m_rs_state.frontFace = VK_FRONT_FACE_CW;
+    m_rs_state.depthBiasEnable = VK_FALSE;
 
     memset(&m_cb_state,0,sizeof(m_cb_state));
     m_cb_state.sType = VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO;
@@ -1466,9 +1476,14 @@
     vkCmdBindDynamicViewportState( handle(), viewportState);
 }
 
-void VkCommandBufferObj::BindDynamicRasterState(VkDynamicRasterState rasterState)
+void VkCommandBufferObj::BindDynamicRasterLineState(VkDynamicRasterLineState rasterLineState)
 {
-    vkCmdBindDynamicRasterState( handle(), rasterState);
+    vkCmdBindDynamicRasterLineState( handle(), rasterLineState);
+}
+
+void VkCommandBufferObj::BindDynamicRasterDepthBiasState(VkDynamicRasterDepthBiasState rasterDepthBiasState)
+{
+    vkCmdBindDynamicRasterDepthBiasState( handle(), rasterDepthBiasState);
 }
 
 void VkCommandBufferObj::BindDynamicColorBlendState(VkDynamicColorBlendState colorBlendState)
diff --git a/tests/vkrenderframework.h b/tests/vkrenderframework.h
index f8f2b27..f58a9b4 100644
--- a/tests/vkrenderframework.h
+++ b/tests/vkrenderframework.h
@@ -112,7 +112,8 @@
     VkFramebuffer                       m_framebuffer;
     std::vector<VkClearValue>           m_renderPassClearValues;
     VkRenderPassBeginInfo               m_renderPassBeginInfo;
-    VkDynamicRasterState                m_stateRaster;
+    VkDynamicRasterLineState            m_stateRasterLine;
+    VkDynamicRasterDepthBiasState       m_stateRasterDepthBias;
     VkDynamicColorBlendState            m_colorBlend;
     VkDynamicViewportState              m_stateViewport;
     VkDynamicDepthStencilState          m_stateDepthStencil;
@@ -176,7 +177,8 @@
     void BindIndexBuffer(VkIndexBufferObj *indexBuffer, VkDeviceSize offset);
     void BeginRenderPass(const VkRenderPassBeginInfo &info);
     void BindDynamicViewportState(VkDynamicViewportState viewportState);
-    void BindDynamicRasterState(VkDynamicRasterState rasterState);
+    void BindDynamicRasterLineState(VkDynamicRasterLineState rasterLineState);
+    void BindDynamicRasterDepthBiasState(VkDynamicRasterDepthBiasState rasterStateDepthBias);
     void BindDynamicColorBlendState(VkDynamicColorBlendState colorBlendState);
     void BindDynamicDepthStencilState(VkDynamicDepthStencilState depthStencilState);
     void EndRenderPass();
diff --git a/tests/vktestbinding.cpp b/tests/vktestbinding.cpp
index 6ad1b7e..fe5f6cb 100644
--- a/tests/vktestbinding.cpp
+++ b/tests/vktestbinding.cpp
@@ -791,11 +791,18 @@
     NON_DISPATCHABLE_HANDLE_INIT(vkCreateDynamicViewportState, dev, &info);
 }
 
-NON_DISPATCHABLE_HANDLE_DTOR(DynamicRasterState, vkDestroyDynamicRasterState)
+NON_DISPATCHABLE_HANDLE_DTOR(DynamicRasterLineState, vkDestroyDynamicRasterLineState)
 
-void DynamicRasterState::init(const Device &dev, const VkDynamicRasterStateCreateInfo &info)
+void DynamicRasterLineState::init(const Device &dev, const VkDynamicRasterLineStateCreateInfo &info)
 {
-    NON_DISPATCHABLE_HANDLE_INIT(vkCreateDynamicRasterState, dev, &info);
+    NON_DISPATCHABLE_HANDLE_INIT(vkCreateDynamicRasterLineState, dev, &info);
+}
+
+NON_DISPATCHABLE_HANDLE_DTOR(DynamicRasterDepthBiasState, vkDestroyDynamicRasterDepthBiasState)
+
+void DynamicRasterDepthBiasState::init(const Device &dev, const VkDynamicRasterDepthBiasStateCreateInfo &info)
+{
+    NON_DISPATCHABLE_HANDLE_INIT(vkCreateDynamicRasterDepthBiasState, dev, &info);
 }
 
 NON_DISPATCHABLE_HANDLE_DTOR(DynamicColorBlendState, vkDestroyDynamicColorBlendState)
diff --git a/tests/vktestbinding.h b/tests/vktestbinding.h
index 63be2a9..d5873ce 100644
--- a/tests/vktestbinding.h
+++ b/tests/vktestbinding.h
@@ -56,7 +56,8 @@
 class DescriptorSetPool;
 class DescriptorSet;
 class DynamicViewportState;
-class DynamicRasterState;
+class DynamicRasterLineState;
+class DynamicRasterDepthBiasState;
 class DynamicColorBlendState;
 class DynamicDepthStencilState;
 class CmdBuffer;
@@ -559,12 +560,20 @@
     void init(const Device &dev, const VkDynamicViewportStateCreateInfo &info);
 };
 
-class DynamicRasterState : public internal::NonDispHandle<VkDynamicRasterState> {
+class DynamicRasterLineState : public internal::NonDispHandle<VkDynamicRasterLineState> {
 public:
-    ~DynamicRasterState();
+    ~DynamicRasterLineState();
 
-    // vkCreateDynamicRasterState()
-    void init(const Device &dev, const VkDynamicRasterStateCreateInfo &info);
+    // vkCreateDynamicRasterLineState()
+    void init(const Device &dev, const VkDynamicRasterLineStateCreateInfo &info);
+};
+
+class DynamicRasterDepthBiasState : public internal::NonDispHandle<VkDynamicRasterDepthBiasState> {
+public:
+    ~DynamicRasterDepthBiasState();
+
+    // vkCreateDynamicRasterDepthBiasState()
+    void init(const Device &dev, const VkDynamicRasterDepthBiasStateCreateInfo &info);
 };
 
 class DynamicColorBlendState : public internal::NonDispHandle<VkDynamicColorBlendState> {
diff --git a/vk-layer-generate.py b/vk-layer-generate.py
index 42db53c..4af3b37 100755
--- a/vk-layer-generate.py
+++ b/vk-layer-generate.py
@@ -1404,7 +1404,7 @@
     def generate_command_buffer_validates(self):
         cbv_txt = []
         cbv_txt.append('%s' % self.lineinfo.get())
-        for o in ['VkPipeline', 'VkDynamicViewportState', 'VkDynamicRasterState', 'VkDynamicColorBlendState', 'VkDynamicDepthStencilState',
+        for o in ['VkPipeline', 'VkDynamicViewportState', 'VkDynamicRasterLineState', 'VkDynamicRasterDepthBiasState', 'VkDynamicColorBlendState', 'VkDynamicDepthStencilState',
                   'VkPipelineLayout', 'VkBuffer', 'VkEvent', 'VkQueryPool', 'VkRenderPass', 'VkFramebuffer']:
             cbv_txt.append('static void validate_object(VkCmdBuffer dispatchable_object, %s object)' % (o))
             cbv_txt.append('{')
@@ -1597,7 +1597,8 @@
         'VkDescriptorPool' : 'VK_OBJECT_TYPE_DESCRIPTOR_POOL',
         'VkDescriptorSet' : 'VK_OBJECT_TYPE_DESCRIPTOR_SET',
         'VkDynamicViewportState' : 'VK_OBJECT_TYPE_DYNAMIC_VIEWPORT_STATE',
-        'VkDynamicRasterState' : 'VK_OBJECT_TYPE_DYNAMIC_RASTER_STATE',
+        'VkDynamicRasterLineState' : 'VK_OBJECT_TYPE_DYNAMIC_RASTER_LINE_STATE',
+        'VkDynamicRasterDepthBiasState' : 'VK_OBJECT_TYPE_DYNAMIC_RASTER_DEPTH_BIAS_STATE',
         'VkDynamicColorBlendState' : 'VK_OBJECT_TYPE_DYNAMIC_COLOR_BLEND_STATE',
         'VkDynamicDepthStencilState' : 'VK_OBJECT_TYPE_DYNAMIC_DEPTH_STENCIL_STATE',
         'VkFramebuffer' : 'VK_OBJECT_TYPE_FRAMEBUFFER',
diff --git a/vulkan.py b/vulkan.py
index 8843ee0..e7206b4 100755
--- a/vulkan.py
+++ b/vulkan.py
@@ -209,7 +209,8 @@
         "VkDescriptorPool",
         "VkDescriptorSet",
         "VkDynamicViewportState",
-        "VkDynamicRasterState",
+        "VkDynamicRasterLineState",
+        "VkDynamicRasterDepthBiasState",
         "VkDynamicColorBlendState",
         "VkDynamicDepthStencilState",
         "VkRenderPass",
@@ -672,14 +673,23 @@
             [Param("VkDevice", "device"),
              Param("VkDynamicViewportState", "dynamicViewportState")]),
 
-        Proto("VkResult", "CreateDynamicRasterState",
+        Proto("VkResult", "CreateDynamicRasterLineState",
             [Param("VkDevice", "device"),
-             Param("const VkDynamicRasterStateCreateInfo*", "pCreateInfo"),
-             Param("VkDynamicRasterState*", "pState")]),
+             Param("const VkDynamicRasterLineStateCreateInfo*", "pCreateInfo"),
+             Param("VkDynamicRasterLineState*", "pState")]),
 
-        Proto("VkResult", "DestroyDynamicRasterState",
+        Proto("VkResult", "DestroyDynamicRasterLineState",
             [Param("VkDevice", "device"),
-             Param("VkDynamicRasterState", "dynamicRasterState")]),
+             Param("VkDynamicRasterLineState", "dynamicRasterLineState")]),
+
+        Proto("VkResult", "CreateDynamicRasterDepthBiasState",
+            [Param("VkDevice", "device"),
+             Param("const VkDynamicRasterDepthBiasStateCreateInfo*", "pCreateInfo"),
+             Param("VkDynamicRasterDepthBiasState*", "pState")]),
+
+        Proto("VkResult", "DestroyDynamicRasterDepthBiasState",
+            [Param("VkDevice", "device"),
+             Param("VkDynamicRasterDepthBiasState", "dynamicRasterDepthBiasState")]),
 
         Proto("VkResult", "CreateDynamicColorBlendState",
             [Param("VkDevice", "device"),
@@ -742,9 +752,13 @@
             [Param("VkCmdBuffer", "cmdBuffer"),
              Param("VkDynamicViewportState", "dynamicViewportState")]),
 
-        Proto("void", "CmdBindDynamicRasterState",
+        Proto("void", "CmdBindDynamicRasterLineState",
             [Param("VkCmdBuffer", "cmdBuffer"),
-             Param("VkDynamicRasterState", "dynamicRasterState")]),
+             Param("VkDynamicRasterLineState", "dynamicRasterLineState")]),
+
+        Proto("void", "CmdBindDynamicRasterDepthBiasState",
+            [Param("VkCmdBuffer", "cmdBuffer"),
+             Param("VkDynamicRasterDepthBiasState", "dynamicRasterDepthBiasState")]),
 
         Proto("void", "CmdBindDynamicColorBlendState",
             [Param("VkCmdBuffer", "cmdBuffer"),
@@ -1140,7 +1154,8 @@
     "VkDescriptorPool",
     "VkDescriptorSet",
     "VkDynamicViewportState",
-    "VkDynamicRasterState",
+    "VkDynamicRasterLineState",
+    "VkDynamicRasterDepthBiasState",
     "VkDynamicColorBlendState",
     "VkDynamicDepthStencilState",
     "VkRenderPass",