blob: 5b672d3ec683828f103fb12671b7291993b6eb61 [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 Madillbcf467f2018-05-23 09:46:00 -040070} // anonymous namespace
Jamie Madill7b57b9d2017-01-13 09:33:38 -050071
72// static
Jamie Madill639bc902018-07-18 17:08:27 -040073FramebufferVk *FramebufferVk::CreateUserFBO(RendererVk *renderer, const gl::FramebufferState &state)
Jamie Madill7b57b9d2017-01-13 09:33:38 -050074{
Jamie Madill639bc902018-07-18 17:08:27 -040075 return new FramebufferVk(renderer, state, nullptr);
Jamie Madill7b57b9d2017-01-13 09:33:38 -050076}
77
78// static
Jamie Madill639bc902018-07-18 17:08:27 -040079FramebufferVk *FramebufferVk::CreateDefaultFBO(RendererVk *renderer,
80 const gl::FramebufferState &state,
Jamie Madill7b57b9d2017-01-13 09:33:38 -050081 WindowSurfaceVk *backbuffer)
82{
Jamie Madill639bc902018-07-18 17:08:27 -040083 return new FramebufferVk(renderer, state, backbuffer);
Jamie Madill7b57b9d2017-01-13 09:33:38 -050084}
85
Jamie Madill639bc902018-07-18 17:08:27 -040086FramebufferVk::FramebufferVk(RendererVk *renderer,
87 const gl::FramebufferState &state,
88 WindowSurfaceVk *backbuffer)
Jamie Madill9aef3672018-04-27 11:45:06 -040089 : FramebufferImpl(state),
90 mBackbuffer(backbuffer),
Jamie Madill9aef3672018-04-27 11:45:06 -040091 mActiveColorComponents(0),
Jamie Madilld754eb52018-07-19 14:55:03 -040092 mReadPixelBuffer(VK_BUFFER_USAGE_TRANSFER_DST_BIT, kMinReadPixelsBufferSize),
Luc Ferron1617e692018-07-11 11:08:19 -040093 mBlitPixelBuffer(VK_BUFFER_USAGE_TRANSFER_SRC_BIT, kMinReadPixelsBufferSize)
Jamie Madill7b57b9d2017-01-13 09:33:38 -050094{
Jamie Madill639bc902018-07-18 17:08:27 -040095 mBlitPixelBuffer.init(1, renderer);
96 ASSERT(mBlitPixelBuffer.valid());
97
Jamie Madilld754eb52018-07-19 14:55:03 -040098 mReadPixelBuffer.init(1, renderer);
99 ASSERT(mReadPixelBuffer.valid());
Jamie Madill7b57b9d2017-01-13 09:33:38 -0500100}
101
Jamie Madill58675012018-05-22 14:54:07 -0400102FramebufferVk::~FramebufferVk() = default;
Jamie Madill9e54b5a2016-05-25 12:57:39 -0400103
Jamie Madillc564c072017-06-01 12:45:42 -0400104void FramebufferVk::destroy(const gl::Context *context)
Jamie Madill5deea722017-02-16 10:44:46 -0500105{
Luc Ferron534b00d2018-05-18 08:16:53 -0400106 ContextVk *contextVk = vk::GetImpl(context);
107 RendererVk *renderer = contextVk->getRenderer();
Jamie Madillc57ee252018-05-30 19:53:48 -0400108 renderer->releaseObject(getStoredQueueSerial(), &mFramebuffer);
Luc Ferron534b00d2018-05-18 08:16:53 -0400109
Jamie Madilld754eb52018-07-19 14:55:03 -0400110 mReadPixelBuffer.destroy(contextVk->getDevice());
Luc Ferron1617e692018-07-11 11:08:19 -0400111 mBlitPixelBuffer.destroy(contextVk->getDevice());
Jamie Madill5deea722017-02-16 10:44:46 -0500112}
113
Jamie Madill4928b7c2017-06-20 12:57:39 -0400114gl::Error FramebufferVk::discard(const gl::Context *context,
115 size_t count,
116 const GLenum *attachments)
Jamie Madill9e54b5a2016-05-25 12:57:39 -0400117{
118 UNIMPLEMENTED();
Yuly Novikovc4d18aa2017-03-09 18:45:02 -0500119 return gl::InternalError();
Jamie Madill9e54b5a2016-05-25 12:57:39 -0400120}
121
Jamie Madill4928b7c2017-06-20 12:57:39 -0400122gl::Error FramebufferVk::invalidate(const gl::Context *context,
123 size_t count,
124 const GLenum *attachments)
Jamie Madill9e54b5a2016-05-25 12:57:39 -0400125{
126 UNIMPLEMENTED();
Yuly Novikovc4d18aa2017-03-09 18:45:02 -0500127 return gl::InternalError();
Jamie Madill9e54b5a2016-05-25 12:57:39 -0400128}
129
Jamie Madill4928b7c2017-06-20 12:57:39 -0400130gl::Error FramebufferVk::invalidateSub(const gl::Context *context,
131 size_t count,
Jamie Madill9e54b5a2016-05-25 12:57:39 -0400132 const GLenum *attachments,
133 const gl::Rectangle &area)
134{
135 UNIMPLEMENTED();
Yuly Novikovc4d18aa2017-03-09 18:45:02 -0500136 return gl::InternalError();
Jamie Madill9e54b5a2016-05-25 12:57:39 -0400137}
138
Jamie Madillc564c072017-06-01 12:45:42 -0400139gl::Error FramebufferVk::clear(const gl::Context *context, GLbitfield mask)
Jamie Madill9e54b5a2016-05-25 12:57:39 -0400140{
Jamie Madill0cec82a2018-03-14 09:21:07 -0400141 ContextVk *contextVk = vk::GetImpl(context);
Jamie Madill7b57b9d2017-01-13 09:33:38 -0500142
Jamie Madill0cec82a2018-03-14 09:21:07 -0400143 // This command buffer is only started once.
Jamie Madill50cf2be2018-06-15 09:46:57 -0400144 vk::CommandBuffer *commandBuffer = nullptr;
Jamie Madill7b57b9d2017-01-13 09:33:38 -0500145
Jamie Madill0cec82a2018-03-14 09:21:07 -0400146 const gl::FramebufferAttachment *depthAttachment = mState.getDepthAttachment();
147 bool clearDepth = (depthAttachment && (mask & GL_DEPTH_BUFFER_BIT) != 0);
148 ASSERT(!clearDepth || depthAttachment->isAttached());
149
150 const gl::FramebufferAttachment *stencilAttachment = mState.getStencilAttachment();
151 bool clearStencil = (stencilAttachment && (mask & GL_STENCIL_BUFFER_BIT) != 0);
152 ASSERT(!clearStencil || stencilAttachment->isAttached());
153
Luc Ferrona8af3a62018-03-29 14:44:24 -0400154 bool clearColor = IsMaskFlagSet(static_cast<int>(mask), GL_COLOR_BUFFER_BIT);
155
Luc Ferron8836f632018-04-05 07:26:53 -0400156 const gl::FramebufferAttachment *depthStencilAttachment = mState.getDepthStencilAttachment();
Jamie Madilld47044a2018-04-27 11:45:03 -0400157 const gl::State &glState = context->getGLState();
Luc Ferron8836f632018-04-05 07:26:53 -0400158
Jamie Madill9aef3672018-04-27 11:45:06 -0400159 // The most costly clear mode is when we need to mask out specific color channels. This can
160 // only be done with a draw call. The scissor region however can easily be integrated with
161 // this method. Similarly for depth/stencil clear.
162 VkColorComponentFlags colorMaskFlags = contextVk->getClearColorMask();
163 if (clearColor && (mActiveColorComponents & colorMaskFlags) != mActiveColorComponents)
164 {
Jamie Madill21061022018-07-12 23:56:30 -0400165 ANGLE_TRY(clearWithDraw(contextVk, colorMaskFlags));
Jamie Madill78cd9402018-05-10 16:49:58 -0400166
167 // Stencil clears must be handled separately. The only way to write out a stencil value from
168 // a fragment shader in Vulkan is with VK_EXT_shader_stencil_export. Support for this
169 // extension is sparse. Hence, we call into the RenderPass clear path. We similarly clear
170 // depth to keep the code simple, but depth clears could be combined with the masked color
171 // clears as an optimization.
172
173 if (clearDepth || clearStencil)
174 {
175 // Masked stencil clears are currently not implemented.
176 // TODO(jmadill): Masked stencil clear. http://anglebug.com/2540
177 ANGLE_TRY(clearWithClearAttachments(contextVk, false, clearDepth, clearStencil));
178 }
179 return gl::NoError();
Jamie Madill9aef3672018-04-27 11:45:06 -0400180 }
181
Luc Ferron8836f632018-04-05 07:26:53 -0400182 // If we clear the depth OR the stencil but not both, and we have a packed depth stencil
183 // attachment, we need to use clearAttachment instead of clearDepthStencil since Vulkan won't
184 // allow us to clear one or the other separately.
185 bool isSingleClearOnPackedDepthStencilAttachment =
186 depthStencilAttachment && (clearDepth != clearStencil);
Jamie Madilld47044a2018-04-27 11:45:03 -0400187 if (glState.isScissorTestEnabled() || isSingleClearOnPackedDepthStencilAttachment)
Luc Ferrona8af3a62018-03-29 14:44:24 -0400188 {
189 // With scissor test enabled, we clear very differently and we don't need to access
190 // the image inside each attachment we can just use clearCmdAttachments with our
191 // scissor region instead.
Jamie Madill78cd9402018-05-10 16:49:58 -0400192
193 // Masked stencil clears are currently not implemented.
194 // TODO(jmadill): Masked stencil clear. http://anglebug.com/2540
Jamie Madillb90779e2018-04-27 11:45:01 -0400195 ANGLE_TRY(clearWithClearAttachments(contextVk, clearColor, clearDepth, clearStencil));
Luc Ferrona8af3a62018-03-29 14:44:24 -0400196 return gl::NoError();
197 }
198
199 // Standard Depth/stencil clear without scissor.
Jamie Madill0cec82a2018-03-14 09:21:07 -0400200 if (clearDepth || clearStencil)
Jamie Madill7b57b9d2017-01-13 09:33:38 -0500201 {
Jamie Madill21061022018-07-12 23:56:30 -0400202 ANGLE_TRY(beginWriteResource(contextVk, &commandBuffer));
Jamie Madill0cec82a2018-03-14 09:21:07 -0400203
204 const VkClearDepthStencilValue &clearDepthStencilValue =
205 contextVk->getClearDepthStencilValue().depthStencil;
206
Luc Ferron26581112018-06-21 09:43:08 -0400207 RenderTargetVk *renderTarget = mRenderTargetCache.getDepthStencil();
Luc Ferron5bdf8bd2018-06-20 09:51:37 -0400208 const angle::Format &format = renderTarget->getImageFormat().textureFormat();
209 const VkImageAspectFlags aspectFlags = vk::GetDepthStencilAspectFlags(format);
210
Jamie Madille4e2d0c2018-06-22 08:25:05 -0400211 vk::ImageHelper *image = renderTarget->getImageForWrite(this);
Jamie Madillbcf467f2018-05-23 09:46:00 -0400212 image->clearDepthStencil(aspectFlags, clearDepthStencilValue, commandBuffer);
Jamie Madill7b57b9d2017-01-13 09:33:38 -0500213 }
214
Luc Ferrond3ab3072018-06-19 09:55:04 -0400215 if (!clearColor)
216 {
217 return gl::NoError();
218 }
219
Jamie Madill7b57b9d2017-01-13 09:33:38 -0500220 const auto *attachment = mState.getFirstNonNullAttachment();
221 ASSERT(attachment && attachment->isAttached());
Jamie Madill7b57b9d2017-01-13 09:33:38 -0500222
Jamie Madill0cec82a2018-03-14 09:21:07 -0400223 if (!commandBuffer)
224 {
Jamie Madill21061022018-07-12 23:56:30 -0400225 ANGLE_TRY(beginWriteResource(contextVk, &commandBuffer));
Jamie Madill0cec82a2018-03-14 09:21:07 -0400226 }
Jamie Madillefb5a5c2018-01-29 15:56:59 -0500227
Jamie Madill66546be2018-03-08 09:47:20 -0500228 // TODO(jmadill): Support gaps in RenderTargets. http://anglebug.com/2394
Jamie Madill50cf2be2018-06-15 09:46:57 -0400229 const auto &colorRenderTargets = mRenderTargetCache.getColors();
Jamie Madill9aef3672018-04-27 11:45:06 -0400230 const VkClearColorValue &clearColorValue = contextVk->getClearColorValue().color;
Jamie Madill66546be2018-03-08 09:47:20 -0500231 for (size_t colorIndex : mState.getEnabledDrawBuffers())
Jamie Madill7b57b9d2017-01-13 09:33:38 -0500232 {
Luc Ferron5fd36932018-06-19 14:55:50 -0400233 VkClearColorValue modifiedClearColorValue = clearColorValue;
Luc Ferron26581112018-06-21 09:43:08 -0400234 RenderTargetVk *colorRenderTarget = colorRenderTargets[colorIndex];
Luc Ferron5fd36932018-06-19 14:55:50 -0400235
236 // Its possible we're clearing a render target that has no alpha channel but we represent it
237 // with a texture that has one. We must not affect its alpha channel no matter what the
238 // clear value is in that case.
239 if (mEmulatedAlphaAttachmentMask[colorIndex])
240 {
241 modifiedClearColorValue.float32[3] = 1.0;
242 }
243
Jamie Madill66546be2018-03-08 09:47:20 -0500244 ASSERT(colorRenderTarget);
Jamie Madille4e2d0c2018-06-22 08:25:05 -0400245 vk::ImageHelper *image = colorRenderTarget->getImageForWrite(this);
Luc Ferronc20b9502018-05-24 09:30:17 -0400246 GLint mipLevelToClear = (attachment->type() == GL_TEXTURE) ? attachment->mipLevel() : 0;
Luc Ferron5fd36932018-06-19 14:55:50 -0400247 image->clearColor(modifiedClearColorValue, mipLevelToClear, 1, commandBuffer);
Jamie Madill7b57b9d2017-01-13 09:33:38 -0500248 }
249
Jamie Madill7b57b9d2017-01-13 09:33:38 -0500250 return gl::NoError();
Jamie Madill9e54b5a2016-05-25 12:57:39 -0400251}
252
Jamie Madillc564c072017-06-01 12:45:42 -0400253gl::Error FramebufferVk::clearBufferfv(const gl::Context *context,
Jamie Madill9e54b5a2016-05-25 12:57:39 -0400254 GLenum buffer,
255 GLint drawbuffer,
256 const GLfloat *values)
257{
258 UNIMPLEMENTED();
Yuly Novikovc4d18aa2017-03-09 18:45:02 -0500259 return gl::InternalError();
Jamie Madill9e54b5a2016-05-25 12:57:39 -0400260}
261
Jamie Madillc564c072017-06-01 12:45:42 -0400262gl::Error FramebufferVk::clearBufferuiv(const gl::Context *context,
Jamie Madill9e54b5a2016-05-25 12:57:39 -0400263 GLenum buffer,
264 GLint drawbuffer,
265 const GLuint *values)
266{
267 UNIMPLEMENTED();
Yuly Novikovc4d18aa2017-03-09 18:45:02 -0500268 return gl::InternalError();
Jamie Madill9e54b5a2016-05-25 12:57:39 -0400269}
270
Jamie Madillc564c072017-06-01 12:45:42 -0400271gl::Error FramebufferVk::clearBufferiv(const gl::Context *context,
Jamie Madill9e54b5a2016-05-25 12:57:39 -0400272 GLenum buffer,
273 GLint drawbuffer,
274 const GLint *values)
275{
276 UNIMPLEMENTED();
Yuly Novikovc4d18aa2017-03-09 18:45:02 -0500277 return gl::InternalError();
Jamie Madill9e54b5a2016-05-25 12:57:39 -0400278}
279
Jamie Madillc564c072017-06-01 12:45:42 -0400280gl::Error FramebufferVk::clearBufferfi(const gl::Context *context,
Jamie Madill9e54b5a2016-05-25 12:57:39 -0400281 GLenum buffer,
282 GLint drawbuffer,
283 GLfloat depth,
284 GLint stencil)
285{
286 UNIMPLEMENTED();
Yuly Novikovc4d18aa2017-03-09 18:45:02 -0500287 return gl::InternalError();
Jamie Madill9e54b5a2016-05-25 12:57:39 -0400288}
289
Jamie Madill4928b7c2017-06-20 12:57:39 -0400290GLenum FramebufferVk::getImplementationColorReadFormat(const gl::Context *context) const
Jamie Madill9e54b5a2016-05-25 12:57:39 -0400291{
Jamie Madill66546be2018-03-08 09:47:20 -0500292 return GetReadAttachmentInfo(context, mRenderTargetCache.getColorRead(mState)).format;
Jamie Madill9e54b5a2016-05-25 12:57:39 -0400293}
294
Jamie Madill4928b7c2017-06-20 12:57:39 -0400295GLenum FramebufferVk::getImplementationColorReadType(const gl::Context *context) const
Jamie Madill9e54b5a2016-05-25 12:57:39 -0400296{
Jamie Madill66546be2018-03-08 09:47:20 -0500297 return GetReadAttachmentInfo(context, mRenderTargetCache.getColorRead(mState)).type;
Jamie Madill9e54b5a2016-05-25 12:57:39 -0400298}
299
Jamie Madillc564c072017-06-01 12:45:42 -0400300gl::Error FramebufferVk::readPixels(const gl::Context *context,
Jamie Madill9e54b5a2016-05-25 12:57:39 -0400301 const gl::Rectangle &area,
302 GLenum format,
303 GLenum type,
Jamie Madilld4826152017-09-21 11:18:59 -0400304 void *pixels)
Jamie Madill9e54b5a2016-05-25 12:57:39 -0400305{
Luc Ferrona1c72422018-05-14 15:58:28 -0400306 // Clip read area to framebuffer.
307 const gl::Extents &fbSize = getState().getReadAttachment()->getSize();
308 const gl::Rectangle fbRect(0, 0, fbSize.width, fbSize.height);
Luc Ferronbf6dc372018-06-28 15:24:19 -0400309 ContextVk *contextVk = vk::GetImpl(context);
310 RendererVk *renderer = contextVk->getRenderer();
311
Luc Ferrona1c72422018-05-14 15:58:28 -0400312 gl::Rectangle clippedArea;
313 if (!ClipRectangle(area, fbRect, &clippedArea))
314 {
315 // nothing to read
316 return gl::NoError();
317 }
Luc Ferronbf6dc372018-06-28 15:24:19 -0400318 gl::Rectangle flippedArea = clippedArea;
Geoff Lange076a232018-07-16 15:34:05 -0400319 if (contextVk->isViewportFlipEnabledForReadFBO())
Luc Ferronbf6dc372018-06-28 15:24:19 -0400320 {
321 flippedArea.y = fbRect.height - flippedArea.y - flippedArea.height;
322 }
Luc Ferrona1c72422018-05-14 15:58:28 -0400323
Jamie Madill66546be2018-03-08 09:47:20 -0500324 const gl::State &glState = context->getGLState();
Luc Ferron534b00d2018-05-18 08:16:53 -0400325
326 vk::CommandBuffer *commandBuffer = nullptr;
Jamie Madill21061022018-07-12 23:56:30 -0400327 ANGLE_TRY(beginWriteResource(contextVk, &commandBuffer));
Jamie Madill66546be2018-03-08 09:47:20 -0500328
Luc Ferron44a3cf42018-07-09 09:40:57 -0400329 gl::PixelPackState packState(glState.getPackState());
Geoff Lange076a232018-07-16 15:34:05 -0400330 if (contextVk->isViewportFlipEnabledForReadFBO())
Luc Ferronbf6dc372018-06-28 15:24:19 -0400331 {
332 packState.reverseRowOrder = !packState.reverseRowOrder;
333 }
334
Luc Ferrona1c72422018-05-14 15:58:28 -0400335 const gl::InternalFormat &sizedFormatInfo = gl::GetInternalFormatInfo(format, type);
336
337 GLuint outputPitch = 0;
Jamie Madillca2ff382018-07-11 09:01:17 -0400338 ANGLE_TRY_CHECKED_MATH(sizedFormatInfo.computeRowPitch(type, area.width, packState.alignment,
339 packState.rowLength, &outputPitch));
Luc Ferrona1c72422018-05-14 15:58:28 -0400340 GLuint outputSkipBytes = 0;
Jamie Madillca2ff382018-07-11 09:01:17 -0400341 ANGLE_TRY_CHECKED_MATH(
342 sizedFormatInfo.computeSkipBytes(type, outputPitch, 0, packState, false, &outputSkipBytes));
Luc Ferrona1c72422018-05-14 15:58:28 -0400343
344 outputSkipBytes += (clippedArea.x - area.x) * sizedFormatInfo.pixelBytes +
345 (clippedArea.y - area.y) * outputPitch;
Luc Ferron60284222018-03-20 16:01:44 -0400346
Jamie Madilldb9c69e2018-07-18 17:23:47 -0400347 const angle::Format &angleFormat = GetFormatFromFormatType(format, type);
348
349 PackPixelsParams params(flippedArea, angleFormat, outputPitch, packState,
350 glState.getTargetBuffer(gl::BufferBinding::PixelPack), 0);
Jamie Madill7b57b9d2017-01-13 09:33:38 -0500351
Jamie Madill21061022018-07-12 23:56:30 -0400352 ANGLE_TRY(readPixelsImpl(contextVk, flippedArea, params, VK_IMAGE_ASPECT_COLOR_BIT,
Luc Ferron1617e692018-07-11 11:08:19 -0400353 getColorReadRenderTarget(),
Rafael Cintron05a449a2018-06-20 18:08:04 -0700354 static_cast<uint8_t *>(pixels) + outputSkipBytes));
Jamie Madilld754eb52018-07-19 14:55:03 -0400355 mReadPixelBuffer.releaseRetainedBuffers(renderer);
Luc Ferron534b00d2018-05-18 08:16:53 -0400356 return gl::NoError();
Luc Ferron018709f2018-05-10 13:53:11 -0400357}
Jamie Madill7b57b9d2017-01-13 09:33:38 -0500358
Luc Ferron26581112018-06-21 09:43:08 -0400359RenderTargetVk *FramebufferVk::getDepthStencilRenderTarget() const
360{
361 return mRenderTargetCache.getDepthStencil();
362}
363
Jamie Madilld754eb52018-07-19 14:55:03 -0400364void FramebufferVk::blitWithCopy(vk::CommandBuffer *commandBuffer,
365 const gl::Rectangle &copyArea,
366 RenderTargetVk *readRenderTarget,
367 RenderTargetVk *drawRenderTarget,
368 bool blitDepthBuffer,
369 bool blitStencilBuffer)
Luc Ferronbe30c4f2018-06-21 09:43:08 -0400370{
Luc Ferronbe30c4f2018-06-21 09:43:08 -0400371 VkFlags aspectFlags =
372 vk::GetDepthStencilAspectFlags(readRenderTarget->getImageFormat().textureFormat());
373 vk::ImageHelper *readImage = readRenderTarget->getImageForRead(
Luc Ferron1617e692018-07-11 11:08:19 -0400374 this, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, commandBuffer);
Luc Ferronbe30c4f2018-06-21 09:43:08 -0400375 vk::ImageHelper *writeImage = drawRenderTarget->getImageForWrite(this);
376 // Requirement of the copyImageToBuffer, the dst image must be in
377 // VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL layout.
378 writeImage->changeLayoutWithStages(aspectFlags, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
379 VK_PIPELINE_STAGE_ALL_COMMANDS_BIT,
380 VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, commandBuffer);
Luc Ferron1617e692018-07-11 11:08:19 -0400381
382 VkImageAspectFlags aspectMask =
383 vk::GetDepthStencilAspectFlagsForCopy(blitDepthBuffer, blitStencilBuffer);
Luc Ferronbe30c4f2018-06-21 09:43:08 -0400384 vk::ImageHelper::Copy(readImage, writeImage, gl::Offset(), gl::Offset(),
Jamie Madilld754eb52018-07-19 14:55:03 -0400385 gl::Extents(copyArea.width, copyArea.height, 1), aspectMask,
386 commandBuffer);
Luc Ferronbe30c4f2018-06-21 09:43:08 -0400387}
388
Jamie Madill58675012018-05-22 14:54:07 -0400389RenderTargetVk *FramebufferVk::getColorReadRenderTarget() const
Luc Ferron018709f2018-05-10 13:53:11 -0400390{
391 RenderTargetVk *renderTarget = mRenderTargetCache.getColorRead(mState);
Jamie Madillbcf467f2018-05-23 09:46:00 -0400392 ASSERT(renderTarget && renderTarget->getImage().valid());
Luc Ferron018709f2018-05-10 13:53:11 -0400393 return renderTarget;
Jamie Madill9e54b5a2016-05-25 12:57:39 -0400394}
395
Jamie Madill21061022018-07-12 23:56:30 -0400396angle::Result FramebufferVk::blitWithReadback(ContextVk *contextVk,
Jamie Madilld754eb52018-07-19 14:55:03 -0400397 const gl::Rectangle &copyArea,
Jamie Madill21061022018-07-12 23:56:30 -0400398 bool blitDepthBuffer,
399 bool blitStencilBuffer,
400 vk::CommandBuffer *commandBuffer,
401 RenderTargetVk *readRenderTarget,
402 RenderTargetVk *drawRenderTarget)
Luc Ferron1617e692018-07-11 11:08:19 -0400403{
Luc Ferron1617e692018-07-11 11:08:19 -0400404 RendererVk *renderer = contextVk->getRenderer();
405 vk::ImageHelper *imageForRead = readRenderTarget->getImageForRead(
406 this, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, commandBuffer);
407 const angle::Format &drawFormat = drawRenderTarget->getImageFormat().angleFormat();
Luc Ferron1617e692018-07-11 11:08:19 -0400408
409 GLuint outputPitch = 0;
410
411 if (blitStencilBuffer)
412 {
413 // If we're copying the stencil bits, we need to adjust the outputPitch
414 // because in Vulkan, if we copy the stencil out of a any texture, the stencil
415 // will be tightly packed in an S8 buffer (as specified in the spec here
416 // https://www.khronos.org/registry/vulkan/specs/1.1-extensions/man/html/VkBufferImageCopy.html)
Jamie Madilld754eb52018-07-19 14:55:03 -0400417 outputPitch = copyArea.width * (drawFormat.stencilBits / 8);
Luc Ferron1617e692018-07-11 11:08:19 -0400418 }
419 else
420 {
Jamie Madilld754eb52018-07-19 14:55:03 -0400421 outputPitch = copyArea.width * drawFormat.pixelBytes;
Luc Ferron1617e692018-07-11 11:08:19 -0400422 }
423
424 PackPixelsParams packPixelsParams;
425 packPixelsParams.pack.alignment = 1;
426 packPixelsParams.pack.reverseRowOrder = true;
Jamie Madilldb9c69e2018-07-18 17:23:47 -0400427 packPixelsParams.destFormat = &drawFormat;
Jamie Madilld754eb52018-07-19 14:55:03 -0400428 packPixelsParams.area.height = copyArea.height;
429 packPixelsParams.area.width = copyArea.width;
430 packPixelsParams.area.x = copyArea.x;
431 packPixelsParams.area.y = copyArea.y;
Luc Ferron1617e692018-07-11 11:08:19 -0400432 packPixelsParams.outputPitch = outputPitch;
433
434 GLuint pixelBytes = imageForRead->getFormat().angleFormat().pixelBytes;
Jamie Madilld754eb52018-07-19 14:55:03 -0400435 GLuint sizeToRequest = copyArea.width * copyArea.height * pixelBytes;
Luc Ferron1617e692018-07-11 11:08:19 -0400436
437 uint8_t *copyPtr = nullptr;
438 VkBuffer handleOut = VK_NULL_HANDLE;
439 uint32_t offsetOut = 0;
440
Luc Ferron1617e692018-07-11 11:08:19 -0400441 VkImageAspectFlags copyFlags =
442 vk::GetDepthStencilAspectFlagsForCopy(blitDepthBuffer, blitStencilBuffer);
443
Jamie Madill21061022018-07-12 23:56:30 -0400444 ANGLE_TRY(mBlitPixelBuffer.allocate(contextVk, sizeToRequest, &copyPtr, &handleOut, &offsetOut,
Luc Ferron1617e692018-07-11 11:08:19 -0400445 nullptr));
Jamie Madilld754eb52018-07-19 14:55:03 -0400446 ANGLE_TRY(readPixelsImpl(contextVk, copyArea, packPixelsParams, copyFlags, readRenderTarget,
Luc Ferron1617e692018-07-11 11:08:19 -0400447 copyPtr));
Jamie Madill21061022018-07-12 23:56:30 -0400448 ANGLE_TRY(mBlitPixelBuffer.flush(contextVk));
Luc Ferron1617e692018-07-11 11:08:19 -0400449
450 // Reinitialize the commandBuffer after a read pixels because it calls
451 // renderer->finish which makes command buffers obsolete.
Jamie Madill21061022018-07-12 23:56:30 -0400452 ANGLE_TRY(beginWriteResource(contextVk, &commandBuffer));
Luc Ferron1617e692018-07-11 11:08:19 -0400453
454 // We read the bytes of the image in a buffer, now we have to copy them into the
455 // destination target.
456 vk::ImageHelper *imageForWrite = drawRenderTarget->getImageForWrite(this);
457
458 imageForWrite->changeLayoutWithStages(
459 imageForWrite->getAspectFlags(), VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
460 VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, commandBuffer);
461
462 VkBufferImageCopy region;
463 region.bufferOffset = offsetOut;
Jamie Madilld754eb52018-07-19 14:55:03 -0400464 region.bufferImageHeight = copyArea.height;
465 region.bufferRowLength = copyArea.width;
466 region.imageExtent.width = copyArea.width;
467 region.imageExtent.height = copyArea.height;
Luc Ferron1617e692018-07-11 11:08:19 -0400468 region.imageExtent.depth = 1;
469 region.imageSubresource.mipLevel = 0;
470 region.imageSubresource.aspectMask = copyFlags;
471 region.imageSubresource.baseArrayLayer = 0;
472 region.imageSubresource.layerCount = 1;
Jamie Madilld754eb52018-07-19 14:55:03 -0400473 region.imageOffset.x = copyArea.x;
474 region.imageOffset.y = copyArea.y;
Luc Ferron1617e692018-07-11 11:08:19 -0400475 region.imageOffset.z = 0;
476
477 commandBuffer->copyBufferToImage(handleOut, imageForWrite->getImage(),
478 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1, &region);
479
480 mBlitPixelBuffer.releaseRetainedBuffers(renderer);
Jamie Madill21061022018-07-12 23:56:30 -0400481 return angle::Result::Continue();
Luc Ferron1617e692018-07-11 11:08:19 -0400482}
483
Jamie Madillc564c072017-06-01 12:45:42 -0400484gl::Error FramebufferVk::blit(const gl::Context *context,
Jamie Madill9e54b5a2016-05-25 12:57:39 -0400485 const gl::Rectangle &sourceArea,
486 const gl::Rectangle &destArea,
487 GLbitfield mask,
488 GLenum filter)
489{
Luc Ferron26581112018-06-21 09:43:08 -0400490 ContextVk *contextVk = vk::GetImpl(context);
491 RendererVk *renderer = contextVk->getRenderer();
492
493 const gl::State &glState = context->getGLState();
494 const gl::Framebuffer *sourceFramebuffer = glState.getReadFramebuffer();
Jamie Madillba365932018-07-18 17:23:46 -0400495 bool blitColorBuffer = (mask & GL_COLOR_BUFFER_BIT) != 0;
496 bool blitDepthBuffer = (mask & GL_DEPTH_BUFFER_BIT) != 0;
497 bool blitStencilBuffer = (mask & GL_STENCIL_BUFFER_BIT) != 0;
Luc Ferron26581112018-06-21 09:43:08 -0400498
499 vk::CommandBuffer *commandBuffer = nullptr;
Jamie Madill21061022018-07-12 23:56:30 -0400500 ANGLE_TRY(beginWriteResource(contextVk, &commandBuffer));
Luc Ferron26581112018-06-21 09:43:08 -0400501 FramebufferVk *sourceFramebufferVk = vk::GetImpl(sourceFramebuffer);
Luc Ferron82eda932018-07-09 15:10:22 -0400502 bool flipSource = contextVk->isViewportFlipEnabledForReadFBO();
503 bool flipDest = contextVk->isViewportFlipEnabledForDrawFBO();
504
Jamie Madilld754eb52018-07-19 14:55:03 -0400505 gl::Rectangle readRect = sourceArea;
506 gl::Rectangle drawRect = destArea;
507
508 if (glState.isScissorTestEnabled())
509 {
510 const gl::Rectangle scissorRect = glState.getScissor();
511 if (!ClipRectangle(sourceArea, scissorRect, &readRect))
512 {
513 return gl::NoError();
514 }
515
516 if (!ClipRectangle(destArea, scissorRect, &drawRect))
517 {
518 return gl::NoError();
519 }
520 }
521
522 // After cropping for the scissor, we also want to crop for the size of the buffers.
523
Luc Ferron26581112018-06-21 09:43:08 -0400524 if (blitColorBuffer)
525 {
526 RenderTargetVk *readRenderTarget = sourceFramebufferVk->getColorReadRenderTarget();
527
Jamie Madilld754eb52018-07-19 14:55:03 -0400528 gl::Rectangle readRenderTargetRect;
529 if (!ClipToRenderTarget(readRect, readRenderTarget, &readRenderTargetRect))
530 {
531 return gl::NoError();
532 }
533
Luc Ferron26581112018-06-21 09:43:08 -0400534 for (size_t colorAttachment : mState.getEnabledDrawBuffers())
535 {
536 RenderTargetVk *drawRenderTarget = mRenderTargetCache.getColors()[colorAttachment];
537 ASSERT(drawRenderTarget);
538 ASSERT(HasSrcAndDstBlitProperties(renderer->getPhysicalDevice(), readRenderTarget,
539 drawRenderTarget));
Jamie Madilld754eb52018-07-19 14:55:03 -0400540
541 gl::Rectangle drawRenderTargetRect;
542 if (!ClipToRenderTarget(drawRect, drawRenderTarget, &drawRenderTargetRect))
543 {
544 return gl::NoError();
545 }
546
547 blitWithCommand(commandBuffer, readRenderTargetRect, drawRenderTargetRect,
548 readRenderTarget, drawRenderTarget, filter, true, false, false,
549 flipSource, flipDest);
Luc Ferron26581112018-06-21 09:43:08 -0400550 }
551 }
552
553 if (blitDepthBuffer || blitStencilBuffer)
554 {
555 RenderTargetVk *readRenderTarget = sourceFramebufferVk->getDepthStencilRenderTarget();
556 ASSERT(readRenderTarget);
557
Jamie Madilld754eb52018-07-19 14:55:03 -0400558 gl::Rectangle readRenderTargetRect;
559 if (!ClipToRenderTarget(readRect, readRenderTarget, &readRenderTargetRect))
560 {
561 return gl::NoError();
562 }
563
Luc Ferron26581112018-06-21 09:43:08 -0400564 RenderTargetVk *drawRenderTarget = mRenderTargetCache.getDepthStencil();
Jamie Madilld754eb52018-07-19 14:55:03 -0400565 ASSERT(drawRenderTarget);
566
567 gl::Rectangle drawRenderTargetRect;
568 if (!ClipToRenderTarget(drawRect, drawRenderTarget, &drawRenderTargetRect))
569 {
570 return gl::NoError();
571 }
572
573 ASSERT(readRenderTargetRect == drawRenderTargetRect);
574 ASSERT(filter == GL_NEAREST);
Luc Ferron26581112018-06-21 09:43:08 -0400575
576 if (HasSrcAndDstBlitProperties(renderer->getPhysicalDevice(), readRenderTarget,
577 drawRenderTarget))
578 {
Jamie Madilld754eb52018-07-19 14:55:03 -0400579 blitWithCommand(commandBuffer, readRenderTargetRect, drawRenderTargetRect,
580 readRenderTarget, drawRenderTarget, filter, false, blitDepthBuffer,
581 blitStencilBuffer, flipSource, flipDest);
Luc Ferron26581112018-06-21 09:43:08 -0400582 }
583 else
584 {
Luc Ferron1617e692018-07-11 11:08:19 -0400585 if (flipSource || flipDest)
586 {
Jamie Madilld754eb52018-07-19 14:55:03 -0400587 ANGLE_TRY(blitWithReadback(contextVk, readRenderTargetRect, blitDepthBuffer,
Luc Ferron1617e692018-07-11 11:08:19 -0400588 blitStencilBuffer, commandBuffer, readRenderTarget,
589 drawRenderTarget));
590 }
591 else
592 {
Jamie Madilld754eb52018-07-19 14:55:03 -0400593 blitWithCopy(commandBuffer, readRenderTargetRect, readRenderTarget,
594 drawRenderTarget, blitDepthBuffer, blitStencilBuffer);
Luc Ferron1617e692018-07-11 11:08:19 -0400595 }
Luc Ferron26581112018-06-21 09:43:08 -0400596 }
597 }
598
599 return gl::NoError();
600}
601
Jamie Madilld754eb52018-07-19 14:55:03 -0400602void FramebufferVk::blitWithCommand(vk::CommandBuffer *commandBuffer,
603 const gl::Rectangle &readRectIn,
604 const gl::Rectangle &drawRectIn,
605 RenderTargetVk *readRenderTarget,
606 RenderTargetVk *drawRenderTarget,
607 GLenum filter,
608 bool colorBlit,
609 bool depthBlit,
610 bool stencilBlit,
611 bool flipSource,
612 bool flipDest)
Luc Ferron26581112018-06-21 09:43:08 -0400613{
614 // Since blitRenderbufferRect is called for each render buffer that needs to be blitted,
615 // it should never be the case that both color and depth/stencil need to be blitted at
616 // at the same time.
617 ASSERT(colorBlit != (depthBlit || stencilBlit));
618
Luc Ferron26581112018-06-21 09:43:08 -0400619 const vk::Format &readImageFormat = readRenderTarget->getImageFormat();
620 VkImageAspectFlags aspectMask =
621 colorBlit ? VK_IMAGE_ASPECT_COLOR_BIT
622 : vk::GetDepthStencilAspectFlags(readImageFormat.textureFormat());
623 vk::ImageHelper *srcImage = readRenderTarget->getImageForRead(
Luc Ferron1617e692018-07-11 11:08:19 -0400624 this, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, commandBuffer);
Luc Ferron26581112018-06-21 09:43:08 -0400625
Jamie Madilld754eb52018-07-19 14:55:03 -0400626 const gl::Extents sourceFrameBufferExtents = readRenderTarget->getImageExtents();
627 gl::Rectangle readRect = readRectIn;
628
Luc Ferron82eda932018-07-09 15:10:22 -0400629 if (flipSource)
630 {
Jamie Madilld754eb52018-07-19 14:55:03 -0400631 readRect.y = sourceFrameBufferExtents.height - readRect.y - readRect.height;
Luc Ferron82eda932018-07-09 15:10:22 -0400632 }
633
Jamie Madillba365932018-07-18 17:23:46 -0400634 VkImageBlit blit = {};
635 blit.srcOffsets[0] = {readRect.x0(), flipSource ? readRect.y1() : readRect.y0(), 0};
636 blit.srcOffsets[1] = {readRect.x1(), flipSource ? readRect.y0() : readRect.y1(), 1};
637 blit.srcSubresource.aspectMask = aspectMask;
638 blit.srcSubresource.mipLevel = 0;
Luc Ferron26581112018-06-21 09:43:08 -0400639 blit.srcSubresource.baseArrayLayer = 0;
640 blit.srcSubresource.layerCount = 1;
641 blit.dstSubresource.aspectMask = aspectMask;
642 blit.dstSubresource.mipLevel = 0;
643 blit.dstSubresource.baseArrayLayer = 0;
644 blit.dstSubresource.layerCount = 1;
645
646 const gl::Extents &drawFrameBufferExtents = drawRenderTarget->getImageExtents();
Jamie Madilld754eb52018-07-19 14:55:03 -0400647 gl::Rectangle drawRect = drawRectIn;
Luc Ferron26581112018-06-21 09:43:08 -0400648
Luc Ferron82eda932018-07-09 15:10:22 -0400649 if (flipDest)
650 {
Jamie Madilld754eb52018-07-19 14:55:03 -0400651 drawRect.y = drawFrameBufferExtents.height - drawRect.y - drawRect.height;
Luc Ferron82eda932018-07-09 15:10:22 -0400652 }
653
Jamie Madilld754eb52018-07-19 14:55:03 -0400654 blit.dstOffsets[0] = {drawRect.x0(), flipDest ? drawRect.y1() : drawRect.y0(), 0};
655 blit.dstOffsets[1] = {drawRect.x1(), flipDest ? drawRect.y0() : drawRect.y1(), 1};
Luc Ferron26581112018-06-21 09:43:08 -0400656
657 vk::ImageHelper *dstImage = drawRenderTarget->getImageForWrite(this);
658
659 // Requirement of the copyImageToBuffer, the dst image must be in
660 // VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL layout.
661 dstImage->changeLayoutWithStages(aspectMask, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
662 VK_PIPELINE_STAGE_ALL_COMMANDS_BIT,
663 VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, commandBuffer);
664
665 commandBuffer->blitImage(srcImage->getImage(), VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
666 dstImage->getImage(), VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1, &blit,
667 gl_vk::GetFilter(filter));
Jamie Madill9e54b5a2016-05-25 12:57:39 -0400668}
669
Kenneth Russellce8602a2017-10-03 18:23:08 -0700670bool FramebufferVk::checkStatus(const gl::Context *context) const
Jamie Madill9e54b5a2016-05-25 12:57:39 -0400671{
Luc Ferron5bdf8bd2018-06-20 09:51:37 -0400672 // if we have both a depth and stencil buffer, they must refer to the same object
673 // since we only support packed_depth_stencil and not separate depth and stencil
674 if (mState.hasSeparateDepthAndStencilAttachments())
675 {
676 return false;
677 }
678
Jamie Madillb79e7bb2017-10-24 13:55:50 -0400679 return true;
Jamie Madill9e54b5a2016-05-25 12:57:39 -0400680}
681
Jamie Madill19fa1c62018-03-08 09:47:21 -0500682gl::Error FramebufferVk::syncState(const gl::Context *context,
683 const gl::Framebuffer::DirtyBits &dirtyBits)
Jamie Madill9e54b5a2016-05-25 12:57:39 -0400684{
Jamie Madille1f3ad42017-10-28 23:00:42 -0400685 ContextVk *contextVk = vk::GetImpl(context);
Jamie Madill7bd16662017-10-28 19:40:50 -0400686 RendererVk *renderer = contextVk->getRenderer();
Jamie Madilldd43e6c2017-03-24 14:18:49 -0400687
688 ASSERT(dirtyBits.any());
Jamie Madill57d9cbb2018-04-27 11:45:04 -0400689 for (size_t dirtyBit : dirtyBits)
690 {
691 switch (dirtyBit)
692 {
693 case gl::Framebuffer::DIRTY_BIT_DEPTH_ATTACHMENT:
694 case gl::Framebuffer::DIRTY_BIT_STENCIL_ATTACHMENT:
695 ANGLE_TRY(mRenderTargetCache.updateDepthStencilRenderTarget(context, mState));
696 break;
697 case gl::Framebuffer::DIRTY_BIT_DRAW_BUFFERS:
698 case gl::Framebuffer::DIRTY_BIT_READ_BUFFER:
699 case gl::Framebuffer::DIRTY_BIT_DEFAULT_WIDTH:
700 case gl::Framebuffer::DIRTY_BIT_DEFAULT_HEIGHT:
701 case gl::Framebuffer::DIRTY_BIT_DEFAULT_SAMPLES:
702 case gl::Framebuffer::DIRTY_BIT_DEFAULT_FIXED_SAMPLE_LOCATIONS:
703 break;
704 default:
705 {
706 ASSERT(gl::Framebuffer::DIRTY_BIT_COLOR_ATTACHMENT_0 == 0 &&
707 dirtyBit < gl::Framebuffer::DIRTY_BIT_COLOR_ATTACHMENT_MAX);
708 size_t colorIndex =
709 static_cast<size_t>(dirtyBit - gl::Framebuffer::DIRTY_BIT_COLOR_ATTACHMENT_0);
710 ANGLE_TRY(mRenderTargetCache.updateColorRenderTarget(context, mState, colorIndex));
Jamie Madill9aef3672018-04-27 11:45:06 -0400711
712 // Update cached masks for masked clears.
713 RenderTargetVk *renderTarget = mRenderTargetCache.getColors()[colorIndex];
714 if (renderTarget)
715 {
Luc Ferron5fd36932018-06-19 14:55:50 -0400716 const angle::Format &emulatedFormat =
717 renderTarget->getImageFormat().textureFormat();
718 updateActiveColorMasks(
719 colorIndex, emulatedFormat.redBits > 0, emulatedFormat.greenBits > 0,
720 emulatedFormat.blueBits > 0, emulatedFormat.alphaBits > 0);
721
Luc Ferron5fd36932018-06-19 14:55:50 -0400722 const angle::Format &sourceFormat =
723 renderTarget->getImageFormat().angleFormat();
724 mEmulatedAlphaAttachmentMask.set(
725 colorIndex, sourceFormat.alphaBits == 0 && emulatedFormat.alphaBits > 0);
Luc Ferron0bb940a2018-06-22 09:59:34 -0400726
727 contextVk->updateColorMask(context->getGLState().getBlendState());
Jamie Madill9aef3672018-04-27 11:45:06 -0400728 }
729 else
730 {
Jamie Madill58675012018-05-22 14:54:07 -0400731 updateActiveColorMasks(colorIndex, false, false, false, false);
Jamie Madill9aef3672018-04-27 11:45:06 -0400732 }
Jamie Madill57d9cbb2018-04-27 11:45:04 -0400733 break;
734 }
735 }
736 }
Jamie Madill66546be2018-03-08 09:47:20 -0500737
Jamie Madill9aef3672018-04-27 11:45:06 -0400738 mActiveColorComponents = gl_vk::GetColorComponentFlags(
Luc Ferron5fd36932018-06-19 14:55:50 -0400739 mActiveColorComponentMasksForClear[0].any(), mActiveColorComponentMasksForClear[1].any(),
740 mActiveColorComponentMasksForClear[2].any(), mActiveColorComponentMasksForClear[3].any());
Jamie Madill9aef3672018-04-27 11:45:06 -0400741
Jamie Madill9f2a8612017-11-30 12:43:09 -0500742 mRenderPassDesc.reset();
Jamie Madillc57ee252018-05-30 19:53:48 -0400743 renderer->releaseObject(getStoredQueueSerial(), &mFramebuffer);
Jamie Madill49ac74b2017-12-21 14:42:33 -0500744
Jamie Madill316c6062018-05-29 10:49:45 -0400745 // Will freeze the current set of dependencies on this FBO. The next time we render we will
Jamie Madilla5e06072018-05-18 14:36:05 -0400746 // create a new entry in the command graph.
Jamie Madill316c6062018-05-29 10:49:45 -0400747 onResourceChanged(renderer);
Jamie Madill72106562017-03-24 14:18:50 -0400748
Jamie Madill72106562017-03-24 14:18:50 -0400749 contextVk->invalidateCurrentPipeline();
Jamie Madill19fa1c62018-03-08 09:47:21 -0500750
751 return gl::NoError();
Jamie Madillab9f9c32017-01-17 17:47:34 -0500752}
753
Jamie Madillb90779e2018-04-27 11:45:01 -0400754const vk::RenderPassDesc &FramebufferVk::getRenderPassDesc()
Jamie Madillab9f9c32017-01-17 17:47:34 -0500755{
Jamie Madill9f2a8612017-11-30 12:43:09 -0500756 if (mRenderPassDesc.valid())
Jamie Madillab9f9c32017-01-17 17:47:34 -0500757 {
Jamie Madill9f2a8612017-11-30 12:43:09 -0500758 return mRenderPassDesc.value();
Jamie Madillab9f9c32017-01-17 17:47:34 -0500759 }
760
Jamie Madill0b684ce2017-11-23 12:57:39 -0500761 vk::RenderPassDesc desc;
Jamie Madillab9f9c32017-01-17 17:47:34 -0500762
Jamie Madill66546be2018-03-08 09:47:20 -0500763 // TODO(jmadill): Support gaps in RenderTargets. http://anglebug.com/2394
764 const auto &colorRenderTargets = mRenderTargetCache.getColors();
765 for (size_t colorIndex : mState.getEnabledDrawBuffers())
Jamie Madillab9f9c32017-01-17 17:47:34 -0500766 {
Jamie Madill66546be2018-03-08 09:47:20 -0500767 RenderTargetVk *colorRenderTarget = colorRenderTargets[colorIndex];
768 ASSERT(colorRenderTarget);
Jamie Madillbcf467f2018-05-23 09:46:00 -0400769 desc.packColorAttachment(colorRenderTarget->getImage());
Jamie Madillab9f9c32017-01-17 17:47:34 -0500770 }
771
Jamie Madill66546be2018-03-08 09:47:20 -0500772 RenderTargetVk *depthStencilRenderTarget = mRenderTargetCache.getDepthStencil();
773 if (depthStencilRenderTarget)
Jamie Madillab9f9c32017-01-17 17:47:34 -0500774 {
Jamie Madillbcf467f2018-05-23 09:46:00 -0400775 desc.packDepthStencilAttachment(depthStencilRenderTarget->getImage());
Jamie Madillab9f9c32017-01-17 17:47:34 -0500776 }
777
Jamie Madill9f2a8612017-11-30 12:43:09 -0500778 mRenderPassDesc = desc;
779 return mRenderPassDesc.value();
Jamie Madillab9f9c32017-01-17 17:47:34 -0500780}
781
Jamie Madill21061022018-07-12 23:56:30 -0400782angle::Result FramebufferVk::getFramebuffer(ContextVk *contextVk, vk::Framebuffer **framebufferOut)
Jamie Madillab9f9c32017-01-17 17:47:34 -0500783{
784 // If we've already created our cached Framebuffer, return it.
Jamie Madilldd43e6c2017-03-24 14:18:49 -0400785 if (mFramebuffer.valid())
Jamie Madillab9f9c32017-01-17 17:47:34 -0500786 {
Jamie Madill55981482018-07-11 09:01:18 -0400787 *framebufferOut = &mFramebuffer;
Jamie Madill21061022018-07-12 23:56:30 -0400788 return angle::Result::Continue();
Jamie Madillab9f9c32017-01-17 17:47:34 -0500789 }
790
Jamie Madillb90779e2018-04-27 11:45:01 -0400791 const vk::RenderPassDesc &desc = getRenderPassDesc();
Jamie Madill9f2a8612017-11-30 12:43:09 -0500792
Jamie Madillab9f9c32017-01-17 17:47:34 -0500793 vk::RenderPass *renderPass = nullptr;
Jamie Madill21061022018-07-12 23:56:30 -0400794 ANGLE_TRY(contextVk->getRenderer()->getCompatibleRenderPass(contextVk, desc, &renderPass));
Jamie Madillab9f9c32017-01-17 17:47:34 -0500795
796 // If we've a Framebuffer provided by a Surface (default FBO/backbuffer), query it.
797 if (mBackbuffer)
798 {
Jamie Madill21061022018-07-12 23:56:30 -0400799 return mBackbuffer->getCurrentFramebuffer(contextVk, *renderPass, framebufferOut);
Jamie Madillab9f9c32017-01-17 17:47:34 -0500800 }
801
802 // Gather VkImageViews over all FBO attachments, also size of attached region.
803 std::vector<VkImageView> attachments;
804 gl::Extents attachmentsSize;
805
Jamie Madill66546be2018-03-08 09:47:20 -0500806 // TODO(jmadill): Support gaps in RenderTargets. http://anglebug.com/2394
807 const auto &colorRenderTargets = mRenderTargetCache.getColors();
808 for (size_t colorIndex : mState.getEnabledDrawBuffers())
Jamie Madillab9f9c32017-01-17 17:47:34 -0500809 {
Jamie Madill66546be2018-03-08 09:47:20 -0500810 RenderTargetVk *colorRenderTarget = colorRenderTargets[colorIndex];
811 ASSERT(colorRenderTarget);
Jamie Madillbcf467f2018-05-23 09:46:00 -0400812 attachments.push_back(colorRenderTarget->getImageView()->getHandle());
Jamie Madillab9f9c32017-01-17 17:47:34 -0500813
Jamie Madillbcf467f2018-05-23 09:46:00 -0400814 ASSERT(attachmentsSize.empty() || attachmentsSize == colorRenderTarget->getImageExtents());
815 attachmentsSize = colorRenderTarget->getImageExtents();
Jamie Madillab9f9c32017-01-17 17:47:34 -0500816 }
817
Jamie Madill66546be2018-03-08 09:47:20 -0500818 RenderTargetVk *depthStencilRenderTarget = mRenderTargetCache.getDepthStencil();
819 if (depthStencilRenderTarget)
Jamie Madillab9f9c32017-01-17 17:47:34 -0500820 {
Jamie Madillbcf467f2018-05-23 09:46:00 -0400821 attachments.push_back(depthStencilRenderTarget->getImageView()->getHandle());
Jamie Madillab9f9c32017-01-17 17:47:34 -0500822
Jamie Madillbc543422018-03-30 10:43:19 -0400823 ASSERT(attachmentsSize.empty() ||
Jamie Madillbcf467f2018-05-23 09:46:00 -0400824 attachmentsSize == depthStencilRenderTarget->getImageExtents());
825 attachmentsSize = depthStencilRenderTarget->getImageExtents();
Jamie Madillab9f9c32017-01-17 17:47:34 -0500826 }
827
828 ASSERT(!attachments.empty());
829
830 VkFramebufferCreateInfo framebufferInfo;
831
832 framebufferInfo.sType = VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO;
833 framebufferInfo.pNext = nullptr;
834 framebufferInfo.flags = 0;
Jamie Madill9f2a8612017-11-30 12:43:09 -0500835 framebufferInfo.renderPass = renderPass->getHandle();
Jamie Madillab9f9c32017-01-17 17:47:34 -0500836 framebufferInfo.attachmentCount = static_cast<uint32_t>(attachments.size());
837 framebufferInfo.pAttachments = attachments.data();
838 framebufferInfo.width = static_cast<uint32_t>(attachmentsSize.width);
839 framebufferInfo.height = static_cast<uint32_t>(attachmentsSize.height);
840 framebufferInfo.layers = 1;
841
Jamie Madill21061022018-07-12 23:56:30 -0400842 ANGLE_TRY(mFramebuffer.init(contextVk, framebufferInfo));
Jamie Madill5deea722017-02-16 10:44:46 -0500843
Jamie Madill55981482018-07-11 09:01:18 -0400844 *framebufferOut = &mFramebuffer;
Jamie Madill21061022018-07-12 23:56:30 -0400845 return angle::Result::Continue();
Jamie Madill9e54b5a2016-05-25 12:57:39 -0400846}
847
Jamie Madill21061022018-07-12 23:56:30 -0400848angle::Result FramebufferVk::clearWithClearAttachments(ContextVk *contextVk,
849 bool clearColor,
850 bool clearDepth,
851 bool clearStencil)
Luc Ferron5242d5b2018-02-15 07:14:35 -0500852{
Jamie Madill316c6062018-05-29 10:49:45 -0400853 // Trigger a new command node to ensure overlapping writes happen sequentially.
854 onResourceChanged(contextVk->getRenderer());
Jamie Madill9aef3672018-04-27 11:45:06 -0400855
Luc Ferron5242d5b2018-02-15 07:14:35 -0500856 // This command can only happen inside a render pass, so obtain one if its already happening
857 // or create a new one if not.
Luc Ferron5242d5b2018-02-15 07:14:35 -0500858 vk::CommandBuffer *commandBuffer = nullptr;
Jamie Madill316c6062018-05-29 10:49:45 -0400859 vk::RecordingMode mode = vk::RecordingMode::Start;
860 ANGLE_TRY(getCommandBufferForDraw(contextVk, &commandBuffer, &mode));
Luc Ferron5242d5b2018-02-15 07:14:35 -0500861
Luc Ferrone4c38be2018-04-17 11:09:16 -0400862 // TODO(jmadill): Cube map attachments. http://anglebug.com/2470
863 // We assume for now that we always need to clear only 1 layer starting at the
864 // baseArrayLayer 0, this might need to change depending how we'll implement
865 // cube maps, 3d textures and array textures.
866 VkClearRect clearRect;
867 clearRect.baseArrayLayer = 0;
868 clearRect.layerCount = 1;
869
870 // When clearing, the scissor region must be clipped to the renderArea per the validation rules
871 // in Vulkan.
872 gl::Rectangle intersection;
Jamie Madill316c6062018-05-29 10:49:45 -0400873 if (!gl::ClipRectangle(contextVk->getGLState().getScissor(), getRenderPassRenderArea(),
Jamie Madill9aef3672018-04-27 11:45:06 -0400874 &intersection))
Luc Ferrone4c38be2018-04-17 11:09:16 -0400875 {
876 // There is nothing to clear since the scissor is outside of the render area.
Jamie Madill21061022018-07-12 23:56:30 -0400877 return angle::Result::Continue();
Luc Ferrone4c38be2018-04-17 11:09:16 -0400878 }
Luc Ferron1a135ad2018-07-04 10:35:31 -0400879
Luc Ferrone4c38be2018-04-17 11:09:16 -0400880 clearRect.rect = gl_vk::GetRect(intersection);
881
Luc Ferron82eda932018-07-09 15:10:22 -0400882 if (contextVk->isViewportFlipEnabledForDrawFBO())
Luc Ferron1a135ad2018-07-04 10:35:31 -0400883 {
884 clearRect.rect.offset.y = getRenderPassRenderArea().height - clearRect.rect.offset.y -
885 clearRect.rect.extent.height;
886 }
887
Luc Ferron5242d5b2018-02-15 07:14:35 -0500888 gl::AttachmentArray<VkClearAttachment> clearAttachments;
889 int clearAttachmentIndex = 0;
Luc Ferrona8af3a62018-03-29 14:44:24 -0400890
891 if (clearColor)
Luc Ferron5242d5b2018-02-15 07:14:35 -0500892 {
Luc Ferronf6e160f2018-06-12 10:13:57 -0400893 RenderTargetVk *renderTarget = getColorReadRenderTarget();
894 const vk::Format &format = renderTarget->getImageFormat();
895 VkClearValue modifiedClear = contextVk->getClearColorValue();
896
897 // We need to make sure we are not clearing the alpha channel if we are using a buffer
898 // format that doesn't have an alpha channel.
899 if (format.angleFormat().alphaBits == 0)
900 {
901 modifiedClear.color.float32[3] = 1.0;
902 }
903
Luc Ferrona8af3a62018-03-29 14:44:24 -0400904 // TODO(jmadill): Support gaps in RenderTargets. http://anglebug.com/2394
905 for (size_t colorIndex : mState.getEnabledDrawBuffers())
906 {
907 VkClearAttachment &clearAttachment = clearAttachments[clearAttachmentIndex];
908 clearAttachment.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
909 clearAttachment.colorAttachment = static_cast<uint32_t>(colorIndex);
Luc Ferronf6e160f2018-06-12 10:13:57 -0400910 clearAttachment.clearValue = modifiedClear;
Luc Ferrona8af3a62018-03-29 14:44:24 -0400911 ++clearAttachmentIndex;
912 }
913 }
914
915 if (clearDepth && clearStencil && mState.getDepthStencilAttachment() != nullptr)
916 {
917 // When we have a packed depth/stencil attachment we can do 1 clear for both when it
918 // applies.
Luc Ferron5242d5b2018-02-15 07:14:35 -0500919 VkClearAttachment &clearAttachment = clearAttachments[clearAttachmentIndex];
Luc Ferrona8af3a62018-03-29 14:44:24 -0400920 clearAttachment.aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT;
921 clearAttachment.colorAttachment = VK_ATTACHMENT_UNUSED;
922 clearAttachment.clearValue = contextVk->getClearDepthStencilValue();
Luc Ferron5242d5b2018-02-15 07:14:35 -0500923 ++clearAttachmentIndex;
924 }
Luc Ferrona8af3a62018-03-29 14:44:24 -0400925 else
926 {
927 if (clearDepth)
928 {
929 VkClearAttachment &clearAttachment = clearAttachments[clearAttachmentIndex];
930 clearAttachment.aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT;
931 clearAttachment.colorAttachment = VK_ATTACHMENT_UNUSED;
932 clearAttachment.clearValue = contextVk->getClearDepthStencilValue();
933 ++clearAttachmentIndex;
934 }
935
936 if (clearStencil)
937 {
938 VkClearAttachment &clearAttachment = clearAttachments[clearAttachmentIndex];
939 clearAttachment.aspectMask = VK_IMAGE_ASPECT_STENCIL_BIT;
940 clearAttachment.colorAttachment = VK_ATTACHMENT_UNUSED;
941 clearAttachment.clearValue = contextVk->getClearDepthStencilValue();
942 ++clearAttachmentIndex;
943 }
944 }
Luc Ferron5242d5b2018-02-15 07:14:35 -0500945
Luc Ferrona8af3a62018-03-29 14:44:24 -0400946 commandBuffer->clearAttachments(static_cast<uint32_t>(clearAttachmentIndex),
Luc Ferron5242d5b2018-02-15 07:14:35 -0500947 clearAttachments.data(), 1, &clearRect);
Jamie Madill21061022018-07-12 23:56:30 -0400948 return angle::Result::Continue();
Luc Ferron5242d5b2018-02-15 07:14:35 -0500949}
950
Jamie Madill21061022018-07-12 23:56:30 -0400951angle::Result FramebufferVk::clearWithDraw(ContextVk *contextVk,
952 VkColorComponentFlags colorMaskFlags)
Jamie Madill9aef3672018-04-27 11:45:06 -0400953{
954 RendererVk *renderer = contextVk->getRenderer();
955 vk::ShaderLibrary *shaderLibrary = renderer->getShaderLibrary();
956
Jamie Madill316c6062018-05-29 10:49:45 -0400957 // Trigger a new command node to ensure overlapping writes happen sequentially.
958 onResourceChanged(renderer);
959
Jamie Madill9aef3672018-04-27 11:45:06 -0400960 const vk::ShaderAndSerial *fullScreenQuad = nullptr;
Jamie Madill21061022018-07-12 23:56:30 -0400961 ANGLE_TRY(shaderLibrary->getShader(contextVk, vk::InternalShaderID::FullScreenQuad_vert,
Jamie Madill9aef3672018-04-27 11:45:06 -0400962 &fullScreenQuad));
963
jchen10be7f44f2018-05-21 14:35:32 +0800964 const vk::ShaderAndSerial *pushConstantColor = nullptr;
Jamie Madill21061022018-07-12 23:56:30 -0400965 ANGLE_TRY(shaderLibrary->getShader(contextVk, vk::InternalShaderID::PushConstantColor_frag,
jchen10be7f44f2018-05-21 14:35:32 +0800966 &pushConstantColor));
Jamie Madill9aef3672018-04-27 11:45:06 -0400967
Jamie Madilld668be92018-06-13 16:54:06 -0400968 // The shader uses a simple pipeline layout with a push constant range.
969 vk::PipelineLayoutDesc pipelineLayoutDesc;
970 pipelineLayoutDesc.updatePushConstantRange(gl::ShaderType::Fragment, 0,
971 sizeof(VkClearColorValue));
972
973 // The shader does not use any descriptor sets.
974 vk::DescriptorSetLayoutPointerArray descriptorSetLayouts;
975
976 vk::BindingPointer<vk::PipelineLayout> pipelineLayout;
Jamie Madill21061022018-07-12 23:56:30 -0400977 ANGLE_TRY(renderer->getPipelineLayout(contextVk, pipelineLayoutDesc, descriptorSetLayouts,
978 &pipelineLayout));
Jamie Madill9aef3672018-04-27 11:45:06 -0400979
Jamie Madill316c6062018-05-29 10:49:45 -0400980 vk::RecordingMode recordingMode = vk::RecordingMode::Start;
981 vk::CommandBuffer *drawCommands = nullptr;
982 ANGLE_TRY(getCommandBufferForDraw(contextVk, &drawCommands, &recordingMode));
Jamie Madill9aef3672018-04-27 11:45:06 -0400983
Jamie Madill316c6062018-05-29 10:49:45 -0400984 const gl::Rectangle &renderArea = getRenderPassRenderArea();
Luc Ferronb70ad522018-07-09 16:06:26 -0400985 bool invertViewport = contextVk->isViewportFlipEnabledForDrawFBO();
Jamie Madill9aef3672018-04-27 11:45:06 -0400986
987 // This pipeline desc could be cached.
988 vk::PipelineDesc pipelineDesc;
989 pipelineDesc.initDefaults();
Luc Ferron5fd36932018-06-19 14:55:50 -0400990 pipelineDesc.updateColorWriteMask(colorMaskFlags, getEmulatedAlphaAttachmentMask());
Jamie Madill9aef3672018-04-27 11:45:06 -0400991 pipelineDesc.updateRenderPassDesc(getRenderPassDesc());
Jamie Madill06ca6342018-07-12 15:56:53 -0400992 pipelineDesc.updateShaders(fullScreenQuad->getSerial(), pushConstantColor->getSerial());
Luc Ferron82eda932018-07-09 15:10:22 -0400993 pipelineDesc.updateViewport(this, renderArea, 0.0f, 1.0f, invertViewport);
Jamie Madill9aef3672018-04-27 11:45:06 -0400994
995 const gl::State &glState = contextVk->getGLState();
996 if (glState.isScissorTestEnabled())
997 {
998 gl::Rectangle intersection;
Jamie Madill316c6062018-05-29 10:49:45 -0400999 if (!gl::ClipRectangle(glState.getScissor(), renderArea, &intersection))
Jamie Madill9aef3672018-04-27 11:45:06 -04001000 {
Jamie Madill21061022018-07-12 23:56:30 -04001001 return angle::Result::Continue();
Jamie Madill9aef3672018-04-27 11:45:06 -04001002 }
1003
Luc Ferron82eda932018-07-09 15:10:22 -04001004 pipelineDesc.updateScissor(intersection, invertViewport, renderArea);
Jamie Madill9aef3672018-04-27 11:45:06 -04001005 }
1006 else
1007 {
Luc Ferron82eda932018-07-09 15:10:22 -04001008 pipelineDesc.updateScissor(renderArea, invertViewport, renderArea);
Jamie Madill9aef3672018-04-27 11:45:06 -04001009 }
1010
1011 vk::PipelineAndSerial *pipeline = nullptr;
Jamie Madill06ca6342018-07-12 15:56:53 -04001012 ANGLE_TRY(renderer->getPipeline(contextVk, *fullScreenQuad, *pushConstantColor,
1013 pipelineLayout.get(), pipelineDesc, gl::AttributesMask(),
1014 &pipeline));
Jamie Madill9aef3672018-04-27 11:45:06 -04001015 pipeline->updateSerial(renderer->getCurrentQueueSerial());
1016
Jamie Madill316c6062018-05-29 10:49:45 -04001017 vk::CommandBuffer *writeCommands = nullptr;
Jamie Madill21061022018-07-12 23:56:30 -04001018 ANGLE_TRY(appendWriteResource(contextVk, &writeCommands));
Jamie Madill9aef3672018-04-27 11:45:06 -04001019
Luc Ferron66c2f4a2018-06-19 10:27:57 -04001020 // If the format of the framebuffer does not have an alpha channel, we need to make sure we does
1021 // not affect the alpha channel of the type we're using to emulate the format.
1022 // TODO(jmadill): Implement EXT_draw_buffers http://anglebug.com/2394
1023 RenderTargetVk *renderTarget = mRenderTargetCache.getColors()[0];
1024 ASSERT(renderTarget);
1025
1026 const vk::Format &imageFormat = renderTarget->getImageFormat();
jchen10be7f44f2018-05-21 14:35:32 +08001027 VkClearColorValue clearColorValue = contextVk->getClearColorValue().color;
Luc Ferron66c2f4a2018-06-19 10:27:57 -04001028 bool overrideAlphaWithOne =
1029 imageFormat.textureFormat().alphaBits > 0 && imageFormat.angleFormat().alphaBits == 0;
1030 clearColorValue.float32[3] = overrideAlphaWithOne ? 1.0f : clearColorValue.float32[3];
1031
Jamie Madilld668be92018-06-13 16:54:06 -04001032 drawCommands->pushConstants(pipelineLayout.get(), VK_SHADER_STAGE_FRAGMENT_BIT, 0,
Jamie Madill316c6062018-05-29 10:49:45 -04001033 sizeof(VkClearColorValue), clearColorValue.float32);
Jamie Madill9aef3672018-04-27 11:45:06 -04001034
1035 // TODO(jmadill): Masked combined color and depth/stencil clear. http://anglebug.com/2455
1036 // Any active queries submitted by the user should also be paused here.
Jamie Madill316c6062018-05-29 10:49:45 -04001037 drawCommands->bindPipeline(VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline->get());
1038 drawCommands->draw(6, 1, 0, 0);
Jamie Madill9aef3672018-04-27 11:45:06 -04001039
Jamie Madill21061022018-07-12 23:56:30 -04001040 return angle::Result::Continue();
Jamie Madill9aef3672018-04-27 11:45:06 -04001041}
1042
Geoff Lang13455072018-05-09 11:24:43 -04001043gl::Error FramebufferVk::getSamplePosition(const gl::Context *context,
1044 size_t index,
1045 GLfloat *xy) const
JiangYizhoubddc46b2016-12-09 09:50:51 +08001046{
1047 UNIMPLEMENTED();
1048 return gl::InternalError() << "getSamplePosition is unimplemented.";
1049}
1050
Jamie Madill21061022018-07-12 23:56:30 -04001051angle::Result FramebufferVk::getCommandBufferForDraw(ContextVk *contextVk,
1052 vk::CommandBuffer **commandBufferOut,
1053 vk::RecordingMode *modeOut)
Jamie Madilldf68a6f2017-01-13 17:29:53 -05001054{
Jamie Madill49ac74b2017-12-21 14:42:33 -05001055 RendererVk *renderer = contextVk->getRenderer();
Jamie Madillbef918c2017-12-13 13:11:30 -05001056
Jamie Madill316c6062018-05-29 10:49:45 -04001057 // This will clear the current write operation if it is complete.
Jamie Madill5dca6512018-05-30 10:53:51 -04001058 if (appendToStartedRenderPass(renderer, commandBufferOut))
Jamie Madill4c26fc22017-02-24 11:04:10 -05001059 {
Jamie Madill316c6062018-05-29 10:49:45 -04001060 *modeOut = vk::RecordingMode::Append;
Jamie Madill21061022018-07-12 23:56:30 -04001061 return angle::Result::Continue();
Jamie Madill9cceac42018-03-31 14:19:16 -04001062 }
Jamie Madill4c26fc22017-02-24 11:04:10 -05001063
Jamie Madilldf68a6f2017-01-13 17:29:53 -05001064 vk::Framebuffer *framebuffer = nullptr;
Jamie Madill21061022018-07-12 23:56:30 -04001065 ANGLE_TRY(getFramebuffer(contextVk, &framebuffer));
Jamie Madilldf68a6f2017-01-13 17:29:53 -05001066
Jamie Madill316c6062018-05-29 10:49:45 -04001067 // TODO(jmadill): Proper clear value implementation. http://anglebug.com/2361
Jamie Madilldf68a6f2017-01-13 17:29:53 -05001068 std::vector<VkClearValue> attachmentClearValues;
Jamie Madilldf68a6f2017-01-13 17:29:53 -05001069
Jamie Madill316c6062018-05-29 10:49:45 -04001070 vk::CommandBuffer *writeCommands = nullptr;
Jamie Madill21061022018-07-12 23:56:30 -04001071 ANGLE_TRY(appendWriteResource(contextVk, &writeCommands));
Jamie Madille4c5a232018-03-02 21:00:31 -05001072
Jamie Madillbcf467f2018-05-23 09:46:00 -04001073 vk::RenderPassDesc renderPassDesc;
1074
Jamie Madill49ac74b2017-12-21 14:42:33 -05001075 // Initialize RenderPass info.
Jamie Madill66546be2018-03-08 09:47:20 -05001076 // TODO(jmadill): Support gaps in RenderTargets. http://anglebug.com/2394
1077 const auto &colorRenderTargets = mRenderTargetCache.getColors();
1078 for (size_t colorIndex : mState.getEnabledDrawBuffers())
Jamie Madill4c26fc22017-02-24 11:04:10 -05001079 {
Jamie Madill66546be2018-03-08 09:47:20 -05001080 RenderTargetVk *colorRenderTarget = colorRenderTargets[colorIndex];
1081 ASSERT(colorRenderTarget);
Jamie Madill49ac74b2017-12-21 14:42:33 -05001082
Jamie Madill316c6062018-05-29 10:49:45 -04001083 colorRenderTarget->onColorDraw(this, writeCommands, &renderPassDesc);
Jamie Madill66546be2018-03-08 09:47:20 -05001084 attachmentClearValues.emplace_back(contextVk->getClearColorValue());
1085 }
1086
1087 RenderTargetVk *depthStencilRenderTarget = mRenderTargetCache.getDepthStencil();
1088 if (depthStencilRenderTarget)
1089 {
Jamie Madill316c6062018-05-29 10:49:45 -04001090 depthStencilRenderTarget->onDepthStencilDraw(this, writeCommands, &renderPassDesc);
Jamie Madillf4d693c2018-02-14 16:38:16 -05001091 attachmentClearValues.emplace_back(contextVk->getClearDepthStencilValue());
Jamie Madill49ac74b2017-12-21 14:42:33 -05001092 }
1093
Luc Ferrond17bdfe2018-04-05 13:50:10 -04001094 gl::Rectangle renderArea =
1095 gl::Rectangle(0, 0, mState.getDimensions().width, mState.getDimensions().height);
Jamie Madill49ac74b2017-12-21 14:42:33 -05001096
Jamie Madill316c6062018-05-29 10:49:45 -04001097 *modeOut = vk::RecordingMode::Start;
Jamie Madill21061022018-07-12 23:56:30 -04001098 return beginRenderPass(contextVk, *framebuffer, renderArea, mRenderPassDesc.value(),
Jamie Madill316c6062018-05-29 10:49:45 -04001099 attachmentClearValues, commandBufferOut);
Jamie Madilldf68a6f2017-01-13 17:29:53 -05001100}
1101
Jamie Madill9aef3672018-04-27 11:45:06 -04001102void FramebufferVk::updateActiveColorMasks(size_t colorIndex, bool r, bool g, bool b, bool a)
1103{
Luc Ferron5fd36932018-06-19 14:55:50 -04001104 mActiveColorComponentMasksForClear[0].set(colorIndex, r);
1105 mActiveColorComponentMasksForClear[1].set(colorIndex, g);
1106 mActiveColorComponentMasksForClear[2].set(colorIndex, b);
1107 mActiveColorComponentMasksForClear[3].set(colorIndex, a);
1108}
1109
1110gl::DrawBufferMask FramebufferVk::getEmulatedAlphaAttachmentMask()
1111{
1112 return mEmulatedAlphaAttachmentMask;
Jamie Madill9aef3672018-04-27 11:45:06 -04001113}
Luc Ferron018709f2018-05-10 13:53:11 -04001114
Jamie Madill21061022018-07-12 23:56:30 -04001115angle::Result FramebufferVk::readPixelsImpl(ContextVk *contextVk,
1116 const gl::Rectangle &area,
1117 const PackPixelsParams &packPixelsParams,
1118 const VkImageAspectFlags &copyAspectFlags,
1119 RenderTargetVk *renderTarget,
1120 void *pixels)
Luc Ferron018709f2018-05-10 13:53:11 -04001121{
Jamie Madill58675012018-05-22 14:54:07 -04001122 RendererVk *renderer = contextVk->getRenderer();
1123
Jamie Madill58675012018-05-22 14:54:07 -04001124 vk::CommandBuffer *commandBuffer = nullptr;
Jamie Madill21061022018-07-12 23:56:30 -04001125 ANGLE_TRY(beginWriteResource(contextVk, &commandBuffer));
Jamie Madill58675012018-05-22 14:54:07 -04001126
Jamie Madillbcf467f2018-05-23 09:46:00 -04001127 // Note that although we're reading from the image, we need to update the layout below.
Luc Ferron1617e692018-07-11 11:08:19 -04001128
1129 vk::ImageHelper *srcImage =
1130 renderTarget->getImageForRead(this, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, commandBuffer);
Jamie Madillbcf467f2018-05-23 09:46:00 -04001131
1132 const angle::Format &angleFormat = srcImage->getFormat().textureFormat();
Luc Ferron1617e692018-07-11 11:08:19 -04001133
1134 GLuint pixelBytes = angleFormat.pixelBytes;
1135
1136 // If we're copying only the stencil bits, we need to adjust the allocation size and the source
1137 // pitch because in Vulkan, if we copy the stencil out of a D24S8 texture, the stencil will be
1138 // tightly packed in an S8 buffer (as specified in the spec here
1139 // https://www.khronos.org/registry/vulkan/specs/1.1-extensions/man/html/VkBufferImageCopy.html)
1140 if (copyAspectFlags == VK_IMAGE_ASPECT_STENCIL_BIT)
1141 {
1142 pixelBytes = angleFormat.stencilBits / 8;
1143 }
1144
Jamie Madillba365932018-07-18 17:23:46 -04001145 VkBuffer bufferHandle = VK_NULL_HANDLE;
1146 uint8_t *readPixelBuffer = nullptr;
1147 bool newBufferAllocated = false;
1148 uint32_t stagingOffset = 0;
1149 size_t allocationSize = area.width * pixelBytes * area.height;
Luc Ferron018709f2018-05-10 13:53:11 -04001150
Jamie Madilld754eb52018-07-19 14:55:03 -04001151 ANGLE_TRY(mReadPixelBuffer.allocate(contextVk, allocationSize, &readPixelBuffer, &bufferHandle,
1152 &stagingOffset, &newBufferAllocated));
Luc Ferron018709f2018-05-10 13:53:11 -04001153
Luc Ferron534b00d2018-05-18 08:16:53 -04001154 VkBufferImageCopy region;
1155 region.bufferImageHeight = area.height;
1156 region.bufferOffset = static_cast<VkDeviceSize>(stagingOffset);
1157 region.bufferRowLength = area.width;
1158 region.imageExtent.width = area.width;
1159 region.imageExtent.height = area.height;
1160 region.imageExtent.depth = 1;
1161 region.imageOffset.x = area.x;
1162 region.imageOffset.y = area.y;
1163 region.imageOffset.z = 0;
Luc Ferron1617e692018-07-11 11:08:19 -04001164 region.imageSubresource.aspectMask = copyAspectFlags;
Luc Ferron534b00d2018-05-18 08:16:53 -04001165 region.imageSubresource.baseArrayLayer = 0;
1166 region.imageSubresource.layerCount = 1;
1167 region.imageSubresource.mipLevel = 0;
1168
Jamie Madillbcf467f2018-05-23 09:46:00 -04001169 commandBuffer->copyImageToBuffer(srcImage->getImage(), srcImage->getCurrentLayout(),
1170 bufferHandle, 1, &region);
Luc Ferron018709f2018-05-10 13:53:11 -04001171
1172 // Triggers a full finish.
1173 // TODO(jmadill): Don't block on asynchronous readback.
Jamie Madill21061022018-07-12 23:56:30 -04001174 ANGLE_TRY(renderer->finish(contextVk));
Luc Ferron018709f2018-05-10 13:53:11 -04001175
Luc Ferron534b00d2018-05-18 08:16:53 -04001176 // The buffer we copied to needs to be invalidated before we read from it because its not been
1177 // created with the host coherent bit.
Jamie Madilld754eb52018-07-19 14:55:03 -04001178 ANGLE_TRY(mReadPixelBuffer.invalidate(contextVk));
Yuly Novikov6c6c76c2018-05-17 18:45:06 +00001179
Luc Ferron1617e692018-07-11 11:08:19 -04001180 PackPixels(packPixelsParams, angleFormat, area.width * pixelBytes, readPixelBuffer,
Rafael Cintron05a449a2018-06-20 18:08:04 -07001181 static_cast<uint8_t *>(pixels));
Luc Ferron018709f2018-05-10 13:53:11 -04001182
Jamie Madill21061022018-07-12 23:56:30 -04001183 return angle::Result::Continue();
Luc Ferron018709f2018-05-10 13:53:11 -04001184}
Jamie Madill58675012018-05-22 14:54:07 -04001185
1186const gl::Extents &FramebufferVk::getReadImageExtents() const
1187{
Jamie Madillbcf467f2018-05-23 09:46:00 -04001188 return getColorReadRenderTarget()->getImageExtents();
Jamie Madill58675012018-05-22 14:54:07 -04001189}
Jamie Madill9e54b5a2016-05-25 12:57:39 -04001190} // namespace rx