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

[dxvk] Remove dummy resources that are no longer needed

Browse Source
This commit is contained in:
Philip Rebohle 2022-07-12 01:54:22 +02:00
parent 6482898167
commit 6f5ae58ccc
No known key found for this signature in database
GPG Key ID: C8CC613427A31C99
5 changed files with 8 additions and 283 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
src/dxvk/dxvk_adapter.cpp
View File

@ -525,11 +525,9 @@ namespace dxvk {
if (vr != VK_SUCCESS)
throw DxvkError("DxvkAdapter: Failed to create device");
Rc<DxvkDevice> result = new DxvkDevice(instance, this,
return new DxvkDevice(instance, this,
new vk::DeviceFn(true, m_vki->instance(), device),
devExtensions, enabledFeatures);
result->initResources();
return result;
}

5
src/dxvk/dxvk_device.cpp
View File

@ -188,11 +188,6 @@ namespace dxvk {
}
void DxvkDevice::initResources() {
m_objects.dummyResources().clearResources(this);
}
void DxvkDevice::registerShader(const Rc<DxvkShader>& shader) {
m_objects.pipelineManager().registerShader(shader);
}

9
src/dxvk/dxvk_device.h
View File

@ -356,15 +356,6 @@ namespace dxvk {
*/
uint32_t getCurrentFrameId() const;
/**
* \brief Initializes dummy resources
*
* Should be called after creating the device in
* case the device initialization was successful
* and the device is usable.
*/
void initResources();
/**
* \brief Registers a shader
* \param [in] shader Newly compiled shader

144
src/dxvk/dxvk_unbound.cpp
View File

@ -4,13 +4,7 @@ namespace dxvk {
DxvkUnboundResources::DxvkUnboundResources(DxvkDevice* dev)
: m_sampler (createSampler(dev)),
m_buffer (createBuffer(dev)),
m_bufferView (createBufferView(dev, m_buffer)),
m_image1D (createImage(dev, VK_IMAGE_TYPE_1D, 1)),
m_image2D (createImage(dev, VK_IMAGE_TYPE_2D, 6)),
m_image3D (createImage(dev, VK_IMAGE_TYPE_3D, 1)),
m_viewsSampled (createImageViews(dev, VK_FORMAT_R32_SFLOAT)),
m_viewsStorage (createImageViews(dev, VK_FORMAT_R32_UINT)) {
m_buffer (createBuffer(dev)) {
}
@ -20,22 +14,6 @@ namespace dxvk {
}
void DxvkUnboundResources::clearResources(DxvkDevice* dev) {
const Rc<DxvkContext> ctx = dev->createContext(DxvkContextType::Supplementary);
ctx->beginRecording(dev->createCommandList());
this->clearBuffer(ctx, m_buffer);
this->clearImage(ctx, m_image1D);
this->clearImage(ctx, m_image2D);
this->clearImage(ctx, m_image3D);
dev->submitCommandList(
ctx->endRecording(),
VK_NULL_HANDLE,
VK_NULL_HANDLE);
}
Rc<DxvkSampler> DxvkUnboundResources::createSampler(DxvkDevice* dev) {
DxvkSamplerCreateInfo info;
info.minFilter = VK_FILTER_LINEAR;
@ -76,123 +54,13 @@ namespace dxvk {
| VK_ACCESS_SHADER_READ_BIT
| VK_ACCESS_SHADER_WRITE_BIT;
return dev->createBuffer(info,
Rc<DxvkBuffer> buffer = dev->createBuffer(info,
VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT |
VK_MEMORY_PROPERTY_HOST_COHERENT_BIT |
VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);
}
Rc<DxvkBufferView> DxvkUnboundResources::createBufferView(
DxvkDevice* dev,
const Rc<DxvkBuffer>& buffer) {
DxvkBufferViewCreateInfo info;
info.format = VK_FORMAT_R32_UINT;
info.rangeOffset = 0;
info.rangeLength = buffer->info().size;
return dev->createBufferView(buffer, info);
}
Rc<DxvkImage> DxvkUnboundResources::createImage(
DxvkDevice* dev,
VkImageType type,
uint32_t layers) {
DxvkImageCreateInfo info;
info.type = type;
info.format = VK_FORMAT_R32_UINT;
info.flags = VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT;
info.sampleCount = VK_SAMPLE_COUNT_1_BIT;
info.extent = { 1, 1, 1 };
info.numLayers = layers;
info.mipLevels = 1;
info.usage = VK_IMAGE_USAGE_TRANSFER_DST_BIT
| VK_IMAGE_USAGE_SAMPLED_BIT
| VK_IMAGE_USAGE_STORAGE_BIT;
info.stages = VK_PIPELINE_STAGE_TRANSFER_BIT
| dev->getShaderPipelineStages();
info.access = VK_ACCESS_SHADER_READ_BIT;
info.layout = VK_IMAGE_LAYOUT_GENERAL;
info.tiling = VK_IMAGE_TILING_OPTIMAL;
if (type == VK_IMAGE_TYPE_2D)
info.flags |= VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT;
return dev->createImage(info,
VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);
}
Rc<DxvkImageView> DxvkUnboundResources::createImageView(
DxvkDevice* dev,
const Rc<DxvkImage>& image,
VkFormat format,
VkImageViewType type,
uint32_t layers) {
DxvkImageViewCreateInfo info;
info.type = type;
info.format = format;
info.usage = VK_IMAGE_USAGE_SAMPLED_BIT
| VK_IMAGE_USAGE_STORAGE_BIT;
info.aspect = VK_IMAGE_ASPECT_COLOR_BIT;
info.minLevel = 0;
info.numLevels = 1;
info.minLayer = 0;
info.numLayers = layers;
info.swizzle = VkComponentMapping {
VK_COMPONENT_SWIZZLE_ZERO, VK_COMPONENT_SWIZZLE_ZERO,
VK_COMPONENT_SWIZZLE_ZERO, VK_COMPONENT_SWIZZLE_ZERO };
return dev->createImageView(image, info);
}
DxvkUnboundResources::UnboundViews DxvkUnboundResources::createImageViews(DxvkDevice* dev, VkFormat format) {
UnboundViews result;
result.view1D = createImageView(dev, m_image1D, format, VK_IMAGE_VIEW_TYPE_1D, 1);
result.view1DArr = createImageView(dev, m_image1D, format, VK_IMAGE_VIEW_TYPE_1D_ARRAY, 1);
result.view2D = createImageView(dev, m_image2D, format, VK_IMAGE_VIEW_TYPE_2D, 1);
result.view2DArr = createImageView(dev, m_image2D, format, VK_IMAGE_VIEW_TYPE_2D_ARRAY, 1);
result.viewCube = createImageView(dev, m_image2D, format, VK_IMAGE_VIEW_TYPE_CUBE, 6);
result.viewCubeArr = createImageView(dev, m_image2D, format, VK_IMAGE_VIEW_TYPE_CUBE_ARRAY, 6);
result.view3D = createImageView(dev, m_image3D, format, VK_IMAGE_VIEW_TYPE_3D, 1);
return result;
}
const DxvkImageView* DxvkUnboundResources::getImageView(VkImageViewType type, bool sampled) const {
auto views = sampled ? &m_viewsSampled : &m_viewsStorage;
switch (type) {
case VK_IMAGE_VIEW_TYPE_1D: return views->view1D.ptr();
case VK_IMAGE_VIEW_TYPE_1D_ARRAY: return views->view1DArr.ptr();
// When implicit samplers are unbound -- we assume 2D in the shader.
case VK_IMAGE_VIEW_TYPE_MAX_ENUM:
case VK_IMAGE_VIEW_TYPE_2D: return views->view2D.ptr();
case VK_IMAGE_VIEW_TYPE_2D_ARRAY: return views->view2DArr.ptr();
case VK_IMAGE_VIEW_TYPE_CUBE: return views->viewCube.ptr();
case VK_IMAGE_VIEW_TYPE_CUBE_ARRAY: return views->viewCubeArr.ptr();
case VK_IMAGE_VIEW_TYPE_3D: return views->view3D.ptr();
default: return nullptr;
}
}
void DxvkUnboundResources::clearBuffer(
const Rc<DxvkContext>& ctx,
const Rc<DxvkBuffer>& buffer) {
ctx->initBuffer(buffer);
}
void DxvkUnboundResources::clearImage(
const Rc<DxvkContext>& ctx,
const Rc<DxvkImage>& image) {
ctx->initImage(image,
VkImageSubresourceRange {
VK_IMAGE_ASPECT_COLOR_BIT,
0, image->info().mipLevels,
0, image->info().numLayers },
VK_IMAGE_LAYOUT_UNDEFINED);
std::memset(buffer->mapPtr(0), 0, info.size);
return buffer;
}
}

129
src/dxvk/dxvk_unbound.h
View File

@ -34,36 +34,6 @@ namespace dxvk {
return m_buffer->getSliceHandle().handle;
}
/**
* \brief Dummy buffer descriptor
*
* Points to a small buffer filled with zeroes.
* Do not write to this buffer, and do not use
* it if out-of-bounds read access is possible.
* \returns Dummy buffer descriptor
*/
VkDescriptorBufferInfo bufferDescriptor() const {
auto slice = m_buffer->getSliceHandle();
VkDescriptorBufferInfo result;
result.buffer = slice.handle;
result.offset = slice.offset;
result.range = slice.length;
return result;
}
/**
* \brief Dummy buffer view
*
* Returns an \c R32_UINT view into the
* dummy buffer, which will contain one
* element with undefined value.
* \returns Dummy buffer view
*/
VkBufferView bufferViewDescriptor() const {
return m_bufferView->handle();
}
/**
* \brief Dummy sampler descriptor
*
@ -80,112 +50,15 @@ namespace dxvk {
return result;
}
/**
* \brief Dummy combined image sampler descriptor
*
* Contains both an image view and a sampler
* descriptor for the given image view type.
* \param [in] type Image view type
* \returns Dummy image view descriptor
*/
VkDescriptorImageInfo imageSamplerDescriptor(VkImageViewType type) const {
auto view = getImageView(type, true);
VkDescriptorImageInfo result;
result.sampler = m_sampler->handle();
result.imageView = view->handle();
result.imageLayout = view->imageInfo().layout;
return result;
}
/**
* \brief Dummy image view descriptor
*
* Points to an image view which, instead of
* reading image data, will return zeroes for
* all components unconditionally.
* \param [in] type Image view type
* \param [in] sampled Format selector
* \returns Dummy image view descriptor
*/
VkDescriptorImageInfo imageViewDescriptor(VkImageViewType type, bool sampled) const {
auto view = getImageView(type, sampled);
VkDescriptorImageInfo result;
result.sampler = VK_NULL_HANDLE;
result.imageView = view->handle();
result.imageLayout = view->imageInfo().layout;
return result;
}
/**
* \brief Clears the resources
*
* Initializes all images and buffers to zero.
* \param [in] dev The DXVK device handle
*/
void clearResources(DxvkDevice* dev);
private:
struct UnboundViews {
Rc<DxvkImageView> view1D;
Rc<DxvkImageView> view1DArr;
Rc<DxvkImageView> view2D;
Rc<DxvkImageView> view2DArr;
Rc<DxvkImageView> viewCube;
Rc<DxvkImageView> viewCubeArr;
Rc<DxvkImageView> view3D;
};
Rc<DxvkSampler> m_sampler;
Rc<DxvkBuffer> m_buffer;
Rc<DxvkBufferView> m_bufferView;
Rc<DxvkImage> m_image1D;
Rc<DxvkImage> m_image2D;
Rc<DxvkImage> m_image3D;
UnboundViews m_viewsSampled;
UnboundViews m_viewsStorage;
Rc<DxvkBuffer> m_buffer;
Rc<DxvkSampler> createSampler(DxvkDevice* dev);
Rc<DxvkBuffer> createBuffer(DxvkDevice* dev);
Rc<DxvkBufferView> createBufferView(
DxvkDevice* dev,
const Rc<DxvkBuffer>& buffer);
Rc<DxvkImage> createImage(
DxvkDevice* dev,
VkImageType type,
uint32_t layers);
Rc<DxvkImageView> createImageView(
DxvkDevice* dev,
const Rc<DxvkImage>& image,
VkFormat format,
VkImageViewType type,
uint32_t layers);
UnboundViews createImageViews(
DxvkDevice* dev,
VkFormat format);
const DxvkImageView* getImageView(
VkImageViewType type,
bool sampled) const;
void clearBuffer(
const Rc<DxvkContext>& ctx,
const Rc<DxvkBuffer>& buffer);
void clearImage(
const Rc<DxvkContext>& ctx,
const Rc<DxvkImage>& image);
};
}