OLD | NEW |
1 /* | 1 /* |
2 * Copyright 2011 Google Inc. | 2 * Copyright 2011 Google Inc. |
3 * | 3 * |
4 * Use of this source code is governed by a BSD-style license that can be | 4 * Use of this source code is governed by a BSD-style license that can be |
5 * found in the LICENSE file. | 5 * found in the LICENSE file. |
6 */ | 6 */ |
7 | 7 |
8 | 8 |
9 #include "GrNonAtomicRef.h" | |
10 #include "gl/GrGLInterface.h" | 9 #include "gl/GrGLInterface.h" |
11 #include "GrGLTestInterface.h" | 10 #include "GrGLTestInterface.h" |
12 #include "SkMutex.h" | 11 #include "SkMutex.h" |
13 #include "SkTDArray.h" | 12 #include "SkTDArray.h" |
14 #include <type_traits> | |
15 | 13 |
16 // added to suppress 'no previous prototype' warning and because this code is du
plicated in | 14 // added to suppress 'no previous prototype' warning and because this code is du
plicated in |
17 // SkNullGLContext.cpp | 15 // SkNullGLContext.cpp |
18 namespace { | 16 namespace { |
19 | 17 |
20 class GLObject : public GrNonAtomicRef<GLObject> { | 18 class BufferObj { |
21 public: | 19 public: |
22 GLObject(GrGLuint id) : fID(id) {} | 20 BufferObj(GrGLuint id) : fID(id), fDataPtr(nullptr), fSize(0), fMapped(false
) {} |
23 GrGLuint id() const { return fID; } | 21 ~BufferObj() { delete[] fDataPtr; } |
24 | |
25 private: | |
26 GrGLuint fID; | |
27 }; | |
28 | |
29 // This class maintains a sparsely populated array of object pointers. | |
30 template<typename T> class TGLObjectManager { | |
31 static_assert(std::is_convertible<T*, GLObject*>::value, "T must be a subclas
s of GLObject"); | |
32 | |
33 public: | |
34 TGLObjectManager() : fFreeListHead(kFreeListEnd) { | |
35 *fGLObjects.append() = nullptr; // 0 is not a valid GL object id. | |
36 } | |
37 | |
38 ~TGLObjectManager() { | |
39 // nullptr out the entries that are really free list links rather than p
trs before deleting. | |
40 intptr_t curr = fFreeListHead; | |
41 while (kFreeListEnd != curr) { | |
42 intptr_t next = reinterpret_cast<intptr_t>(fGLObjects[SkToS32(curr)]
); | |
43 fGLObjects[SkToS32(curr)] = nullptr; | |
44 curr = next; | |
45 } | |
46 | |
47 fGLObjects.safeUnrefAll(); | |
48 } | |
49 | |
50 T* lookUp(GrGLuint id) { | |
51 T* object = fGLObjects[id]; | |
52 SkASSERT(object && object->id() == id); | |
53 return object; | |
54 } | |
55 | |
56 T* create() { | |
57 GrGLuint id; | |
58 T* object; | |
59 | |
60 if (kFreeListEnd == fFreeListHead) { | |
61 // no free slots - create a new one | |
62 id = fGLObjects.count(); | |
63 object = new T(id); | |
64 *fGLObjects.append() = object; | |
65 } else { | |
66 // grab the head of the free list and advance the head to the next f
ree slot. | |
67 id = static_cast<GrGLuint>(fFreeListHead); | |
68 fFreeListHead = reinterpret_cast<intptr_t>(fGLObjects[id]); | |
69 | |
70 object = new T(id); | |
71 fGLObjects[id] = object; | |
72 } | |
73 | |
74 return object; | |
75 } | |
76 | |
77 void free(T* object) { | |
78 SkASSERT(object); | |
79 SkASSERT(fGLObjects.count() > 0); | |
80 | |
81 GrGLuint id = object->id(); | |
82 object->unref(); | |
83 | |
84 fGLObjects[id] = reinterpret_cast<T*>(fFreeListHead); | |
85 fFreeListHead = id; | |
86 } | |
87 | |
88 private: | |
89 static const intptr_t kFreeListEnd = -1; | |
90 // Index of the first entry of fGLObjects in the free list. Free slots in fG
LObjects are indices | |
91 // to the next free slot. The last free slot has a value of kFreeListEnd. | |
92 intptr_t fFreeListHead; | |
93 SkTDArray<T*> fGLObjects; | |
94 }; | |
95 | |
96 class Buffer : public GLObject { | |
97 public: | |
98 Buffer(GrGLuint id) : INHERITED(id), fDataPtr(nullptr), fSize(0), fMapped(fa
lse) {} | |
99 ~Buffer() { delete[] fDataPtr; } | |
100 | 22 |
101 void allocate(GrGLsizeiptr size, const GrGLchar* dataPtr) { | 23 void allocate(GrGLsizeiptr size, const GrGLchar* dataPtr) { |
102 if (fDataPtr) { | 24 if (fDataPtr) { |
103 SkASSERT(0 != fSize); | 25 SkASSERT(0 != fSize); |
104 delete[] fDataPtr; | 26 delete[] fDataPtr; |
105 } | 27 } |
106 | 28 |
107 fSize = size; | 29 fSize = size; |
108 fDataPtr = new char[size]; | 30 fDataPtr = new char[size]; |
109 } | 31 } |
110 | 32 |
| 33 GrGLuint id() const { return fID; } |
111 GrGLchar* dataPtr() { return fDataPtr; } | 34 GrGLchar* dataPtr() { return fDataPtr; } |
112 GrGLsizeiptr size() const { return fSize; } | 35 GrGLsizeiptr size() const { return fSize; } |
113 | 36 |
114 void setMapped(bool mapped) { fMapped = mapped; } | 37 void setMapped(bool mapped) { fMapped = mapped; } |
115 bool mapped() const { return fMapped; } | 38 bool mapped() const { return fMapped; } |
116 | 39 |
117 private: | 40 private: |
| 41 GrGLuint fID; |
118 GrGLchar* fDataPtr; | 42 GrGLchar* fDataPtr; |
119 GrGLsizeiptr fSize; // size in bytes | 43 GrGLsizeiptr fSize; // size in bytes |
120 bool fMapped; | 44 bool fMapped; |
121 | |
122 typedef GLObject INHERITED; | |
123 }; | 45 }; |
124 | 46 |
125 class FramebufferAttachment : public GLObject { | 47 // This class maintains a sparsely populated array of buffer pointers. |
| 48 class BufferManager { |
126 public: | 49 public: |
127 FramebufferAttachment(int id) : INHERITED(id), fNumSamples(1) {} | 50 BufferManager() : fFreeListHead(kFreeListEnd) { |
128 int numSamples() const { return fNumSamples; } | 51 *fBuffers.append() = nullptr; // 0 is not a valid GL buffer id. |
| 52 } |
129 | 53 |
130 protected: | 54 ~BufferManager() { |
131 int fNumSamples; | 55 // nullptr out the entries that are really free list links rather than p
trs before deleting. |
| 56 intptr_t curr = fFreeListHead; |
| 57 while (kFreeListEnd != curr) { |
| 58 intptr_t next = reinterpret_cast<intptr_t>(fBuffers[SkToS32(curr)]); |
| 59 fBuffers[SkToS32(curr)] = nullptr; |
| 60 curr = next; |
| 61 } |
132 | 62 |
133 typedef GLObject INHERITED; | 63 fBuffers.deleteAll(); |
134 }; | 64 } |
135 | 65 |
136 class Renderbuffer : public FramebufferAttachment { | 66 BufferObj* lookUp(GrGLuint id) { |
137 public: | 67 BufferObj* buffer = fBuffers[id]; |
138 Renderbuffer(int id) : INHERITED(id) {} | 68 SkASSERT(buffer && buffer->id() == id); |
139 void setNumSamples(int numSamples) { fNumSamples = numSamples; } | 69 return buffer; |
| 70 } |
140 | 71 |
141 private: | 72 BufferObj* create() { |
142 typedef FramebufferAttachment INHERITED; | 73 GrGLuint id; |
143 }; | 74 BufferObj* buffer; |
144 | 75 |
145 class Texture : public FramebufferAttachment { | 76 if (kFreeListEnd == fFreeListHead) { |
146 public: | 77 // no free slots - create a new one |
147 // We currently only use FramebufferAttachment objects for a sample count, a
nd all textures in | 78 id = fBuffers.count(); |
148 // Skia have one sample, so there is no need as of yet to track individual t
extures. This also | 79 buffer = new BufferObj(id); |
149 // works around a bug in chromium's cc_unittests where they send us texture
IDs that were | 80 *fBuffers.append() = buffer; |
150 // generated by cc::TestGLES2Interface. | 81 } else { |
151 static Texture* GetSingleInstance() { | 82 // grab the head of the free list and advance the head to the next f
ree slot. |
152 static Texture* singleInstance; | 83 id = static_cast<GrGLuint>(fFreeListHead); |
153 if (!singleInstance) { | 84 fFreeListHead = reinterpret_cast<intptr_t>(fBuffers[id]); |
154 singleInstance = new Texture(); | 85 |
| 86 buffer = new BufferObj(id); |
| 87 fBuffers[id] = buffer; |
155 } | 88 } |
156 return singleInstance; | 89 |
| 90 return buffer; |
| 91 } |
| 92 |
| 93 void free(BufferObj* buffer) { |
| 94 SkASSERT(buffer); |
| 95 SkASSERT(fBuffers.count() > 0); |
| 96 |
| 97 GrGLuint id = buffer->id(); |
| 98 delete buffer; |
| 99 |
| 100 fBuffers[id] = reinterpret_cast<BufferObj*>(fFreeListHead); |
| 101 fFreeListHead = id; |
157 } | 102 } |
158 | 103 |
159 private: | 104 private: |
160 Texture() : INHERITED(1) {} | 105 static const intptr_t kFreeListEnd = -1; |
161 | 106 // Index of the first entry of fBuffers in the free list. Free slots in fBuf
fers are indices to |
162 typedef FramebufferAttachment INHERITED; | 107 // the next free slot. The last free slot has a value of kFreeListEnd. |
163 }; | 108 intptr_t fFreeListHead; |
164 | 109 SkTDArray<BufferObj*> fBuffers; |
165 class Framebuffer : public GLObject { | |
166 public: | |
167 Framebuffer(int id) : INHERITED(id) {} | |
168 | |
169 void setAttachment(GrGLenum attachmentPoint, const FramebufferAttachment* at
tachment) { | |
170 switch (attachmentPoint) { | |
171 default: | |
172 SK_ABORT("Invalid framebuffer attachment."); | |
173 break; | |
174 case GR_GL_STENCIL_ATTACHMENT: | |
175 fAttachments[(int)AttachmentPoint::kStencil].reset(SkRef(attachm
ent)); | |
176 break; | |
177 case GR_GL_DEPTH_ATTACHMENT: | |
178 fAttachments[(int)AttachmentPoint::kDepth].reset(SkRef(attachmen
t)); | |
179 break; | |
180 case GR_GL_COLOR_ATTACHMENT0: | |
181 fAttachments[(int)AttachmentPoint::kColor].reset(SkRef(attachmen
t)); | |
182 break; | |
183 } | |
184 } | |
185 | |
186 void notifyAttachmentDeleteWhileBound(const FramebufferAttachment* deleted)
{ | |
187 for (auto& attachment : fAttachments) { | |
188 if (attachment == deleted) { | |
189 attachment.reset(nullptr); | |
190 } | |
191 } | |
192 } | |
193 | |
194 int numSamples() const { | |
195 int numSamples = 0; | |
196 for (auto& attachment : fAttachments) { | |
197 if (!attachment) { | |
198 continue; | |
199 } | |
200 if (numSamples) { | |
201 GrAlwaysAssert(attachment->numSamples() == numSamples); | |
202 continue; | |
203 } | |
204 numSamples = attachment->numSamples(); | |
205 } | |
206 GrAlwaysAssert(numSamples); | |
207 return numSamples; | |
208 } | |
209 | |
210 private: | |
211 enum AttachmentPoint { | |
212 kStencil, | |
213 kDepth, | |
214 kColor | |
215 }; | |
216 constexpr int static kNumAttachmentPoints = 1 + (int)AttachmentPoint::kColor
; | |
217 | |
218 SkAutoTUnref<const FramebufferAttachment> fAttachments[kNumAttachmentPoints]
; | |
219 | |
220 typedef GLObject INHERITED; | |
221 }; | 110 }; |
222 | 111 |
223 /** Null interface implementation */ | 112 /** Null interface implementation */ |
224 class NullInterface : public GrGLTestInterface { | 113 class NullInterface : public GrGLTestInterface { |
225 public: | 114 public: |
226 NullInterface(bool enableNVPR) | 115 NullInterface(bool enableNVPR) |
227 : fCurrDrawFramebuffer(0) | 116 : fCurrProgramID(0) |
228 , fCurrReadFramebuffer(0) | |
229 , fCurrRenderbuffer(0) | |
230 , fCurrProgramID(0) | |
231 , fCurrShaderID(0) | 117 , fCurrShaderID(0) |
232 , fCurrGenericID(0) | 118 , fCurrGenericID(0) |
233 , fCurrUniformLocation(0) | 119 , fCurrUniformLocation(0) |
234 , fCurrPathID(0) { | 120 , fCurrPathID(0) { |
235 memset(fBoundBuffers, 0, sizeof(fBoundBuffers)); | 121 memset(fBoundBuffers, 0, sizeof(fBoundBuffers)); |
236 fExtensions.push_back("GL_ARB_framebuffer_object"); | 122 fExtensions.push_back("GL_ARB_framebuffer_object"); |
237 fExtensions.push_back("GL_ARB_blend_func_extended"); | 123 fExtensions.push_back("GL_ARB_blend_func_extended"); |
238 fExtensions.push_back("GL_ARB_timer_query"); | 124 fExtensions.push_back("GL_ARB_timer_query"); |
239 fExtensions.push_back("GL_ARB_draw_buffers"); | 125 fExtensions.push_back("GL_ARB_draw_buffers"); |
240 fExtensions.push_back("GL_ARB_occlusion_query"); | 126 fExtensions.push_back("GL_ARB_occlusion_query"); |
241 fExtensions.push_back("GL_EXT_stencil_wrap"); | 127 fExtensions.push_back("GL_EXT_stencil_wrap"); |
242 if (enableNVPR) { | 128 if (enableNVPR) { |
243 fExtensions.push_back("GL_NV_path_rendering"); | 129 fExtensions.push_back("GL_NV_path_rendering"); |
244 fExtensions.push_back("GL_ARB_program_interface_query"); | 130 fExtensions.push_back("GL_ARB_program_interface_query"); |
245 } | 131 } |
246 fExtensions.push_back(nullptr); | 132 fExtensions.push_back(nullptr); |
247 | 133 |
248 this->init(kGL_GrGLStandard); | 134 this->init(kGL_GrGLStandard); |
249 } | 135 } |
250 | 136 |
251 GrGLenum checkFramebufferStatus(GrGLenum target) override { | 137 GrGLenum checkFramebufferStatus(GrGLenum target) override { |
252 return GR_GL_FRAMEBUFFER_COMPLETE; | 138 return GR_GL_FRAMEBUFFER_COMPLETE; |
253 } | 139 } |
254 | 140 |
255 GrGLvoid genBuffers(GrGLsizei n, GrGLuint* ids) override { | 141 GrGLvoid genBuffers(GrGLsizei n, GrGLuint* ids) override { |
256 for (int i = 0; i < n; ++i) { | 142 for (int i = 0; i < n; ++i) { |
257 Buffer* buffer = fBufferManager.create(); | 143 BufferObj* buffer = fBufferManager.create(); |
258 ids[i] = buffer->id(); | 144 ids[i] = buffer->id(); |
259 } | 145 } |
260 } | 146 } |
261 | 147 |
262 GrGLvoid bufferData(GrGLenum target, GrGLsizeiptr size, const GrGLvoid* data
, | 148 GrGLvoid bufferData(GrGLenum target, GrGLsizeiptr size, const GrGLvoid* data
, |
263 GrGLenum usage) override { | 149 GrGLenum usage) override { |
264 GrGLuint id = fBoundBuffers[GetBufferIndex(target)]; | 150 GrGLuint id = fBoundBuffers[GetBufferIndex(target)]; |
265 if (id > 0) { | 151 if (id > 0) { |
266 Buffer* buffer = fBufferManager.lookUp(id); | 152 BufferObj* buffer = fBufferManager.lookUp(id); |
267 buffer->allocate(size, (const GrGLchar*) data); | 153 buffer->allocate(size, (const GrGLchar*) data); |
268 } | 154 } |
269 } | 155 } |
270 | 156 |
271 GrGLuint createProgram() override { | 157 GrGLuint createProgram() override { |
272 return ++fCurrProgramID; | 158 return ++fCurrProgramID; |
273 } | 159 } |
274 | 160 |
275 GrGLuint createShader(GrGLenum type) override { | 161 GrGLuint createShader(GrGLenum type) override { |
276 return ++fCurrShaderID; | 162 return ++fCurrShaderID; |
(...skipping 14 matching lines...) Expand all Loading... |
291 if (ids[i] == fBoundBuffers[buffIdx]) { | 177 if (ids[i] == fBoundBuffers[buffIdx]) { |
292 fBoundBuffers[buffIdx] = 0; | 178 fBoundBuffers[buffIdx] = 0; |
293 break; | 179 break; |
294 } | 180 } |
295 } | 181 } |
296 } | 182 } |
297 | 183 |
298 // Then actually "delete" the buffers. | 184 // Then actually "delete" the buffers. |
299 for (int i = 0; i < n; ++i) { | 185 for (int i = 0; i < n; ++i) { |
300 if (ids[i] > 0) { | 186 if (ids[i] > 0) { |
301 Buffer* buffer = fBufferManager.lookUp(ids[i]); | 187 BufferObj* buffer = fBufferManager.lookUp(ids[i]); |
302 fBufferManager.free(buffer); | 188 fBufferManager.free(buffer); |
303 } | 189 } |
304 } | 190 } |
305 } | 191 } |
306 | 192 |
307 GrGLvoid genFramebuffers(GrGLsizei n, GrGLuint *framebuffers) override { | 193 GrGLvoid genFramebuffers(GrGLsizei n, GrGLuint *framebuffers) override { |
308 for (int i = 0; i < n; ++i) { | 194 this->genGenericIds(n, framebuffers); |
309 Framebuffer* framebuffer = fFramebufferManager.create(); | |
310 framebuffers[i] = framebuffer->id(); | |
311 } | |
312 } | |
313 | |
314 GrGLvoid bindFramebuffer(GrGLenum target, GrGLuint framebuffer) override { | |
315 SkASSERT(GR_GL_FRAMEBUFFER == target || GR_GL_DRAW_FRAMEBUFFER == target
|| | |
316 GR_GL_READ_FRAMEBUFFER == target); | |
317 if (GR_GL_READ_FRAMEBUFFER != target) { | |
318 fCurrDrawFramebuffer = framebuffer; | |
319 } | |
320 if (GR_GL_DRAW_FRAMEBUFFER != target) { | |
321 fCurrReadFramebuffer = framebuffer; | |
322 } | |
323 } | |
324 | |
325 GrGLvoid deleteFramebuffers(GrGLsizei n, const GrGLuint* ids) override { | |
326 for (int i = 0; i < n; ++i) { | |
327 if (ids[i] == fCurrDrawFramebuffer) { | |
328 fCurrDrawFramebuffer = 0; | |
329 } | |
330 if (ids[i] == fCurrReadFramebuffer) { | |
331 fCurrReadFramebuffer = 0; | |
332 } | |
333 | |
334 if (ids[i] > 0) { | |
335 Framebuffer* framebuffer = fFramebufferManager.lookUp(ids[i]); | |
336 fFramebufferManager.free(framebuffer); | |
337 } | |
338 } | |
339 } | 195 } |
340 | 196 |
341 GrGLvoid genQueries(GrGLsizei n, GrGLuint *ids) override { this->genGenericI
ds(n, ids); } | 197 GrGLvoid genQueries(GrGLsizei n, GrGLuint *ids) override { this->genGenericI
ds(n, ids); } |
342 | 198 |
343 GrGLvoid genRenderbuffers(GrGLsizei n, GrGLuint *renderbuffers) override { | 199 GrGLvoid genRenderbuffers(GrGLsizei n, GrGLuint *renderbuffers) override { |
344 for (int i = 0; i < n; ++i) { | 200 this->genGenericIds(n, renderbuffers); |
345 Renderbuffer* renderbuffer = fRenderbufferManager.create(); | |
346 renderbuffers[i] = renderbuffer->id(); | |
347 } | |
348 } | |
349 | |
350 GrGLvoid bindRenderbuffer(GrGLenum target, GrGLuint renderbuffer) override { | |
351 SkASSERT(GR_GL_RENDERBUFFER == target); | |
352 fCurrRenderbuffer = renderbuffer; | |
353 } | |
354 | |
355 GrGLvoid deleteRenderbuffers(GrGLsizei n, const GrGLuint* ids) override { | |
356 for (int i = 0; i < n; ++i) { | |
357 if (ids[i] <= 0) { | |
358 continue; | |
359 } | |
360 if (ids[i] == fCurrRenderbuffer) { | |
361 fCurrRenderbuffer = 0; | |
362 } | |
363 Renderbuffer* renderbuffer = fRenderbufferManager.lookUp(ids[i]); | |
364 | |
365 if (fCurrDrawFramebuffer) { | |
366 Framebuffer* drawFramebuffer = fFramebufferManager.lookUp(fCurrD
rawFramebuffer); | |
367 drawFramebuffer->notifyAttachmentDeleteWhileBound(renderbuffer); | |
368 } | |
369 if (fCurrReadFramebuffer) { | |
370 Framebuffer* readFramebuffer = fFramebufferManager.lookUp(fCurrR
eadFramebuffer); | |
371 readFramebuffer->notifyAttachmentDeleteWhileBound(renderbuffer); | |
372 } | |
373 | |
374 fRenderbufferManager.free(renderbuffer); | |
375 } | |
376 } | |
377 | |
378 GrGLvoid renderbufferStorage(GrGLenum target, GrGLenum internalformat, GrGLs
izei width, | |
379 GrGLsizei height) override { | |
380 GrAlwaysAssert(GR_GL_RENDERBUFFER == target); | |
381 GrAlwaysAssert(fCurrRenderbuffer); | |
382 Renderbuffer* renderbuffer = fRenderbufferManager.lookUp(fCurrRenderbuff
er); | |
383 renderbuffer->setNumSamples(1); | |
384 } | |
385 | |
386 GrGLvoid renderbufferStorageMultisample(GrGLenum target, GrGLsizei samples, | |
387 GrGLenum internalformat, GrGLsizei w
idth, | |
388 GrGLsizei height) override { | |
389 GrAlwaysAssert(GR_GL_RENDERBUFFER == target); | |
390 GrAlwaysAssert(samples > 0); | |
391 GrAlwaysAssert(fCurrRenderbuffer); | |
392 Renderbuffer* renderbuffer = fRenderbufferManager.lookUp(fCurrRenderbuff
er); | |
393 renderbuffer->setNumSamples(samples); | |
394 } | |
395 | |
396 GrGLvoid namedRenderbufferStorage(GrGLuint renderbuffer, GrGLenum GrGLintern
alformat, | |
397 GrGLsizei width, GrGLsizei height) overrid
e { | |
398 SK_ABORT("Not implemented"); | |
399 } | |
400 | |
401 GrGLvoid namedRenderbufferStorageMultisample(GrGLuint renderbuffer, GrGLsize
i samples, | |
402 GrGLenum GrGLinternalformat, Gr
GLsizei width, | |
403 GrGLsizei height) override { | |
404 SK_ABORT("Not implemented"); | |
405 } | |
406 | |
407 GrGLvoid framebufferRenderbuffer(GrGLenum target, GrGLenum attachment, | |
408 GrGLenum renderbuffertarget, | |
409 GrGLuint renderBufferID) override { | |
410 GrGLuint id = this->getBoundFramebufferID(target); | |
411 GrAlwaysAssert(id); | |
412 Framebuffer* framebuffer = fFramebufferManager.lookUp(id); | |
413 | |
414 GrAlwaysAssert(GR_GL_RENDERBUFFER == renderbuffertarget); | |
415 GrAlwaysAssert(fCurrRenderbuffer); | |
416 Renderbuffer* renderbuffer = fRenderbufferManager.lookUp(fCurrRenderbuff
er); | |
417 | |
418 framebuffer->setAttachment(attachment, renderbuffer); | |
419 } | |
420 | |
421 GrGLvoid namedFramebufferRenderbuffer(GrGLuint framebuffer, GrGLenum attachm
ent, | |
422 GrGLenum renderbuffertarget, | |
423 GrGLuint renderbuffer) override { | |
424 SK_ABORT("Not implemented"); | |
425 } | 201 } |
426 | 202 |
427 GrGLvoid genTextures(GrGLsizei n, GrGLuint *textures) override { | 203 GrGLvoid genTextures(GrGLsizei n, GrGLuint *textures) override { |
428 this->genGenericIds(n, textures); | 204 this->genGenericIds(n, textures); |
429 } | 205 } |
430 | 206 |
431 GrGLvoid framebufferTexture2D(GrGLenum target, GrGLenum attachment, GrGLenum
textarget, | |
432 GrGLuint textureID, GrGLint level) override { | |
433 GrGLuint id = this->getBoundFramebufferID(target); | |
434 GrAlwaysAssert(id); | |
435 Framebuffer* framebuffer = fFramebufferManager.lookUp(id); | |
436 framebuffer->setAttachment(attachment, Texture::GetSingleInstance()); | |
437 } | |
438 | |
439 GrGLvoid framebufferTexture2DMultisample(GrGLenum target, GrGLenum attachmen
t, | |
440 GrGLenum textarget, GrGLuint textur
e, GrGLint level, | |
441 GrGLsizei samples) override { | |
442 SK_ABORT("Not implemented"); | |
443 } | |
444 | |
445 GrGLvoid namedFramebufferTexture1D(GrGLuint framebuffer, GrGLenum attachment
, | |
446 GrGLenum textarget, GrGLuint texture, | |
447 GrGLint level) override { | |
448 SK_ABORT("Not implemented"); | |
449 } | |
450 | |
451 GrGLvoid namedFramebufferTexture2D(GrGLuint framebuffer, GrGLenum attachment
, | |
452 GrGLenum textarget, GrGLuint texture, | |
453 GrGLint level) override { | |
454 SK_ABORT("Not implemented"); | |
455 } | |
456 | |
457 GrGLvoid namedFramebufferTexture3D(GrGLuint framebuffer, GrGLenum attachment
, | |
458 GrGLenum textarget, GrGLuint texture, GrG
Lint level, | |
459 GrGLint zoffset) override { | |
460 SK_ABORT("Not implemented"); | |
461 } | |
462 | |
463 GrGLvoid genVertexArrays(GrGLsizei n, GrGLuint *arrays) override { | 207 GrGLvoid genVertexArrays(GrGLsizei n, GrGLuint *arrays) override { |
464 this->genGenericIds(n, arrays); | 208 this->genGenericIds(n, arrays); |
465 } | 209 } |
466 | 210 |
467 GrGLenum getError() override { return GR_GL_NO_ERROR; } | 211 GrGLenum getError() override { return GR_GL_NO_ERROR; } |
468 | 212 |
469 GrGLvoid getIntegerv(GrGLenum pname, GrGLint* params) override { | 213 GrGLvoid getIntegerv(GrGLenum pname, GrGLint* params) override { |
470 // TODO: remove from Ganesh the #defines for gets we don't use. | 214 // TODO: remove from Ganesh the #defines for gets we don't use. |
471 // We would like to minimize gets overall due to performance issues | 215 // We would like to minimize gets overall due to performance issues |
472 switch (pname) { | 216 switch (pname) { |
473 case GR_GL_CONTEXT_PROFILE_MASK: | 217 case GR_GL_CONTEXT_PROFILE_MASK: |
474 *params = GR_GL_CONTEXT_COMPATIBILITY_PROFILE_BIT; | 218 *params = GR_GL_CONTEXT_COMPATIBILITY_PROFILE_BIT; |
475 break; | 219 break; |
476 case GR_GL_STENCIL_BITS: | 220 case GR_GL_STENCIL_BITS: |
477 *params = 8; | 221 *params = 8; |
478 break; | 222 break; |
479 case GR_GL_SAMPLES: { | 223 case GR_GL_SAMPLES: |
480 GrAlwaysAssert(fCurrDrawFramebuffer); | 224 *params = 1; |
481 Framebuffer* framebuffer = fFramebufferManager.lookUp(fCurrDrawF
ramebuffer); | |
482 *params = framebuffer->numSamples(); | |
483 break; | 225 break; |
484 } | |
485 case GR_GL_FRAMEBUFFER_BINDING: | 226 case GR_GL_FRAMEBUFFER_BINDING: |
486 *params = 0; | 227 *params = 0; |
487 break; | 228 break; |
488 case GR_GL_VIEWPORT: | 229 case GR_GL_VIEWPORT: |
489 params[0] = 0; | 230 params[0] = 0; |
490 params[1] = 0; | 231 params[1] = 0; |
491 params[2] = 800; | 232 params[2] = 800; |
492 params[3] = 600; | 233 params[3] = 600; |
493 break; | 234 break; |
494 case GR_GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS: | 235 case GR_GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS: |
(...skipping 133 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
628 | 369 |
629 GrGLint getUniformLocation(GrGLuint program, const char* name) override { | 370 GrGLint getUniformLocation(GrGLuint program, const char* name) override { |
630 return ++fCurrUniformLocation; | 371 return ++fCurrUniformLocation; |
631 } | 372 } |
632 | 373 |
633 GrGLvoid* mapBufferRange(GrGLenum target, GrGLintptr offset, GrGLsizeiptr le
ngth, | 374 GrGLvoid* mapBufferRange(GrGLenum target, GrGLintptr offset, GrGLsizeiptr le
ngth, |
634 GrGLbitfield access) override { | 375 GrGLbitfield access) override { |
635 GrGLuint id = fBoundBuffers[GetBufferIndex(target)]; | 376 GrGLuint id = fBoundBuffers[GetBufferIndex(target)]; |
636 if (id > 0) { | 377 if (id > 0) { |
637 // We just ignore the offset and length here. | 378 // We just ignore the offset and length here. |
638 Buffer* buffer = fBufferManager.lookUp(id); | 379 BufferObj* buffer = fBufferManager.lookUp(id); |
639 SkASSERT(!buffer->mapped()); | 380 SkASSERT(!buffer->mapped()); |
640 buffer->setMapped(true); | 381 buffer->setMapped(true); |
641 return buffer->dataPtr(); | 382 return buffer->dataPtr(); |
642 } | 383 } |
643 return nullptr; | 384 return nullptr; |
644 } | 385 } |
645 | 386 |
646 GrGLvoid* mapBuffer(GrGLenum target, GrGLenum access) override { | 387 GrGLvoid* mapBuffer(GrGLenum target, GrGLenum access) override { |
647 GrGLuint id = fBoundBuffers[GetBufferIndex(target)]; | 388 GrGLuint id = fBoundBuffers[GetBufferIndex(target)]; |
648 if (id > 0) { | 389 if (id > 0) { |
649 Buffer* buffer = fBufferManager.lookUp(id); | 390 BufferObj* buffer = fBufferManager.lookUp(id); |
650 SkASSERT(!buffer->mapped()); | 391 SkASSERT(!buffer->mapped()); |
651 buffer->setMapped(true); | 392 buffer->setMapped(true); |
652 return buffer->dataPtr(); | 393 return buffer->dataPtr(); |
653 } | 394 } |
654 | 395 |
655 SkASSERT(false); | 396 SkASSERT(false); |
656 return nullptr; // no buffer bound to target | 397 return nullptr; // no buffer bound to target |
657 } | 398 } |
658 | 399 |
659 GrGLboolean unmapBuffer(GrGLenum target) override { | 400 GrGLboolean unmapBuffer(GrGLenum target) override { |
660 GrGLuint id = fBoundBuffers[GetBufferIndex(target)]; | 401 GrGLuint id = fBoundBuffers[GetBufferIndex(target)]; |
661 if (id > 0) { | 402 if (id > 0) { |
662 Buffer* buffer = fBufferManager.lookUp(id); | 403 BufferObj* buffer = fBufferManager.lookUp(id); |
663 SkASSERT(buffer->mapped()); | 404 SkASSERT(buffer->mapped()); |
664 buffer->setMapped(false); | 405 buffer->setMapped(false); |
665 return GR_GL_TRUE; | 406 return GR_GL_TRUE; |
666 } | 407 } |
667 | 408 |
668 GrAlwaysAssert(false); | 409 GrAlwaysAssert(false); |
669 return GR_GL_FALSE; // GR_GL_INVALID_OPERATION; | 410 return GR_GL_FALSE; // GR_GL_INVALID_OPERATION; |
670 } | 411 } |
671 | 412 |
672 GrGLvoid getBufferParameteriv(GrGLenum target, GrGLenum pname, GrGLint* para
ms) override { | 413 GrGLvoid getBufferParameteriv(GrGLenum target, GrGLenum pname, GrGLint* para
ms) override { |
673 switch (pname) { | 414 switch (pname) { |
674 case GR_GL_BUFFER_MAPPED: { | 415 case GR_GL_BUFFER_MAPPED: { |
675 *params = GR_GL_FALSE; | 416 *params = GR_GL_FALSE; |
676 GrGLuint id = fBoundBuffers[GetBufferIndex(target)]; | 417 GrGLuint id = fBoundBuffers[GetBufferIndex(target)]; |
677 if (id > 0) { | 418 if (id > 0) { |
678 Buffer* buffer = fBufferManager.lookUp(id); | 419 BufferObj* buffer = fBufferManager.lookUp(id); |
679 if (buffer->mapped()) { | 420 if (buffer->mapped()) { |
680 *params = GR_GL_TRUE; | 421 *params = GR_GL_TRUE; |
681 } | 422 } |
682 } | 423 } |
683 break; } | 424 break; } |
684 default: | 425 default: |
685 SkFAIL("Unexpected pname to GetBufferParamateriv"); | 426 SkFAIL("Unexpected pname to GetBufferParamateriv"); |
686 break; | 427 break; |
687 } | 428 } |
688 }; | 429 }; |
(...skipping 11 matching lines...) Expand all Loading... |
700 case GR_GL_ARRAY_BUFFER: return 0; | 441 case GR_GL_ARRAY_BUFFER: return 0; |
701 case GR_GL_ELEMENT_ARRAY_BUFFER: return 1; | 442 case GR_GL_ELEMENT_ARRAY_BUFFER: return 1; |
702 case GR_GL_TEXTURE_BUFFER: return 2; | 443 case GR_GL_TEXTURE_BUFFER: return 2; |
703 case GR_GL_DRAW_INDIRECT_BUFFER: return 3; | 444 case GR_GL_DRAW_INDIRECT_BUFFER: return 3; |
704 case GR_GL_PIXEL_PACK_BUFFER: return 4; | 445 case GR_GL_PIXEL_PACK_BUFFER: return 4; |
705 case GR_GL_PIXEL_UNPACK_BUFFER: return 5; | 446 case GR_GL_PIXEL_UNPACK_BUFFER: return 5; |
706 } | 447 } |
707 } | 448 } |
708 constexpr int static kNumBufferTargets = 6; | 449 constexpr int static kNumBufferTargets = 6; |
709 | 450 |
710 TGLObjectManager<Buffer> fBufferManager; | 451 BufferManager fBufferManager; |
711 GrGLuint fBoundBuffers[kNumBufferTargets]; | 452 GrGLuint fBoundBuffers[kNumBufferTargets]; |
712 TGLObjectManager<Framebuffer> fFramebufferManager; | 453 GrGLuint fCurrProgramID; |
713 GrGLuint fCurrDrawFramebuffer; | 454 GrGLuint fCurrShaderID; |
714 GrGLuint fCurrReadFramebuffer; | 455 GrGLuint fCurrGenericID; |
715 TGLObjectManager<Renderbuffer> fRenderbufferManager; | 456 GrGLuint fCurrUniformLocation; |
716 GrGLuint fCurrRenderbuffer; | 457 GrGLuint fCurrPathID; |
717 GrGLuint fCurrProgramID; | 458 SkTArray<const char*> fExtensions; |
718 GrGLuint fCurrShaderID; | |
719 GrGLuint fCurrGenericID; | |
720 GrGLuint fCurrUniformLocation; | |
721 GrGLuint fCurrPathID; | |
722 SkTArray<const char*> fExtensions; | |
723 | 459 |
724 // the OpenGLES 2.0 spec says this must be >= 128 | 460 // the OpenGLES 2.0 spec says this must be >= 128 |
725 static const GrGLint kDefaultMaxVertexUniformVectors = 128; | 461 static const GrGLint kDefaultMaxVertexUniformVectors = 128; |
726 | 462 |
727 // the OpenGLES 2.0 spec says this must be >=16 | 463 // the OpenGLES 2.0 spec says this must be >=16 |
728 static const GrGLint kDefaultMaxFragmentUniformVectors = 16; | 464 static const GrGLint kDefaultMaxFragmentUniformVectors = 16; |
729 | 465 |
730 // the OpenGLES 2.0 spec says this must be >= 8 | 466 // the OpenGLES 2.0 spec says this must be >= 8 |
731 static const GrGLint kDefaultMaxVertexAttribs = 8; | 467 static const GrGLint kDefaultMaxVertexAttribs = 8; |
732 | 468 |
733 // the OpenGLES 2.0 spec says this must be >= 8 | 469 // the OpenGLES 2.0 spec says this must be >= 8 |
734 static const GrGLint kDefaultMaxVaryingVectors = 8; | 470 static const GrGLint kDefaultMaxVaryingVectors = 8; |
735 | 471 |
736 GrGLuint getBoundFramebufferID(GrGLenum target) { | |
737 switch (target) { | |
738 case GR_GL_FRAMEBUFFER: | |
739 case GR_GL_DRAW_FRAMEBUFFER: | |
740 return fCurrDrawFramebuffer; | |
741 case GR_GL_READ_FRAMEBUFFER: | |
742 return fCurrReadFramebuffer; | |
743 default: | |
744 SK_ABORT("Invalid framebuffer target."); | |
745 return 0; | |
746 } | |
747 } | |
748 | |
749 const GrGLubyte* CombinedExtensionString() { | 472 const GrGLubyte* CombinedExtensionString() { |
750 static SkString gExtString; | 473 static SkString gExtString; |
751 static SkMutex gMutex; | 474 static SkMutex gMutex; |
752 gMutex.acquire(); | 475 gMutex.acquire(); |
753 if (0 == gExtString.size()) { | 476 if (0 == gExtString.size()) { |
754 int i = 0; | 477 int i = 0; |
755 while (fExtensions[i]) { | 478 while (fExtensions[i]) { |
756 if (i > 0) { | 479 if (i > 0) { |
757 gExtString.append(" "); | 480 gExtString.append(" "); |
758 } | 481 } |
(...skipping 51 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
810 break; | 533 break; |
811 } | 534 } |
812 } | 535 } |
813 | 536 |
814 typedef GrGLTestInterface INHERITED; | 537 typedef GrGLTestInterface INHERITED; |
815 }; | 538 }; |
816 | 539 |
817 } // anonymous namespace | 540 } // anonymous namespace |
818 | 541 |
819 const GrGLInterface* GrGLCreateNullInterface(bool enableNVPR) { return new NullI
nterface(enableNVPR); } | 542 const GrGLInterface* GrGLCreateNullInterface(bool enableNVPR) { return new NullI
nterface(enableNVPR); } |
OLD | NEW |