kc3-lang/angle/src/libANGLE/ImageIndex.h

• Show log

  Commit

• Hash : cb16fb5f
  Author :
  Date : 2019-08-29T16:53:55
  

  Vulkan: Support texture base and max levels
  
  The Vulkan backend uses a vkImage that matches the number
  of effective levels in the GL texture. This is due to the fact
  that GL textures can have really strange layouts that only make
  sense when base level and max level are applied.
  
  For instance, take the following layout with disjoint mip levels:
  
    Level 0: 4x4 RGBA
    Level 1: 2x2 RGBA
    Level 2: 10x10 RGB
  
  If base level is set to zero and max level is set to 1, the image is
  still considered mip-complete:
  
    Level 0: 4x4 RGBA  ==> Base Level 0 ==>  Level 0: 4x4 RGBA
    Level 1: 2x2 RGBA  ==> Max Level 1  ==>  Level 1: 2x2 RGBA
    Level 2: 10x10 RGB
  
  If base and max level are then both set to 2, the texture is still
  considered complete, but of a different size and format:
  
    Level 0: 4x4 RGBA
    Level 1: 2x2 RGBA
    Level 2: 10x10 RGB ==> Base/Max Level 2 ==> Level 2: 10x10 RGB
  
  When the base or max level is changed, we must recreate the vkImage to
  match the new level count.
  
  To support that, we:
  
   - Stage updates from the current image to the new image
   - Only stage updates if there aren't already staged updates for a level
   - Free the current image and so it can be recreated at the next draw
  
  This CL does the following:
  
   - Refactors TextureVk::copyImageDataToBuffer to support staging updates
     without flush
   - Adds TextureVk::copyImageDataToBufferAndGetData to support previous
     use model
   - Adds TextureVk::changeLevels, triggered during syncState, which stages
     updates and releases the current image.
   - Updates ImageHelper::flushStagedUpdates to understand base/max levels
   - Updates TextureVk::ensureImageInitialized and TextureVk::generateMipmap
     to account for base/max level
   - Tracks base and max levels in ImageHelper
   - Adds ImageHelper::stageSubresourceUpdateFromBuffer to support
     this use case
   - Adds ImageHelper::isUpdateStaged to determine if changeLevels
     should propagate data
   - Makes gl::TextureTypeToTarget available for use outside of ImageIndex
   - Enables several deqp and end2end tests
  
  Bug: angleproject:3148
  Test: dEQP-GLES3.functional.texture.mipmap.*base_level*
  Test: dEQP-GLES3.functional.texture.mipmap.*max_level*
  Change-Id: I14ca071c9c62eb310dfed7ef9290dc65fc3ff696
  Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/1776933
  Reviewed-by: Courtney Goeltzenleuchter <courtneygo@google.com>
  Commit-Queue: Cody Northrop <cnorthrop@google.com>
  

Download

• src/libANGLE/ImageIndex.h

• //
  // Copyright 2014 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.
  //
  
  // ImageIndex.h: A helper struct for indexing into an Image array
  
  #ifndef LIBANGLE_IMAGE_INDEX_H_
  #define LIBANGLE_IMAGE_INDEX_H_
  
  #include "common/PackedEnums.h"
  #include "common/mathutil.h"
  
  #include "angle_gl.h"
  
  namespace gl
  {
  
  class ImageIndexIterator;
  
  class ImageIndex
  {
    public:
      ImageIndex();
      ImageIndex(const ImageIndex &other);
      ImageIndex &operator=(const ImageIndex &other);
  
      TextureType getType() const { return mType; }
      GLint getLevelIndex() const { return mLevelIndex; }
      GLint getLayerIndex() const { return mLayerIndex; }
      GLint getLayerCount() const { return mLayerCount; }
  
      bool hasLayer() const;
      bool has3DLayer() const;
      bool usesTex3D() const;
      GLint cubeMapFaceIndex() const;
      bool valid() const;
      // Note that you cannot use this function when the ImageIndex represents an entire level of cube
      // map.
      TextureTarget getTarget() const;
  
      TextureTarget getTargetOrFirstCubeFace() const;
  
      bool isLayered() const;
      bool isEntireLevelCubeMap() const;
  
      static ImageIndex Make2D(GLint levelIndex);
      static ImageIndex MakeRectangle(GLint levelIndex);
      static ImageIndex MakeCubeMapFace(TextureTarget target, GLint levelIndex);
      static ImageIndex Make2DArray(GLint levelIndex, GLint layerIndex = kEntireLevel);
      static ImageIndex Make2DArrayRange(GLint levelIndex, GLint layerIndex, GLint layerCount);
      static ImageIndex Make3D(GLint levelIndex, GLint layerIndex = kEntireLevel);
      static ImageIndex MakeFromTarget(TextureTarget target, GLint levelIndex, GLint depth);
      static ImageIndex MakeFromType(TextureType type,
                                     GLint levelIndex,
                                     GLint layerIndex = kEntireLevel,
                                     GLint layerCount = 1);
      static ImageIndex Make2DMultisample();
      static ImageIndex Make2DMultisampleArray(GLint layerIndex = kEntireLevel);
      static ImageIndex Make2DMultisampleArrayRange(GLint layerIndex, GLint layerCount);
  
      static constexpr GLint kEntireLevel = static_cast<GLint>(-1);
  
      bool operator<(const ImageIndex &b) const;
      bool operator==(const ImageIndex &b) const;
      bool operator!=(const ImageIndex &b) const;
  
      // Only valid for 3D/Cube textures with layers.
      ImageIndexIterator getLayerIterator(GLint layerCount) const;
  
    private:
      friend class ImageIndexIterator;
  
      ImageIndex(TextureType type, GLint leveIndex, GLint layerIndex, GLint layerCount);
  
      TextureType mType;
      GLint mLevelIndex;
      GLint mLayerIndex;
      GLint mLayerCount;
  };
  
  // To be used like this:
  //
  // ImageIndexIterator it = ...;
  // while (it.hasNext())
  // {
  //     ImageIndex current = it.next();
  // }
  class ImageIndexIterator
  {
    public:
      ImageIndexIterator(const ImageIndexIterator &other);
  
      static ImageIndexIterator Make2D(GLint minMip, GLint maxMip);
      static ImageIndexIterator MakeRectangle(GLint minMip, GLint maxMip);
      static ImageIndexIterator MakeCube(GLint minMip, GLint maxMip);
      static ImageIndexIterator Make3D(GLint minMip, GLint maxMip, GLint minLayer, GLint maxLayer);
      static ImageIndexIterator Make2DArray(GLint minMip, GLint maxMip, const GLsizei *layerCounts);
      static ImageIndexIterator Make2DMultisample();
      static ImageIndexIterator Make2DMultisampleArray(const GLsizei *layerCounts);
      static ImageIndexIterator MakeGeneric(TextureType type,
                                            GLint minMip,
                                            GLint maxMip,
                                            GLint minLayer,
                                            GLint maxLayer);
  
      ImageIndex next();
      ImageIndex current() const;
      bool hasNext() const;
  
    private:
      ImageIndexIterator(TextureType type,
                         const Range<GLint> &mipRange,
                         const Range<GLint> &layerRange,
                         const GLsizei *layerCounts);
  
      GLint maxLayer() const;
  
      const Range<GLint> mMipRange;
      const Range<GLint> mLayerRange;
      const GLsizei *const mLayerCounts;
  
      ImageIndex mCurrentIndex;
  };
  
  TextureTarget TextureTypeToTarget(TextureType type, GLint layerIndex);
  
  }  // namespace gl
  
  #endif  // LIBANGLE_IMAGE_INDEX_H_
  

Download