blob: 0b720912a3ffc0a01930d7dc5a0c8e304f5a4231 [file] [log] [blame]
Jamie Madill9e54b5a2016-05-25 12:57:39 -04001//
2// Copyright 2016 The ANGLE Project Authors. All rights reserved.
3// Use of this source code is governed by a BSD-style license that can be
4// found in the LICENSE file.
5//
6// FramebufferVk.cpp:
7// Implements the class methods for FramebufferVk.
8//
9
10#include "libANGLE/renderer/vulkan/FramebufferVk.h"
11
Jamie Madill7b57b9d2017-01-13 09:33:38 -050012#include <vulkan/vulkan.h>
Jamie Madill231c7f52017-04-26 13:45:37 -040013#include <array>
Jamie Madill7b57b9d2017-01-13 09:33:38 -050014
Jamie Madill9e54b5a2016-05-25 12:57:39 -040015#include "common/debug.h"
Jamie Madillc564c072017-06-01 12:45:42 -040016#include "libANGLE/Context.h"
17#include "libANGLE/Display.h"
Jamie Madill7b57b9d2017-01-13 09:33:38 -050018#include "libANGLE/formatutils.h"
19#include "libANGLE/renderer/renderer_utils.h"
Jamie Madill1f46bc12018-02-20 16:09:43 -050020#include "libANGLE/renderer/vulkan/CommandGraph.h"
Jamie Madill7b57b9d2017-01-13 09:33:38 -050021#include "libANGLE/renderer/vulkan/ContextVk.h"
Jamie Madill5deea722017-02-16 10:44:46 -050022#include "libANGLE/renderer/vulkan/DisplayVk.h"
Jamie Madill7b57b9d2017-01-13 09:33:38 -050023#include "libANGLE/renderer/vulkan/RenderTargetVk.h"
24#include "libANGLE/renderer/vulkan/RendererVk.h"
25#include "libANGLE/renderer/vulkan/SurfaceVk.h"
Jamie Madill3c424b42018-01-19 12:35:09 -050026#include "libANGLE/renderer/vulkan/vk_format_utils.h"
Jamie Madill9e54b5a2016-05-25 12:57:39 -040027
28namespace rx
29{
30
Jamie Madill7b57b9d2017-01-13 09:33:38 -050031namespace
32{
Luc Ferron534b00d2018-05-18 08:16:53 -040033constexpr size_t kMinReadPixelsBufferSize = 128000;
34
Jamie Madill66546be2018-03-08 09:47:20 -050035const gl::InternalFormat &GetReadAttachmentInfo(const gl::Context *context,
36 RenderTargetVk *renderTarget)
Jamie Madill7b57b9d2017-01-13 09:33:38 -050037{
Jamie Madillbc543422018-03-30 10:43:19 -040038 GLenum implFormat =
Jamie Madillbcf467f2018-05-23 09:46:00 -040039 renderTarget->getImageFormat().textureFormat().fboImplementationInternalFormat;
Jamie Madill66546be2018-03-08 09:47:20 -050040 return gl::GetSizedInternalFormatInfo(implFormat);
Jamie Madill7b57b9d2017-01-13 09:33:38 -050041}
Luc Ferron26581112018-06-21 09:43:08 -040042
Jamie Madilld754eb52018-07-19 14:55:03 -040043bool ClipToRenderTarget(const gl::Rectangle &area,
44 RenderTargetVk *renderTarget,
45 gl::Rectangle *rectOut)
46{
47 const gl::Extents &renderTargetExtents = renderTarget->getImageExtents();
48 gl::Rectangle renderTargetRect(0, 0, renderTargetExtents.width, renderTargetExtents.height);
49 return ClipRectangle(area, renderTargetRect, rectOut);
50}
51
Luc Ferron26581112018-06-21 09:43:08 -040052bool HasSrcAndDstBlitProperties(const VkPhysicalDevice &physicalDevice,
53 RenderTargetVk *srcRenderTarget,
54 RenderTargetVk *dstRenderTarget)
55{
56 VkFormatProperties drawImageProperties;
57 vk::GetFormatProperties(physicalDevice, srcRenderTarget->getImageFormat().vkTextureFormat,
58 &drawImageProperties);
59
60 VkFormatProperties readImageProperties;
61 vk::GetFormatProperties(physicalDevice, dstRenderTarget->getImageFormat().vkTextureFormat,
62 &readImageProperties);
63
64 // Verifies if the draw and read images have the necessary prerequisites for blitting.
65 return (IsMaskFlagSet<VkFormatFeatureFlags>(drawImageProperties.optimalTilingFeatures,
66 VK_FORMAT_FEATURE_BLIT_DST_BIT) &&
67 IsMaskFlagSet<VkFormatFeatureFlags>(readImageProperties.optimalTilingFeatures,
68 VK_FORMAT_FEATURE_BLIT_SRC_BIT));
69}
Jamie Madillb436aac2018-07-18 17:23:48 -040070
71// Special rules apply to VkBufferImageCopy with depth/stencil. The components are tightly packed
72// into a depth or stencil section of the destination buffer. See the spec:
73// https://www.khronos.org/registry/vulkan/specs/1.1-extensions/man/html/VkBufferImageCopy.html
74const angle::Format &GetDepthStencilImageToBufferFormat(const angle::Format &imageFormat,
75 VkImageAspectFlagBits copyAspect)
76{
77 if (copyAspect == VK_IMAGE_ASPECT_STENCIL_BIT)
78 {
79 ASSERT(imageFormat.id == angle::FormatID::D24_UNORM_S8_UINT ||
80 imageFormat.id == angle::FormatID::D32_FLOAT_S8X24_UINT ||
81 imageFormat.id == angle::FormatID::S8_UINT);
82 return angle::Format::Get(angle::FormatID::S8_UINT);
83 }
84
85 ASSERT(copyAspect == VK_IMAGE_ASPECT_DEPTH_BIT);
86
87 switch (imageFormat.id)
88 {
89 case angle::FormatID::D16_UNORM:
90 return imageFormat;
91 case angle::FormatID::D24_UNORM_X8_UINT:
92 return imageFormat;
93 case angle::FormatID::D24_UNORM_S8_UINT:
94 return angle::Format::Get(angle::FormatID::D24_UNORM_X8_UINT);
95 case angle::FormatID::D32_FLOAT:
96 return imageFormat;
97 case angle::FormatID::D32_FLOAT_S8X24_UINT:
98 return angle::Format::Get(angle::FormatID::D32_FLOAT);
99 default:
100 UNREACHABLE();
101 return imageFormat;
102 }
103}
Jamie Madillbcf467f2018-05-23 09:46:00 -0400104} // anonymous namespace
Jamie Madill7b57b9d2017-01-13 09:33:38 -0500105
106// static
Jamie Madill639bc902018-07-18 17:08:27 -0400107FramebufferVk *FramebufferVk::CreateUserFBO(RendererVk *renderer, const gl::FramebufferState &state)
Jamie Madill7b57b9d2017-01-13 09:33:38 -0500108{
Jamie Madill639bc902018-07-18 17:08:27 -0400109 return new FramebufferVk(renderer, state, nullptr);
Jamie Madill7b57b9d2017-01-13 09:33:38 -0500110}
111
112// static
Jamie Madill639bc902018-07-18 17:08:27 -0400113FramebufferVk *FramebufferVk::CreateDefaultFBO(RendererVk *renderer,
114 const gl::FramebufferState &state,
Jamie Madill7b57b9d2017-01-13 09:33:38 -0500115 WindowSurfaceVk *backbuffer)
116{
Jamie Madill639bc902018-07-18 17:08:27 -0400117 return new FramebufferVk(renderer, state, backbuffer);
Jamie Madill7b57b9d2017-01-13 09:33:38 -0500118}
119
Jamie Madill639bc902018-07-18 17:08:27 -0400120FramebufferVk::FramebufferVk(RendererVk *renderer,
121 const gl::FramebufferState &state,
122 WindowSurfaceVk *backbuffer)
Jamie Madill9aef3672018-04-27 11:45:06 -0400123 : FramebufferImpl(state),
124 mBackbuffer(backbuffer),
Jamie Madill9aef3672018-04-27 11:45:06 -0400125 mActiveColorComponents(0),
Jamie Madilld754eb52018-07-19 14:55:03 -0400126 mReadPixelBuffer(VK_BUFFER_USAGE_TRANSFER_DST_BIT, kMinReadPixelsBufferSize),
Luc Ferron1617e692018-07-11 11:08:19 -0400127 mBlitPixelBuffer(VK_BUFFER_USAGE_TRANSFER_SRC_BIT, kMinReadPixelsBufferSize)
Jamie Madill7b57b9d2017-01-13 09:33:38 -0500128{
Jamie Madill639bc902018-07-18 17:08:27 -0400129 mBlitPixelBuffer.init(1, renderer);
Jamie Madilld754eb52018-07-19 14:55:03 -0400130 mReadPixelBuffer.init(1, renderer);
Jamie Madill7b57b9d2017-01-13 09:33:38 -0500131}
132
Jamie Madill58675012018-05-22 14:54:07 -0400133FramebufferVk::~FramebufferVk() = default;
Jamie Madill9e54b5a2016-05-25 12:57:39 -0400134
Jamie Madillc564c072017-06-01 12:45:42 -0400135void FramebufferVk::destroy(const gl::Context *context)
Jamie Madill5deea722017-02-16 10:44:46 -0500136{
Luc Ferron534b00d2018-05-18 08:16:53 -0400137 ContextVk *contextVk = vk::GetImpl(context);
138 RendererVk *renderer = contextVk->getRenderer();
Jamie Madillc57ee252018-05-30 19:53:48 -0400139 renderer->releaseObject(getStoredQueueSerial(), &mFramebuffer);
Luc Ferron534b00d2018-05-18 08:16:53 -0400140
Jamie Madilld754eb52018-07-19 14:55:03 -0400141 mReadPixelBuffer.destroy(contextVk->getDevice());
Luc Ferron1617e692018-07-11 11:08:19 -0400142 mBlitPixelBuffer.destroy(contextVk->getDevice());
Jamie Madill5deea722017-02-16 10:44:46 -0500143}
144
Jamie Madill4928b7c2017-06-20 12:57:39 -0400145gl::Error FramebufferVk::discard(const gl::Context *context,
146 size_t count,
147 const GLenum *attachments)
Jamie Madill9e54b5a2016-05-25 12:57:39 -0400148{
149 UNIMPLEMENTED();
Yuly Novikovc4d18aa2017-03-09 18:45:02 -0500150 return gl::InternalError();
Jamie Madill9e54b5a2016-05-25 12:57:39 -0400151}
152
Jamie Madill4928b7c2017-06-20 12:57:39 -0400153gl::Error FramebufferVk::invalidate(const gl::Context *context,
154 size_t count,
155 const GLenum *attachments)
Jamie Madill9e54b5a2016-05-25 12:57:39 -0400156{
157 UNIMPLEMENTED();
Yuly Novikovc4d18aa2017-03-09 18:45:02 -0500158 return gl::InternalError();
Jamie Madill9e54b5a2016-05-25 12:57:39 -0400159}
160
Jamie Madill4928b7c2017-06-20 12:57:39 -0400161gl::Error FramebufferVk::invalidateSub(const gl::Context *context,
162 size_t count,
Jamie Madill9e54b5a2016-05-25 12:57:39 -0400163 const GLenum *attachments,
164 const gl::Rectangle &area)
165{
166 UNIMPLEMENTED();
Yuly Novikovc4d18aa2017-03-09 18:45:02 -0500167 return gl::InternalError();
Jamie Madill9e54b5a2016-05-25 12:57:39 -0400168}
169
Jamie Madillc564c072017-06-01 12:45:42 -0400170gl::Error FramebufferVk::clear(const gl::Context *context, GLbitfield mask)
Jamie Madill9e54b5a2016-05-25 12:57:39 -0400171{
Jamie Madill0cec82a2018-03-14 09:21:07 -0400172 ContextVk *contextVk = vk::GetImpl(context);
Jamie Madill7b57b9d2017-01-13 09:33:38 -0500173
Jamie Madill0cec82a2018-03-14 09:21:07 -0400174 // This command buffer is only started once.
Jamie Madill50cf2be2018-06-15 09:46:57 -0400175 vk::CommandBuffer *commandBuffer = nullptr;
Jamie Madill7b57b9d2017-01-13 09:33:38 -0500176
Jamie Madill0cec82a2018-03-14 09:21:07 -0400177 const gl::FramebufferAttachment *depthAttachment = mState.getDepthAttachment();
178 bool clearDepth = (depthAttachment && (mask & GL_DEPTH_BUFFER_BIT) != 0);
179 ASSERT(!clearDepth || depthAttachment->isAttached());
180
181 const gl::FramebufferAttachment *stencilAttachment = mState.getStencilAttachment();
182 bool clearStencil = (stencilAttachment && (mask & GL_STENCIL_BUFFER_BIT) != 0);
183 ASSERT(!clearStencil || stencilAttachment->isAttached());
184
Luc Ferrona8af3a62018-03-29 14:44:24 -0400185 bool clearColor = IsMaskFlagSet(static_cast<int>(mask), GL_COLOR_BUFFER_BIT);
186
Luc Ferron8836f632018-04-05 07:26:53 -0400187 const gl::FramebufferAttachment *depthStencilAttachment = mState.getDepthStencilAttachment();
Jamie Madilld47044a2018-04-27 11:45:03 -0400188 const gl::State &glState = context->getGLState();
Luc Ferron8836f632018-04-05 07:26:53 -0400189
Jamie Madill9aef3672018-04-27 11:45:06 -0400190 // The most costly clear mode is when we need to mask out specific color channels. This can
191 // only be done with a draw call. The scissor region however can easily be integrated with
192 // this method. Similarly for depth/stencil clear.
193 VkColorComponentFlags colorMaskFlags = contextVk->getClearColorMask();
194 if (clearColor && (mActiveColorComponents & colorMaskFlags) != mActiveColorComponents)
195 {
Jamie Madill21061022018-07-12 23:56:30 -0400196 ANGLE_TRY(clearWithDraw(contextVk, colorMaskFlags));
Jamie Madill78cd9402018-05-10 16:49:58 -0400197
198 // Stencil clears must be handled separately. The only way to write out a stencil value from
199 // a fragment shader in Vulkan is with VK_EXT_shader_stencil_export. Support for this
200 // extension is sparse. Hence, we call into the RenderPass clear path. We similarly clear
201 // depth to keep the code simple, but depth clears could be combined with the masked color
202 // clears as an optimization.
203
204 if (clearDepth || clearStencil)
205 {
206 // Masked stencil clears are currently not implemented.
207 // TODO(jmadill): Masked stencil clear. http://anglebug.com/2540
208 ANGLE_TRY(clearWithClearAttachments(contextVk, false, clearDepth, clearStencil));
209 }
210 return gl::NoError();
Jamie Madill9aef3672018-04-27 11:45:06 -0400211 }
212
Luc Ferron8836f632018-04-05 07:26:53 -0400213 // If we clear the depth OR the stencil but not both, and we have a packed depth stencil
214 // attachment, we need to use clearAttachment instead of clearDepthStencil since Vulkan won't
215 // allow us to clear one or the other separately.
216 bool isSingleClearOnPackedDepthStencilAttachment =
217 depthStencilAttachment && (clearDepth != clearStencil);
Jamie Madilld47044a2018-04-27 11:45:03 -0400218 if (glState.isScissorTestEnabled() || isSingleClearOnPackedDepthStencilAttachment)
Luc Ferrona8af3a62018-03-29 14:44:24 -0400219 {
220 // With scissor test enabled, we clear very differently and we don't need to access
221 // the image inside each attachment we can just use clearCmdAttachments with our
222 // scissor region instead.
Jamie Madill78cd9402018-05-10 16:49:58 -0400223
224 // Masked stencil clears are currently not implemented.
225 // TODO(jmadill): Masked stencil clear. http://anglebug.com/2540
Jamie Madillb90779e2018-04-27 11:45:01 -0400226 ANGLE_TRY(clearWithClearAttachments(contextVk, clearColor, clearDepth, clearStencil));
Luc Ferrona8af3a62018-03-29 14:44:24 -0400227 return gl::NoError();
228 }
229
230 // Standard Depth/stencil clear without scissor.
Jamie Madill0cec82a2018-03-14 09:21:07 -0400231 if (clearDepth || clearStencil)
Jamie Madill7b57b9d2017-01-13 09:33:38 -0500232 {
Jamie Madill21061022018-07-12 23:56:30 -0400233 ANGLE_TRY(beginWriteResource(contextVk, &commandBuffer));
Jamie Madill0cec82a2018-03-14 09:21:07 -0400234
235 const VkClearDepthStencilValue &clearDepthStencilValue =
236 contextVk->getClearDepthStencilValue().depthStencil;
237
Luc Ferron26581112018-06-21 09:43:08 -0400238 RenderTargetVk *renderTarget = mRenderTargetCache.getDepthStencil();
Luc Ferron5bdf8bd2018-06-20 09:51:37 -0400239 const angle::Format &format = renderTarget->getImageFormat().textureFormat();
240 const VkImageAspectFlags aspectFlags = vk::GetDepthStencilAspectFlags(format);
241
Jamie Madille4e2d0c2018-06-22 08:25:05 -0400242 vk::ImageHelper *image = renderTarget->getImageForWrite(this);
Jamie Madillbcf467f2018-05-23 09:46:00 -0400243 image->clearDepthStencil(aspectFlags, clearDepthStencilValue, commandBuffer);
Jamie Madill7b57b9d2017-01-13 09:33:38 -0500244 }
245
Luc Ferrond3ab3072018-06-19 09:55:04 -0400246 if (!clearColor)
247 {
248 return gl::NoError();
249 }
250
Jamie Madill7b57b9d2017-01-13 09:33:38 -0500251 const auto *attachment = mState.getFirstNonNullAttachment();
252 ASSERT(attachment && attachment->isAttached());
Jamie Madill7b57b9d2017-01-13 09:33:38 -0500253
Jamie Madill0cec82a2018-03-14 09:21:07 -0400254 if (!commandBuffer)
255 {
Jamie Madill21061022018-07-12 23:56:30 -0400256 ANGLE_TRY(beginWriteResource(contextVk, &commandBuffer));
Jamie Madill0cec82a2018-03-14 09:21:07 -0400257 }
Jamie Madillefb5a5c2018-01-29 15:56:59 -0500258
Jamie Madill66546be2018-03-08 09:47:20 -0500259 // TODO(jmadill): Support gaps in RenderTargets. http://anglebug.com/2394
Jamie Madill50cf2be2018-06-15 09:46:57 -0400260 const auto &colorRenderTargets = mRenderTargetCache.getColors();
Jamie Madill9aef3672018-04-27 11:45:06 -0400261 const VkClearColorValue &clearColorValue = contextVk->getClearColorValue().color;
Jamie Madill66546be2018-03-08 09:47:20 -0500262 for (size_t colorIndex : mState.getEnabledDrawBuffers())
Jamie Madill7b57b9d2017-01-13 09:33:38 -0500263 {
Luc Ferron5fd36932018-06-19 14:55:50 -0400264 VkClearColorValue modifiedClearColorValue = clearColorValue;
Luc Ferron26581112018-06-21 09:43:08 -0400265 RenderTargetVk *colorRenderTarget = colorRenderTargets[colorIndex];
Luc Ferron5fd36932018-06-19 14:55:50 -0400266
267 // Its possible we're clearing a render target that has no alpha channel but we represent it
268 // with a texture that has one. We must not affect its alpha channel no matter what the
269 // clear value is in that case.
270 if (mEmulatedAlphaAttachmentMask[colorIndex])
271 {
272 modifiedClearColorValue.float32[3] = 1.0;
273 }
274
Jamie Madill66546be2018-03-08 09:47:20 -0500275 ASSERT(colorRenderTarget);
Jamie Madille4e2d0c2018-06-22 08:25:05 -0400276 vk::ImageHelper *image = colorRenderTarget->getImageForWrite(this);
Luc Ferronc20b9502018-05-24 09:30:17 -0400277 GLint mipLevelToClear = (attachment->type() == GL_TEXTURE) ? attachment->mipLevel() : 0;
Luc Ferron5fd36932018-06-19 14:55:50 -0400278 image->clearColor(modifiedClearColorValue, mipLevelToClear, 1, commandBuffer);
Jamie Madill7b57b9d2017-01-13 09:33:38 -0500279 }
280
Jamie Madill7b57b9d2017-01-13 09:33:38 -0500281 return gl::NoError();
Jamie Madill9e54b5a2016-05-25 12:57:39 -0400282}
283
Jamie Madillc564c072017-06-01 12:45:42 -0400284gl::Error FramebufferVk::clearBufferfv(const gl::Context *context,
Jamie Madill9e54b5a2016-05-25 12:57:39 -0400285 GLenum buffer,
286 GLint drawbuffer,
287 const GLfloat *values)
288{
289 UNIMPLEMENTED();
Yuly Novikovc4d18aa2017-03-09 18:45:02 -0500290 return gl::InternalError();
Jamie Madill9e54b5a2016-05-25 12:57:39 -0400291}
292
Jamie Madillc564c072017-06-01 12:45:42 -0400293gl::Error FramebufferVk::clearBufferuiv(const gl::Context *context,
Jamie Madill9e54b5a2016-05-25 12:57:39 -0400294 GLenum buffer,
295 GLint drawbuffer,
296 const GLuint *values)
297{
298 UNIMPLEMENTED();
Yuly Novikovc4d18aa2017-03-09 18:45:02 -0500299 return gl::InternalError();
Jamie Madill9e54b5a2016-05-25 12:57:39 -0400300}
301
Jamie Madillc564c072017-06-01 12:45:42 -0400302gl::Error FramebufferVk::clearBufferiv(const gl::Context *context,
Jamie Madill9e54b5a2016-05-25 12:57:39 -0400303 GLenum buffer,
304 GLint drawbuffer,
305 const GLint *values)
306{
307 UNIMPLEMENTED();
Yuly Novikovc4d18aa2017-03-09 18:45:02 -0500308 return gl::InternalError();
Jamie Madill9e54b5a2016-05-25 12:57:39 -0400309}
310
Jamie Madillc564c072017-06-01 12:45:42 -0400311gl::Error FramebufferVk::clearBufferfi(const gl::Context *context,
Jamie Madill9e54b5a2016-05-25 12:57:39 -0400312 GLenum buffer,
313 GLint drawbuffer,
314 GLfloat depth,
315 GLint stencil)
316{
317 UNIMPLEMENTED();
Yuly Novikovc4d18aa2017-03-09 18:45:02 -0500318 return gl::InternalError();
Jamie Madill9e54b5a2016-05-25 12:57:39 -0400319}
320
Jamie Madill4928b7c2017-06-20 12:57:39 -0400321GLenum FramebufferVk::getImplementationColorReadFormat(const gl::Context *context) const
Jamie Madill9e54b5a2016-05-25 12:57:39 -0400322{
Jamie Madill66546be2018-03-08 09:47:20 -0500323 return GetReadAttachmentInfo(context, mRenderTargetCache.getColorRead(mState)).format;
Jamie Madill9e54b5a2016-05-25 12:57:39 -0400324}
325
Jamie Madill4928b7c2017-06-20 12:57:39 -0400326GLenum FramebufferVk::getImplementationColorReadType(const gl::Context *context) const
Jamie Madill9e54b5a2016-05-25 12:57:39 -0400327{
Jamie Madill66546be2018-03-08 09:47:20 -0500328 return GetReadAttachmentInfo(context, mRenderTargetCache.getColorRead(mState)).type;
Jamie Madill9e54b5a2016-05-25 12:57:39 -0400329}
330
Jamie Madillc564c072017-06-01 12:45:42 -0400331gl::Error FramebufferVk::readPixels(const gl::Context *context,
Jamie Madill9e54b5a2016-05-25 12:57:39 -0400332 const gl::Rectangle &area,
333 GLenum format,
334 GLenum type,
Jamie Madilld4826152017-09-21 11:18:59 -0400335 void *pixels)
Jamie Madill9e54b5a2016-05-25 12:57:39 -0400336{
Luc Ferrona1c72422018-05-14 15:58:28 -0400337 // Clip read area to framebuffer.
338 const gl::Extents &fbSize = getState().getReadAttachment()->getSize();
339 const gl::Rectangle fbRect(0, 0, fbSize.width, fbSize.height);
Luc Ferronbf6dc372018-06-28 15:24:19 -0400340 ContextVk *contextVk = vk::GetImpl(context);
341 RendererVk *renderer = contextVk->getRenderer();
342
Luc Ferrona1c72422018-05-14 15:58:28 -0400343 gl::Rectangle clippedArea;
344 if (!ClipRectangle(area, fbRect, &clippedArea))
345 {
346 // nothing to read
347 return gl::NoError();
348 }
Luc Ferronbf6dc372018-06-28 15:24:19 -0400349 gl::Rectangle flippedArea = clippedArea;
Geoff Lange076a232018-07-16 15:34:05 -0400350 if (contextVk->isViewportFlipEnabledForReadFBO())
Luc Ferronbf6dc372018-06-28 15:24:19 -0400351 {
352 flippedArea.y = fbRect.height - flippedArea.y - flippedArea.height;
353 }
Luc Ferrona1c72422018-05-14 15:58:28 -0400354
Jamie Madill66546be2018-03-08 09:47:20 -0500355 const gl::State &glState = context->getGLState();
Luc Ferron534b00d2018-05-18 08:16:53 -0400356
357 vk::CommandBuffer *commandBuffer = nullptr;
Jamie Madill21061022018-07-12 23:56:30 -0400358 ANGLE_TRY(beginWriteResource(contextVk, &commandBuffer));
Jamie Madill66546be2018-03-08 09:47:20 -0500359
Luc Ferron44a3cf42018-07-09 09:40:57 -0400360 gl::PixelPackState packState(glState.getPackState());
Geoff Lange076a232018-07-16 15:34:05 -0400361 if (contextVk->isViewportFlipEnabledForReadFBO())
Luc Ferronbf6dc372018-06-28 15:24:19 -0400362 {
363 packState.reverseRowOrder = !packState.reverseRowOrder;
364 }
365
Luc Ferrona1c72422018-05-14 15:58:28 -0400366 const gl::InternalFormat &sizedFormatInfo = gl::GetInternalFormatInfo(format, type);
367
368 GLuint outputPitch = 0;
Jamie Madillca2ff382018-07-11 09:01:17 -0400369 ANGLE_TRY_CHECKED_MATH(sizedFormatInfo.computeRowPitch(type, area.width, packState.alignment,
370 packState.rowLength, &outputPitch));
Luc Ferrona1c72422018-05-14 15:58:28 -0400371 GLuint outputSkipBytes = 0;
Jamie Madillca2ff382018-07-11 09:01:17 -0400372 ANGLE_TRY_CHECKED_MATH(
373 sizedFormatInfo.computeSkipBytes(type, outputPitch, 0, packState, false, &outputSkipBytes));
Luc Ferrona1c72422018-05-14 15:58:28 -0400374
375 outputSkipBytes += (clippedArea.x - area.x) * sizedFormatInfo.pixelBytes +
376 (clippedArea.y - area.y) * outputPitch;
Luc Ferron60284222018-03-20 16:01:44 -0400377
Jamie Madilldb9c69e2018-07-18 17:23:47 -0400378 const angle::Format &angleFormat = GetFormatFromFormatType(format, type);
379
380 PackPixelsParams params(flippedArea, angleFormat, outputPitch, packState,
381 glState.getTargetBuffer(gl::BufferBinding::PixelPack), 0);
Jamie Madill7b57b9d2017-01-13 09:33:38 -0500382
Jamie Madill21061022018-07-12 23:56:30 -0400383 ANGLE_TRY(readPixelsImpl(contextVk, flippedArea, params, VK_IMAGE_ASPECT_COLOR_BIT,
Luc Ferron1617e692018-07-11 11:08:19 -0400384 getColorReadRenderTarget(),
Rafael Cintron05a449a2018-06-20 18:08:04 -0700385 static_cast<uint8_t *>(pixels) + outputSkipBytes));
Jamie Madilld754eb52018-07-19 14:55:03 -0400386 mReadPixelBuffer.releaseRetainedBuffers(renderer);
Luc Ferron534b00d2018-05-18 08:16:53 -0400387 return gl::NoError();
Luc Ferron018709f2018-05-10 13:53:11 -0400388}
Jamie Madill7b57b9d2017-01-13 09:33:38 -0500389
Luc Ferron26581112018-06-21 09:43:08 -0400390RenderTargetVk *FramebufferVk::getDepthStencilRenderTarget() const
391{
392 return mRenderTargetCache.getDepthStencil();
393}
394
Jamie Madilld754eb52018-07-19 14:55:03 -0400395void FramebufferVk::blitWithCopy(vk::CommandBuffer *commandBuffer,
396 const gl::Rectangle &copyArea,
397 RenderTargetVk *readRenderTarget,
398 RenderTargetVk *drawRenderTarget,
399 bool blitDepthBuffer,
400 bool blitStencilBuffer)
Luc Ferronbe30c4f2018-06-21 09:43:08 -0400401{
Luc Ferronbe30c4f2018-06-21 09:43:08 -0400402 VkFlags aspectFlags =
403 vk::GetDepthStencilAspectFlags(readRenderTarget->getImageFormat().textureFormat());
404 vk::ImageHelper *readImage = readRenderTarget->getImageForRead(
Luc Ferron1617e692018-07-11 11:08:19 -0400405 this, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, commandBuffer);
Luc Ferronbe30c4f2018-06-21 09:43:08 -0400406 vk::ImageHelper *writeImage = drawRenderTarget->getImageForWrite(this);
407 // Requirement of the copyImageToBuffer, the dst image must be in
408 // VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL layout.
409 writeImage->changeLayoutWithStages(aspectFlags, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
410 VK_PIPELINE_STAGE_ALL_COMMANDS_BIT,
411 VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, commandBuffer);
Luc Ferron1617e692018-07-11 11:08:19 -0400412
413 VkImageAspectFlags aspectMask =
414 vk::GetDepthStencilAspectFlagsForCopy(blitDepthBuffer, blitStencilBuffer);
Luc Ferronbe30c4f2018-06-21 09:43:08 -0400415 vk::ImageHelper::Copy(readImage, writeImage, gl::Offset(), gl::Offset(),
Jamie Madilld754eb52018-07-19 14:55:03 -0400416 gl::Extents(copyArea.width, copyArea.height, 1), aspectMask,
417 commandBuffer);
Luc Ferronbe30c4f2018-06-21 09:43:08 -0400418}
419
Jamie Madill58675012018-05-22 14:54:07 -0400420RenderTargetVk *FramebufferVk::getColorReadRenderTarget() const
Luc Ferron018709f2018-05-10 13:53:11 -0400421{
422 RenderTargetVk *renderTarget = mRenderTargetCache.getColorRead(mState);
Jamie Madillbcf467f2018-05-23 09:46:00 -0400423 ASSERT(renderTarget && renderTarget->getImage().valid());
Luc Ferron018709f2018-05-10 13:53:11 -0400424 return renderTarget;
Jamie Madill9e54b5a2016-05-25 12:57:39 -0400425}
426
Jamie Madill21061022018-07-12 23:56:30 -0400427angle::Result FramebufferVk::blitWithReadback(ContextVk *contextVk,
Jamie Madilld754eb52018-07-19 14:55:03 -0400428 const gl::Rectangle &copyArea,
Jamie Madillb436aac2018-07-18 17:23:48 -0400429 VkImageAspectFlagBits aspect,
Jamie Madill21061022018-07-12 23:56:30 -0400430 vk::CommandBuffer *commandBuffer,
431 RenderTargetVk *readRenderTarget,
432 RenderTargetVk *drawRenderTarget)
Luc Ferron1617e692018-07-11 11:08:19 -0400433{
Jamie Madillb436aac2018-07-18 17:23:48 -0400434 RendererVk *renderer = contextVk->getRenderer();
435 const angle::Format &readFormat = readRenderTarget->getImageFormat().textureFormat();
Luc Ferron1617e692018-07-11 11:08:19 -0400436
Jamie Madillb436aac2018-07-18 17:23:48 -0400437 ASSERT(aspect == VK_IMAGE_ASPECT_DEPTH_BIT || aspect == VK_IMAGE_ASPECT_STENCIL_BIT);
Luc Ferron1617e692018-07-11 11:08:19 -0400438
Jamie Madillb436aac2018-07-18 17:23:48 -0400439 // This path is only currently used for y-flipping depth/stencil blits.
Luc Ferron1617e692018-07-11 11:08:19 -0400440 PackPixelsParams packPixelsParams;
441 packPixelsParams.pack.alignment = 1;
442 packPixelsParams.pack.reverseRowOrder = true;
Jamie Madilld754eb52018-07-19 14:55:03 -0400443 packPixelsParams.area.width = copyArea.width;
Jamie Madillb436aac2018-07-18 17:23:48 -0400444 packPixelsParams.area.height = copyArea.height;
Jamie Madilld754eb52018-07-19 14:55:03 -0400445 packPixelsParams.area.x = copyArea.x;
446 packPixelsParams.area.y = copyArea.y;
Luc Ferron1617e692018-07-11 11:08:19 -0400447
Jamie Madillb436aac2018-07-18 17:23:48 -0400448 // Read back depth values into the destination buffer.
449 const angle::Format &copyFormat = GetDepthStencilImageToBufferFormat(readFormat, aspect);
450 packPixelsParams.destFormat = &copyFormat;
451 packPixelsParams.outputPitch = copyFormat.pixelBytes * copyArea.width;
Luc Ferron1617e692018-07-11 11:08:19 -0400452
Jamie Madillb436aac2018-07-18 17:23:48 -0400453 // Allocate a space in the destination buffer to write to.
454 size_t blitAllocationSize = copyFormat.pixelBytes * copyArea.width * copyArea.height;
455 uint8_t *destPtr = nullptr;
456 VkBuffer destBufferHandle = VK_NULL_HANDLE;
Jamie Madill4c310832018-08-29 13:43:17 -0400457 VkDeviceSize destOffset = 0;
Jamie Madillb436aac2018-07-18 17:23:48 -0400458 ANGLE_TRY(mBlitPixelBuffer.allocate(contextVk, blitAllocationSize, &destPtr, &destBufferHandle,
459 &destOffset, nullptr));
Luc Ferron1617e692018-07-11 11:08:19 -0400460
Jamie Madillb436aac2018-07-18 17:23:48 -0400461 ANGLE_TRY(
462 readPixelsImpl(contextVk, copyArea, packPixelsParams, aspect, readRenderTarget, destPtr));
Luc Ferron1617e692018-07-11 11:08:19 -0400463
Jamie Madillb436aac2018-07-18 17:23:48 -0400464 VkBufferImageCopy copyRegion;
465 copyRegion.bufferOffset = destOffset;
466 copyRegion.bufferImageHeight = copyArea.height;
467 copyRegion.bufferRowLength = copyArea.width;
468 copyRegion.imageExtent.width = copyArea.width;
469 copyRegion.imageExtent.height = copyArea.height;
470 copyRegion.imageExtent.depth = 1;
471 copyRegion.imageSubresource.mipLevel = 0;
472 copyRegion.imageSubresource.aspectMask = aspect;
473 copyRegion.imageSubresource.baseArrayLayer = 0;
474 copyRegion.imageSubresource.layerCount = 1;
475 copyRegion.imageOffset.x = copyArea.x;
476 copyRegion.imageOffset.y = copyArea.y;
477 copyRegion.imageOffset.z = 0;
478
Jamie Madill21061022018-07-12 23:56:30 -0400479 ANGLE_TRY(mBlitPixelBuffer.flush(contextVk));
Luc Ferron1617e692018-07-11 11:08:19 -0400480
481 // Reinitialize the commandBuffer after a read pixels because it calls
482 // renderer->finish which makes command buffers obsolete.
Jamie Madill21061022018-07-12 23:56:30 -0400483 ANGLE_TRY(beginWriteResource(contextVk, &commandBuffer));
Luc Ferron1617e692018-07-11 11:08:19 -0400484
485 // We read the bytes of the image in a buffer, now we have to copy them into the
486 // destination target.
487 vk::ImageHelper *imageForWrite = drawRenderTarget->getImageForWrite(this);
488
489 imageForWrite->changeLayoutWithStages(
490 imageForWrite->getAspectFlags(), VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
491 VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, commandBuffer);
492
Jamie Madillb436aac2018-07-18 17:23:48 -0400493 commandBuffer->copyBufferToImage(destBufferHandle, imageForWrite->getImage(),
494 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1, &copyRegion);
Luc Ferron1617e692018-07-11 11:08:19 -0400495
496 mBlitPixelBuffer.releaseRetainedBuffers(renderer);
Jamie Madillb436aac2018-07-18 17:23:48 -0400497
Jamie Madill21061022018-07-12 23:56:30 -0400498 return angle::Result::Continue();
Luc Ferron1617e692018-07-11 11:08:19 -0400499}
500
Jamie Madillc564c072017-06-01 12:45:42 -0400501gl::Error FramebufferVk::blit(const gl::Context *context,
Jamie Madill9e54b5a2016-05-25 12:57:39 -0400502 const gl::Rectangle &sourceArea,
503 const gl::Rectangle &destArea,
504 GLbitfield mask,
505 GLenum filter)
506{
Luc Ferron26581112018-06-21 09:43:08 -0400507 ContextVk *contextVk = vk::GetImpl(context);
508 RendererVk *renderer = contextVk->getRenderer();
509
510 const gl::State &glState = context->getGLState();
511 const gl::Framebuffer *sourceFramebuffer = glState.getReadFramebuffer();
Jamie Madillba365932018-07-18 17:23:46 -0400512 bool blitColorBuffer = (mask & GL_COLOR_BUFFER_BIT) != 0;
513 bool blitDepthBuffer = (mask & GL_DEPTH_BUFFER_BIT) != 0;
514 bool blitStencilBuffer = (mask & GL_STENCIL_BUFFER_BIT) != 0;
Luc Ferron26581112018-06-21 09:43:08 -0400515
516 vk::CommandBuffer *commandBuffer = nullptr;
Jamie Madill21061022018-07-12 23:56:30 -0400517 ANGLE_TRY(beginWriteResource(contextVk, &commandBuffer));
Luc Ferron26581112018-06-21 09:43:08 -0400518 FramebufferVk *sourceFramebufferVk = vk::GetImpl(sourceFramebuffer);
Luc Ferron82eda932018-07-09 15:10:22 -0400519 bool flipSource = contextVk->isViewportFlipEnabledForReadFBO();
520 bool flipDest = contextVk->isViewportFlipEnabledForDrawFBO();
521
Jamie Madilld754eb52018-07-19 14:55:03 -0400522 gl::Rectangle readRect = sourceArea;
523 gl::Rectangle drawRect = destArea;
524
525 if (glState.isScissorTestEnabled())
526 {
527 const gl::Rectangle scissorRect = glState.getScissor();
528 if (!ClipRectangle(sourceArea, scissorRect, &readRect))
529 {
530 return gl::NoError();
531 }
532
533 if (!ClipRectangle(destArea, scissorRect, &drawRect))
534 {
535 return gl::NoError();
536 }
537 }
538
539 // After cropping for the scissor, we also want to crop for the size of the buffers.
540
Luc Ferron26581112018-06-21 09:43:08 -0400541 if (blitColorBuffer)
542 {
543 RenderTargetVk *readRenderTarget = sourceFramebufferVk->getColorReadRenderTarget();
544
Jamie Madilld754eb52018-07-19 14:55:03 -0400545 gl::Rectangle readRenderTargetRect;
546 if (!ClipToRenderTarget(readRect, readRenderTarget, &readRenderTargetRect))
547 {
548 return gl::NoError();
549 }
550
Luc Ferron26581112018-06-21 09:43:08 -0400551 for (size_t colorAttachment : mState.getEnabledDrawBuffers())
552 {
553 RenderTargetVk *drawRenderTarget = mRenderTargetCache.getColors()[colorAttachment];
554 ASSERT(drawRenderTarget);
555 ASSERT(HasSrcAndDstBlitProperties(renderer->getPhysicalDevice(), readRenderTarget,
556 drawRenderTarget));
Jamie Madilld754eb52018-07-19 14:55:03 -0400557
558 gl::Rectangle drawRenderTargetRect;
559 if (!ClipToRenderTarget(drawRect, drawRenderTarget, &drawRenderTargetRect))
560 {
561 return gl::NoError();
562 }
563
564 blitWithCommand(commandBuffer, readRenderTargetRect, drawRenderTargetRect,
565 readRenderTarget, drawRenderTarget, filter, true, false, false,
566 flipSource, flipDest);
Luc Ferron26581112018-06-21 09:43:08 -0400567 }
568 }
569
570 if (blitDepthBuffer || blitStencilBuffer)
571 {
572 RenderTargetVk *readRenderTarget = sourceFramebufferVk->getDepthStencilRenderTarget();
573 ASSERT(readRenderTarget);
574
Jamie Madilld754eb52018-07-19 14:55:03 -0400575 gl::Rectangle readRenderTargetRect;
576 if (!ClipToRenderTarget(readRect, readRenderTarget, &readRenderTargetRect))
577 {
578 return gl::NoError();
579 }
580
Luc Ferron26581112018-06-21 09:43:08 -0400581 RenderTargetVk *drawRenderTarget = mRenderTargetCache.getDepthStencil();
Jamie Madilld754eb52018-07-19 14:55:03 -0400582 ASSERT(drawRenderTarget);
583
584 gl::Rectangle drawRenderTargetRect;
585 if (!ClipToRenderTarget(drawRect, drawRenderTarget, &drawRenderTargetRect))
586 {
587 return gl::NoError();
588 }
589
590 ASSERT(readRenderTargetRect == drawRenderTargetRect);
591 ASSERT(filter == GL_NEAREST);
Luc Ferron26581112018-06-21 09:43:08 -0400592
593 if (HasSrcAndDstBlitProperties(renderer->getPhysicalDevice(), readRenderTarget,
594 drawRenderTarget))
595 {
Jamie Madilld754eb52018-07-19 14:55:03 -0400596 blitWithCommand(commandBuffer, readRenderTargetRect, drawRenderTargetRect,
597 readRenderTarget, drawRenderTarget, filter, false, blitDepthBuffer,
598 blitStencilBuffer, flipSource, flipDest);
Luc Ferron26581112018-06-21 09:43:08 -0400599 }
600 else
601 {
Luc Ferron1617e692018-07-11 11:08:19 -0400602 if (flipSource || flipDest)
603 {
Jamie Madillb436aac2018-07-18 17:23:48 -0400604 if (blitDepthBuffer)
605 {
606 ANGLE_TRY(blitWithReadback(contextVk, readRenderTargetRect,
607 VK_IMAGE_ASPECT_DEPTH_BIT, commandBuffer,
608 readRenderTarget, drawRenderTarget));
609 }
610 if (blitStencilBuffer)
611 {
612 ANGLE_TRY(blitWithReadback(contextVk, readRenderTargetRect,
613 VK_IMAGE_ASPECT_STENCIL_BIT, commandBuffer,
614 readRenderTarget, drawRenderTarget));
615 }
Luc Ferron1617e692018-07-11 11:08:19 -0400616 }
617 else
618 {
Jamie Madilld754eb52018-07-19 14:55:03 -0400619 blitWithCopy(commandBuffer, readRenderTargetRect, readRenderTarget,
620 drawRenderTarget, blitDepthBuffer, blitStencilBuffer);
Luc Ferron1617e692018-07-11 11:08:19 -0400621 }
Luc Ferron26581112018-06-21 09:43:08 -0400622 }
623 }
624
625 return gl::NoError();
626}
627
Jamie Madilld754eb52018-07-19 14:55:03 -0400628void FramebufferVk::blitWithCommand(vk::CommandBuffer *commandBuffer,
629 const gl::Rectangle &readRectIn,
630 const gl::Rectangle &drawRectIn,
631 RenderTargetVk *readRenderTarget,
632 RenderTargetVk *drawRenderTarget,
633 GLenum filter,
634 bool colorBlit,
635 bool depthBlit,
636 bool stencilBlit,
637 bool flipSource,
638 bool flipDest)
Luc Ferron26581112018-06-21 09:43:08 -0400639{
640 // Since blitRenderbufferRect is called for each render buffer that needs to be blitted,
641 // it should never be the case that both color and depth/stencil need to be blitted at
642 // at the same time.
643 ASSERT(colorBlit != (depthBlit || stencilBlit));
644
Luc Ferron26581112018-06-21 09:43:08 -0400645 const vk::Format &readImageFormat = readRenderTarget->getImageFormat();
646 VkImageAspectFlags aspectMask =
647 colorBlit ? VK_IMAGE_ASPECT_COLOR_BIT
648 : vk::GetDepthStencilAspectFlags(readImageFormat.textureFormat());
649 vk::ImageHelper *srcImage = readRenderTarget->getImageForRead(
Luc Ferron1617e692018-07-11 11:08:19 -0400650 this, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, commandBuffer);
Luc Ferron26581112018-06-21 09:43:08 -0400651
Jamie Madilld754eb52018-07-19 14:55:03 -0400652 const gl::Extents sourceFrameBufferExtents = readRenderTarget->getImageExtents();
653 gl::Rectangle readRect = readRectIn;
654
Luc Ferron82eda932018-07-09 15:10:22 -0400655 if (flipSource)
656 {
Jamie Madilld754eb52018-07-19 14:55:03 -0400657 readRect.y = sourceFrameBufferExtents.height - readRect.y - readRect.height;
Luc Ferron82eda932018-07-09 15:10:22 -0400658 }
659
Jamie Madillba365932018-07-18 17:23:46 -0400660 VkImageBlit blit = {};
661 blit.srcOffsets[0] = {readRect.x0(), flipSource ? readRect.y1() : readRect.y0(), 0};
662 blit.srcOffsets[1] = {readRect.x1(), flipSource ? readRect.y0() : readRect.y1(), 1};
663 blit.srcSubresource.aspectMask = aspectMask;
664 blit.srcSubresource.mipLevel = 0;
Luc Ferron26581112018-06-21 09:43:08 -0400665 blit.srcSubresource.baseArrayLayer = 0;
666 blit.srcSubresource.layerCount = 1;
667 blit.dstSubresource.aspectMask = aspectMask;
668 blit.dstSubresource.mipLevel = 0;
669 blit.dstSubresource.baseArrayLayer = 0;
670 blit.dstSubresource.layerCount = 1;
671
672 const gl::Extents &drawFrameBufferExtents = drawRenderTarget->getImageExtents();
Jamie Madilld754eb52018-07-19 14:55:03 -0400673 gl::Rectangle drawRect = drawRectIn;
Luc Ferron26581112018-06-21 09:43:08 -0400674
Luc Ferron82eda932018-07-09 15:10:22 -0400675 if (flipDest)
676 {
Jamie Madilld754eb52018-07-19 14:55:03 -0400677 drawRect.y = drawFrameBufferExtents.height - drawRect.y - drawRect.height;
Luc Ferron82eda932018-07-09 15:10:22 -0400678 }
679
Jamie Madilld754eb52018-07-19 14:55:03 -0400680 blit.dstOffsets[0] = {drawRect.x0(), flipDest ? drawRect.y1() : drawRect.y0(), 0};
681 blit.dstOffsets[1] = {drawRect.x1(), flipDest ? drawRect.y0() : drawRect.y1(), 1};
Luc Ferron26581112018-06-21 09:43:08 -0400682
683 vk::ImageHelper *dstImage = drawRenderTarget->getImageForWrite(this);
684
685 // Requirement of the copyImageToBuffer, the dst image must be in
686 // VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL layout.
687 dstImage->changeLayoutWithStages(aspectMask, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
688 VK_PIPELINE_STAGE_ALL_COMMANDS_BIT,
689 VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, commandBuffer);
690
691 commandBuffer->blitImage(srcImage->getImage(), VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
692 dstImage->getImage(), VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1, &blit,
693 gl_vk::GetFilter(filter));
Jamie Madill9e54b5a2016-05-25 12:57:39 -0400694}
695
Kenneth Russellce8602a2017-10-03 18:23:08 -0700696bool FramebufferVk::checkStatus(const gl::Context *context) const
Jamie Madill9e54b5a2016-05-25 12:57:39 -0400697{
Luc Ferron5bdf8bd2018-06-20 09:51:37 -0400698 // if we have both a depth and stencil buffer, they must refer to the same object
699 // since we only support packed_depth_stencil and not separate depth and stencil
700 if (mState.hasSeparateDepthAndStencilAttachments())
701 {
702 return false;
703 }
704
Jamie Madillb79e7bb2017-10-24 13:55:50 -0400705 return true;
Jamie Madill9e54b5a2016-05-25 12:57:39 -0400706}
707
Jamie Madill19fa1c62018-03-08 09:47:21 -0500708gl::Error FramebufferVk::syncState(const gl::Context *context,
709 const gl::Framebuffer::DirtyBits &dirtyBits)
Jamie Madill9e54b5a2016-05-25 12:57:39 -0400710{
Jamie Madille1f3ad42017-10-28 23:00:42 -0400711 ContextVk *contextVk = vk::GetImpl(context);
Jamie Madill7bd16662017-10-28 19:40:50 -0400712 RendererVk *renderer = contextVk->getRenderer();
Jamie Madilldd43e6c2017-03-24 14:18:49 -0400713
714 ASSERT(dirtyBits.any());
Jamie Madill57d9cbb2018-04-27 11:45:04 -0400715 for (size_t dirtyBit : dirtyBits)
716 {
717 switch (dirtyBit)
718 {
719 case gl::Framebuffer::DIRTY_BIT_DEPTH_ATTACHMENT:
720 case gl::Framebuffer::DIRTY_BIT_STENCIL_ATTACHMENT:
721 ANGLE_TRY(mRenderTargetCache.updateDepthStencilRenderTarget(context, mState));
722 break;
723 case gl::Framebuffer::DIRTY_BIT_DRAW_BUFFERS:
724 case gl::Framebuffer::DIRTY_BIT_READ_BUFFER:
725 case gl::Framebuffer::DIRTY_BIT_DEFAULT_WIDTH:
726 case gl::Framebuffer::DIRTY_BIT_DEFAULT_HEIGHT:
727 case gl::Framebuffer::DIRTY_BIT_DEFAULT_SAMPLES:
728 case gl::Framebuffer::DIRTY_BIT_DEFAULT_FIXED_SAMPLE_LOCATIONS:
729 break;
730 default:
731 {
732 ASSERT(gl::Framebuffer::DIRTY_BIT_COLOR_ATTACHMENT_0 == 0 &&
733 dirtyBit < gl::Framebuffer::DIRTY_BIT_COLOR_ATTACHMENT_MAX);
734 size_t colorIndex =
735 static_cast<size_t>(dirtyBit - gl::Framebuffer::DIRTY_BIT_COLOR_ATTACHMENT_0);
736 ANGLE_TRY(mRenderTargetCache.updateColorRenderTarget(context, mState, colorIndex));
Jamie Madill9aef3672018-04-27 11:45:06 -0400737
738 // Update cached masks for masked clears.
739 RenderTargetVk *renderTarget = mRenderTargetCache.getColors()[colorIndex];
740 if (renderTarget)
741 {
Luc Ferron5fd36932018-06-19 14:55:50 -0400742 const angle::Format &emulatedFormat =
743 renderTarget->getImageFormat().textureFormat();
744 updateActiveColorMasks(
745 colorIndex, emulatedFormat.redBits > 0, emulatedFormat.greenBits > 0,
746 emulatedFormat.blueBits > 0, emulatedFormat.alphaBits > 0);
747
Luc Ferron5fd36932018-06-19 14:55:50 -0400748 const angle::Format &sourceFormat =
749 renderTarget->getImageFormat().angleFormat();
750 mEmulatedAlphaAttachmentMask.set(
751 colorIndex, sourceFormat.alphaBits == 0 && emulatedFormat.alphaBits > 0);
Luc Ferron0bb940a2018-06-22 09:59:34 -0400752
753 contextVk->updateColorMask(context->getGLState().getBlendState());
Jamie Madill9aef3672018-04-27 11:45:06 -0400754 }
755 else
756 {
Jamie Madill58675012018-05-22 14:54:07 -0400757 updateActiveColorMasks(colorIndex, false, false, false, false);
Jamie Madill9aef3672018-04-27 11:45:06 -0400758 }
Jamie Madill57d9cbb2018-04-27 11:45:04 -0400759 break;
760 }
761 }
762 }
Jamie Madill66546be2018-03-08 09:47:20 -0500763
Jamie Madill9aef3672018-04-27 11:45:06 -0400764 mActiveColorComponents = gl_vk::GetColorComponentFlags(
Luc Ferron5fd36932018-06-19 14:55:50 -0400765 mActiveColorComponentMasksForClear[0].any(), mActiveColorComponentMasksForClear[1].any(),
766 mActiveColorComponentMasksForClear[2].any(), mActiveColorComponentMasksForClear[3].any());
Jamie Madill9aef3672018-04-27 11:45:06 -0400767
Jamie Madill9f2a8612017-11-30 12:43:09 -0500768 mRenderPassDesc.reset();
Jamie Madillc57ee252018-05-30 19:53:48 -0400769 renderer->releaseObject(getStoredQueueSerial(), &mFramebuffer);
Jamie Madill49ac74b2017-12-21 14:42:33 -0500770
Jamie Madill316c6062018-05-29 10:49:45 -0400771 // Will freeze the current set of dependencies on this FBO. The next time we render we will
Jamie Madilla5e06072018-05-18 14:36:05 -0400772 // create a new entry in the command graph.
Jamie Madill316c6062018-05-29 10:49:45 -0400773 onResourceChanged(renderer);
Jamie Madill72106562017-03-24 14:18:50 -0400774
Jamie Madill72106562017-03-24 14:18:50 -0400775 contextVk->invalidateCurrentPipeline();
Jamie Madill19fa1c62018-03-08 09:47:21 -0500776
777 return gl::NoError();
Jamie Madillab9f9c32017-01-17 17:47:34 -0500778}
779
Jamie Madillb90779e2018-04-27 11:45:01 -0400780const vk::RenderPassDesc &FramebufferVk::getRenderPassDesc()
Jamie Madillab9f9c32017-01-17 17:47:34 -0500781{
Jamie Madill9f2a8612017-11-30 12:43:09 -0500782 if (mRenderPassDesc.valid())
Jamie Madillab9f9c32017-01-17 17:47:34 -0500783 {
Jamie Madill9f2a8612017-11-30 12:43:09 -0500784 return mRenderPassDesc.value();
Jamie Madillab9f9c32017-01-17 17:47:34 -0500785 }
786
Jamie Madill0b684ce2017-11-23 12:57:39 -0500787 vk::RenderPassDesc desc;
Jamie Madillab9f9c32017-01-17 17:47:34 -0500788
Jamie Madill66546be2018-03-08 09:47:20 -0500789 // TODO(jmadill): Support gaps in RenderTargets. http://anglebug.com/2394
790 const auto &colorRenderTargets = mRenderTargetCache.getColors();
791 for (size_t colorIndex : mState.getEnabledDrawBuffers())
Jamie Madillab9f9c32017-01-17 17:47:34 -0500792 {
Jamie Madill66546be2018-03-08 09:47:20 -0500793 RenderTargetVk *colorRenderTarget = colorRenderTargets[colorIndex];
794 ASSERT(colorRenderTarget);
Jamie Madillbcf467f2018-05-23 09:46:00 -0400795 desc.packColorAttachment(colorRenderTarget->getImage());
Jamie Madillab9f9c32017-01-17 17:47:34 -0500796 }
797
Jamie Madill66546be2018-03-08 09:47:20 -0500798 RenderTargetVk *depthStencilRenderTarget = mRenderTargetCache.getDepthStencil();
799 if (depthStencilRenderTarget)
Jamie Madillab9f9c32017-01-17 17:47:34 -0500800 {
Jamie Madillbcf467f2018-05-23 09:46:00 -0400801 desc.packDepthStencilAttachment(depthStencilRenderTarget->getImage());
Jamie Madillab9f9c32017-01-17 17:47:34 -0500802 }
803
Jamie Madill9f2a8612017-11-30 12:43:09 -0500804 mRenderPassDesc = desc;
805 return mRenderPassDesc.value();
Jamie Madillab9f9c32017-01-17 17:47:34 -0500806}
807
Jamie Madill21061022018-07-12 23:56:30 -0400808angle::Result FramebufferVk::getFramebuffer(ContextVk *contextVk, vk::Framebuffer **framebufferOut)
Jamie Madillab9f9c32017-01-17 17:47:34 -0500809{
810 // If we've already created our cached Framebuffer, return it.
Jamie Madilldd43e6c2017-03-24 14:18:49 -0400811 if (mFramebuffer.valid())
Jamie Madillab9f9c32017-01-17 17:47:34 -0500812 {
Jamie Madill55981482018-07-11 09:01:18 -0400813 *framebufferOut = &mFramebuffer;
Jamie Madill21061022018-07-12 23:56:30 -0400814 return angle::Result::Continue();
Jamie Madillab9f9c32017-01-17 17:47:34 -0500815 }
816
Jamie Madillb90779e2018-04-27 11:45:01 -0400817 const vk::RenderPassDesc &desc = getRenderPassDesc();
Jamie Madill9f2a8612017-11-30 12:43:09 -0500818
Jamie Madillab9f9c32017-01-17 17:47:34 -0500819 vk::RenderPass *renderPass = nullptr;
Jamie Madill21061022018-07-12 23:56:30 -0400820 ANGLE_TRY(contextVk->getRenderer()->getCompatibleRenderPass(contextVk, desc, &renderPass));
Jamie Madillab9f9c32017-01-17 17:47:34 -0500821
822 // If we've a Framebuffer provided by a Surface (default FBO/backbuffer), query it.
823 if (mBackbuffer)
824 {
Jamie Madill21061022018-07-12 23:56:30 -0400825 return mBackbuffer->getCurrentFramebuffer(contextVk, *renderPass, framebufferOut);
Jamie Madillab9f9c32017-01-17 17:47:34 -0500826 }
827
828 // Gather VkImageViews over all FBO attachments, also size of attached region.
829 std::vector<VkImageView> attachments;
830 gl::Extents attachmentsSize;
831
Jamie Madill66546be2018-03-08 09:47:20 -0500832 // TODO(jmadill): Support gaps in RenderTargets. http://anglebug.com/2394
833 const auto &colorRenderTargets = mRenderTargetCache.getColors();
834 for (size_t colorIndex : mState.getEnabledDrawBuffers())
Jamie Madillab9f9c32017-01-17 17:47:34 -0500835 {
Jamie Madill66546be2018-03-08 09:47:20 -0500836 RenderTargetVk *colorRenderTarget = colorRenderTargets[colorIndex];
837 ASSERT(colorRenderTarget);
Jamie Madillbcf467f2018-05-23 09:46:00 -0400838 attachments.push_back(colorRenderTarget->getImageView()->getHandle());
Jamie Madillab9f9c32017-01-17 17:47:34 -0500839
Jamie Madillbcf467f2018-05-23 09:46:00 -0400840 ASSERT(attachmentsSize.empty() || attachmentsSize == colorRenderTarget->getImageExtents());
841 attachmentsSize = colorRenderTarget->getImageExtents();
Jamie Madillab9f9c32017-01-17 17:47:34 -0500842 }
843
Jamie Madill66546be2018-03-08 09:47:20 -0500844 RenderTargetVk *depthStencilRenderTarget = mRenderTargetCache.getDepthStencil();
845 if (depthStencilRenderTarget)
Jamie Madillab9f9c32017-01-17 17:47:34 -0500846 {
Jamie Madillbcf467f2018-05-23 09:46:00 -0400847 attachments.push_back(depthStencilRenderTarget->getImageView()->getHandle());
Jamie Madillab9f9c32017-01-17 17:47:34 -0500848
Jamie Madillbc543422018-03-30 10:43:19 -0400849 ASSERT(attachmentsSize.empty() ||
Jamie Madillbcf467f2018-05-23 09:46:00 -0400850 attachmentsSize == depthStencilRenderTarget->getImageExtents());
851 attachmentsSize = depthStencilRenderTarget->getImageExtents();
Jamie Madillab9f9c32017-01-17 17:47:34 -0500852 }
853
854 ASSERT(!attachments.empty());
855
856 VkFramebufferCreateInfo framebufferInfo;
857
858 framebufferInfo.sType = VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO;
859 framebufferInfo.pNext = nullptr;
860 framebufferInfo.flags = 0;
Jamie Madill9f2a8612017-11-30 12:43:09 -0500861 framebufferInfo.renderPass = renderPass->getHandle();
Jamie Madillab9f9c32017-01-17 17:47:34 -0500862 framebufferInfo.attachmentCount = static_cast<uint32_t>(attachments.size());
863 framebufferInfo.pAttachments = attachments.data();
864 framebufferInfo.width = static_cast<uint32_t>(attachmentsSize.width);
865 framebufferInfo.height = static_cast<uint32_t>(attachmentsSize.height);
866 framebufferInfo.layers = 1;
867
Jamie Madill21061022018-07-12 23:56:30 -0400868 ANGLE_TRY(mFramebuffer.init(contextVk, framebufferInfo));
Jamie Madill5deea722017-02-16 10:44:46 -0500869
Jamie Madill55981482018-07-11 09:01:18 -0400870 *framebufferOut = &mFramebuffer;
Jamie Madill21061022018-07-12 23:56:30 -0400871 return angle::Result::Continue();
Jamie Madill9e54b5a2016-05-25 12:57:39 -0400872}
873
Jamie Madill21061022018-07-12 23:56:30 -0400874angle::Result FramebufferVk::clearWithClearAttachments(ContextVk *contextVk,
875 bool clearColor,
876 bool clearDepth,
877 bool clearStencil)
Luc Ferron5242d5b2018-02-15 07:14:35 -0500878{
Jamie Madill316c6062018-05-29 10:49:45 -0400879 // Trigger a new command node to ensure overlapping writes happen sequentially.
880 onResourceChanged(contextVk->getRenderer());
Jamie Madill9aef3672018-04-27 11:45:06 -0400881
Luc Ferron5242d5b2018-02-15 07:14:35 -0500882 // This command can only happen inside a render pass, so obtain one if its already happening
883 // or create a new one if not.
Luc Ferron5242d5b2018-02-15 07:14:35 -0500884 vk::CommandBuffer *commandBuffer = nullptr;
Jamie Madill316c6062018-05-29 10:49:45 -0400885 vk::RecordingMode mode = vk::RecordingMode::Start;
886 ANGLE_TRY(getCommandBufferForDraw(contextVk, &commandBuffer, &mode));
Luc Ferron5242d5b2018-02-15 07:14:35 -0500887
Luc Ferrone4c38be2018-04-17 11:09:16 -0400888 // TODO(jmadill): Cube map attachments. http://anglebug.com/2470
889 // We assume for now that we always need to clear only 1 layer starting at the
890 // baseArrayLayer 0, this might need to change depending how we'll implement
891 // cube maps, 3d textures and array textures.
892 VkClearRect clearRect;
893 clearRect.baseArrayLayer = 0;
894 clearRect.layerCount = 1;
895
896 // When clearing, the scissor region must be clipped to the renderArea per the validation rules
897 // in Vulkan.
898 gl::Rectangle intersection;
Jamie Madill316c6062018-05-29 10:49:45 -0400899 if (!gl::ClipRectangle(contextVk->getGLState().getScissor(), getRenderPassRenderArea(),
Jamie Madill9aef3672018-04-27 11:45:06 -0400900 &intersection))
Luc Ferrone4c38be2018-04-17 11:09:16 -0400901 {
902 // There is nothing to clear since the scissor is outside of the render area.
Jamie Madill21061022018-07-12 23:56:30 -0400903 return angle::Result::Continue();
Luc Ferrone4c38be2018-04-17 11:09:16 -0400904 }
Luc Ferron1a135ad2018-07-04 10:35:31 -0400905
Luc Ferrone4c38be2018-04-17 11:09:16 -0400906 clearRect.rect = gl_vk::GetRect(intersection);
907
Luc Ferron82eda932018-07-09 15:10:22 -0400908 if (contextVk->isViewportFlipEnabledForDrawFBO())
Luc Ferron1a135ad2018-07-04 10:35:31 -0400909 {
910 clearRect.rect.offset.y = getRenderPassRenderArea().height - clearRect.rect.offset.y -
911 clearRect.rect.extent.height;
912 }
913
Luc Ferron5242d5b2018-02-15 07:14:35 -0500914 gl::AttachmentArray<VkClearAttachment> clearAttachments;
915 int clearAttachmentIndex = 0;
Luc Ferrona8af3a62018-03-29 14:44:24 -0400916
917 if (clearColor)
Luc Ferron5242d5b2018-02-15 07:14:35 -0500918 {
Luc Ferronf6e160f2018-06-12 10:13:57 -0400919 RenderTargetVk *renderTarget = getColorReadRenderTarget();
920 const vk::Format &format = renderTarget->getImageFormat();
921 VkClearValue modifiedClear = contextVk->getClearColorValue();
922
923 // We need to make sure we are not clearing the alpha channel if we are using a buffer
924 // format that doesn't have an alpha channel.
925 if (format.angleFormat().alphaBits == 0)
926 {
927 modifiedClear.color.float32[3] = 1.0;
928 }
929
Luc Ferrona8af3a62018-03-29 14:44:24 -0400930 // TODO(jmadill): Support gaps in RenderTargets. http://anglebug.com/2394
931 for (size_t colorIndex : mState.getEnabledDrawBuffers())
932 {
933 VkClearAttachment &clearAttachment = clearAttachments[clearAttachmentIndex];
934 clearAttachment.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
935 clearAttachment.colorAttachment = static_cast<uint32_t>(colorIndex);
Luc Ferronf6e160f2018-06-12 10:13:57 -0400936 clearAttachment.clearValue = modifiedClear;
Luc Ferrona8af3a62018-03-29 14:44:24 -0400937 ++clearAttachmentIndex;
938 }
939 }
940
941 if (clearDepth && clearStencil && mState.getDepthStencilAttachment() != nullptr)
942 {
943 // When we have a packed depth/stencil attachment we can do 1 clear for both when it
944 // applies.
Luc Ferron5242d5b2018-02-15 07:14:35 -0500945 VkClearAttachment &clearAttachment = clearAttachments[clearAttachmentIndex];
Luc Ferrona8af3a62018-03-29 14:44:24 -0400946 clearAttachment.aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT;
947 clearAttachment.colorAttachment = VK_ATTACHMENT_UNUSED;
948 clearAttachment.clearValue = contextVk->getClearDepthStencilValue();
Luc Ferron5242d5b2018-02-15 07:14:35 -0500949 ++clearAttachmentIndex;
950 }
Luc Ferrona8af3a62018-03-29 14:44:24 -0400951 else
952 {
953 if (clearDepth)
954 {
955 VkClearAttachment &clearAttachment = clearAttachments[clearAttachmentIndex];
956 clearAttachment.aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT;
957 clearAttachment.colorAttachment = VK_ATTACHMENT_UNUSED;
958 clearAttachment.clearValue = contextVk->getClearDepthStencilValue();
959 ++clearAttachmentIndex;
960 }
961
962 if (clearStencil)
963 {
964 VkClearAttachment &clearAttachment = clearAttachments[clearAttachmentIndex];
965 clearAttachment.aspectMask = VK_IMAGE_ASPECT_STENCIL_BIT;
966 clearAttachment.colorAttachment = VK_ATTACHMENT_UNUSED;
967 clearAttachment.clearValue = contextVk->getClearDepthStencilValue();
968 ++clearAttachmentIndex;
969 }
970 }
Luc Ferron5242d5b2018-02-15 07:14:35 -0500971
Luc Ferrona8af3a62018-03-29 14:44:24 -0400972 commandBuffer->clearAttachments(static_cast<uint32_t>(clearAttachmentIndex),
Luc Ferron5242d5b2018-02-15 07:14:35 -0500973 clearAttachments.data(), 1, &clearRect);
Jamie Madill21061022018-07-12 23:56:30 -0400974 return angle::Result::Continue();
Luc Ferron5242d5b2018-02-15 07:14:35 -0500975}
976
Jamie Madill21061022018-07-12 23:56:30 -0400977angle::Result FramebufferVk::clearWithDraw(ContextVk *contextVk,
978 VkColorComponentFlags colorMaskFlags)
Jamie Madill9aef3672018-04-27 11:45:06 -0400979{
980 RendererVk *renderer = contextVk->getRenderer();
981 vk::ShaderLibrary *shaderLibrary = renderer->getShaderLibrary();
982
Jamie Madill316c6062018-05-29 10:49:45 -0400983 // Trigger a new command node to ensure overlapping writes happen sequentially.
984 onResourceChanged(renderer);
985
Jamie Madill9aef3672018-04-27 11:45:06 -0400986 const vk::ShaderAndSerial *fullScreenQuad = nullptr;
Jamie Madill21061022018-07-12 23:56:30 -0400987 ANGLE_TRY(shaderLibrary->getShader(contextVk, vk::InternalShaderID::FullScreenQuad_vert,
Jamie Madill9aef3672018-04-27 11:45:06 -0400988 &fullScreenQuad));
989
jchen10be7f44f2018-05-21 14:35:32 +0800990 const vk::ShaderAndSerial *pushConstantColor = nullptr;
Jamie Madill21061022018-07-12 23:56:30 -0400991 ANGLE_TRY(shaderLibrary->getShader(contextVk, vk::InternalShaderID::PushConstantColor_frag,
jchen10be7f44f2018-05-21 14:35:32 +0800992 &pushConstantColor));
Jamie Madill9aef3672018-04-27 11:45:06 -0400993
Jamie Madilld668be92018-06-13 16:54:06 -0400994 // The shader uses a simple pipeline layout with a push constant range.
995 vk::PipelineLayoutDesc pipelineLayoutDesc;
996 pipelineLayoutDesc.updatePushConstantRange(gl::ShaderType::Fragment, 0,
997 sizeof(VkClearColorValue));
998
999 // The shader does not use any descriptor sets.
1000 vk::DescriptorSetLayoutPointerArray descriptorSetLayouts;
1001
1002 vk::BindingPointer<vk::PipelineLayout> pipelineLayout;
Jamie Madill21061022018-07-12 23:56:30 -04001003 ANGLE_TRY(renderer->getPipelineLayout(contextVk, pipelineLayoutDesc, descriptorSetLayouts,
1004 &pipelineLayout));
Jamie Madill9aef3672018-04-27 11:45:06 -04001005
Jamie Madill316c6062018-05-29 10:49:45 -04001006 vk::RecordingMode recordingMode = vk::RecordingMode::Start;
1007 vk::CommandBuffer *drawCommands = nullptr;
1008 ANGLE_TRY(getCommandBufferForDraw(contextVk, &drawCommands, &recordingMode));
Jamie Madill9aef3672018-04-27 11:45:06 -04001009
Jamie Madill316c6062018-05-29 10:49:45 -04001010 const gl::Rectangle &renderArea = getRenderPassRenderArea();
Luc Ferronb70ad522018-07-09 16:06:26 -04001011 bool invertViewport = contextVk->isViewportFlipEnabledForDrawFBO();
Jamie Madill9aef3672018-04-27 11:45:06 -04001012
1013 // This pipeline desc could be cached.
1014 vk::PipelineDesc pipelineDesc;
1015 pipelineDesc.initDefaults();
Luc Ferron5fd36932018-06-19 14:55:50 -04001016 pipelineDesc.updateColorWriteMask(colorMaskFlags, getEmulatedAlphaAttachmentMask());
Jamie Madill9aef3672018-04-27 11:45:06 -04001017 pipelineDesc.updateRenderPassDesc(getRenderPassDesc());
Jamie Madill06ca6342018-07-12 15:56:53 -04001018 pipelineDesc.updateShaders(fullScreenQuad->getSerial(), pushConstantColor->getSerial());
Luc Ferron82eda932018-07-09 15:10:22 -04001019 pipelineDesc.updateViewport(this, renderArea, 0.0f, 1.0f, invertViewport);
Jamie Madill9aef3672018-04-27 11:45:06 -04001020
1021 const gl::State &glState = contextVk->getGLState();
1022 if (glState.isScissorTestEnabled())
1023 {
1024 gl::Rectangle intersection;
Jamie Madill316c6062018-05-29 10:49:45 -04001025 if (!gl::ClipRectangle(glState.getScissor(), renderArea, &intersection))
Jamie Madill9aef3672018-04-27 11:45:06 -04001026 {
Jamie Madill21061022018-07-12 23:56:30 -04001027 return angle::Result::Continue();
Jamie Madill9aef3672018-04-27 11:45:06 -04001028 }
1029
Luc Ferron82eda932018-07-09 15:10:22 -04001030 pipelineDesc.updateScissor(intersection, invertViewport, renderArea);
Jamie Madill9aef3672018-04-27 11:45:06 -04001031 }
1032 else
1033 {
Luc Ferron82eda932018-07-09 15:10:22 -04001034 pipelineDesc.updateScissor(renderArea, invertViewport, renderArea);
Jamie Madill9aef3672018-04-27 11:45:06 -04001035 }
1036
1037 vk::PipelineAndSerial *pipeline = nullptr;
Jamie Madill06ca6342018-07-12 15:56:53 -04001038 ANGLE_TRY(renderer->getPipeline(contextVk, *fullScreenQuad, *pushConstantColor,
1039 pipelineLayout.get(), pipelineDesc, gl::AttributesMask(),
1040 &pipeline));
Jamie Madill9aef3672018-04-27 11:45:06 -04001041 pipeline->updateSerial(renderer->getCurrentQueueSerial());
1042
Jamie Madill316c6062018-05-29 10:49:45 -04001043 vk::CommandBuffer *writeCommands = nullptr;
Jamie Madill21061022018-07-12 23:56:30 -04001044 ANGLE_TRY(appendWriteResource(contextVk, &writeCommands));
Jamie Madill9aef3672018-04-27 11:45:06 -04001045
Luc Ferron66c2f4a2018-06-19 10:27:57 -04001046 // If the format of the framebuffer does not have an alpha channel, we need to make sure we does
1047 // not affect the alpha channel of the type we're using to emulate the format.
1048 // TODO(jmadill): Implement EXT_draw_buffers http://anglebug.com/2394
1049 RenderTargetVk *renderTarget = mRenderTargetCache.getColors()[0];
1050 ASSERT(renderTarget);
1051
1052 const vk::Format &imageFormat = renderTarget->getImageFormat();
jchen10be7f44f2018-05-21 14:35:32 +08001053 VkClearColorValue clearColorValue = contextVk->getClearColorValue().color;
Luc Ferron66c2f4a2018-06-19 10:27:57 -04001054 bool overrideAlphaWithOne =
1055 imageFormat.textureFormat().alphaBits > 0 && imageFormat.angleFormat().alphaBits == 0;
1056 clearColorValue.float32[3] = overrideAlphaWithOne ? 1.0f : clearColorValue.float32[3];
1057
Jamie Madilld668be92018-06-13 16:54:06 -04001058 drawCommands->pushConstants(pipelineLayout.get(), VK_SHADER_STAGE_FRAGMENT_BIT, 0,
Jamie Madill316c6062018-05-29 10:49:45 -04001059 sizeof(VkClearColorValue), clearColorValue.float32);
Jamie Madill9aef3672018-04-27 11:45:06 -04001060
1061 // TODO(jmadill): Masked combined color and depth/stencil clear. http://anglebug.com/2455
1062 // Any active queries submitted by the user should also be paused here.
Jamie Madill316c6062018-05-29 10:49:45 -04001063 drawCommands->bindPipeline(VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline->get());
1064 drawCommands->draw(6, 1, 0, 0);
Jamie Madill9aef3672018-04-27 11:45:06 -04001065
Jamie Madill21061022018-07-12 23:56:30 -04001066 return angle::Result::Continue();
Jamie Madill9aef3672018-04-27 11:45:06 -04001067}
1068
Geoff Lang13455072018-05-09 11:24:43 -04001069gl::Error FramebufferVk::getSamplePosition(const gl::Context *context,
1070 size_t index,
1071 GLfloat *xy) const
JiangYizhoubddc46b2016-12-09 09:50:51 +08001072{
1073 UNIMPLEMENTED();
1074 return gl::InternalError() << "getSamplePosition is unimplemented.";
1075}
1076
Jamie Madill21061022018-07-12 23:56:30 -04001077angle::Result FramebufferVk::getCommandBufferForDraw(ContextVk *contextVk,
1078 vk::CommandBuffer **commandBufferOut,
1079 vk::RecordingMode *modeOut)
Jamie Madilldf68a6f2017-01-13 17:29:53 -05001080{
Jamie Madill49ac74b2017-12-21 14:42:33 -05001081 RendererVk *renderer = contextVk->getRenderer();
Jamie Madillbef918c2017-12-13 13:11:30 -05001082
Jamie Madill316c6062018-05-29 10:49:45 -04001083 // This will clear the current write operation if it is complete.
Jamie Madill5dca6512018-05-30 10:53:51 -04001084 if (appendToStartedRenderPass(renderer, commandBufferOut))
Jamie Madill4c26fc22017-02-24 11:04:10 -05001085 {
Jamie Madill316c6062018-05-29 10:49:45 -04001086 *modeOut = vk::RecordingMode::Append;
Jamie Madill21061022018-07-12 23:56:30 -04001087 return angle::Result::Continue();
Jamie Madill9cceac42018-03-31 14:19:16 -04001088 }
Jamie Madill4c26fc22017-02-24 11:04:10 -05001089
Jamie Madilldf68a6f2017-01-13 17:29:53 -05001090 vk::Framebuffer *framebuffer = nullptr;
Jamie Madill21061022018-07-12 23:56:30 -04001091 ANGLE_TRY(getFramebuffer(contextVk, &framebuffer));
Jamie Madilldf68a6f2017-01-13 17:29:53 -05001092
Jamie Madill316c6062018-05-29 10:49:45 -04001093 // TODO(jmadill): Proper clear value implementation. http://anglebug.com/2361
Jamie Madilldf68a6f2017-01-13 17:29:53 -05001094 std::vector<VkClearValue> attachmentClearValues;
Jamie Madilldf68a6f2017-01-13 17:29:53 -05001095
Jamie Madill316c6062018-05-29 10:49:45 -04001096 vk::CommandBuffer *writeCommands = nullptr;
Jamie Madill21061022018-07-12 23:56:30 -04001097 ANGLE_TRY(appendWriteResource(contextVk, &writeCommands));
Jamie Madille4c5a232018-03-02 21:00:31 -05001098
Jamie Madillbcf467f2018-05-23 09:46:00 -04001099 vk::RenderPassDesc renderPassDesc;
1100
Jamie Madill49ac74b2017-12-21 14:42:33 -05001101 // Initialize RenderPass info.
Jamie Madill66546be2018-03-08 09:47:20 -05001102 // TODO(jmadill): Support gaps in RenderTargets. http://anglebug.com/2394
1103 const auto &colorRenderTargets = mRenderTargetCache.getColors();
1104 for (size_t colorIndex : mState.getEnabledDrawBuffers())
Jamie Madill4c26fc22017-02-24 11:04:10 -05001105 {
Jamie Madill66546be2018-03-08 09:47:20 -05001106 RenderTargetVk *colorRenderTarget = colorRenderTargets[colorIndex];
1107 ASSERT(colorRenderTarget);
Jamie Madill49ac74b2017-12-21 14:42:33 -05001108
Jamie Madill316c6062018-05-29 10:49:45 -04001109 colorRenderTarget->onColorDraw(this, writeCommands, &renderPassDesc);
Jamie Madill66546be2018-03-08 09:47:20 -05001110 attachmentClearValues.emplace_back(contextVk->getClearColorValue());
1111 }
1112
1113 RenderTargetVk *depthStencilRenderTarget = mRenderTargetCache.getDepthStencil();
1114 if (depthStencilRenderTarget)
1115 {
Jamie Madill316c6062018-05-29 10:49:45 -04001116 depthStencilRenderTarget->onDepthStencilDraw(this, writeCommands, &renderPassDesc);
Jamie Madillf4d693c2018-02-14 16:38:16 -05001117 attachmentClearValues.emplace_back(contextVk->getClearDepthStencilValue());
Jamie Madill49ac74b2017-12-21 14:42:33 -05001118 }
1119
Luc Ferrond17bdfe2018-04-05 13:50:10 -04001120 gl::Rectangle renderArea =
1121 gl::Rectangle(0, 0, mState.getDimensions().width, mState.getDimensions().height);
Jamie Madill49ac74b2017-12-21 14:42:33 -05001122
Jamie Madill316c6062018-05-29 10:49:45 -04001123 *modeOut = vk::RecordingMode::Start;
Jamie Madill21061022018-07-12 23:56:30 -04001124 return beginRenderPass(contextVk, *framebuffer, renderArea, mRenderPassDesc.value(),
Jamie Madill316c6062018-05-29 10:49:45 -04001125 attachmentClearValues, commandBufferOut);
Jamie Madilldf68a6f2017-01-13 17:29:53 -05001126}
1127
Jamie Madill9aef3672018-04-27 11:45:06 -04001128void FramebufferVk::updateActiveColorMasks(size_t colorIndex, bool r, bool g, bool b, bool a)
1129{
Luc Ferron5fd36932018-06-19 14:55:50 -04001130 mActiveColorComponentMasksForClear[0].set(colorIndex, r);
1131 mActiveColorComponentMasksForClear[1].set(colorIndex, g);
1132 mActiveColorComponentMasksForClear[2].set(colorIndex, b);
1133 mActiveColorComponentMasksForClear[3].set(colorIndex, a);
1134}
1135
1136gl::DrawBufferMask FramebufferVk::getEmulatedAlphaAttachmentMask()
1137{
1138 return mEmulatedAlphaAttachmentMask;
Jamie Madill9aef3672018-04-27 11:45:06 -04001139}
Luc Ferron018709f2018-05-10 13:53:11 -04001140
Jamie Madill21061022018-07-12 23:56:30 -04001141angle::Result FramebufferVk::readPixelsImpl(ContextVk *contextVk,
1142 const gl::Rectangle &area,
1143 const PackPixelsParams &packPixelsParams,
Jamie Madillb436aac2018-07-18 17:23:48 -04001144 VkImageAspectFlagBits copyAspectFlags,
Jamie Madill21061022018-07-12 23:56:30 -04001145 RenderTargetVk *renderTarget,
1146 void *pixels)
Luc Ferron018709f2018-05-10 13:53:11 -04001147{
Jamie Madill58675012018-05-22 14:54:07 -04001148 RendererVk *renderer = contextVk->getRenderer();
1149
Jamie Madill58675012018-05-22 14:54:07 -04001150 vk::CommandBuffer *commandBuffer = nullptr;
Jamie Madill21061022018-07-12 23:56:30 -04001151 ANGLE_TRY(beginWriteResource(contextVk, &commandBuffer));
Jamie Madill58675012018-05-22 14:54:07 -04001152
Jamie Madillbcf467f2018-05-23 09:46:00 -04001153 // Note that although we're reading from the image, we need to update the layout below.
Luc Ferron1617e692018-07-11 11:08:19 -04001154
1155 vk::ImageHelper *srcImage =
1156 renderTarget->getImageForRead(this, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, commandBuffer);
Jamie Madillbcf467f2018-05-23 09:46:00 -04001157
Jamie Madillb436aac2018-07-18 17:23:48 -04001158 const angle::Format *readFormat = &srcImage->getFormat().textureFormat();
Luc Ferron1617e692018-07-11 11:08:19 -04001159
Jamie Madillb436aac2018-07-18 17:23:48 -04001160 if (copyAspectFlags != VK_IMAGE_ASPECT_COLOR_BIT)
Luc Ferron1617e692018-07-11 11:08:19 -04001161 {
Jamie Madillb436aac2018-07-18 17:23:48 -04001162 readFormat = &GetDepthStencilImageToBufferFormat(*readFormat, copyAspectFlags);
Luc Ferron1617e692018-07-11 11:08:19 -04001163 }
1164
Jamie Madillba365932018-07-18 17:23:46 -04001165 VkBuffer bufferHandle = VK_NULL_HANDLE;
1166 uint8_t *readPixelBuffer = nullptr;
1167 bool newBufferAllocated = false;
Jamie Madill4c310832018-08-29 13:43:17 -04001168 VkDeviceSize stagingOffset = 0;
Jamie Madillb436aac2018-07-18 17:23:48 -04001169 size_t allocationSize = readFormat->pixelBytes * area.width * area.height;
Luc Ferron018709f2018-05-10 13:53:11 -04001170
Jamie Madilld754eb52018-07-19 14:55:03 -04001171 ANGLE_TRY(mReadPixelBuffer.allocate(contextVk, allocationSize, &readPixelBuffer, &bufferHandle,
1172 &stagingOffset, &newBufferAllocated));
Luc Ferron018709f2018-05-10 13:53:11 -04001173
Luc Ferron534b00d2018-05-18 08:16:53 -04001174 VkBufferImageCopy region;
1175 region.bufferImageHeight = area.height;
Jamie Madill4c310832018-08-29 13:43:17 -04001176 region.bufferOffset = stagingOffset;
Luc Ferron534b00d2018-05-18 08:16:53 -04001177 region.bufferRowLength = area.width;
1178 region.imageExtent.width = area.width;
1179 region.imageExtent.height = area.height;
1180 region.imageExtent.depth = 1;
1181 region.imageOffset.x = area.x;
1182 region.imageOffset.y = area.y;
1183 region.imageOffset.z = 0;
Luc Ferron1617e692018-07-11 11:08:19 -04001184 region.imageSubresource.aspectMask = copyAspectFlags;
Luc Ferron534b00d2018-05-18 08:16:53 -04001185 region.imageSubresource.baseArrayLayer = 0;
1186 region.imageSubresource.layerCount = 1;
1187 region.imageSubresource.mipLevel = 0;
1188
Jamie Madillbcf467f2018-05-23 09:46:00 -04001189 commandBuffer->copyImageToBuffer(srcImage->getImage(), srcImage->getCurrentLayout(),
1190 bufferHandle, 1, &region);
Luc Ferron018709f2018-05-10 13:53:11 -04001191
1192 // Triggers a full finish.
1193 // TODO(jmadill): Don't block on asynchronous readback.
Jamie Madill21061022018-07-12 23:56:30 -04001194 ANGLE_TRY(renderer->finish(contextVk));
Luc Ferron018709f2018-05-10 13:53:11 -04001195
Luc Ferron534b00d2018-05-18 08:16:53 -04001196 // The buffer we copied to needs to be invalidated before we read from it because its not been
1197 // created with the host coherent bit.
Jamie Madilld754eb52018-07-19 14:55:03 -04001198 ANGLE_TRY(mReadPixelBuffer.invalidate(contextVk));
Yuly Novikov6c6c76c2018-05-17 18:45:06 +00001199
Jamie Madillb436aac2018-07-18 17:23:48 -04001200 PackPixels(packPixelsParams, *readFormat, area.width * readFormat->pixelBytes, readPixelBuffer,
Rafael Cintron05a449a2018-06-20 18:08:04 -07001201 static_cast<uint8_t *>(pixels));
Luc Ferron018709f2018-05-10 13:53:11 -04001202
Jamie Madill21061022018-07-12 23:56:30 -04001203 return angle::Result::Continue();
Luc Ferron018709f2018-05-10 13:53:11 -04001204}
Jamie Madill58675012018-05-22 14:54:07 -04001205
1206const gl::Extents &FramebufferVk::getReadImageExtents() const
1207{
Jamie Madillbcf467f2018-05-23 09:46:00 -04001208 return getColorReadRenderTarget()->getImageExtents();
Jamie Madill58675012018-05-22 14:54:07 -04001209}
Jamie Madill9e54b5a2016-05-25 12:57:39 -04001210} // namespace rx