Metal extra capture apis stub replay

renderdoc/CMakeLists.txt

@@ -419,7 +419,7 @@ if(CMAKE_COMPILER_IS_GNUCXX OR CMAKE_CXX_COMPILER_ID MATCHES "Clang" OR APPLE)
             APPEND_STRING PROPERTY COMPILE_FLAGS " -Wno-unknown-warning -Wno-format-truncation")
 
     	# stb_image requires these flags to enable ARM SIMD (NEON) for arm32
-        if (CMAKE_SYSTEM_PROCESSOR MATCHES "arm" AND NOT CMAKE_SYSTEM_PROCESSOR MATCHES "aarch64")
+        if (CMAKE_SYSTEM_PROCESSOR MATCHES "arm" AND NOT CMAKE_SYSTEM_PROCESSOR MATCHES "aarch64" AND NOT CMAKE_SYSTEM_PROCESSOR MATCHES "arm64")
             set_source_files_properties(3rdparty/stb/stb_impl.c
                 PROPERTIES COMPILE_FLAGS "-mfpu=neon-vfpv4 -mfp16-format=ieee")
         endif()
@@ -446,7 +446,7 @@ if(CMAKE_COMPILER_IS_GNUCXX OR CMAKE_CXX_COMPILER_ID MATCHES "Clang" OR APPLE)
             PROPERTIES COMPILE_FLAGS "-Wno-unknown-warning-option -Wno-self-assign-overloaded")
 
         # stb_image requires these flags to enable ARM SIMD (NEON) for arm32
-        if (CMAKE_SYSTEM_PROCESSOR MATCHES "arm" AND NOT CMAKE_SYSTEM_PROCESSOR MATCHES "aarch64")
+        if (CMAKE_SYSTEM_PROCESSOR MATCHES "arm" AND NOT CMAKE_SYSTEM_PROCESSOR MATCHES "aarch64" AND NOT CMAKE_SYSTEM_PROCESSOR MATCHES "arm64")
             set_source_files_properties(3rdparty/stb/stb_impl.c
                         PROPERTIES COMPILE_FLAGS "-mfpu=neon-vfpv4")
         endif()

renderdoc/driver/metal/metal_blit_command_encoder.cpp

@@ -82,6 +82,25 @@ bool WrappedMTLBlitCommandEncoder::Serialise_endEncoding(SerialiserType &ser)
   // TODO: implement RD MTL replay
   if(IsReplayingAndReading())
   {
+    m_Device->SetCurrentCommandBuffer(BlitCommandEncoder->m_CommandBuffer);
+    if(IsLoading(m_State))
+    {
+      AddEvent();
+
+      ActionDescription action;
+      action.flags |= ActionFlags::PassBoundary;
+      action.flags |= ActionFlags::EndPass;
+
+      AddAction(action);
+    }
+    if(IsActiveReplaying(m_State))
+    {
+      if(!m_Device->IsCurrentCommandBufferEventInReplayRange())
+        return true;
+    }
+    WrappedMTLBlitCommandEncoder *blitEncoder = m_Device->GetCurrentReplayBlitEncoder();
+    Unwrap(blitEncoder)->endEncoding();
+    m_Device->ClearActiveBlitCommandEncoder();
   }
   return true;
 }
@@ -231,6 +250,14 @@ bool WrappedMTLBlitCommandEncoder::Serialise_synchronizeResource(SerialiserType
   // TODO: implement RD MTL replay
   if(IsReplayingAndReading())
   {
+    m_Device->SetCurrentCommandBuffer(BlitCommandEncoder->m_CommandBuffer);
+    if(IsActiveReplaying(m_State))
+    {
+      if(!m_Device->IsCurrentCommandBufferEventInReplayRange())
+        return true;
+    }
+    WrappedMTLBlitCommandEncoder *blitEncoder = m_Device->GetCurrentReplayBlitEncoder();
+    Unwrap(blitEncoder)->synchronizeResource(Unwrap(resource));
   }
   return true;
 }

renderdoc/driver/metal/metal_command_buffer.cpp

@@ -41,15 +41,38 @@ template <typename SerialiserType>
 bool WrappedMTLCommandBuffer::Serialise_blitCommandEncoder(SerialiserType &ser,
                                                            WrappedMTLBlitCommandEncoder *encoder)
 {
-  SERIALISE_ELEMENT_LOCAL(CommandBuffer, this);
+  SERIALISE_ELEMENT_LOCAL(CommandBuffer, this).Unimportant();
   SERIALISE_ELEMENT_LOCAL(BlitCommandEncoder, GetResID(encoder))
       .TypedAs("MTLBlitCommandEncoder"_lit);
 
   SERIALISE_CHECK_READ_ERRORS();
 
   if(IsReplayingAndReading())
   {
-    // TODO: implement RD MTL replay
+    m_Device->SetCurrentCommandBuffer(CommandBuffer);
+    if(IsActiveReplaying(m_State))
+    {
+      if(!m_Device->IsCurrentCommandBufferEventInReplayRange())
+        return true;
+    }
+    if(IsLoading(m_State))
+    {
+      AddEvent();
+
+      ActionDescription action;
+      action.flags |= ActionFlags::PassBoundary;
+      action.flags |= ActionFlags::BeginPass;
+
+      AddAction(action);
+    }
+    WrappedMTLCommandBuffer *cmdBuffer = m_Device->GetCurrentReplayCommandBuffer();
+    MTL::BlitCommandEncoder *mtlBlitCommandEncoder = Unwrap(cmdBuffer)->blitCommandEncoder();
+    WrappedMTLBlitCommandEncoder *wrappedMTLBlitCommandEncoder;
+    ResourceId liveID =
+        GetResourceManager()->WrapResource(mtlBlitCommandEncoder, wrappedMTLBlitCommandEncoder);
+    wrappedMTLBlitCommandEncoder->SetCommandBuffer(cmdBuffer);
+    m_Device->SetActiveBlitCommandEncoder(wrappedMTLBlitCommandEncoder);
+    // TODO: initialise the replay tracked render state
   }
   return true;
 }
@@ -99,7 +122,33 @@ bool WrappedMTLCommandBuffer::Serialise_renderCommandEncoderWithDescriptor(
 
   if(IsReplayingAndReading())
   {
-    // TODO: implement RD MTL replay
+    m_Device->SetCurrentCommandBuffer(CommandBuffer);
+    if(IsActiveReplaying(m_State))
+    {
+      if(!m_Device->IsCurrentCommandBufferEventInReplayRange())
+        return true;
+    }
+    if(IsLoading(m_State))
+    {
+      AddEvent();
+
+      ActionDescription action;
+      action.flags |= ActionFlags::PassBoundary;
+      action.flags |= ActionFlags::BeginPass;
+
+      AddAction(action);
+    }
+    WrappedMTLCommandBuffer *cmdBuffer = m_Device->GetCurrentReplayCommandBuffer();
+    MTL::RenderPassDescriptor *mtlDescriptor(descriptor);
+    MTL::RenderCommandEncoder *mtlRenderCommandEncoder =
+        Unwrap(cmdBuffer)->renderCommandEncoder(mtlDescriptor);
+    mtlDescriptor->release();
+    WrappedMTLRenderCommandEncoder *wrappedMTLRenderCommandEncoder;
+    ResourceId liveID =
+        GetResourceManager()->WrapResource(mtlRenderCommandEncoder, wrappedMTLRenderCommandEncoder);
+    wrappedMTLRenderCommandEncoder->SetCommandBuffer(cmdBuffer);
+    m_Device->SetActiveRenderCommandEncoder(wrappedMTLRenderCommandEncoder);
+    // TODO: initialise the replay tracked render state
   }
   return true;
 }
@@ -160,6 +209,7 @@ bool WrappedMTLCommandBuffer::Serialise_presentDrawable(SerialiserType &ser,
   // TODO: implement RD MTL replay
   if(IsReplayingAndReading())
   {
+    m_Device->SetCurrentCommandBuffer(CommandBuffer);
     if(IsLoading(m_State))
     {
       AddEvent();
@@ -172,6 +222,11 @@ bool WrappedMTLCommandBuffer::Serialise_presentDrawable(SerialiserType &ser,
       m_Device->SetLastPresentedIamge(presentedImageId);
       AddAction(action);
     }
+    if(IsActiveReplaying(m_State))
+    {
+      if(!m_Device->IsCurrentCommandBufferEventInReplayRange())
+        return true;
+    }
   }
   return true;
 }
@@ -219,7 +274,9 @@ bool WrappedMTLCommandBuffer::Serialise_commit(SerialiserType &ser)
   // TODO: implement RD MTL replay
   if(IsReplayingAndReading())
   {
-    CommandBuffer->commit();
+    m_Device->SetCurrentCommandBuffer(CommandBuffer);
+    WrappedMTLCommandBuffer *cmdBuffer = m_Device->GetCurrentReplayCommandBuffer();
+    m_Device->ReplayCommandBufferCommit(cmdBuffer);
   }
   return true;
 }
@@ -254,6 +311,9 @@ bool WrappedMTLCommandBuffer::Serialise_enqueue(SerialiserType &ser)
   // TODO: implement RD MTL replay
   if(IsReplayingAndReading())
   {
+    m_Device->SetCurrentCommandBuffer(CommandBuffer);
+    WrappedMTLCommandBuffer *cmdBuffer = m_Device->GetCurrentReplayCommandBuffer();
+    m_Device->ReplayCommandBufferEnqueue(cmdBuffer);
   }
   return true;
 }
@@ -290,6 +350,11 @@ bool WrappedMTLCommandBuffer::Serialise_waitUntilCompleted(SerialiserType &ser)
   // TODO: implement RD MTL replay
   if(IsReplayingAndReading())
   {
+    m_Device->SetCurrentCommandBuffer(NULL);
+    if(IsActiveReplaying(m_State))
+    {
+      Unwrap(CommandBuffer)->waitUntilCompleted();
+    }
   }
   return true;
 }

renderdoc/driver/metal/metal_command_queue.cpp

@@ -45,7 +45,20 @@ bool WrappedMTLCommandQueue::Serialise_commandBuffer(SerialiserType &ser,
 
   if(IsReplayingAndReading())
   {
-    // TODO: implement RD MTL replay
+    WrappedMTLCommandBuffer *wrappedMTLCommandBuffer = m_Device->GetNextCommandBuffer();
+    GetResourceManager()->ReplaceResource(CommandBuffer, GetResID(wrappedMTLCommandBuffer));
+
+    m_Device->AddResource(CommandBuffer, ResourceType::CommandBuffer, "Command Buffer");
+    m_Device->DerivedResource(CommandQueue, CommandBuffer);
+    m_Device->SetCurrentCommandBuffer(wrappedMTLCommandBuffer);
+    if(IsLoading(m_State))
+    {
+      m_Device->NewReplayCommandBuffer(wrappedMTLCommandBuffer);
+    }
+    else
+    {
+      m_Device->ResetReplayCommandBuffer(wrappedMTLCommandBuffer);
+    }
   }
   return true;
 }

renderdoc/driver/metal/metal_core.cpp

@@ -249,7 +249,11 @@ bool WrappedMTLDevice::ProcessChunk(ReadSerialiser &ser, MetalChunk chunk)
     case MetalChunk::MTLRenderCommandEncoder_setViewports: METAL_CHUNK_NOT_HANDLED();
     case MetalChunk::MTLRenderCommandEncoder_setFrontFacingWinding: METAL_CHUNK_NOT_HANDLED();
     case MetalChunk::MTLRenderCommandEncoder_setVertexAmplificationCount: METAL_CHUNK_NOT_HANDLED();
-    case MetalChunk::MTLRenderCommandEncoder_setCullMode: METAL_CHUNK_NOT_HANDLED();
+    case MetalChunk::MTLRenderCommandEncoder_setCullMode:
+    {
+      MTL::CullMode cullMode;
+      return m_DummyReplayRenderCommandEncoder->Serialise_setCullMode(ser, cullMode);
+    }
     case MetalChunk::MTLRenderCommandEncoder_setDepthClipMode: METAL_CHUNK_NOT_HANDLED();
     case MetalChunk::MTLRenderCommandEncoder_setDepthBias: METAL_CHUNK_NOT_HANDLED();
     case MetalChunk::MTLRenderCommandEncoder_setScissorRect: METAL_CHUNK_NOT_HANDLED();
@@ -298,11 +302,11 @@ bool WrappedMTLDevice::ProcessChunk(ReadSerialiser &ser, MetalChunk chunk)
       return m_DummyReplayRenderCommandEncoder->Serialise_drawPrimitives(
           ser, MTL::PrimitiveTypePoint, 0, 0, 0, 0);
     case MetalChunk::MTLRenderCommandEncoder_drawPrimitives_indirect: METAL_CHUNK_NOT_HANDLED();
-    case MetalChunk::MTLRenderCommandEncoder_drawIndexedPrimitives: METAL_CHUNK_NOT_HANDLED();
+    case MetalChunk::MTLRenderCommandEncoder_drawIndexedPrimitives:
     case MetalChunk::MTLRenderCommandEncoder_drawIndexedPrimitives_instanced:
-      METAL_CHUNK_NOT_HANDLED();
     case MetalChunk::MTLRenderCommandEncoder_drawIndexedPrimitives_instanced_base:
-      METAL_CHUNK_NOT_HANDLED();
+      return m_DummyReplayRenderCommandEncoder->Serialise_drawIndexedPrimitives(
+          ser, MTL::PrimitiveTypePoint, 0, MTL::IndexTypeUInt16, NULL, 0, 0, 0, 0);
     case MetalChunk::MTLRenderCommandEncoder_drawIndexedPrimitives_indirect:
       METAL_CHUNK_NOT_HANDLED();
     case MetalChunk::MTLRenderCommandEncoder_textureBarrier: METAL_CHUNK_NOT_HANDLED();
@@ -473,6 +477,11 @@ bool WrappedMTLDevice::ProcessChunk(ReadSerialiser &ser, MetalChunk chunk)
   return true;
 }
 
+WrappedMTLCommandBuffer *WrappedMTLDevice::GetNextCommandBuffer()
+{
+  METAL_NOT_IMPLEMENTED();
+  return NULL;
+}
 void WrappedMTLDevice::AddResource(ResourceId id, ResourceType type, const char *defaultNamePrefix)
 {
   ResourceDescription &descr = GetReplay()->GetResourceDesc(id);
@@ -487,7 +496,7 @@ void WrappedMTLDevice::AddResource(ResourceId id, ResourceType type, const char
 
 void WrappedMTLDevice::DerivedResource(ResourceId parentLive, ResourceId child)
 {
-  ResourceId parentId = GetResourceManager()->GetOriginalID(parentLive);
+  ResourceId parentId = GetResourceManager()->GetUnreplacedOriginalID(parentLive);
 
   GetReplay()->GetResourceDesc(parentId).derivedResources.push_back(child);
   GetReplay()->GetResourceDesc(child).parentResources.push_back(parentId);
@@ -1068,6 +1077,75 @@ MetalDrawableInfo WrappedMTLDevice::UnregisterDrawableInfo(MTL::Drawable *mtlDra
   return drawableInfo;
 }
 
+void WrappedMTLDevice::ClearActiveRenderCommandEncoder()
+{
+  METAL_NOT_IMPLEMENTED();
+}
+
+void WrappedMTLDevice::SetActiveRenderCommandEncoder(WrappedMTLRenderCommandEncoder *renderCommandEncoder)
+{
+  METAL_NOT_IMPLEMENTED();
+}
+
+WrappedMTLRenderCommandEncoder *WrappedMTLDevice::GetCurrentReplayRenderEncoder()
+{
+  METAL_NOT_IMPLEMENTED();
+  return NULL;
+}
+
+void WrappedMTLDevice::ClearActiveBlitCommandEncoder()
+{
+  METAL_NOT_IMPLEMENTED();
+}
+
+void WrappedMTLDevice::SetActiveBlitCommandEncoder(WrappedMTLBlitCommandEncoder *blitCommandEncoder)
+{
+  METAL_NOT_IMPLEMENTED();
+}
+
+WrappedMTLBlitCommandEncoder *WrappedMTLDevice::GetCurrentReplayBlitEncoder()
+{
+  METAL_NOT_IMPLEMENTED();
+  return NULL;
+}
+
+WrappedMTLCommandBuffer *WrappedMTLDevice::GetCurrentReplayCommandBuffer()
+{
+  METAL_NOT_IMPLEMENTED();
+  return NULL;
+}
+
+bool WrappedMTLDevice::IsCurrentCommandBufferEventInReplayRange()
+{
+  METAL_NOT_IMPLEMENTED();
+  return false;
+}
+
+void WrappedMTLDevice::NewReplayCommandBuffer(WrappedMTLCommandBuffer *cmdBuffer)
+{
+  METAL_NOT_IMPLEMENTED();
+}
+
+void WrappedMTLDevice::ResetReplayCommandBuffer(WrappedMTLCommandBuffer *cmdBuffer)
+{
+  METAL_NOT_IMPLEMENTED();
+}
+
+void WrappedMTLDevice::ReplayCommandBufferEnqueue(WrappedMTLCommandBuffer *cmdBuffer)
+{
+  METAL_NOT_IMPLEMENTED();
+}
+
+void WrappedMTLDevice::ReplayCommandBufferCommit(WrappedMTLCommandBuffer *cmdBuffer)
+{
+  METAL_NOT_IMPLEMENTED();
+}
+
+void WrappedMTLDevice::SetCurrentCommandBuffer(WrappedMTLCommandBuffer *cmdBuffer)
+{
+  METAL_NOT_IMPLEMENTED();
+}
+
 MetalInitParams::MetalInitParams()
 {
   memset(this, 0, sizeof(MetalInitParams));

renderdoc/driver/metal/metal_device.cpp

@@ -436,6 +436,17 @@ WrappedMTLRenderPipelineState *WrappedMTLDevice::newRenderPipelineStateWithDescr
   SERIALISE_TIME_CALL(realMTLRenderPipelineState =
                           Unwrap(this)->newRenderPipelineState(realDescriptor, error));
   realDescriptor->release();
+  if(!realMTLRenderPipelineState)
+  {
+    if(IsCaptureMode(m_State))
+    {
+      return NULL;
+    }
+    RDCASSERT(error && *error);
+    RDCFATAL("newRenderPipelineStateWithDescriptor() failed\n%s",
+             (*error)->localizedDescription()->utf8String());
+    return NULL;
+  }
 
   WrappedMTLRenderPipelineState *wrappedMTLRenderPipelineState;
   ResourceId id =