1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
|
/*
* Copyright 2013 Google Inc.
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#include "gl/GrGLExtensions.h"
#include "gl/GrGLDefines.h"
#include "gl/GrGLUtil.h"
#include "SkJSONWriter.h"
#include "SkMakeUnique.h"
#include "SkTSearch.h"
#include "SkTSort.h"
namespace { // This cannot be static because it is used as a template parameter.
inline bool extension_compare(const SkString& a, const SkString& b) {
return strcmp(a.c_str(), b.c_str()) < 0;
}
}
// finds the index of ext in strings or a negative result if ext is not found.
static int find_string(const SkTArray<SkString>& strings, const char ext[]) {
if (strings.empty()) {
return -1;
}
SkString extensionStr(ext);
int idx = SkTSearch<SkString, extension_compare>(&strings.front(),
strings.count(),
extensionStr,
sizeof(SkString));
return idx;
}
GrGLExtensions::GrGLExtensions(const GrGLExtensions& that) {
*this = that;
}
GrGLExtensions& GrGLExtensions::operator=(const GrGLExtensions& that) {
if (this != &that) {
fStrings = that.fStrings;
fInitialized = that.fInitialized;
}
return *this;
}
static void eat_space_sep_strings(SkTArray<SkString>* out, const char in[]) {
if (!in) {
return;
}
while (true) {
// skip over multiple spaces between extensions
while (' ' == *in) {
++in;
}
// quit once we reach the end of the string.
if ('\0' == *in) {
break;
}
// we found an extension
size_t length = strcspn(in, " ");
out->push_back().set(in, length);
in += length;
}
}
bool GrGLExtensions::init(GrGLStandard standard,
GrGLFunction<GrGLGetStringProc> getString,
GrGLFunction<GrGLGetStringiProc> getStringi,
GrGLFunction<GrGLGetIntegervProc> getIntegerv,
GrGLFunction<GrEGLQueryStringProc> queryString,
GrEGLDisplay eglDisplay) {
fInitialized = false;
fStrings.reset();
if (!getString) {
return false;
}
// glGetStringi and indexed extensions were added in version 3.0 of desktop GL and ES.
const GrGLubyte* verString = getString(GR_GL_VERSION);
GrGLVersion version = GrGLGetVersionFromString((const char*) verString);
if (GR_GL_INVALID_VER == version) {
return false;
}
bool indexed = version >= GR_GL_VER(3, 0);
if (indexed) {
if (!getStringi || !getIntegerv) {
return false;
}
GrGLint extensionCnt = 0;
getIntegerv(GR_GL_NUM_EXTENSIONS, &extensionCnt);
fStrings.push_back_n(extensionCnt);
for (int i = 0; i < extensionCnt; ++i) {
const char* ext = (const char*) getStringi(GR_GL_EXTENSIONS, i);
fStrings[i] = ext;
}
} else {
const char* extensions = (const char*) getString(GR_GL_EXTENSIONS);
if (!extensions) {
return false;
}
eat_space_sep_strings(&fStrings, extensions);
}
if (queryString) {
const char* extensions = queryString(eglDisplay, GR_EGL_EXTENSIONS);
eat_space_sep_strings(&fStrings, extensions);
}
if (!fStrings.empty()) {
SkTLessFunctionToFunctorAdaptor<SkString, extension_compare> cmp;
SkTQSort(&fStrings.front(), &fStrings.back(), cmp);
}
fInitialized = true;
return true;
}
bool GrGLExtensions::has(const char ext[]) const {
SkASSERT(fInitialized);
return find_string(fStrings, ext) >= 0;
}
bool GrGLExtensions::remove(const char ext[]) {
SkASSERT(fInitialized);
int idx = find_string(fStrings, ext);
if (idx < 0) {
return false;
}
// This is not terribly effecient but we really only expect this function to be called at
// most a handful of times when our test programs start.
fStrings.removeShuffle(idx);
if (idx != fStrings.count()) {
SkTLessFunctionToFunctorAdaptor<SkString, extension_compare> cmp;
SkTInsertionSort(&(fStrings.operator[](idx)), &fStrings.back(), cmp);
}
return true;
}
void GrGLExtensions::add(const char ext[]) {
int idx = find_string(fStrings, ext);
if (idx < 0) {
// This is not the most effecient approach since we end up looking at all of the
// extensions after the add
fStrings.emplace_back(ext);
SkTLessFunctionToFunctorAdaptor<SkString, extension_compare> cmp;
SkTInsertionSort(&fStrings.front(), &fStrings.back(), cmp);
}
}
void GrGLExtensions::dumpJSON(SkJSONWriter* writer) const {
writer->beginArray();
for (int i = 0; i < fStrings.count(); ++i) {
writer->appendString(fStrings[i].c_str());
}
writer->endArray();
}
|
