Vulkan: Implement basic TexSubImage2D.

src/libANGLE/renderer/vulkan/TextureVk.cpp

@@ -180,6 +180,38 @@ gl::Error TextureVk::setImage(const gl::Context *context,
     // TODO(jmadill): Consider re-using staging texture.
     if (pixels)
     {
+        ANGLE_TRY(setSubImageImpl(contextVk, formatInfo, unpack, type, pixels));
+    }
+
+    return gl::NoError();
+}
+
+gl::Error TextureVk::setSubImage(const gl::Context *context,
+                                 GLenum target,
+                                 size_t level,
+                                 const gl::Box &area,
+                                 GLenum format,
+                                 GLenum type,
+                                 const gl::PixelUnpackState &unpack,
+                                 const uint8_t *pixels)
+{
+    ContextVk *contextVk                 = vk::GetImpl(context);
+    const gl::InternalFormat &formatInfo = gl::GetInternalFormatInfo(format, type);
+    ANGLE_TRY(setSubImageImpl(contextVk, formatInfo, unpack, type, pixels));
+    return gl::NoError();
+}
+
+gl::Error TextureVk::setSubImageImpl(ContextVk *contextVk,
+                                     const gl::InternalFormat &formatInfo,
+                                     const gl::PixelUnpackState &unpack,
+                                     GLenum type,
+                                     const uint8_t *pixels)
+{
+    RendererVk *renderer       = contextVk->getRenderer();
+    VkDevice device            = renderer->getDevice();
+    const gl::Extents &size    = mRenderTarget.extents;
+    const vk::Format &vkFormat = *mRenderTarget.format;
+
     vk::StagingImage stagingImage;
     ANGLE_TRY(renderer->createStagingImage(TextureDimension::TEX_2D, vkFormat, size,
                                            vk::StagingUsage::Write, &stagingImage));
@@ -190,8 +222,7 @@ gl::Error TextureVk::setImage(const gl::Context *context,
         inputRowPitch);
 
     GLuint inputDepthPitch = 0;
-        ANGLE_TRY_RESULT(
-            formatInfo.computeDepthPitch(size.height, unpack.imageHeight, inputRowPitch),
+    ANGLE_TRY_RESULT(formatInfo.computeDepthPitch(size.height, unpack.imageHeight, inputRowPitch),
                      inputDepthPitch);
 
     // TODO(jmadill): skip images for 3D Textures.
@@ -238,9 +269,9 @@ gl::Error TextureVk::setImage(const gl::Context *context,
     stagingImage.getImage().changeLayoutWithStages(
         VK_IMAGE_ASPECT_COLOR_BIT, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
         VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, commandBuffer);
-        mImage.changeLayoutWithStages(
-            VK_IMAGE_ASPECT_COLOR_BIT, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
-            VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, commandBuffer);
+    mImage.changeLayoutWithStages(VK_IMAGE_ASPECT_COLOR_BIT, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
+                                  VK_PIPELINE_STAGE_ALL_COMMANDS_BIT,
+                                  VK_PIPELINE_STAGE_TRANSFER_BIT, commandBuffer);
 
     gl::Box wholeRegion(0, 0, 0, size.width, size.height, size.depth);
     commandBuffer->copySingleImage(stagingImage.getImage(), mImage, wholeRegion,
@@ -248,24 +279,9 @@ gl::Error TextureVk::setImage(const gl::Context *context,
 
     // TODO(jmadill): Re-use staging images.
     renderer->releaseObject(renderer->getCurrentQueueSerial(), &stagingImage);
-    }
-
     return gl::NoError();
 }
 
-gl::Error TextureVk::setSubImage(const gl::Context *context,
-                                 GLenum target,
-                                 size_t level,
-                                 const gl::Box &area,
-                                 GLenum format,
-                                 GLenum type,
-                                 const gl::PixelUnpackState &unpack,
-                                 const uint8_t *pixels)
-{
-    UNIMPLEMENTED();
-    return gl::InternalError();
-}
-
 gl::Error TextureVk::setCompressedImage(const gl::Context *context,
                                         GLenum target,
                                         size_t level,

src/libANGLE/renderer/vulkan/TextureVk.h

@@ -116,6 +116,12 @@ class TextureVk : public TextureImpl, public ResourceVk
     const vk::Sampler &getSampler() const;
 
   private:
+    gl::Error setSubImageImpl(ContextVk *contextVk,
+                              const gl::InternalFormat &formatInfo,
+                              const gl::PixelUnpackState &unpack,
+                              GLenum type,
+                              const uint8_t *pixels);
+
     // TODO(jmadill): support a more flexible storage back-end.
     vk::Image mImage;
     vk::DeviceMemory mDeviceMemory;

src/tests/gl_tests/StateChangeTest.cpp

@@ -950,6 +950,44 @@ TEST_P(SimpleStateChangeTest, RedefineTextureInUse)
     EXPECT_PIXEL_COLOR_EQ(w, h, GLColor::white);
 }
 
+// Test updating a Texture's contents while in use by GL works as expected.
+TEST_P(SimpleStateChangeTest, UpdateTextureInUse)
+{
+    std::array<GLColor, 4> rgby = {{GLColor::red, GLColor::green, GLColor::blue, GLColor::yellow}};
+
+    GLTexture tex;
+    glBindTexture(GL_TEXTURE_2D, tex);
+    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 2, 2, 0, GL_RGBA, GL_UNSIGNED_BYTE, rgby.data());
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+
+    // Draw RGBY to the Framebuffer. The texture is now in-use by GL.
+    draw2DTexturedQuad(0.5f, 1.0f, true);
+
+    // Update the texture to be YBGR, while the Texture is in-use. Should not affect the draw.
+    std::array<GLColor, 4> ybgr = {{GLColor::yellow, GLColor::blue, GLColor::green, GLColor::red}};
+    glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 2, 2, GL_RGBA, GL_UNSIGNED_BYTE, ybgr.data());
+    ASSERT_GL_NO_ERROR();
+
+    // Check the Framebuffer. The draw call should have completed with the original RGBY data.
+    int w = getWindowWidth() - 2;
+    int h = getWindowHeight() - 2;
+
+    EXPECT_PIXEL_COLOR_EQ(0, 0, GLColor::red);
+    EXPECT_PIXEL_COLOR_EQ(w, 0, GLColor::green);
+    EXPECT_PIXEL_COLOR_EQ(0, h, GLColor::blue);
+    EXPECT_PIXEL_COLOR_EQ(w, h, GLColor::yellow);
+
+    // Draw again to the Framebuffer. The second draw call should use the updated YBGR data.
+    draw2DTexturedQuad(0.5f, 1.0f, true);
+
+    EXPECT_PIXEL_COLOR_EQ(0, 0, GLColor::yellow);
+    EXPECT_PIXEL_COLOR_EQ(w, 0, GLColor::blue);
+    EXPECT_PIXEL_COLOR_EQ(0, h, GLColor::green);
+    EXPECT_PIXEL_COLOR_EQ(w, h, GLColor::red);
+    ASSERT_GL_NO_ERROR();
+}
+
 const char kSolidColorVertexShader[] = R"(attribute vec2 position;
 void main()
 {