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

• Show log

  Commit

• Hash : c2679dbc
  Author :
  Date : 2025-03-10T12:15:08
  

  Key vertex array index range cache on restart
  
  Key vertex array index range cache on primitive restart enablement.
  Add the test to WebGLCompatibilityTest as otherwise the
  VertexArray::getIndexRange() is not testable. Currently WebGL
  compatibility contexts allow changing primitive restart.
  
  Bug: angleproject:401284933
  Change-Id: I48a53770d7dcb2276b89fd743f4834c53c8d8d1e
  Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/6333538
  Auto-Submit: Kimmo Kinnunen <kkinnunen@apple.com>
  Reviewed-by: Geoff Lang <geofflang@chromium.org>
  Reviewed-by: Kenneth Russell <kbr@chromium.org>
  

Download

• src/libANGLE/IndexRangeCache.h

• //
  // Copyright 2013 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.
  //
  
  // IndexRangeCache.h: Defines the gl::IndexRangeCache class which stores information about
  // ranges of indices.
  
  #ifndef LIBANGLE_INDEXRANGECACHE_H_
  #define LIBANGLE_INDEXRANGECACHE_H_
  
  #include "angle_gl.h"
  #include "common/PackedEnums.h"
  #include "common/angleutils.h"
  #include "common/mathutil.h"
  
  #include <map>
  
  namespace gl
  {
  
  struct IndexRangeKey
  {
      IndexRangeKey() = default;
      IndexRangeKey(DrawElementsType type, size_t offset, size_t count, bool primitiveRestart);
      bool operator<(const IndexRangeKey &rhs) const;
      bool operator==(const IndexRangeKey &rhs) const;
  
      DrawElementsType type{DrawElementsType::InvalidEnum};
      size_t offset{0};
      size_t count{0};
      bool primitiveRestartEnabled{false};
  };
  
  class IndexRangeCache
  {
    public:
      IndexRangeCache();
      ~IndexRangeCache();
  
      void addRange(DrawElementsType type,
                    size_t offset,
                    size_t count,
                    bool primitiveRestartEnabled,
                    const IndexRange &range);
      bool findRange(DrawElementsType type,
                     size_t offset,
                     size_t count,
                     bool primitiveRestartEnabled,
                     IndexRange *outRange) const;
  
      void invalidateRange(size_t offset, size_t size);
      void clear();
  
    private:
      std::map<IndexRangeKey, IndexRange> mIndexRangeCache;
  };
  
  // First level cache stored inline at the query site.
  class IndexRangeInlineCache
  {
    public:
      IndexRangeInlineCache() = default;
      IndexRangeInlineCache(DrawElementsType type,
                            size_t offset,
                            size_t count,
                            bool primitiveRestartEnabled,
                            IndexRange indexRange)
          : mPayload(std::move(indexRange)), mKey(type, offset, count, primitiveRestartEnabled)
      {}
  
      bool get(DrawElementsType type,
               size_t offset,
               size_t count,
               bool primitiveRestartEnabled,
               IndexRange *indexRangeOut)
      {
          if (mKey == IndexRangeKey(type, offset, count, primitiveRestartEnabled))
          {
              *indexRangeOut = mPayload;
              return true;
          }
          return false;
      }
  
    private:
      IndexRange mPayload{IndexRange::Undefined{}};
      IndexRangeKey mKey;
  };
  
  inline IndexRangeKey::IndexRangeKey(DrawElementsType type_,
                                      size_t offset_,
                                      size_t count_,
                                      bool primitiveRestartEnabled_)
      : type(type_), offset(offset_), count(count_), primitiveRestartEnabled(primitiveRestartEnabled_)
  {}
  
  inline bool IndexRangeKey::operator==(const IndexRangeKey &rhs) const
  {
      return type == rhs.type && offset == rhs.offset && count == rhs.count &&
             primitiveRestartEnabled == rhs.primitiveRestartEnabled;
  }
  
  }  // namespace gl
  
  #endif  // LIBANGLE_INDEXRANGECACHE_H_
  

Download