griefith/test
1
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity
Files
286cbc8317bdbe9f2eaebb5df8ecccb53bc830f4
test/source/blender/gpu/vulkan/vk_framebuffer.cc

Ignoring revisions in .git-blame-ignore-revs. Click here to bypass and see the normal blame view.

665 lines
24 KiB
C++
Raw Normal View History

License Headers: Set copyright to "Blender Authors", add AUTHORS Listing the "Blender Foundation" as copyright holder implied the Blender Foundation holds copyright to files which may include work from many developers. While keeping copyright on headers makes sense for isolated libraries, Blender's own code may be refactored or moved between files in a way that makes the per file copyright holders less meaningful. Copyright references to the "Blender Foundation" have been replaced with "Blender Authors", with the exception of `./extern/` since these this contains libraries which are more isolated, any changed to license headers there can be handled on a case-by-case basis. Some directories in `./intern/` have also been excluded: - `./intern/cycles/` it's own `AUTHORS` file is planned. - `./intern/opensubdiv/`. An "AUTHORS" file has been added, using the chromium projects authors file as a template. Design task: #110784 Ref !110783.
2023-08-16 00:20:26 +10:00
/* SPDX-FileCopyrightText: 2022 Blender Authors
Cleanup: Add a copyright notice to files and use SPDX format A lot of files were missing copyright field in the header and the Blender Foundation contributed to them in a sense of bug fixing and general maintenance. This change makes it explicit that those files are at least partially copyrighted by the Blender Foundation. Note that this does not make it so the Blender Foundation is the only holder of the copyright in those files, and developers who do not have a signed contract with the foundation still hold the copyright as well. Another aspect of this change is using SPDX format for the header. We already used it for the license specification, and now we state it for the copyright as well, following the FAQ: https://reuse.software/faq/
2023-05-31 16:19:06 +02:00
*
* SPDX-License-Identifier: GPL-2.0-or-later */
GPU: Add placeholder for Vulkan backend. This patch adds a placeholder for the vulkan backend. When activated (`WITH_VULKAN_BACKEND=On` and `--gpu-backend vulkan`) it might open a blender screen, but nothing should be visible as none of the functions are implemented or otherwise crash on a nullptr. This is expected as this is just a placeholder. The goal is to add shader compilation +validation to this backend as one of the next steps so we can validate changes to existing shaders on OpenGL, Metal and Vulkan at the same time. Reviewed By: fclem Differential Revision: https://developer.blender.org/D16338
2022-10-31 16:01:02 +01:00
/** \file
* \ingroup gpu
*/
#include "vk_framebuffer.hh"
Vulkan: Share Device Between Contexts Previous GHOST_ContextVK would create a logical device for each context. Blender uses multiple contexts at the same time and wasn't able to share resources between them as the logical device where different. This patch will create a single logical device and share them between multiple contexts. This allows sharing memory/shaders between contexts and make sure that all memory allocations are freed from the device it was allocated from. Some allocations in Blender are freed when there isn't a context, this was failing in the previous implementation. We didn't noticed it before as we didn't test multiple contexts. This patch also moves device specific data structures from VKContext to VKDevice like the descriptor pools, debug layers etc. Pull Request: https://projects.blender.org/blender/blender/pulls/107606
2023-05-04 10:06:48 +02:00
#include "vk_backend.hh"
Vulkan: Frame Buffer Flipping Vulkan coordinate system is flipped compared to OpenGL. This PR flips the drawing when drawn to the on-screen frame buffer. Offscreen frame buffers are still drawn upside down. The flipping is done by making the viewport of the framebuffer negative. Pull Request: https://projects.blender.org/blender/blender/pulls/107743
2023-05-09 09:22:26 +02:00
#include "vk_context.hh"
Vulkan: Clearing Framebuffer + Scissors This PR adds support for clearing framebuffers and scissor testing. Tweaks had to be made to VKTexture to keep track of its layout on the device. Based on the actual call the layout can switch to a more optimum layout. For example during upload of a texture the texture will be converted to a transfer destination optimized layout. When reading from the texture it will be converted to a transfer source optimized layout. The order of the attachments in the framebuffer follows the next rules - When only color attachments are there the color attachments will be placed in the slot they are defined. This way it will match the ShaderCreateInfo binding location. - When a stencil/depth attachment is added it will be placed right after the color attachments. When there isn't a color attachment it will be the first attachment. Pull Request: https://projects.blender.org/blender/blender/pulls/106044
2023-03-28 11:51:32 +02:00
#include "vk_memory.hh"
Vulkan: Rewrite GHOST_ContextVK This is a rewrite of GHOST_ContextVK to align with Metal backend as described in #111389 - solution 3 with the adaptation that GHOST is still responsible for presenting the swap chain image and a post callback is still needed in case the swapchain is recreated. This PR also includes some smaller improvements in stability. Technical documentation: https://developer.blender.org/docs/eevee_and_viewport/gpu/vulkan/swap_chain/ * Renderpasses and framebuffers are not owned anymore by GHOST_ContextVK * VKFramebuffer doesn't contain a swap chain image. * Swapchain images can only be used as a blit destination or present source. Not as an attachment. * GHOST_ContextVK::swapBuffers would call a callback with the image the GPU module needs to blit the results to. * Clearing of depth/stencil attachments when no depth write state is set. * Enable VK_KHR_maintenance4 to relax the stage interface mapping. * Removes most vulkan validation warnings/errors. * Detection of frame buffer changes that needs to be applied before performing a command requiring render pass (draw/clear attachment) **Benefits** * Late retrieval of a swap chain image results in better overall performance as Blender doesn't need to wait until the image is presented on the screen. * Easier API and clearer state (transitions) * More control over Image layouts and command buffer states. (Better alignment with Vulkan API) Pull Request: https://projects.blender.org/blender/blender/pulls/111473
2023-08-29 15:05:08 +02:00
#include "vk_state_manager.hh"
Vulkan: Clearing Framebuffer + Scissors This PR adds support for clearing framebuffers and scissor testing. Tweaks had to be made to VKTexture to keep track of its layout on the device. Based on the actual call the layout can switch to a more optimum layout. For example during upload of a texture the texture will be converted to a transfer destination optimized layout. When reading from the texture it will be converted to a transfer source optimized layout. The order of the attachments in the framebuffer follows the next rules - When only color attachments are there the color attachments will be placed in the slot they are defined. This way it will match the ShaderCreateInfo binding location. - When a stencil/depth attachment is added it will be placed right after the color attachments. When there isn't a color attachment it will be the first attachment. Pull Request: https://projects.blender.org/blender/blender/pulls/106044
2023-03-28 11:51:32 +02:00
#include "vk_texture.hh"
GPU: Add placeholder for Vulkan backend. This patch adds a placeholder for the vulkan backend. When activated (`WITH_VULKAN_BACKEND=On` and `--gpu-backend vulkan`) it might open a blender screen, but nothing should be visible as none of the functions are implemented or otherwise crash on a nullptr. This is expected as this is just a placeholder. The goal is to add shader compilation +validation to this backend as one of the next steps so we can validate changes to existing shaders on OpenGL, Metal and Vulkan at the same time. Reviewed By: fclem Differential Revision: https://developer.blender.org/D16338
2022-10-31 16:01:02 +01:00
namespace blender::gpu {
Vulkan: Add Initial VKFrameBuffer. This was backported from tmp-vulkan. When disabling the fence check in ghost it is able to start blender. It will show a black screen so not usable for users.
2023-02-28 06:13:57 +01:00
/* -------------------------------------------------------------------- */
/** \name Creation & Deletion
* \{ */
VKFrameBuffer::VKFrameBuffer(const char *name) : FrameBuffer(name)
{
Vulkan: Frame Buffer Flipping Vulkan coordinate system is flipped compared to OpenGL. This PR flips the drawing when drawn to the on-screen frame buffer. Offscreen frame buffers are still drawn upside down. The flipping is done by making the viewport of the framebuffer negative. Pull Request: https://projects.blender.org/blender/blender/pulls/107743
2023-05-09 09:22:26 +02:00
size_set(1, 1);
Vulkan: Add Support for sRGB Framebuffer Enablement Allow binding of framebuffers without sRGB to linear transform. `GPU_framebuffer_bind_no_srgb`. This Patch removes color transform artifacts in node, image and sequence editor. When the framebuffer is an srgb framebuffer and it is bound without the transformation, the SRGB textures are bound as UNORM variants. As framebuffer, render pass and subpass recreation is ensured by `VKCommandBuffer` we don't need to mark the framebuffer dirty at this time. Later on we can optimize this by adding a state changed detection for framebuffers and render passes. Pull Request: https://projects.blender.org/blender/blender/pulls/113838
2023-10-19 14:41:18 +02:00
srgb_ = false;
enabled_srgb_ = false;
Vulkan: Add Initial VKFrameBuffer. This was backported from tmp-vulkan. When disabling the fence check in ghost it is able to start blender. It will show a black screen so not usable for users.
2023-02-28 06:13:57 +01:00
}
VKFrameBuffer::~VKFrameBuffer()
{
Vulkan: Rewrite GHOST_ContextVK This is a rewrite of GHOST_ContextVK to align with Metal backend as described in #111389 - solution 3 with the adaptation that GHOST is still responsible for presenting the swap chain image and a post callback is still needed in case the swapchain is recreated. This PR also includes some smaller improvements in stability. Technical documentation: https://developer.blender.org/docs/eevee_and_viewport/gpu/vulkan/swap_chain/ * Renderpasses and framebuffers are not owned anymore by GHOST_ContextVK * VKFramebuffer doesn't contain a swap chain image. * Swapchain images can only be used as a blit destination or present source. Not as an attachment. * GHOST_ContextVK::swapBuffers would call a callback with the image the GPU module needs to blit the results to. * Clearing of depth/stencil attachments when no depth write state is set. * Enable VK_KHR_maintenance4 to relax the stage interface mapping. * Removes most vulkan validation warnings/errors. * Detection of frame buffer changes that needs to be applied before performing a command requiring render pass (draw/clear attachment) **Benefits** * Late retrieval of a swap chain image results in better overall performance as Blender doesn't need to wait until the image is presented on the screen. * Easier API and clearer state (transitions) * More control over Image layouts and command buffer states. (Better alignment with Vulkan API) Pull Request: https://projects.blender.org/blender/blender/pulls/111473
2023-08-29 15:05:08 +02:00
render_pass_free();
Vulkan: Add Initial VKFrameBuffer. This was backported from tmp-vulkan. When disabling the fence check in ghost it is able to start blender. It will show a black screen so not usable for users.
2023-02-28 06:13:57 +01:00
}
/** \} */
Vulkan: Add Support for sRGB Framebuffer Enablement Allow binding of framebuffers without sRGB to linear transform. `GPU_framebuffer_bind_no_srgb`. This Patch removes color transform artifacts in node, image and sequence editor. When the framebuffer is an srgb framebuffer and it is bound without the transformation, the SRGB textures are bound as UNORM variants. As framebuffer, render pass and subpass recreation is ensured by `VKCommandBuffer` we don't need to mark the framebuffer dirty at this time. Later on we can optimize this by adding a state changed detection for framebuffers and render passes. Pull Request: https://projects.blender.org/blender/blender/pulls/113838
2023-10-19 14:41:18 +02:00
void VKFrameBuffer::bind(bool enabled_srgb)
GPU: Add placeholder for Vulkan backend. This patch adds a placeholder for the vulkan backend. When activated (`WITH_VULKAN_BACKEND=On` and `--gpu-backend vulkan`) it might open a blender screen, but nothing should be visible as none of the functions are implemented or otherwise crash on a nullptr. This is expected as this is just a placeholder. The goal is to add shader compilation +validation to this backend as one of the next steps so we can validate changes to existing shaders on OpenGL, Metal and Vulkan at the same time. Reviewed By: fclem Differential Revision: https://developer.blender.org/D16338
2022-10-31 16:01:02 +01:00
{
Vulkan: Frame Buffer Flipping Vulkan coordinate system is flipped compared to OpenGL. This PR flips the drawing when drawn to the on-screen frame buffer. Offscreen frame buffers are still drawn upside down. The flipping is done by making the viewport of the framebuffer negative. Pull Request: https://projects.blender.org/blender/blender/pulls/107743
2023-05-09 09:22:26 +02:00
VKContext &context = *VKContext::get();
/* Updating attachments can issue pipeline barriers, this should be done outside the render pass.
* When done inside a render pass there should be a self-dependency between sub-passes on the
* active render pass. As the active render pass isn't aware of the new render pass (and should
* not) it is better to deactivate it before updating the attachments. For more information check
* `VkSubpassDependency`. */
if (context.has_active_framebuffer()) {
context.deactivate_framebuffer();
}
Vulkan: Clearing Framebuffer + Scissors This PR adds support for clearing framebuffers and scissor testing. Tweaks had to be made to VKTexture to keep track of its layout on the device. Based on the actual call the layout can switch to a more optimum layout. For example during upload of a texture the texture will be converted to a transfer destination optimized layout. When reading from the texture it will be converted to a transfer source optimized layout. The order of the attachments in the framebuffer follows the next rules - When only color attachments are there the color attachments will be placed in the slot they are defined. This way it will match the ShaderCreateInfo binding location. - When a stencil/depth attachment is added it will be placed right after the color attachments. When there isn't a color attachment it will be the first attachment. Pull Request: https://projects.blender.org/blender/blender/pulls/106044
2023-03-28 11:51:32 +02:00
context.activate_framebuffer(*this);
Vulkan: Add Support for sRGB Framebuffer Enablement Allow binding of framebuffers without sRGB to linear transform. `GPU_framebuffer_bind_no_srgb`. This Patch removes color transform artifacts in node, image and sequence editor. When the framebuffer is an srgb framebuffer and it is bound without the transformation, the SRGB textures are bound as UNORM variants. As framebuffer, render pass and subpass recreation is ensured by `VKCommandBuffer` we don't need to mark the framebuffer dirty at this time. Later on we can optimize this by adding a state changed detection for framebuffers and render passes. Pull Request: https://projects.blender.org/blender/blender/pulls/113838
2023-10-19 14:41:18 +02:00
enabled_srgb_ = enabled_srgb;
Shader::set_framebuffer_srgb_target(enabled_srgb && srgb_);
Vulkan: Clearing Framebuffer + Scissors This PR adds support for clearing framebuffers and scissor testing. Tweaks had to be made to VKTexture to keep track of its layout on the device. Based on the actual call the layout can switch to a more optimum layout. For example during upload of a texture the texture will be converted to a transfer destination optimized layout. When reading from the texture it will be converted to a transfer source optimized layout. The order of the attachments in the framebuffer follows the next rules - When only color attachments are there the color attachments will be placed in the slot they are defined. This way it will match the ShaderCreateInfo binding location. - When a stencil/depth attachment is added it will be placed right after the color attachments. When there isn't a color attachment it will be the first attachment. Pull Request: https://projects.blender.org/blender/blender/pulls/106044
2023-03-28 11:51:32 +02:00
}
GPU: Framebuffer: Add multi viewport support This add the possibility to define different viewports inside a single framebuffer and let the vertex shader decide which viewport to render to. This only contain the GL and VK implementation. The Vulkan implementation works but still has a validation error related to shader features and extension. The test passes nonetheless. Pull Request: https://projects.blender.org/blender/blender/pulls/110923
2023-08-08 17:12:49 +02:00
Array<VkViewport, 16> VKFrameBuffer::vk_viewports_get() const
Vulkan: Frame Buffer Flipping Vulkan coordinate system is flipped compared to OpenGL. This PR flips the drawing when drawn to the on-screen frame buffer. Offscreen frame buffers are still drawn upside down. The flipping is done by making the viewport of the framebuffer negative. Pull Request: https://projects.blender.org/blender/blender/pulls/107743
2023-05-09 09:22:26 +02:00
{
GPU: Framebuffer: Add multi viewport support This add the possibility to define different viewports inside a single framebuffer and let the vertex shader decide which viewport to render to. This only contain the GL and VK implementation. The Vulkan implementation works but still has a validation error related to shader features and extension. The test passes nonetheless. Pull Request: https://projects.blender.org/blender/blender/pulls/110923
2023-08-08 17:12:49 +02:00
Array<VkViewport, 16> viewports(this->multi_viewport_ ? GPU_MAX_VIEWPORTS : 1);
int index = 0;
for (VkViewport &viewport : viewports) {
viewport.x = viewport_[index][0];
viewport.y = viewport_[index][1];
viewport.width = viewport_[index][2];
viewport.height = viewport_[index][3];
viewport.minDepth = 0.0f;
viewport.maxDepth = 1.0f;
index++;
Vulkan: Frame Buffer Flipping Vulkan coordinate system is flipped compared to OpenGL. This PR flips the drawing when drawn to the on-screen frame buffer. Offscreen frame buffers are still drawn upside down. The flipping is done by making the viewport of the framebuffer negative. Pull Request: https://projects.blender.org/blender/blender/pulls/107743
2023-05-09 09:22:26 +02:00
}
GPU: Framebuffer: Add multi viewport support This add the possibility to define different viewports inside a single framebuffer and let the vertex shader decide which viewport to render to. This only contain the GL and VK implementation. The Vulkan implementation works but still has a validation error related to shader features and extension. The test passes nonetheless. Pull Request: https://projects.blender.org/blender/blender/pulls/110923
2023-08-08 17:12:49 +02:00
return viewports;
Vulkan: Frame Buffer Flipping Vulkan coordinate system is flipped compared to OpenGL. This PR flips the drawing when drawn to the on-screen frame buffer. Offscreen frame buffers are still drawn upside down. The flipping is done by making the viewport of the framebuffer negative. Pull Request: https://projects.blender.org/blender/blender/pulls/107743
2023-05-09 09:22:26 +02:00
}
GPU: Framebuffer: Add multi viewport support This add the possibility to define different viewports inside a single framebuffer and let the vertex shader decide which viewport to render to. This only contain the GL and VK implementation. The Vulkan implementation works but still has a validation error related to shader features and extension. The test passes nonetheless. Pull Request: https://projects.blender.org/blender/blender/pulls/110923
2023-08-08 17:12:49 +02:00
Array<VkRect2D, 16> VKFrameBuffer::vk_render_areas_get() const
Vulkan: Clearing Framebuffer + Scissors This PR adds support for clearing framebuffers and scissor testing. Tweaks had to be made to VKTexture to keep track of its layout on the device. Based on the actual call the layout can switch to a more optimum layout. For example during upload of a texture the texture will be converted to a transfer destination optimized layout. When reading from the texture it will be converted to a transfer source optimized layout. The order of the attachments in the framebuffer follows the next rules - When only color attachments are there the color attachments will be placed in the slot they are defined. This way it will match the ShaderCreateInfo binding location. - When a stencil/depth attachment is added it will be placed right after the color attachments. When there isn't a color attachment it will be the first attachment. Pull Request: https://projects.blender.org/blender/blender/pulls/106044
2023-03-28 11:51:32 +02:00
{
GPU: Framebuffer: Add multi viewport support This add the possibility to define different viewports inside a single framebuffer and let the vertex shader decide which viewport to render to. This only contain the GL and VK implementation. The Vulkan implementation works but still has a validation error related to shader features and extension. The test passes nonetheless. Pull Request: https://projects.blender.org/blender/blender/pulls/110923
2023-08-08 17:12:49 +02:00
Array<VkRect2D, 16> render_areas(this->multi_viewport_ ? GPU_MAX_VIEWPORTS : 1);
for (VkRect2D &render_area : render_areas) {
if (scissor_test_get()) {
int scissor_rect[4];
scissor_get(scissor_rect);
Vulkan: Fix Blitting Extents During Blitting it is not allowed to read/write outside the texture bounds. This patch ensures that the bounds (called extents in Vulkan) are inside the expected range. Pull Request: https://projects.blender.org/blender/blender/pulls/113050
2023-09-29 11:44:50 +02:00
render_area.offset.x = clamp_i(scissor_rect[0], 0, width_);
render_area.offset.y = clamp_i(scissor_rect[1], 0, height_);
render_area.extent.width = clamp_i(scissor_rect[2], 1, width_ - scissor_rect[0]);
render_area.extent.height = clamp_i(scissor_rect[3], 1, height_ - scissor_rect[1]);
GPU: Framebuffer: Add multi viewport support This add the possibility to define different viewports inside a single framebuffer and let the vertex shader decide which viewport to render to. This only contain the GL and VK implementation. The Vulkan implementation works but still has a validation error related to shader features and extension. The test passes nonetheless. Pull Request: https://projects.blender.org/blender/blender/pulls/110923
2023-08-08 17:12:49 +02:00
}
else {
render_area.offset.x = 0;
render_area.offset.y = 0;
render_area.extent.width = width_;
render_area.extent.height = height_;
}
Vulkan: Clearing Framebuffer + Scissors This PR adds support for clearing framebuffers and scissor testing. Tweaks had to be made to VKTexture to keep track of its layout on the device. Based on the actual call the layout can switch to a more optimum layout. For example during upload of a texture the texture will be converted to a transfer destination optimized layout. When reading from the texture it will be converted to a transfer source optimized layout. The order of the attachments in the framebuffer follows the next rules - When only color attachments are there the color attachments will be placed in the slot they are defined. This way it will match the ShaderCreateInfo binding location. - When a stencil/depth attachment is added it will be placed right after the color attachments. When there isn't a color attachment it will be the first attachment. Pull Request: https://projects.blender.org/blender/blender/pulls/106044
2023-03-28 11:51:32 +02:00
}
GPU: Framebuffer: Add multi viewport support This add the possibility to define different viewports inside a single framebuffer and let the vertex shader decide which viewport to render to. This only contain the GL and VK implementation. The Vulkan implementation works but still has a validation error related to shader features and extension. The test passes nonetheless. Pull Request: https://projects.blender.org/blender/blender/pulls/110923
2023-08-08 17:12:49 +02:00
return render_areas;
GPU: Add placeholder for Vulkan backend. This patch adds a placeholder for the vulkan backend. When activated (`WITH_VULKAN_BACKEND=On` and `--gpu-backend vulkan`) it might open a blender screen, but nothing should be visible as none of the functions are implemented or otherwise crash on a nullptr. This is expected as this is just a placeholder. The goal is to add shader compilation +validation to this backend as one of the next steps so we can validate changes to existing shaders on OpenGL, Metal and Vulkan at the same time. Reviewed By: fclem Differential Revision: https://developer.blender.org/D16338
2022-10-31 16:01:02 +01:00
}
bool VKFrameBuffer::check(char /*err_out*/[256])
{
Vulkan: Frame Buffer Flipping Vulkan coordinate system is flipped compared to OpenGL. This PR flips the drawing when drawn to the on-screen frame buffer. Offscreen frame buffers are still drawn upside down. The flipping is done by making the viewport of the framebuffer negative. Pull Request: https://projects.blender.org/blender/blender/pulls/107743
2023-05-09 09:22:26 +02:00
return true;
GPU: Add placeholder for Vulkan backend. This patch adds a placeholder for the vulkan backend. When activated (`WITH_VULKAN_BACKEND=On` and `--gpu-backend vulkan`) it might open a blender screen, but nothing should be visible as none of the functions are implemented or otherwise crash on a nullptr. This is expected as this is just a placeholder. The goal is to add shader compilation +validation to this backend as one of the next steps so we can validate changes to existing shaders on OpenGL, Metal and Vulkan at the same time. Reviewed By: fclem Differential Revision: https://developer.blender.org/D16338
2022-10-31 16:01:02 +01:00
}
Vulkan: Clearing Framebuffer + Scissors This PR adds support for clearing framebuffers and scissor testing. Tweaks had to be made to VKTexture to keep track of its layout on the device. Based on the actual call the layout can switch to a more optimum layout. For example during upload of a texture the texture will be converted to a transfer destination optimized layout. When reading from the texture it will be converted to a transfer source optimized layout. The order of the attachments in the framebuffer follows the next rules - When only color attachments are there the color attachments will be placed in the slot they are defined. This way it will match the ShaderCreateInfo binding location. - When a stencil/depth attachment is added it will be placed right after the color attachments. When there isn't a color attachment it will be the first attachment. Pull Request: https://projects.blender.org/blender/blender/pulls/106044
2023-03-28 11:51:32 +02:00
void VKFrameBuffer::build_clear_attachments_depth_stencil(
const eGPUFrameBufferBits buffers,
float clear_depth,
uint32_t clear_stencil,
Vector<VkClearAttachment> &r_attachments) const
{
VkClearAttachment clear_attachment = {};
clear_attachment.aspectMask = (buffers & GPU_DEPTH_BIT ? VK_IMAGE_ASPECT_DEPTH_BIT : 0) |
(buffers & GPU_STENCIL_BIT ? VK_IMAGE_ASPECT_STENCIL_BIT : 0);
clear_attachment.clearValue.depthStencil.depth = clear_depth;
clear_attachment.clearValue.depthStencil.stencil = clear_stencil;
r_attachments.append(clear_attachment);
}
void VKFrameBuffer::build_clear_attachments_color(const float (*clear_colors)[4],
const bool multi_clear_colors,
Vector<VkClearAttachment> &r_attachments) const
GPU: Add placeholder for Vulkan backend. This patch adds a placeholder for the vulkan backend. When activated (`WITH_VULKAN_BACKEND=On` and `--gpu-backend vulkan`) it might open a blender screen, but nothing should be visible as none of the functions are implemented or otherwise crash on a nullptr. This is expected as this is just a placeholder. The goal is to add shader compilation +validation to this backend as one of the next steps so we can validate changes to existing shaders on OpenGL, Metal and Vulkan at the same time. Reviewed By: fclem Differential Revision: https://developer.blender.org/D16338
2022-10-31 16:01:02 +01:00
{
Vulkan: Clearing Framebuffer + Scissors This PR adds support for clearing framebuffers and scissor testing. Tweaks had to be made to VKTexture to keep track of its layout on the device. Based on the actual call the layout can switch to a more optimum layout. For example during upload of a texture the texture will be converted to a transfer destination optimized layout. When reading from the texture it will be converted to a transfer source optimized layout. The order of the attachments in the framebuffer follows the next rules - When only color attachments are there the color attachments will be placed in the slot they are defined. This way it will match the ShaderCreateInfo binding location. - When a stencil/depth attachment is added it will be placed right after the color attachments. When there isn't a color attachment it will be the first attachment. Pull Request: https://projects.blender.org/blender/blender/pulls/106044
2023-03-28 11:51:32 +02:00
int color_index = 0;
for (int color_slot = 0; color_slot < GPU_FB_MAX_COLOR_ATTACHMENT; color_slot++) {
const GPUAttachment &attachment = attachments_[GPU_FB_COLOR_ATTACHMENT0 + color_slot];
if (attachment.tex == nullptr) {
continue;
}
VkClearAttachment clear_attachment = {};
clear_attachment.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
clear_attachment.colorAttachment = color_slot;
eGPUDataFormat data_format = to_data_format(GPU_texture_format(attachment.tex));
clear_attachment.clearValue.color = to_vk_clear_color_value(data_format,
&clear_colors[color_index]);
r_attachments.append(clear_attachment);
color_index += multi_clear_colors ? 1 : 0;
}
GPU: Add placeholder for Vulkan backend. This patch adds a placeholder for the vulkan backend. When activated (`WITH_VULKAN_BACKEND=On` and `--gpu-backend vulkan`) it might open a blender screen, but nothing should be visible as none of the functions are implemented or otherwise crash on a nullptr. This is expected as this is just a placeholder. The goal is to add shader compilation +validation to this backend as one of the next steps so we can validate changes to existing shaders on OpenGL, Metal and Vulkan at the same time. Reviewed By: fclem Differential Revision: https://developer.blender.org/D16338
2022-10-31 16:01:02 +01:00
}
Vulkan: Clearing Framebuffer + Scissors This PR adds support for clearing framebuffers and scissor testing. Tweaks had to be made to VKTexture to keep track of its layout on the device. Based on the actual call the layout can switch to a more optimum layout. For example during upload of a texture the texture will be converted to a transfer destination optimized layout. When reading from the texture it will be converted to a transfer source optimized layout. The order of the attachments in the framebuffer follows the next rules - When only color attachments are there the color attachments will be placed in the slot they are defined. This way it will match the ShaderCreateInfo binding location. - When a stencil/depth attachment is added it will be placed right after the color attachments. When there isn't a color attachment it will be the first attachment. Pull Request: https://projects.blender.org/blender/blender/pulls/106044
2023-03-28 11:51:32 +02:00
/* -------------------------------------------------------------------- */
/** \name Clear
* \{ */
Cleanup: Use Span instead of Vector const reference Span is preferrable since it's agnostic of the source container, makes it clearer that there is no ownership, is 8 bytes smaller, and can be passed by value.
2024-02-14 16:59:36 -05:00
void VKFrameBuffer::clear(const Span<VkClearAttachment> attachments) const
GPU: Add placeholder for Vulkan backend. This patch adds a placeholder for the vulkan backend. When activated (`WITH_VULKAN_BACKEND=On` and `--gpu-backend vulkan`) it might open a blender screen, but nothing should be visible as none of the functions are implemented or otherwise crash on a nullptr. This is expected as this is just a placeholder. The goal is to add shader compilation +validation to this backend as one of the next steps so we can validate changes to existing shaders on OpenGL, Metal and Vulkan at the same time. Reviewed By: fclem Differential Revision: https://developer.blender.org/D16338
2022-10-31 16:01:02 +01:00
{
Vulkan: Frame Buffer Flipping Vulkan coordinate system is flipped compared to OpenGL. This PR flips the drawing when drawn to the on-screen frame buffer. Offscreen frame buffers are still drawn upside down. The flipping is done by making the viewport of the framebuffer negative. Pull Request: https://projects.blender.org/blender/blender/pulls/107743
2023-05-09 09:22:26 +02:00
if (attachments.is_empty()) {
return;
}
Vulkan: Clearing Framebuffer + Scissors This PR adds support for clearing framebuffers and scissor testing. Tweaks had to be made to VKTexture to keep track of its layout on the device. Based on the actual call the layout can switch to a more optimum layout. For example during upload of a texture the texture will be converted to a transfer destination optimized layout. When reading from the texture it will be converted to a transfer source optimized layout. The order of the attachments in the framebuffer follows the next rules - When only color attachments are there the color attachments will be placed in the slot they are defined. This way it will match the ShaderCreateInfo binding location. - When a stencil/depth attachment is added it will be placed right after the color attachments. When there isn't a color attachment it will be the first attachment. Pull Request: https://projects.blender.org/blender/blender/pulls/106044
2023-03-28 11:51:32 +02:00
VkClearRect clear_rect = {};
GPU: Framebuffer: Add multi viewport support This add the possibility to define different viewports inside a single framebuffer and let the vertex shader decide which viewport to render to. This only contain the GL and VK implementation. The Vulkan implementation works but still has a validation error related to shader features and extension. The test passes nonetheless. Pull Request: https://projects.blender.org/blender/blender/pulls/110923
2023-08-08 17:12:49 +02:00
clear_rect.rect = vk_render_areas_get()[0];
Vulkan: Clearing Framebuffer + Scissors This PR adds support for clearing framebuffers and scissor testing. Tweaks had to be made to VKTexture to keep track of its layout on the device. Based on the actual call the layout can switch to a more optimum layout. For example during upload of a texture the texture will be converted to a transfer destination optimized layout. When reading from the texture it will be converted to a transfer source optimized layout. The order of the attachments in the framebuffer follows the next rules - When only color attachments are there the color attachments will be placed in the slot they are defined. This way it will match the ShaderCreateInfo binding location. - When a stencil/depth attachment is added it will be placed right after the color attachments. When there isn't a color attachment it will be the first attachment. Pull Request: https://projects.blender.org/blender/blender/pulls/106044
2023-03-28 11:51:32 +02:00
clear_rect.baseArrayLayer = 0;
clear_rect.layerCount = 1;
VKContext &context = *VKContext::get();
Vulkan: Separate DataTransfer, Compute, Graphics Commands Goal is to reduce the number of command buffer flushes by tracking what is happening in the different command queues. This is an initial step towards advanced queue-ing strategies. The new (intermediate) strategy records commands to different command buffers based on what they do. There is a command buffer for data transfers, compute pipelines and graphics pipelines. When a compute command is recorded it ensures that all graphic commands are finished. When a graphic command is recorded it ensures all compute commands are finished. When a graphic or compute command is scheduled all recorded data transfer commands are scheduled as well. Some improvements are expected as multiple compute and data transfers commands can now be scheduled at the same time and don't need to unbind and rebind render passes. Especially when using EEVEE-Next which is compute centric the performance change is visible for the user. Pull Request: https://projects.blender.org/blender/blender/pulls/114104
2023-10-30 14:21:14 +01:00
VKCommandBuffers &command_buffers = context.command_buffers_get();
command_buffers.clear(attachments, Span<VkClearRect>(&clear_rect, 1));
Vulkan: Clearing Framebuffer + Scissors This PR adds support for clearing framebuffers and scissor testing. Tweaks had to be made to VKTexture to keep track of its layout on the device. Based on the actual call the layout can switch to a more optimum layout. For example during upload of a texture the texture will be converted to a transfer destination optimized layout. When reading from the texture it will be converted to a transfer source optimized layout. The order of the attachments in the framebuffer follows the next rules - When only color attachments are there the color attachments will be placed in the slot they are defined. This way it will match the ShaderCreateInfo binding location. - When a stencil/depth attachment is added it will be placed right after the color attachments. When there isn't a color attachment it will be the first attachment. Pull Request: https://projects.blender.org/blender/blender/pulls/106044
2023-03-28 11:51:32 +02:00
}
void VKFrameBuffer::clear(const eGPUFrameBufferBits buffers,
const float clear_color[4],
float clear_depth,
uint clear_stencil)
{
Vector<VkClearAttachment> attachments;
if (buffers & (GPU_DEPTH_BIT | GPU_STENCIL_BIT)) {
Vulkan: Rewrite GHOST_ContextVK This is a rewrite of GHOST_ContextVK to align with Metal backend as described in #111389 - solution 3 with the adaptation that GHOST is still responsible for presenting the swap chain image and a post callback is still needed in case the swapchain is recreated. This PR also includes some smaller improvements in stability. Technical documentation: https://developer.blender.org/docs/eevee_and_viewport/gpu/vulkan/swap_chain/ * Renderpasses and framebuffers are not owned anymore by GHOST_ContextVK * VKFramebuffer doesn't contain a swap chain image. * Swapchain images can only be used as a blit destination or present source. Not as an attachment. * GHOST_ContextVK::swapBuffers would call a callback with the image the GPU module needs to blit the results to. * Clearing of depth/stencil attachments when no depth write state is set. * Enable VK_KHR_maintenance4 to relax the stage interface mapping. * Removes most vulkan validation warnings/errors. * Detection of frame buffer changes that needs to be applied before performing a command requiring render pass (draw/clear attachment) **Benefits** * Late retrieval of a swap chain image results in better overall performance as Blender doesn't need to wait until the image is presented on the screen. * Easier API and clearer state (transitions) * More control over Image layouts and command buffer states. (Better alignment with Vulkan API) Pull Request: https://projects.blender.org/blender/blender/pulls/111473
2023-08-29 15:05:08 +02:00
VKContext &context = *VKContext::get();
Vulkan: Workbench Shadow Drawing There were some issues with workbench shadow drawing. This PR does some tweaks to fix the shadow drawing on vulkan. * Framebuffer stencil clearing when write stencil is disabled * Tweaks to stencil operation and tests * Disable restart for line adjacency Pull Request: https://projects.blender.org/blender/blender/pulls/114673
2023-11-09 16:07:26 +01:00
eGPUWriteMask needed_mask = GPU_WRITE_NONE;
if (buffers & GPU_DEPTH_BIT) {
needed_mask |= GPU_WRITE_DEPTH;
}
if (buffers & GPU_STENCIL_BIT) {
needed_mask |= GPU_WRITE_STENCIL;
}
/* Clearing depth via vkCmdClearAttachments requires a render pass with write depth or stencil
* enabled. When not enabled, clearing should be done via texture directly. */
if ((context.state_manager_get().state.write_mask & needed_mask) == needed_mask) {
Vulkan: Rewrite GHOST_ContextVK This is a rewrite of GHOST_ContextVK to align with Metal backend as described in #111389 - solution 3 with the adaptation that GHOST is still responsible for presenting the swap chain image and a post callback is still needed in case the swapchain is recreated. This PR also includes some smaller improvements in stability. Technical documentation: https://developer.blender.org/docs/eevee_and_viewport/gpu/vulkan/swap_chain/ * Renderpasses and framebuffers are not owned anymore by GHOST_ContextVK * VKFramebuffer doesn't contain a swap chain image. * Swapchain images can only be used as a blit destination or present source. Not as an attachment. * GHOST_ContextVK::swapBuffers would call a callback with the image the GPU module needs to blit the results to. * Clearing of depth/stencil attachments when no depth write state is set. * Enable VK_KHR_maintenance4 to relax the stage interface mapping. * Removes most vulkan validation warnings/errors. * Detection of frame buffer changes that needs to be applied before performing a command requiring render pass (draw/clear attachment) **Benefits** * Late retrieval of a swap chain image results in better overall performance as Blender doesn't need to wait until the image is presented on the screen. * Easier API and clearer state (transitions) * More control over Image layouts and command buffer states. (Better alignment with Vulkan API) Pull Request: https://projects.blender.org/blender/blender/pulls/111473
2023-08-29 15:05:08 +02:00
build_clear_attachments_depth_stencil(buffers, clear_depth, clear_stencil, attachments);
}
else {
VKTexture *depth_texture = unwrap(unwrap(depth_tex()));
if (depth_texture != nullptr) {
if (G.debug & G_DEBUG_GPU) {
std::cout
<< "PERFORMANCE: impact clearing depth texture in render pass that doesn't allow "
"depth writes.\n";
}
depth_attachment_layout_ensure(context, VK_IMAGE_LAYOUT_GENERAL);
depth_texture->clear_depth_stencil(buffers, clear_depth, clear_stencil);
}
}
Vulkan: Clearing Framebuffer + Scissors This PR adds support for clearing framebuffers and scissor testing. Tweaks had to be made to VKTexture to keep track of its layout on the device. Based on the actual call the layout can switch to a more optimum layout. For example during upload of a texture the texture will be converted to a transfer destination optimized layout. When reading from the texture it will be converted to a transfer source optimized layout. The order of the attachments in the framebuffer follows the next rules - When only color attachments are there the color attachments will be placed in the slot they are defined. This way it will match the ShaderCreateInfo binding location. - When a stencil/depth attachment is added it will be placed right after the color attachments. When there isn't a color attachment it will be the first attachment. Pull Request: https://projects.blender.org/blender/blender/pulls/106044
2023-03-28 11:51:32 +02:00
}
if (buffers & GPU_COLOR_BIT) {
float clear_color_single[4];
copy_v4_v4(clear_color_single, clear_color);
build_clear_attachments_color(&clear_color_single, false, attachments);
}
Vulkan: Rewrite GHOST_ContextVK This is a rewrite of GHOST_ContextVK to align with Metal backend as described in #111389 - solution 3 with the adaptation that GHOST is still responsible for presenting the swap chain image and a post callback is still needed in case the swapchain is recreated. This PR also includes some smaller improvements in stability. Technical documentation: https://developer.blender.org/docs/eevee_and_viewport/gpu/vulkan/swap_chain/ * Renderpasses and framebuffers are not owned anymore by GHOST_ContextVK * VKFramebuffer doesn't contain a swap chain image. * Swapchain images can only be used as a blit destination or present source. Not as an attachment. * GHOST_ContextVK::swapBuffers would call a callback with the image the GPU module needs to blit the results to. * Clearing of depth/stencil attachments when no depth write state is set. * Enable VK_KHR_maintenance4 to relax the stage interface mapping. * Removes most vulkan validation warnings/errors. * Detection of frame buffer changes that needs to be applied before performing a command requiring render pass (draw/clear attachment) **Benefits** * Late retrieval of a swap chain image results in better overall performance as Blender doesn't need to wait until the image is presented on the screen. * Easier API and clearer state (transitions) * More control over Image layouts and command buffer states. (Better alignment with Vulkan API) Pull Request: https://projects.blender.org/blender/blender/pulls/111473
2023-08-29 15:05:08 +02:00
if (!attachments.is_empty()) {
clear(attachments);
}
Vulkan: Clearing Framebuffer + Scissors This PR adds support for clearing framebuffers and scissor testing. Tweaks had to be made to VKTexture to keep track of its layout on the device. Based on the actual call the layout can switch to a more optimum layout. For example during upload of a texture the texture will be converted to a transfer destination optimized layout. When reading from the texture it will be converted to a transfer source optimized layout. The order of the attachments in the framebuffer follows the next rules - When only color attachments are there the color attachments will be placed in the slot they are defined. This way it will match the ShaderCreateInfo binding location. - When a stencil/depth attachment is added it will be placed right after the color attachments. When there isn't a color attachment it will be the first attachment. Pull Request: https://projects.blender.org/blender/blender/pulls/106044
2023-03-28 11:51:32 +02:00
}
void VKFrameBuffer::clear_multi(const float (*clear_color)[4])
{
Vector<VkClearAttachment> attachments;
build_clear_attachments_color(clear_color, true, attachments);
clear(attachments);
GPU: Add placeholder for Vulkan backend. This patch adds a placeholder for the vulkan backend. When activated (`WITH_VULKAN_BACKEND=On` and `--gpu-backend vulkan`) it might open a blender screen, but nothing should be visible as none of the functions are implemented or otherwise crash on a nullptr. This is expected as this is just a placeholder. The goal is to add shader compilation +validation to this backend as one of the next steps so we can validate changes to existing shaders on OpenGL, Metal and Vulkan at the same time. Reviewed By: fclem Differential Revision: https://developer.blender.org/D16338
2022-10-31 16:01:02 +01:00
}
void VKFrameBuffer::clear_attachment(GPUAttachmentType /*type*/,
eGPUDataFormat /*data_format*/,
const void * /*clear_value*/)
{
Vulkan: Clearing Framebuffer + Scissors This PR adds support for clearing framebuffers and scissor testing. Tweaks had to be made to VKTexture to keep track of its layout on the device. Based on the actual call the layout can switch to a more optimum layout. For example during upload of a texture the texture will be converted to a transfer destination optimized layout. When reading from the texture it will be converted to a transfer source optimized layout. The order of the attachments in the framebuffer follows the next rules - When only color attachments are there the color attachments will be placed in the slot they are defined. This way it will match the ShaderCreateInfo binding location. - When a stencil/depth attachment is added it will be placed right after the color attachments. When there isn't a color attachment it will be the first attachment. Pull Request: https://projects.blender.org/blender/blender/pulls/106044
2023-03-28 11:51:32 +02:00
/* Clearing of a single attachment was added to implement `clear_multi` in OpenGL. As
* `clear_multi` is supported in Vulkan it isn't needed to implement this method.
*/
BLI_assert_unreachable();
GPU: Add placeholder for Vulkan backend. This patch adds a placeholder for the vulkan backend. When activated (`WITH_VULKAN_BACKEND=On` and `--gpu-backend vulkan`) it might open a blender screen, but nothing should be visible as none of the functions are implemented or otherwise crash on a nullptr. This is expected as this is just a placeholder. The goal is to add shader compilation +validation to this backend as one of the next steps so we can validate changes to existing shaders on OpenGL, Metal and Vulkan at the same time. Reviewed By: fclem Differential Revision: https://developer.blender.org/D16338
2022-10-31 16:01:02 +01:00
}
Vulkan: Clearing Framebuffer + Scissors This PR adds support for clearing framebuffers and scissor testing. Tweaks had to be made to VKTexture to keep track of its layout on the device. Based on the actual call the layout can switch to a more optimum layout. For example during upload of a texture the texture will be converted to a transfer destination optimized layout. When reading from the texture it will be converted to a transfer source optimized layout. The order of the attachments in the framebuffer follows the next rules - When only color attachments are there the color attachments will be placed in the slot they are defined. This way it will match the ShaderCreateInfo binding location. - When a stencil/depth attachment is added it will be placed right after the color attachments. When there isn't a color attachment it will be the first attachment. Pull Request: https://projects.blender.org/blender/blender/pulls/106044
2023-03-28 11:51:32 +02:00
/** \} */
/* -------------------------------------------------------------------- */
/** \name Load/Store operations
* \{ */
GPU: Add clear color support to explicit FB LoadStore state Enhance custom framebuffer binding state to allow specification of clear color as part of the loadstore state at framebuffer bind time. This ensures all parameters controlling attachment loading and storage behaviour can be explicitly specified when binding a framebuffer. This change enables optimizations which leverage explicit framebuffer load store state to also specify a clear color without prematurely triggering a clear which may occur independently to render work when using GPU_framebuffer_clear(..). Authored by Apple: Michael Parkin-White. Pull Request: https://projects.blender.org/blender/blender/pulls/111810
2023-09-04 18:30:54 +02:00
void VKFrameBuffer::attachment_set_loadstore_op(GPUAttachmentType /*type*/, GPULoadStore /*ls*/)
GPU: Add placeholder for Vulkan backend. This patch adds a placeholder for the vulkan backend. When activated (`WITH_VULKAN_BACKEND=On` and `--gpu-backend vulkan`) it might open a blender screen, but nothing should be visible as none of the functions are implemented or otherwise crash on a nullptr. This is expected as this is just a placeholder. The goal is to add shader compilation +validation to this backend as one of the next steps so we can validate changes to existing shaders on OpenGL, Metal and Vulkan at the same time. Reviewed By: fclem Differential Revision: https://developer.blender.org/D16338
2022-10-31 16:01:02 +01:00
{
Vulkan: Rewrite GHOST_ContextVK This is a rewrite of GHOST_ContextVK to align with Metal backend as described in #111389 - solution 3 with the adaptation that GHOST is still responsible for presenting the swap chain image and a post callback is still needed in case the swapchain is recreated. This PR also includes some smaller improvements in stability. Technical documentation: https://developer.blender.org/docs/eevee_and_viewport/gpu/vulkan/swap_chain/ * Renderpasses and framebuffers are not owned anymore by GHOST_ContextVK * VKFramebuffer doesn't contain a swap chain image. * Swapchain images can only be used as a blit destination or present source. Not as an attachment. * GHOST_ContextVK::swapBuffers would call a callback with the image the GPU module needs to blit the results to. * Clearing of depth/stencil attachments when no depth write state is set. * Enable VK_KHR_maintenance4 to relax the stage interface mapping. * Removes most vulkan validation warnings/errors. * Detection of frame buffer changes that needs to be applied before performing a command requiring render pass (draw/clear attachment) **Benefits** * Late retrieval of a swap chain image results in better overall performance as Blender doesn't need to wait until the image is presented on the screen. * Easier API and clearer state (transitions) * More control over Image layouts and command buffer states. (Better alignment with Vulkan API) Pull Request: https://projects.blender.org/blender/blender/pulls/111473
2023-08-29 15:05:08 +02:00
NOT_YET_IMPLEMENTED;
GPU: Add placeholder for Vulkan backend. This patch adds a placeholder for the vulkan backend. When activated (`WITH_VULKAN_BACKEND=On` and `--gpu-backend vulkan`) it might open a blender screen, but nothing should be visible as none of the functions are implemented or otherwise crash on a nullptr. This is expected as this is just a placeholder. The goal is to add shader compilation +validation to this backend as one of the next steps so we can validate changes to existing shaders on OpenGL, Metal and Vulkan at the same time. Reviewed By: fclem Differential Revision: https://developer.blender.org/D16338
2022-10-31 16:01:02 +01:00
}
Vulkan: Clearing Framebuffer + Scissors This PR adds support for clearing framebuffers and scissor testing. Tweaks had to be made to VKTexture to keep track of its layout on the device. Based on the actual call the layout can switch to a more optimum layout. For example during upload of a texture the texture will be converted to a transfer destination optimized layout. When reading from the texture it will be converted to a transfer source optimized layout. The order of the attachments in the framebuffer follows the next rules - When only color attachments are there the color attachments will be placed in the slot they are defined. This way it will match the ShaderCreateInfo binding location. - When a stencil/depth attachment is added it will be placed right after the color attachments. When there isn't a color attachment it will be the first attachment. Pull Request: https://projects.blender.org/blender/blender/pulls/106044
2023-03-28 11:51:32 +02:00
/** \} */
GL: Add subpass input emulation This adds basic emulation of the subpass input feature of vulkan and to a lower extend Raster Order Group on Metal. This help test paths that might use this feature in the future (like shadow rendering) on all platform and or simplify higher level code for supporting older hardware. This add clear description to the load/store ops and to the new `GPUAttachementState`. The OpenGL backend will correctly mask un-writable attachments and will bind as texture readable attachments. Even if possible by the vulkan standard, the GPU API prohibit the read and write to the same attachment inside the same subpass. In the GL backend, this is implemented using `glTextureBarrier` and `texelFetch` as it is described in the ARB_texture_barrier extension. https://registry.khronos.org/OpenGL/extensions/ARB/ARB_texture_barrier.txt Pull Request: https://projects.blender.org/blender/blender/pulls/112051
2023-10-01 15:27:21 +02:00
/* -------------------------------------------------------------------- */
/** \name Sub-pass transition
* \{ */
GPU: Assert framebuffer operations match attachment layout Ensure attachment states and load/store configs don't get out of sync with the framebuffer layout. In theory, a Framebuffer could have empty attachments interleaved with valid ones so checking just the attachments "length" is not enough. What this does instead is to ensure that valid attachments have a valid config and that null attachments either don't have a matching config or have an IGNORE/DONT_CARE one. Pull Request: https://projects.blender.org/blender/blender/pulls/117073
2024-01-15 13:25:20 +01:00
void VKFrameBuffer::subpass_transition_impl(const GPUAttachmentState /*depth_attachment_state*/,
Span<GPUAttachmentState> /*color_attachment_states*/)
GL: Add subpass input emulation This adds basic emulation of the subpass input feature of vulkan and to a lower extend Raster Order Group on Metal. This help test paths that might use this feature in the future (like shadow rendering) on all platform and or simplify higher level code for supporting older hardware. This add clear description to the load/store ops and to the new `GPUAttachementState`. The OpenGL backend will correctly mask un-writable attachments and will bind as texture readable attachments. Even if possible by the vulkan standard, the GPU API prohibit the read and write to the same attachment inside the same subpass. In the GL backend, this is implemented using `glTextureBarrier` and `texelFetch` as it is described in the ARB_texture_barrier extension. https://registry.khronos.org/OpenGL/extensions/ARB/ARB_texture_barrier.txt Pull Request: https://projects.blender.org/blender/blender/pulls/112051
2023-10-01 15:27:21 +02:00
{
NOT_YET_IMPLEMENTED;
}
/** \} */
Vulkan: Clearing Framebuffer + Scissors This PR adds support for clearing framebuffers and scissor testing. Tweaks had to be made to VKTexture to keep track of its layout on the device. Based on the actual call the layout can switch to a more optimum layout. For example during upload of a texture the texture will be converted to a transfer destination optimized layout. When reading from the texture it will be converted to a transfer source optimized layout. The order of the attachments in the framebuffer follows the next rules - When only color attachments are there the color attachments will be placed in the slot they are defined. This way it will match the ShaderCreateInfo binding location. - When a stencil/depth attachment is added it will be placed right after the color attachments. When there isn't a color attachment it will be the first attachment. Pull Request: https://projects.blender.org/blender/blender/pulls/106044
2023-03-28 11:51:32 +02:00
/* -------------------------------------------------------------------- */
/** \name Read back
* \{ */
Vulkan: Frame Buffer Flipping Vulkan coordinate system is flipped compared to OpenGL. This PR flips the drawing when drawn to the on-screen frame buffer. Offscreen frame buffers are still drawn upside down. The flipping is done by making the viewport of the framebuffer negative. Pull Request: https://projects.blender.org/blender/blender/pulls/107743
2023-05-09 09:22:26 +02:00
void VKFrameBuffer::read(eGPUFrameBufferBits plane,
eGPUDataFormat format,
Vulkan: Area Readback of Framebuffer Textures This PR adds the ability to only read back an area of a framebuffer texture. It also adds the ability to read back from the depth attachment. Also reduces the amount of needed memory and reduces the CPU cycles by reading back directly into the memory provided by the user. The previous implementation wasn't able to do so as the `VKTexture::read` function always returned a new buffer. The introduced `VKTexture::read_sub` works on a pre-allocated buffer. Pull Request: https://projects.blender.org/blender/blender/pulls/108418
2023-05-30 13:47:55 +02:00
const int area[4],
int /*channel_len*/,
Vulkan: Frame Buffer Flipping Vulkan coordinate system is flipped compared to OpenGL. This PR flips the drawing when drawn to the on-screen frame buffer. Offscreen frame buffers are still drawn upside down. The flipping is done by making the viewport of the framebuffer negative. Pull Request: https://projects.blender.org/blender/blender/pulls/107743
2023-05-09 09:22:26 +02:00
int slot,
void *r_data)
GPU: Add placeholder for Vulkan backend. This patch adds a placeholder for the vulkan backend. When activated (`WITH_VULKAN_BACKEND=On` and `--gpu-backend vulkan`) it might open a blender screen, but nothing should be visible as none of the functions are implemented or otherwise crash on a nullptr. This is expected as this is just a placeholder. The goal is to add shader compilation +validation to this backend as one of the next steps so we can validate changes to existing shaders on OpenGL, Metal and Vulkan at the same time. Reviewed By: fclem Differential Revision: https://developer.blender.org/D16338
2022-10-31 16:01:02 +01:00
{
Vulkan: Add support for Framebuffer Depth Blit This PR adds support for `GPU_framebuffer_blit` When used with `GPU_DEPTH_BIT`. The challenge with is that not all GPUs support using a depth texture as a blit destination. An AMD GPU doesn't support a depth buffer with stencil buffer as blit destination. ![image](/attachments/130e7e38-2dbc-4653-950c-2234bd5bad52) > NOTE: AMD GPUs don't support 24 bit unsigned normalized depth textures at all. In all cases when we use depth blitting we are blitting the whole texture and in stead we can use a texture copy. A negative effect is that we need to unbind the framebuffer when copying depth textures, but a positive effect is that we can use a data transfer function what should theoretically be faster. This should be revisited when we are investigating in areas to improve the performance of the Vulkan backend. Pull Request: https://projects.blender.org/blender/blender/pulls/112674
2023-09-28 10:00:24 +02:00
VKContext &context = *VKContext::get();
Vulkan: Readback Texture Views When using EEVEE-Next the final render data is readback from texture views. This wasn't implemented yet. This PR adds support for reading back texture views. It also makes sure the correct layer is read when reading back data from framebuffers and adds internal support to read back a partial texture. Pull Request: https://projects.blender.org/blender/blender/pulls/114411
2023-11-02 15:55:05 +01:00
GPUAttachment *attachment = nullptr;
Vulkan: Frame Buffer Flipping Vulkan coordinate system is flipped compared to OpenGL. This PR flips the drawing when drawn to the on-screen frame buffer. Offscreen frame buffers are still drawn upside down. The flipping is done by making the viewport of the framebuffer negative. Pull Request: https://projects.blender.org/blender/blender/pulls/107743
2023-05-09 09:22:26 +02:00
switch (plane) {
case GPU_COLOR_BIT:
Vulkan: Readback Texture Views When using EEVEE-Next the final render data is readback from texture views. This wasn't implemented yet. This PR adds support for reading back texture views. It also makes sure the correct layer is read when reading back data from framebuffers and adds internal support to read back a partial texture. Pull Request: https://projects.blender.org/blender/blender/pulls/114411
2023-11-02 15:55:05 +01:00
attachment = &attachments_[GPU_FB_COLOR_ATTACHMENT0 + slot];
Vulkan: Add support for Framebuffer Depth Blit This PR adds support for `GPU_framebuffer_blit` When used with `GPU_DEPTH_BIT`. The challenge with is that not all GPUs support using a depth texture as a blit destination. An AMD GPU doesn't support a depth buffer with stencil buffer as blit destination. ![image](/attachments/130e7e38-2dbc-4653-950c-2234bd5bad52) > NOTE: AMD GPUs don't support 24 bit unsigned normalized depth textures at all. In all cases when we use depth blitting we are blitting the whole texture and in stead we can use a texture copy. A negative effect is that we need to unbind the framebuffer when copying depth textures, but a positive effect is that we can use a data transfer function what should theoretically be faster. This should be revisited when we are investigating in areas to improve the performance of the Vulkan backend. Pull Request: https://projects.blender.org/blender/blender/pulls/112674
2023-09-28 10:00:24 +02:00
color_attachment_layout_ensure(context, slot, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL);
Vulkan: Frame Buffer Flipping Vulkan coordinate system is flipped compared to OpenGL. This PR flips the drawing when drawn to the on-screen frame buffer. Offscreen frame buffers are still drawn upside down. The flipping is done by making the viewport of the framebuffer negative. Pull Request: https://projects.blender.org/blender/blender/pulls/107743
2023-05-09 09:22:26 +02:00
break;
Vulkan: Area Readback of Framebuffer Textures This PR adds the ability to only read back an area of a framebuffer texture. It also adds the ability to read back from the depth attachment. Also reduces the amount of needed memory and reduces the CPU cycles by reading back directly into the memory provided by the user. The previous implementation wasn't able to do so as the `VKTexture::read` function always returned a new buffer. The introduced `VKTexture::read_sub` works on a pre-allocated buffer. Pull Request: https://projects.blender.org/blender/blender/pulls/108418
2023-05-30 13:47:55 +02:00
case GPU_DEPTH_BIT:
Vulkan: Readback Texture Views When using EEVEE-Next the final render data is readback from texture views. This wasn't implemented yet. This PR adds support for reading back texture views. It also makes sure the correct layer is read when reading back data from framebuffers and adds internal support to read back a partial texture. Pull Request: https://projects.blender.org/blender/blender/pulls/114411
2023-11-02 15:55:05 +01:00
attachment = attachments_[GPU_FB_DEPTH_ATTACHMENT].tex ?
&attachments_[GPU_FB_DEPTH_ATTACHMENT] :
&attachments_[GPU_FB_DEPTH_STENCIL_ATTACHMENT];
Vulkan: Add support for Framebuffer Depth Blit This PR adds support for `GPU_framebuffer_blit` When used with `GPU_DEPTH_BIT`. The challenge with is that not all GPUs support using a depth texture as a blit destination. An AMD GPU doesn't support a depth buffer with stencil buffer as blit destination. ![image](/attachments/130e7e38-2dbc-4653-950c-2234bd5bad52) > NOTE: AMD GPUs don't support 24 bit unsigned normalized depth textures at all. In all cases when we use depth blitting we are blitting the whole texture and in stead we can use a texture copy. A negative effect is that we need to unbind the framebuffer when copying depth textures, but a positive effect is that we can use a data transfer function what should theoretically be faster. This should be revisited when we are investigating in areas to improve the performance of the Vulkan backend. Pull Request: https://projects.blender.org/blender/blender/pulls/112674
2023-09-28 10:00:24 +02:00
depth_attachment_layout_ensure(context, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL);
Vulkan: Area Readback of Framebuffer Textures This PR adds the ability to only read back an area of a framebuffer texture. It also adds the ability to read back from the depth attachment. Also reduces the amount of needed memory and reduces the CPU cycles by reading back directly into the memory provided by the user. The previous implementation wasn't able to do so as the `VKTexture::read` function always returned a new buffer. The introduced `VKTexture::read_sub` works on a pre-allocated buffer. Pull Request: https://projects.blender.org/blender/blender/pulls/108418
2023-05-30 13:47:55 +02:00
break;
Vulkan: Frame Buffer Flipping Vulkan coordinate system is flipped compared to OpenGL. This PR flips the drawing when drawn to the on-screen frame buffer. Offscreen frame buffers are still drawn upside down. The flipping is done by making the viewport of the framebuffer negative. Pull Request: https://projects.blender.org/blender/blender/pulls/107743
2023-05-09 09:22:26 +02:00
default:
BLI_assert_unreachable();
return;
}
Vulkan: Readback Texture Views When using EEVEE-Next the final render data is readback from texture views. This wasn't implemented yet. This PR adds support for reading back texture views. It also makes sure the correct layer is read when reading back data from framebuffers and adds internal support to read back a partial texture. Pull Request: https://projects.blender.org/blender/blender/pulls/114411
2023-11-02 15:55:05 +01:00
VKTexture *texture = unwrap(unwrap(attachment->tex));
Vulkan: Frame Buffer Flipping Vulkan coordinate system is flipped compared to OpenGL. This PR flips the drawing when drawn to the on-screen frame buffer. Offscreen frame buffers are still drawn upside down. The flipping is done by making the viewport of the framebuffer negative. Pull Request: https://projects.blender.org/blender/blender/pulls/107743
2023-05-09 09:22:26 +02:00
BLI_assert_msg(texture,
Vulkan: Area Readback of Framebuffer Textures This PR adds the ability to only read back an area of a framebuffer texture. It also adds the ability to read back from the depth attachment. Also reduces the amount of needed memory and reduces the CPU cycles by reading back directly into the memory provided by the user. The previous implementation wasn't able to do so as the `VKTexture::read` function always returned a new buffer. The introduced `VKTexture::read_sub` works on a pre-allocated buffer. Pull Request: https://projects.blender.org/blender/blender/pulls/108418
2023-05-30 13:47:55 +02:00
"Trying to read back texture from framebuffer, but no texture is available in "
"requested slot.");
Vulkan: Readback Texture Views When using EEVEE-Next the final render data is readback from texture views. This wasn't implemented yet. This PR adds support for reading back texture views. It also makes sure the correct layer is read when reading back data from framebuffers and adds internal support to read back a partial texture. Pull Request: https://projects.blender.org/blender/blender/pulls/114411
2023-11-02 15:55:05 +01:00
if (texture == nullptr) {
return;
}
Vulkan: Fix Image Range Validation Error Co-authored-by: vnapdv <kaz380@hotmail.co.jp> Pull Request: https://projects.blender.org/blender/blender/pulls/117024
2024-01-11 12:47:11 +01:00
const int area6[6] = {area[0], area[1], 0, area[2], area[3], 1};
Vulkan: Readback Texture Views When using EEVEE-Next the final render data is readback from texture views. This wasn't implemented yet. This PR adds support for reading back texture views. It also makes sure the correct layer is read when reading back data from framebuffers and adds internal support to read back a partial texture. Pull Request: https://projects.blender.org/blender/blender/pulls/114411
2023-11-02 15:55:05 +01:00
IndexRange layers(max_ii(attachment->layer, 0), 1);
Vulkan: Fix Image Range Validation Error Co-authored-by: vnapdv <kaz380@hotmail.co.jp> Pull Request: https://projects.blender.org/blender/blender/pulls/117024
2024-01-11 12:47:11 +01:00
texture->read_sub(0, format, area6, layers, r_data);
GPU: Add placeholder for Vulkan backend. This patch adds a placeholder for the vulkan backend. When activated (`WITH_VULKAN_BACKEND=On` and `--gpu-backend vulkan`) it might open a blender screen, but nothing should be visible as none of the functions are implemented or otherwise crash on a nullptr. This is expected as this is just a placeholder. The goal is to add shader compilation +validation to this backend as one of the next steps so we can validate changes to existing shaders on OpenGL, Metal and Vulkan at the same time. Reviewed By: fclem Differential Revision: https://developer.blender.org/D16338
2022-10-31 16:01:02 +01:00
}
Vulkan: Clearing Framebuffer + Scissors This PR adds support for clearing framebuffers and scissor testing. Tweaks had to be made to VKTexture to keep track of its layout on the device. Based on the actual call the layout can switch to a more optimum layout. For example during upload of a texture the texture will be converted to a transfer destination optimized layout. When reading from the texture it will be converted to a transfer source optimized layout. The order of the attachments in the framebuffer follows the next rules - When only color attachments are there the color attachments will be placed in the slot they are defined. This way it will match the ShaderCreateInfo binding location. - When a stencil/depth attachment is added it will be placed right after the color attachments. When there isn't a color attachment it will be the first attachment. Pull Request: https://projects.blender.org/blender/blender/pulls/106044
2023-03-28 11:51:32 +02:00
/** \} */
/* -------------------------------------------------------------------- */
/** \name Blit operations
* \{ */
Vulkan: Separate DataTransfer, Compute, Graphics Commands Goal is to reduce the number of command buffer flushes by tracking what is happening in the different command queues. This is an initial step towards advanced queue-ing strategies. The new (intermediate) strategy records commands to different command buffers based on what they do. There is a command buffer for data transfers, compute pipelines and graphics pipelines. When a compute command is recorded it ensures that all graphic commands are finished. When a graphic command is recorded it ensures all compute commands are finished. When a graphic or compute command is scheduled all recorded data transfer commands are scheduled as well. Some improvements are expected as multiple compute and data transfers commands can now be scheduled at the same time and don't need to unbind and rebind render passes. Especially when using EEVEE-Next which is compute centric the performance change is visible for the user. Pull Request: https://projects.blender.org/blender/blender/pulls/114104
2023-10-30 14:21:14 +01:00
static void blit_aspect(VKCommandBuffers &command_buffer,
Vulkan: Add support for Framebuffer Depth Blit This PR adds support for `GPU_framebuffer_blit` When used with `GPU_DEPTH_BIT`. The challenge with is that not all GPUs support using a depth texture as a blit destination. An AMD GPU doesn't support a depth buffer with stencil buffer as blit destination. ![image](/attachments/130e7e38-2dbc-4653-950c-2234bd5bad52) > NOTE: AMD GPUs don't support 24 bit unsigned normalized depth textures at all. In all cases when we use depth blitting we are blitting the whole texture and in stead we can use a texture copy. A negative effect is that we need to unbind the framebuffer when copying depth textures, but a positive effect is that we can use a data transfer function what should theoretically be faster. This should be revisited when we are investigating in areas to improve the performance of the Vulkan backend. Pull Request: https://projects.blender.org/blender/blender/pulls/112674
2023-09-28 10:00:24 +02:00
VKTexture &dst_texture,
VKTexture &src_texture,
int dst_offset_x,
int dst_offset_y,
Cleanup: Vulkan: Replace FlagBits with Flags Vulkan API uses Flags and FlagBits for enumerations. The FlagBits contains the options that can be hold with the Flags data type. This wasn't well understood at the beginning of the project and the FlagBits where used where Flags should have been used. This cleanup fixes this, improving the readability of the code where bit manipulations where used. Pull Request: https://projects.blender.org/blender/blender/pulls/114459
2023-11-03 14:42:12 +01:00
VkImageAspectFlags image_aspect)
GPU: Add placeholder for Vulkan backend. This patch adds a placeholder for the vulkan backend. When activated (`WITH_VULKAN_BACKEND=On` and `--gpu-backend vulkan`) it might open a blender screen, but nothing should be visible as none of the functions are implemented or otherwise crash on a nullptr. This is expected as this is just a placeholder. The goal is to add shader compilation +validation to this backend as one of the next steps so we can validate changes to existing shaders on OpenGL, Metal and Vulkan at the same time. Reviewed By: fclem Differential Revision: https://developer.blender.org/D16338
2022-10-31 16:01:02 +01:00
{
Vulkan: Add support for Framebuffer Depth Blit This PR adds support for `GPU_framebuffer_blit` When used with `GPU_DEPTH_BIT`. The challenge with is that not all GPUs support using a depth texture as a blit destination. An AMD GPU doesn't support a depth buffer with stencil buffer as blit destination. ![image](/attachments/130e7e38-2dbc-4653-950c-2234bd5bad52) > NOTE: AMD GPUs don't support 24 bit unsigned normalized depth textures at all. In all cases when we use depth blitting we are blitting the whole texture and in stead we can use a texture copy. A negative effect is that we need to unbind the framebuffer when copying depth textures, but a positive effect is that we can use a data transfer function what should theoretically be faster. This should be revisited when we are investigating in areas to improve the performance of the Vulkan backend. Pull Request: https://projects.blender.org/blender/blender/pulls/112674
2023-09-28 10:00:24 +02:00
/* Prefer texture copy, as some platforms don't support using D32_SFLOAT_S8_UINT to be used as
* a blit destination. */
if (dst_offset_x == 0 && dst_offset_y == 0 &&
Vulkan: Reusing Textures from Pool This PR solves an issue when using texture pools with textures that are not natively supported by the device. In the previous implementation the internal `Texture::format_` was changed. Any check if the texture could be reused would fail as its format would be different that the requested one. This PR fixes this by separating the requested format `Texture::format_` and how it is stored on the GPU `VKTexture::device_format_`. This solves the next artifacts: * Workbench flickering artifacts on AMD/Intel GPUs * Workbench TAA on AMD/Intel GPUs * Overlays were not always drawn fully solid Pull Request: https://projects.blender.org/blender/blender/pulls/114697
2023-11-10 12:52:34 +01:00
dst_texture.device_format_get() == src_texture.device_format_get() &&
Vulkan: Add support for Framebuffer Depth Blit This PR adds support for `GPU_framebuffer_blit` When used with `GPU_DEPTH_BIT`. The challenge with is that not all GPUs support using a depth texture as a blit destination. An AMD GPU doesn't support a depth buffer with stencil buffer as blit destination. ![image](/attachments/130e7e38-2dbc-4653-950c-2234bd5bad52) > NOTE: AMD GPUs don't support 24 bit unsigned normalized depth textures at all. In all cases when we use depth blitting we are blitting the whole texture and in stead we can use a texture copy. A negative effect is that we need to unbind the framebuffer when copying depth textures, but a positive effect is that we can use a data transfer function what should theoretically be faster. This should be revisited when we are investigating in areas to improve the performance of the Vulkan backend. Pull Request: https://projects.blender.org/blender/blender/pulls/112674
2023-09-28 10:00:24 +02:00
src_texture.width_get() == dst_texture.width_get() &&
src_texture.height_get() == dst_texture.height_get())
{
src_texture.copy_to(dst_texture, image_aspect);
Vulkan: Frame Buffer Flipping Vulkan coordinate system is flipped compared to OpenGL. This PR flips the drawing when drawn to the on-screen frame buffer. Offscreen frame buffers are still drawn upside down. The flipping is done by making the viewport of the framebuffer negative. Pull Request: https://projects.blender.org/blender/blender/pulls/107743
2023-05-09 09:22:26 +02:00
return;
}
VkImageBlit image_blit = {};
Vulkan: Add support for Framebuffer Depth Blit This PR adds support for `GPU_framebuffer_blit` When used with `GPU_DEPTH_BIT`. The challenge with is that not all GPUs support using a depth texture as a blit destination. An AMD GPU doesn't support a depth buffer with stencil buffer as blit destination. ![image](/attachments/130e7e38-2dbc-4653-950c-2234bd5bad52) > NOTE: AMD GPUs don't support 24 bit unsigned normalized depth textures at all. In all cases when we use depth blitting we are blitting the whole texture and in stead we can use a texture copy. A negative effect is that we need to unbind the framebuffer when copying depth textures, but a positive effect is that we can use a data transfer function what should theoretically be faster. This should be revisited when we are investigating in areas to improve the performance of the Vulkan backend. Pull Request: https://projects.blender.org/blender/blender/pulls/112674
2023-09-28 10:00:24 +02:00
image_blit.srcSubresource.aspectMask = image_aspect;
Vulkan: Frame Buffer Flipping Vulkan coordinate system is flipped compared to OpenGL. This PR flips the drawing when drawn to the on-screen frame buffer. Offscreen frame buffers are still drawn upside down. The flipping is done by making the viewport of the framebuffer negative. Pull Request: https://projects.blender.org/blender/blender/pulls/107743
2023-05-09 09:22:26 +02:00
image_blit.srcSubresource.mipLevel = 0;
image_blit.srcSubresource.baseArrayLayer = 0;
image_blit.srcSubresource.layerCount = 1;
image_blit.srcOffsets[0].x = 0;
image_blit.srcOffsets[0].y = 0;
image_blit.srcOffsets[0].z = 0;
image_blit.srcOffsets[1].x = src_texture.width_get();
image_blit.srcOffsets[1].y = src_texture.height_get();
image_blit.srcOffsets[1].z = 1;
Vulkan: Add support for Framebuffer Depth Blit This PR adds support for `GPU_framebuffer_blit` When used with `GPU_DEPTH_BIT`. The challenge with is that not all GPUs support using a depth texture as a blit destination. An AMD GPU doesn't support a depth buffer with stencil buffer as blit destination. ![image](/attachments/130e7e38-2dbc-4653-950c-2234bd5bad52) > NOTE: AMD GPUs don't support 24 bit unsigned normalized depth textures at all. In all cases when we use depth blitting we are blitting the whole texture and in stead we can use a texture copy. A negative effect is that we need to unbind the framebuffer when copying depth textures, but a positive effect is that we can use a data transfer function what should theoretically be faster. This should be revisited when we are investigating in areas to improve the performance of the Vulkan backend. Pull Request: https://projects.blender.org/blender/blender/pulls/112674
2023-09-28 10:00:24 +02:00
image_blit.dstSubresource.aspectMask = image_aspect;
Vulkan: Frame Buffer Flipping Vulkan coordinate system is flipped compared to OpenGL. This PR flips the drawing when drawn to the on-screen frame buffer. Offscreen frame buffers are still drawn upside down. The flipping is done by making the viewport of the framebuffer negative. Pull Request: https://projects.blender.org/blender/blender/pulls/107743
2023-05-09 09:22:26 +02:00
image_blit.dstSubresource.mipLevel = 0;
image_blit.dstSubresource.baseArrayLayer = 0;
image_blit.dstSubresource.layerCount = 1;
Vulkan: Fix Blitting Extents During Blitting it is not allowed to read/write outside the texture bounds. This patch ensures that the bounds (called extents in Vulkan) are inside the expected range. Pull Request: https://projects.blender.org/blender/blender/pulls/113050
2023-09-29 11:44:50 +02:00
image_blit.dstOffsets[0].x = min_ii(dst_offset_x, dst_texture.width_get());
image_blit.dstOffsets[0].y = min_ii(dst_offset_y, dst_texture.height_get());
Vulkan: Frame Buffer Flipping Vulkan coordinate system is flipped compared to OpenGL. This PR flips the drawing when drawn to the on-screen frame buffer. Offscreen frame buffers are still drawn upside down. The flipping is done by making the viewport of the framebuffer negative. Pull Request: https://projects.blender.org/blender/blender/pulls/107743
2023-05-09 09:22:26 +02:00
image_blit.dstOffsets[0].z = 0;
Vulkan: Fix Blitting Extents During Blitting it is not allowed to read/write outside the texture bounds. This patch ensures that the bounds (called extents in Vulkan) are inside the expected range. Pull Request: https://projects.blender.org/blender/blender/pulls/113050
2023-09-29 11:44:50 +02:00
image_blit.dstOffsets[1].x = min_ii(dst_offset_x + src_texture.width_get(),
dst_texture.width_get());
image_blit.dstOffsets[1].y = min_ii(dst_offset_y + src_texture.height_get(),
dst_texture.height_get());
Vulkan: Frame Buffer Flipping Vulkan coordinate system is flipped compared to OpenGL. This PR flips the drawing when drawn to the on-screen frame buffer. Offscreen frame buffers are still drawn upside down. The flipping is done by making the viewport of the framebuffer negative. Pull Request: https://projects.blender.org/blender/blender/pulls/107743
2023-05-09 09:22:26 +02:00
image_blit.dstOffsets[1].z = 1;
Vulkan: Add support for Framebuffer Depth Blit This PR adds support for `GPU_framebuffer_blit` When used with `GPU_DEPTH_BIT`. The challenge with is that not all GPUs support using a depth texture as a blit destination. An AMD GPU doesn't support a depth buffer with stencil buffer as blit destination. ![image](/attachments/130e7e38-2dbc-4653-950c-2234bd5bad52) > NOTE: AMD GPUs don't support 24 bit unsigned normalized depth textures at all. In all cases when we use depth blitting we are blitting the whole texture and in stead we can use a texture copy. A negative effect is that we need to unbind the framebuffer when copying depth textures, but a positive effect is that we can use a data transfer function what should theoretically be faster. This should be revisited when we are investigating in areas to improve the performance of the Vulkan backend. Pull Request: https://projects.blender.org/blender/blender/pulls/112674
2023-09-28 10:00:24 +02:00
command_buffer.blit(dst_texture, src_texture, Span<VkImageBlit>(&image_blit, 1));
}
void VKFrameBuffer::blit_to(eGPUFrameBufferBits planes,
int src_slot,
FrameBuffer *dst,
int dst_slot,
int dst_offset_x,
int dst_offset_y)
{
BLI_assert(dst);
BLI_assert_msg(ELEM(planes, GPU_COLOR_BIT, GPU_DEPTH_BIT),
"VKFrameBuffer::blit_to only supports a single color or depth aspect.");
UNUSED_VARS_NDEBUG(planes);
VKContext &context = *VKContext::get();
Vulkan: Separate DataTransfer, Compute, Graphics Commands Goal is to reduce the number of command buffer flushes by tracking what is happening in the different command queues. This is an initial step towards advanced queue-ing strategies. The new (intermediate) strategy records commands to different command buffers based on what they do. There is a command buffer for data transfers, compute pipelines and graphics pipelines. When a compute command is recorded it ensures that all graphic commands are finished. When a graphic command is recorded it ensures all compute commands are finished. When a graphic or compute command is scheduled all recorded data transfer commands are scheduled as well. Some improvements are expected as multiple compute and data transfers commands can now be scheduled at the same time and don't need to unbind and rebind render passes. Especially when using EEVEE-Next which is compute centric the performance change is visible for the user. Pull Request: https://projects.blender.org/blender/blender/pulls/114104
2023-10-30 14:21:14 +01:00
VKCommandBuffers &command_buffers = context.command_buffers_get();
Vulkan: Add support for Framebuffer Depth Blit This PR adds support for `GPU_framebuffer_blit` When used with `GPU_DEPTH_BIT`. The challenge with is that not all GPUs support using a depth texture as a blit destination. An AMD GPU doesn't support a depth buffer with stencil buffer as blit destination. ![image](/attachments/130e7e38-2dbc-4653-950c-2234bd5bad52) > NOTE: AMD GPUs don't support 24 bit unsigned normalized depth textures at all. In all cases when we use depth blitting we are blitting the whole texture and in stead we can use a texture copy. A negative effect is that we need to unbind the framebuffer when copying depth textures, but a positive effect is that we can use a data transfer function what should theoretically be faster. This should be revisited when we are investigating in areas to improve the performance of the Vulkan backend. Pull Request: https://projects.blender.org/blender/blender/pulls/112674
2023-09-28 10:00:24 +02:00
if (!context.has_active_framebuffer()) {
BLI_assert_unreachable();
return;
}
VKFrameBuffer &dst_framebuffer = *unwrap(dst);
if (planes & GPU_COLOR_BIT) {
const GPUAttachment &src_attachment = attachments_[GPU_FB_COLOR_ATTACHMENT0 + src_slot];
const GPUAttachment &dst_attachment =
dst_framebuffer.attachments_[GPU_FB_COLOR_ATTACHMENT0 + dst_slot];
if (src_attachment.tex && dst_attachment.tex) {
VKTexture &src_texture = *unwrap(unwrap(src_attachment.tex));
VKTexture &dst_texture = *unwrap(unwrap(dst_attachment.tex));
color_attachment_layout_ensure(context, src_slot, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL);
dst_framebuffer.color_attachment_layout_ensure(
context, dst_slot, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL);
Vulkan: Separate DataTransfer, Compute, Graphics Commands Goal is to reduce the number of command buffer flushes by tracking what is happening in the different command queues. This is an initial step towards advanced queue-ing strategies. The new (intermediate) strategy records commands to different command buffers based on what they do. There is a command buffer for data transfers, compute pipelines and graphics pipelines. When a compute command is recorded it ensures that all graphic commands are finished. When a graphic command is recorded it ensures all compute commands are finished. When a graphic or compute command is scheduled all recorded data transfer commands are scheduled as well. Some improvements are expected as multiple compute and data transfers commands can now be scheduled at the same time and don't need to unbind and rebind render passes. Especially when using EEVEE-Next which is compute centric the performance change is visible for the user. Pull Request: https://projects.blender.org/blender/blender/pulls/114104
2023-10-30 14:21:14 +01:00
blit_aspect(command_buffers,
Vulkan: Add support for Framebuffer Depth Blit This PR adds support for `GPU_framebuffer_blit` When used with `GPU_DEPTH_BIT`. The challenge with is that not all GPUs support using a depth texture as a blit destination. An AMD GPU doesn't support a depth buffer with stencil buffer as blit destination. ![image](/attachments/130e7e38-2dbc-4653-950c-2234bd5bad52) > NOTE: AMD GPUs don't support 24 bit unsigned normalized depth textures at all. In all cases when we use depth blitting we are blitting the whole texture and in stead we can use a texture copy. A negative effect is that we need to unbind the framebuffer when copying depth textures, but a positive effect is that we can use a data transfer function what should theoretically be faster. This should be revisited when we are investigating in areas to improve the performance of the Vulkan backend. Pull Request: https://projects.blender.org/blender/blender/pulls/112674
2023-09-28 10:00:24 +02:00
dst_texture,
src_texture,
dst_offset_x,
dst_offset_y,
VK_IMAGE_ASPECT_COLOR_BIT);
}
}
if (planes & GPU_DEPTH_BIT) {
/* Retrieve source texture. */
const GPUAttachment &src_attachment = attachments_[GPU_FB_DEPTH_STENCIL_ATTACHMENT].tex ?
attachments_[GPU_FB_DEPTH_STENCIL_ATTACHMENT] :
attachments_[GPU_FB_DEPTH_ATTACHMENT];
const GPUAttachment &dst_attachment =
dst_framebuffer.attachments_[GPU_FB_DEPTH_STENCIL_ATTACHMENT].tex ?
dst_framebuffer.attachments_[GPU_FB_DEPTH_STENCIL_ATTACHMENT] :
dst_framebuffer.attachments_[GPU_FB_DEPTH_ATTACHMENT];
if (src_attachment.tex && dst_attachment.tex) {
VKTexture &src_texture = *unwrap(unwrap(src_attachment.tex));
VKTexture &dst_texture = *unwrap(unwrap(dst_attachment.tex));
depth_attachment_layout_ensure(context, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL);
dst_framebuffer.depth_attachment_layout_ensure(context,
VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL);
Vulkan: Separate DataTransfer, Compute, Graphics Commands Goal is to reduce the number of command buffer flushes by tracking what is happening in the different command queues. This is an initial step towards advanced queue-ing strategies. The new (intermediate) strategy records commands to different command buffers based on what they do. There is a command buffer for data transfers, compute pipelines and graphics pipelines. When a compute command is recorded it ensures that all graphic commands are finished. When a graphic command is recorded it ensures all compute commands are finished. When a graphic or compute command is scheduled all recorded data transfer commands are scheduled as well. Some improvements are expected as multiple compute and data transfers commands can now be scheduled at the same time and don't need to unbind and rebind render passes. Especially when using EEVEE-Next which is compute centric the performance change is visible for the user. Pull Request: https://projects.blender.org/blender/blender/pulls/114104
2023-10-30 14:21:14 +01:00
blit_aspect(command_buffers,
Vulkan: Add support for Framebuffer Depth Blit This PR adds support for `GPU_framebuffer_blit` When used with `GPU_DEPTH_BIT`. The challenge with is that not all GPUs support using a depth texture as a blit destination. An AMD GPU doesn't support a depth buffer with stencil buffer as blit destination. ![image](/attachments/130e7e38-2dbc-4653-950c-2234bd5bad52) > NOTE: AMD GPUs don't support 24 bit unsigned normalized depth textures at all. In all cases when we use depth blitting we are blitting the whole texture and in stead we can use a texture copy. A negative effect is that we need to unbind the framebuffer when copying depth textures, but a positive effect is that we can use a data transfer function what should theoretically be faster. This should be revisited when we are investigating in areas to improve the performance of the Vulkan backend. Pull Request: https://projects.blender.org/blender/blender/pulls/112674
2023-09-28 10:00:24 +02:00
dst_texture,
src_texture,
dst_offset_x,
dst_offset_y,
VK_IMAGE_ASPECT_DEPTH_BIT);
}
}
GPU: Add placeholder for Vulkan backend. This patch adds a placeholder for the vulkan backend. When activated (`WITH_VULKAN_BACKEND=On` and `--gpu-backend vulkan`) it might open a blender screen, but nothing should be visible as none of the functions are implemented or otherwise crash on a nullptr. This is expected as this is just a placeholder. The goal is to add shader compilation +validation to this backend as one of the next steps so we can validate changes to existing shaders on OpenGL, Metal and Vulkan at the same time. Reviewed By: fclem Differential Revision: https://developer.blender.org/D16338
2022-10-31 16:01:02 +01:00
}
Vulkan: Clearing Framebuffer + Scissors This PR adds support for clearing framebuffers and scissor testing. Tweaks had to be made to VKTexture to keep track of its layout on the device. Based on the actual call the layout can switch to a more optimum layout. For example during upload of a texture the texture will be converted to a transfer destination optimized layout. When reading from the texture it will be converted to a transfer source optimized layout. The order of the attachments in the framebuffer follows the next rules - When only color attachments are there the color attachments will be placed in the slot they are defined. This way it will match the ShaderCreateInfo binding location. - When a stencil/depth attachment is added it will be placed right after the color attachments. When there isn't a color attachment it will be the first attachment. Pull Request: https://projects.blender.org/blender/blender/pulls/106044
2023-03-28 11:51:32 +02:00
/** \} */
/* -------------------------------------------------------------------- */
/** \name Update attachments
* \{ */
Vulkan: Rewrite GHOST_ContextVK This is a rewrite of GHOST_ContextVK to align with Metal backend as described in #111389 - solution 3 with the adaptation that GHOST is still responsible for presenting the swap chain image and a post callback is still needed in case the swapchain is recreated. This PR also includes some smaller improvements in stability. Technical documentation: https://developer.blender.org/docs/eevee_and_viewport/gpu/vulkan/swap_chain/ * Renderpasses and framebuffers are not owned anymore by GHOST_ContextVK * VKFramebuffer doesn't contain a swap chain image. * Swapchain images can only be used as a blit destination or present source. Not as an attachment. * GHOST_ContextVK::swapBuffers would call a callback with the image the GPU module needs to blit the results to. * Clearing of depth/stencil attachments when no depth write state is set. * Enable VK_KHR_maintenance4 to relax the stage interface mapping. * Removes most vulkan validation warnings/errors. * Detection of frame buffer changes that needs to be applied before performing a command requiring render pass (draw/clear attachment) **Benefits** * Late retrieval of a swap chain image results in better overall performance as Blender doesn't need to wait until the image is presented on the screen. * Easier API and clearer state (transitions) * More control over Image layouts and command buffer states. (Better alignment with Vulkan API) Pull Request: https://projects.blender.org/blender/blender/pulls/111473
2023-08-29 15:05:08 +02:00
void VKFrameBuffer::vk_render_pass_ensure()
Vulkan: Clearing Framebuffer + Scissors This PR adds support for clearing framebuffers and scissor testing. Tweaks had to be made to VKTexture to keep track of its layout on the device. Based on the actual call the layout can switch to a more optimum layout. For example during upload of a texture the texture will be converted to a transfer destination optimized layout. When reading from the texture it will be converted to a transfer source optimized layout. The order of the attachments in the framebuffer follows the next rules - When only color attachments are there the color attachments will be placed in the slot they are defined. This way it will match the ShaderCreateInfo binding location. - When a stencil/depth attachment is added it will be placed right after the color attachments. When there isn't a color attachment it will be the first attachment. Pull Request: https://projects.blender.org/blender/blender/pulls/106044
2023-03-28 11:51:32 +02:00
{
if (!dirty_attachments_) {
return;
}
render_pass_free();
render_pass_create();
dirty_attachments_ = false;
}
void VKFrameBuffer::render_pass_create()
{
BLI_assert(vk_render_pass_ == VK_NULL_HANDLE);
BLI_assert(vk_framebuffer_ == VK_NULL_HANDLE);
VK_ALLOCATION_CALLBACKS
Cleanup: spelling in comments
2023-04-05 14:38:26 +10:00
/* Track first attachment for size. */
Vulkan: Clearing Framebuffer + Scissors This PR adds support for clearing framebuffers and scissor testing. Tweaks had to be made to VKTexture to keep track of its layout on the device. Based on the actual call the layout can switch to a more optimum layout. For example during upload of a texture the texture will be converted to a transfer destination optimized layout. When reading from the texture it will be converted to a transfer source optimized layout. The order of the attachments in the framebuffer follows the next rules - When only color attachments are there the color attachments will be placed in the slot they are defined. This way it will match the ShaderCreateInfo binding location. - When a stencil/depth attachment is added it will be placed right after the color attachments. When there isn't a color attachment it will be the first attachment. Pull Request: https://projects.blender.org/blender/blender/pulls/106044
2023-03-28 11:51:32 +02:00
GPUAttachmentType first_attachment = GPU_FB_MAX_ATTACHMENT;
std::array<VkAttachmentDescription, GPU_FB_MAX_ATTACHMENT> attachment_descriptions;
std::array<VkImageView, GPU_FB_MAX_ATTACHMENT> image_views;
std::array<VkAttachmentReference, GPU_FB_MAX_ATTACHMENT> attachment_references;
Vulkan: Image Views The ownership of image views depends on how they are used. When used as an framebuffer attachment the image view is owned by the framebuffer. When used as a image/texture in a shader the ownership of the image view is the texture itself. Pull Request: https://projects.blender.org/blender/blender/pulls/108765
2023-06-08 16:07:38 +02:00
image_views_.clear();
Vulkan: Clearing Framebuffer + Scissors This PR adds support for clearing framebuffers and scissor testing. Tweaks had to be made to VKTexture to keep track of its layout on the device. Based on the actual call the layout can switch to a more optimum layout. For example during upload of a texture the texture will be converted to a transfer destination optimized layout. When reading from the texture it will be converted to a transfer source optimized layout. The order of the attachments in the framebuffer follows the next rules - When only color attachments are there the color attachments will be placed in the slot they are defined. This way it will match the ShaderCreateInfo binding location. - When a stencil/depth attachment is added it will be placed right after the color attachments. When there isn't a color attachment it will be the first attachment. Pull Request: https://projects.blender.org/blender/blender/pulls/106044
2023-03-28 11:51:32 +02:00
bool has_depth_attachment = false;
bool found_attachment = false;
Vulkan: Support for Framebuffer with Missing Attachments Wireframe mode wasn't working and viewport had flickering artifacts. Reason was that the render pass creation failed for its framebuffer as the input data was filled with garbage for attachments that were unused. Vulkan requires every attachment to be filled upto the highest used attachment slot. This PR fills missing attachments with a dummy texture. Pull Request: https://projects.blender.org/blender/blender/pulls/113141
2023-10-10 09:27:07 +02:00
const VKImageView &dummy_attachment =
VKBackend::get().device_get().dummy_color_attachment_get().image_view_get();
Vulkan: Clearing Framebuffer + Scissors This PR adds support for clearing framebuffers and scissor testing. Tweaks had to be made to VKTexture to keep track of its layout on the device. Based on the actual call the layout can switch to a more optimum layout. For example during upload of a texture the texture will be converted to a transfer destination optimized layout. When reading from the texture it will be converted to a transfer source optimized layout. The order of the attachments in the framebuffer follows the next rules - When only color attachments are there the color attachments will be placed in the slot they are defined. This way it will match the ShaderCreateInfo binding location. - When a stencil/depth attachment is added it will be placed right after the color attachments. When there isn't a color attachment it will be the first attachment. Pull Request: https://projects.blender.org/blender/blender/pulls/106044
2023-03-28 11:51:32 +02:00
int depth_location = -1;
for (int type = GPU_FB_MAX_ATTACHMENT - 1; type >= 0; type--) {
GPUAttachment &attachment = attachments_[type];
if (attachment.tex == nullptr && !found_attachment) {
/* Move the depth texture to the next binding point after all color textures. The binding
* location of the color textures should be kept in sync between ShaderCreateInfos and the
* framebuffer attachments. The depth buffer should be the last slot. */
depth_location = max_ii(type - GPU_FB_COLOR_ATTACHMENT0, 0);
continue;
}
found_attachment |= attachment.tex != nullptr;
/* Keep the first attachment to the first color attachment, or to the depth buffer when there
* is no color attachment. */
if (attachment.tex != nullptr &&
(first_attachment == GPU_FB_MAX_ATTACHMENT || type >= GPU_FB_COLOR_ATTACHMENT0))
{
first_attachment = static_cast<GPUAttachmentType>(type);
}
int attachment_location = type >= GPU_FB_COLOR_ATTACHMENT0 ? type - GPU_FB_COLOR_ATTACHMENT0 :
depth_location;
Vulkan: Support for Framebuffer with Missing Attachments Wireframe mode wasn't working and viewport had flickering artifacts. Reason was that the render pass creation failed for its framebuffer as the input data was filled with garbage for attachments that were unused. Vulkan requires every attachment to be filled upto the highest used attachment slot. This PR fills missing attachments with a dummy texture. Pull Request: https://projects.blender.org/blender/blender/pulls/113141
2023-10-10 09:27:07 +02:00
const bool is_depth_attachment = ELEM(
type, GPU_FB_DEPTH_ATTACHMENT, GPU_FB_DEPTH_STENCIL_ATTACHMENT);
Vulkan: Clearing Framebuffer + Scissors This PR adds support for clearing framebuffers and scissor testing. Tweaks had to be made to VKTexture to keep track of its layout on the device. Based on the actual call the layout can switch to a more optimum layout. For example during upload of a texture the texture will be converted to a transfer destination optimized layout. When reading from the texture it will be converted to a transfer source optimized layout. The order of the attachments in the framebuffer follows the next rules - When only color attachments are there the color attachments will be placed in the slot they are defined. This way it will match the ShaderCreateInfo binding location. - When a stencil/depth attachment is added it will be placed right after the color attachments. When there isn't a color attachment it will be the first attachment. Pull Request: https://projects.blender.org/blender/blender/pulls/106044
2023-03-28 11:51:32 +02:00
if (attachment.tex) {
Vulkan: Support for Framebuffer with Missing Attachments Wireframe mode wasn't working and viewport had flickering artifacts. Reason was that the render pass creation failed for its framebuffer as the input data was filled with garbage for attachments that were unused. Vulkan requires every attachment to be filled upto the highest used attachment slot. This PR fills missing attachments with a dummy texture. Pull Request: https://projects.blender.org/blender/blender/pulls/113141
2023-10-10 09:27:07 +02:00
BLI_assert_msg(!is_depth_attachment || !has_depth_attachment,
"There can only be one depth/stencil attachment.");
has_depth_attachment |= is_depth_attachment;
Cleanup: spelling in comments
2023-04-05 14:38:26 +10:00
/* Ensure texture is allocated to ensure the image view. */
Vulkan: Clearing Framebuffer + Scissors This PR adds support for clearing framebuffers and scissor testing. Tweaks had to be made to VKTexture to keep track of its layout on the device. Based on the actual call the layout can switch to a more optimum layout. For example during upload of a texture the texture will be converted to a transfer destination optimized layout. When reading from the texture it will be converted to a transfer source optimized layout. The order of the attachments in the framebuffer follows the next rules - When only color attachments are there the color attachments will be placed in the slot they are defined. This way it will match the ShaderCreateInfo binding location. - When a stencil/depth attachment is added it will be placed right after the color attachments. When there isn't a color attachment it will be the first attachment. Pull Request: https://projects.blender.org/blender/blender/pulls/106044
2023-03-28 11:51:32 +02:00
VKTexture &texture = *static_cast<VKTexture *>(unwrap(attachment.tex));
Vulkan: Add Support for sRGB Framebuffer Enablement Allow binding of framebuffers without sRGB to linear transform. `GPU_framebuffer_bind_no_srgb`. This Patch removes color transform artifacts in node, image and sequence editor. When the framebuffer is an srgb framebuffer and it is bound without the transformation, the SRGB textures are bound as UNORM variants. As framebuffer, render pass and subpass recreation is ensured by `VKCommandBuffer` we don't need to mark the framebuffer dirty at this time. Later on we can optimize this by adding a state changed detection for framebuffers and render passes. Pull Request: https://projects.blender.org/blender/blender/pulls/113838
2023-10-19 14:41:18 +02:00
const bool use_stencil = false;
const bool use_srgb = srgb_ && enabled_srgb_;
Vulkan: Use Correct Image Aspects Depending on the usage of an image/image view different image aspect requirements need to be used. When changing the layout of an image all aspects needs to be included. When using it as a sampler or framebuffer attachment only one aspect can be used. This change also remove duplicated code when creating image views. Pull Request: https://projects.blender.org/blender/blender/pulls/111349
2023-08-22 11:00:43 +02:00
image_views_.append(VKImageView(texture,
eImageViewUsage::Attachment,
IndexRange(max_ii(attachment.layer, 0), 1),
IndexRange(attachment.mip, 1),
Vulkan: Add Support for sRGB Framebuffer Enablement Allow binding of framebuffers without sRGB to linear transform. `GPU_framebuffer_bind_no_srgb`. This Patch removes color transform artifacts in node, image and sequence editor. When the framebuffer is an srgb framebuffer and it is bound without the transformation, the SRGB textures are bound as UNORM variants. As framebuffer, render pass and subpass recreation is ensured by `VKCommandBuffer` we don't need to mark the framebuffer dirty at this time. Later on we can optimize this by adding a state changed detection for framebuffers and render passes. Pull Request: https://projects.blender.org/blender/blender/pulls/113838
2023-10-19 14:41:18 +02:00
use_stencil,
use_srgb,
Vulkan: Use Correct Image Aspects Depending on the usage of an image/image view different image aspect requirements need to be used. When changing the layout of an image all aspects needs to be included. When using it as a sampler or framebuffer attachment only one aspect can be used. This change also remove duplicated code when creating image views. Pull Request: https://projects.blender.org/blender/blender/pulls/111349
2023-08-22 11:00:43 +02:00
name_));
Vulkan: Add Support for sRGB Framebuffer Enablement Allow binding of framebuffers without sRGB to linear transform. `GPU_framebuffer_bind_no_srgb`. This Patch removes color transform artifacts in node, image and sequence editor. When the framebuffer is an srgb framebuffer and it is bound without the transformation, the SRGB textures are bound as UNORM variants. As framebuffer, render pass and subpass recreation is ensured by `VKCommandBuffer` we don't need to mark the framebuffer dirty at this time. Later on we can optimize this by adding a state changed detection for framebuffers and render passes. Pull Request: https://projects.blender.org/blender/blender/pulls/113838
2023-10-19 14:41:18 +02:00
const VKImageView &image_view = image_views_.last();
image_views[attachment_location] = image_view.vk_handle();
Vulkan: Clearing Framebuffer + Scissors This PR adds support for clearing framebuffers and scissor testing. Tweaks had to be made to VKTexture to keep track of its layout on the device. Based on the actual call the layout can switch to a more optimum layout. For example during upload of a texture the texture will be converted to a transfer destination optimized layout. When reading from the texture it will be converted to a transfer source optimized layout. The order of the attachments in the framebuffer follows the next rules - When only color attachments are there the color attachments will be placed in the slot they are defined. This way it will match the ShaderCreateInfo binding location. - When a stencil/depth attachment is added it will be placed right after the color attachments. When there isn't a color attachment it will be the first attachment. Pull Request: https://projects.blender.org/blender/blender/pulls/106044
2023-03-28 11:51:32 +02:00
VkAttachmentDescription &attachment_description =
attachment_descriptions[attachment_location];
attachment_description.flags = 0;
Vulkan: Add Support for sRGB Framebuffer Enablement Allow binding of framebuffers without sRGB to linear transform. `GPU_framebuffer_bind_no_srgb`. This Patch removes color transform artifacts in node, image and sequence editor. When the framebuffer is an srgb framebuffer and it is bound without the transformation, the SRGB textures are bound as UNORM variants. As framebuffer, render pass and subpass recreation is ensured by `VKCommandBuffer` we don't need to mark the framebuffer dirty at this time. Later on we can optimize this by adding a state changed detection for framebuffers and render passes. Pull Request: https://projects.blender.org/blender/blender/pulls/113838
2023-10-19 14:41:18 +02:00
attachment_description.format = image_view.vk_format();
Vulkan: Clearing Framebuffer + Scissors This PR adds support for clearing framebuffers and scissor testing. Tweaks had to be made to VKTexture to keep track of its layout on the device. Based on the actual call the layout can switch to a more optimum layout. For example during upload of a texture the texture will be converted to a transfer destination optimized layout. When reading from the texture it will be converted to a transfer source optimized layout. The order of the attachments in the framebuffer follows the next rules - When only color attachments are there the color attachments will be placed in the slot they are defined. This way it will match the ShaderCreateInfo binding location. - When a stencil/depth attachment is added it will be placed right after the color attachments. When there isn't a color attachment it will be the first attachment. Pull Request: https://projects.blender.org/blender/blender/pulls/106044
2023-03-28 11:51:32 +02:00
attachment_description.samples = VK_SAMPLE_COUNT_1_BIT;
Vulkan: Frame Buffer Flipping Vulkan coordinate system is flipped compared to OpenGL. This PR flips the drawing when drawn to the on-screen frame buffer. Offscreen frame buffers are still drawn upside down. The flipping is done by making the viewport of the framebuffer negative. Pull Request: https://projects.blender.org/blender/blender/pulls/107743
2023-05-09 09:22:26 +02:00
attachment_description.loadOp = VK_ATTACHMENT_LOAD_OP_LOAD;
Vulkan: Clearing Framebuffer + Scissors This PR adds support for clearing framebuffers and scissor testing. Tweaks had to be made to VKTexture to keep track of its layout on the device. Based on the actual call the layout can switch to a more optimum layout. For example during upload of a texture the texture will be converted to a transfer destination optimized layout. When reading from the texture it will be converted to a transfer source optimized layout. The order of the attachments in the framebuffer follows the next rules - When only color attachments are there the color attachments will be placed in the slot they are defined. This way it will match the ShaderCreateInfo binding location. - When a stencil/depth attachment is added it will be placed right after the color attachments. When there isn't a color attachment it will be the first attachment. Pull Request: https://projects.blender.org/blender/blender/pulls/106044
2023-03-28 11:51:32 +02:00
attachment_description.storeOp = VK_ATTACHMENT_STORE_OP_STORE;
Vulkan: Image Views The ownership of image views depends on how they are used. When used as an framebuffer attachment the image view is owned by the framebuffer. When used as a image/texture in a shader the ownership of the image view is the texture itself. Pull Request: https://projects.blender.org/blender/blender/pulls/108765
2023-06-08 16:07:38 +02:00
attachment_description.stencilLoadOp = VK_ATTACHMENT_LOAD_OP_LOAD;
attachment_description.stencilStoreOp = VK_ATTACHMENT_STORE_OP_STORE;
attachment_description.initialLayout = texture.current_layout_get();
attachment_description.finalLayout = texture.current_layout_get();
Vulkan: Clearing Framebuffer + Scissors This PR adds support for clearing framebuffers and scissor testing. Tweaks had to be made to VKTexture to keep track of its layout on the device. Based on the actual call the layout can switch to a more optimum layout. For example during upload of a texture the texture will be converted to a transfer destination optimized layout. When reading from the texture it will be converted to a transfer source optimized layout. The order of the attachments in the framebuffer follows the next rules - When only color attachments are there the color attachments will be placed in the slot they are defined. This way it will match the ShaderCreateInfo binding location. - When a stencil/depth attachment is added it will be placed right after the color attachments. When there isn't a color attachment it will be the first attachment. Pull Request: https://projects.blender.org/blender/blender/pulls/106044
2023-03-28 11:51:32 +02:00
/* Create the attachment reference. */
VkAttachmentReference &attachment_reference = attachment_references[attachment_location];
attachment_reference.attachment = attachment_location;
attachment_reference.layout = is_depth_attachment ?
VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL :
VK_IMAGE_LAYOUT_GENERAL;
}
Vulkan: Support for Framebuffer with Missing Attachments Wireframe mode wasn't working and viewport had flickering artifacts. Reason was that the render pass creation failed for its framebuffer as the input data was filled with garbage for attachments that were unused. Vulkan requires every attachment to be filled upto the highest used attachment slot. This PR fills missing attachments with a dummy texture. Pull Request: https://projects.blender.org/blender/blender/pulls/113141
2023-10-10 09:27:07 +02:00
else if (!is_depth_attachment) {
image_views[attachment_location] = dummy_attachment.vk_handle();
VkAttachmentDescription &attachment_description =
attachment_descriptions[attachment_location];
attachment_description.flags = 0;
attachment_description.format = VK_FORMAT_R32_SFLOAT;
attachment_description.samples = VK_SAMPLE_COUNT_1_BIT;
attachment_description.loadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE;
attachment_description.storeOp = VK_ATTACHMENT_STORE_OP_DONT_CARE;
attachment_description.stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE;
attachment_description.stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE;
attachment_description.initialLayout = VK_IMAGE_LAYOUT_GENERAL;
attachment_description.finalLayout = VK_IMAGE_LAYOUT_GENERAL;
VkAttachmentReference &attachment_reference = attachment_references[attachment_location];
attachment_reference.attachment = VK_ATTACHMENT_UNUSED;
attachment_reference.layout = VK_IMAGE_LAYOUT_UNDEFINED;
}
Vulkan: Clearing Framebuffer + Scissors This PR adds support for clearing framebuffers and scissor testing. Tweaks had to be made to VKTexture to keep track of its layout on the device. Based on the actual call the layout can switch to a more optimum layout. For example during upload of a texture the texture will be converted to a transfer destination optimized layout. When reading from the texture it will be converted to a transfer source optimized layout. The order of the attachments in the framebuffer follows the next rules - When only color attachments are there the color attachments will be placed in the slot they are defined. This way it will match the ShaderCreateInfo binding location. - When a stencil/depth attachment is added it will be placed right after the color attachments. When there isn't a color attachment it will be the first attachment. Pull Request: https://projects.blender.org/blender/blender/pulls/106044
2023-03-28 11:51:32 +02:00
}
/* Update the size, viewport & scissor based on the first attachment. */
if (first_attachment != GPU_FB_MAX_ATTACHMENT) {
GPUAttachment &attachment = attachments_[first_attachment];
BLI_assert(attachment.tex);
int size[3];
GPU_texture_get_mipmap_size(attachment.tex, attachment.mip, size);
size_set(size[0], size[1]);
}
else {
Cleanup: spelling in comments, odd comment block spacing
2023-06-02 10:16:16 +10:00
/* A frame-buffer should at least be 1 by 1. */
Vulkan: Frame Buffer Flipping Vulkan coordinate system is flipped compared to OpenGL. This PR flips the drawing when drawn to the on-screen frame buffer. Offscreen frame buffers are still drawn upside down. The flipping is done by making the viewport of the framebuffer negative. Pull Request: https://projects.blender.org/blender/blender/pulls/107743
2023-05-09 09:22:26 +02:00
this->size_set(1, 1);
Vulkan: Clearing Framebuffer + Scissors This PR adds support for clearing framebuffers and scissor testing. Tweaks had to be made to VKTexture to keep track of its layout on the device. Based on the actual call the layout can switch to a more optimum layout. For example during upload of a texture the texture will be converted to a transfer destination optimized layout. When reading from the texture it will be converted to a transfer source optimized layout. The order of the attachments in the framebuffer follows the next rules - When only color attachments are there the color attachments will be placed in the slot they are defined. This way it will match the ShaderCreateInfo binding location. - When a stencil/depth attachment is added it will be placed right after the color attachments. When there isn't a color attachment it will be the first attachment. Pull Request: https://projects.blender.org/blender/blender/pulls/106044
2023-03-28 11:51:32 +02:00
}
viewport_reset();
scissor_reset();
/* Create render pass. */
const int attachment_len = has_depth_attachment ? depth_location + 1 : depth_location;
const int color_attachment_len = depth_location;
VkSubpassDescription subpass = {};
subpass.pipelineBindPoint = VK_PIPELINE_BIND_POINT_GRAPHICS;
subpass.colorAttachmentCount = color_attachment_len;
Vulkan: Fix Compilation Error on Windows Platforms. Automatically conversion not working. Replacing `begin` with `data` would solve this issue. Pull Request: https://projects.blender.org/blender/blender/pulls/106539
2023-04-04 12:13:01 +02:00
subpass.pColorAttachments = attachment_references.data();
Vulkan: Clearing Framebuffer + Scissors This PR adds support for clearing framebuffers and scissor testing. Tweaks had to be made to VKTexture to keep track of its layout on the device. Based on the actual call the layout can switch to a more optimum layout. For example during upload of a texture the texture will be converted to a transfer destination optimized layout. When reading from the texture it will be converted to a transfer source optimized layout. The order of the attachments in the framebuffer follows the next rules - When only color attachments are there the color attachments will be placed in the slot they are defined. This way it will match the ShaderCreateInfo binding location. - When a stencil/depth attachment is added it will be placed right after the color attachments. When there isn't a color attachment it will be the first attachment. Pull Request: https://projects.blender.org/blender/blender/pulls/106044
2023-03-28 11:51:32 +02:00
if (has_depth_attachment) {
subpass.pDepthStencilAttachment = &attachment_references[depth_location];
}
VkRenderPassCreateInfo render_pass_info = {};
render_pass_info.sType = VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO;
render_pass_info.attachmentCount = attachment_len;
render_pass_info.pAttachments = attachment_descriptions.data();
render_pass_info.subpassCount = 1;
render_pass_info.pSubpasses = &subpass;
Vulkan: Share Device Between Contexts Previous GHOST_ContextVK would create a logical device for each context. Blender uses multiple contexts at the same time and wasn't able to share resources between them as the logical device where different. This patch will create a single logical device and share them between multiple contexts. This allows sharing memory/shaders between contexts and make sure that all memory allocations are freed from the device it was allocated from. Some allocations in Blender are freed when there isn't a context, this was failing in the previous implementation. We didn't noticed it before as we didn't test multiple contexts. This patch also moves device specific data structures from VKContext to VKDevice like the descriptor pools, debug layers etc. Pull Request: https://projects.blender.org/blender/blender/pulls/107606
2023-05-04 10:06:48 +02:00
const VKDevice &device = VKBackend::get().device_get();
Vulkan: Clearing Framebuffer + Scissors This PR adds support for clearing framebuffers and scissor testing. Tweaks had to be made to VKTexture to keep track of its layout on the device. Based on the actual call the layout can switch to a more optimum layout. For example during upload of a texture the texture will be converted to a transfer destination optimized layout. When reading from the texture it will be converted to a transfer source optimized layout. The order of the attachments in the framebuffer follows the next rules - When only color attachments are there the color attachments will be placed in the slot they are defined. This way it will match the ShaderCreateInfo binding location. - When a stencil/depth attachment is added it will be placed right after the color attachments. When there isn't a color attachment it will be the first attachment. Pull Request: https://projects.blender.org/blender/blender/pulls/106044
2023-03-28 11:51:32 +02:00
vkCreateRenderPass(
Vulkan: Share Device Between Contexts Previous GHOST_ContextVK would create a logical device for each context. Blender uses multiple contexts at the same time and wasn't able to share resources between them as the logical device where different. This patch will create a single logical device and share them between multiple contexts. This allows sharing memory/shaders between contexts and make sure that all memory allocations are freed from the device it was allocated from. Some allocations in Blender are freed when there isn't a context, this was failing in the previous implementation. We didn't noticed it before as we didn't test multiple contexts. This patch also moves device specific data structures from VKContext to VKDevice like the descriptor pools, debug layers etc. Pull Request: https://projects.blender.org/blender/blender/pulls/107606
2023-05-04 10:06:48 +02:00
device.device_get(), &render_pass_info, vk_allocation_callbacks, &vk_render_pass_);
Vulkan: Clearing Framebuffer + Scissors This PR adds support for clearing framebuffers and scissor testing. Tweaks had to be made to VKTexture to keep track of its layout on the device. Based on the actual call the layout can switch to a more optimum layout. For example during upload of a texture the texture will be converted to a transfer destination optimized layout. When reading from the texture it will be converted to a transfer source optimized layout. The order of the attachments in the framebuffer follows the next rules - When only color attachments are there the color attachments will be placed in the slot they are defined. This way it will match the ShaderCreateInfo binding location. - When a stencil/depth attachment is added it will be placed right after the color attachments. When there isn't a color attachment it will be the first attachment. Pull Request: https://projects.blender.org/blender/blender/pulls/106044
2023-03-28 11:51:32 +02:00
Cleanup: spelling in comments
2023-04-05 14:38:26 +10:00
/* We might want to split frame-buffer and render pass. */
Vulkan: Clearing Framebuffer + Scissors This PR adds support for clearing framebuffers and scissor testing. Tweaks had to be made to VKTexture to keep track of its layout on the device. Based on the actual call the layout can switch to a more optimum layout. For example during upload of a texture the texture will be converted to a transfer destination optimized layout. When reading from the texture it will be converted to a transfer source optimized layout. The order of the attachments in the framebuffer follows the next rules - When only color attachments are there the color attachments will be placed in the slot they are defined. This way it will match the ShaderCreateInfo binding location. - When a stencil/depth attachment is added it will be placed right after the color attachments. When there isn't a color attachment it will be the first attachment. Pull Request: https://projects.blender.org/blender/blender/pulls/106044
2023-03-28 11:51:32 +02:00
VkFramebufferCreateInfo framebuffer_create_info = {};
framebuffer_create_info.sType = VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO;
framebuffer_create_info.renderPass = vk_render_pass_;
framebuffer_create_info.attachmentCount = attachment_len;
Vulkan: Fix Compilation Error on Windows Platforms. Automatically conversion not working. Replacing `begin` with `data` would solve this issue. Pull Request: https://projects.blender.org/blender/blender/pulls/106539
2023-04-04 12:13:01 +02:00
framebuffer_create_info.pAttachments = image_views.data();
Vulkan: Clearing Framebuffer + Scissors This PR adds support for clearing framebuffers and scissor testing. Tweaks had to be made to VKTexture to keep track of its layout on the device. Based on the actual call the layout can switch to a more optimum layout. For example during upload of a texture the texture will be converted to a transfer destination optimized layout. When reading from the texture it will be converted to a transfer source optimized layout. The order of the attachments in the framebuffer follows the next rules - When only color attachments are there the color attachments will be placed in the slot they are defined. This way it will match the ShaderCreateInfo binding location. - When a stencil/depth attachment is added it will be placed right after the color attachments. When there isn't a color attachment it will be the first attachment. Pull Request: https://projects.blender.org/blender/blender/pulls/106044
2023-03-28 11:51:32 +02:00
framebuffer_create_info.width = width_;
framebuffer_create_info.height = height_;
framebuffer_create_info.layers = 1;
vkCreateFramebuffer(
Vulkan: Share Device Between Contexts Previous GHOST_ContextVK would create a logical device for each context. Blender uses multiple contexts at the same time and wasn't able to share resources between them as the logical device where different. This patch will create a single logical device and share them between multiple contexts. This allows sharing memory/shaders between contexts and make sure that all memory allocations are freed from the device it was allocated from. Some allocations in Blender are freed when there isn't a context, this was failing in the previous implementation. We didn't noticed it before as we didn't test multiple contexts. This patch also moves device specific data structures from VKContext to VKDevice like the descriptor pools, debug layers etc. Pull Request: https://projects.blender.org/blender/blender/pulls/107606
2023-05-04 10:06:48 +02:00
device.device_get(), &framebuffer_create_info, vk_allocation_callbacks, &vk_framebuffer_);
Vulkan: Clearing Framebuffer + Scissors This PR adds support for clearing framebuffers and scissor testing. Tweaks had to be made to VKTexture to keep track of its layout on the device. Based on the actual call the layout can switch to a more optimum layout. For example during upload of a texture the texture will be converted to a transfer destination optimized layout. When reading from the texture it will be converted to a transfer source optimized layout. The order of the attachments in the framebuffer follows the next rules - When only color attachments are there the color attachments will be placed in the slot they are defined. This way it will match the ShaderCreateInfo binding location. - When a stencil/depth attachment is added it will be placed right after the color attachments. When there isn't a color attachment it will be the first attachment. Pull Request: https://projects.blender.org/blender/blender/pulls/106044
2023-03-28 11:51:32 +02:00
}
void VKFrameBuffer::render_pass_free()
{
if (vk_render_pass_ == VK_NULL_HANDLE) {
return;
}
Vulkan: Postpone Resource Destruction Resources can still be in use inside the vulkan command queue, when they are destroyed. Especially as Vulkan doesn't allow resetting bindings to nothing. This PR will collect the resources that needs to be destroyed inside the VKDevice and actually destroy the resources when on frame end. The resources currently include: * VkBuffer * VkImage * VkImageView * VkFramebuffer * VkRenderPass Pull Request: https://projects.blender.org/blender/blender/pulls/112514
2023-09-18 13:42:17 +02:00
VKDevice &device = VKBackend::get().device_get();
Vulkan: Initial Graphics Pipeline Initial graphic pipeline targeting. The goal of this PR is to have an initial graphics pipeline with missing features. It should help identifying areas that requires engineering. Current state is that developers of the GPU module can help with the many smaller pieces that needs to be engineered in order to get it working. It is not intended for users or developers from other modules, but your welcome to learn and give feedback on the code and engineering part. We do expect that large parts of the code still needs to be re-engineered into a more future-proof implementation. **Some highlights**: - In Vulkan the state is kept in the pipeline. Therefore the state is tracked per pipeline. In the near future this could be used as a cache. More research is needed against the default pipeline cache that vulkan already provides. - This PR is based on the work that Kazashi Yoshioka already did. And include work from him in the next areas - Vertex attributes - Vertex data conversions - Pipeline state - Immediate support working. - This PR modifies the VKCommandBuffer to keep track of the framebuffer and its binding state(render pass). Some Vulkan commands require no render pass to be active, other require a render pass. As the order of our commands on API level can not be separated this PR introduces a state engine to keep track of the current state and desired state. This is a temporary solution, the final solution will be proposed when we have a pixel on the screen. At that time I expect that we can design a command encoder that supports all the cases we need. **Notices**: - This branch works on NVIDIA GPUs and has been validated on a Linux system. AMD is known not to work (stalls) and Intel GPUs have not been tested at all. Windows might work but hasn't been validated yet. - The graphics pipeline is implemented with pixels in mind, not with performance. Currently when a draw call is scheduled it is flushed and waited until it is finished drawing, before other draw calls can be scheduled. We expected the performance to be worse that it actually is, but we expect huge performance gains in the future. - Any advanced drawing (that is used by the image editor, compositor or 3d viewport) isn't implemented and might crash when used. - Using multiple windows or resizing of window isn't supported and will stall the system. Pull Request: https://projects.blender.org/blender/blender/pulls/106224
2023-05-11 13:01:56 +02:00
if (device.is_initialized()) {
Vulkan: Postpone Resource Destruction Resources can still be in use inside the vulkan command queue, when they are destroyed. Especially as Vulkan doesn't allow resetting bindings to nothing. This PR will collect the resources that needs to be destroyed inside the VKDevice and actually destroy the resources when on frame end. The resources currently include: * VkBuffer * VkImage * VkImageView * VkFramebuffer * VkRenderPass Pull Request: https://projects.blender.org/blender/blender/pulls/112514
2023-09-18 13:42:17 +02:00
device.discard_render_pass(vk_render_pass_);
device.discard_frame_buffer(vk_framebuffer_);
Vulkan: Initial Graphics Pipeline Initial graphic pipeline targeting. The goal of this PR is to have an initial graphics pipeline with missing features. It should help identifying areas that requires engineering. Current state is that developers of the GPU module can help with the many smaller pieces that needs to be engineered in order to get it working. It is not intended for users or developers from other modules, but your welcome to learn and give feedback on the code and engineering part. We do expect that large parts of the code still needs to be re-engineered into a more future-proof implementation. **Some highlights**: - In Vulkan the state is kept in the pipeline. Therefore the state is tracked per pipeline. In the near future this could be used as a cache. More research is needed against the default pipeline cache that vulkan already provides. - This PR is based on the work that Kazashi Yoshioka already did. And include work from him in the next areas - Vertex attributes - Vertex data conversions - Pipeline state - Immediate support working. - This PR modifies the VKCommandBuffer to keep track of the framebuffer and its binding state(render pass). Some Vulkan commands require no render pass to be active, other require a render pass. As the order of our commands on API level can not be separated this PR introduces a state engine to keep track of the current state and desired state. This is a temporary solution, the final solution will be proposed when we have a pixel on the screen. At that time I expect that we can design a command encoder that supports all the cases we need. **Notices**: - This branch works on NVIDIA GPUs and has been validated on a Linux system. AMD is known not to work (stalls) and Intel GPUs have not been tested at all. Windows might work but hasn't been validated yet. - The graphics pipeline is implemented with pixels in mind, not with performance. Currently when a draw call is scheduled it is flushed and waited until it is finished drawing, before other draw calls can be scheduled. We expected the performance to be worse that it actually is, but we expect huge performance gains in the future. - Any advanced drawing (that is used by the image editor, compositor or 3d viewport) isn't implemented and might crash when used. - Using multiple windows or resizing of window isn't supported and will stall the system. Pull Request: https://projects.blender.org/blender/blender/pulls/106224
2023-05-11 13:01:56 +02:00
}
Vulkan: Image Views The ownership of image views depends on how they are used. When used as an framebuffer attachment the image view is owned by the framebuffer. When used as a image/texture in a shader the ownership of the image view is the texture itself. Pull Request: https://projects.blender.org/blender/blender/pulls/108765
2023-06-08 16:07:38 +02:00
image_views_.clear();
Vulkan: Clearing Framebuffer + Scissors This PR adds support for clearing framebuffers and scissor testing. Tweaks had to be made to VKTexture to keep track of its layout on the device. Based on the actual call the layout can switch to a more optimum layout. For example during upload of a texture the texture will be converted to a transfer destination optimized layout. When reading from the texture it will be converted to a transfer source optimized layout. The order of the attachments in the framebuffer follows the next rules - When only color attachments are there the color attachments will be placed in the slot they are defined. This way it will match the ShaderCreateInfo binding location. - When a stencil/depth attachment is added it will be placed right after the color attachments. When there isn't a color attachment it will be the first attachment. Pull Request: https://projects.blender.org/blender/blender/pulls/106044
2023-03-28 11:51:32 +02:00
vk_render_pass_ = VK_NULL_HANDLE;
vk_framebuffer_ = VK_NULL_HANDLE;
}
Vulkan: Rewrite GHOST_ContextVK This is a rewrite of GHOST_ContextVK to align with Metal backend as described in #111389 - solution 3 with the adaptation that GHOST is still responsible for presenting the swap chain image and a post callback is still needed in case the swapchain is recreated. This PR also includes some smaller improvements in stability. Technical documentation: https://developer.blender.org/docs/eevee_and_viewport/gpu/vulkan/swap_chain/ * Renderpasses and framebuffers are not owned anymore by GHOST_ContextVK * VKFramebuffer doesn't contain a swap chain image. * Swapchain images can only be used as a blit destination or present source. Not as an attachment. * GHOST_ContextVK::swapBuffers would call a callback with the image the GPU module needs to blit the results to. * Clearing of depth/stencil attachments when no depth write state is set. * Enable VK_KHR_maintenance4 to relax the stage interface mapping. * Removes most vulkan validation warnings/errors. * Detection of frame buffer changes that needs to be applied before performing a command requiring render pass (draw/clear attachment) **Benefits** * Late retrieval of a swap chain image results in better overall performance as Blender doesn't need to wait until the image is presented on the screen. * Easier API and clearer state (transitions) * More control over Image layouts and command buffer states. (Better alignment with Vulkan API) Pull Request: https://projects.blender.org/blender/blender/pulls/111473
2023-08-29 15:05:08 +02:00
void VKFrameBuffer::color_attachment_layout_ensure(VKContext &context,
int color_attachment,
VkImageLayout requested_layout)
{
VKTexture *color_texture = unwrap(unwrap(color_tex(color_attachment)));
if (color_texture == nullptr) {
return;
}
if (color_texture->current_layout_get() == requested_layout) {
return;
}
color_texture->layout_ensure(context, requested_layout);
dirty_attachments_ = true;
}
void VKFrameBuffer::depth_attachment_layout_ensure(VKContext &context,
VkImageLayout requested_layout)
{
VKTexture *depth_texture = unwrap(unwrap(depth_tex()));
if (depth_texture == nullptr) {
return;
}
if (depth_texture->current_layout_get() == requested_layout) {
return;
}
depth_texture->layout_ensure(context, requested_layout);
dirty_attachments_ = true;
}
void VKFrameBuffer::update_size()
{
if (!dirty_attachments_) {
return;
}
for (int i = 0; i < GPU_FB_MAX_ATTACHMENT; i++) {
GPUAttachment &attachment = attachments_[i];
if (attachment.tex) {
int size[3];
GPU_texture_get_mipmap_size(attachment.tex, attachment.mip, size);
size_set(size[0], size[1]);
return;
}
}
size_set(1, 1);
}
Vulkan: Add Support for sRGB Framebuffer Enablement Allow binding of framebuffers without sRGB to linear transform. `GPU_framebuffer_bind_no_srgb`. This Patch removes color transform artifacts in node, image and sequence editor. When the framebuffer is an srgb framebuffer and it is bound without the transformation, the SRGB textures are bound as UNORM variants. As framebuffer, render pass and subpass recreation is ensured by `VKCommandBuffer` we don't need to mark the framebuffer dirty at this time. Later on we can optimize this by adding a state changed detection for framebuffers and render passes. Pull Request: https://projects.blender.org/blender/blender/pulls/113838
2023-10-19 14:41:18 +02:00
void VKFrameBuffer::update_srgb()
{
for (int i : IndexRange(GPU_FB_MAX_COLOR_ATTACHMENT)) {
VKTexture *texture = unwrap(unwrap(color_tex(i)));
if (texture) {
srgb_ = (texture->format_flag_get() & GPU_FORMAT_SRGB) != 0;
return;
}
}
}
Vulkan: Support for Framebuffer with Missing Attachments Wireframe mode wasn't working and viewport had flickering artifacts. Reason was that the render pass creation failed for its framebuffer as the input data was filled with garbage for attachments that were unused. Vulkan requires every attachment to be filled upto the highest used attachment slot. This PR fills missing attachments with a dummy texture. Pull Request: https://projects.blender.org/blender/blender/pulls/113141
2023-10-10 09:27:07 +02:00
int VKFrameBuffer::color_attachments_resource_size() const
{
int size = 0;
for (int color_slot : IndexRange(GPU_FB_MAX_COLOR_ATTACHMENT)) {
if (color_tex(color_slot) != nullptr) {
size = max_ii(color_slot + 1, size);
}
}
return size;
}
Vulkan: Clearing Framebuffer + Scissors This PR adds support for clearing framebuffers and scissor testing. Tweaks had to be made to VKTexture to keep track of its layout on the device. Based on the actual call the layout can switch to a more optimum layout. For example during upload of a texture the texture will be converted to a transfer destination optimized layout. When reading from the texture it will be converted to a transfer source optimized layout. The order of the attachments in the framebuffer follows the next rules - When only color attachments are there the color attachments will be placed in the slot they are defined. This way it will match the ShaderCreateInfo binding location. - When a stencil/depth attachment is added it will be placed right after the color attachments. When there isn't a color attachment it will be the first attachment. Pull Request: https://projects.blender.org/blender/blender/pulls/106044
2023-03-28 11:51:32 +02:00
/** \} */
Cleanup: trailing space
2023-01-31 15:49:04 +11:00
} // namespace blender::gpu
Reference in New Issue Copy Permalink