kc3-lang/angle/src/libANGLE/Context.inl.h

• Show log

  Commit

• Hash : 248119b3
  Author :
  Date : 2020-07-20T16:05:45
  

  Vulkan: Fix render target's tracking of content defined
  
  Imagine the following scenario:
  
  1. Clear draw framebuffer
  2. Invalidate draw framebuffer
  3. Update texture attached to draw framebuffer
  4. Draw again into draw framebuffer
  
  Step 3 could be a number of things, such as glCopyTex[Sub]Image,
  glBlitFramebuffer, glTex[Sub]Image2D, glGenerateMipmap etc.
  
  In the above scenario, at step 2, the framebuffer's render target
  remembers it being invalidated (mContentDefined = false).  This is used
  to set the loadOp of the next render pass to DONT_CARE.
  
  However, mContentDefined was implemented for a very specific
  optimization regarding the swapchain's depth buffer.  The reuse of this
  variable for glInvalidateFramebuffer was erroneous as this variable
  didn't track whether the contents are defined for the general case.
  
  With this change, mContentDefined is set to true during
  FramebufferVk::syncState for each render target whose contents are
  marked dirty.
  
  This change additionally makes glBlitFramebuffer signal the contents of
  the blit targets as dirty, as well as textures that are used as storage
  images.
  
  Bug: angleproject:4859
  Change-Id: I68c829f75ff4a3d03bb293ec72c609384983026d
  Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/2309110
  Commit-Queue: Shahbaz Youssefi <syoussefi@chromium.org>
  Reviewed-by: Jamie Madill <jmadill@chromium.org>
  Reviewed-by: Charlie Lao <cclao@google.com>
  

Download

• src/libANGLE/Context.inl.h

• //
  // Copyright 2018 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.
  //
  
  // Context.inl.h: Defines inline functions of gl::Context class
  // Has to be included after libANGLE/Context.h when using one
  // of the defined functions
  
  #ifndef LIBANGLE_CONTEXT_INL_H_
  #define LIBANGLE_CONTEXT_INL_H_
  
  #include "libANGLE/GLES1Renderer.h"
  #include "libANGLE/renderer/ContextImpl.h"
  
  #define ANGLE_HANDLE_ERR(X) \
      (void)(X);              \
      return;
  #define ANGLE_CONTEXT_TRY(EXPR) ANGLE_TRY_TEMPLATE(EXPR, ANGLE_HANDLE_ERR)
  
  namespace gl
  {
  constexpr angle::PackedEnumMap<PrimitiveMode, GLsizei> kMinimumPrimitiveCounts = {{
      {PrimitiveMode::Points, 1},
      {PrimitiveMode::Lines, 2},
      {PrimitiveMode::LineLoop, 2},
      {PrimitiveMode::LineStrip, 2},
      {PrimitiveMode::Triangles, 3},
      {PrimitiveMode::TriangleStrip, 3},
      {PrimitiveMode::TriangleFan, 3},
      {PrimitiveMode::LinesAdjacency, 2},
      {PrimitiveMode::LineStripAdjacency, 2},
      {PrimitiveMode::TrianglesAdjacency, 3},
      {PrimitiveMode::TriangleStripAdjacency, 3},
  }};
  
  ANGLE_INLINE void MarkTransformFeedbackBufferUsage(const Context *context,
                                                     GLsizei count,
                                                     GLsizei instanceCount)
  {
      if (context->getStateCache().isTransformFeedbackActiveUnpaused())
      {
          TransformFeedback *transformFeedback = context->getState().getCurrentTransformFeedback();
          transformFeedback->onVerticesDrawn(context, count, instanceCount);
      }
  }
  
  ANGLE_INLINE void MarkShaderStorageUsage(const Context *context)
  {
      for (size_t index : context->getStateCache().getActiveShaderStorageBufferIndices())
      {
          Buffer *buffer = context->getState().getIndexedShaderStorageBuffer(index).get();
          if (buffer)
          {
              buffer->onDataChanged();
          }
      }
  
      for (size_t index : context->getStateCache().getActiveImageUnitIndices())
      {
          const ImageUnit &imageUnit = context->getState().getImageUnit(index);
          const Texture *texture     = imageUnit.texture.get();
          if (texture)
          {
              texture->onStateChange(angle::SubjectMessage::ContentsChanged);
          }
      }
  }
  
  // Return true if the draw is a no-op, else return false.
  //  If there is no active program for the vertex or fragment shader stages, the results of vertex
  //  and fragment shader execution will respectively be undefined. However, this is not
  //  an error. ANGLE will treat this as a no-op.
  //  A no-op draw occurs if the count of vertices is less than the minimum required to
  //  have a valid primitive for this mode (0 for points, 0-1 for lines, 0-2 for tris).
  ANGLE_INLINE bool Context::noopDraw(PrimitiveMode mode, GLsizei count) const
  {
      if (!mStateCache.getCanDraw())
      {
          return true;
      }
  
      return count < kMinimumPrimitiveCounts[mode];
  }
  
  ANGLE_INLINE angle::Result Context::syncDirtyBits()
  {
      const State::DirtyBits &dirtyBits = mState.getDirtyBits();
      ANGLE_TRY(mImplementation->syncState(this, dirtyBits, mAllDirtyBits));
      mState.clearDirtyBits();
      return angle::Result::Continue;
  }
  
  ANGLE_INLINE angle::Result Context::syncDirtyBits(const State::DirtyBits &bitMask)
  {
      const State::DirtyBits &dirtyBits = (mState.getDirtyBits() & bitMask);
      ANGLE_TRY(mImplementation->syncState(this, dirtyBits, bitMask));
      mState.clearDirtyBits(dirtyBits);
      return angle::Result::Continue;
  }
  
  ANGLE_INLINE angle::Result Context::syncDirtyObjects(const State::DirtyObjects &objectMask)
  {
      return mState.syncDirtyObjects(this, objectMask);
  }
  
  ANGLE_INLINE angle::Result Context::prepareForDraw(PrimitiveMode mode)
  {
      if (mGLES1Renderer)
      {
          ANGLE_TRY(mGLES1Renderer->prepareForDraw(mode, this, &mState));
      }
  
      ANGLE_TRY(syncDirtyObjects(mDrawDirtyObjects));
      ASSERT(!isRobustResourceInitEnabled() ||
             !mState.getDrawFramebuffer()->hasResourceThatNeedsInit());
      return syncDirtyBits();
  }
  
  ANGLE_INLINE void Context::drawArrays(PrimitiveMode mode, GLint first, GLsizei count)
  {
      // No-op if count draws no primitives for given mode
      if (noopDraw(mode, count))
      {
          return;
      }
  
      ANGLE_CONTEXT_TRY(prepareForDraw(mode));
      ANGLE_CONTEXT_TRY(mImplementation->drawArrays(this, mode, first, count));
      MarkTransformFeedbackBufferUsage(this, count, 1);
  }
  
  ANGLE_INLINE void Context::drawElements(PrimitiveMode mode,
                                          GLsizei count,
                                          DrawElementsType type,
                                          const void *indices)
  {
      // No-op if count draws no primitives for given mode
      if (noopDraw(mode, count))
      {
          return;
      }
  
      ANGLE_CONTEXT_TRY(prepareForDraw(mode));
      ANGLE_CONTEXT_TRY(mImplementation->drawElements(this, mode, count, type, indices));
  }
  
  ANGLE_INLINE void StateCache::onBufferBindingChange(Context *context)
  {
      updateBasicDrawStatesError();
      updateBasicDrawElementsError();
  }
  
  ANGLE_INLINE void Context::bindBuffer(BufferBinding target, BufferID buffer)
  {
      Buffer *bufferObject =
          mState.mBufferManager->checkBufferAllocation(mImplementation.get(), buffer);
      mState.setBufferBinding(this, target, bufferObject);
      mStateCache.onBufferBindingChange(this);
  }
  
  }  // namespace gl
  
  #endif  // LIBANGLE_CONTEXT_INL_H_
  

Download