Add support for VK_KHR_timeline_semaphore

2026-09-23 14:15:42 +00:00 · 2019-10-15 12:51:11 +01:00
parent d48b84d8f5
commit 125cee09ef
9 changed files with 323 additions and 12 deletions
@@ -587,6 +587,9 @@ enum class VulkanChunk : uint32_t
  vkResetQueryPoolEXT,
  ImageRefs,
  vkCmdSetLineStippleEXT,
+  vkGetSemaphoreCounterValueKHR,
+  vkWaitSemaphoresKHR,
+  vkSignalSemaphoreKHR,
  Max,
 };

@@ -818,6 +821,8 @@ DECLARE_REFLECTION_STRUCT(VkPhysicalDeviceSubgroupSizeControlPropertiesEXT);
 DECLARE_REFLECTION_STRUCT(VkPhysicalDeviceSurfaceInfo2KHR);
 DECLARE_REFLECTION_STRUCT(VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT);
 DECLARE_REFLECTION_STRUCT(VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT);
+DECLARE_REFLECTION_STRUCT(VkPhysicalDeviceTimelineSemaphoreFeaturesKHR);
+DECLARE_REFLECTION_STRUCT(VkPhysicalDeviceTimelineSemaphorePropertiesKHR);
 DECLARE_REFLECTION_STRUCT(VkPhysicalDeviceTransformFeedbackFeaturesEXT);
 DECLARE_REFLECTION_STRUCT(VkPhysicalDeviceTransformFeedbackPropertiesEXT);
 DECLARE_REFLECTION_STRUCT(VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR);
@@ -877,6 +882,9 @@ DECLARE_REFLECTION_STRUCT(VkSamplerYcbcrConversionImageFormatProperties);
 DECLARE_REFLECTION_STRUCT(VkSamplerYcbcrConversionInfo);
 DECLARE_REFLECTION_STRUCT(VkSemaphoreCreateInfo);
 DECLARE_REFLECTION_STRUCT(VkSemaphoreGetFdInfoKHR);
+DECLARE_REFLECTION_STRUCT(VkSemaphoreSignalInfoKHR);
+DECLARE_REFLECTION_STRUCT(VkSemaphoreTypeCreateInfoKHR);
+DECLARE_REFLECTION_STRUCT(VkSemaphoreWaitInfoKHR);
 DECLARE_REFLECTION_STRUCT(VkShaderModuleCreateInfo);
 DECLARE_REFLECTION_STRUCT(VkShaderModuleValidationCacheCreateInfoEXT);
 DECLARE_REFLECTION_STRUCT(VkSharedPresentSurfaceCapabilitiesKHR);
@@ -897,6 +905,7 @@ DECLARE_REFLECTION_STRUCT(VkSwapchainCounterCreateInfoEXT);
 DECLARE_REFLECTION_STRUCT(VkSwapchainCreateInfoKHR);
 DECLARE_REFLECTION_STRUCT(VkSwapchainDisplayNativeHdrCreateInfoAMD);
 DECLARE_REFLECTION_STRUCT(VkTextureLODGatherFormatPropertiesAMD);
+DECLARE_REFLECTION_STRUCT(VkTimelineSemaphoreSubmitInfoKHR);
 DECLARE_REFLECTION_STRUCT(VkValidationCacheCreateInfoEXT);
 DECLARE_REFLECTION_STRUCT(VkValidationFeaturesEXT);
 DECLARE_REFLECTION_STRUCT(VkValidationFlagsEXT);
@@ -1081,6 +1090,8 @@ DECLARE_DESERIALISE_TYPE(VkPhysicalDeviceSubgroupSizeControlPropertiesEXT);
 DECLARE_DESERIALISE_TYPE(VkPhysicalDeviceSurfaceInfo2KHR);
 DECLARE_DESERIALISE_TYPE(VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT);
 DECLARE_DESERIALISE_TYPE(VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT);
+DECLARE_DESERIALISE_TYPE(VkPhysicalDeviceTimelineSemaphoreFeaturesKHR);
+DECLARE_DESERIALISE_TYPE(VkPhysicalDeviceTimelineSemaphorePropertiesKHR);
 DECLARE_DESERIALISE_TYPE(VkPhysicalDeviceTransformFeedbackFeaturesEXT);
 DECLARE_DESERIALISE_TYPE(VkPhysicalDeviceTransformFeedbackPropertiesEXT);
 DECLARE_DESERIALISE_TYPE(VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR);
@@ -1137,6 +1148,9 @@ DECLARE_DESERIALISE_TYPE(VkSamplerYcbcrConversionImageFormatProperties);
 DECLARE_DESERIALISE_TYPE(VkSamplerYcbcrConversionInfo);
 DECLARE_DESERIALISE_TYPE(VkSemaphoreCreateInfo);
 DECLARE_DESERIALISE_TYPE(VkSemaphoreGetFdInfoKHR);
+DECLARE_DESERIALISE_TYPE(VkSemaphoreSignalInfoKHR);
+DECLARE_DESERIALISE_TYPE(VkSemaphoreTypeCreateInfoKHR);
+DECLARE_DESERIALISE_TYPE(VkSemaphoreWaitInfoKHR);
 DECLARE_DESERIALISE_TYPE(VkShaderModuleCreateInfo);
 DECLARE_DESERIALISE_TYPE(VkShaderModuleValidationCacheCreateInfoEXT);
 DECLARE_DESERIALISE_TYPE(VkSharedPresentSurfaceCapabilitiesKHR);
@@ -1157,6 +1171,7 @@ DECLARE_DESERIALISE_TYPE(VkSwapchainCounterCreateInfoEXT);
 DECLARE_DESERIALISE_TYPE(VkSwapchainCreateInfoKHR);
 DECLARE_DESERIALISE_TYPE(VkSwapchainDisplayNativeHdrCreateInfoAMD);
 DECLARE_DESERIALISE_TYPE(VkTextureLODGatherFormatPropertiesAMD);
+DECLARE_DESERIALISE_TYPE(VkTimelineSemaphoreSubmitInfoKHR);
 DECLARE_DESERIALISE_TYPE(VkValidationCacheCreateInfoEXT);
 DECLARE_DESERIALISE_TYPE(VkValidationFeaturesEXT);
 DECLARE_DESERIALISE_TYPE(VkValidationFlagsEXT);
@@ -1017,6 +1017,9 @@ static const VkExtensionProperties supportedExtensions[] = {
    {
        VK_KHR_SWAPCHAIN_MUTABLE_FORMAT_EXTENSION_NAME, VK_KHR_SWAPCHAIN_MUTABLE_FORMAT_SPEC_VERSION,
    },
+    {
+        VK_KHR_TIMELINE_SEMAPHORE_EXTENSION_NAME, VK_KHR_TIMELINE_SEMAPHORE_SPEC_VERSION,
+    },
    {
        VK_KHR_UNIFORM_BUFFER_STANDARD_LAYOUT_EXTENSION_NAME,
        VK_KHR_UNIFORM_BUFFER_STANDARD_LAYOUT_SPEC_VERSION,
@@ -2181,4 +2181,15 @@ public:
                                   const VkMetalSurfaceCreateInfoEXT *pCreateInfo,
                                   const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface);
 #endif
+
+  // VK_KHR_timeline_semaphore
+
+  IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkGetSemaphoreCounterValueKHR, VkDevice device,
+                                VkSemaphore semaphore, uint64_t *pValue);
+
+  IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkWaitSemaphoresKHR, VkDevice device,
+                                const VkSemaphoreWaitInfoKHR *pWaitInfo, uint64_t timeout);
+
+  IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkSignalSemaphoreKHR, VkDevice device,
+                                const VkSemaphoreSignalInfoKHR *pSignalInfo);
 };
@@ -451,7 +451,8 @@
  DeclExt(KHR_pipeline_executable_properties);  \
  DeclExt(AMD_negative_viewport_height);        \
  DeclExt(EXT_line_rasterization);              \
-  DeclExt(GOOGLE_display_timing);
+  DeclExt(GOOGLE_display_timing);               \
+  DeclExt(KHR_timeline_semaphore);

 // for simplicity and since the check itself is platform agnostic,
 // these aren't protected in platform defines
@@ -536,7 +537,8 @@
  CheckExt(KHR_pipeline_executable_properties, VKXX); \
  CheckExt(AMD_negative_viewport_height, VKXX);       \
  CheckExt(EXT_line_rasterization, VKXX);             \
-  CheckExt(GOOGLE_display_timing, VKXX);
+  CheckExt(GOOGLE_display_timing, VKXX);              \
+  CheckExt(KHR_timeline_semaphore, VKXX);

 #define HookInitVulkanInstanceExts()                                                                 \
  HookInitExtension(KHR_surface, DestroySurfaceKHR);                                                 \
@@ -682,6 +684,9 @@
  HookInitExtension(EXT_line_rasterization, CmdSetLineStippleEXT);                                 \
  HookInitExtension(GOOGLE_display_timing, GetRefreshCycleDurationGOOGLE);                         \
  HookInitExtension(GOOGLE_display_timing, GetPastPresentationTimingGOOGLE);                       \
+  HookInitExtension(KHR_timeline_semaphore, GetSemaphoreCounterValueKHR);                          \
+  HookInitExtension(KHR_timeline_semaphore, WaitSemaphoresKHR);                                    \
+  HookInitExtension(KHR_timeline_semaphore, SignalSemaphoreKHR);                                   \
  HookInitDevice_PlatformSpecific()

 #define DefineHooks()                                                                                \
@@ -1278,4 +1283,10 @@
  HookDefine4(VkResult, vkGetPastPresentationTimingGOOGLE, VkDevice, device, VkSwapchainKHR,         \
              swapchain, uint32_t *, pPresentationTimingCount, VkPastPresentationTimingGOOGLE *,     \
              pPresentationTimings);                                                                 \
+  HookDefine3(VkResult, vkGetSemaphoreCounterValueKHR, VkDevice, device, VkSemaphore, semaphore,     \
+              uint64_t *, pValue);                                                                   \
+  HookDefine3(VkResult, vkWaitSemaphoresKHR, VkDevice, device, const VkSemaphoreWaitInfoKHR *,       \
+              pWaitInfo, uint64_t, timeout);                                                         \
+  HookDefine2(VkResult, vkSignalSemaphoreKHR, VkDevice, device, const VkSemaphoreSignalInfoKHR *,    \
+              pSignalInfo);                                                                          \
  HookDefine_PlatformSpecific()
@@ -891,6 +891,17 @@ SERIALISE_VK_HANDLES();
  PNEXT_STRUCT(VK_STRUCTURE_TYPE_PRESENT_INFO_KHR, VkPresentInfoKHR)                                   \
  PNEXT_STRUCT(VK_STRUCTURE_TYPE_ACQUIRE_NEXT_IMAGE_INFO_KHR, VkAcquireNextImageInfoKHR)               \
                                                                                                       \
+  /* VK_KHR_timeline_semaphore */                                                                      \
+  PNEXT_STRUCT(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES_KHR,                      \
+               VkPhysicalDeviceTimelineSemaphoreFeaturesKHR)                                           \
+  PNEXT_STRUCT(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES_KHR,                    \
+               VkPhysicalDeviceTimelineSemaphorePropertiesKHR)                                         \
+  PNEXT_STRUCT(VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO_KHR, VkSemaphoreTypeCreateInfoKHR)         \
+  PNEXT_STRUCT(VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO_KHR,                                   \
+               VkTimelineSemaphoreSubmitInfoKHR)                                                       \
+  PNEXT_STRUCT(VK_STRUCTURE_TYPE_SEMAPHORE_WAIT_INFO_KHR, VkSemaphoreWaitInfoKHR)                      \
+  PNEXT_STRUCT(VK_STRUCTURE_TYPE_SEMAPHORE_SIGNAL_INFO_KHR, VkSemaphoreSignalInfoKHR)                  \
+                                                                                                       \
  /* VK_KHR_uniform_buffer_standard_layout */                                                          \
  PNEXT_STRUCT(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES_KHR,          \
               VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR)                                 \
@@ -991,14 +1002,6 @@ SERIALISE_VK_HANDLES();
  /* VK_EXT_texture_compression_astc_hdr */                                                            \
  PNEXT_UNSUPPORTED(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES_EXT)       \
                                                                                                       \
-  /* VK_KHR_timeline_semaphore */                                                                      \
-  PNEXT_UNSUPPORTED(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES_KHR)                 \
-  PNEXT_UNSUPPORTED(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES_KHR)               \
-  PNEXT_UNSUPPORTED(VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO_KHR)                                  \
-  PNEXT_UNSUPPORTED(VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO_KHR)                              \
-  PNEXT_UNSUPPORTED(VK_STRUCTURE_TYPE_SEMAPHORE_WAIT_INFO_KHR)                                         \
-  PNEXT_UNSUPPORTED(VK_STRUCTURE_TYPE_SEMAPHORE_SIGNAL_INFO_KHR)                                       \
-                                                                                                       \
  /* VK_INTEL_performance_query */                                                                     \
  PNEXT_UNSUPPORTED(VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO_INTEL)                                    \
  PNEXT_UNSUPPORTED(VK_STRUCTURE_TYPE_INITIALIZE_PERFORMANCE_API_INFO_INTEL)                           \
@@ -3438,6 +3441,109 @@ void Deserialise(const VkPhysicalDeviceYcbcrImageArraysFeaturesEXT &el)
  DeserialiseNext(el.pNext);
 }

+template <typename SerialiserType>
+void DoSerialise(SerialiserType &ser, VkPhysicalDeviceTimelineSemaphoreFeaturesKHR &el)
+{
+  RDCASSERT(ser.IsReading() ||
+            el.sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES_KHR);
+  SerialiseNext(ser, el.sType, el.pNext);
+
+  SERIALISE_MEMBER(timelineSemaphore);
+}
+
+template <>
+void Deserialise(const VkPhysicalDeviceTimelineSemaphoreFeaturesKHR &el)
+{
+  DeserialiseNext(el.pNext);
+}
+
+template <typename SerialiserType>
+void DoSerialise(SerialiserType &ser, VkPhysicalDeviceTimelineSemaphorePropertiesKHR &el)
+{
+  RDCASSERT(ser.IsReading() ||
+            el.sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES_KHR);
+  SerialiseNext(ser, el.sType, el.pNext);
+
+  SERIALISE_MEMBER(maxTimelineSemaphoreValueDifference);
+}
+
+template <>
+void Deserialise(const VkPhysicalDeviceTimelineSemaphorePropertiesKHR &el)
+{
+  DeserialiseNext(el.pNext);
+}
+
+template <typename SerialiserType>
+void DoSerialise(SerialiserType &ser, VkSemaphoreTypeCreateInfoKHR &el)
+{
+  RDCASSERT(ser.IsReading() || el.sType == VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO_KHR);
+  SerialiseNext(ser, el.sType, el.pNext);
+
+  SERIALISE_MEMBER(semaphoreType);
+  SERIALISE_MEMBER(initialValue);
+}
+
+template <>
+void Deserialise(const VkSemaphoreTypeCreateInfoKHR &el)
+{
+  DeserialiseNext(el.pNext);
+}
+
+template <typename SerialiserType>
+void DoSerialise(SerialiserType &ser, VkTimelineSemaphoreSubmitInfoKHR &el)
+{
+  RDCASSERT(ser.IsReading() || el.sType == VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO_KHR);
+  SerialiseNext(ser, el.sType, el.pNext);
+
+  SERIALISE_MEMBER(waitSemaphoreValueCount);
+  SERIALISE_MEMBER_ARRAY(pWaitSemaphoreValues, waitSemaphoreValueCount);
+  SERIALISE_MEMBER(signalSemaphoreValueCount);
+  SERIALISE_MEMBER_ARRAY(pSignalSemaphoreValues, signalSemaphoreValueCount);
+}
+
+template <>
+void Deserialise(const VkTimelineSemaphoreSubmitInfoKHR &el)
+{
+  DeserialiseNext(el.pNext);
+  delete[] el.pWaitSemaphoreValues;
+  delete[] el.pSignalSemaphoreValues;
+}
+
+template <typename SerialiserType>
+void DoSerialise(SerialiserType &ser, VkSemaphoreWaitInfoKHR &el)
+{
+  RDCASSERT(ser.IsReading() || el.sType == VK_STRUCTURE_TYPE_SEMAPHORE_WAIT_INFO_KHR);
+  SerialiseNext(ser, el.sType, el.pNext);
+
+  SERIALISE_MEMBER(semaphoreCount);
+  SERIALISE_MEMBER_ARRAY(pSemaphores, semaphoreCount);
+  SERIALISE_MEMBER_ARRAY(pValues, semaphoreCount);
+}
+
+template <>
+void Deserialise(const VkSemaphoreWaitInfoKHR &el)
+{
+  DeserialiseNext(el.pNext);
+  delete[] el.pSemaphores;
+  delete[] el.pValues;
+}
+
+template <typename SerialiserType>
+void DoSerialise(SerialiserType &ser, VkSemaphoreSignalInfoKHR &el)
+{
+  RDCASSERT(ser.IsReading() || el.sType == VK_STRUCTURE_TYPE_SEMAPHORE_SIGNAL_INFO_KHR);
+  SerialiseNext(ser, el.sType, el.pNext);
+
+  SERIALISE_MEMBER(semaphore);
+  SERIALISE_MEMBER(value);
+}
+
+template <>
+void Deserialise(const VkSemaphoreSignalInfoKHR &el)
+{
+  DeserialiseNext(el.pNext);
+}
+
 template <typename SerialiserType>
 void DoSerialise(SerialiserType &ser, VkDebugMarkerMarkerInfoEXT &el)
 {
@@ -7577,6 +7683,8 @@ INSTANTIATE_SERIALISE_TYPE(VkPhysicalDeviceSubgroupSizeControlPropertiesEXT);
 INSTANTIATE_SERIALISE_TYPE(VkPhysicalDeviceSurfaceInfo2KHR);
 INSTANTIATE_SERIALISE_TYPE(VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT);
 INSTANTIATE_SERIALISE_TYPE(VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT);
+INSTANTIATE_SERIALISE_TYPE(VkPhysicalDeviceTimelineSemaphoreFeaturesKHR);
+INSTANTIATE_SERIALISE_TYPE(VkPhysicalDeviceTimelineSemaphorePropertiesKHR);
 INSTANTIATE_SERIALISE_TYPE(VkPhysicalDeviceTransformFeedbackFeaturesEXT);
 INSTANTIATE_SERIALISE_TYPE(VkPhysicalDeviceTransformFeedbackPropertiesEXT);
 INSTANTIATE_SERIALISE_TYPE(VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR);
@@ -7636,6 +7744,9 @@ INSTANTIATE_SERIALISE_TYPE(VkSamplerYcbcrConversionImageFormatProperties);
 INSTANTIATE_SERIALISE_TYPE(VkSamplerYcbcrConversionInfo);
 INSTANTIATE_SERIALISE_TYPE(VkSemaphoreCreateInfo);
 INSTANTIATE_SERIALISE_TYPE(VkSemaphoreGetFdInfoKHR);
+INSTANTIATE_SERIALISE_TYPE(VkSemaphoreSignalInfoKHR);
+INSTANTIATE_SERIALISE_TYPE(VkSemaphoreTypeCreateInfoKHR);
+INSTANTIATE_SERIALISE_TYPE(VkSemaphoreWaitInfoKHR);
 INSTANTIATE_SERIALISE_TYPE(VkShaderModuleCreateInfo);
 INSTANTIATE_SERIALISE_TYPE(VkShaderModuleValidationCacheCreateInfoEXT);
 INSTANTIATE_SERIALISE_TYPE(VkSharedPresentSurfaceCapabilitiesKHR);
@@ -7656,6 +7767,7 @@ INSTANTIATE_SERIALISE_TYPE(VkSwapchainCounterCreateInfoEXT);
 INSTANTIATE_SERIALISE_TYPE(VkSwapchainCreateInfoKHR);
 INSTANTIATE_SERIALISE_TYPE(VkSwapchainDisplayNativeHdrCreateInfoAMD);
 INSTANTIATE_SERIALISE_TYPE(VkTextureLODGatherFormatPropertiesAMD);
+INSTANTIATE_SERIALISE_TYPE(VkTimelineSemaphoreSubmitInfoKHR);
 INSTANTIATE_SERIALISE_TYPE(VkValidationCacheCreateInfoEXT);
 INSTANTIATE_SERIALISE_TYPE(VkValidationFeaturesEXT);
 INSTANTIATE_SERIALISE_TYPE(VkValidationFlagsEXT);
@@ -28,7 +28,7 @@
 template <>
 rdcstr DoStringise(const VulkanChunk &el)
 {
-  RDCCOMPILE_ASSERT((uint32_t)VulkanChunk::Max == 1136, "Chunks changed without updating names");
+  RDCCOMPILE_ASSERT((uint32_t)VulkanChunk::Max == 1139, "Chunks changed without updating names");

  BEGIN_ENUM_STRINGISE(VulkanChunk)
  {
@@ -168,6 +168,9 @@ rdcstr DoStringise(const VulkanChunk &el)
    STRINGISE_ENUM_CLASS(vkResetQueryPoolEXT);
    STRINGISE_ENUM_CLASS_NAMED(ImageRefs, "Image References")
    STRINGISE_ENUM_CLASS(vkCmdSetLineStippleEXT);
+    STRINGISE_ENUM_CLASS(vkGetSemaphoreCounterValueKHR);
+    STRINGISE_ENUM_CLASS(vkWaitSemaphoresKHR);
+    STRINGISE_ENUM_CLASS(vkSignalSemaphoreKHR);
    STRINGISE_ENUM_CLASS_NAMED(Max, "Max Chunk");
  }
  END_ENUM_STRINGISE()
@@ -2322,6 +2322,13 @@ bool WrappedVulkan::Serialise_vkCreateDevice(SerialiserType &ser, VkPhysicalDevi
        CHECK_PHYS_EXT_FEATURE(shaderInt8);
      }
      END_PHYS_EXT_CHECK();
+
+      BEGIN_PHYS_EXT_CHECK(VkPhysicalDeviceTimelineSemaphoreFeaturesKHR,
+                           VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES_KHR);
+      {
+        CHECK_PHYS_EXT_FEATURE(timelineSemaphore);
+      }
+      END_PHYS_EXT_CHECK();
    }

    if(availFeatures.depthClamp)
@@ -1653,4 +1653,4 @@ INSTANTIATE_FUNCTION_SERIALISED(void, vkQueueInsertDebugUtilsLabelEXT, VkQueue q
                                const VkDebugUtilsLabelEXT *pLabelInfo);

 INSTANTIATE_FUNCTION_SERIALISED(void, vkGetDeviceQueue2, VkDevice device,
-                                const VkDeviceQueueInfo2 *pQueueInfo, VkQueue *pQueue);
+                                const VkDeviceQueueInfo2 *pQueueInfo, VkQueue *pQueue);
@@ -937,6 +937,146 @@ VkResult WrappedVulkan::vkGetFenceFdKHR(VkDevice device, const VkFenceGetFdInfoK
  return ObjDisp(device)->GetFenceFdKHR(Unwrap(device), &unwrappedInfo, pFd);
 }

+template <typename SerialiserType>
+bool WrappedVulkan::Serialise_vkGetSemaphoreCounterValueKHR(SerialiserType &ser, VkDevice device,
+                                                            VkSemaphore semaphore, uint64_t *pValue)
+{
+  SERIALISE_ELEMENT(device);
+  SERIALISE_ELEMENT(semaphore);
+  SERIALISE_ELEMENT_OPT(pValue);
+
+  Serialise_DebugMessages(ser);
+
+  SERIALISE_CHECK_READ_ERRORS();
+
+  if(IsReplayingAndReading())
+  {
+    ObjDisp(device)->DeviceWaitIdle(Unwrap(device));
+  }
+
+  return true;
+}
+
+VkResult WrappedVulkan::vkGetSemaphoreCounterValueKHR(VkDevice device, VkSemaphore semaphore,
+                                                      uint64_t *pValue)
+{
+  SCOPED_DBG_SINK();
+
+  VkResult ret;
+  SERIALISE_TIME_CALL(ret = ObjDisp(device)->GetSemaphoreCounterValueKHR(
+                          Unwrap(device), Unwrap(semaphore), pValue));
+
+  if(IsActiveCapturing(m_State))
+  {
+    CACHE_THREAD_SERIALISER();
+
+    SCOPED_SERIALISE_CHUNK(VulkanChunk::vkGetSemaphoreCounterValueKHR);
+    Serialise_vkGetSemaphoreCounterValueKHR(ser, device, semaphore, pValue);
+
+    m_FrameCaptureRecord->AddChunk(scope.Get());
+    GetResourceManager()->MarkResourceFrameReferenced(GetResID(semaphore), eFrameRef_Read);
+  }
+
+  return ret;
+}
+
+template <typename SerialiserType>
+bool WrappedVulkan::Serialise_vkWaitSemaphoresKHR(SerialiserType &ser, VkDevice device,
+                                                  const VkSemaphoreWaitInfoKHR *pWaitInfo,
+                                                  uint64_t timeout)
+{
+  SERIALISE_ELEMENT(device);
+  SERIALISE_ELEMENT_LOCAL(WaitInfo, *pWaitInfo);
+  SERIALISE_ELEMENT(timeout);
+
+  Serialise_DebugMessages(ser);
+
+  SERIALISE_CHECK_READ_ERRORS();
+
+  if(IsReplayingAndReading())
+  {
+    ObjDisp(device)->DeviceWaitIdle(Unwrap(device));
+  }
+
+  return true;
+}
+
+VkResult WrappedVulkan::vkWaitSemaphoresKHR(VkDevice device, const VkSemaphoreWaitInfoKHR *pWaitInfo,
+                                            uint64_t timeout)
+{
+  SCOPED_DBG_SINK();
+
+  VkSemaphore *unwrappedSems = GetTempArray<VkSemaphore>(pWaitInfo->semaphoreCount);
+  for(uint32_t i = 0; i < pWaitInfo->semaphoreCount; i++)
+    unwrappedSems[i] = Unwrap(pWaitInfo->pSemaphores[i]);
+
+  VkSemaphoreWaitInfoKHR unwrapped = *pWaitInfo;
+  unwrapped.pSemaphores = unwrappedSems;
+
+  VkResult ret;
+  SERIALISE_TIME_CALL(ret = ObjDisp(device)->WaitSemaphoresKHR(Unwrap(device), &unwrapped, timeout));
+
+  if(IsActiveCapturing(m_State))
+  {
+    CACHE_THREAD_SERIALISER();
+
+    SCOPED_SERIALISE_CHUNK(VulkanChunk::vkWaitSemaphoresKHR);
+    Serialise_vkWaitSemaphoresKHR(ser, device, pWaitInfo, timeout);
+
+    m_FrameCaptureRecord->AddChunk(scope.Get());
+    for(uint32_t i = 0; i < pWaitInfo->semaphoreCount; i++)
+      GetResourceManager()->MarkResourceFrameReferenced(GetResID(pWaitInfo->pSemaphores[i]),
+                                                        eFrameRef_Read);
+  }
+
+  return ret;
+}
+
+template <typename SerialiserType>
+bool WrappedVulkan::Serialise_vkSignalSemaphoreKHR(SerialiserType &ser, VkDevice device,
+                                                   const VkSemaphoreSignalInfoKHR *pSignalInfo)
+{
+  SERIALISE_ELEMENT(device);
+  SERIALISE_ELEMENT_LOCAL(SignalInfo, *pSignalInfo);
+
+  Serialise_DebugMessages(ser);
+
+  SERIALISE_CHECK_READ_ERRORS();
+
+  if(IsReplayingAndReading())
+  {
+    ObjDisp(device)->DeviceWaitIdle(Unwrap(device));
+  }
+
+  return true;
+}
+
+VkResult WrappedVulkan::vkSignalSemaphoreKHR(VkDevice device,
+                                             const VkSemaphoreSignalInfoKHR *pSignalInfo)
+{
+  VkSemaphoreSignalInfoKHR unwrapped = *pSignalInfo;
+  unwrapped.semaphore = Unwrap(unwrapped.semaphore);
+
+  SCOPED_DBG_SINK();
+
+  VkResult ret;
+  SERIALISE_TIME_CALL(ret = ObjDisp(device)->SignalSemaphoreKHR(Unwrap(device), &unwrapped));
+
+  if(IsActiveCapturing(m_State))
+  {
+    CACHE_THREAD_SERIALISER();
+
+    SCOPED_SERIALISE_CHUNK(VulkanChunk::vkSignalSemaphoreKHR);
+    Serialise_vkSignalSemaphoreKHR(ser, device, pSignalInfo);
+
+    m_FrameCaptureRecord->AddChunk(scope.Get());
+    GetResourceManager()->MarkResourceFrameReferenced(GetResID(pSignalInfo->semaphore),
+                                                      eFrameRef_Read);
+  }
+
+  return ret;
+}
+
 #if defined(VK_USE_PLATFORM_WIN32_KHR)

 VkResult WrappedVulkan::vkImportSemaphoreWin32HandleKHR(
@@ -1015,3 +1155,12 @@ INSTANTIATE_FUNCTION_SERIALISED(void, vkCmdWaitEvents, VkCommandBuffer commandBu
                                const VkBufferMemoryBarrier *pBufferMemoryBarriers,
                                uint32_t imageMemoryBarrierCount,
                                const VkImageMemoryBarrier *pImageMemoryBarriers);
+
+INSTANTIATE_FUNCTION_SERIALISED(void, vkGetSemaphoreCounterValueKHR, VkDevice device,
+                                VkSemaphore semaphore, uint64_t *pValue);
+
+INSTANTIATE_FUNCTION_SERIALISED(void, vkWaitSemaphoresKHR, VkDevice device,
+                                const VkSemaphoreWaitInfoKHR *pWaitInfo, uint64_t timeout);
+
+INSTANTIATE_FUNCTION_SERIALISED(void, vkSignalSemaphoreKHR, VkDevice device,
+                                const VkSemaphoreSignalInfoKHR *pSignalInfo);