fabi/Xenia-Canary
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
40ca4abc0b50ec5d31e48fc05d0a79b8fd5d7d04
Xenia-Canary/src/xenia/gpu/vulkan/render_cache.cc

1405 lines
54 KiB
C++
Raw Blame History

/**
******************************************************************************
* Xenia : Xbox 360 Emulator Research Project *
******************************************************************************
* Copyright 2020 Ben Vanik. All rights reserved. *
* Released under the BSD license - see LICENSE in the root for more details. *
******************************************************************************
*/
#include "xenia/gpu/vulkan/render_cache.h"
#include <algorithm>
#include "third_party/fmt/include/fmt/format.h"
#include "xenia/base/logging.h"
#include "xenia/base/math.h"
#include "xenia/base/memory.h"
#include "xenia/base/profiling.h"
#include "xenia/gpu/gpu_flags.h"
#include "xenia/gpu/registers.h"
#include "xenia/gpu/vulkan/vulkan_gpu_flags.h"
namespace xe {
namespace gpu {
namespace vulkan {
using namespace xe::gpu::xenos;
using xe::ui::vulkan::CheckResult;
constexpr uint32_t kEdramBufferCapacity = 10 * 1024 * 1024;
xenos::ColorRenderTargetFormat GetBaseRTFormat(
xenos::ColorRenderTargetFormat format) {
switch (format) {
case xenos::ColorRenderTargetFormat::k_8_8_8_8_GAMMA:
return xenos::ColorRenderTargetFormat::k_8_8_8_8;
case xenos::ColorRenderTargetFormat::k_2_10_10_10_AS_10_10_10_10:
return xenos::ColorRenderTargetFormat::k_2_10_10_10;
case xenos::ColorRenderTargetFormat::k_2_10_10_10_FLOAT_AS_16_16_16_16:
return xenos::ColorRenderTargetFormat::k_2_10_10_10_FLOAT;
default:
return format;
}
}
VkFormat ColorRenderTargetFormatToVkFormat(
xenos::ColorRenderTargetFormat format) {
switch (format) {
case xenos::ColorRenderTargetFormat::k_8_8_8_8:
case xenos::ColorRenderTargetFormat::k_8_8_8_8_GAMMA:
return VK_FORMAT_R8G8B8A8_UNORM;
case xenos::ColorRenderTargetFormat::k_2_10_10_10:
case xenos::ColorRenderTargetFormat::k_2_10_10_10_AS_10_10_10_10:
return VK_FORMAT_A2R10G10B10_UNORM_PACK32;
case xenos::ColorRenderTargetFormat::k_2_10_10_10_FLOAT:
case xenos::ColorRenderTargetFormat::k_2_10_10_10_FLOAT_AS_16_16_16_16:
return VK_FORMAT_R16G16B16A16_SFLOAT;
case xenos::ColorRenderTargetFormat::k_16_16:
return VK_FORMAT_R16G16_UNORM;
case xenos::ColorRenderTargetFormat::k_16_16_16_16:
return VK_FORMAT_R16G16B16A16_UNORM;
case xenos::ColorRenderTargetFormat::k_16_16_FLOAT:
return VK_FORMAT_R16G16_SFLOAT;
case xenos::ColorRenderTargetFormat::k_16_16_16_16_FLOAT:
return VK_FORMAT_R16G16B16A16_SFLOAT;
case xenos::ColorRenderTargetFormat::k_32_FLOAT:
return VK_FORMAT_R32_SFLOAT;
case xenos::ColorRenderTargetFormat::k_32_32_FLOAT:
return VK_FORMAT_R32G32_SFLOAT;
default:
assert_unhandled_case(key.edram_format);
return VK_FORMAT_UNDEFINED;
}
}
VkFormat DepthRenderTargetFormatToVkFormat(
xenos::DepthRenderTargetFormat format) {
switch (format) {
case xenos::DepthRenderTargetFormat::kD24S8:
return VK_FORMAT_D24_UNORM_S8_UINT;
case xenos::DepthRenderTargetFormat::kD24FS8:
// Vulkan doesn't support 24-bit floats, so just promote it to 32-bit
return VK_FORMAT_D32_SFLOAT_S8_UINT;
default:
return VK_FORMAT_UNDEFINED;
}
}
// Cached framebuffer referencing tile attachments.
// Each framebuffer is specific to a render pass. Ugh.
class CachedFramebuffer {
public:
// TODO(benvanik): optimized key? tile base + format for each?
// Framebuffer with the attachments ready for use in the parent render pass.
VkFramebuffer handle = nullptr;
// Width of the framebuffer in pixels.
uint32_t width = 0;
// Height of the framebuffer in pixels.
uint32_t height = 0;
// References to color attachments, if used.
CachedTileView* color_attachments[4] = {nullptr};
// Reference to depth/stencil attachment, if used.
CachedTileView* depth_stencil_attachment = nullptr;
// Associated render pass
VkRenderPass render_pass = nullptr;
CachedFramebuffer(VkDevice device, VkRenderPass render_pass,
uint32_t surface_width, uint32_t surface_height,
CachedTileView* target_color_attachments[4],
CachedTileView* target_depth_stencil_attachment);
~CachedFramebuffer();
VkResult Initialize();
bool IsCompatible(const RenderConfiguration& desired_config) const;
private:
VkDevice device_ = nullptr;
};
// Cached render passes based on register states.
// Each render pass is dependent on the format, dimensions, and use of
// all attachments. The same render pass can be reused for multiple
// framebuffers pointing at various tile views, though those cached
// framebuffers are specific to the render pass.
class CachedRenderPass {
public:
// Configuration this pass was created with.
RenderConfiguration config;
// Initialized render pass for the register state.
VkRenderPass handle = nullptr;
// Cache of framebuffers for the various tile attachments.
std::vector<CachedFramebuffer*> cached_framebuffers;
CachedRenderPass(VkDevice device, const RenderConfiguration& desired_config);
~CachedRenderPass();
VkResult Initialize();
bool IsCompatible(const RenderConfiguration& desired_config) const;
private:
VkDevice device_ = nullptr;
};
CachedTileView::CachedTileView(ui::vulkan::VulkanDevice* device,
VkDeviceMemory edram_memory,
TileViewKey view_key)
: device_(device), key(std::move(view_key)) {}
CachedTileView::~CachedTileView() {
VK_SAFE_DESTROY(vkDestroyImageView, *device_, image_view, nullptr);
VK_SAFE_DESTROY(vkDestroyImageView, *device_, image_view_depth, nullptr);
VK_SAFE_DESTROY(vkDestroyImageView, *device_, image_view_stencil, nullptr);
VK_SAFE_DESTROY(vkDestroyImage, *device_, image, nullptr);
VK_SAFE_DESTROY(vkFreeMemory, *device_, memory, nullptr);
}
VkResult CachedTileView::Initialize(VkCommandBuffer command_buffer) {
VkResult status = VK_SUCCESS;
// Map format to Vulkan.
VkFormat vulkan_format = VK_FORMAT_UNDEFINED;
uint32_t bpp = 4;
if (key.color_or_depth) {
auto edram_format =
static_cast<xenos::ColorRenderTargetFormat>(key.edram_format);
vulkan_format = ColorRenderTargetFormatToVkFormat(edram_format);
switch (edram_format) {
case xenos::ColorRenderTargetFormat::k_16_16_16_16:
case xenos::ColorRenderTargetFormat::k_16_16_16_16_FLOAT:
case xenos::ColorRenderTargetFormat::k_32_32_FLOAT:
bpp = 8;
break;
default:
bpp = 4;
break;
}
} else {
auto edram_format =
static_cast<xenos::DepthRenderTargetFormat>(key.edram_format);
vulkan_format = DepthRenderTargetFormatToVkFormat(edram_format);
}
assert_true(vulkan_format != VK_FORMAT_UNDEFINED);
// FIXME(DrChat): Was this check necessary?
// assert_true(bpp == 4);
// Create the image with the desired properties.
VkImageCreateInfo image_info;
image_info.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO;
image_info.pNext = nullptr;
// TODO(benvanik): exploit VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT so we can have
// multiple views.
image_info.flags = 0;
image_info.imageType = VK_IMAGE_TYPE_2D;
image_info.format = vulkan_format;
image_info.extent.width = key.tile_width * 80;
image_info.extent.height = key.tile_height * 16;
image_info.extent.depth = 1;
image_info.mipLevels = 1;
image_info.arrayLayers = 1;
if (cvars::vulkan_native_msaa) {
auto msaa_samples = static_cast<xenos::MsaaSamples>(key.msaa_samples);
switch (msaa_samples) {
case xenos::MsaaSamples::k1X:
image_info.samples = VK_SAMPLE_COUNT_1_BIT;
break;
case xenos::MsaaSamples::k2X:
image_info.samples = VK_SAMPLE_COUNT_2_BIT;
break;
case xenos::MsaaSamples::k4X:
image_info.samples = VK_SAMPLE_COUNT_4_BIT;
break;
default:
assert_unhandled_case(msaa_samples);
}
} else {
image_info.samples = VK_SAMPLE_COUNT_1_BIT;
}
sample_count = image_info.samples;
image_info.tiling = VK_IMAGE_TILING_OPTIMAL;
image_info.usage = VK_IMAGE_USAGE_TRANSFER_SRC_BIT |
VK_IMAGE_USAGE_TRANSFER_DST_BIT |
VK_IMAGE_USAGE_SAMPLED_BIT;
image_info.usage |= key.color_or_depth
? VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT
: VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT;
image_info.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
image_info.queueFamilyIndexCount = 0;
image_info.pQueueFamilyIndices = nullptr;
image_info.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
status = vkCreateImage(*device_, &image_info, nullptr, &image);
if (status != VK_SUCCESS) {
return status;
}
device_->DbgSetObjectName(
reinterpret_cast<uint64_t>(image), VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT,
fmt::format("RT(d): 0x{:08X} 0x{:08X}({}) 0x{:08X}({}) {} {} {}",
uint32_t(key.tile_offset), uint32_t(key.tile_width),
uint32_t(key.tile_width), uint32_t(key.tile_height),
uint32_t(key.tile_height), uint32_t(key.color_or_depth),
uint32_t(key.msaa_samples), uint32_t(key.edram_format)));
VkMemoryRequirements memory_requirements;
vkGetImageMemoryRequirements(*device_, image, &memory_requirements);
// Bind to a newly allocated chunk.
// TODO: Alias from a really big buffer?
memory = device_->AllocateMemory(memory_requirements, 0);
status = vkBindImageMemory(*device_, image, memory, 0);
if (status != VK_SUCCESS) {
return status;
}
// Create the image view we'll use to attach it to a framebuffer.
VkImageViewCreateInfo image_view_info;
image_view_info.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;
image_view_info.pNext = nullptr;
image_view_info.flags = 0;
image_view_info.image = image;
image_view_info.viewType = VK_IMAGE_VIEW_TYPE_2D;
image_view_info.format = image_info.format;
// TODO(benvanik): manipulate? may not be able to when attached.
image_view_info.components = {
VK_COMPONENT_SWIZZLE_R,
VK_COMPONENT_SWIZZLE_G,
VK_COMPONENT_SWIZZLE_B,
VK_COMPONENT_SWIZZLE_A,
};
image_view_info.subresourceRange = {VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 1};
if (key.color_or_depth) {
image_view_info.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
} else {
image_view_info.subresourceRange.aspectMask =
VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT;
}
status = vkCreateImageView(*device_, &image_view_info, nullptr, &image_view);
if (status != VK_SUCCESS) {
return status;
}
// Create separate depth/stencil views.
if (key.color_or_depth == 0) {
image_view_info.subresourceRange.aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT;
status = vkCreateImageView(*device_, &image_view_info, nullptr,
&image_view_depth);
if (status != VK_SUCCESS) {
return status;
}
image_view_info.subresourceRange.aspectMask = VK_IMAGE_ASPECT_STENCIL_BIT;
status = vkCreateImageView(*device_, &image_view_info, nullptr,
&image_view_stencil);
if (status != VK_SUCCESS) {
return status;
}
}
// TODO(benvanik): transition to general layout?
VkImageMemoryBarrier image_barrier;
image_barrier.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER;
image_barrier.pNext = nullptr;
image_barrier.srcAccessMask = 0;
image_barrier.dstAccessMask =
key.color_or_depth ? VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT
: VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT;
image_barrier.oldLayout = VK_IMAGE_LAYOUT_UNDEFINED;
image_barrier.newLayout = VK_IMAGE_LAYOUT_GENERAL;
image_barrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
image_barrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
image_barrier.image = image;
image_barrier.subresourceRange.aspectMask =
key.color_or_depth
? VK_IMAGE_ASPECT_COLOR_BIT
: VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT;
image_barrier.subresourceRange.baseMipLevel = 0;
image_barrier.subresourceRange.levelCount = 1;
image_barrier.subresourceRange.baseArrayLayer = 0;
image_barrier.subresourceRange.layerCount = 1;
vkCmdPipelineBarrier(command_buffer, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT,
key.color_or_depth
? VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT
: VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT,
0, 0, nullptr, 0, nullptr, 1, &image_barrier);
image_layout = image_barrier.newLayout;
return VK_SUCCESS;
}
CachedFramebuffer::CachedFramebuffer(
VkDevice device, VkRenderPass render_pass, uint32_t surface_width,
uint32_t surface_height, CachedTileView* target_color_attachments[4],
CachedTileView* target_depth_stencil_attachment)
: device_(device),
width(surface_width),
height(surface_height),
depth_stencil_attachment(target_depth_stencil_attachment),
render_pass(render_pass) {
for (int i = 0; i < 4; ++i) {
color_attachments[i] = target_color_attachments[i];
}
}
CachedFramebuffer::~CachedFramebuffer() {
VK_SAFE_DESTROY(vkDestroyFramebuffer, device_, handle, nullptr);
}
VkResult CachedFramebuffer::Initialize() {
// Create framebuffer.
VkImageView image_views[5] = {nullptr};
int image_view_count = 0;
for (int i = 0; i < 4; ++i) {
if (color_attachments[i]) {
image_views[image_view_count++] = color_attachments[i]->image_view;
}
}
if (depth_stencil_attachment) {
image_views[image_view_count++] = depth_stencil_attachment->image_view;
}
VkFramebufferCreateInfo framebuffer_info;
framebuffer_info.sType = VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO;
framebuffer_info.pNext = nullptr;
framebuffer_info.flags = 0;
framebuffer_info.renderPass = render_pass;
framebuffer_info.attachmentCount = image_view_count;
framebuffer_info.pAttachments = image_views;
framebuffer_info.width = width;
framebuffer_info.height = height;
framebuffer_info.layers = 1;
return vkCreateFramebuffer(device_, &framebuffer_info, nullptr, &handle);
}
bool CachedFramebuffer::IsCompatible(
const RenderConfiguration& desired_config) const {
// We already know all render pass things line up, so let's verify dimensions,
// edram offsets, etc. We need an exact match.
uint32_t surface_pitch_px =
desired_config.surface_msaa != xenos::MsaaSamples::k4X
? desired_config.surface_pitch_px
: desired_config.surface_pitch_px * 2;
uint32_t surface_height_px =
desired_config.surface_msaa == xenos::MsaaSamples::k1X
? desired_config.surface_height_px
: desired_config.surface_height_px * 2;
surface_pitch_px = std::min(surface_pitch_px, 2560u);
surface_height_px = std::min(surface_height_px, 2560u);
if (surface_pitch_px != width || surface_height_px != height) {
return false;
}
// TODO(benvanik): separate image views from images in tiles and store in fb?
for (int i = 0; i < 4; ++i) {
// Ensure the the attachment points to the same tile.
if (!color_attachments[i]) {
continue;
}
auto& color_info = color_attachments[i]->key;
auto& desired_color_info = desired_config.color[i];
if (color_info.tile_offset != desired_color_info.edram_base ||
color_info.edram_format !=
static_cast<uint16_t>(desired_color_info.format)) {
return false;
}
}
// Ensure depth attachment is correct.
if (depth_stencil_attachment &&
(depth_stencil_attachment->key.tile_offset !=
desired_config.depth_stencil.edram_base ||
depth_stencil_attachment->key.edram_format !=
static_cast<uint16_t>(desired_config.depth_stencil.format))) {
return false;
}
return true;
}
CachedRenderPass::CachedRenderPass(VkDevice device,
const RenderConfiguration& desired_config)
: device_(device) {
std::memcpy(&config, &desired_config, sizeof(config));
}
CachedRenderPass::~CachedRenderPass() {
for (auto framebuffer : cached_framebuffers) {
delete framebuffer;
}
cached_framebuffers.clear();
VK_SAFE_DESTROY(vkDestroyRenderPass, device_, handle, nullptr);
}
VkResult CachedRenderPass::Initialize() {
VkSampleCountFlagBits sample_count;
if (cvars::vulkan_native_msaa) {
switch (config.surface_msaa) {
case xenos::MsaaSamples::k1X:
sample_count = VK_SAMPLE_COUNT_1_BIT;
break;
case xenos::MsaaSamples::k2X:
sample_count = VK_SAMPLE_COUNT_2_BIT;
break;
case xenos::MsaaSamples::k4X:
sample_count = VK_SAMPLE_COUNT_4_BIT;
break;
default:
assert_unhandled_case(config.surface_msaa);
break;
}
} else {
sample_count = VK_SAMPLE_COUNT_1_BIT;
}
// Initialize all attachments to default unused.
// As we set layout(location=RT) in shaders we must always provide 4.
VkAttachmentDescription attachments[5];
for (int i = 0; i < 4; ++i) {
attachments[i].flags = VK_ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT;
attachments[i].format = VK_FORMAT_UNDEFINED;
attachments[i].samples = sample_count;
attachments[i].loadOp = VK_ATTACHMENT_LOAD_OP_LOAD;
attachments[i].storeOp = VK_ATTACHMENT_STORE_OP_STORE;
attachments[i].stencilLoadOp = VK_ATTACHMENT_LOAD_OP_LOAD;
attachments[i].stencilStoreOp = VK_ATTACHMENT_STORE_OP_STORE;
attachments[i].initialLayout = VK_IMAGE_LAYOUT_GENERAL;
attachments[i].finalLayout = VK_IMAGE_LAYOUT_GENERAL;
}
auto& depth_stencil_attachment = attachments[4];
depth_stencil_attachment.flags = 0;
depth_stencil_attachment.format = VK_FORMAT_UNDEFINED;
depth_stencil_attachment.samples = sample_count;
depth_stencil_attachment.loadOp = VK_ATTACHMENT_LOAD_OP_LOAD;
depth_stencil_attachment.storeOp = VK_ATTACHMENT_STORE_OP_STORE;
depth_stencil_attachment.stencilLoadOp = VK_ATTACHMENT_LOAD_OP_LOAD;
depth_stencil_attachment.stencilStoreOp = VK_ATTACHMENT_STORE_OP_STORE;
depth_stencil_attachment.initialLayout = VK_IMAGE_LAYOUT_GENERAL;
depth_stencil_attachment.finalLayout = VK_IMAGE_LAYOUT_GENERAL;
// Configure attachments based on what's enabled.
VkAttachmentReference color_attachment_refs[4];
for (int i = 0; i < 4; ++i) {
auto& color_config = config.color[i];
// TODO(benvanik): see how loose we can be with these.
attachments[i].format =
ColorRenderTargetFormatToVkFormat(color_config.format);
auto& color_attachment_ref = color_attachment_refs[i];
color_attachment_ref.attachment = i;
color_attachment_ref.layout = VK_IMAGE_LAYOUT_GENERAL;
}
// Configure depth.
VkAttachmentReference depth_stencil_attachment_ref;
depth_stencil_attachment_ref.layout = VK_IMAGE_LAYOUT_GENERAL;
auto& depth_config = config.depth_stencil;
depth_stencil_attachment_ref.attachment = 4;
depth_stencil_attachment.format =
DepthRenderTargetFormatToVkFormat(depth_config.format);
// Single subpass that writes to our attachments.
// FIXME: "Multiple attachments that alias the same memory must not be used in
// a single subpass"
// TODO: Input attachment for depth/stencil reads?
VkSubpassDescription subpass_info;
subpass_info.flags = 0;
subpass_info.pipelineBindPoint = VK_PIPELINE_BIND_POINT_GRAPHICS;
subpass_info.inputAttachmentCount = 0;
subpass_info.pInputAttachments = nullptr;
subpass_info.colorAttachmentCount = 4;
subpass_info.pColorAttachments = color_attachment_refs;
subpass_info.pResolveAttachments = nullptr;
subpass_info.pDepthStencilAttachment = &depth_stencil_attachment_ref;
subpass_info.preserveAttachmentCount = 0;
subpass_info.pPreserveAttachments = nullptr;
// Create the render pass.
VkRenderPassCreateInfo render_pass_info;
std::memset(&render_pass_info, 0, sizeof(render_pass_info));
render_pass_info.sType = VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO;
render_pass_info.pNext = nullptr;
render_pass_info.flags = 0;
render_pass_info.attachmentCount = 5;
render_pass_info.pAttachments = attachments;
render_pass_info.subpassCount = 1;
render_pass_info.pSubpasses = &subpass_info;
// Add a dependency on external render passes -> us (MAY_ALIAS bit)
VkSubpassDependency dependencies[1];
dependencies[0].srcSubpass = VK_SUBPASS_EXTERNAL;
dependencies[0].dstSubpass = 0;
dependencies[0].srcStageMask = VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT;
dependencies[0].dstStageMask = VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT;
dependencies[0].srcAccessMask = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT |
VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT;
dependencies[0].dstAccessMask = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT |
VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT;
dependencies[0].dependencyFlags = 0;
render_pass_info.dependencyCount = 1;
render_pass_info.pDependencies = dependencies;
return vkCreateRenderPass(device_, &render_pass_info, nullptr, &handle);
}
bool CachedRenderPass::IsCompatible(
const RenderConfiguration& desired_config) const {
if (config.surface_msaa != desired_config.surface_msaa &&
cvars::vulkan_native_msaa) {
return false;
}
for (int i = 0; i < 4; ++i) {
// TODO(benvanik): allow compatible vulkan formats.
if (config.color[i].format != desired_config.color[i].format) {
return false;
}
}
if (config.depth_stencil.format != desired_config.depth_stencil.format) {
return false;
}
return true;
}
RenderCache::RenderCache(RegisterFile* register_file,
ui::vulkan::VulkanDevice* device)
: register_file_(register_file), device_(device) {}
RenderCache::~RenderCache() { Shutdown(); }
VkResult RenderCache::Initialize() {
VkResult status = VK_SUCCESS;
// Create the buffer we'll bind to our memory.
VkBufferCreateInfo buffer_info;
buffer_info.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO;
buffer_info.pNext = nullptr;
buffer_info.flags = 0;
buffer_info.size = kEdramBufferCapacity;
buffer_info.usage =
VK_BUFFER_USAGE_TRANSFER_SRC_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT;
buffer_info.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
buffer_info.queueFamilyIndexCount = 0;
buffer_info.pQueueFamilyIndices = nullptr;
status = vkCreateBuffer(*device_, &buffer_info, nullptr, &edram_buffer_);
CheckResult(status, "vkCreateBuffer");
if (status != VK_SUCCESS) {
return status;
}
// Query requirements for the buffer.
// It should be 1:1.
VkMemoryRequirements buffer_requirements;
vkGetBufferMemoryRequirements(*device_, edram_buffer_, &buffer_requirements);
assert_true(buffer_requirements.size == kEdramBufferCapacity);
// Allocate EDRAM memory.
// TODO(benvanik): do we need it host visible?
edram_memory_ = device_->AllocateMemory(buffer_requirements);
assert_not_null(edram_memory_);
if (!edram_memory_) {
return VK_ERROR_INITIALIZATION_FAILED;
}
// Bind buffer to map our entire memory.
status = vkBindBufferMemory(*device_, edram_buffer_, edram_memory_, 0);
CheckResult(status, "vkBindBufferMemory");
if (status != VK_SUCCESS) {
return status;
}
if (status == VK_SUCCESS) {
// For debugging, upload a grid into the EDRAM buffer.
uint32_t* gpu_data = nullptr;
status = vkMapMemory(*device_, edram_memory_, 0, buffer_requirements.size,
0, reinterpret_cast<void**>(&gpu_data));
if (status == VK_SUCCESS) {
for (int i = 0; i < kEdramBufferCapacity / 4; i++) {
gpu_data[i] = (i % 8) >= 4 ? 0xFF0000FF : 0xFFFFFFFF;
}
vkUnmapMemory(*device_, edram_memory_);
}
}
return VK_SUCCESS;
}
void RenderCache::Shutdown() {
// TODO(benvanik): wait for idle.
// Dispose all render passes (and their framebuffers).
for (auto render_pass : cached_render_passes_) {
delete render_pass;
}
cached_render_passes_.clear();
// Dispose all of our cached tile views.
for (auto tile_view : cached_tile_views_) {
delete tile_view;
}
cached_tile_views_.clear();
// Release underlying EDRAM memory.
if (edram_buffer_) {
vkDestroyBuffer(*device_, edram_buffer_, nullptr);
edram_buffer_ = nullptr;
}
if (edram_memory_) {
vkFreeMemory(*device_, edram_memory_, nullptr);
edram_memory_ = nullptr;
}
}
bool RenderCache::dirty() const {
auto& regs = *register_file_;
auto& cur_regs = shadow_registers_;
bool dirty = false;
dirty |= cur_regs.rb_modecontrol.value != regs[XE_GPU_REG_RB_MODECONTROL].u32;
dirty |=
cur_regs.rb_surface_info.value != regs[XE_GPU_REG_RB_SURFACE_INFO].u32;
dirty |= cur_regs.rb_color_info.value != regs[XE_GPU_REG_RB_COLOR_INFO].u32;
dirty |= cur_regs.rb_color1_info.value != regs[XE_GPU_REG_RB_COLOR1_INFO].u32;
dirty |= cur_regs.rb_color2_info.value != regs[XE_GPU_REG_RB_COLOR2_INFO].u32;
dirty |= cur_regs.rb_color3_info.value != regs[XE_GPU_REG_RB_COLOR3_INFO].u32;
dirty |= cur_regs.rb_depth_info.value != regs[XE_GPU_REG_RB_DEPTH_INFO].u32;
dirty |= cur_regs.pa_sc_window_scissor_tl !=
regs[XE_GPU_REG_PA_SC_WINDOW_SCISSOR_TL].u32;
dirty |= cur_regs.pa_sc_window_scissor_br !=
regs[XE_GPU_REG_PA_SC_WINDOW_SCISSOR_BR].u32;
return dirty;
}
const RenderState* RenderCache::BeginRenderPass(VkCommandBuffer command_buffer,
VulkanShader* vertex_shader,
VulkanShader* pixel_shader) {
#if FINE_GRAINED_DRAW_SCOPES
SCOPE_profile_cpu_f("gpu");
#endif // FINE_GRAINED_DRAW_SCOPES
assert_null(current_command_buffer_);
current_command_buffer_ = command_buffer;
// Lookup or construct a render pass compatible with our current state.
auto config = &current_state_.config;
CachedRenderPass* render_pass = nullptr;
CachedFramebuffer* framebuffer = nullptr;
auto& regs = shadow_registers_;
bool dirty = false;
dirty |=
SetShadowRegister(&regs.rb_modecontrol.value, XE_GPU_REG_RB_MODECONTROL);
dirty |= SetShadowRegister(&regs.rb_surface_info.value,
XE_GPU_REG_RB_SURFACE_INFO);
dirty |=
SetShadowRegister(&regs.rb_color_info.value, XE_GPU_REG_RB_COLOR_INFO);
dirty |=
SetShadowRegister(&regs.rb_color1_info.value, XE_GPU_REG_RB_COLOR1_INFO);
dirty |=
SetShadowRegister(&regs.rb_color2_info.value, XE_GPU_REG_RB_COLOR2_INFO);
dirty |=
SetShadowRegister(&regs.rb_color3_info.value, XE_GPU_REG_RB_COLOR3_INFO);
dirty |=
SetShadowRegister(&regs.rb_depth_info.value, XE_GPU_REG_RB_DEPTH_INFO);
dirty |= SetShadowRegister(&regs.pa_sc_window_scissor_tl,
XE_GPU_REG_PA_SC_WINDOW_SCISSOR_TL);
dirty |= SetShadowRegister(&regs.pa_sc_window_scissor_br,
XE_GPU_REG_PA_SC_WINDOW_SCISSOR_BR);
if (!dirty && current_state_.render_pass) {
// No registers have changed so we can reuse the previous render pass -
// just begin with what we had.
render_pass = current_state_.render_pass;
framebuffer = current_state_.framebuffer;
} else {
// Re-parse configuration.
if (!ParseConfiguration(config)) {
return nullptr;
}
// Lookup or generate a new render pass and framebuffer for the new state.
if (!ConfigureRenderPass(command_buffer, config, &render_pass,
&framebuffer)) {
return nullptr;
}
current_state_.render_pass = render_pass;
current_state_.render_pass_handle = render_pass->handle;
current_state_.framebuffer = framebuffer;
current_state_.framebuffer_handle = framebuffer->handle;
// TODO(DrChat): Determine if we actually need an EDRAM buffer.
/*
// Depth
auto depth_target = current_state_.framebuffer->depth_stencil_attachment;
if (depth_target && current_state_.config.depth_stencil.used) {
UpdateTileView(command_buffer, depth_target, true);
}
// Color
for (int i = 0; i < 4; i++) {
auto target = current_state_.framebuffer->color_attachments[i];
if (!target || !current_state_.config.color[i].used) {
continue;
}
UpdateTileView(command_buffer, target, true);
}
*/
}
if (!render_pass) {
return nullptr;
}
// Setup render pass in command buffer.
// This is meant to preserve previous contents as we may be called
// repeatedly.
VkRenderPassBeginInfo render_pass_begin_info;
render_pass_begin_info.sType = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO;
render_pass_begin_info.pNext = nullptr;
render_pass_begin_info.renderPass = render_pass->handle;
render_pass_begin_info.framebuffer = framebuffer->handle;
// Render into the entire buffer (or at least tell the API we are doing
// this). In theory it'd be better to clip this to the scissor region, but
// the docs warn anything but the full framebuffer may be slow.
render_pass_begin_info.renderArea.offset.x = 0;
render_pass_begin_info.renderArea.offset.y = 0;
render_pass_begin_info.renderArea.extent.width = config->surface_pitch_px;
render_pass_begin_info.renderArea.extent.height = config->surface_height_px;
if (config->surface_msaa == xenos::MsaaSamples::k2X) {
render_pass_begin_info.renderArea.extent.height =
std::min(config->surface_height_px * 2, 2560u);
} else if (config->surface_msaa == xenos::MsaaSamples::k4X) {
render_pass_begin_info.renderArea.extent.width *= 2;
render_pass_begin_info.renderArea.extent.height =
std::min(config->surface_height_px * 2, 2560u);
}
// Configure clear color, if clearing.
// TODO(benvanik): enable clearing here during resolve?
render_pass_begin_info.clearValueCount = 0;
render_pass_begin_info.pClearValues = nullptr;
// Begin the render pass.
vkCmdBeginRenderPass(command_buffer, &render_pass_begin_info,
VK_SUBPASS_CONTENTS_INLINE);
return &current_state_;
}
bool RenderCache::ParseConfiguration(RenderConfiguration* config) {
auto& regs = shadow_registers_;
// RB_MODECONTROL
// Rough mode control (color, color+depth, etc).
config->mode_control = regs.rb_modecontrol.edram_mode;
// RB_SURFACE_INFO
// https://fossies.org/dox/MesaLib-10.3.5/fd2__gmem_8c_source.html
config->surface_pitch_px = regs.rb_surface_info.surface_pitch;
config->surface_msaa = regs.rb_surface_info.msaa_samples;
// TODO(benvanik): verify min/max so we don't go out of bounds.
// TODO(benvanik): has to be a good way to get height.
// Guess the height from the scissor height.
// It's wildly inaccurate, but I've never seen it be bigger than the
// EDRAM tiling.
/*
uint32_t ws_y = (regs.pa_sc_window_scissor_tl >> 16) & 0x7FFF;
uint32_t ws_h = ((regs.pa_sc_window_scissor_br >> 16) & 0x7FFF) - ws_y;
config->surface_height_px = std::min(2560u, xe::round_up(ws_h, 16));
*/
// TODO(DrChat): Find an accurate way to get the surface height. Until we do,
// we're going to hardcode it to 2560, as that's the absolute maximum.
config->surface_height_px = 2560;
// Color attachment configuration.
if (config->mode_control == ModeControl::kColorDepth) {
reg::RB_COLOR_INFO color_info[4] = {
regs.rb_color_info,
regs.rb_color1_info,
regs.rb_color2_info,
regs.rb_color3_info,
};
for (int i = 0; i < 4; ++i) {
config->color[i].edram_base = color_info[i].color_base;
config->color[i].format = GetBaseRTFormat(color_info[i].color_format);
}
} else {
for (int i = 0; i < 4; ++i) {
config->color[i].edram_base = 0;
config->color[i].format = xenos::ColorRenderTargetFormat::k_8_8_8_8;
config->color[i].used = false;
}
}
// Depth/stencil attachment configuration.
if (config->mode_control == ModeControl::kColorDepth ||
config->mode_control == ModeControl::kDepth) {
config->depth_stencil.edram_base = regs.rb_depth_info.depth_base;
config->depth_stencil.format = regs.rb_depth_info.depth_format;
} else {
config->depth_stencil.edram_base = 0;
config->depth_stencil.format = xenos::DepthRenderTargetFormat::kD24S8;
config->depth_stencil.used = false;
}
return true;
}
bool RenderCache::ConfigureRenderPass(VkCommandBuffer command_buffer,
RenderConfiguration* config,
CachedRenderPass** out_render_pass,
CachedFramebuffer** out_framebuffer) {
*out_render_pass = nullptr;
*out_framebuffer = nullptr;
// TODO(benvanik): better lookup.
// Attempt to find the render pass in our cache.
CachedRenderPass* render_pass = nullptr;
for (auto cached_render_pass : cached_render_passes_) {
if (cached_render_pass->IsCompatible(*config)) {
// Found a match.
render_pass = cached_render_pass;
break;
}
}
// If no render pass was found in the cache create a new one.
if (!render_pass) {
render_pass = new CachedRenderPass(*device_, *config);
VkResult status = render_pass->Initialize();
if (status != VK_SUCCESS) {
XELOGE("{}: Failed to create render pass, status {}", __func__,
ui::vulkan::to_string(status));
delete render_pass;
return false;
}
cached_render_passes_.push_back(render_pass);
}
// TODO(benvanik): better lookup.
// Attempt to find the framebuffer in the render pass cache.
CachedFramebuffer* framebuffer = nullptr;
for (auto cached_framebuffer : render_pass->cached_framebuffers) {
if (cached_framebuffer->IsCompatible(*config)) {
// Found a match.
framebuffer = cached_framebuffer;
break;
}
}
// If no framebuffer was found in the cache create a new one.
if (!framebuffer) {
uint32_t tile_width =
config->surface_msaa == xenos::MsaaSamples::k4X ? 40 : 80;
uint32_t tile_height =
config->surface_msaa != xenos::MsaaSamples::k1X ? 8 : 16;
CachedTileView* target_color_attachments[4] = {nullptr, nullptr, nullptr,
nullptr};
for (int i = 0; i < 4; ++i) {
TileViewKey color_key;
color_key.tile_offset = config->color[i].edram_base;
color_key.tile_width =
xe::round_up(config->surface_pitch_px, tile_width) / tile_width;
// color_key.tile_height =
// xe::round_up(config->surface_height_px, tile_height) / tile_height;
color_key.tile_height = 160;
color_key.color_or_depth = 1;
color_key.msaa_samples =
0; // static_cast<uint16_t>(config->surface_msaa);
color_key.edram_format = static_cast<uint16_t>(config->color[i].format);
target_color_attachments[i] =
FindOrCreateTileView(command_buffer, color_key);
if (!target_color_attachments[i]) {
XELOGE("Failed to get tile view for color attachment");
return false;
}
}
TileViewKey depth_stencil_key;
depth_stencil_key.tile_offset = config->depth_stencil.edram_base;
depth_stencil_key.tile_width =
xe::round_up(config->surface_pitch_px, tile_width) / tile_width;
// depth_stencil_key.tile_height =
// xe::round_up(config->surface_height_px, tile_height) / tile_height;
depth_stencil_key.tile_height = 160;
depth_stencil_key.color_or_depth = 0;
depth_stencil_key.msaa_samples =
0; // static_cast<uint16_t>(config->surface_msaa);
depth_stencil_key.edram_format =
static_cast<uint16_t>(config->depth_stencil.format);
auto target_depth_stencil_attachment =
FindOrCreateTileView(command_buffer, depth_stencil_key);
if (!target_depth_stencil_attachment) {
XELOGE("Failed to get tile view for depth/stencil attachment");
return false;
}
uint32_t surface_pitch_px = config->surface_msaa != xenos::MsaaSamples::k4X
? config->surface_pitch_px
: config->surface_pitch_px * 2;
uint32_t surface_height_px = config->surface_msaa == xenos::MsaaSamples::k1X
? config->surface_height_px
: config->surface_height_px * 2;
surface_pitch_px = std::min(surface_pitch_px, 2560u);
surface_height_px = std::min(surface_height_px, 2560u);
framebuffer = new CachedFramebuffer(
*device_, render_pass->handle, surface_pitch_px, surface_height_px,
target_color_attachments, target_depth_stencil_attachment);
VkResult status = framebuffer->Initialize();
if (status != VK_SUCCESS) {
XELOGE("{}: Failed to create framebuffer, status {}", __func__,
ui::vulkan::to_string(status));
delete framebuffer;
return false;
}
render_pass->cached_framebuffers.push_back(framebuffer);
}
*out_render_pass = render_pass;
*out_framebuffer = framebuffer;
return true;
}
CachedTileView* RenderCache::FindTileView(uint32_t base, uint32_t pitch,
xenos::MsaaSamples samples,
bool color_or_depth,
uint32_t format) {
uint32_t tile_width = samples == xenos::MsaaSamples::k4X ? 40 : 80;
uint32_t tile_height = samples != xenos::MsaaSamples::k1X ? 8 : 16;
if (color_or_depth) {
// Adjust similar formats for easier matching.
format = static_cast<uint32_t>(
GetBaseRTFormat(static_cast<xenos::ColorRenderTargetFormat>(format)));
}
TileViewKey key;
key.tile_offset = base;
key.tile_width = xe::round_up(pitch, tile_width) / tile_width;
key.tile_height = 160;
key.color_or_depth = color_or_depth ? 1 : 0;
key.msaa_samples = 0;
key.edram_format = static_cast<uint16_t>(format);
auto view = FindTileView(key);
if (view) {
return view;
}
return nullptr;
}
CachedTileView* RenderCache::FindOrCreateTileView(
VkCommandBuffer command_buffer, const TileViewKey& view_key) {
auto tile_view = FindTileView(view_key);
if (tile_view) {
return tile_view;
}
// Create a new tile and add to the cache.
tile_view = new CachedTileView(device_, edram_memory_, view_key);
VkResult status = tile_view->Initialize(command_buffer);
if (status != VK_SUCCESS) {
XELOGE("{}: Failed to create tile view, status {}", __func__,
ui::vulkan::to_string(status));
delete tile_view;
return nullptr;
}
cached_tile_views_.push_back(tile_view);
return tile_view;
}
void RenderCache::UpdateTileView(VkCommandBuffer command_buffer,
CachedTileView* view, bool load,
bool insert_barrier) {
uint32_t tile_width =
view->key.msaa_samples == uint16_t(xenos::MsaaSamples::k4X) ? 40 : 80;
uint32_t tile_height =
view->key.msaa_samples != uint16_t(xenos::MsaaSamples::k1X) ? 8 : 16;
if (insert_barrier) {
VkBufferMemoryBarrier barrier;
barrier.sType = VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER;
barrier.pNext = nullptr;
if (load) {
barrier.srcAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT;
barrier.dstAccessMask = VK_ACCESS_TRANSFER_READ_BIT;
} else {
barrier.srcAccessMask = VK_ACCESS_TRANSFER_READ_BIT;
barrier.dstAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT;
}
barrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
barrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
barrier.buffer = edram_buffer_;
barrier.offset = view->key.tile_offset * 5120;
barrier.size = view->key.tile_width * tile_width * view->key.tile_height *
tile_height * view->key.color_or_depth
? 4
: 1;
vkCmdPipelineBarrier(command_buffer, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT,
VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, 0, 0, nullptr, 1,
&barrier, 0, nullptr);
}
// TODO(DrChat): Stencil copies.
VkBufferImageCopy region;
region.bufferOffset = view->key.tile_offset * 5120;
region.bufferRowLength = 0;
region.bufferImageHeight = 0;
region.imageSubresource = {0, 0, 0, 1};
region.imageSubresource.aspectMask = view->key.color_or_depth
? VK_IMAGE_ASPECT_COLOR_BIT
: VK_IMAGE_ASPECT_DEPTH_BIT;
region.imageOffset = {0, 0, 0};
region.imageExtent = {view->key.tile_width * tile_width,
view->key.tile_height * tile_height, 1};
if (load) {
vkCmdCopyBufferToImage(command_buffer, edram_buffer_, view->image,
VK_IMAGE_LAYOUT_GENERAL, 1, &region);
} else {
vkCmdCopyImageToBuffer(command_buffer, view->image, VK_IMAGE_LAYOUT_GENERAL,
edram_buffer_, 1, &region);
}
}
CachedTileView* RenderCache::FindTileView(const TileViewKey& view_key) const {
// Check the cache.
// TODO(benvanik): better lookup.
for (auto tile_view : cached_tile_views_) {
if (tile_view->IsEqual(view_key)) {
return tile_view;
}
}
return nullptr;
}
void RenderCache::EndRenderPass() {
assert_not_null(current_command_buffer_);
// End the render pass.
vkCmdEndRenderPass(current_command_buffer_);
// Copy all render targets back into our EDRAM buffer.
// Don't bother waiting on this command to complete, as next render pass may
// reuse previous framebuffer attachments. If they need this, they will wait.
// TODO: Should we bother re-tiling the images on copy back?
//
// FIXME: There's a case where we may have a really big render target (as we
// can't get the correct height atm) and we may end up overwriting the valid
// contents of another render target by mistake! Need to reorder copy commands
// to avoid this.
// TODO(DrChat): Determine if we actually need an EDRAM buffer.
/*
std::vector<CachedTileView*> cached_views;
// Depth
auto depth_target = current_state_.framebuffer->depth_stencil_attachment;
if (depth_target && current_state_.config.depth_stencil.used) {
cached_views.push_back(depth_target);
}
// Color
for (int i = 0; i < 4; i++) {
auto target = current_state_.framebuffer->color_attachments[i];
if (!target || !current_state_.config.color[i].used) {
continue;
}
cached_views.push_back(target);
}
std::sort(
cached_views.begin(), cached_views.end(),
[](CachedTileView const* a, CachedTileView const* b) { return *a < *b; });
for (auto view : cached_views) {
UpdateTileView(current_command_buffer_, view, false, false);
}
*/
current_command_buffer_ = nullptr;
}
void RenderCache::ClearCache() {
// TODO(benvanik): caching.
}
void RenderCache::RawCopyToImage(VkCommandBuffer command_buffer,
uint32_t edram_base, VkImage image,
VkImageLayout image_layout,
bool color_or_depth, VkOffset3D offset,
VkExtent3D extents) {
// Transition the texture into a transfer destination layout.
VkImageMemoryBarrier image_barrier;
image_barrier.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER;
image_barrier.pNext = nullptr;
image_barrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
image_barrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
if (image_layout != VK_IMAGE_LAYOUT_GENERAL &&
image_layout != VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL) {
image_barrier.srcAccessMask = 0;
image_barrier.dstAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT;
image_barrier.oldLayout = image_layout;
image_barrier.newLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL;
image_barrier.image = image;
image_barrier.subresourceRange = {0, 0, 1, 0, 1};
image_barrier.subresourceRange.aspectMask =
color_or_depth
? VK_IMAGE_ASPECT_COLOR_BIT
: VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT;
vkCmdPipelineBarrier(command_buffer, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT,
VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, 0, 0, nullptr, 0,
nullptr, 1, &image_barrier);
}
VkBufferMemoryBarrier buffer_barrier;
buffer_barrier.sType = VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER;
buffer_barrier.srcAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT;
buffer_barrier.dstAccessMask = VK_ACCESS_TRANSFER_READ_BIT;
buffer_barrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
buffer_barrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
buffer_barrier.buffer = edram_buffer_;
buffer_barrier.offset = edram_base * 5120;
// TODO: Calculate this accurately (need texel size)
buffer_barrier.size = extents.width * extents.height * 4;
vkCmdPipelineBarrier(command_buffer, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT,
VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, 0, 0, nullptr, 1,
&buffer_barrier, 0, nullptr);
// Issue the copy command.
// TODO(DrChat): Stencil copies.
VkBufferImageCopy region;
region.bufferOffset = edram_base * 5120;
region.bufferImageHeight = 0;
region.bufferRowLength = 0;
region.imageOffset = offset;
region.imageExtent = extents;
region.imageSubresource = {0, 0, 0, 1};
region.imageSubresource.aspectMask =
color_or_depth ? VK_IMAGE_ASPECT_COLOR_BIT : VK_IMAGE_ASPECT_DEPTH_BIT;
vkCmdCopyBufferToImage(command_buffer, edram_buffer_, image, image_layout, 1,
&region);
// Transition the image back into its previous layout.
if (image_layout != VK_IMAGE_LAYOUT_GENERAL &&
image_layout != VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL) {
image_barrier.srcAccessMask = image_barrier.dstAccessMask;
image_barrier.dstAccessMask = 0;
std::swap(image_barrier.oldLayout, image_barrier.newLayout);
vkCmdPipelineBarrier(command_buffer, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT,
VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, 0, 0, nullptr, 0,
nullptr, 1, &image_barrier);
}
}
void RenderCache::BlitToImage(VkCommandBuffer command_buffer,
uint32_t edram_base, uint32_t pitch,
uint32_t height, xenos::MsaaSamples num_samples,
VkImage image, VkImageLayout image_layout,
bool color_or_depth, uint32_t format,
VkFilter filter, VkOffset3D offset,
VkExtent3D extents) {
if (color_or_depth) {
// Adjust similar formats for easier matching.
format = static_cast<uint32_t>(
GetBaseRTFormat(static_cast<xenos::ColorRenderTargetFormat>(format)));
}
uint32_t tile_width = num_samples == xenos::MsaaSamples::k4X ? 40 : 80;
uint32_t tile_height = num_samples != xenos::MsaaSamples::k1X ? 8 : 16;
// Grab a tile view that represents the source image.
TileViewKey key;
key.color_or_depth = color_or_depth ? 1 : 0;
key.msaa_samples = 0; // static_cast<uint16_t>(num_samples);
key.edram_format = format;
key.tile_offset = edram_base;
key.tile_width = xe::round_up(pitch, tile_width) / tile_width;
// key.tile_height = xe::round_up(height, tile_height) / tile_height;
key.tile_height = 160;
auto tile_view = FindOrCreateTileView(command_buffer, key);
assert_not_null(tile_view);
// Update the view with the latest contents.
// UpdateTileView(command_buffer, tile_view, true, true);
// Put a barrier on the tile view.
VkImageMemoryBarrier image_barrier;
image_barrier.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER;
image_barrier.pNext = nullptr;
image_barrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
image_barrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
image_barrier.srcAccessMask =
color_or_depth ? VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT
: VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT;
image_barrier.dstAccessMask = VK_ACCESS_TRANSFER_READ_BIT;
image_barrier.oldLayout = VK_IMAGE_LAYOUT_GENERAL;
image_barrier.newLayout = VK_IMAGE_LAYOUT_GENERAL;
image_barrier.image = tile_view->image;
image_barrier.subresourceRange = {0, 0, 1, 0, 1};
image_barrier.subresourceRange.aspectMask =
color_or_depth ? VK_IMAGE_ASPECT_COLOR_BIT
: VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT;
vkCmdPipelineBarrier(command_buffer, VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT,
VK_PIPELINE_STAGE_TRANSFER_BIT, 0, 0, nullptr, 0,
nullptr, 1, &image_barrier);
// If we overflow we'll lose the device here.
// assert_true(extents.width <= key.tile_width * tile_width);
// assert_true(extents.height <= key.tile_height * tile_height);
// Now issue the blit to the destination.
if (tile_view->sample_count == VK_SAMPLE_COUNT_1_BIT) {
VkImageBlit image_blit;
image_blit.srcSubresource = {0, 0, 0, 1};
image_blit.srcSubresource.aspectMask =
color_or_depth ? VK_IMAGE_ASPECT_COLOR_BIT : VK_IMAGE_ASPECT_DEPTH_BIT;
image_blit.srcOffsets[0] = {0, 0, offset.z};
image_blit.srcOffsets[1] = {int32_t(extents.width), int32_t(extents.height),
int32_t(extents.depth)};
image_blit.dstSubresource = {0, 0, 0, 1};
image_blit.dstSubresource.aspectMask =
color_or_depth ? VK_IMAGE_ASPECT_COLOR_BIT : VK_IMAGE_ASPECT_DEPTH_BIT;
image_blit.dstOffsets[0] = offset;
image_blit.dstOffsets[1] = {offset.x + int32_t(extents.width),
offset.y + int32_t(extents.height),
offset.z + int32_t(extents.depth)};
vkCmdBlitImage(command_buffer, tile_view->image, VK_IMAGE_LAYOUT_GENERAL,
image, image_layout, 1, &image_blit, filter);
} else {
VkImageResolve image_resolve;
image_resolve.srcSubresource = {0, 0, 0, 1};
image_resolve.srcSubresource.aspectMask =
color_or_depth ? VK_IMAGE_ASPECT_COLOR_BIT : VK_IMAGE_ASPECT_DEPTH_BIT;
image_resolve.srcOffset = {0, 0, 0};
image_resolve.dstSubresource = {0, 0, 0, 1};
image_resolve.dstSubresource.aspectMask =
color_or_depth ? VK_IMAGE_ASPECT_COLOR_BIT : VK_IMAGE_ASPECT_DEPTH_BIT;
image_resolve.dstOffset = offset;
image_resolve.extent = extents;
vkCmdResolveImage(command_buffer, tile_view->image, VK_IMAGE_LAYOUT_GENERAL,
image, image_layout, 1, &image_resolve);
}
// Add another barrier on the tile view.
image_barrier.srcAccessMask = image_barrier.dstAccessMask;
image_barrier.dstAccessMask =
color_or_depth ? VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT
: VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT;
std::swap(image_barrier.oldLayout, image_barrier.newLayout);
vkCmdPipelineBarrier(command_buffer, VK_PIPELINE_STAGE_TRANSFER_BIT,
VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, 0, 0, nullptr, 0,
nullptr, 1, &image_barrier);
}
void RenderCache::ClearEDRAMColor(VkCommandBuffer command_buffer,
uint32_t edram_base,
xenos::ColorRenderTargetFormat format,
uint32_t pitch, uint32_t height,
xenos::MsaaSamples num_samples,
float* color) {
// TODO: For formats <= 4 bpp, we can directly fill the EDRAM buffer. Just
// need to detect this and calculate a value.
// Adjust similar formats for easier matching.
format = GetBaseRTFormat(static_cast<xenos::ColorRenderTargetFormat>(format));
uint32_t tile_width = num_samples == xenos::MsaaSamples::k4X ? 40 : 80;
uint32_t tile_height = num_samples != xenos::MsaaSamples::k1X ? 8 : 16;
// Grab a tile view (as we need to clear an image first)
TileViewKey key;
key.color_or_depth = 1;
key.msaa_samples = 0; // static_cast<uint16_t>(num_samples);
key.edram_format = static_cast<uint16_t>(format);
key.tile_offset = edram_base;
key.tile_width = xe::round_up(pitch, tile_width) / tile_width;
// key.tile_height = xe::round_up(height, tile_height) / tile_height;
key.tile_height = 160;
auto tile_view = FindOrCreateTileView(command_buffer, key);
assert_not_null(tile_view);
VkImageSubresourceRange range = {VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 1};
VkClearColorValue clear_value;
std::memcpy(clear_value.float32, color, sizeof(float) * 4);
// Issue a clear command
vkCmdClearColorImage(command_buffer, tile_view->image,
VK_IMAGE_LAYOUT_GENERAL, &clear_value, 1, &range);
// Copy image back into EDRAM buffer
// UpdateTileView(command_buffer, tile_view, false, false);
}
void RenderCache::ClearEDRAMDepthStencil(VkCommandBuffer command_buffer,
uint32_t edram_base,
xenos::DepthRenderTargetFormat format,
uint32_t pitch, uint32_t height,
xenos::MsaaSamples num_samples,
float depth, uint32_t stencil) {
// TODO: For formats <= 4 bpp, we can directly fill the EDRAM buffer. Just
// need to detect this and calculate a value.
uint32_t tile_width = num_samples == xenos::MsaaSamples::k4X ? 40 : 80;
uint32_t tile_height = num_samples != xenos::MsaaSamples::k1X ? 8 : 16;
// Grab a tile view (as we need to clear an image first)
TileViewKey key;
key.color_or_depth = 0;
key.msaa_samples = 0; // static_cast<uint16_t>(num_samples);
key.edram_format = static_cast<uint16_t>(format);
key.tile_offset = edram_base;
key.tile_width = xe::round_up(pitch, tile_width) / tile_width;
// key.tile_height = xe::round_up(height, tile_height) / tile_height;
key.tile_height = 160;
auto tile_view = FindOrCreateTileView(command_buffer, key);
assert_not_null(tile_view);
VkImageSubresourceRange range = {
VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT, 0, 1, 0, 1,
};
VkClearDepthStencilValue clear_value;
clear_value.depth = depth;
clear_value.stencil = stencil;
// Issue a clear command
vkCmdClearDepthStencilImage(command_buffer, tile_view->image,
VK_IMAGE_LAYOUT_GENERAL, &clear_value, 1, &range);
// Copy image back into EDRAM buffer
// UpdateTileView(command_buffer, tile_view, false, false);
}
void RenderCache::FillEDRAM(VkCommandBuffer command_buffer, uint32_t value) {
vkCmdFillBuffer(command_buffer, edram_buffer_, 0, kEdramBufferCapacity,
value);
}
bool RenderCache::SetShadowRegister(uint32_t* dest, uint32_t register_name) {
uint32_t value = register_file_->values[register_name].u32;
if (*dest == value) {
return false;
}
*dest = value;
return true;
}
} // namespace vulkan
} // namespace gpu
} // namespace xe
Reference in New Issue View Git Blame Copy Permalink