src/libANGLE/renderer/vulkan/FramebufferVk.cpp - platform/external/angle - Git at Google

 //
 // Copyright 2016 The ANGLE Project Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 //
 // FramebufferVk.cpp:
 //    Implements the class methods for FramebufferVk.
 //

 #include "libANGLE/renderer/vulkan/FramebufferVk.h"

 #include <vulkan/vulkan.h>
 #include <array>

 #include "common/debug.h"
 #include "image_util/imageformats.h"
 #include "libANGLE/Context.h"
 #include "libANGLE/Display.h"
 #include "libANGLE/formatutils.h"
 #include "libANGLE/renderer/renderer_utils.h"
 #include "libANGLE/renderer/vulkan/CommandBufferNode.h"
 #include "libANGLE/renderer/vulkan/ContextVk.h"
 #include "libANGLE/renderer/vulkan/DisplayVk.h"
 #include "libANGLE/renderer/vulkan/RenderTargetVk.h"
 #include "libANGLE/renderer/vulkan/RendererVk.h"
 #include "libANGLE/renderer/vulkan/SurfaceVk.h"
 #include "libANGLE/renderer/vulkan/vk_format_utils.h"

 namespace rx
 {

 namespace
 {
 gl::ErrorOrResult<const gl::InternalFormat *> GetReadAttachmentInfo(
     const gl::Context *context,
     const gl::FramebufferAttachment *readAttachment)
 {
     RenderTargetVk *renderTarget = nullptr;
     ANGLE_TRY(readAttachment->getRenderTarget(context, &renderTarget));

     GLenum implFormat = renderTarget->format->textureFormat().fboImplementationInternalFormat;
     return &gl::GetSizedInternalFormatInfo(implFormat);
 }
 }  // anonymous namespace

 // static
 FramebufferVk *FramebufferVk::CreateUserFBO(const gl::FramebufferState &state)
 {
     return new FramebufferVk(state);
 }

 // static
 FramebufferVk *FramebufferVk::CreateDefaultFBO(const gl::FramebufferState &state,
                                                WindowSurfaceVk *backbuffer)
 {
     return new FramebufferVk(state, backbuffer);
 }

 FramebufferVk::FramebufferVk(const gl::FramebufferState &state)
     : FramebufferImpl(state),
       mBackbuffer(nullptr),
       mRenderPassDesc(),
       mFramebuffer(),
       mLastRenderNodeSerial()
 {
 }

 FramebufferVk::FramebufferVk(const gl::FramebufferState &state, WindowSurfaceVk *backbuffer)
     : FramebufferImpl(state),
       mBackbuffer(backbuffer),
       mRenderPassDesc(),
       mFramebuffer(),
       mLastRenderNodeSerial()
 {
 }

 FramebufferVk::~FramebufferVk()
 {
 }

 void FramebufferVk::destroy(const gl::Context *context)
 {
     RendererVk *renderer = vk::GetImpl(context)->getRenderer();

     renderer->releaseResource(*this, &mFramebuffer);
 }

 void FramebufferVk::destroyDefault(const egl::Display *display)
 {
     VkDevice device = vk::GetImpl(display)->getRenderer()->getDevice();

     mFramebuffer.destroy(device);
 }

 gl::Error FramebufferVk::discard(const gl::Context *context,
                                  size_t count,
                                  const GLenum *attachments)
 {
     UNIMPLEMENTED();
     return gl::InternalError();
 }

 gl::Error FramebufferVk::invalidate(const gl::Context *context,
                                     size_t count,
                                     const GLenum *attachments)
 {
     UNIMPLEMENTED();
     return gl::InternalError();
 }

 gl::Error FramebufferVk::invalidateSub(const gl::Context *context,
                                        size_t count,
                                        const GLenum *attachments,
                                        const gl::Rectangle &area)
 {
     UNIMPLEMENTED();
     return gl::InternalError();
 }

 gl::Error FramebufferVk::clear(const gl::Context *context, GLbitfield mask)
 {
     if (mState.getDepthAttachment() && (mask & GL_DEPTH_BUFFER_BIT) != 0)
     {
         // TODO(jmadill): Depth clear
         UNIMPLEMENTED();
     }

     if (mState.getStencilAttachment() && (mask & GL_STENCIL_BUFFER_BIT) != 0)
     {
         // TODO(jmadill): Stencil clear
         UNIMPLEMENTED();
     }

     if ((mask & GL_COLOR_BUFFER_BIT) == 0)
     {
         return gl::NoError();
     }

     const auto &glState    = context->getGLState();
     const auto &clearColor = glState.getColorClearValue();
     VkClearColorValue clearColorValue;
     clearColorValue.float32[0] = clearColor.red;
     clearColorValue.float32[1] = clearColor.green;
     clearColorValue.float32[2] = clearColor.blue;
     clearColorValue.float32[3] = clearColor.alpha;

     // TODO(jmadill): Scissored clears.
     const auto *attachment = mState.getFirstNonNullAttachment();
     ASSERT(attachment && attachment->isAttached());
     const auto &size = attachment->getSize();
     const gl::Rectangle renderArea(0, 0, size.width, size.height);

     RendererVk *renderer = vk::GetImpl(context)->getRenderer();

     vk::CommandBuffer *commandBuffer = nullptr;
     ANGLE_TRY(recordWriteCommands(renderer, &commandBuffer));

     Serial currentSerial = renderer->getCurrentQueueSerial();

     for (const auto &colorAttachment : mState.getColorAttachments())
     {
         if (colorAttachment.isAttached())
         {
             RenderTargetVk *renderTarget = nullptr;
             ANGLE_TRY(colorAttachment.getRenderTarget(context, &renderTarget));

             renderTarget->resource->setWriteNode(getCurrentWriteNode(currentSerial), currentSerial);

             renderTarget->image->changeLayoutWithStages(
                 VK_IMAGE_ASPECT_COLOR_BIT, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
                 VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, commandBuffer);

             commandBuffer->clearSingleColorImage(*renderTarget->image, clearColorValue);
         }
     }

     // TODO(jmadill): Depth/stencil clear.

     return gl::NoError();
 }

 gl::Error FramebufferVk::clearBufferfv(const gl::Context *context,
                                        GLenum buffer,
                                        GLint drawbuffer,
                                        const GLfloat *values)
 {
     UNIMPLEMENTED();
     return gl::InternalError();
 }

 gl::Error FramebufferVk::clearBufferuiv(const gl::Context *context,
                                         GLenum buffer,
                                         GLint drawbuffer,
                                         const GLuint *values)
 {
     UNIMPLEMENTED();
     return gl::InternalError();
 }

 gl::Error FramebufferVk::clearBufferiv(const gl::Context *context,
                                        GLenum buffer,
                                        GLint drawbuffer,
                                        const GLint *values)
 {
     UNIMPLEMENTED();
     return gl::InternalError();
 }

 gl::Error FramebufferVk::clearBufferfi(const gl::Context *context,
                                        GLenum buffer,
                                        GLint drawbuffer,
                                        GLfloat depth,
                                        GLint stencil)
 {
     UNIMPLEMENTED();
     return gl::InternalError();
 }

 GLenum FramebufferVk::getImplementationColorReadFormat(const gl::Context *context) const
 {
     auto errOrResult = GetReadAttachmentInfo(context, mState.getReadAttachment());

     // TODO(jmadill): Handle getRenderTarget error.
     if (errOrResult.isError())
     {
         ERR() << "Internal error in FramebufferVk::getImplementationColorReadFormat.";
         return GL_NONE;
     }

     return errOrResult.getResult()->format;
 }

 GLenum FramebufferVk::getImplementationColorReadType(const gl::Context *context) const
 {
     auto errOrResult = GetReadAttachmentInfo(context, mState.getReadAttachment());

     // TODO(jmadill): Handle getRenderTarget error.
     if (errOrResult.isError())
     {
         ERR() << "Internal error in FramebufferVk::getImplementationColorReadFormat.";
         return GL_NONE;
     }

     return errOrResult.getResult()->type;
 }

 gl::Error FramebufferVk::readPixels(const gl::Context *context,
                                     const gl::Rectangle &area,
                                     GLenum format,
                                     GLenum type,
                                     void *pixels)
 {
     const auto &glState         = context->getGLState();
     const auto *readFramebuffer = glState.getReadFramebuffer();
     const auto *readAttachment  = readFramebuffer->getReadColorbuffer();

     RenderTargetVk *renderTarget = nullptr;
     ANGLE_TRY(readAttachment->getRenderTarget(context, &renderTarget));

     ContextVk *contextVk = vk::GetImpl(context);
     RendererVk *renderer = contextVk->getRenderer();
     VkDevice device      = renderer->getDevice();

     vk::Image *readImage = renderTarget->image;
     vk::StagingImage stagingImage;
     ANGLE_TRY(renderer->createStagingImage(TextureDimension::TEX_2D, *renderTarget->format,
                                            renderTarget->extents, vk::StagingUsage::Read,
                                            &stagingImage));

     vk::CommandBuffer *commandBuffer = nullptr;
     ANGLE_TRY(recordWriteCommands(renderer, &commandBuffer));

     stagingImage.getImage().changeLayoutTop(VK_IMAGE_ASPECT_COLOR_BIT, VK_IMAGE_LAYOUT_GENERAL,
                                             commandBuffer);

     readImage->changeLayoutWithStages(
         VK_IMAGE_ASPECT_COLOR_BIT, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
         VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, commandBuffer);

     VkImageCopy region;
     region.srcSubresource.aspectMask     = VK_IMAGE_ASPECT_COLOR_BIT;
     region.srcSubresource.mipLevel       = 0;
     region.srcSubresource.baseArrayLayer = 0;
     region.srcSubresource.layerCount     = 1;
     region.srcOffset.x                   = area.x;
     region.srcOffset.y                   = area.y;
     region.srcOffset.z                   = 0;
     region.dstSubresource.aspectMask     = VK_IMAGE_ASPECT_COLOR_BIT;
     region.dstSubresource.mipLevel       = 0;
     region.dstSubresource.baseArrayLayer = 0;
     region.dstSubresource.layerCount     = 1;
     region.dstOffset.x                   = 0;
     region.dstOffset.y                   = 0;
     region.dstOffset.z                   = 0;
     region.extent.width                  = area.width;
     region.extent.height                 = area.height;
     region.extent.depth                  = 1;

     commandBuffer->copyImage(*readImage, stagingImage.getImage(), 1, &region);

     // Triggers a full finish.
     // TODO(jmadill): Don't block on asynchronous readback.
     ANGLE_TRY(renderer->finish(context));

     // TODO(jmadill): parameters
     uint8_t *mapPointer = nullptr;
     ANGLE_TRY(
         stagingImage.getDeviceMemory().map(device, 0, stagingImage.getSize(), 0, &mapPointer));

     const auto &angleFormat = renderTarget->format->textureFormat();

     // TODO(jmadill): Use pixel bytes from the ANGLE format directly.
     const auto &glFormat = gl::GetSizedInternalFormatInfo(angleFormat.glInternalFormat);
     int inputPitch       = glFormat.pixelBytes * area.width;

     PackPixelsParams params;
     params.area        = area;
     params.format      = format;
     params.type        = type;
     params.outputPitch = inputPitch;
     params.packBuffer  = glState.getTargetBuffer(gl::BufferBinding::PixelPack);
     params.pack        = glState.getPackState();

     PackPixels(params, angleFormat, inputPitch, mapPointer, reinterpret_cast<uint8_t *>(pixels));

     stagingImage.getDeviceMemory().unmap(device);
     renderer->releaseObject(renderer->getCurrentQueueSerial(), &stagingImage);

     return vk::NoError();
 }

 gl::Error FramebufferVk::blit(const gl::Context *context,
                               const gl::Rectangle &sourceArea,
                               const gl::Rectangle &destArea,
                               GLbitfield mask,
                               GLenum filter)
 {
     UNIMPLEMENTED();
     return gl::InternalError();
 }

 bool FramebufferVk::checkStatus(const gl::Context *context) const
 {
     return true;
 }

 void FramebufferVk::syncState(const gl::Context *context,
                               const gl::Framebuffer::DirtyBits &dirtyBits)
 {
     ContextVk *contextVk = vk::GetImpl(context);
     RendererVk *renderer = contextVk->getRenderer();

     ASSERT(dirtyBits.any());

     // TODO(jmadill): Smarter update.
     mRenderPassDesc.reset();
     renderer->releaseResource(*this, &mFramebuffer);

     // Trigger a new set of secondary commands next time we render to this FBO,.
     mLastRenderNodeSerial = Serial();

     contextVk->invalidateCurrentPipeline();
 }

 const vk::RenderPassDesc &FramebufferVk::getRenderPassDesc(const gl::Context *context)
 {
     if (mRenderPassDesc.valid())
     {
         return mRenderPassDesc.value();
     }

     vk::RenderPassDesc desc;

     const auto &colorAttachments = mState.getColorAttachments();
     for (size_t attachmentIndex = 0; attachmentIndex < colorAttachments.size(); ++attachmentIndex)
     {
         const auto &colorAttachment = colorAttachments[attachmentIndex];
         if (colorAttachment.isAttached())
         {
             RenderTargetVk *renderTarget = nullptr;
             ANGLE_SWALLOW_ERR(colorAttachment.getRenderTarget(context, &renderTarget));
             desc.packColorAttachment(*renderTarget->format, colorAttachment.getSamples());
         }
     }

     const auto *depthStencilAttachment = mState.getDepthStencilAttachment();

     if (depthStencilAttachment && depthStencilAttachment->isAttached())
     {
         RenderTargetVk *renderTarget = nullptr;
         ANGLE_SWALLOW_ERR(depthStencilAttachment->getRenderTarget(context, &renderTarget));
         desc.packDepthStencilAttachment(*renderTarget->format,
                                         depthStencilAttachment->getSamples());
     }

     mRenderPassDesc = desc;
     return mRenderPassDesc.value();
 }

 gl::ErrorOrResult<vk::Framebuffer *> FramebufferVk::getFramebuffer(const gl::Context *context,
                                                                    RendererVk *rendererVk)
 {
     // If we've already created our cached Framebuffer, return it.
     if (mFramebuffer.valid())
     {
         return &mFramebuffer;
     }

     const vk::RenderPassDesc &desc = getRenderPassDesc(context);

     vk::RenderPass *renderPass = nullptr;
     ANGLE_TRY(rendererVk->getCompatibleRenderPass(desc, &renderPass));

     // If we've a Framebuffer provided by a Surface (default FBO/backbuffer), query it.
     VkDevice device = rendererVk->getDevice();
     if (mBackbuffer)
     {
         return mBackbuffer->getCurrentFramebuffer(device, *renderPass);
     }

     // Gather VkImageViews over all FBO attachments, also size of attached region.
     std::vector<VkImageView> attachments;
     gl::Extents attachmentsSize;

     const auto &colorAttachments = mState.getColorAttachments();
     for (size_t attachmentIndex = 0; attachmentIndex < colorAttachments.size(); ++attachmentIndex)
     {
         const auto &colorAttachment = colorAttachments[attachmentIndex];
         if (colorAttachment.isAttached())
         {
             RenderTargetVk *renderTarget = nullptr;
             ANGLE_TRY(colorAttachment.getRenderTarget(context, &renderTarget));
             attachments.push_back(renderTarget->imageView->getHandle());

             ASSERT(attachmentsSize.empty() || attachmentsSize == colorAttachment.getSize());
             attachmentsSize = colorAttachment.getSize();
         }
     }

     const auto *depthStencilAttachment = mState.getDepthStencilAttachment();
     if (depthStencilAttachment && depthStencilAttachment->isAttached())
     {
         RenderTargetVk *renderTarget = nullptr;
         ANGLE_TRY(depthStencilAttachment->getRenderTarget(context, &renderTarget));
         attachments.push_back(renderTarget->imageView->getHandle());

         ASSERT(attachmentsSize.empty() || attachmentsSize == depthStencilAttachment->getSize());
         attachmentsSize = depthStencilAttachment->getSize();
     }

     ASSERT(!attachments.empty());

     VkFramebufferCreateInfo framebufferInfo;

     framebufferInfo.sType           = VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO;
     framebufferInfo.pNext           = nullptr;
     framebufferInfo.flags           = 0;
     framebufferInfo.renderPass      = renderPass->getHandle();
     framebufferInfo.attachmentCount = static_cast<uint32_t>(attachments.size());
     framebufferInfo.pAttachments    = attachments.data();
     framebufferInfo.width           = static_cast<uint32_t>(attachmentsSize.width);
     framebufferInfo.height          = static_cast<uint32_t>(attachmentsSize.height);
     framebufferInfo.layers          = 1;

     ANGLE_TRY(mFramebuffer.init(device, framebufferInfo));

     return &mFramebuffer;
 }

 gl::Error FramebufferVk::getSamplePosition(size_t index, GLfloat *xy) const
 {
     UNIMPLEMENTED();
     return gl::InternalError() << "getSamplePosition is unimplemented.";
 }

 gl::Error FramebufferVk::getRenderNode(const gl::Context *context, vk::CommandBufferNode **nodeOut)
 {
     ContextVk *contextVk = vk::GetImpl(context);
     RendererVk *renderer = contextVk->getRenderer();
     Serial currentSerial = renderer->getCurrentQueueSerial();

     if (isCurrentlyRecording(currentSerial) && mLastRenderNodeSerial == currentSerial)
     {
         *nodeOut = getCurrentWriteNode(currentSerial);
         ASSERT((*nodeOut)->getInsideRenderPassCommands()->valid());
         return gl::NoError();
     }

     vk::CommandBufferNode *node = getNewWriteNode(renderer);

     vk::Framebuffer *framebuffer = nullptr;
     ANGLE_TRY_RESULT(getFramebuffer(context, renderer), framebuffer);

     const gl::State &glState = context->getGLState();

     // Hard-code RenderPass to clear the first render target to the current clear value.
     // TODO(jmadill): Proper clear value implementation.
     VkClearColorValue colorClear;
     memset(&colorClear, 0, sizeof(VkClearColorValue));
     colorClear.float32[0] = glState.getColorClearValue().red;
     colorClear.float32[1] = glState.getColorClearValue().green;
     colorClear.float32[2] = glState.getColorClearValue().blue;
     colorClear.float32[3] = glState.getColorClearValue().alpha;

     std::vector<VkClearValue> attachmentClearValues;
     attachmentClearValues.push_back({colorClear});

     node->storeRenderPassInfo(*framebuffer, glState.getViewport(), attachmentClearValues);

     // Initialize RenderPass info.
     // TODO(jmadill): Could cache this info, would require dependent state change messaging.
     const auto &colorAttachments = mState.getColorAttachments();
     for (size_t attachmentIndex = 0; attachmentIndex < colorAttachments.size(); ++attachmentIndex)
     {
         const auto &colorAttachment = colorAttachments[attachmentIndex];
         if (colorAttachment.isAttached())
         {
             RenderTargetVk *renderTarget = nullptr;
             ANGLE_SWALLOW_ERR(colorAttachment.getRenderTarget(context, &renderTarget));

             // TODO(jmadill): May need layout transition.
             renderTarget->image->updateLayout(VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL);
             node->appendColorRenderTarget(currentSerial, renderTarget);
         }
     }

     const gl::FramebufferAttachment *depthStencilAttachment = mState.getDepthOrStencilAttachment();
     if (depthStencilAttachment && depthStencilAttachment->isAttached())
     {
         RenderTargetVk *renderTarget = nullptr;
         ANGLE_SWALLOW_ERR(depthStencilAttachment->getRenderTarget(context, &renderTarget));

         // TODO(jmadill): May need layout transition.
         renderTarget->image->updateLayout(VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL);
         node->appendDepthStencilRenderTarget(currentSerial, renderTarget);
     }

     mLastRenderNodeSerial = currentSerial;

     *nodeOut = node;
     return gl::NoError();
 }

 }  // namespace rx
	//
	// Copyright 2016 The ANGLE Project Authors. All rights reserved.
	// Use of this source code is governed by a BSD-style license that can be
	// found in the LICENSE file.
	//
	// FramebufferVk.cpp:
	// Implements the class methods for FramebufferVk.
	//

	#include "libANGLE/renderer/vulkan/FramebufferVk.h"

	#include <vulkan/vulkan.h>
	#include <array>

	#include "common/debug.h"
	#include "image_util/imageformats.h"
	#include "libANGLE/Context.h"
	#include "libANGLE/Display.h"
	#include "libANGLE/formatutils.h"
	#include "libANGLE/renderer/renderer_utils.h"
	#include "libANGLE/renderer/vulkan/CommandBufferNode.h"
	#include "libANGLE/renderer/vulkan/ContextVk.h"
	#include "libANGLE/renderer/vulkan/DisplayVk.h"
	#include "libANGLE/renderer/vulkan/RenderTargetVk.h"
	#include "libANGLE/renderer/vulkan/RendererVk.h"
	#include "libANGLE/renderer/vulkan/SurfaceVk.h"
	#include "libANGLE/renderer/vulkan/vk_format_utils.h"

	namespace rx
	{

	namespace
	{
	gl::ErrorOrResult<const gl::InternalFormat *> GetReadAttachmentInfo(
	const gl::Context *context,
	const gl::FramebufferAttachment *readAttachment)
	{
	RenderTargetVk *renderTarget = nullptr;
	ANGLE_TRY(readAttachment->getRenderTarget(context, &renderTarget));

	GLenum implFormat = renderTarget->format->textureFormat().fboImplementationInternalFormat;
	return &gl::GetSizedInternalFormatInfo(implFormat);
	}
	} // anonymous namespace

	// static
	FramebufferVk *FramebufferVk::CreateUserFBO(const gl::FramebufferState &state)
	{
	return new FramebufferVk(state);
	}

	// static
	FramebufferVk *FramebufferVk::CreateDefaultFBO(const gl::FramebufferState &state,
	WindowSurfaceVk *backbuffer)
	{
	return new FramebufferVk(state, backbuffer);
	}

	FramebufferVk::FramebufferVk(const gl::FramebufferState &state)
	: FramebufferImpl(state),
	mBackbuffer(nullptr),
	mRenderPassDesc(),
	mFramebuffer(),
	mLastRenderNodeSerial()
	{
	}

	FramebufferVk::FramebufferVk(const gl::FramebufferState &state, WindowSurfaceVk *backbuffer)
	: FramebufferImpl(state),
	mBackbuffer(backbuffer),
	mRenderPassDesc(),
	mFramebuffer(),
	mLastRenderNodeSerial()
	{
	}

	FramebufferVk::~FramebufferVk()
	{
	}

	void FramebufferVk::destroy(const gl::Context *context)
	{
	RendererVk *renderer = vk::GetImpl(context)->getRenderer();

	renderer->releaseResource(*this, &mFramebuffer);
	}

	void FramebufferVk::destroyDefault(const egl::Display *display)
	{
	VkDevice device = vk::GetImpl(display)->getRenderer()->getDevice();

	mFramebuffer.destroy(device);
	}

	gl::Error FramebufferVk::discard(const gl::Context *context,
	size_t count,
	const GLenum *attachments)
	{
	UNIMPLEMENTED();
	return gl::InternalError();
	}

	gl::Error FramebufferVk::invalidate(const gl::Context *context,
	size_t count,
	const GLenum *attachments)
	{
	UNIMPLEMENTED();
	return gl::InternalError();
	}

	gl::Error FramebufferVk::invalidateSub(const gl::Context *context,
	size_t count,
	const GLenum *attachments,
	const gl::Rectangle &area)
	{
	UNIMPLEMENTED();
	return gl::InternalError();
	}

	gl::Error FramebufferVk::clear(const gl::Context *context, GLbitfield mask)
	{
	if (mState.getDepthAttachment() && (mask & GL_DEPTH_BUFFER_BIT) != 0)
	{
	// TODO(jmadill): Depth clear
	UNIMPLEMENTED();
	}

	if (mState.getStencilAttachment() && (mask & GL_STENCIL_BUFFER_BIT) != 0)
	{
	// TODO(jmadill): Stencil clear
	UNIMPLEMENTED();
	}

	if ((mask & GL_COLOR_BUFFER_BIT) == 0)
	{
	return gl::NoError();
	}

	const auto &glState = context->getGLState();
	const auto &clearColor = glState.getColorClearValue();
	VkClearColorValue clearColorValue;
	clearColorValue.float32[0] = clearColor.red;
	clearColorValue.float32[1] = clearColor.green;
	clearColorValue.float32[2] = clearColor.blue;
	clearColorValue.float32[3] = clearColor.alpha;

	// TODO(jmadill): Scissored clears.
	const auto *attachment = mState.getFirstNonNullAttachment();
	ASSERT(attachment && attachment->isAttached());
	const auto &size = attachment->getSize();
	const gl::Rectangle renderArea(0, 0, size.width, size.height);

	RendererVk *renderer = vk::GetImpl(context)->getRenderer();

	vk::CommandBuffer *commandBuffer = nullptr;
	ANGLE_TRY(recordWriteCommands(renderer, &commandBuffer));

	Serial currentSerial = renderer->getCurrentQueueSerial();

	for (const auto &colorAttachment : mState.getColorAttachments())
	{
	if (colorAttachment.isAttached())
	{
	RenderTargetVk *renderTarget = nullptr;
	ANGLE_TRY(colorAttachment.getRenderTarget(context, &renderTarget));

	renderTarget->resource->setWriteNode(getCurrentWriteNode(currentSerial), currentSerial);

	renderTarget->image->changeLayoutWithStages(
	VK_IMAGE_ASPECT_COLOR_BIT, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
	VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, commandBuffer);

	commandBuffer->clearSingleColorImage(*renderTarget->image, clearColorValue);
	}
	}

	// TODO(jmadill): Depth/stencil clear.

	return gl::NoError();
	}

	gl::Error FramebufferVk::clearBufferfv(const gl::Context *context,
	GLenum buffer,
	GLint drawbuffer,
	const GLfloat *values)
	{
	UNIMPLEMENTED();
	return gl::InternalError();
	}

	gl::Error FramebufferVk::clearBufferuiv(const gl::Context *context,
	GLenum buffer,
	GLint drawbuffer,
	const GLuint *values)
	{
	UNIMPLEMENTED();
	return gl::InternalError();
	}

	gl::Error FramebufferVk::clearBufferiv(const gl::Context *context,
	GLenum buffer,
	GLint drawbuffer,
	const GLint *values)
	{
	UNIMPLEMENTED();
	return gl::InternalError();
	}

	gl::Error FramebufferVk::clearBufferfi(const gl::Context *context,
	GLenum buffer,
	GLint drawbuffer,
	GLfloat depth,
	GLint stencil)
	{
	UNIMPLEMENTED();
	return gl::InternalError();
	}

	GLenum FramebufferVk::getImplementationColorReadFormat(const gl::Context *context) const
	{
	auto errOrResult = GetReadAttachmentInfo(context, mState.getReadAttachment());

	// TODO(jmadill): Handle getRenderTarget error.
	if (errOrResult.isError())
	{
	ERR() << "Internal error in FramebufferVk::getImplementationColorReadFormat.";
	return GL_NONE;
	}

	return errOrResult.getResult()->format;
	}

	GLenum FramebufferVk::getImplementationColorReadType(const gl::Context *context) const
	{
	auto errOrResult = GetReadAttachmentInfo(context, mState.getReadAttachment());

	// TODO(jmadill): Handle getRenderTarget error.
	if (errOrResult.isError())
	{
	ERR() << "Internal error in FramebufferVk::getImplementationColorReadFormat.";
	return GL_NONE;
	}

	return errOrResult.getResult()->type;
	}

	gl::Error FramebufferVk::readPixels(const gl::Context *context,
	const gl::Rectangle &area,
	GLenum format,
	GLenum type,
	void *pixels)
	{
	const auto &glState = context->getGLState();
	const auto *readFramebuffer = glState.getReadFramebuffer();
	const auto *readAttachment = readFramebuffer->getReadColorbuffer();

	RenderTargetVk *renderTarget = nullptr;
	ANGLE_TRY(readAttachment->getRenderTarget(context, &renderTarget));

	ContextVk *contextVk = vk::GetImpl(context);
	RendererVk *renderer = contextVk->getRenderer();
	VkDevice device = renderer->getDevice();

	vk::Image *readImage = renderTarget->image;
	vk::StagingImage stagingImage;
	ANGLE_TRY(renderer->createStagingImage(TextureDimension::TEX_2D, *renderTarget->format,
	renderTarget->extents, vk::StagingUsage::Read,
	&stagingImage));

	vk::CommandBuffer *commandBuffer = nullptr;
	ANGLE_TRY(recordWriteCommands(renderer, &commandBuffer));

	stagingImage.getImage().changeLayoutTop(VK_IMAGE_ASPECT_COLOR_BIT, VK_IMAGE_LAYOUT_GENERAL,
	commandBuffer);

	readImage->changeLayoutWithStages(
	VK_IMAGE_ASPECT_COLOR_BIT, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
	VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, commandBuffer);

	VkImageCopy region;
	region.srcSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
	region.srcSubresource.mipLevel = 0;
	region.srcSubresource.baseArrayLayer = 0;
	region.srcSubresource.layerCount = 1;
	region.srcOffset.x = area.x;
	region.srcOffset.y = area.y;
	region.srcOffset.z = 0;
	region.dstSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
	region.dstSubresource.mipLevel = 0;
	region.dstSubresource.baseArrayLayer = 0;
	region.dstSubresource.layerCount = 1;
	region.dstOffset.x = 0;
	region.dstOffset.y = 0;
	region.dstOffset.z = 0;
	region.extent.width = area.width;
	region.extent.height = area.height;
	region.extent.depth = 1;

	commandBuffer->copyImage(*readImage, stagingImage.getImage(), 1, &region);

	// Triggers a full finish.
	// TODO(jmadill): Don't block on asynchronous readback.
	ANGLE_TRY(renderer->finish(context));

	// TODO(jmadill): parameters
	uint8_t *mapPointer = nullptr;
	ANGLE_TRY(
	stagingImage.getDeviceMemory().map(device, 0, stagingImage.getSize(), 0, &mapPointer));

	const auto &angleFormat = renderTarget->format->textureFormat();

	// TODO(jmadill): Use pixel bytes from the ANGLE format directly.
	const auto &glFormat = gl::GetSizedInternalFormatInfo(angleFormat.glInternalFormat);
	int inputPitch = glFormat.pixelBytes * area.width;

	PackPixelsParams params;
	params.area = area;
	params.format = format;
	params.type = type;
	params.outputPitch = inputPitch;
	params.packBuffer = glState.getTargetBuffer(gl::BufferBinding::PixelPack);
	params.pack = glState.getPackState();

	PackPixels(params, angleFormat, inputPitch, mapPointer, reinterpret_cast<uint8_t *>(pixels));

	stagingImage.getDeviceMemory().unmap(device);
	renderer->releaseObject(renderer->getCurrentQueueSerial(), &stagingImage);

	return vk::NoError();
	}

	gl::Error FramebufferVk::blit(const gl::Context *context,
	const gl::Rectangle &sourceArea,
	const gl::Rectangle &destArea,
	GLbitfield mask,
	GLenum filter)
	{
	UNIMPLEMENTED();
	return gl::InternalError();
	}

	bool FramebufferVk::checkStatus(const gl::Context *context) const
	{
	return true;
	}

	void FramebufferVk::syncState(const gl::Context *context,
	const gl::Framebuffer::DirtyBits &dirtyBits)
	{
	ContextVk *contextVk = vk::GetImpl(context);
	RendererVk *renderer = contextVk->getRenderer();

	ASSERT(dirtyBits.any());

	// TODO(jmadill): Smarter update.
	mRenderPassDesc.reset();
	renderer->releaseResource(*this, &mFramebuffer);

	// Trigger a new set of secondary commands next time we render to this FBO,.
	mLastRenderNodeSerial = Serial();

	contextVk->invalidateCurrentPipeline();
	}

	const vk::RenderPassDesc &FramebufferVk::getRenderPassDesc(const gl::Context *context)
	{
	if (mRenderPassDesc.valid())
	{
	return mRenderPassDesc.value();
	}

	vk::RenderPassDesc desc;

	const auto &colorAttachments = mState.getColorAttachments();
	for (size_t attachmentIndex = 0; attachmentIndex < colorAttachments.size(); ++attachmentIndex)
	{
	const auto &colorAttachment = colorAttachments[attachmentIndex];
	if (colorAttachment.isAttached())
	{
	RenderTargetVk *renderTarget = nullptr;
	ANGLE_SWALLOW_ERR(colorAttachment.getRenderTarget(context, &renderTarget));
	desc.packColorAttachment(*renderTarget->format, colorAttachment.getSamples());
	}
	}

	const auto *depthStencilAttachment = mState.getDepthStencilAttachment();

	if (depthStencilAttachment && depthStencilAttachment->isAttached())
	{
	RenderTargetVk *renderTarget = nullptr;
	ANGLE_SWALLOW_ERR(depthStencilAttachment->getRenderTarget(context, &renderTarget));
	desc.packDepthStencilAttachment(*renderTarget->format,
	depthStencilAttachment->getSamples());
	}

	mRenderPassDesc = desc;
	return mRenderPassDesc.value();
	}

	gl::ErrorOrResult<vk::Framebuffer > FramebufferVk::getFramebuffer(const gl::Context context,
	RendererVk *rendererVk)
	{
	// If we've already created our cached Framebuffer, return it.
	if (mFramebuffer.valid())
	{
	return &mFramebuffer;
	}

	const vk::RenderPassDesc &desc = getRenderPassDesc(context);

	vk::RenderPass *renderPass = nullptr;
	ANGLE_TRY(rendererVk->getCompatibleRenderPass(desc, &renderPass));

	// If we've a Framebuffer provided by a Surface (default FBO/backbuffer), query it.
	VkDevice device = rendererVk->getDevice();
	if (mBackbuffer)
	{
	return mBackbuffer->getCurrentFramebuffer(device, *renderPass);
	}

	// Gather VkImageViews over all FBO attachments, also size of attached region.
	std::vector<VkImageView> attachments;
	gl::Extents attachmentsSize;

	const auto &colorAttachments = mState.getColorAttachments();
	for (size_t attachmentIndex = 0; attachmentIndex < colorAttachments.size(); ++attachmentIndex)
	{
	const auto &colorAttachment = colorAttachments[attachmentIndex];
	if (colorAttachment.isAttached())
	{
	RenderTargetVk *renderTarget = nullptr;
	ANGLE_TRY(colorAttachment.getRenderTarget(context, &renderTarget));
	attachments.push_back(renderTarget->imageView->getHandle());

	ASSERT(attachmentsSize.empty() \|\| attachmentsSize == colorAttachment.getSize());
	attachmentsSize = colorAttachment.getSize();
	}
	}

	const auto *depthStencilAttachment = mState.getDepthStencilAttachment();
	if (depthStencilAttachment && depthStencilAttachment->isAttached())
	{
	RenderTargetVk *renderTarget = nullptr;
	ANGLE_TRY(depthStencilAttachment->getRenderTarget(context, &renderTarget));
	attachments.push_back(renderTarget->imageView->getHandle());

	ASSERT(attachmentsSize.empty() \|\| attachmentsSize == depthStencilAttachment->getSize());
	attachmentsSize = depthStencilAttachment->getSize();
	}

	ASSERT(!attachments.empty());

	VkFramebufferCreateInfo framebufferInfo;

	framebufferInfo.sType = VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO;
	framebufferInfo.pNext = nullptr;
	framebufferInfo.flags = 0;
	framebufferInfo.renderPass = renderPass->getHandle();
	framebufferInfo.attachmentCount = static_cast<uint32_t>(attachments.size());
	framebufferInfo.pAttachments = attachments.data();
	framebufferInfo.width = static_cast<uint32_t>(attachmentsSize.width);
	framebufferInfo.height = static_cast<uint32_t>(attachmentsSize.height);
	framebufferInfo.layers = 1;

	ANGLE_TRY(mFramebuffer.init(device, framebufferInfo));

	return &mFramebuffer;
	}

	gl::Error FramebufferVk::getSamplePosition(size_t index, GLfloat *xy) const
	{
	UNIMPLEMENTED();
	return gl::InternalError() << "getSamplePosition is unimplemented.";
	}

	gl::Error FramebufferVk::getRenderNode(const gl::Context context, vk::CommandBufferNode *nodeOut)
	{
	ContextVk *contextVk = vk::GetImpl(context);
	RendererVk *renderer = contextVk->getRenderer();
	Serial currentSerial = renderer->getCurrentQueueSerial();

	if (isCurrentlyRecording(currentSerial) && mLastRenderNodeSerial == currentSerial)
	{
	*nodeOut = getCurrentWriteNode(currentSerial);
	ASSERT((*nodeOut)->getInsideRenderPassCommands()->valid());
	return gl::NoError();
	}

	vk::CommandBufferNode *node = getNewWriteNode(renderer);

	vk::Framebuffer *framebuffer = nullptr;
	ANGLE_TRY_RESULT(getFramebuffer(context, renderer), framebuffer);

	const gl::State &glState = context->getGLState();

	// Hard-code RenderPass to clear the first render target to the current clear value.
	// TODO(jmadill): Proper clear value implementation.
	VkClearColorValue colorClear;
	memset(&colorClear, 0, sizeof(VkClearColorValue));
	colorClear.float32[0] = glState.getColorClearValue().red;
	colorClear.float32[1] = glState.getColorClearValue().green;
	colorClear.float32[2] = glState.getColorClearValue().blue;
	colorClear.float32[3] = glState.getColorClearValue().alpha;

	std::vector<VkClearValue> attachmentClearValues;
	attachmentClearValues.push_back({colorClear});

	node->storeRenderPassInfo(*framebuffer, glState.getViewport(), attachmentClearValues);

	// Initialize RenderPass info.
	// TODO(jmadill): Could cache this info, would require dependent state change messaging.
	const auto &colorAttachments = mState.getColorAttachments();
	for (size_t attachmentIndex = 0; attachmentIndex < colorAttachments.size(); ++attachmentIndex)
	{
	const auto &colorAttachment = colorAttachments[attachmentIndex];
	if (colorAttachment.isAttached())
	{
	RenderTargetVk *renderTarget = nullptr;
	ANGLE_SWALLOW_ERR(colorAttachment.getRenderTarget(context, &renderTarget));

	// TODO(jmadill): May need layout transition.
	renderTarget->image->updateLayout(VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL);
	node->appendColorRenderTarget(currentSerial, renderTarget);
	}
	}

	const gl::FramebufferAttachment *depthStencilAttachment = mState.getDepthOrStencilAttachment();
	if (depthStencilAttachment && depthStencilAttachment->isAttached())
	{
	RenderTargetVk *renderTarget = nullptr;
	ANGLE_SWALLOW_ERR(depthStencilAttachment->getRenderTarget(context, &renderTarget));

	// TODO(jmadill): May need layout transition.
	renderTarget->image->updateLayout(VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL);
	node->appendDepthStencilRenderTarget(currentSerial, renderTarget);
	}

	mLastRenderNodeSerial = currentSerial;

	*nodeOut = node;
	return gl::NoError();
	}

	} // namespace rx