rooty/dxvk
1
0
Fork 0
mirror of https://github.com/doitsujin/dxvk.git synced 2025-04-01 09:25:24 +02:00
Code Issues Projects Releases Wiki Activity

[dxvk] Don't create shader modules for internal copy pipelines

Browse Source
This commit is contained in:
Philip Rebohle 2025-03-23 23:34:41 +01:00
parent 9e33073a5f
commit 6f5e185ceb
2 changed files with 130 additions and 197 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

298
src/dxvk/dxvk_meta_copy.cpp
View File

@ -1,5 +1,6 @@
#include "dxvk_device.h" #include "dxvk_device.h"
#include "dxvk_meta_copy.h" #include "dxvk_meta_copy.h"
#include "dxvk_util.h"
#include <dxvk_fullscreen_geom.h> #include <dxvk_fullscreen_geom.h>
#include <dxvk_fullscreen_vert.h> #include <dxvk_fullscreen_vert.h>
@ -77,74 +78,36 @@ namespace dxvk {
} }
DxvkMetaCopyObjects::DxvkMetaCopyObjects(const DxvkDevice* device) DxvkMetaCopyObjects::DxvkMetaCopyObjects(DxvkDevice* device)
: m_vkd (device->vkd()), : m_device(device) {
m_color {
createShaderModule(dxvk_copy_color_1d),
createShaderModule(dxvk_copy_color_2d),
createShaderModule(dxvk_copy_color_ms) } {
if (device->features().vk12.shaderOutputLayer) {
m_shaderVert = createShaderModule(dxvk_fullscreen_layer_vert);
} else {
m_shaderVert = createShaderModule(dxvk_fullscreen_vert);
m_shaderGeom = createShaderModule(dxvk_fullscreen_geom);
}
if (device->features().extShaderStencilExport) {
m_depthStencil = {
createShaderModule(dxvk_copy_depth_stencil_1d),
createShaderModule(dxvk_copy_depth_stencil_2d),
createShaderModule(dxvk_copy_depth_stencil_ms) };
m_shaderBufferToImageDSExport = createShaderModule(dxvk_buffer_to_image_ds_export);
} else {
m_shaderBufferToImageD = createShaderModule(dxvk_buffer_to_image_d);
m_shaderBufferToImageS = createShaderModule(dxvk_buffer_to_image_s_discard);
}
m_shaderImageToBufferDS = createShaderModule(dxvk_image_to_buffer_ds);
m_shaderImageToBufferF = createShaderModule(dxvk_image_to_buffer_f);
} }
DxvkMetaCopyObjects::~DxvkMetaCopyObjects() { DxvkMetaCopyObjects::~DxvkMetaCopyObjects() {
auto vk = m_device->vkd();
for (const auto& p : m_bufferToImagePipelines) for (const auto& p : m_bufferToImagePipelines)
m_vkd->vkDestroyPipeline(m_vkd->device(), p.second, nullptr); vk->vkDestroyPipeline(vk->device(), p.second, nullptr);
for (const auto& p : m_imageToBufferPipelines) for (const auto& p : m_imageToBufferPipelines)
m_vkd->vkDestroyPipeline(m_vkd->device(), p.second, nullptr); vk->vkDestroyPipeline(vk->device(), p.second, nullptr);
m_vkd->vkDestroyDescriptorSetLayout(m_vkd->device(), m_bufferToImageCopySetLayout, nullptr); vk->vkDestroyDescriptorSetLayout(vk->device(), m_bufferToImageCopySetLayout, nullptr);
m_vkd->vkDestroyDescriptorSetLayout(m_vkd->device(), m_imageToBufferCopySetLayout, nullptr); vk->vkDestroyDescriptorSetLayout(vk->device(), m_imageToBufferCopySetLayout, nullptr);
m_vkd->vkDestroyPipelineLayout(m_vkd->device(), m_bufferToImageCopyPipelineLayout, nullptr); vk->vkDestroyPipelineLayout(vk->device(), m_bufferToImageCopyPipelineLayout, nullptr);
m_vkd->vkDestroyPipelineLayout(m_vkd->device(), m_imageToBufferCopyPipelineLayout, nullptr); vk->vkDestroyPipelineLayout(vk->device(), m_imageToBufferCopyPipelineLayout, nullptr);
m_vkd->vkDestroyShaderModule(m_vkd->device(), m_shaderBufferToImageD, nullptr); vk->vkDestroyDescriptorSetLayout(vk->device(), m_copyBufferImagePipeline.dsetLayout, nullptr);
m_vkd->vkDestroyShaderModule(m_vkd->device(), m_shaderBufferToImageS, nullptr); vk->vkDestroyPipeline(vk->device(), m_copyBufferImagePipeline.pipeHandle, nullptr);
m_vkd->vkDestroyShaderModule(m_vkd->device(), m_shaderBufferToImageDSExport, nullptr); vk->vkDestroyPipelineLayout(vk->device(), m_copyBufferImagePipeline.pipeLayout, nullptr);
m_vkd->vkDestroyShaderModule(m_vkd->device(), m_shaderImageToBufferF, nullptr);
m_vkd->vkDestroyShaderModule(m_vkd->device(), m_shaderImageToBufferDS, nullptr);
m_vkd->vkDestroyDescriptorSetLayout(m_vkd->device(), m_copyBufferImagePipeline.dsetLayout, nullptr);
m_vkd->vkDestroyPipeline(m_vkd->device(), m_copyBufferImagePipeline.pipeHandle, nullptr);
m_vkd->vkDestroyPipelineLayout(m_vkd->device(), m_copyBufferImagePipeline.pipeLayout, nullptr);
for (const auto& pair : m_pipelines) { for (const auto& pair : m_pipelines) {
m_vkd->vkDestroyPipeline(m_vkd->device(), pair.second.pipeHandle, nullptr); vk->vkDestroyPipeline(vk->device(), pair.second.pipeHandle, nullptr);
m_vkd->vkDestroyPipelineLayout(m_vkd->device(), pair.second.pipeLayout, nullptr); vk->vkDestroyPipelineLayout(vk->device(), pair.second.pipeLayout, nullptr);
m_vkd->vkDestroyDescriptorSetLayout (m_vkd->device(), pair.second.dsetLayout, nullptr); vk->vkDestroyDescriptorSetLayout(vk->device(), pair.second.dsetLayout, nullptr);
} }
m_vkd->vkDestroyShaderModule(m_vkd->device(), m_depthStencil.fragMs, nullptr);
m_vkd->vkDestroyShaderModule(m_vkd->device(), m_depthStencil.frag2D, nullptr);
m_vkd->vkDestroyShaderModule(m_vkd->device(), m_depthStencil.frag1D, nullptr);
m_vkd->vkDestroyShaderModule(m_vkd->device(), m_color.fragMs, nullptr);
m_vkd->vkDestroyShaderModule(m_vkd->device(), m_color.frag2D, nullptr);
m_vkd->vkDestroyShaderModule(m_vkd->device(), m_color.frag1D, nullptr);
m_vkd->vkDestroyShaderModule(m_vkd->device(), m_shaderGeom, nullptr);
m_vkd->vkDestroyShaderModule(m_vkd->device(), m_shaderVert, nullptr);
} }
@ -267,20 +230,9 @@ namespace dxvk {
} }
VkShaderModule DxvkMetaCopyObjects::createShaderModule(
const SpirvCodeBuffer& code) const {
VkShaderModuleCreateInfo info = { VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO };
info.codeSize = code.size();
info.pCode = code.data();
VkShaderModule result = VK_NULL_HANDLE;
if (m_vkd->vkCreateShaderModule(m_vkd->device(), &info, nullptr, &result) != VK_SUCCESS)
throw DxvkError("DxvkMetaCopyObjects: Failed to create shader module");
return result;
}
DxvkMetaCopyPipeline DxvkMetaCopyObjects::createCopyFormattedBufferPipeline() { DxvkMetaCopyPipeline DxvkMetaCopyObjects::createCopyFormattedBufferPipeline() {
auto vk = m_device->vkd();
DxvkMetaCopyPipeline pipeline; DxvkMetaCopyPipeline pipeline;
std::array<VkDescriptorSetLayoutBinding, 2> bindings = {{ std::array<VkDescriptorSetLayoutBinding, 2> bindings = {{
@ -292,7 +244,7 @@ namespace dxvk {
setLayoutInfo.bindingCount = bindings.size(); setLayoutInfo.bindingCount = bindings.size();
setLayoutInfo.pBindings = bindings.data(); setLayoutInfo.pBindings = bindings.data();
if (m_vkd->vkCreateDescriptorSetLayout(m_vkd->device(), &setLayoutInfo, nullptr, &pipeline.dsetLayout) != VK_SUCCESS) if (vk->vkCreateDescriptorSetLayout(vk->device(), &setLayoutInfo, nullptr, &pipeline.dsetLayout))
throw DxvkError("DxvkMetaCopyObjects: Failed to create descriptor set layout"); throw DxvkError("DxvkMetaCopyObjects: Failed to create descriptor set layout");
VkPushConstantRange pushRange = { VK_SHADER_STAGE_COMPUTE_BIT, 0, sizeof(DxvkFormattedBufferCopyArgs) }; VkPushConstantRange pushRange = { VK_SHADER_STAGE_COMPUTE_BIT, 0, sizeof(DxvkFormattedBufferCopyArgs) };
@ -303,24 +255,25 @@ namespace dxvk {
pipelineLayoutInfo.pushConstantRangeCount = 1; pipelineLayoutInfo.pushConstantRangeCount = 1;
pipelineLayoutInfo.pPushConstantRanges = &pushRange; pipelineLayoutInfo.pPushConstantRanges = &pushRange;
if (m_vkd->vkCreatePipelineLayout(m_vkd->device(), &pipelineLayoutInfo, nullptr, &pipeline.pipeLayout) != VK_SUCCESS) if (vk->vkCreatePipelineLayout(vk->device(), &pipelineLayoutInfo, nullptr, &pipeline.pipeLayout))
throw DxvkError("DxvkMetaCopyObjects: Failed to create pipeline layout"); throw DxvkError("DxvkMetaCopyObjects: Failed to create pipeline layout");
VkShaderModule shaderModule = createShaderModule(dxvk_copy_buffer_image); VkShaderModuleCreateInfo moduleInfo = { VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO };
moduleInfo.codeSize = sizeof(dxvk_copy_buffer_image);
moduleInfo.pCode = dxvk_copy_buffer_image;
VkComputePipelineCreateInfo pipelineInfo = { VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO }; VkComputePipelineCreateInfo pipelineInfo = { VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO };
pipelineInfo.layout = pipeline.pipeLayout; pipelineInfo.layout = pipeline.pipeLayout;
pipelineInfo.stage.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO; pipelineInfo.stage.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
pipelineInfo.stage.pNext = &moduleInfo;
pipelineInfo.stage.stage = VK_SHADER_STAGE_COMPUTE_BIT; pipelineInfo.stage.stage = VK_SHADER_STAGE_COMPUTE_BIT;
pipelineInfo.stage.module = shaderModule;
pipelineInfo.stage.pName = "main"; pipelineInfo.stage.pName = "main";
pipelineInfo.basePipelineIndex = -1; pipelineInfo.basePipelineIndex = -1;
if (m_vkd->vkCreateComputePipelines(m_vkd->device(), VK_NULL_HANDLE, if (vk->vkCreateComputePipelines(vk->device(), VK_NULL_HANDLE,
1, &pipelineInfo, nullptr, &pipeline.pipeHandle) != VK_SUCCESS) 1, &pipelineInfo, nullptr, &pipeline.pipeHandle) != VK_SUCCESS)
throw DxvkError("DxvkMetaCopyObjects: Failed to create compute pipeline"); throw DxvkError("DxvkMetaCopyObjects: Failed to create compute pipeline");
m_vkd->vkDestroyShaderModule(m_vkd->device(), shaderModule, nullptr);
return pipeline; return pipeline;
} }
@ -337,6 +290,8 @@ namespace dxvk {
VkPipeline DxvkMetaCopyObjects::createCopyBufferToImagePipeline( VkPipeline DxvkMetaCopyObjects::createCopyBufferToImagePipeline(
const DxvkMetaBufferImageCopyPipelineKey& key) { const DxvkMetaBufferImageCopyPipelineKey& key) {
auto vk = m_device->vkd();
if (!m_bufferToImageCopySetLayout) { if (!m_bufferToImageCopySetLayout) {
std::array<VkDescriptorSetLayoutBinding, 1> bindings = {{ std::array<VkDescriptorSetLayoutBinding, 1> bindings = {{
{ 0, VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER, 1, VK_SHADER_STAGE_FRAGMENT_BIT } { 0, VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER, 1, VK_SHADER_STAGE_FRAGMENT_BIT }
@ -346,10 +301,10 @@ namespace dxvk {
info.bindingCount = bindings.size(); info.bindingCount = bindings.size();
info.pBindings = bindings.data(); info.pBindings = bindings.data();
VkResult vr = m_vkd->vkCreateDescriptorSetLayout(m_vkd->device(), VkResult vr = vk->vkCreateDescriptorSetLayout(vk->device(),
&info, nullptr, &m_bufferToImageCopySetLayout); &info, nullptr, &m_bufferToImageCopySetLayout);
if (vr != VK_SUCCESS) if (vr)
throw DxvkError(str::format("DxvkMetaCopyObjects: Failed to create descriptor set layout: ", vr)); throw DxvkError(str::format("DxvkMetaCopyObjects: Failed to create descriptor set layout: ", vr));
} }
@ -365,56 +320,31 @@ namespace dxvk {
info.pushConstantRangeCount = 1; info.pushConstantRangeCount = 1;
info.pPushConstantRanges = &pushConstants; info.pPushConstantRanges = &pushConstants;
VkResult vr = m_vkd->vkCreatePipelineLayout(m_vkd->device(), VkResult vr = vk->vkCreatePipelineLayout(vk->device(),
&info, nullptr, &m_bufferToImageCopyPipelineLayout); &info, nullptr, &m_bufferToImageCopyPipelineLayout);
if (vr != VK_SUCCESS) if (vr)
throw DxvkError(str::format("DxvkMetaCopyObjects: Failed to create pipeline layout: ", vr)); throw DxvkError(str::format("DxvkMetaCopyObjects: Failed to create pipeline layout: ", vr));
} }
std::array<VkPipelineShaderStageCreateInfo, 3> stages = { };
uint32_t stageCount = 0;
stages[stageCount++] = VkPipelineShaderStageCreateInfo {
VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO, nullptr, 0,
VK_SHADER_STAGE_VERTEX_BIT, m_shaderVert, "main" };
if (m_shaderGeom) {
stages[stageCount++] = VkPipelineShaderStageCreateInfo {
VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO, nullptr, 0,
VK_SHADER_STAGE_GEOMETRY_BIT, m_shaderGeom, "main" };
}
// We don't support color right now // We don't support color right now
if (!(key.imageAspects & (VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT))) { if (!(key.imageAspects & (VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT))) {
Logger::err(str::format("DxvkMetaCopyObjects: Color images not unsupported")); Logger::err(str::format("DxvkMetaCopyObjects: Color images not supported"));
return VK_NULL_HANDLE; return VK_NULL_HANDLE;
} }
VkSpecializationMapEntry specMap = { }; // Set up geometry stages as necessary
specMap.size = sizeof(VkFormat); util::DxvkBuiltInShaderStages stages = { };
VkSpecializationInfo specInfo = { }; if (m_device->features().vk12.shaderOutputLayer) {
specInfo.mapEntryCount = 1; stages.addStage(VK_SHADER_STAGE_VERTEX_BIT, dxvk_fullscreen_layer_vert, nullptr);
specInfo.pMapEntries = &specMap; } else {
specInfo.dataSize = sizeof(VkFormat); stages.addStage(VK_SHADER_STAGE_VERTEX_BIT, dxvk_fullscreen_vert, nullptr);
specInfo.pData = &key.bufferFormat; stages.addStage(VK_SHADER_STAGE_GEOMETRY_BIT, dxvk_fullscreen_geom, nullptr);
// Always use the DS export shader if possible, it can
// support writing to one aspect exclusively.
auto& stage = stages[stageCount++];
stage.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
stage.stage = VK_SHADER_STAGE_FRAGMENT_BIT;
stage.module = m_shaderBufferToImageDSExport;
stage.pName = "main";
stage.pSpecializationInfo = &specInfo;
if (!m_shaderBufferToImageDSExport) {
stage.module = key.imageAspects == VK_IMAGE_ASPECT_STENCIL_BIT
? m_shaderBufferToImageS
: m_shaderBufferToImageD;
} }
// Set up dynamic states. Stencil write mask is
// only required for the stencil discard shader.
std::array<VkDynamicState, 3> dynStates = {{ std::array<VkDynamicState, 3> dynStates = {{
VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT, VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT,
VK_DYNAMIC_STATE_SCISSOR_WITH_COUNT, VK_DYNAMIC_STATE_SCISSOR_WITH_COUNT,
@ -425,8 +355,26 @@ namespace dxvk {
dynState.dynamicStateCount = dynStates.size(); dynState.dynamicStateCount = dynStates.size();
dynState.pDynamicStates = dynStates.data(); dynState.pDynamicStates = dynStates.data();
if (stage.module != m_shaderBufferToImageS) // Determine fragment shader to use. Always use the DS export shader
dynState.dynamicStateCount -= 1; // if possible, it can support writing to one aspect exclusively.
VkSpecializationMapEntry specMap = { };
specMap.size = sizeof(VkFormat);
VkSpecializationInfo specInfo = { };
specInfo.mapEntryCount = 1;
specInfo.pMapEntries = &specMap;
specInfo.dataSize = sizeof(VkFormat);
specInfo.pData = &key.bufferFormat;
if (m_device->features().extShaderStencilExport) {
stages.addStage(VK_SHADER_STAGE_FRAGMENT_BIT, dxvk_buffer_to_image_ds_export, &specInfo);
dynState.dynamicStateCount -= 1u;
} else if (key.imageAspects == VK_IMAGE_ASPECT_STENCIL_BIT) {
stages.addStage(VK_SHADER_STAGE_FRAGMENT_BIT, dxvk_buffer_to_image_s_discard, &specInfo);
} else {
stages.addStage(VK_SHADER_STAGE_FRAGMENT_BIT, dxvk_buffer_to_image_d, &specInfo);
dynState.dynamicStateCount -= 1u;
}
VkPipelineVertexInputStateCreateInfo viState = { VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO }; VkPipelineVertexInputStateCreateInfo viState = { VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO };
@ -466,7 +414,7 @@ namespace dxvk {
stencilOp.reference = 0xff; stencilOp.reference = 0xff;
// Clear stencil for depth-only aspect // Clear stencil for depth-only aspect
if (stage.module == m_shaderBufferToImageD) if (!m_device->features().extShaderStencilExport && key.imageAspects != VK_IMAGE_ASPECT_STENCIL_BIT)
stencilOp.reference = 0x00; stencilOp.reference = 0x00;
VkPipelineDepthStencilStateCreateInfo dsState = { VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO }; VkPipelineDepthStencilStateCreateInfo dsState = { VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO };
@ -492,8 +440,8 @@ namespace dxvk {
} }
VkGraphicsPipelineCreateInfo info = { VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO, &rtState }; VkGraphicsPipelineCreateInfo info = { VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO, &rtState };
info.stageCount = stageCount; info.stageCount = stages.count();
info.pStages = stages.data(); info.pStages = stages.infos();
info.pVertexInputState = &viState; info.pVertexInputState = &viState;
info.pInputAssemblyState = &iaState; info.pInputAssemblyState = &iaState;
info.pViewportState = &vpState; info.pViewportState = &vpState;
@ -506,7 +454,7 @@ namespace dxvk {
info.basePipelineIndex = -1; info.basePipelineIndex = -1;
VkPipeline pipeline = VK_NULL_HANDLE; VkPipeline pipeline = VK_NULL_HANDLE;
VkResult vr = m_vkd->vkCreateGraphicsPipelines(m_vkd->device(), VkResult vr = vk->vkCreateGraphicsPipelines(vk->device(),
VK_NULL_HANDLE, 1, &info, nullptr, &pipeline); VK_NULL_HANDLE, 1, &info, nullptr, &pipeline);
if (vr != VK_SUCCESS) if (vr != VK_SUCCESS)
@ -518,6 +466,8 @@ namespace dxvk {
VkPipeline DxvkMetaCopyObjects::createCopyImageToBufferPipeline( VkPipeline DxvkMetaCopyObjects::createCopyImageToBufferPipeline(
const DxvkMetaBufferImageCopyPipelineKey& key) { const DxvkMetaBufferImageCopyPipelineKey& key) {
auto vk = m_device->vkd();
if (!m_imageToBufferCopySetLayout) { if (!m_imageToBufferCopySetLayout) {
std::array<VkDescriptorSetLayoutBinding, 3> bindings = {{ std::array<VkDescriptorSetLayoutBinding, 3> bindings = {{
{ 0, VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER, 1, VK_SHADER_STAGE_COMPUTE_BIT }, { 0, VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER, 1, VK_SHADER_STAGE_COMPUTE_BIT },
@ -529,10 +479,10 @@ namespace dxvk {
info.bindingCount = bindings.size(); info.bindingCount = bindings.size();
info.pBindings = bindings.data(); info.pBindings = bindings.data();
VkResult vr = m_vkd->vkCreateDescriptorSetLayout(m_vkd->device(), VkResult vr = vk->vkCreateDescriptorSetLayout(vk->device(),
&info, nullptr, &m_imageToBufferCopySetLayout); &info, nullptr, &m_imageToBufferCopySetLayout);
if (vr != VK_SUCCESS) if (vr)
throw DxvkError(str::format("DxvkMetaCopyObjects: Failed to create descriptor set layout: ", vr)); throw DxvkError(str::format("DxvkMetaCopyObjects: Failed to create descriptor set layout: ", vr));
} }
@ -548,10 +498,10 @@ namespace dxvk {
info.pushConstantRangeCount = 1; info.pushConstantRangeCount = 1;
info.pPushConstantRanges = &pushConstants; info.pPushConstantRanges = &pushConstants;
VkResult vr = m_vkd->vkCreatePipelineLayout(m_vkd->device(), VkResult vr = vk->vkCreatePipelineLayout(vk->device(),
&info, nullptr, &m_imageToBufferCopyPipelineLayout); &info, nullptr, &m_imageToBufferCopyPipelineLayout);
if (vr != VK_SUCCESS) if (vr)
throw DxvkError(str::format("DxvkMetaCopyObjects: Failed to create pipeline layout: ", vr)); throw DxvkError(str::format("DxvkMetaCopyObjects: Failed to create pipeline layout: ", vr));
} }
@ -569,23 +519,31 @@ namespace dxvk {
specInfo.dataSize = sizeof(VkFormat); specInfo.dataSize = sizeof(VkFormat);
specInfo.pData = &key.bufferFormat; specInfo.pData = &key.bufferFormat;
VkShaderModuleCreateInfo moduleInfo = { VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO };
if (key.imageAspects & VK_IMAGE_ASPECT_STENCIL_BIT) {
moduleInfo.codeSize = sizeof(dxvk_image_to_buffer_ds);
moduleInfo.pCode = dxvk_image_to_buffer_ds;
} else {
moduleInfo.codeSize = sizeof(dxvk_image_to_buffer_f);
moduleInfo.pCode = dxvk_image_to_buffer_f;
}
VkComputePipelineCreateInfo info = { VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO }; VkComputePipelineCreateInfo info = { VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO };
info.stage.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO; info.stage.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
info.stage.pNext = &moduleInfo;
info.stage.pName = "main"; info.stage.pName = "main";
info.stage.stage = VK_SHADER_STAGE_COMPUTE_BIT; info.stage.stage = VK_SHADER_STAGE_COMPUTE_BIT;
info.stage.pSpecializationInfo = &specInfo; info.stage.pSpecializationInfo = &specInfo;
info.layout = m_imageToBufferCopyPipelineLayout; info.layout = m_imageToBufferCopyPipelineLayout;
info.basePipelineIndex = -1; info.basePipelineIndex = -1;
info.stage.module = key.imageAspects & VK_IMAGE_ASPECT_STENCIL_BIT
? m_shaderImageToBufferDS
: m_shaderImageToBufferF;
VkPipeline pipeline = VK_NULL_HANDLE; VkPipeline pipeline = VK_NULL_HANDLE;
VkResult vr = m_vkd->vkCreateComputePipelines(m_vkd->device(),
VkResult vr = vk->vkCreateComputePipelines(vk->device(),
VK_NULL_HANDLE, 1, &info, nullptr, &pipeline); VK_NULL_HANDLE, 1, &info, nullptr, &pipeline);
if (vr != VK_SUCCESS) if (vr)
throw DxvkError(str::format("DxvkMetaCopyObjects: Failed to create compute pipeline", vr)); throw DxvkError(str::format("DxvkMetaCopyObjects: Failed to create compute pipeline", vr));
return pipeline; return pipeline;
@ -594,6 +552,8 @@ namespace dxvk {
VkDescriptorSetLayout DxvkMetaCopyObjects::createDescriptorSetLayout( VkDescriptorSetLayout DxvkMetaCopyObjects::createDescriptorSetLayout(
const DxvkMetaCopyPipelineKey& key) const { const DxvkMetaCopyPipelineKey& key) const {
auto vk = m_device->vkd();
std::array<VkDescriptorSetLayoutBinding, 2> bindings = {{ std::array<VkDescriptorSetLayoutBinding, 2> bindings = {{
{ 0, VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, 1, VK_SHADER_STAGE_FRAGMENT_BIT }, { 0, VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, 1, VK_SHADER_STAGE_FRAGMENT_BIT },
{ 1, VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, 1, VK_SHADER_STAGE_FRAGMENT_BIT }, { 1, VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, 1, VK_SHADER_STAGE_FRAGMENT_BIT },
@ -604,14 +564,18 @@ namespace dxvk {
info.pBindings = bindings.data(); info.pBindings = bindings.data();
VkDescriptorSetLayout result = VK_NULL_HANDLE; VkDescriptorSetLayout result = VK_NULL_HANDLE;
if (m_vkd->vkCreateDescriptorSetLayout(m_vkd->device(), &info, nullptr, &result) != VK_SUCCESS)
if (vk->vkCreateDescriptorSetLayout(vk->device(), &info, nullptr, &result))
throw DxvkError("DxvkMetaCopyObjects: Failed to create descriptor set layout"); throw DxvkError("DxvkMetaCopyObjects: Failed to create descriptor set layout");
return result; return result;
} }
VkPipelineLayout DxvkMetaCopyObjects::createPipelineLayout( VkPipelineLayout DxvkMetaCopyObjects::createPipelineLayout(
VkDescriptorSetLayout descriptorSetLayout) const { VkDescriptorSetLayout descriptorSetLayout) const {
auto vk = m_device->vkd();
VkPushConstantRange push = { VK_SHADER_STAGE_FRAGMENT_BIT, 0, sizeof(VkOffset2D) }; VkPushConstantRange push = { VK_SHADER_STAGE_FRAGMENT_BIT, 0, sizeof(VkOffset2D) };
VkPipelineLayoutCreateInfo info = { VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO }; VkPipelineLayoutCreateInfo info = { VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO };
@ -621,8 +585,10 @@ namespace dxvk {
info.pPushConstantRanges = &push; info.pPushConstantRanges = &push;
VkPipelineLayout result = VK_NULL_HANDLE; VkPipelineLayout result = VK_NULL_HANDLE;
if (m_vkd->vkCreatePipelineLayout(m_vkd->device(), &info, nullptr, &result) != VK_SUCCESS)
if (vk->vkCreatePipelineLayout(vk->device(), &info, nullptr, &result))
throw DxvkError("DxvkMetaCopyObjects: Failed to create pipeline layout"); throw DxvkError("DxvkMetaCopyObjects: Failed to create pipeline layout");
return result; return result;
} }
@ -630,49 +596,37 @@ namespace dxvk {
VkPipeline DxvkMetaCopyObjects::createPipelineObject( VkPipeline DxvkMetaCopyObjects::createPipelineObject(
const DxvkMetaCopyPipelineKey& key, const DxvkMetaCopyPipelineKey& key,
VkPipelineLayout pipelineLayout) { VkPipelineLayout pipelineLayout) {
auto vk = m_device->vkd();
auto aspect = lookupFormatInfo(key.format)->aspectMask; auto aspect = lookupFormatInfo(key.format)->aspectMask;
std::array<VkPipelineShaderStageCreateInfo, 3> stages; // Set up geometry stages as necessary
uint32_t stageCount = 0; util::DxvkBuiltInShaderStages stages = { };
stages[stageCount++] = VkPipelineShaderStageCreateInfo {
VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO, nullptr, 0,
VK_SHADER_STAGE_VERTEX_BIT, m_shaderVert, "main" };
if (m_shaderGeom) {
stages[stageCount++] = VkPipelineShaderStageCreateInfo {
VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO, nullptr, 0,
VK_SHADER_STAGE_GEOMETRY_BIT, m_shaderGeom, "main" };
}
std::array<std::pair<const FragShaders*, VkImageAspectFlags>, 3> shaderSets = {{
{ &m_color, VK_IMAGE_ASPECT_COLOR_BIT },
{ &m_color, VK_IMAGE_ASPECT_DEPTH_BIT },
{ &m_depthStencil, VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT },
}};
const FragShaders* shaderSet = nullptr; if (m_device->features().vk12.shaderOutputLayer) {
stages.addStage(VK_SHADER_STAGE_VERTEX_BIT, dxvk_fullscreen_layer_vert, nullptr);
for (const auto& pair : shaderSets) { } else {
if (pair.second == aspect) stages.addStage(VK_SHADER_STAGE_VERTEX_BIT, dxvk_fullscreen_vert, nullptr);
shaderSet = pair.first; stages.addStage(VK_SHADER_STAGE_GEOMETRY_BIT, dxvk_fullscreen_geom, nullptr);
} }
if (!shaderSet) bool useDepthStencil = m_device->features().extShaderStencilExport
throw DxvkError(str::format("DxvkMetaCopyObjects: Unsupported aspect mask: ", aspect)); && (aspect == (VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT));
VkShaderModule psModule = VK_NULL_HANDLE; if (useDepthStencil) {
if (key.viewType == VK_IMAGE_VIEW_TYPE_1D)
if (key.viewType == VK_IMAGE_VIEW_TYPE_1D_ARRAY) stages.addStage(VK_SHADER_STAGE_FRAGMENT_BIT, dxvk_copy_depth_stencil_1d, nullptr);
psModule = shaderSet->frag1D; else if (key.samples == VK_SAMPLE_COUNT_1_BIT)
else if (key.samples == VK_SAMPLE_COUNT_1_BIT) stages.addStage(VK_SHADER_STAGE_FRAGMENT_BIT, dxvk_copy_depth_stencil_2d, nullptr);
psModule = shaderSet->frag2D; else
else stages.addStage(VK_SHADER_STAGE_FRAGMENT_BIT, dxvk_copy_depth_stencil_ms, nullptr);
psModule = shaderSet->fragMs; } else {
if (key.viewType == VK_IMAGE_VIEW_TYPE_1D)
stages[stageCount++] = VkPipelineShaderStageCreateInfo { stages.addStage(VK_SHADER_STAGE_FRAGMENT_BIT, dxvk_copy_color_1d, nullptr);
VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO, nullptr, 0, else if (key.samples == VK_SAMPLE_COUNT_1_BIT)
VK_SHADER_STAGE_FRAGMENT_BIT, psModule, "main" }; stages.addStage(VK_SHADER_STAGE_FRAGMENT_BIT, dxvk_copy_color_2d, nullptr);
else
stages.addStage(VK_SHADER_STAGE_FRAGMENT_BIT, dxvk_copy_color_ms, nullptr);
}
std::array<VkDynamicState, 2> dynStates = {{ std::array<VkDynamicState, 2> dynStates = {{
VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT, VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT,
@ -742,8 +696,8 @@ namespace dxvk {
} }
VkGraphicsPipelineCreateInfo info = { VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO, &rtState }; VkGraphicsPipelineCreateInfo info = { VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO, &rtState };
info.stageCount = stageCount; info.stageCount = stages.count();
info.pStages = stages.data(); info.pStages = stages.infos();
info.pVertexInputState = &viState; info.pVertexInputState = &viState;
info.pInputAssemblyState = &iaState; info.pInputAssemblyState = &iaState;
info.pViewportState = &vpState; info.pViewportState = &vpState;
@ -756,9 +710,11 @@ namespace dxvk {
info.basePipelineIndex = -1; info.basePipelineIndex = -1;
VkPipeline result = VK_NULL_HANDLE; VkPipeline result = VK_NULL_HANDLE;
if (m_vkd->vkCreateGraphicsPipelines(m_vkd->device(), VK_NULL_HANDLE, 1, &info, nullptr, &result) != VK_SUCCESS)
if (vk->vkCreateGraphicsPipelines(vk->device(), VK_NULL_HANDLE, 1, &info, nullptr, &result))
throw DxvkError("DxvkMetaCopyObjects: Failed to create graphics pipeline"); throw DxvkError("DxvkMetaCopyObjects: Failed to create graphics pipeline");
return result; return result;
} }
} }

29
src/dxvk/dxvk_meta_copy.h
View File

@ -142,7 +142,7 @@ namespace dxvk {
public: public:
DxvkMetaCopyObjects(const DxvkDevice* device); DxvkMetaCopyObjects(DxvkDevice* device);
~DxvkMetaCopyObjects(); ~DxvkMetaCopyObjects();
/** /**
@ -209,34 +209,14 @@ namespace dxvk {
private: private:
struct FragShaders { DxvkDevice* m_device = nullptr;
VkShaderModule frag1D = VK_NULL_HANDLE;
VkShaderModule frag2D = VK_NULL_HANDLE;
VkShaderModule fragMs = VK_NULL_HANDLE;
};
Rc<vk::DeviceFn> m_vkd;
VkShaderModule m_shaderVert = VK_NULL_HANDLE;
VkShaderModule m_shaderGeom = VK_NULL_HANDLE;
VkDescriptorSetLayout m_bufferToImageCopySetLayout = VK_NULL_HANDLE; VkDescriptorSetLayout m_bufferToImageCopySetLayout = VK_NULL_HANDLE;
VkPipelineLayout m_bufferToImageCopyPipelineLayout = VK_NULL_HANDLE; VkPipelineLayout m_bufferToImageCopyPipelineLayout = VK_NULL_HANDLE;
VkShaderModule m_shaderBufferToImageD = VK_NULL_HANDLE;
VkShaderModule m_shaderBufferToImageS = VK_NULL_HANDLE;
VkShaderModule m_shaderBufferToImageDSExport = VK_NULL_HANDLE;
VkDescriptorSetLayout m_imageToBufferCopySetLayout = VK_NULL_HANDLE; VkDescriptorSetLayout m_imageToBufferCopySetLayout = VK_NULL_HANDLE;
VkPipelineLayout m_imageToBufferCopyPipelineLayout = VK_NULL_HANDLE; VkPipelineLayout m_imageToBufferCopyPipelineLayout = VK_NULL_HANDLE;
VkShaderModule m_shaderImageToBufferF = VK_NULL_HANDLE;
VkShaderModule m_shaderImageToBufferDS = VK_NULL_HANDLE;
FragShaders m_color;
FragShaders m_depth;
FragShaders m_depthStencil;
dxvk::mutex m_mutex; dxvk::mutex m_mutex;
std::unordered_map< std::unordered_map<
@ -252,9 +232,6 @@ namespace dxvk {
DxvkMetaCopyPipeline m_copyBufferImagePipeline = { }; DxvkMetaCopyPipeline m_copyBufferImagePipeline = { };
VkShaderModule createShaderModule(
const SpirvCodeBuffer& code) const;
DxvkMetaCopyPipeline createCopyFormattedBufferPipeline(); DxvkMetaCopyPipeline createCopyFormattedBufferPipeline();
DxvkMetaCopyPipeline createPipeline( DxvkMetaCopyPipeline createPipeline(
@ -278,4 +255,4 @@ namespace dxvk {
}; };
} }