Resolve to correct depth slice.

squidbus · squidbus · commit c372d9cef83f · 2025-07-22T10:50:40.000-07:00
diff --git a/MarathonRecomp/gpu/rhi/plume_render_interface_types.h b/MarathonRecomp/gpu/rhi/plume_render_interface_types.h
@@ -1643,6 +1643,7 @@ namespace plume {
         const RenderTexture **colorAttachments = nullptr;
         uint32_t colorAttachmentsCount = 0;
         const RenderTexture *depthAttachment = nullptr;
+        uint32_t depthAttachmentSlice = 0;
         bool depthAttachmentReadOnly = false;
 
         RenderFramebufferDesc() = default;
diff --git a/MarathonRecomp/gpu/rhi/plume_vulkan.cpp b/MarathonRecomp/gpu/rhi/plume_vulkan.cpp
@@ -2465,7 +2465,28 @@ namespace plume {
         if (desc.depthAttachment != nullptr) {
             depthAttachment = static_cast<const VulkanTexture *>(desc.depthAttachment);
             assert((depthAttachment->desc.flags & RenderTextureFlag::DEPTH_TARGET) && "Depth attachment must be a depth target.");
-            imageViews.emplace_back(depthAttachment->imageView);
+            if (desc.depthAttachmentSlice != 0) {
+                VkImageViewCreateInfo viewInfo = {};
+                viewInfo.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;
+                viewInfo.image = depthAttachment->vk;
+                viewInfo.viewType = toImageViewType(RenderTextureViewDimension::TEXTURE_2D, depthAttachment->desc.arraySize);
+                viewInfo.format = toVk(depthAttachment->desc.format);
+                viewInfo.subresourceRange.aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT;
+                viewInfo.subresourceRange.baseMipLevel = 0;
+                viewInfo.subresourceRange.levelCount = 1;
+                viewInfo.subresourceRange.baseArrayLayer = desc.depthAttachmentSlice;
+                viewInfo.subresourceRange.layerCount = 1;
+
+                res = vkCreateImageView(device->vk, &viewInfo, nullptr, &depthAttachmentView);
+                if (res != VK_SUCCESS) {
+                    fprintf(stderr, "vkCreateImageView failed with error code 0x%X.\n", res);
+                    return;
+                }
+
+                imageViews.emplace_back(depthAttachmentView);
+            } else {
+                imageViews.emplace_back(depthAttachment->imageView);
+            }
 
             if (desc.colorAttachmentsCount == 0) {
                 width = uint32_t(depthAttachment->desc.width);
@@ -2536,6 +2557,10 @@ namespace plume {
         if (renderPass != VK_NULL_HANDLE) {
             vkDestroyRenderPass(device->vk, renderPass, nullptr);
         }
+
+        if (depthAttachmentView != VK_NULL_HANDLE) {
+            vkDestroyImageView(device->vk, depthAttachmentView, nullptr);
+        }
     }
 
     uint32_t VulkanFramebuffer::getWidth() const {
diff --git a/MarathonRecomp/gpu/rhi/plume_vulkan.h b/MarathonRecomp/gpu/rhi/plume_vulkan.h
@@ -266,6 +266,7 @@ namespace plume {
         VkRenderPass renderPass = VK_NULL_HANDLE;
         std::vector<const VulkanTexture *> colorAttachments;
         const VulkanTexture *depthAttachment = nullptr;
+        VkImageView depthAttachmentView = VK_NULL_HANDLE;
         bool depthAttachmentReadOnly = false;
         uint32_t width = 0;
         uint32_t height = 0;
diff --git a/MarathonRecomp/gpu/video.cpp b/MarathonRecomp/gpu/video.cpp
@@ -872,6 +872,7 @@ struct RenderCommand
             GuestDevice* device;
             uint32_t flags;
             GuestTexture* texture;
+            uint32_t destSliceOrFace;
         } stretchRect;
 
         struct 
@@ -3221,13 +3222,14 @@ static void FlushViewport()
     }
 }
 
-static void StretchRect(GuestDevice* device, uint32_t flags, uint32_t, GuestTexture* texture)
+static void StretchRect(GuestDevice* device, uint32_t flags, uint32_t, GuestTexture* texture, uint32_t, uint32_t, uint32_t destSliceOrFace)
 {
     // printf("StretchRect %x\n", texture);
     RenderCommand cmd;
     cmd.type = RenderCommandType::StretchRect;
     cmd.stretchRect.flags = flags;
     cmd.stretchRect.texture = texture;
+    cmd.stretchRect.destSliceOrFace = destSliceOrFace;
     g_renderQueue.enqueue(cmd);
 }
 
@@ -3247,7 +3249,7 @@ static void ProcStretchRect(const RenderCommand& cmd)
 
     args.texture->sourceSurface = surface;
     // printf("ProcStretchRect: surface - %x %x ? (%x : %x)\n", surface, isDepthStencil, g_depthStencil, g_renderTarget);
-    surface->destinationTextures.emplace(args.texture);
+    surface->destinationTextures.emplace(args.texture, args.destSliceOrFace);
 
     // If the texture is assigned to any slots, set it again. This'll also push the barrier.
     for (uint32_t i = 0; i < std::size(g_textures); i++)
@@ -3373,7 +3375,7 @@ static bool PopulateBarriersForStretchRect(GuestSurface* renderTarget, GuestSurf
 
             AddBarrier(surface, srcLayout);
 
-            for (const auto texture : surface->destinationTextures)
+            for (const auto [texture, _] : surface->destinationTextures)
                 AddBarrier(texture, dstLayout);
 
             addedAny = true;
@@ -3393,7 +3395,7 @@ static void ExecutePendingStretchRectCommands(GuestSurface* renderTarget, GuestS
         {
             const bool multiSampling = surface->sampleCount != RenderSampleCount::COUNT_1;
 
-            for (const auto texture : surface->destinationTextures)
+            for (const auto [texture, slice] : surface->destinationTextures)
             {
                 bool shaderResolve = true;
 
@@ -3483,27 +3485,29 @@ static void ExecutePendingStretchRectCommands(GuestSurface* renderTarget, GuestS
                         }
                     }
 
-                    if (texture->framebuffer == nullptr)
+                    auto& framebuffer = texture->framebuffers[slice];
+                    if (framebuffer == nullptr)
                     {
                         if (texture->format == RenderFormat::D32_FLOAT)
                         {
                             RenderFramebufferDesc desc;
                             desc.depthAttachment = texture->texture;
-                            texture->framebuffer = g_device->createFramebuffer(desc);
+                            desc.depthAttachmentSlice = slice;
+                            framebuffer = g_device->createFramebuffer(desc);
                         }
                         else
                         {
                             RenderFramebufferDesc desc;
                             desc.colorAttachments = const_cast<const RenderTexture**>(&texture->texture);
                             desc.colorAttachmentsCount = 1;
-                            texture->framebuffer = g_device->createFramebuffer(desc);
+                            framebuffer = g_device->createFramebuffer(desc);
                         }
                     }
 
-                    if (g_framebuffer != texture->framebuffer.get())
+                    if (g_framebuffer != framebuffer.get())
                     {
-                        commandList->setFramebuffer(texture->framebuffer.get());
-                        g_framebuffer = texture->framebuffer.get();
+                        commandList->setFramebuffer(framebuffer.get());
+                        g_framebuffer = framebuffer.get();
                     }
 
                     commandList->setPipeline(pipeline);
@@ -3559,7 +3563,7 @@ static void ProcExecutePendingStretchRectCommands(const RenderCommand& cmd)
             if (surface->format != RenderFormat::D32_FLOAT)
                 ExecutePendingStretchRectCommands(surface, nullptr);
 
-            for (const auto texture : surface->destinationTextures)
+            for (const auto [texture, _] : surface->destinationTextures)
                 texture->sourceSurface = nullptr;
 
             surface->destinationTextures.clear();
@@ -8068,7 +8072,7 @@ int D3DDevice_EndTiling(GuestDevice* device, uint32_t flags, Rect* pResolveRects
     //     printf("pResolveParams: %x %x %x\n", resolveParams->format.get(), resolveParams->unk.get(), resolveParams->format2.get());
     // }
     if (pDestTexture) {
-        StretchRect(device, flags, 0, pDestTexture);
+        StretchRect(device, flags, 0, pDestTexture, 0, 0, 0);
     }
     return 0;
 }
diff --git a/MarathonRecomp/gpu/video.h b/MarathonRecomp/gpu/video.h
@@ -171,7 +171,7 @@ struct GuestTexture : GuestBaseTexture
     uint32_t depth = 0;
     RenderTextureViewDimension viewDimension = RenderTextureViewDimension::UNKNOWN;
     void* mappedMemory = nullptr;
-    std::unique_ptr<RenderFramebuffer> framebuffer;
+    ankerl::unordered_dense::map<uint32_t, std::unique_ptr<RenderFramebuffer>> framebuffers;
     std::unique_ptr<GuestTexture> patchedTexture;
     struct GuestSurface* sourceSurface = nullptr;
 };
@@ -228,7 +228,7 @@ struct GuestSurface : GuestBaseTexture
     uint32_t guestFormat = 0;
     ankerl::unordered_dense::map<const RenderTexture*, std::unique_ptr<RenderFramebuffer>> framebuffers;
     RenderSampleCounts sampleCount = RenderSampleCount::COUNT_1;
-    ankerl::unordered_dense::set<GuestTexture*> destinationTextures;
+    ankerl::unordered_dense::map<GuestTexture*, uint32_t> destinationTextures;
     bool wasCached = false;
 };
 

Original file line number	Diff line number	Diff line change
`@@ -872,6 +872,7 @@ struct RenderCommand`
`872`	`872`	`GuestDevice* device;`
`873`	`873`	`uint32_t flags;`
`874`	`874`	`GuestTexture* texture;`
	`875`	`+ uint32_t destSliceOrFace;`
`875`	`876`	`} stretchRect;`
`876`	`877`
`877`	`878`	`struct`
`@@ -3221,13 +3222,14 @@ static void FlushViewport()`
`3221`	`3222`	`}`
`3222`	`3223`	`}`
`3223`	`3224`
`3224`		`-static void StretchRect(GuestDevice* device, uint32_t flags, uint32_t, GuestTexture* texture)`
	`3225`	`+static void StretchRect(GuestDevice* device, uint32_t flags, uint32_t, GuestTexture* texture, uint32_t, uint32_t, uint32_t destSliceOrFace)`
`3225`	`3226`	`{`
`3226`	`3227`	`// printf("StretchRect %x\n", texture);`
`3227`	`3228`	`RenderCommand cmd;`
`3228`	`3229`	`cmd.type = RenderCommandType::StretchRect;`
`3229`	`3230`	`cmd.stretchRect.flags = flags;`
`3230`	`3231`	`cmd.stretchRect.texture = texture;`
	`3232`	`+ cmd.stretchRect.destSliceOrFace = destSliceOrFace;`
`3231`	`3233`	`g_renderQueue.enqueue(cmd);`
`3232`	`3234`	`}`
`3233`	`3235`
`@@ -3247,7 +3249,7 @@ static void ProcStretchRect(const RenderCommand& cmd)`
`3247`	`3249`
`3248`	`3250`	`args.texture->sourceSurface = surface;`
`3249`	`3251`	`// printf("ProcStretchRect: surface - %x %x ? (%x : %x)\n", surface, isDepthStencil, g_depthStencil, g_renderTarget);`
`3250`		`- surface->destinationTextures.emplace(args.texture);`
	`3252`	`+ surface->destinationTextures.emplace(args.texture, args.destSliceOrFace);`
`3251`	`3253`
`3252`	`3254`	`// If the texture is assigned to any slots, set it again. This'll also push the barrier.`
`3253`	`3255`	`for (uint32_t i = 0; i < std::size(g_textures); i++)`
`@@ -3373,7 +3375,7 @@ static bool PopulateBarriersForStretchRect(GuestSurface* renderTarget, GuestSurf`
`3373`	`3375`
`3374`	`3376`	`AddBarrier(surface, srcLayout);`
`3375`	`3377`
`3376`		`- for (const auto texture : surface->destinationTextures)`
	`3378`	`+ for (const auto [texture, _] : surface->destinationTextures)`
`3377`	`3379`	`AddBarrier(texture, dstLayout);`
`3378`	`3380`
`3379`	`3381`	`addedAny = true;`
`@@ -3393,7 +3395,7 @@ static void ExecutePendingStretchRectCommands(GuestSurface* renderTarget, GuestS`
`3393`	`3395`	`{`
`3394`	`3396`	`const bool multiSampling = surface->sampleCount != RenderSampleCount::COUNT_1;`
`3395`	`3397`
`3396`		`- for (const auto texture : surface->destinationTextures)`
	`3398`	`+ for (const auto [texture, slice] : surface->destinationTextures)`
`3397`	`3399`	`{`
`3398`	`3400`	`bool shaderResolve = true;`
`3399`	`3401`
`@@ -3483,27 +3485,29 @@ static void ExecutePendingStretchRectCommands(GuestSurface* renderTarget, GuestS`
`3483`	`3485`	`}`
`3484`	`3486`	`}`
`3485`	`3487`
`3486`		`- if (texture->framebuffer == nullptr)`
	`3488`	`+ auto& framebuffer = texture->framebuffers[slice];`
	`3489`	`+ if (framebuffer == nullptr)`
`3487`	`3490`	`{`
`3488`	`3491`	`if (texture->format == RenderFormat::D32_FLOAT)`
`3489`	`3492`	`{`
`3490`	`3493`	`RenderFramebufferDesc desc;`
`3491`	`3494`	`desc.depthAttachment = texture->texture;`
`3492`		`- texture->framebuffer = g_device->createFramebuffer(desc);`
	`3495`	`+ desc.depthAttachmentSlice = slice;`
	`3496`	`+ framebuffer = g_device->createFramebuffer(desc);`
`3493`	`3497`	`}`
`3494`	`3498`	`else`
`3495`	`3499`	`{`
`3496`	`3500`	`RenderFramebufferDesc desc;`
`3497`	`3501`	`desc.colorAttachments = const_cast<const RenderTexture**>(&texture->texture);`
`3498`	`3502`	`desc.colorAttachmentsCount = 1;`
`3499`		`- texture->framebuffer = g_device->createFramebuffer(desc);`
	`3503`	`+ framebuffer = g_device->createFramebuffer(desc);`
`3500`	`3504`	`}`
`3501`	`3505`	`}`
`3502`	`3506`
`3503`		`- if (g_framebuffer != texture->framebuffer.get())`
	`3507`	`+ if (g_framebuffer != framebuffer.get())`
`3504`	`3508`	`{`
`3505`		`- commandList->setFramebuffer(texture->framebuffer.get());`
`3506`		`- g_framebuffer = texture->framebuffer.get();`
	`3509`	`+ commandList->setFramebuffer(framebuffer.get());`
	`3510`	`+ g_framebuffer = framebuffer.get();`
`3507`	`3511`	`}`
`3508`	`3512`
`3509`	`3513`	`commandList->setPipeline(pipeline);`
`@@ -3559,7 +3563,7 @@ static void ProcExecutePendingStretchRectCommands(const RenderCommand& cmd)`
`3559`	`3563`	`if (surface->format != RenderFormat::D32_FLOAT)`
`3560`	`3564`	`ExecutePendingStretchRectCommands(surface, nullptr);`
`3561`	`3565`
`3562`		`- for (const auto texture : surface->destinationTextures)`
	`3566`	`+ for (const auto [texture, _] : surface->destinationTextures)`
`3563`	`3567`	`texture->sourceSurface = nullptr;`
`3564`	`3568`
`3565`	`3569`	`surface->destinationTextures.clear();`
`@@ -8068,7 +8072,7 @@ int D3DDevice_EndTiling(GuestDevice* device, uint32_t flags, Rect* pResolveRects`
`8068`	`8072`	`// printf("pResolveParams: %x %x %x\n", resolveParams->format.get(), resolveParams->unk.get(), resolveParams->format2.get());`
`8069`	`8073`	`// }`
`8070`	`8074`	`if (pDestTexture) {`
`8071`		`- StretchRect(device, flags, 0, pDestTexture);`
	`8075`	`+ StretchRect(device, flags, 0, pDestTexture, 0, 0, 0);`
`8072`	`8076`	`}`
`8073`	`8077`	`return 0;`
`8074`	`8078`	`}`