Handle Clear* commands for layered framebuffers

src/libANGLE/renderer/gl/ClearMultiviewGL.cpp

+//
+// Copyright 2017 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.
+//
+// ClearMultiviewGL:
+//   A helper for clearing multiview side-by-side and layered framebuffers.
+//
+
+#include "libANGLE/renderer/gl/ClearMultiviewGL.h"
+#include "libANGLE/renderer/gl/FunctionsGL.h"
+#include "libANGLE/renderer/gl/StateManagerGL.h"
+#include "libANGLE/renderer/gl/TextureGL.h"
+
+#include "libANGLE/Framebuffer.h"
+
+namespace rx
+{
+
+ClearMultiviewGL::ClearMultiviewGL(const FunctionsGL *functions, StateManagerGL *stateManager)
+    : mFunctions(functions), mStateManager(stateManager), mFramebuffer(0u)
+{
+}
+
+ClearMultiviewGL::~ClearMultiviewGL()
+{
+    if (mFramebuffer != 0u)
+    {
+        mFunctions->deleteFramebuffers(1, &mFramebuffer);
+    }
+}
+
+void ClearMultiviewGL::clearMultiviewFBO(const gl::FramebufferState &state,
+                                         const gl::Rectangle &scissorBase,
+                                         ClearCommandType clearCommandType,
+                                         GLbitfield mask,
+                                         GLenum buffer,
+                                         GLint drawbuffer,
+                                         const uint8_t *values,
+                                         GLfloat depth,
+                                         GLint stencil)
+{
+    const auto &firstAttachment = state.getFirstNonNullAttachment();
+    switch (firstAttachment->getMultiviewLayout())
+    {
+        case GL_FRAMEBUFFER_MULTIVIEW_LAYERED_ANGLE:
+            clearLayeredFBO(state, clearCommandType, mask, buffer, drawbuffer, values, depth,
+                            stencil);
+            break;
+        case GL_FRAMEBUFFER_MULTIVIEW_SIDE_BY_SIDE_ANGLE:
+            clearSideBySideFBO(state, scissorBase, clearCommandType, mask, buffer, drawbuffer,
+                               values, depth, stencil);
+            break;
+        default:
+            UNREACHABLE();
+    }
+}
+
+void ClearMultiviewGL::clearLayeredFBO(const gl::FramebufferState &state,
+                                       ClearCommandType clearCommandType,
+                                       GLbitfield mask,
+                                       GLenum buffer,
+                                       GLint drawbuffer,
+                                       const uint8_t *values,
+                                       GLfloat depth,
+                                       GLint stencil)
+{
+    initializeResources();
+
+    mStateManager->bindFramebuffer(GL_DRAW_FRAMEBUFFER, mFramebuffer);
+
+    const auto &firstAttachment = state.getFirstNonNullAttachment();
+    ASSERT(firstAttachment->getMultiviewLayout() == GL_FRAMEBUFFER_MULTIVIEW_LAYERED_ANGLE);
+
+    const auto &drawBuffers = state.getDrawBufferStates();
+    mFunctions->drawBuffers(static_cast<GLsizei>(drawBuffers.size()), drawBuffers.data());
+
+    // Attach the new attachments and clear.
+    int numViews      = firstAttachment->getNumViews();
+    int baseViewIndex = firstAttachment->getBaseViewIndex();
+    for (int i = 0; i < numViews; ++i)
+    {
+        attachTextures(state, baseViewIndex + i);
+        genericClear(clearCommandType, mask, buffer, drawbuffer, values, depth, stencil);
+    }
+
+    detachTextures(state);
+}
+
+void ClearMultiviewGL::clearSideBySideFBO(const gl::FramebufferState &state,
+                                          const gl::Rectangle &scissorBase,
+                                          ClearCommandType clearCommandType,
+                                          GLbitfield mask,
+                                          GLenum buffer,
+                                          GLint drawbuffer,
+                                          const uint8_t *values,
+                                          GLfloat depth,
+                                          GLint stencil)
+{
+    const auto &firstAttachment = state.getFirstNonNullAttachment();
+    ASSERT(firstAttachment->getMultiviewLayout() == GL_FRAMEBUFFER_MULTIVIEW_SIDE_BY_SIDE_ANGLE);
+
+    const auto &viewportOffsets = firstAttachment->getMultiviewViewportOffsets();
+    for (size_t i = 0u; i < viewportOffsets.size(); ++i)
+    {
+        gl::Rectangle scissor(scissorBase.x + viewportOffsets[i].x,
+                              scissorBase.y + viewportOffsets[i].y, scissorBase.width,
+                              scissorBase.height);
+        mStateManager->setScissorIndexed(0u, scissor);
+        genericClear(clearCommandType, mask, buffer, drawbuffer, values, depth, stencil);
+    }
+}
+
+void ClearMultiviewGL::genericClear(ClearCommandType clearCommandType,
+                                    GLbitfield mask,
+                                    GLenum buffer,
+                                    GLint drawbuffer,
+                                    const uint8_t *values,
+                                    GLfloat depth,
+                                    GLint stencil)
+{
+    switch (clearCommandType)
+    {
+        case ClearCommandType::Clear:
+            mFunctions->clear(mask);
+            break;
+        case ClearCommandType::ClearBufferfv:
+            mFunctions->clearBufferfv(buffer, drawbuffer,
+                                      reinterpret_cast<const GLfloat *>(values));
+            break;
+        case ClearCommandType::ClearBufferuiv:
+            mFunctions->clearBufferuiv(buffer, drawbuffer,
+                                       reinterpret_cast<const GLuint *>(values));
+            break;
+        case ClearCommandType::ClearBufferiv:
+            mFunctions->clearBufferiv(buffer, drawbuffer, reinterpret_cast<const GLint *>(values));
+            break;
+        case ClearCommandType::ClearBufferfi:
+            mFunctions->clearBufferfi(buffer, drawbuffer, depth, stencil);
+            break;
+        default:
+            UNREACHABLE();
+    }
+}
+
+void ClearMultiviewGL::attachTextures(const gl::FramebufferState &state, int layer)
+{
+    for (auto drawBufferId : state.getEnabledDrawBuffers())
+    {
+        const auto &attachment = state.getColorAttachment(drawBufferId);
+        if (attachment == nullptr)
+        {
+            continue;
+        }
+
+        const auto &imageIndex = attachment->getTextureImageIndex();
+        ASSERT(imageIndex.type == GL_TEXTURE_2D_ARRAY);
+
+        GLenum colorAttachment =
+            static_cast<GLenum>(GL_COLOR_ATTACHMENT0 + static_cast<int>(drawBufferId));
+        const TextureGL *textureGL = GetImplAs<TextureGL>(attachment->getTexture());
+        mFunctions->framebufferTextureLayer(GL_DRAW_FRAMEBUFFER, colorAttachment,
+                                            textureGL->getTextureID(), imageIndex.mipIndex, layer);
+    }
+
+    const auto &depthStencilAttachment = state.getDepthStencilAttachment();
+    const auto &depthAttachment        = state.getDepthAttachment();
+    const auto &stencilAttachment      = state.getStencilAttachment();
+    if (depthStencilAttachment != nullptr)
+    {
+        const auto &imageIndex = depthStencilAttachment->getTextureImageIndex();
+        ASSERT(imageIndex.type == GL_TEXTURE_2D_ARRAY);
+
+        const TextureGL *textureGL = GetImplAs<TextureGL>(depthStencilAttachment->getTexture());
+        mFunctions->framebufferTextureLayer(GL_DRAW_FRAMEBUFFER, GL_DEPTH_STENCIL_ATTACHMENT,
+                                            textureGL->getTextureID(), imageIndex.mipIndex, layer);
+    }
+    else if (depthAttachment != nullptr)
+    {
+        const auto &imageIndex = depthAttachment->getTextureImageIndex();
+        ASSERT(imageIndex.type == GL_TEXTURE_2D_ARRAY);
+
+        const TextureGL *textureGL = GetImplAs<TextureGL>(depthAttachment->getTexture());
+        mFunctions->framebufferTextureLayer(GL_DRAW_FRAMEBUFFER, GL_DEPTH_ATTACHMENT,
+                                            textureGL->getTextureID(), imageIndex.mipIndex, layer);
+    }
+    else if (stencilAttachment != nullptr)
+    {
+        const auto &imageIndex = stencilAttachment->getTextureImageIndex();
+        ASSERT(imageIndex.type == GL_TEXTURE_2D_ARRAY);
+
+        const TextureGL *textureGL = GetImplAs<TextureGL>(stencilAttachment->getTexture());
+        mFunctions->framebufferTextureLayer(GL_DRAW_FRAMEBUFFER, GL_STENCIL_ATTACHMENT,
+                                            textureGL->getTextureID(), imageIndex.mipIndex, layer);
+    }
+}
+
+void ClearMultiviewGL::detachTextures(const gl::FramebufferState &state)
+{
+    for (auto drawBufferId : state.getEnabledDrawBuffers())
+    {
+        const auto &attachment = state.getColorAttachment(drawBufferId);
+        if (attachment == nullptr)
+        {
+            continue;
+        }
+
+        GLenum colorAttachment =
+            static_cast<GLenum>(GL_COLOR_ATTACHMENT0 + static_cast<int>(drawBufferId));
+        mFunctions->framebufferTextureLayer(GL_DRAW_FRAMEBUFFER, colorAttachment, 0, 0, 0);
+    }
+
+    const auto &depthStencilAttachment = state.getDepthStencilAttachment();
+    const auto &depthAttachment        = state.getDepthAttachment();
+    const auto &stencilAttachment      = state.getStencilAttachment();
+    if (depthStencilAttachment != nullptr)
+    {
+        mFunctions->framebufferTextureLayer(GL_DRAW_FRAMEBUFFER, GL_DEPTH_STENCIL_ATTACHMENT, 0, 0,
+                                            0);
+    }
+    else if (depthAttachment != nullptr)
+    {
+        mFunctions->framebufferTextureLayer(GL_DRAW_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, 0, 0, 0);
+    }
+    else if (stencilAttachment != nullptr)
+    {
+        mFunctions->framebufferTextureLayer(GL_DRAW_FRAMEBUFFER, GL_STENCIL_ATTACHMENT, 0, 0, 0);
+    }
+}
+
+void ClearMultiviewGL::initializeResources()
+{
+    if (mFramebuffer == 0u)
+    {
+        mFunctions->genFramebuffers(1, &mFramebuffer);
+    }
+    ASSERT(mFramebuffer != 0u);
+}
+
+}  // namespace rx
\ No newline at end of file

src/libANGLE/renderer/gl/ClearMultiviewGL.h

+//
+// Copyright 2017 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.
+//
+// ClearMultiviewGL:
+//   A helper for clearing multiview side-by-side and layered framebuffers.
+//
+
+#ifndef LIBANGLE_RENDERER_GL_CLEARMULTIVIEWGL_H_
+#define LIBANGLE_RENDERER_GL_CLEARMULTIVIEWGL_H_
+
+#include "angle_gl.h"
+#include "libANGLE/Error.h"
+#include "libANGLE/angletypes.h"
+
+namespace gl
+{
+class FramebufferState;
+}  // namespace gl
+
+namespace rx
+{
+class FunctionsGL;
+class StateManagerGL;
+
+class ClearMultiviewGL : angle::NonCopyable
+{
+  public:
+    // Enum containing the different types of Clear* commands.
+    enum class ClearCommandType
+    {
+        Clear,
+        ClearBufferfv,
+        ClearBufferuiv,
+        ClearBufferiv,
+        ClearBufferfi
+    };
+
+  public:
+    ClearMultiviewGL(const FunctionsGL *functions, StateManagerGL *stateManager);
+    ~ClearMultiviewGL();
+
+    ClearMultiviewGL(const ClearMultiviewGL &rht) = delete;
+    ClearMultiviewGL &operator=(const ClearMultiviewGL &rht) = delete;
+    ClearMultiviewGL(ClearMultiviewGL &&rht)                 = delete;
+    ClearMultiviewGL &operator=(ClearMultiviewGL &&rht) = delete;
+
+    void clearMultiviewFBO(const gl::FramebufferState &state,
+                           const gl::Rectangle &scissorBase,
+                           ClearCommandType clearCommandType,
+                           GLbitfield mask,
+                           GLenum buffer,
+                           GLint drawbuffer,
+                           const uint8_t *values,
+                           GLfloat depth,
+                           GLint stencil);
+    void initializeResources();
+
+  private:
+    void attachTextures(const gl::FramebufferState &state, int layer);
+    void detachTextures(const gl::FramebufferState &state);
+    void clearLayeredFBO(const gl::FramebufferState &state,
+                         ClearCommandType clearCommandType,
+                         GLbitfield mask,
+                         GLenum buffer,
+                         GLint drawbuffer,
+                         const uint8_t *values,
+                         GLfloat depth,
+                         GLint stencil);
+    void clearSideBySideFBO(const gl::FramebufferState &state,
+                            const gl::Rectangle &scissorBase,
+                            ClearCommandType clearCommandType,
+                            GLbitfield mask,
+                            GLenum buffer,
+                            GLint drawbuffer,
+                            const uint8_t *values,
+                            GLfloat depth,
+                            GLint stencil);
+    void genericClear(ClearCommandType clearCommandType,
+                      GLbitfield mask,
+                      GLenum buffer,
+                      GLint drawbuffer,
+                      const uint8_t *values,
+                      GLfloat depth,
+                      GLint stencil);
+
+    const FunctionsGL *mFunctions;
+    StateManagerGL *mStateManager;
+
+    GLuint mFramebuffer;
+};
+}  // namespace rx
+
+#endif  // LIBANGLE_RENDERER_GL_CLEARMULTIVIEWGL_H_
\ No newline at end of file

src/libANGLE/renderer/gl/ContextGL.cpp

@@ -65,7 +65,7 @@ ProgramImpl *ContextGL::createProgram(const gl::ProgramState &data)
 FramebufferImpl *ContextGL::createFramebuffer(const gl::FramebufferState &data)
 {
     return new FramebufferGL(data, getFunctions(), getStateManager(), getWorkaroundsGL(),
-                             mRenderer->getBlitter(), false);
+                             mRenderer->getBlitter(), mRenderer->getMultiviewClearer(), false);
 }
 
 TextureImpl *ContextGL::createTexture(const gl::TextureState &state)

src/libANGLE/renderer/gl/FramebufferGL.h

@@ -15,6 +15,7 @@ namespace rx
 {
 
 class BlitGL;
+class ClearMultiviewGL;
 class FunctionsGL;
 class StateManagerGL;
 struct WorkaroundsGL;
@@ -27,6 +28,7 @@ class FramebufferGL : public FramebufferImpl
                   StateManagerGL *stateManager,
                   const WorkaroundsGL &workarounds,
                   BlitGL *blitter,
+                  ClearMultiviewGL *multiviewClearer,
                   bool isDefault);
     // Constructor called when we need to create a FramebufferGL from an
     // existing framebuffer name, for example for the default framebuffer
@@ -36,6 +38,7 @@ class FramebufferGL : public FramebufferImpl
                   const FunctionsGL *functions,
                   const WorkaroundsGL &workarounds,
                   BlitGL *blitter,
+                  ClearMultiviewGL *multiviewClearer,
                   StateManagerGL *stateManager);
     ~FramebufferGL() override;
 
@@ -95,17 +98,6 @@ class FramebufferGL : public FramebufferImpl
     void maskOutInactiveOutputDrawBuffers(gl::DrawBufferMask maxSet);
 
   private:
-    // Enum containing the different types of Clear* commands.
-    enum class ClearCommandType
-    {
-        Clear,
-        ClearBufferfv,
-        ClearBufferuiv,
-        ClearBufferiv,
-        ClearBufferfi
-    };
-
-  private:
     void syncClearState(const gl::Context *context, GLbitfield mask);
     void syncClearBufferState(const gl::Context *context, GLenum buffer, GLint drawBuffer);
 
@@ -129,19 +121,11 @@ class FramebufferGL : public FramebufferImpl
                                   GLubyte *pixels,
                                   bool readLastRowSeparately) const;
 
-    void genericSideBySideClear(const gl::Context *context,
-                                ClearCommandType clearCommandType,
-                                GLbitfield mask,
-                                GLenum buffer,
-                                GLint drawbuffer,
-                                const uint8_t *values,
-                                GLfloat depth,
-                                GLint stencil);
-
     const FunctionsGL *mFunctions;
     StateManagerGL *mStateManager;
     const WorkaroundsGL &mWorkarounds;
     BlitGL *mBlitter;
+    ClearMultiviewGL *mMultiviewClearer;
 
     GLuint mFramebufferID;
     bool mIsDefault;

src/libANGLE/renderer/gl/RendererGL.cpp

@@ -18,6 +18,7 @@
 #include "libANGLE/Surface.h"
 #include "libANGLE/renderer/gl/BlitGL.h"
 #include "libANGLE/renderer/gl/BufferGL.h"
+#include "libANGLE/renderer/gl/ClearMultiviewGL.h"
 #include "libANGLE/renderer/gl/CompilerGL.h"
 #include "libANGLE/renderer/gl/ContextGL.h"
 #include "libANGLE/renderer/gl/FenceNVGL.h"
@@ -168,6 +169,7 @@ RendererGL::RendererGL(const FunctionsGL *functions, const egl::AttributeMap &at
       mFunctions(functions),
       mStateManager(nullptr),
       mBlitter(nullptr),
+      mMultiviewClearer(nullptr),
       mUseDebugOutput(false),
       mSkipDrawCalls(false),
       mCapsInitialized(false),
@@ -177,6 +179,7 @@ RendererGL::RendererGL(const FunctionsGL *functions, const egl::AttributeMap &at
     nativegl_gl::GenerateWorkarounds(mFunctions, &mWorkarounds);
     mStateManager = new StateManagerGL(mFunctions, getNativeCaps(), getNativeExtensions());
     mBlitter      = new BlitGL(functions, mWorkarounds, mStateManager);
+    mMultiviewClearer = new ClearMultiviewGL(functions, mStateManager);
 
     bool hasDebugOutput = mFunctions->isAtLeastGL(gl::Version(4, 3)) ||
                           mFunctions->hasGLExtension("GL_KHR_debug") ||
@@ -222,6 +225,7 @@ RendererGL::RendererGL(const FunctionsGL *functions, const egl::AttributeMap &at
 RendererGL::~RendererGL()
 {
     SafeDelete(mBlitter);
+    SafeDelete(mMultiviewClearer);
     SafeDelete(mStateManager);
 }
 

src/libANGLE/renderer/gl/RendererGL.h

@@ -36,6 +36,7 @@ struct BlockMemberInfo;
 namespace rx
 {
 class BlitGL;
+class ClearMultiviewGL;
 class ContextImpl;
 class FunctionsGL;
 class StateManagerGL;
@@ -159,6 +160,7 @@ class RendererGL : angle::NonCopyable
     StateManagerGL *getStateManager() const { return mStateManager; }
     const WorkaroundsGL &getWorkarounds() const { return mWorkarounds; }
     BlitGL *getBlitter() const { return mBlitter; }
+    ClearMultiviewGL *getMultiviewClearer() const { return mMultiviewClearer; }
 
     MultiviewImplementationTypeGL getMultiviewImplementationType() const;
     const gl::Caps &getNativeCaps() const;
@@ -185,6 +187,7 @@ class RendererGL : angle::NonCopyable
     StateManagerGL *mStateManager;
 
     BlitGL *mBlitter;
+    ClearMultiviewGL *mMultiviewClearer;
 
     WorkaroundsGL mWorkarounds;
 

src/libANGLE/renderer/gl/SurfaceGL.cpp

@@ -26,7 +26,8 @@ SurfaceGL::~SurfaceGL()
 FramebufferImpl *SurfaceGL::createDefaultFramebuffer(const gl::FramebufferState &data)
 {
     return new FramebufferGL(data, mRenderer->getFunctions(), mRenderer->getStateManager(),
-                             mRenderer->getWorkarounds(), mRenderer->getBlitter(), true);
+                             mRenderer->getWorkarounds(), mRenderer->getBlitter(),
+                             mRenderer->getMultiviewClearer(), true);
 }
 
 egl::Error SurfaceGL::getSyncValues(EGLuint64KHR *ust, EGLuint64KHR *msc, EGLuint64KHR *sbc)

src/libANGLE/renderer/gl/cgl/PbufferSurfaceCGL.mm

@@ -141,7 +141,8 @@ FramebufferImpl *PbufferSurfaceCGL::createDefaultFramebuffer(const gl::Framebuff
 {
     // TODO(cwallez) assert it happens only once?
     return new FramebufferGL(mFramebuffer, state, mFunctions, mRenderer->getWorkarounds(),
-                             mRenderer->getBlitter(), mStateManager);
+                             mRenderer->getBlitter(), mRenderer->getMultiviewClearer(),
+                             mStateManager);
 }
 
 }  // namespace rx

src/libANGLE/renderer/gl/cgl/WindowSurfaceCGL.mm

@@ -330,7 +330,7 @@ FramebufferImpl *WindowSurfaceCGL::createDefaultFramebuffer(const gl::Framebuffe
 {
     // TODO(cwallez) assert it happens only once?
     return new FramebufferGL(mFramebuffer, state, mFunctions, mWorkarounds, mRenderer->getBlitter(),
-                             mStateManager);
+                             mRenderer->getMultiviewClearer(), mStateManager);
 }
 
 }  // namespace rx

src/libANGLE/renderer/gl/egl/ozone/DisplayOzone.cpp

@@ -309,7 +309,8 @@ FramebufferGL *DisplayOzone::Buffer::framebufferGL(const gl::FramebufferState &s
 {
     return new FramebufferGL(
         mGLFB, state, mDisplay->mFunctionsGL, mDisplay->getRenderer()->getWorkarounds(),
-        mDisplay->getRenderer()->getBlitter(), mDisplay->getRenderer()->getStateManager());
+        mDisplay->getRenderer()->getBlitter(), mDisplay->getRenderer()->getMultiviewClearer(),
+        mDisplay->getRenderer()->getStateManager());
 }
 
 void DisplayOzone::Buffer::present()

src/libANGLE/renderer/gl/wgl/D3DTextureSurfaceWGL.cpp

@@ -466,7 +466,8 @@ EGLint D3DTextureSurfaceWGL::getSwapBehavior() const
 FramebufferImpl *D3DTextureSurfaceWGL::createDefaultFramebuffer(const gl::FramebufferState &data)
 {
     return new FramebufferGL(mFramebufferID, data, mFunctionsGL, mWorkarounds,
-                             mRenderer->getBlitter(), mStateManager);
+                             mRenderer->getBlitter(), mRenderer->getMultiviewClearer(),
+                             mStateManager);
 }
 
 HDC D3DTextureSurfaceWGL::getDC() const

src/libANGLE/renderer/gl/wgl/DXGISwapChainWindowSurfaceWGL.cpp

@@ -270,7 +270,8 @@ FramebufferImpl *DXGISwapChainWindowSurfaceWGL::createDefaultFramebuffer(
     const gl::FramebufferState &data)
 {
     return new FramebufferGL(mFramebufferID, data, mFunctionsGL, mWorkarounds,
-                             mRenderer->getBlitter(), mStateManager);
+                             mRenderer->getBlitter(), mRenderer->getMultiviewClearer(),
+                             mStateManager);
 }
 
 HDC DXGISwapChainWindowSurfaceWGL::getDC() const

src/libGLESv2.gypi

@@ -559,6 +559,8 @@
             'libANGLE/renderer/gl/BlitGL.h',
             'libANGLE/renderer/gl/BufferGL.cpp',
             'libANGLE/renderer/gl/BufferGL.h',
+            'libANGLE/renderer/gl/ClearMultiviewGL.cpp',
+            'libANGLE/renderer/gl/ClearMultiviewGL.h',
             'libANGLE/renderer/gl/CompilerGL.cpp',
             'libANGLE/renderer/gl/CompilerGL.h',
             'libANGLE/renderer/gl/ContextGL.cpp',