The Tor Browser / file comparison

comparison: gfx/skia/trunk/src/gpu/gl/GrGLNoOpInterface.cpp

gfx/skia/trunk/src/gpu/gl/GrGLNoOpInterface.cpp

changeset 0
6474c204b198
equal deleted inserted replaced
-1:000000000000 0:c6379ae73b3d
1 /*
2 * Copyright 2013 Google Inc.
3 *
4 * Use of this source code is governed by a BSD-style license that can be
5 * found in the LICENSE file.
6 */
7
8 #include "GrGLNoOpInterface.h"
9 #include "SkString.h"
10 #include "SkThread.h"
11
12 // the OpenGLES 2.0 spec says this must be >= 128
13 static const GrGLint kDefaultMaxVertexUniformVectors = 128;
14
15 // the OpenGLES 2.0 spec says this must be >=16
16 static const GrGLint kDefaultMaxFragmentUniformVectors = 16;
17
18 // the OpenGLES 2.0 spec says this must be >= 8
19 static const GrGLint kDefaultMaxVertexAttribs = 8;
20
21 // the OpenGLES 2.0 spec says this must be >= 8
22 static const GrGLint kDefaultMaxVaryingVectors = 8;
23
24 static const char* kExtensions[] = {
25 "GL_ARB_framebuffer_object",
26 "GL_ARB_blend_func_extended",
27 "GL_ARB_timer_query",
28 "GL_ARB_draw_buffers",
29 "GL_ARB_occlusion_query",
30 "GL_EXT_blend_color",
31 "GL_EXT_stencil_wrap"
32 };
33
34 namespace {
35 const GrGLubyte* combined_extensions_string() {
36 static SkString gExtString;
37 static SkMutex gMutex;
38 gMutex.acquire();
39 if (0 == gExtString.size()) {
40 for (size_t i = 0; i < GR_ARRAY_COUNT(kExtensions) - 1; ++i) {
41 gExtString.append(kExtensions[i]);
42 gExtString.append(" ");
43 }
44 gExtString.append(kExtensions[GR_ARRAY_COUNT(kExtensions) - 1]);
45 }
46 gMutex.release();
47 return (const GrGLubyte*) gExtString.c_str();
48 }
49 }
50
51 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLBlendColor(GrGLclampf red,
52 GrGLclampf green,
53 GrGLclampf blue,
54 GrGLclampf alpha) {
55 }
56
57 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLBindFragDataLocation(GrGLuint program,
58 GrGLuint colorNumber,
59 const GrGLchar* name) {
60 }
61
62 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLBlendFunc(GrGLenum sfactor,
63 GrGLenum dfactor) {
64 }
65
66 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLBufferSubData(GrGLenum target,
67 GrGLintptr offset,
68 GrGLsizeiptr size,
69 const GrGLvoid* data) {
70 }
71
72 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLClear(GrGLbitfield mask) {
73 }
74
75 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLClearColor(GrGLclampf red,
76 GrGLclampf green,
77 GrGLclampf blue,
78 GrGLclampf alpha) {
79 }
80
81 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLClearStencil(GrGLint s) {
82 }
83
84 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLColorMask(GrGLboolean red,
85 GrGLboolean green,
86 GrGLboolean blue,
87 GrGLboolean alpha) {
88 }
89
90 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLCompileShader(GrGLuint shader) {
91 }
92
93 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLCompressedTexImage2D(GrGLenum target,
94 GrGLint level,
95 GrGLenum internalformat,
96 GrGLsizei width,
97 GrGLsizei height,
98 GrGLint border,
99 GrGLsizei imageSize,
100 const GrGLvoid* data) {
101 }
102
103 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLCopyTexSubImage2D(GrGLenum target,
104 GrGLint level,
105 GrGLint xoffset,
106 GrGLint yoffset,
107 GrGLint x,
108 GrGLint y,
109 GrGLsizei width,
110 GrGLsizei height) {
111 }
112
113 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLCullFace(GrGLenum mode) {
114 }
115
116 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLDepthMask(GrGLboolean flag) {
117 }
118
119 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLDisable(GrGLenum cap) {
120 }
121
122 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLDisableVertexAttribArray(GrGLuint index) {
123 }
124
125 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLDrawArrays(GrGLenum mode,
126 GrGLint first,
127 GrGLsizei count) {
128 }
129
130 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLDrawBuffer(GrGLenum mode) {
131 }
132
133 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLDrawBuffers(GrGLsizei n,
134 const GrGLenum* bufs) {
135 }
136
137 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLDrawElements(GrGLenum mode,
138 GrGLsizei count,
139 GrGLenum type,
140 const GrGLvoid* indices) {
141 }
142
143 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLEnable(GrGLenum cap) {
144 }
145
146 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLEnableVertexAttribArray(GrGLuint index) {
147 }
148
149 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLEndQuery(GrGLenum target) {
150 }
151
152 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLFinish() {
153 }
154
155 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLFlush() {
156 }
157
158 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLFrontFace(GrGLenum mode) {
159 }
160
161 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLLineWidth(GrGLfloat width) {
162 }
163
164 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLLinkProgram(GrGLuint program) {
165 }
166
167 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLLoadIdentity() {
168 }
169
170 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLLoadMatrixf(const GrGLfloat*) {
171 }
172
173 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLMatrixMode(GrGLenum) {
174 }
175
176 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLQueryCounter(GrGLuint id, GrGLenum target) {
177 }
178
179 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLReadBuffer(GrGLenum src) {
180 }
181
182 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLScissor(GrGLint x,
183 GrGLint y,
184 GrGLsizei width,
185 GrGLsizei height) {
186 }
187
188 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLShaderSource(GrGLuint shader,
189 GrGLsizei count,
190 #if GR_GL_USE_NEW_SHADER_SOURCE_SIGNATURE
191 const char* const * str,
192 #else
193 const char** str,
194 #endif
195 const GrGLint* length) {
196 }
197
198 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLStencilFunc(GrGLenum func, GrGLint ref, GrGLuint mask) {
199 }
200
201 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLStencilFuncSeparate(GrGLenum face,
202 GrGLenum func,
203 GrGLint ref,
204 GrGLuint mask) {
205 }
206
207 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLStencilMask(GrGLuint mask) {
208 }
209
210 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLStencilMaskSeparate(GrGLenum face, GrGLuint mask) {
211 }
212
213 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLStencilOp(GrGLenum fail, GrGLenum zfail, GrGLenum zpass) {
214 }
215
216 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLStencilOpSeparate(GrGLenum face,
217 GrGLenum fail,
218 GrGLenum zfail,
219 GrGLenum zpass) {
220 }
221
222 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLTexGenf(GrGLenum, GrGLenum, float) {
223 }
224
225 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLTexGenfv(GrGLenum, GrGLenum, const float*) {
226 }
227
228 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLTexGeni(GrGLenum, GrGLenum, GrGLint) {
229 }
230
231 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLTexImage2D(GrGLenum target,
232 GrGLint level,
233 GrGLint internalformat,
234 GrGLsizei width,
235 GrGLsizei height,
236 GrGLint border,
237 GrGLenum format,
238 GrGLenum type,
239 const GrGLvoid* pixels) {
240 }
241
242 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLTexParameteri(GrGLenum target,
243 GrGLenum pname,
244 GrGLint param) {
245 }
246
247 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLTexParameteriv(GrGLenum target,
248 GrGLenum pname,
249 const GrGLint* params) {
250 }
251
252 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLTexStorage2D(GrGLenum target,
253 GrGLsizei levels,
254 GrGLenum internalformat,
255 GrGLsizei width,
256 GrGLsizei height) {
257 }
258
259 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLDiscardFramebuffer(GrGLenum target,
260 GrGLsizei numAttachments,
261 const GrGLenum* attachments) {
262 }
263
264 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLTexSubImage2D(GrGLenum target,
265 GrGLint level,
266 GrGLint xoffset,
267 GrGLint yoffset,
268 GrGLsizei width,
269 GrGLsizei height,
270 GrGLenum format,
271 GrGLenum type,
272 const GrGLvoid* pixels) {
273 }
274
275 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLUniform1f(GrGLint location, GrGLfloat v0) {
276 }
277
278 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLUniform1i(GrGLint location, GrGLint v0) {
279 }
280
281 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLUniform1fv(GrGLint location,
282 GrGLsizei count,
283 const GrGLfloat* v) {
284 }
285
286 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLUniform1iv(GrGLint location,
287 GrGLsizei count,
288 const GrGLint* v) {
289 }
290
291 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLUniform2f(GrGLint location, GrGLfloat v0, GrGLfloat v1) {
292 }
293
294 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLUniform2i(GrGLint location, GrGLint v0, GrGLint v1) {
295 }
296
297 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLUniform2fv(GrGLint location,
298 GrGLsizei count,
299 const GrGLfloat* v) {
300 }
301
302 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLUniform2iv(GrGLint location,
303 GrGLsizei count,
304 const GrGLint* v) {
305 }
306
307 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLUniform3f(GrGLint location,
308 GrGLfloat v0,
309 GrGLfloat v1,
310 GrGLfloat v2) {
311 }
312
313 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLUniform3i(GrGLint location,
314 GrGLint v0,
315 GrGLint v1,
316 GrGLint v2) {
317 }
318
319 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLUniform3fv(GrGLint location,
320 GrGLsizei count,
321 const GrGLfloat* v) {
322 }
323
324 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLUniform3iv(GrGLint location,
325 GrGLsizei count,
326 const GrGLint* v) {
327 }
328
329 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLUniform4f(GrGLint location,
330 GrGLfloat v0,
331 GrGLfloat v1,
332 GrGLfloat v2,
333 GrGLfloat v3) {
334 }
335
336 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLUniform4i(GrGLint location,
337 GrGLint v0,
338 GrGLint v1,
339 GrGLint v2,
340 GrGLint v3) {
341 }
342
343 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLUniform4fv(GrGLint location,
344 GrGLsizei count,
345 const GrGLfloat* v) {
346 }
347
348 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLUniform4iv(GrGLint location,
349 GrGLsizei count,
350 const GrGLint* v) {
351 }
352
353 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLUniformMatrix2fv(GrGLint location,
354 GrGLsizei count,
355 GrGLboolean transpose,
356 const GrGLfloat* value) {
357 }
358
359 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLUniformMatrix3fv(GrGLint location,
360 GrGLsizei count,
361 GrGLboolean transpose,
362 const GrGLfloat* value) {
363 }
364
365 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLUniformMatrix4fv(GrGLint location,
366 GrGLsizei count,
367 GrGLboolean transpose,
368 const GrGLfloat* value) {
369 }
370
371 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLVertexAttrib4fv(GrGLuint indx, const GrGLfloat* values) {
372 }
373
374 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLVertexAttribPointer(GrGLuint indx,
375 GrGLint size,
376 GrGLenum type,
377 GrGLboolean normalized,
378 GrGLsizei stride,
379 const GrGLvoid* ptr) {
380 }
381
382 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLViewport(GrGLint x,
383 GrGLint y,
384 GrGLsizei width,
385 GrGLsizei height) {
386 }
387
388 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLGetFramebufferAttachmentParameteriv(GrGLenum target,
389 GrGLenum attachment,
390 GrGLenum pname,
391 GrGLint* params) {
392 }
393
394 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLGetRenderbufferParameteriv(GrGLenum target,
395 GrGLenum pname,
396 GrGLint* params) {
397 }
398
399 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLRenderbufferStorage(GrGLenum target,
400 GrGLenum internalformat,
401 GrGLsizei width,
402 GrGLsizei height) {
403 }
404
405 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLRenderbufferStorageMultisample(GrGLenum target,
406 GrGLsizei samples,
407 GrGLenum internalformat,
408 GrGLsizei width,
409 GrGLsizei height) {
410 }
411
412 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLBlitFramebuffer(GrGLint srcX0,
413 GrGLint srcY0,
414 GrGLint srcX1,
415 GrGLint srcY1,
416 GrGLint dstX0,
417 GrGLint dstY0,
418 GrGLint dstX1,
419 GrGLint dstY1,
420 GrGLbitfield mask,
421 GrGLenum filter) {
422 }
423
424 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLResolveMultisampleFramebuffer() {
425 }
426
427 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLBindFragDataLocationIndexed(GrGLuint program,
428 GrGLuint colorNumber,
429 GrGLuint index,
430 const GrGLchar * name) {
431 }
432
433 GrGLenum GR_GL_FUNCTION_TYPE noOpGLCheckFramebufferStatus(GrGLenum target) {
434
435 GrAlwaysAssert(GR_GL_FRAMEBUFFER == target);
436
437 return GR_GL_FRAMEBUFFER_COMPLETE;
438 }
439
440 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLGenIds(GrGLsizei n, GrGLuint* ids) {
441 static int gCurrID = 1;
442 for (int i = 0; i < n; ++i) {
443 ids[i] = ++gCurrID;
444 }
445 }
446
447 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLDeleteIds(GrGLsizei n, const GrGLuint* ids) {
448 }
449
450 GrGLenum GR_GL_FUNCTION_TYPE noOpGLGetError() {
451 return GR_GL_NO_ERROR;
452 }
453
454 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLGetIntegerv(GrGLenum pname, GrGLint* params) {
455 // TODO: remove from Ganesh the #defines for gets we don't use.
456 // We would like to minimize gets overall due to performance issues
457 switch (pname) {
458 case GR_GL_CONTEXT_PROFILE_MASK:
459 *params = GR_GL_CONTEXT_COMPATIBILITY_PROFILE_BIT;
460 break;
461 case GR_GL_STENCIL_BITS:
462 *params = 8;
463 break;
464 case GR_GL_SAMPLES:
465 *params = 1;
466 break;
467 case GR_GL_FRAMEBUFFER_BINDING:
468 *params = 0;
469 break;
470 case GR_GL_VIEWPORT:
471 params[0] = 0;
472 params[1] = 0;
473 params[2] = 800;
474 params[3] = 600;
475 break;
476 case GR_GL_MAX_TEXTURE_IMAGE_UNITS:
477 *params = 8;
478 break;
479 case GR_GL_MAX_TEXTURE_COORDS:
480 *params = 8;
481 break;
482 case GR_GL_MAX_VERTEX_UNIFORM_VECTORS:
483 *params = kDefaultMaxVertexUniformVectors;
484 break;
485 case GR_GL_MAX_FRAGMENT_UNIFORM_VECTORS:
486 *params = kDefaultMaxFragmentUniformVectors;
487 break;
488 case GR_GL_MAX_FRAGMENT_UNIFORM_COMPONENTS:
489 *params = 16 * 4;
490 break;
491 case GR_GL_NUM_COMPRESSED_TEXTURE_FORMATS:
492 *params = 0;
493 break;
494 case GR_GL_COMPRESSED_TEXTURE_FORMATS:
495 break;
496 case GR_GL_MAX_TEXTURE_SIZE:
497 *params = 8192;
498 break;
499 case GR_GL_MAX_RENDERBUFFER_SIZE:
500 *params = 8192;
501 break;
502 case GR_GL_MAX_SAMPLES:
503 *params = 32;
504 break;
505 case GR_GL_MAX_VERTEX_ATTRIBS:
506 *params = kDefaultMaxVertexAttribs;
507 break;
508 case GR_GL_MAX_VARYING_VECTORS:
509 *params = kDefaultMaxVaryingVectors;
510 break;
511 case GR_GL_NUM_EXTENSIONS:
512 *params = GR_ARRAY_COUNT(kExtensions);
513 break;
514 default:
515 GrCrash("Unexpected pname to GetIntegerv");
516 }
517 }
518
519 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLGetInfoLog(GrGLuint program,
520 GrGLsizei bufsize,
521 GrGLsizei* length,
522 char* infolog) {
523 if (length) {
524 *length = 0;
525 }
526 if (bufsize > 0) {
527 *infolog = 0;
528 }
529 }
530
531 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLGetShaderOrProgramiv(GrGLuint program,
532 GrGLenum pname,
533 GrGLint* params) {
534 switch (pname) {
535 case GR_GL_LINK_STATUS: // fallthru
536 case GR_GL_COMPILE_STATUS:
537 *params = GR_GL_TRUE;
538 break;
539 case GR_GL_INFO_LOG_LENGTH:
540 *params = 0;
541 break;
542 // we don't expect any other pnames
543 default:
544 GrCrash("Unexpected pname to GetProgramiv");
545 break;
546 }
547 }
548
549 namespace {
550 template <typename T>
551 void query_result(GrGLenum GLtarget, GrGLenum pname, T *params) {
552 switch (pname) {
553 case GR_GL_QUERY_RESULT_AVAILABLE:
554 *params = GR_GL_TRUE;
555 break;
556 case GR_GL_QUERY_RESULT:
557 *params = 0;
558 break;
559 default:
560 GrCrash("Unexpected pname passed to GetQueryObject.");
561 break;
562 }
563 }
564 }
565
566 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLGetQueryiv(GrGLenum GLtarget,
567 GrGLenum pname,
568 GrGLint *params) {
569 switch (pname) {
570 case GR_GL_CURRENT_QUERY:
571 *params = 0;
572 break;
573 case GR_GL_QUERY_COUNTER_BITS:
574 *params = 32;
575 break;
576 default:
577 GrCrash("Unexpected pname passed GetQueryiv.");
578 }
579 }
580
581 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLGetQueryObjecti64v(GrGLuint id,
582 GrGLenum pname,
583 GrGLint64 *params) {
584 query_result(id, pname, params);
585 }
586
587 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLGetQueryObjectiv(GrGLuint id,
588 GrGLenum pname,
589 GrGLint *params) {
590 query_result(id, pname, params);
591 }
592
593 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLGetQueryObjectui64v(GrGLuint id,
594 GrGLenum pname,
595 GrGLuint64 *params) {
596 query_result(id, pname, params);
597 }
598
599 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLGetQueryObjectuiv(GrGLuint id,
600 GrGLenum pname,
601 GrGLuint *params) {
602 query_result(id, pname, params);
603 }
604
605 const GrGLubyte* GR_GL_FUNCTION_TYPE noOpGLGetString(GrGLenum name) {
606 switch (name) {
607 case GR_GL_EXTENSIONS:
608 return combined_extensions_string();
609 case GR_GL_VERSION:
610 return (const GrGLubyte*)"4.0 Debug GL";
611 case GR_GL_SHADING_LANGUAGE_VERSION:
612 return (const GrGLubyte*)"4.20.8 Debug GLSL";
613 case GR_GL_VENDOR:
614 return (const GrGLubyte*)"Debug Vendor";
615 case GR_GL_RENDERER:
616 return (const GrGLubyte*)"The Debug (Non-)Renderer";
617 default:
618 GrCrash("Unexpected name passed to GetString");
619 return NULL;
620 }
621 }
622
623 const GrGLubyte* GR_GL_FUNCTION_TYPE noOpGLGetStringi(GrGLenum name, GrGLuint i) {
624 switch (name) {
625 case GR_GL_EXTENSIONS:
626 if (static_cast<size_t>(i) <= GR_ARRAY_COUNT(kExtensions)) {
627 return (const GrGLubyte*) kExtensions[i];
628 } else {
629 return NULL;
630 }
631 default:
632 GrCrash("Unexpected name passed to GetStringi");
633 return NULL;
634 }
635 }
636
637 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLGetTexLevelParameteriv(GrGLenum target,
638 GrGLint level,
639 GrGLenum pname,
640 GrGLint* params) {
641 // we used to use this to query stuff about externally created textures,
642 // now we just require clients to tell us everything about the texture.
643 GrCrash("Should never query texture parameters.");
644 }
645
646 GrGLint GR_GL_FUNCTION_TYPE noOpGLGetUniformLocation(GrGLuint program, const char* name) {
647 static int gUniLocation = 0;
648 return ++gUniLocation;
649 }
650
651 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLInsertEventMarker(GrGLsizei length, const char* marker) {
652 }
653 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLPushGroupMarker(GrGLsizei length , const char* marker) {
654 }
655 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLPopGroupMarker() {
656 }

Mercurial Repository: The Tor Browser

Europalab SCM Repository Server

mercurial