Home | History | Annotate | Download | only in OpenglCodecCommon 
      1 /*
      2 * Copyright (C) 2016 The Android Open Source Project
      3 *
      4 * Licensed under the Apache License, Version 2.0 (the "License");
      5 * you may not use this file except in compliance with the License.
      6 * You may obtain a copy of the License at
      7 *
      8 * http://www.apache.org/licenses/LICENSE-2.0
      9 *
     10 * Unless required by applicable law or agreed to in writing, software
     11 * distributed under the License is distributed on an "AS IS" BASIS,
     12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     13 * See the License for the specific language governing permissions and
     14 * limitations under the License.
     15 */
     16 
     17 // This is almost literally
     18 // external/angle/src/common/mathutil.h: IndexRange +
     19 // external/angle/src/libANGLE/IndexRangeCache.h: IndexRangeCache,
     20 // with adaptations to work with goldfish opengl driver.
     21 // Currently, primitive restart is not supported, so there
     22 // is a very minimal incorporation of that.
     23 
     24 #ifndef _GL_INDEX_RANGE_CACHE_H_
     25 #define _GL_INDEX_RANGE_CACHE_H_
     26 
     27 #include <GLES/gl.h>
     28 #include <GLES/glext.h>
     29 #include <GLES2/gl2.h>
     30 #include <GLES2/gl2ext.h>
     31 
     32 #include "glUtils.h"
     33 
     34 #include <map>
     35 
     36 struct IndexRange {
     37     // Inclusive range of indices that are not primitive restart
     38     int start;
     39     int end;
     40 
     41     // Number of non-primitive restart indices
     42     size_t vertexIndexCount; // TODO; not being accounted yet (GLES3 feature)
     43 };
     44 
     45 class IndexRangeCache {
     46 public:
     47     void addRange(GLenum type,
     48                   size_t offset,
     49                   size_t count,
     50                   bool primitiveRestartEnabled,
     51                   int start,
     52                   int end);
     53     bool findRange(GLenum type,
     54                    size_t offset,
     55                    size_t count,
     56                    bool primitiveRestartEnabled,
     57                    int* start_out,
     58                    int* end_out) const;
     59     void invalidateRange(size_t offset, size_t size);
     60     void clear();
     61 private:
     62     struct IndexRangeKey {
     63         IndexRangeKey() :
     64             type(GL_NONE),
     65             offset(0),
     66             count(0),
     67             primitiveRestartEnabled(false) { }
     68         IndexRangeKey(GLenum _type,
     69                       size_t _offset,
     70                       size_t _count,
     71                       bool _primitiveRestart) :
     72             type(_type),
     73             offset(_offset),
     74             count(_count),
     75             primitiveRestartEnabled(_primitiveRestart) { }
     76 
     77         bool operator<(const IndexRangeKey& rhs) const {
     78             size_t end = offset + count * glSizeof(type);
     79             size_t end_other = rhs.offset + rhs.count * glSizeof(rhs.type);
     80 
     81             if (offset != rhs.offset) return offset < rhs.offset;
     82             if (end != end_other) return end < end_other;
     83             if (type != rhs.type) return type < rhs.type;
     84             if (primitiveRestartEnabled != rhs.primitiveRestartEnabled)
     85                 return primitiveRestartEnabled;
     86             return false;
     87         }
     88 
     89         GLenum type;
     90         size_t offset;
     91         size_t count;
     92         bool primitiveRestartEnabled;
     93     };
     94 
     95     typedef std::map<IndexRangeKey, IndexRange> IndexRangeMap;
     96     IndexRangeMap mIndexRangeCache;
     97 };
     98 
     99 #endif
    100