kc3-lang/angle/src/libGLESv2/renderer/IndexRangeCache.cpp

• Show log

  Commit

• Hash : 5d601382
  Author :
  Date : 2014-07-22T15:14:06
  

  Simplify formatutils.h by exposing the info structures.
  
  Removed all the separate query functions and simply expose the internal
  info structures.  This reduces the number of std::map/std::set operations
  that were hidden behind the API.
  
  Moved the validation tables for ES3 format combinations and effective
  internal formats into validationES3.cpp so that formatutils.h only has
  generic GL format queries.
  
  BUG=angle:658
  
  Change-Id: Ieb60d42b8eafcdb4f21dcbec130b39478ce5f7c5
  Reviewed-on: https://chromium-review.googlesource.com/206835
  Reviewed-by: Nicolas Capens <capn@chromium.org>
  Tested-by: Geoff Lang <geofflang@chromium.org>
  

Download

• src/libGLESv2/renderer/IndexRangeCache.cpp

• #include "precompiled.h"
  //
  // Copyright (c) 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.cpp: Defines the rx::IndexRangeCache class which stores information about
  // ranges of indices.
  
  #include "libGLESv2/renderer/IndexRangeCache.h"
  #include "libGLESv2/formatutils.h"
  #include "common/debug.h"
  #include <tuple>
  
  namespace rx
  {
  
  void IndexRangeCache::addRange(GLenum type, unsigned int offset, GLsizei count, unsigned int minIdx, unsigned int maxIdx,
                                 unsigned int streamOffset)
  {
      mIndexRangeCache[IndexRange(type, offset, count)] = IndexBounds(minIdx, maxIdx, streamOffset);
  }
  
  void IndexRangeCache::invalidateRange(unsigned int offset, unsigned int size)
  {
      unsigned int invalidateStart = offset;
      unsigned int invalidateEnd = offset + size;
  
      IndexRangeMap::iterator i = mIndexRangeCache.begin();
      while (i != mIndexRangeCache.end())
      {
          unsigned int rangeStart = i->second.streamOffset;
          unsigned int rangeEnd = i->second.streamOffset + (gl::GetTypeInfo(i->first.type).bytes * i->first.count);
  
          if (invalidateEnd < rangeStart || invalidateStart > rangeEnd)
          {
              ++i;
          }
          else
          {
              i = mIndexRangeCache.erase(i);
          }
      }
  }
  
  bool IndexRangeCache::findRange(GLenum type, unsigned int offset, GLsizei count, unsigned int *outMinIndex,
                                  unsigned int *outMaxIndex, unsigned int *outStreamOffset) const
  {
      IndexRangeMap::const_iterator i = mIndexRangeCache.find(IndexRange(type, offset, count));
      if (i != mIndexRangeCache.end())
      {
          if (outMinIndex)     *outMinIndex = i->second.minIndex;
          if (outMaxIndex)     *outMaxIndex = i->second.maxIndex;
          if (outStreamOffset) *outStreamOffset = i->second.streamOffset;
          return true;
      }
      else
      {
          if (outMinIndex)     *outMinIndex = 0;
          if (outMaxIndex)     *outMaxIndex = 0;
          if (outStreamOffset) *outStreamOffset = 0;
          return false;
      }
  }
  
  void IndexRangeCache::clear()
  {
      mIndexRangeCache.clear();
  }
  
  IndexRangeCache::IndexRange::IndexRange()
      : type(GL_NONE), offset(0), count(0)
  {
  }
  
  IndexRangeCache::IndexRange::IndexRange(GLenum typ, intptr_t off, GLsizei c)
      : type(typ), offset(off), count(c)
  {
  }
  
  bool IndexRangeCache::IndexRange::operator<(const IndexRange& rhs) const
  {
      return std::make_tuple(type, offset, count) < std::make_tuple(rhs.type, rhs.offset, rhs.count);
  }
  
  IndexRangeCache::IndexBounds::IndexBounds()
      : minIndex(0), maxIndex(0), streamOffset(0)
  {
  }
  
  IndexRangeCache::IndexBounds::IndexBounds(unsigned int minIdx, unsigned int maxIdx, unsigned int offset)
      : minIndex(minIdx), maxIndex(maxIdx), streamOffset(offset)
  {
  }
  
  }
  

Download