?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Roll src/third_party/skia d32087a:1052f51
[chromium-blink-merge.git] / ui / gl / gl_bindings_autogen_mock.cc
blob41a38dfba36bceaf2038ca1ff02b90f9651bea1f
1 // Copyright 2014 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4 //
5 // This file is auto-generated from
6 // ui/gl/generate_bindings.py
7 // It's formatted by clang-format using chromium coding style:
8 // clang-format -i -style=chromium filename
9 // DO NOT EDIT!
10
11 #include <string.h>
12
13 #include "ui/gl/gl_mock.h"
14
15 namespace gfx {
16
17 // This is called mainly to prevent the compiler combining the code of mock
18 // functions with identical contents, so that their function pointers will be
19 // different.
20 void MakeFunctionUnique(const char* func_name) {
21 VLOG(2) << "Calling mock " << func_name;
22 }
23
24 void GL_BINDING_CALL MockGLInterface::Mock_glActiveTexture(GLenum texture) {
25 MakeFunctionUnique("glActiveTexture");
26 interface_->ActiveTexture(texture);
27 }
28
29 void GL_BINDING_CALL
30 MockGLInterface::Mock_glApplyFramebufferAttachmentCMAAINTEL(void) {
31 MakeFunctionUnique("glApplyFramebufferAttachmentCMAAINTEL");
32 interface_->ApplyFramebufferAttachmentCMAAINTEL();
33 }
34
35 void GL_BINDING_CALL MockGLInterface::Mock_glAttachShader(GLuint program,
36 GLuint shader) {
37 MakeFunctionUnique("glAttachShader");
38 interface_->AttachShader(program, shader);
39 }
40
41 void GL_BINDING_CALL MockGLInterface::Mock_glBeginQuery(GLenum target,
42 GLuint id) {
43 MakeFunctionUnique("glBeginQuery");
44 interface_->BeginQuery(target, id);
45 }
46
47 void GL_BINDING_CALL MockGLInterface::Mock_glBeginQueryARB(GLenum target,
48 GLuint id) {
49 MakeFunctionUnique("glBeginQueryARB");
50 interface_->BeginQuery(target, id);
51 }
52
53 void GL_BINDING_CALL MockGLInterface::Mock_glBeginQueryEXT(GLenum target,
54 GLuint id) {
55 MakeFunctionUnique("glBeginQueryEXT");
56 interface_->BeginQuery(target, id);
57 }
58
59 void GL_BINDING_CALL
60 MockGLInterface::Mock_glBeginTransformFeedback(GLenum primitiveMode) {
61 MakeFunctionUnique("glBeginTransformFeedback");
62 interface_->BeginTransformFeedback(primitiveMode);
63 }
64
65 void GL_BINDING_CALL
66 MockGLInterface::Mock_glBindAttribLocation(GLuint program,
67 GLuint index,
68 const char* name) {
69 MakeFunctionUnique("glBindAttribLocation");
70 interface_->BindAttribLocation(program, index, name);
71 }
72
73 void GL_BINDING_CALL MockGLInterface::Mock_glBindBuffer(GLenum target,
74 GLuint buffer) {
75 MakeFunctionUnique("glBindBuffer");
76 interface_->BindBuffer(target, buffer);
77 }
78
79 void GL_BINDING_CALL MockGLInterface::Mock_glBindBufferBase(GLenum target,
80 GLuint index,
81 GLuint buffer) {
82 MakeFunctionUnique("glBindBufferBase");
83 interface_->BindBufferBase(target, index, buffer);
84 }
85
86 void GL_BINDING_CALL MockGLInterface::Mock_glBindBufferRange(GLenum target,
87 GLuint index,
88 GLuint buffer,
89 GLintptr offset,
90 GLsizeiptr size) {
91 MakeFunctionUnique("glBindBufferRange");
92 interface_->BindBufferRange(target, index, buffer, offset, size);
93 }
94
95 void GL_BINDING_CALL
96 MockGLInterface::Mock_glBindFragDataLocation(GLuint program,
97 GLuint colorNumber,
98 const char* name) {
99 MakeFunctionUnique("glBindFragDataLocation");
100 interface_->BindFragDataLocation(program, colorNumber, name);
101 }
102
103 void GL_BINDING_CALL
104 MockGLInterface::Mock_glBindFragDataLocationIndexed(GLuint program,
105 GLuint colorNumber,
106 GLuint index,
107 const char* name) {
108 MakeFunctionUnique("glBindFragDataLocationIndexed");
109 interface_->BindFragDataLocationIndexed(program, colorNumber, index, name);
110 }
111
112 void GL_BINDING_CALL
113 MockGLInterface::Mock_glBindFramebuffer(GLenum target, GLuint framebuffer) {
114 MakeFunctionUnique("glBindFramebuffer");
115 interface_->BindFramebufferEXT(target, framebuffer);
116 }
117
118 void GL_BINDING_CALL
119 MockGLInterface::Mock_glBindFramebufferEXT(GLenum target, GLuint framebuffer) {
120 MakeFunctionUnique("glBindFramebufferEXT");
121 interface_->BindFramebufferEXT(target, framebuffer);
122 }
123
124 void GL_BINDING_CALL
125 MockGLInterface::Mock_glBindRenderbuffer(GLenum target, GLuint renderbuffer) {
126 MakeFunctionUnique("glBindRenderbuffer");
127 interface_->BindRenderbufferEXT(target, renderbuffer);
128 }
129
130 void GL_BINDING_CALL
131 MockGLInterface::Mock_glBindRenderbufferEXT(GLenum target,
132 GLuint renderbuffer) {
133 MakeFunctionUnique("glBindRenderbufferEXT");
134 interface_->BindRenderbufferEXT(target, renderbuffer);
135 }
136
137 void GL_BINDING_CALL MockGLInterface::Mock_glBindSampler(GLuint unit,
138 GLuint sampler) {
139 MakeFunctionUnique("glBindSampler");
140 interface_->BindSampler(unit, sampler);
141 }
142
143 void GL_BINDING_CALL MockGLInterface::Mock_glBindTexture(GLenum target,
144 GLuint texture) {
145 MakeFunctionUnique("glBindTexture");
146 interface_->BindTexture(target, texture);
147 }
148
149 void GL_BINDING_CALL
150 MockGLInterface::Mock_glBindTransformFeedback(GLenum target, GLuint id) {
151 MakeFunctionUnique("glBindTransformFeedback");
152 interface_->BindTransformFeedback(target, id);
153 }
154
155 void GL_BINDING_CALL MockGLInterface::Mock_glBindVertexArray(GLuint array) {
156 MakeFunctionUnique("glBindVertexArray");
157 interface_->BindVertexArrayOES(array);
158 }
159
160 void GL_BINDING_CALL
161 MockGLInterface::Mock_glBindVertexArrayAPPLE(GLuint array) {
162 MakeFunctionUnique("glBindVertexArrayAPPLE");
163 interface_->BindVertexArrayOES(array);
164 }
165
166 void GL_BINDING_CALL MockGLInterface::Mock_glBindVertexArrayOES(GLuint array) {
167 MakeFunctionUnique("glBindVertexArrayOES");
168 interface_->BindVertexArrayOES(array);
169 }
170
171 void GL_BINDING_CALL MockGLInterface::Mock_glBlendBarrierKHR(void) {
172 MakeFunctionUnique("glBlendBarrierKHR");
173 interface_->BlendBarrierKHR();
174 }
175
176 void GL_BINDING_CALL MockGLInterface::Mock_glBlendBarrierNV(void) {
177 MakeFunctionUnique("glBlendBarrierNV");
178 interface_->BlendBarrierKHR();
179 }
180
181 void GL_BINDING_CALL MockGLInterface::Mock_glBlendColor(GLclampf red,
182 GLclampf green,
183 GLclampf blue,
184 GLclampf alpha) {
185 MakeFunctionUnique("glBlendColor");
186 interface_->BlendColor(red, green, blue, alpha);
187 }
188
189 void GL_BINDING_CALL MockGLInterface::Mock_glBlendEquation(GLenum mode) {
190 MakeFunctionUnique("glBlendEquation");
191 interface_->BlendEquation(mode);
192 }
193
194 void GL_BINDING_CALL
195 MockGLInterface::Mock_glBlendEquationSeparate(GLenum modeRGB,
196 GLenum modeAlpha) {
197 MakeFunctionUnique("glBlendEquationSeparate");
198 interface_->BlendEquationSeparate(modeRGB, modeAlpha);
199 }
200
201 void GL_BINDING_CALL MockGLInterface::Mock_glBlendFunc(GLenum sfactor,
202 GLenum dfactor) {
203 MakeFunctionUnique("glBlendFunc");
204 interface_->BlendFunc(sfactor, dfactor);
205 }
206
207 void GL_BINDING_CALL
208 MockGLInterface::Mock_glBlendFuncSeparate(GLenum srcRGB,
209 GLenum dstRGB,
210 GLenum srcAlpha,
211 GLenum dstAlpha) {
212 MakeFunctionUnique("glBlendFuncSeparate");
213 interface_->BlendFuncSeparate(srcRGB, dstRGB, srcAlpha, dstAlpha);
214 }
215
216 void GL_BINDING_CALL MockGLInterface::Mock_glBlitFramebuffer(GLint srcX0,
217 GLint srcY0,
218 GLint srcX1,
219 GLint srcY1,
220 GLint dstX0,
221 GLint dstY0,
222 GLint dstX1,
223 GLint dstY1,
224 GLbitfield mask,
225 GLenum filter) {
226 MakeFunctionUnique("glBlitFramebuffer");
227 interface_->BlitFramebufferEXT(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0,
228 dstX1, dstY1, mask, filter);
229 }
230
231 void GL_BINDING_CALL
232 MockGLInterface::Mock_glBlitFramebufferANGLE(GLint srcX0,
233 GLint srcY0,
234 GLint srcX1,
235 GLint srcY1,
236 GLint dstX0,
237 GLint dstY0,
238 GLint dstX1,
239 GLint dstY1,
240 GLbitfield mask,
241 GLenum filter) {
242 MakeFunctionUnique("glBlitFramebufferANGLE");
243 interface_->BlitFramebufferANGLE(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0,
244 dstX1, dstY1, mask, filter);
245 }
246
247 void GL_BINDING_CALL MockGLInterface::Mock_glBlitFramebufferEXT(GLint srcX0,
248 GLint srcY0,
249 GLint srcX1,
250 GLint srcY1,
251 GLint dstX0,
252 GLint dstY0,
253 GLint dstX1,
254 GLint dstY1,
255 GLbitfield mask,
256 GLenum filter) {
257 MakeFunctionUnique("glBlitFramebufferEXT");
258 interface_->BlitFramebufferEXT(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0,
259 dstX1, dstY1, mask, filter);
260 }
261
262 void GL_BINDING_CALL MockGLInterface::Mock_glBufferData(GLenum target,
263 GLsizeiptr size,
264 const void* data,
265 GLenum usage) {
266 MakeFunctionUnique("glBufferData");
267 interface_->BufferData(target, size, data, usage);
268 }
269
270 void GL_BINDING_CALL MockGLInterface::Mock_glBufferSubData(GLenum target,
271 GLintptr offset,
272 GLsizeiptr size,
273 const void* data) {
274 MakeFunctionUnique("glBufferSubData");
275 interface_->BufferSubData(target, offset, size, data);
276 }
277
278 GLenum GL_BINDING_CALL
279 MockGLInterface::Mock_glCheckFramebufferStatus(GLenum target) {
280 MakeFunctionUnique("glCheckFramebufferStatus");
281 return interface_->CheckFramebufferStatusEXT(target);
282 }
283
284 GLenum GL_BINDING_CALL
285 MockGLInterface::Mock_glCheckFramebufferStatusEXT(GLenum target) {
286 MakeFunctionUnique("glCheckFramebufferStatusEXT");
287 return interface_->CheckFramebufferStatusEXT(target);
288 }
289
290 void GL_BINDING_CALL MockGLInterface::Mock_glClear(GLbitfield mask) {
291 MakeFunctionUnique("glClear");
292 interface_->Clear(mask);
293 }
294
295 void GL_BINDING_CALL MockGLInterface::Mock_glClearBufferfi(GLenum buffer,
296 GLint drawbuffer,
297 const GLfloat depth,
298 GLint stencil) {
299 MakeFunctionUnique("glClearBufferfi");
300 interface_->ClearBufferfi(buffer, drawbuffer, depth, stencil);
301 }
302
303 void GL_BINDING_CALL
304 MockGLInterface::Mock_glClearBufferfv(GLenum buffer,
305 GLint drawbuffer,
306 const GLfloat* value) {
307 MakeFunctionUnique("glClearBufferfv");
308 interface_->ClearBufferfv(buffer, drawbuffer, value);
309 }
310
311 void GL_BINDING_CALL MockGLInterface::Mock_glClearBufferiv(GLenum buffer,
312 GLint drawbuffer,
313 const GLint* value) {
314 MakeFunctionUnique("glClearBufferiv");
315 interface_->ClearBufferiv(buffer, drawbuffer, value);
316 }
317
318 void GL_BINDING_CALL
319 MockGLInterface::Mock_glClearBufferuiv(GLenum buffer,
320 GLint drawbuffer,
321 const GLuint* value) {
322 MakeFunctionUnique("glClearBufferuiv");
323 interface_->ClearBufferuiv(buffer, drawbuffer, value);
324 }
325
326 void GL_BINDING_CALL MockGLInterface::Mock_glClearColor(GLclampf red,
327 GLclampf green,
328 GLclampf blue,
329 GLclampf alpha) {
330 MakeFunctionUnique("glClearColor");
331 interface_->ClearColor(red, green, blue, alpha);
332 }
333
334 void GL_BINDING_CALL MockGLInterface::Mock_glClearDepth(GLclampd depth) {
335 MakeFunctionUnique("glClearDepth");
336 interface_->ClearDepth(depth);
337 }
338
339 void GL_BINDING_CALL MockGLInterface::Mock_glClearDepthf(GLclampf depth) {
340 MakeFunctionUnique("glClearDepthf");
341 interface_->ClearDepthf(depth);
342 }
343
344 void GL_BINDING_CALL MockGLInterface::Mock_glClearStencil(GLint s) {
345 MakeFunctionUnique("glClearStencil");
346 interface_->ClearStencil(s);
347 }
348
349 GLenum GL_BINDING_CALL
350 MockGLInterface::Mock_glClientWaitSync(GLsync sync,
351 GLbitfield flags,
352 GLuint64 timeout) {
353 MakeFunctionUnique("glClientWaitSync");
354 return interface_->ClientWaitSync(sync, flags, timeout);
355 }
356
357 void GL_BINDING_CALL MockGLInterface::Mock_glColorMask(GLboolean red,
358 GLboolean green,
359 GLboolean blue,
360 GLboolean alpha) {
361 MakeFunctionUnique("glColorMask");
362 interface_->ColorMask(red, green, blue, alpha);
363 }
364
365 void GL_BINDING_CALL MockGLInterface::Mock_glCompileShader(GLuint shader) {
366 MakeFunctionUnique("glCompileShader");
367 interface_->CompileShader(shader);
368 }
369
370 void GL_BINDING_CALL
371 MockGLInterface::Mock_glCompressedTexImage2D(GLenum target,
372 GLint level,
373 GLenum internalformat,
374 GLsizei width,
375 GLsizei height,
376 GLint border,
377 GLsizei imageSize,
378 const void* data) {
379 MakeFunctionUnique("glCompressedTexImage2D");
380 interface_->CompressedTexImage2D(target, level, internalformat, width, height,
381 border, imageSize, data);
382 }
383
384 void GL_BINDING_CALL
385 MockGLInterface::Mock_glCompressedTexImage3D(GLenum target,
386 GLint level,
387 GLenum internalformat,
388 GLsizei width,
389 GLsizei height,
390 GLsizei depth,
391 GLint border,
392 GLsizei imageSize,
393 const void* data) {
394 MakeFunctionUnique("glCompressedTexImage3D");
395 interface_->CompressedTexImage3D(target, level, internalformat, width, height,
396 depth, border, imageSize, data);
397 }
398
399 void GL_BINDING_CALL
400 MockGLInterface::Mock_glCompressedTexSubImage2D(GLenum target,
401 GLint level,
402 GLint xoffset,
403 GLint yoffset,
404 GLsizei width,
405 GLsizei height,
406 GLenum format,
407 GLsizei imageSize,
408 const void* data) {
409 MakeFunctionUnique("glCompressedTexSubImage2D");
410 interface_->CompressedTexSubImage2D(target, level, xoffset, yoffset, width,
411 height, format, imageSize, data);
412 }
413
414 void GL_BINDING_CALL
415 MockGLInterface::Mock_glCompressedTexSubImage3D(GLenum target,
416 GLint level,
417 GLint xoffset,
418 GLint yoffset,
419 GLint zoffset,
420 GLsizei width,
421 GLsizei height,
422 GLsizei depth,
423 GLenum format,
424 GLsizei imageSize,
425 const void* data) {
426 MakeFunctionUnique("glCompressedTexSubImage3D");
427 interface_->CompressedTexSubImage3D(target, level, xoffset, yoffset, zoffset,
428 width, height, depth, format, imageSize,
429 data);
430 }
431
432 void GL_BINDING_CALL
433 MockGLInterface::Mock_glCopyBufferSubData(GLenum readTarget,
434 GLenum writeTarget,
435 GLintptr readOffset,
436 GLintptr writeOffset,
437 GLsizeiptr size) {
438 MakeFunctionUnique("glCopyBufferSubData");
439 interface_->CopyBufferSubData(readTarget, writeTarget, readOffset,
440 writeOffset, size);
441 }
442
443 void GL_BINDING_CALL
444 MockGLInterface::Mock_glCopyTexImage2D(GLenum target,
445 GLint level,
446 GLenum internalformat,
447 GLint x,
448 GLint y,
449 GLsizei width,
450 GLsizei height,
451 GLint border) {
452 MakeFunctionUnique("glCopyTexImage2D");
453 interface_->CopyTexImage2D(target, level, internalformat, x, y, width, height,
454 border);
455 }
456
457 void GL_BINDING_CALL MockGLInterface::Mock_glCopyTexSubImage2D(GLenum target,
458 GLint level,
459 GLint xoffset,
460 GLint yoffset,
461 GLint x,
462 GLint y,
463 GLsizei width,
464 GLsizei height) {
465 MakeFunctionUnique("glCopyTexSubImage2D");
466 interface_->CopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width,
467 height);
468 }
469
470 void GL_BINDING_CALL MockGLInterface::Mock_glCopyTexSubImage3D(GLenum target,
471 GLint level,
472 GLint xoffset,
473 GLint yoffset,
474 GLint zoffset,
475 GLint x,
476 GLint y,
477 GLsizei width,
478 GLsizei height) {
479 MakeFunctionUnique("glCopyTexSubImage3D");
480 interface_->CopyTexSubImage3D(target, level, xoffset, yoffset, zoffset, x, y,
481 width, height);
482 }
483
484 void GL_BINDING_CALL MockGLInterface::Mock_glCoverFillPathNV(GLuint path,
485 GLenum coverMode) {
486 MakeFunctionUnique("glCoverFillPathNV");
487 interface_->CoverFillPathNV(path, coverMode);
488 }
489
490 void GL_BINDING_CALL
491 MockGLInterface::Mock_glCoverStrokePathNV(GLuint name, GLenum coverMode) {
492 MakeFunctionUnique("glCoverStrokePathNV");
493 interface_->CoverStrokePathNV(name, coverMode);
494 }
495
496 GLuint GL_BINDING_CALL MockGLInterface::Mock_glCreateProgram(void) {
497 MakeFunctionUnique("glCreateProgram");
498 return interface_->CreateProgram();
499 }
500
501 GLuint GL_BINDING_CALL MockGLInterface::Mock_glCreateShader(GLenum type) {
502 MakeFunctionUnique("glCreateShader");
503 return interface_->CreateShader(type);
504 }
505
506 void GL_BINDING_CALL MockGLInterface::Mock_glCullFace(GLenum mode) {
507 MakeFunctionUnique("glCullFace");
508 interface_->CullFace(mode);
509 }
510
511 void GL_BINDING_CALL
512 MockGLInterface::Mock_glDeleteBuffers(GLsizei n, const GLuint* buffers) {
513 MakeFunctionUnique("glDeleteBuffers");
514 interface_->DeleteBuffersARB(n, buffers);
515 }
516
517 void GL_BINDING_CALL
518 MockGLInterface::Mock_glDeleteFencesAPPLE(GLsizei n, const GLuint* fences) {
519 MakeFunctionUnique("glDeleteFencesAPPLE");
520 interface_->DeleteFencesAPPLE(n, fences);
521 }
522
523 void GL_BINDING_CALL
524 MockGLInterface::Mock_glDeleteFencesNV(GLsizei n, const GLuint* fences) {
525 MakeFunctionUnique("glDeleteFencesNV");
526 interface_->DeleteFencesNV(n, fences);
527 }
528
529 void GL_BINDING_CALL
530 MockGLInterface::Mock_glDeleteFramebuffers(GLsizei n,
531 const GLuint* framebuffers) {
532 MakeFunctionUnique("glDeleteFramebuffers");
533 interface_->DeleteFramebuffersEXT(n, framebuffers);
534 }
535
536 void GL_BINDING_CALL
537 MockGLInterface::Mock_glDeleteFramebuffersEXT(GLsizei n,
538 const GLuint* framebuffers) {
539 MakeFunctionUnique("glDeleteFramebuffersEXT");
540 interface_->DeleteFramebuffersEXT(n, framebuffers);
541 }
542
543 void GL_BINDING_CALL MockGLInterface::Mock_glDeletePathsNV(GLuint path,
544 GLsizei range) {
545 MakeFunctionUnique("glDeletePathsNV");
546 interface_->DeletePathsNV(path, range);
547 }
548
549 void GL_BINDING_CALL MockGLInterface::Mock_glDeleteProgram(GLuint program) {
550 MakeFunctionUnique("glDeleteProgram");
551 interface_->DeleteProgram(program);
552 }
553
554 void GL_BINDING_CALL MockGLInterface::Mock_glDeleteQueries(GLsizei n,
555 const GLuint* ids) {
556 MakeFunctionUnique("glDeleteQueries");
557 interface_->DeleteQueries(n, ids);
558 }
559
560 void GL_BINDING_CALL
561 MockGLInterface::Mock_glDeleteQueriesARB(GLsizei n, const GLuint* ids) {
562 MakeFunctionUnique("glDeleteQueriesARB");
563 interface_->DeleteQueries(n, ids);
564 }
565
566 void GL_BINDING_CALL
567 MockGLInterface::Mock_glDeleteQueriesEXT(GLsizei n, const GLuint* ids) {
568 MakeFunctionUnique("glDeleteQueriesEXT");
569 interface_->DeleteQueries(n, ids);
570 }
571
572 void GL_BINDING_CALL
573 MockGLInterface::Mock_glDeleteRenderbuffers(GLsizei n,
574 const GLuint* renderbuffers) {
575 MakeFunctionUnique("glDeleteRenderbuffers");
576 interface_->DeleteRenderbuffersEXT(n, renderbuffers);
577 }
578
579 void GL_BINDING_CALL
580 MockGLInterface::Mock_glDeleteRenderbuffersEXT(GLsizei n,
581 const GLuint* renderbuffers) {
582 MakeFunctionUnique("glDeleteRenderbuffersEXT");
583 interface_->DeleteRenderbuffersEXT(n, renderbuffers);
584 }
585
586 void GL_BINDING_CALL
587 MockGLInterface::Mock_glDeleteSamplers(GLsizei n, const GLuint* samplers) {
588 MakeFunctionUnique("glDeleteSamplers");
589 interface_->DeleteSamplers(n, samplers);
590 }
591
592 void GL_BINDING_CALL MockGLInterface::Mock_glDeleteShader(GLuint shader) {
593 MakeFunctionUnique("glDeleteShader");
594 interface_->DeleteShader(shader);
595 }
596
597 void GL_BINDING_CALL MockGLInterface::Mock_glDeleteSync(GLsync sync) {
598 MakeFunctionUnique("glDeleteSync");
599 interface_->DeleteSync(sync);
600 }
601
602 void GL_BINDING_CALL
603 MockGLInterface::Mock_glDeleteTextures(GLsizei n, const GLuint* textures) {
604 MakeFunctionUnique("glDeleteTextures");
605 interface_->DeleteTextures(n, textures);
606 }
607
608 void GL_BINDING_CALL
609 MockGLInterface::Mock_glDeleteTransformFeedbacks(GLsizei n, const GLuint* ids) {
610 MakeFunctionUnique("glDeleteTransformFeedbacks");
611 interface_->DeleteTransformFeedbacks(n, ids);
612 }
613
614 void GL_BINDING_CALL
615 MockGLInterface::Mock_glDeleteVertexArrays(GLsizei n, const GLuint* arrays) {
616 MakeFunctionUnique("glDeleteVertexArrays");
617 interface_->DeleteVertexArraysOES(n, arrays);
618 }
619
620 void GL_BINDING_CALL
621 MockGLInterface::Mock_glDeleteVertexArraysAPPLE(GLsizei n,
622 const GLuint* arrays) {
623 MakeFunctionUnique("glDeleteVertexArraysAPPLE");
624 interface_->DeleteVertexArraysOES(n, arrays);
625 }
626
627 void GL_BINDING_CALL
628 MockGLInterface::Mock_glDeleteVertexArraysOES(GLsizei n, const GLuint* arrays) {
629 MakeFunctionUnique("glDeleteVertexArraysOES");
630 interface_->DeleteVertexArraysOES(n, arrays);
631 }
632
633 void GL_BINDING_CALL MockGLInterface::Mock_glDepthFunc(GLenum func) {
634 MakeFunctionUnique("glDepthFunc");
635 interface_->DepthFunc(func);
636 }
637
638 void GL_BINDING_CALL MockGLInterface::Mock_glDepthMask(GLboolean flag) {
639 MakeFunctionUnique("glDepthMask");
640 interface_->DepthMask(flag);
641 }
642
643 void GL_BINDING_CALL MockGLInterface::Mock_glDepthRange(GLclampd zNear,
644 GLclampd zFar) {
645 MakeFunctionUnique("glDepthRange");
646 interface_->DepthRange(zNear, zFar);
647 }
648
649 void GL_BINDING_CALL MockGLInterface::Mock_glDepthRangef(GLclampf zNear,
650 GLclampf zFar) {
651 MakeFunctionUnique("glDepthRangef");
652 interface_->DepthRangef(zNear, zFar);
653 }
654
655 void GL_BINDING_CALL MockGLInterface::Mock_glDetachShader(GLuint program,
656 GLuint shader) {
657 MakeFunctionUnique("glDetachShader");
658 interface_->DetachShader(program, shader);
659 }
660
661 void GL_BINDING_CALL MockGLInterface::Mock_glDisable(GLenum cap) {
662 MakeFunctionUnique("glDisable");
663 interface_->Disable(cap);
664 }
665
666 void GL_BINDING_CALL
667 MockGLInterface::Mock_glDisableVertexAttribArray(GLuint index) {
668 MakeFunctionUnique("glDisableVertexAttribArray");
669 interface_->DisableVertexAttribArray(index);
670 }
671
672 void GL_BINDING_CALL
673 MockGLInterface::Mock_glDiscardFramebufferEXT(GLenum target,
674 GLsizei numAttachments,
675 const GLenum* attachments) {
676 MakeFunctionUnique("glDiscardFramebufferEXT");
677 interface_->DiscardFramebufferEXT(target, numAttachments, attachments);
678 }
679
680 void GL_BINDING_CALL MockGLInterface::Mock_glDrawArrays(GLenum mode,
681 GLint first,
682 GLsizei count) {
683 MakeFunctionUnique("glDrawArrays");
684 interface_->DrawArrays(mode, first, count);
685 }
686
687 void GL_BINDING_CALL
688 MockGLInterface::Mock_glDrawArraysInstanced(GLenum mode,
689 GLint first,
690 GLsizei count,
691 GLsizei primcount) {
692 MakeFunctionUnique("glDrawArraysInstanced");
693 interface_->DrawArraysInstancedANGLE(mode, first, count, primcount);
694 }
695
696 void GL_BINDING_CALL
697 MockGLInterface::Mock_glDrawArraysInstancedANGLE(GLenum mode,
698 GLint first,
699 GLsizei count,
700 GLsizei primcount) {
701 MakeFunctionUnique("glDrawArraysInstancedANGLE");
702 interface_->DrawArraysInstancedANGLE(mode, first, count, primcount);
703 }
704
705 void GL_BINDING_CALL
706 MockGLInterface::Mock_glDrawArraysInstancedARB(GLenum mode,
707 GLint first,
708 GLsizei count,
709 GLsizei primcount) {
710 MakeFunctionUnique("glDrawArraysInstancedARB");
711 interface_->DrawArraysInstancedANGLE(mode, first, count, primcount);
712 }
713
714 void GL_BINDING_CALL MockGLInterface::Mock_glDrawBuffer(GLenum mode) {
715 MakeFunctionUnique("glDrawBuffer");
716 interface_->DrawBuffer(mode);
717 }
718
719 void GL_BINDING_CALL MockGLInterface::Mock_glDrawBuffers(GLsizei n,
720 const GLenum* bufs) {
721 MakeFunctionUnique("glDrawBuffers");
722 interface_->DrawBuffersARB(n, bufs);
723 }
724
725 void GL_BINDING_CALL
726 MockGLInterface::Mock_glDrawBuffersARB(GLsizei n, const GLenum* bufs) {
727 MakeFunctionUnique("glDrawBuffersARB");
728 interface_->DrawBuffersARB(n, bufs);
729 }
730
731 void GL_BINDING_CALL
732 MockGLInterface::Mock_glDrawBuffersEXT(GLsizei n, const GLenum* bufs) {
733 MakeFunctionUnique("glDrawBuffersEXT");
734 interface_->DrawBuffersARB(n, bufs);
735 }
736
737 void GL_BINDING_CALL MockGLInterface::Mock_glDrawElements(GLenum mode,
738 GLsizei count,
739 GLenum type,
740 const void* indices) {
741 MakeFunctionUnique("glDrawElements");
742 interface_->DrawElements(mode, count, type, indices);
743 }
744
745 void GL_BINDING_CALL
746 MockGLInterface::Mock_glDrawElementsInstanced(GLenum mode,
747 GLsizei count,
748 GLenum type,
749 const void* indices,
750 GLsizei primcount) {
751 MakeFunctionUnique("glDrawElementsInstanced");
752 interface_->DrawElementsInstancedANGLE(mode, count, type, indices, primcount);
753 }
754
755 void GL_BINDING_CALL
756 MockGLInterface::Mock_glDrawElementsInstancedANGLE(GLenum mode,
757 GLsizei count,
758 GLenum type,
759 const void* indices,
760 GLsizei primcount) {
761 MakeFunctionUnique("glDrawElementsInstancedANGLE");
762 interface_->DrawElementsInstancedANGLE(mode, count, type, indices, primcount);
763 }
764
765 void GL_BINDING_CALL
766 MockGLInterface::Mock_glDrawElementsInstancedARB(GLenum mode,
767 GLsizei count,
768 GLenum type,
769 const void* indices,
770 GLsizei primcount) {
771 MakeFunctionUnique("glDrawElementsInstancedARB");
772 interface_->DrawElementsInstancedANGLE(mode, count, type, indices, primcount);
773 }
774
775 void GL_BINDING_CALL
776 MockGLInterface::Mock_glDrawRangeElements(GLenum mode,
777 GLuint start,
778 GLuint end,
779 GLsizei count,
780 GLenum type,
781 const void* indices) {
782 MakeFunctionUnique("glDrawRangeElements");
783 interface_->DrawRangeElements(mode, start, end, count, type, indices);
784 }
785
786 void GL_BINDING_CALL
787 MockGLInterface::Mock_glEGLImageTargetRenderbufferStorageOES(
788 GLenum target,
789 GLeglImageOES image) {
790 MakeFunctionUnique("glEGLImageTargetRenderbufferStorageOES");
791 interface_->EGLImageTargetRenderbufferStorageOES(target, image);
792 }
793
794 void GL_BINDING_CALL
795 MockGLInterface::Mock_glEGLImageTargetTexture2DOES(GLenum target,
796 GLeglImageOES image) {
797 MakeFunctionUnique("glEGLImageTargetTexture2DOES");
798 interface_->EGLImageTargetTexture2DOES(target, image);
799 }
800
801 void GL_BINDING_CALL MockGLInterface::Mock_glEnable(GLenum cap) {
802 MakeFunctionUnique("glEnable");
803 interface_->Enable(cap);
804 }
805
806 void GL_BINDING_CALL
807 MockGLInterface::Mock_glEnableVertexAttribArray(GLuint index) {
808 MakeFunctionUnique("glEnableVertexAttribArray");
809 interface_->EnableVertexAttribArray(index);
810 }
811
812 void GL_BINDING_CALL MockGLInterface::Mock_glEndQuery(GLenum target) {
813 MakeFunctionUnique("glEndQuery");
814 interface_->EndQuery(target);
815 }
816
817 void GL_BINDING_CALL MockGLInterface::Mock_glEndQueryARB(GLenum target) {
818 MakeFunctionUnique("glEndQueryARB");
819 interface_->EndQuery(target);
820 }
821
822 void GL_BINDING_CALL MockGLInterface::Mock_glEndQueryEXT(GLenum target) {
823 MakeFunctionUnique("glEndQueryEXT");
824 interface_->EndQuery(target);
825 }
826
827 void GL_BINDING_CALL MockGLInterface::Mock_glEndTransformFeedback(void) {
828 MakeFunctionUnique("glEndTransformFeedback");
829 interface_->EndTransformFeedback();
830 }
831
832 GLsync GL_BINDING_CALL MockGLInterface::Mock_glFenceSync(GLenum condition,
833 GLbitfield flags) {
834 MakeFunctionUnique("glFenceSync");
835 return interface_->FenceSync(condition, flags);
836 }
837
838 void GL_BINDING_CALL MockGLInterface::Mock_glFinish(void) {
839 MakeFunctionUnique("glFinish");
840 interface_->Finish();
841 }
842
843 void GL_BINDING_CALL MockGLInterface::Mock_glFinishFenceAPPLE(GLuint fence) {
844 MakeFunctionUnique("glFinishFenceAPPLE");
845 interface_->FinishFenceAPPLE(fence);
846 }
847
848 void GL_BINDING_CALL MockGLInterface::Mock_glFinishFenceNV(GLuint fence) {
849 MakeFunctionUnique("glFinishFenceNV");
850 interface_->FinishFenceNV(fence);
851 }
852
853 void GL_BINDING_CALL MockGLInterface::Mock_glFlush(void) {
854 MakeFunctionUnique("glFlush");
855 interface_->Flush();
856 }
857
858 void GL_BINDING_CALL
859 MockGLInterface::Mock_glFlushMappedBufferRange(GLenum target,
860 GLintptr offset,
861 GLsizeiptr length) {
862 MakeFunctionUnique("glFlushMappedBufferRange");
863 interface_->FlushMappedBufferRange(target, offset, length);
864 }
865
866 void GL_BINDING_CALL
867 MockGLInterface::Mock_glFramebufferRenderbuffer(GLenum target,
868 GLenum attachment,
869 GLenum renderbuffertarget,
870 GLuint renderbuffer) {
871 MakeFunctionUnique("glFramebufferRenderbuffer");
872 interface_->FramebufferRenderbufferEXT(target, attachment, renderbuffertarget,
873 renderbuffer);
874 }
875
876 void GL_BINDING_CALL
877 MockGLInterface::Mock_glFramebufferRenderbufferEXT(GLenum target,
878 GLenum attachment,
879 GLenum renderbuffertarget,
880 GLuint renderbuffer) {
881 MakeFunctionUnique("glFramebufferRenderbufferEXT");
882 interface_->FramebufferRenderbufferEXT(target, attachment, renderbuffertarget,
883 renderbuffer);
884 }
885
886 void GL_BINDING_CALL
887 MockGLInterface::Mock_glFramebufferTexture2D(GLenum target,
888 GLenum attachment,
889 GLenum textarget,
890 GLuint texture,
891 GLint level) {
892 MakeFunctionUnique("glFramebufferTexture2D");
893 interface_->FramebufferTexture2DEXT(target, attachment, textarget, texture,
894 level);
895 }
896
897 void GL_BINDING_CALL
898 MockGLInterface::Mock_glFramebufferTexture2DEXT(GLenum target,
899 GLenum attachment,
900 GLenum textarget,
901 GLuint texture,
902 GLint level) {
903 MakeFunctionUnique("glFramebufferTexture2DEXT");
904 interface_->FramebufferTexture2DEXT(target, attachment, textarget, texture,
905 level);
906 }
907
908 void GL_BINDING_CALL
909 MockGLInterface::Mock_glFramebufferTexture2DMultisampleEXT(GLenum target,
910 GLenum attachment,
911 GLenum textarget,
912 GLuint texture,
913 GLint level,
914 GLsizei samples) {
915 MakeFunctionUnique("glFramebufferTexture2DMultisampleEXT");
916 interface_->FramebufferTexture2DMultisampleEXT(target, attachment, textarget,
917 texture, level, samples);
918 }
919
920 void GL_BINDING_CALL
921 MockGLInterface::Mock_glFramebufferTexture2DMultisampleIMG(GLenum target,
922 GLenum attachment,
923 GLenum textarget,
924 GLuint texture,
925 GLint level,
926 GLsizei samples) {
927 MakeFunctionUnique("glFramebufferTexture2DMultisampleIMG");
928 interface_->FramebufferTexture2DMultisampleIMG(target, attachment, textarget,
929 texture, level, samples);
930 }
931
932 void GL_BINDING_CALL
933 MockGLInterface::Mock_glFramebufferTextureLayer(GLenum target,
934 GLenum attachment,
935 GLuint texture,
936 GLint level,
937 GLint layer) {
938 MakeFunctionUnique("glFramebufferTextureLayer");
939 interface_->FramebufferTextureLayer(target, attachment, texture, level,
940 layer);
941 }
942
943 void GL_BINDING_CALL MockGLInterface::Mock_glFrontFace(GLenum mode) {
944 MakeFunctionUnique("glFrontFace");
945 interface_->FrontFace(mode);
946 }
947
948 void GL_BINDING_CALL MockGLInterface::Mock_glGenBuffers(GLsizei n,
949 GLuint* buffers) {
950 MakeFunctionUnique("glGenBuffers");
951 interface_->GenBuffersARB(n, buffers);
952 }
953
954 void GL_BINDING_CALL MockGLInterface::Mock_glGenFencesAPPLE(GLsizei n,
955 GLuint* fences) {
956 MakeFunctionUnique("glGenFencesAPPLE");
957 interface_->GenFencesAPPLE(n, fences);
958 }
959
960 void GL_BINDING_CALL MockGLInterface::Mock_glGenFencesNV(GLsizei n,
961 GLuint* fences) {
962 MakeFunctionUnique("glGenFencesNV");
963 interface_->GenFencesNV(n, fences);
964 }
965
966 void GL_BINDING_CALL
967 MockGLInterface::Mock_glGenFramebuffers(GLsizei n, GLuint* framebuffers) {
968 MakeFunctionUnique("glGenFramebuffers");
969 interface_->GenFramebuffersEXT(n, framebuffers);
970 }
971
972 void GL_BINDING_CALL
973 MockGLInterface::Mock_glGenFramebuffersEXT(GLsizei n, GLuint* framebuffers) {
974 MakeFunctionUnique("glGenFramebuffersEXT");
975 interface_->GenFramebuffersEXT(n, framebuffers);
976 }
977
978 GLuint GL_BINDING_CALL MockGLInterface::Mock_glGenPathsNV(GLsizei range) {
979 MakeFunctionUnique("glGenPathsNV");
980 return interface_->GenPathsNV(range);
981 }
982
983 void GL_BINDING_CALL MockGLInterface::Mock_glGenQueries(GLsizei n,
984 GLuint* ids) {
985 MakeFunctionUnique("glGenQueries");
986 interface_->GenQueries(n, ids);
987 }
988
989 void GL_BINDING_CALL MockGLInterface::Mock_glGenQueriesARB(GLsizei n,
990 GLuint* ids) {
991 MakeFunctionUnique("glGenQueriesARB");
992 interface_->GenQueries(n, ids);
993 }
994
995 void GL_BINDING_CALL MockGLInterface::Mock_glGenQueriesEXT(GLsizei n,
996 GLuint* ids) {
997 MakeFunctionUnique("glGenQueriesEXT");
998 interface_->GenQueries(n, ids);
999 }
1000
1001 void GL_BINDING_CALL
1002 MockGLInterface::Mock_glGenRenderbuffers(GLsizei n, GLuint* renderbuffers) {
1003 MakeFunctionUnique("glGenRenderbuffers");
1004 interface_->GenRenderbuffersEXT(n, renderbuffers);
1005 }
1006
1007 void GL_BINDING_CALL
1008 MockGLInterface::Mock_glGenRenderbuffersEXT(GLsizei n, GLuint* renderbuffers) {
1009 MakeFunctionUnique("glGenRenderbuffersEXT");
1010 interface_->GenRenderbuffersEXT(n, renderbuffers);
1011 }
1012
1013 void GL_BINDING_CALL MockGLInterface::Mock_glGenSamplers(GLsizei n,
1014 GLuint* samplers) {
1015 MakeFunctionUnique("glGenSamplers");
1016 interface_->GenSamplers(n, samplers);
1017 }
1018
1019 void GL_BINDING_CALL MockGLInterface::Mock_glGenTextures(GLsizei n,
1020 GLuint* textures) {
1021 MakeFunctionUnique("glGenTextures");
1022 interface_->GenTextures(n, textures);
1023 }
1024
1025 void GL_BINDING_CALL
1026 MockGLInterface::Mock_glGenTransformFeedbacks(GLsizei n, GLuint* ids) {
1027 MakeFunctionUnique("glGenTransformFeedbacks");
1028 interface_->GenTransformFeedbacks(n, ids);
1029 }
1030
1031 void GL_BINDING_CALL MockGLInterface::Mock_glGenVertexArrays(GLsizei n,
1032 GLuint* arrays) {
1033 MakeFunctionUnique("glGenVertexArrays");
1034 interface_->GenVertexArraysOES(n, arrays);
1035 }
1036
1037 void GL_BINDING_CALL
1038 MockGLInterface::Mock_glGenVertexArraysAPPLE(GLsizei n, GLuint* arrays) {
1039 MakeFunctionUnique("glGenVertexArraysAPPLE");
1040 interface_->GenVertexArraysOES(n, arrays);
1041 }
1042
1043 void GL_BINDING_CALL
1044 MockGLInterface::Mock_glGenVertexArraysOES(GLsizei n, GLuint* arrays) {
1045 MakeFunctionUnique("glGenVertexArraysOES");
1046 interface_->GenVertexArraysOES(n, arrays);
1047 }
1048
1049 void GL_BINDING_CALL MockGLInterface::Mock_glGenerateMipmap(GLenum target) {
1050 MakeFunctionUnique("glGenerateMipmap");
1051 interface_->GenerateMipmapEXT(target);
1052 }
1053
1054 void GL_BINDING_CALL MockGLInterface::Mock_glGenerateMipmapEXT(GLenum target) {
1055 MakeFunctionUnique("glGenerateMipmapEXT");
1056 interface_->GenerateMipmapEXT(target);
1057 }
1058
1059 void GL_BINDING_CALL MockGLInterface::Mock_glGetActiveAttrib(GLuint program,
1060 GLuint index,
1061 GLsizei bufsize,
1062 GLsizei* length,
1063 GLint* size,
1064 GLenum* type,
1065 char* name) {
1066 MakeFunctionUnique("glGetActiveAttrib");
1067 interface_->GetActiveAttrib(program, index, bufsize, length, size, type,
1068 name);
1069 }
1070
1071 void GL_BINDING_CALL MockGLInterface::Mock_glGetActiveUniform(GLuint program,
1072 GLuint index,
1073 GLsizei bufsize,
1074 GLsizei* length,
1075 GLint* size,
1076 GLenum* type,
1077 char* name) {
1078 MakeFunctionUnique("glGetActiveUniform");
1079 interface_->GetActiveUniform(program, index, bufsize, length, size, type,
1080 name);
1081 }
1082
1083 void GL_BINDING_CALL
1084 MockGLInterface::Mock_glGetActiveUniformBlockName(GLuint program,
1085 GLuint uniformBlockIndex,
1086 GLsizei bufSize,
1087 GLsizei* length,
1088 char* uniformBlockName) {
1089 MakeFunctionUnique("glGetActiveUniformBlockName");
1090 interface_->GetActiveUniformBlockName(program, uniformBlockIndex, bufSize,
1091 length, uniformBlockName);
1092 }
1093
1094 void GL_BINDING_CALL
1095 MockGLInterface::Mock_glGetActiveUniformBlockiv(GLuint program,
1096 GLuint uniformBlockIndex,
1097 GLenum pname,
1098 GLint* params) {
1099 MakeFunctionUnique("glGetActiveUniformBlockiv");
1100 interface_->GetActiveUniformBlockiv(program, uniformBlockIndex, pname,
1101 params);
1102 }
1103
1104 void GL_BINDING_CALL
1105 MockGLInterface::Mock_glGetActiveUniformsiv(GLuint program,
1106 GLsizei uniformCount,
1107 const GLuint* uniformIndices,
1108 GLenum pname,
1109 GLint* params) {
1110 MakeFunctionUnique("glGetActiveUniformsiv");
1111 interface_->GetActiveUniformsiv(program, uniformCount, uniformIndices, pname,
1112 params);
1113 }
1114
1115 void GL_BINDING_CALL
1116 MockGLInterface::Mock_glGetAttachedShaders(GLuint program,
1117 GLsizei maxcount,
1118 GLsizei* count,
1119 GLuint* shaders) {
1120 MakeFunctionUnique("glGetAttachedShaders");
1121 interface_->GetAttachedShaders(program, maxcount, count, shaders);
1122 }
1123
1124 GLint GL_BINDING_CALL
1125 MockGLInterface::Mock_glGetAttribLocation(GLuint program, const char* name) {
1126 MakeFunctionUnique("glGetAttribLocation");
1127 return interface_->GetAttribLocation(program, name);
1128 }
1129
1130 void GL_BINDING_CALL MockGLInterface::Mock_glGetBooleanv(GLenum pname,
1131 GLboolean* params) {
1132 MakeFunctionUnique("glGetBooleanv");
1133 interface_->GetBooleanv(pname, params);
1134 }
1135
1136 void GL_BINDING_CALL
1137 MockGLInterface::Mock_glGetBufferParameteriv(GLenum target,
1138 GLenum pname,
1139 GLint* params) {
1140 MakeFunctionUnique("glGetBufferParameteriv");
1141 interface_->GetBufferParameteriv(target, pname, params);
1142 }
1143
1144 GLenum GL_BINDING_CALL MockGLInterface::Mock_glGetError(void) {
1145 MakeFunctionUnique("glGetError");
1146 return interface_->GetError();
1147 }
1148
1149 void GL_BINDING_CALL MockGLInterface::Mock_glGetFenceivNV(GLuint fence,
1150 GLenum pname,
1151 GLint* params) {
1152 MakeFunctionUnique("glGetFenceivNV");
1153 interface_->GetFenceivNV(fence, pname, params);
1154 }
1155
1156 void GL_BINDING_CALL MockGLInterface::Mock_glGetFloatv(GLenum pname,
1157 GLfloat* params) {
1158 MakeFunctionUnique("glGetFloatv");
1159 interface_->GetFloatv(pname, params);
1160 }
1161
1162 GLint GL_BINDING_CALL
1163 MockGLInterface::Mock_glGetFragDataLocation(GLuint program, const char* name) {
1164 MakeFunctionUnique("glGetFragDataLocation");
1165 return interface_->GetFragDataLocation(program, name);
1166 }
1167
1168 void GL_BINDING_CALL
1169 MockGLInterface::Mock_glGetFramebufferAttachmentParameteriv(GLenum target,
1170 GLenum attachment,
1171 GLenum pname,
1172 GLint* params) {
1173 MakeFunctionUnique("glGetFramebufferAttachmentParameteriv");
1174 interface_->GetFramebufferAttachmentParameterivEXT(target, attachment, pname,
1175 params);
1176 }
1177
1178 void GL_BINDING_CALL
1179 MockGLInterface::Mock_glGetFramebufferAttachmentParameterivEXT(
1180 GLenum target,
1181 GLenum attachment,
1182 GLenum pname,
1183 GLint* params) {
1184 MakeFunctionUnique("glGetFramebufferAttachmentParameterivEXT");
1185 interface_->GetFramebufferAttachmentParameterivEXT(target, attachment, pname,
1186 params);
1187 }
1188
1189 GLenum GL_BINDING_CALL MockGLInterface::Mock_glGetGraphicsResetStatus(void) {
1190 MakeFunctionUnique("glGetGraphicsResetStatus");
1191 return interface_->GetGraphicsResetStatusARB();
1192 }
1193
1194 GLenum GL_BINDING_CALL MockGLInterface::Mock_glGetGraphicsResetStatusARB(void) {
1195 MakeFunctionUnique("glGetGraphicsResetStatusARB");
1196 return interface_->GetGraphicsResetStatusARB();
1197 }
1198
1199 GLenum GL_BINDING_CALL MockGLInterface::Mock_glGetGraphicsResetStatusEXT(void) {
1200 MakeFunctionUnique("glGetGraphicsResetStatusEXT");
1201 return interface_->GetGraphicsResetStatusARB();
1202 }
1203
1204 GLenum GL_BINDING_CALL MockGLInterface::Mock_glGetGraphicsResetStatusKHR(void) {
1205 MakeFunctionUnique("glGetGraphicsResetStatusKHR");
1206 return interface_->GetGraphicsResetStatusARB();
1207 }
1208
1209 void GL_BINDING_CALL MockGLInterface::Mock_glGetInteger64i_v(GLenum target,
1210 GLuint index,
1211 GLint64* data) {
1212 MakeFunctionUnique("glGetInteger64i_v");
1213 interface_->GetInteger64i_v(target, index, data);
1214 }
1215
1216 void GL_BINDING_CALL MockGLInterface::Mock_glGetInteger64v(GLenum pname,
1217 GLint64* params) {
1218 MakeFunctionUnique("glGetInteger64v");
1219 interface_->GetInteger64v(pname, params);
1220 }
1221
1222 void GL_BINDING_CALL MockGLInterface::Mock_glGetIntegeri_v(GLenum target,
1223 GLuint index,
1224 GLint* data) {
1225 MakeFunctionUnique("glGetIntegeri_v");
1226 interface_->GetIntegeri_v(target, index, data);
1227 }
1228
1229 void GL_BINDING_CALL MockGLInterface::Mock_glGetIntegerv(GLenum pname,
1230 GLint* params) {
1231 MakeFunctionUnique("glGetIntegerv");
1232 interface_->GetIntegerv(pname, params);
1233 }
1234
1235 void GL_BINDING_CALL
1236 MockGLInterface::Mock_glGetInternalformativ(GLenum target,
1237 GLenum internalformat,
1238 GLenum pname,
1239 GLsizei bufSize,
1240 GLint* params) {
1241 MakeFunctionUnique("glGetInternalformativ");
1242 interface_->GetInternalformativ(target, internalformat, pname, bufSize,
1243 params);
1244 }
1245
1246 void GL_BINDING_CALL
1247 MockGLInterface::Mock_glGetProgramBinary(GLuint program,
1248 GLsizei bufSize,
1249 GLsizei* length,
1250 GLenum* binaryFormat,
1251 GLvoid* binary) {
1252 MakeFunctionUnique("glGetProgramBinary");
1253 interface_->GetProgramBinary(program, bufSize, length, binaryFormat, binary);
1254 }
1255
1256 void GL_BINDING_CALL
1257 MockGLInterface::Mock_glGetProgramBinaryOES(GLuint program,
1258 GLsizei bufSize,
1259 GLsizei* length,
1260 GLenum* binaryFormat,
1261 GLvoid* binary) {
1262 MakeFunctionUnique("glGetProgramBinaryOES");
1263 interface_->GetProgramBinary(program, bufSize, length, binaryFormat, binary);
1264 }
1265
1266 void GL_BINDING_CALL MockGLInterface::Mock_glGetProgramInfoLog(GLuint program,
1267 GLsizei bufsize,
1268 GLsizei* length,
1269 char* infolog) {
1270 MakeFunctionUnique("glGetProgramInfoLog");
1271 interface_->GetProgramInfoLog(program, bufsize, length, infolog);
1272 }
1273
1274 GLint GL_BINDING_CALL
1275 MockGLInterface::Mock_glGetProgramResourceLocation(GLuint program,
1276 GLenum programInterface,
1277 const char* name) {
1278 MakeFunctionUnique("glGetProgramResourceLocation");
1279 return interface_->GetProgramResourceLocation(program, programInterface,
1280 name);
1281 }
1282
1283 void GL_BINDING_CALL MockGLInterface::Mock_glGetProgramiv(GLuint program,
1284 GLenum pname,
1285 GLint* params) {
1286 MakeFunctionUnique("glGetProgramiv");
1287 interface_->GetProgramiv(program, pname, params);
1288 }
1289
1290 void GL_BINDING_CALL
1291 MockGLInterface::Mock_glGetQueryObjecti64v(GLuint id,
1292 GLenum pname,
1293 GLint64* params) {
1294 MakeFunctionUnique("glGetQueryObjecti64v");
1295 interface_->GetQueryObjecti64v(id, pname, params);
1296 }
1297
1298 void GL_BINDING_CALL
1299 MockGLInterface::Mock_glGetQueryObjecti64vEXT(GLuint id,
1300 GLenum pname,
1301 GLint64* params) {
1302 MakeFunctionUnique("glGetQueryObjecti64vEXT");
1303 interface_->GetQueryObjecti64v(id, pname, params);
1304 }
1305
1306 void GL_BINDING_CALL MockGLInterface::Mock_glGetQueryObjectiv(GLuint id,
1307 GLenum pname,
1308 GLint* params) {
1309 MakeFunctionUnique("glGetQueryObjectiv");
1310 interface_->GetQueryObjectiv(id, pname, params);
1311 }
1312
1313 void GL_BINDING_CALL
1314 MockGLInterface::Mock_glGetQueryObjectivARB(GLuint id,
1315 GLenum pname,
1316 GLint* params) {
1317 MakeFunctionUnique("glGetQueryObjectivARB");
1318 interface_->GetQueryObjectiv(id, pname, params);
1319 }
1320
1321 void GL_BINDING_CALL
1322 MockGLInterface::Mock_glGetQueryObjectivEXT(GLuint id,
1323 GLenum pname,
1324 GLint* params) {
1325 MakeFunctionUnique("glGetQueryObjectivEXT");
1326 interface_->GetQueryObjectiv(id, pname, params);
1327 }
1328
1329 void GL_BINDING_CALL
1330 MockGLInterface::Mock_glGetQueryObjectui64v(GLuint id,
1331 GLenum pname,
1332 GLuint64* params) {
1333 MakeFunctionUnique("glGetQueryObjectui64v");
1334 interface_->GetQueryObjectui64v(id, pname, params);
1335 }
1336
1337 void GL_BINDING_CALL
1338 MockGLInterface::Mock_glGetQueryObjectui64vEXT(GLuint id,
1339 GLenum pname,
1340 GLuint64* params) {
1341 MakeFunctionUnique("glGetQueryObjectui64vEXT");
1342 interface_->GetQueryObjectui64v(id, pname, params);
1343 }
1344
1345 void GL_BINDING_CALL MockGLInterface::Mock_glGetQueryObjectuiv(GLuint id,
1346 GLenum pname,
1347 GLuint* params) {
1348 MakeFunctionUnique("glGetQueryObjectuiv");
1349 interface_->GetQueryObjectuiv(id, pname, params);
1350 }
1351
1352 void GL_BINDING_CALL
1353 MockGLInterface::Mock_glGetQueryObjectuivARB(GLuint id,
1354 GLenum pname,
1355 GLuint* params) {
1356 MakeFunctionUnique("glGetQueryObjectuivARB");
1357 interface_->GetQueryObjectuiv(id, pname, params);
1358 }
1359
1360 void GL_BINDING_CALL
1361 MockGLInterface::Mock_glGetQueryObjectuivEXT(GLuint id,
1362 GLenum pname,
1363 GLuint* params) {
1364 MakeFunctionUnique("glGetQueryObjectuivEXT");
1365 interface_->GetQueryObjectuiv(id, pname, params);
1366 }
1367
1368 void GL_BINDING_CALL MockGLInterface::Mock_glGetQueryiv(GLenum target,
1369 GLenum pname,
1370 GLint* params) {
1371 MakeFunctionUnique("glGetQueryiv");
1372 interface_->GetQueryiv(target, pname, params);
1373 }
1374
1375 void GL_BINDING_CALL MockGLInterface::Mock_glGetQueryivARB(GLenum target,
1376 GLenum pname,
1377 GLint* params) {
1378 MakeFunctionUnique("glGetQueryivARB");
1379 interface_->GetQueryiv(target, pname, params);
1380 }
1381
1382 void GL_BINDING_CALL MockGLInterface::Mock_glGetQueryivEXT(GLenum target,
1383 GLenum pname,
1384 GLint* params) {
1385 MakeFunctionUnique("glGetQueryivEXT");
1386 interface_->GetQueryiv(target, pname, params);
1387 }
1388
1389 void GL_BINDING_CALL
1390 MockGLInterface::Mock_glGetRenderbufferParameteriv(GLenum target,
1391 GLenum pname,
1392 GLint* params) {
1393 MakeFunctionUnique("glGetRenderbufferParameteriv");
1394 interface_->GetRenderbufferParameterivEXT(target, pname, params);
1395 }
1396
1397 void GL_BINDING_CALL
1398 MockGLInterface::Mock_glGetRenderbufferParameterivEXT(GLenum target,
1399 GLenum pname,
1400 GLint* params) {
1401 MakeFunctionUnique("glGetRenderbufferParameterivEXT");
1402 interface_->GetRenderbufferParameterivEXT(target, pname, params);
1403 }
1404
1405 void GL_BINDING_CALL
1406 MockGLInterface::Mock_glGetSamplerParameterfv(GLuint sampler,
1407 GLenum pname,
1408 GLfloat* params) {
1409 MakeFunctionUnique("glGetSamplerParameterfv");
1410 interface_->GetSamplerParameterfv(sampler, pname, params);
1411 }
1412
1413 void GL_BINDING_CALL
1414 MockGLInterface::Mock_glGetSamplerParameteriv(GLuint sampler,
1415 GLenum pname,
1416 GLint* params) {
1417 MakeFunctionUnique("glGetSamplerParameteriv");
1418 interface_->GetSamplerParameteriv(sampler, pname, params);
1419 }
1420
1421 void GL_BINDING_CALL MockGLInterface::Mock_glGetShaderInfoLog(GLuint shader,
1422 GLsizei bufsize,
1423 GLsizei* length,
1424 char* infolog) {
1425 MakeFunctionUnique("glGetShaderInfoLog");
1426 interface_->GetShaderInfoLog(shader, bufsize, length, infolog);
1427 }
1428
1429 void GL_BINDING_CALL
1430 MockGLInterface::Mock_glGetShaderPrecisionFormat(GLenum shadertype,
1431 GLenum precisiontype,
1432 GLint* range,
1433 GLint* precision) {
1434 MakeFunctionUnique("glGetShaderPrecisionFormat");
1435 interface_->GetShaderPrecisionFormat(shadertype, precisiontype, range,
1436 precision);
1437 }
1438
1439 void GL_BINDING_CALL MockGLInterface::Mock_glGetShaderSource(GLuint shader,
1440 GLsizei bufsize,
1441 GLsizei* length,
1442 char* source) {
1443 MakeFunctionUnique("glGetShaderSource");
1444 interface_->GetShaderSource(shader, bufsize, length, source);
1445 }
1446
1447 void GL_BINDING_CALL MockGLInterface::Mock_glGetShaderiv(GLuint shader,
1448 GLenum pname,
1449 GLint* params) {
1450 MakeFunctionUnique("glGetShaderiv");
1451 interface_->GetShaderiv(shader, pname, params);
1452 }
1453
1454 const GLubyte* GL_BINDING_CALL MockGLInterface::Mock_glGetString(GLenum name) {
1455 MakeFunctionUnique("glGetString");
1456 return interface_->GetString(name);
1457 }
1458
1459 const GLubyte* GL_BINDING_CALL
1460 MockGLInterface::Mock_glGetStringi(GLenum name, GLuint index) {
1461 MakeFunctionUnique("glGetStringi");
1462 return interface_->GetStringi(name, index);
1463 }
1464
1465 void GL_BINDING_CALL MockGLInterface::Mock_glGetSynciv(GLsync sync,
1466 GLenum pname,
1467 GLsizei bufSize,
1468 GLsizei* length,
1469 GLint* values) {
1470 MakeFunctionUnique("glGetSynciv");
1471 interface_->GetSynciv(sync, pname, bufSize, length, values);
1472 }
1473
1474 void GL_BINDING_CALL
1475 MockGLInterface::Mock_glGetTexLevelParameterfv(GLenum target,
1476 GLint level,
1477 GLenum pname,
1478 GLfloat* params) {
1479 MakeFunctionUnique("glGetTexLevelParameterfv");
1480 interface_->GetTexLevelParameterfv(target, level, pname, params);
1481 }
1482
1483 void GL_BINDING_CALL
1484 MockGLInterface::Mock_glGetTexLevelParameteriv(GLenum target,
1485 GLint level,
1486 GLenum pname,
1487 GLint* params) {
1488 MakeFunctionUnique("glGetTexLevelParameteriv");
1489 interface_->GetTexLevelParameteriv(target, level, pname, params);
1490 }
1491
1492 void GL_BINDING_CALL
1493 MockGLInterface::Mock_glGetTexParameterfv(GLenum target,
1494 GLenum pname,
1495 GLfloat* params) {
1496 MakeFunctionUnique("glGetTexParameterfv");
1497 interface_->GetTexParameterfv(target, pname, params);
1498 }
1499
1500 void GL_BINDING_CALL MockGLInterface::Mock_glGetTexParameteriv(GLenum target,
1501 GLenum pname,
1502 GLint* params) {
1503 MakeFunctionUnique("glGetTexParameteriv");
1504 interface_->GetTexParameteriv(target, pname, params);
1505 }
1506
1507 void GL_BINDING_CALL
1508 MockGLInterface::Mock_glGetTransformFeedbackVarying(GLuint program,
1509 GLuint index,
1510 GLsizei bufSize,
1511 GLsizei* length,
1512 GLsizei* size,
1513 GLenum* type,
1514 char* name) {
1515 MakeFunctionUnique("glGetTransformFeedbackVarying");
1516 interface_->GetTransformFeedbackVarying(program, index, bufSize, length, size,
1517 type, name);
1518 }
1519
1520 void GL_BINDING_CALL
1521 MockGLInterface::Mock_glGetTranslatedShaderSourceANGLE(GLuint shader,
1522 GLsizei bufsize,
1523 GLsizei* length,
1524 char* source) {
1525 MakeFunctionUnique("glGetTranslatedShaderSourceANGLE");
1526 interface_->GetTranslatedShaderSourceANGLE(shader, bufsize, length, source);
1527 }
1528
1529 GLuint GL_BINDING_CALL
1530 MockGLInterface::Mock_glGetUniformBlockIndex(GLuint program,
1531 const char* uniformBlockName) {
1532 MakeFunctionUnique("glGetUniformBlockIndex");
1533 return interface_->GetUniformBlockIndex(program, uniformBlockName);
1534 }
1535
1536 void GL_BINDING_CALL
1537 MockGLInterface::Mock_glGetUniformIndices(GLuint program,
1538 GLsizei uniformCount,
1539 const char* const* uniformNames,
1540 GLuint* uniformIndices) {
1541 MakeFunctionUnique("glGetUniformIndices");
1542 interface_->GetUniformIndices(program, uniformCount, uniformNames,
1543 uniformIndices);
1544 }
1545
1546 GLint GL_BINDING_CALL
1547 MockGLInterface::Mock_glGetUniformLocation(GLuint program, const char* name) {
1548 MakeFunctionUnique("glGetUniformLocation");
1549 return interface_->GetUniformLocation(program, name);
1550 }
1551
1552 void GL_BINDING_CALL MockGLInterface::Mock_glGetUniformfv(GLuint program,
1553 GLint location,
1554 GLfloat* params) {
1555 MakeFunctionUnique("glGetUniformfv");
1556 interface_->GetUniformfv(program, location, params);
1557 }
1558
1559 void GL_BINDING_CALL MockGLInterface::Mock_glGetUniformiv(GLuint program,
1560 GLint location,
1561 GLint* params) {
1562 MakeFunctionUnique("glGetUniformiv");
1563 interface_->GetUniformiv(program, location, params);
1564 }
1565
1566 void GL_BINDING_CALL MockGLInterface::Mock_glGetUniformuiv(GLuint program,
1567 GLint location,
1568 GLuint* params) {
1569 MakeFunctionUnique("glGetUniformuiv");
1570 interface_->GetUniformuiv(program, location, params);
1571 }
1572
1573 void GL_BINDING_CALL
1574 MockGLInterface::Mock_glGetVertexAttribPointerv(GLuint index,
1575 GLenum pname,
1576 void** pointer) {
1577 MakeFunctionUnique("glGetVertexAttribPointerv");
1578 interface_->GetVertexAttribPointerv(index, pname, pointer);
1579 }
1580
1581 void GL_BINDING_CALL
1582 MockGLInterface::Mock_glGetVertexAttribfv(GLuint index,
1583 GLenum pname,
1584 GLfloat* params) {
1585 MakeFunctionUnique("glGetVertexAttribfv");
1586 interface_->GetVertexAttribfv(index, pname, params);
1587 }
1588
1589 void GL_BINDING_CALL MockGLInterface::Mock_glGetVertexAttribiv(GLuint index,
1590 GLenum pname,
1591 GLint* params) {
1592 MakeFunctionUnique("glGetVertexAttribiv");
1593 interface_->GetVertexAttribiv(index, pname, params);
1594 }
1595
1596 void GL_BINDING_CALL MockGLInterface::Mock_glHint(GLenum target, GLenum mode) {
1597 MakeFunctionUnique("glHint");
1598 interface_->Hint(target, mode);
1599 }
1600
1601 void GL_BINDING_CALL
1602 MockGLInterface::Mock_glInsertEventMarkerEXT(GLsizei length,
1603 const char* marker) {
1604 MakeFunctionUnique("glInsertEventMarkerEXT");
1605 interface_->InsertEventMarkerEXT(length, marker);
1606 }
1607
1608 void GL_BINDING_CALL
1609 MockGLInterface::Mock_glInvalidateFramebuffer(GLenum target,
1610 GLsizei numAttachments,
1611 const GLenum* attachments) {
1612 MakeFunctionUnique("glInvalidateFramebuffer");
1613 interface_->InvalidateFramebuffer(target, numAttachments, attachments);
1614 }
1615
1616 void GL_BINDING_CALL
1617 MockGLInterface::Mock_glInvalidateSubFramebuffer(GLenum target,
1618 GLsizei numAttachments,
1619 const GLenum* attachments,
1620 GLint x,
1621 GLint y,
1622 GLint width,
1623 GLint height) {
1624 MakeFunctionUnique("glInvalidateSubFramebuffer");
1625 interface_->InvalidateSubFramebuffer(target, numAttachments, attachments, x,
1626 y, width, height);
1627 }
1628
1629 GLboolean GL_BINDING_CALL MockGLInterface::Mock_glIsBuffer(GLuint buffer) {
1630 MakeFunctionUnique("glIsBuffer");
1631 return interface_->IsBuffer(buffer);
1632 }
1633
1634 GLboolean GL_BINDING_CALL MockGLInterface::Mock_glIsEnabled(GLenum cap) {
1635 MakeFunctionUnique("glIsEnabled");
1636 return interface_->IsEnabled(cap);
1637 }
1638
1639 GLboolean GL_BINDING_CALL MockGLInterface::Mock_glIsFenceAPPLE(GLuint fence) {
1640 MakeFunctionUnique("glIsFenceAPPLE");
1641 return interface_->IsFenceAPPLE(fence);
1642 }
1643
1644 GLboolean GL_BINDING_CALL MockGLInterface::Mock_glIsFenceNV(GLuint fence) {
1645 MakeFunctionUnique("glIsFenceNV");
1646 return interface_->IsFenceNV(fence);
1647 }
1648
1649 GLboolean GL_BINDING_CALL
1650 MockGLInterface::Mock_glIsFramebuffer(GLuint framebuffer) {
1651 MakeFunctionUnique("glIsFramebuffer");
1652 return interface_->IsFramebufferEXT(framebuffer);
1653 }
1654
1655 GLboolean GL_BINDING_CALL
1656 MockGLInterface::Mock_glIsFramebufferEXT(GLuint framebuffer) {
1657 MakeFunctionUnique("glIsFramebufferEXT");
1658 return interface_->IsFramebufferEXT(framebuffer);
1659 }
1660
1661 GLboolean GL_BINDING_CALL MockGLInterface::Mock_glIsPathNV(GLuint path) {
1662 MakeFunctionUnique("glIsPathNV");
1663 return interface_->IsPathNV(path);
1664 }
1665
1666 GLboolean GL_BINDING_CALL MockGLInterface::Mock_glIsProgram(GLuint program) {
1667 MakeFunctionUnique("glIsProgram");
1668 return interface_->IsProgram(program);
1669 }
1670
1671 GLboolean GL_BINDING_CALL MockGLInterface::Mock_glIsQuery(GLuint query) {
1672 MakeFunctionUnique("glIsQuery");
1673 return interface_->IsQuery(query);
1674 }
1675
1676 GLboolean GL_BINDING_CALL MockGLInterface::Mock_glIsQueryARB(GLuint query) {
1677 MakeFunctionUnique("glIsQueryARB");
1678 return interface_->IsQuery(query);
1679 }
1680
1681 GLboolean GL_BINDING_CALL MockGLInterface::Mock_glIsQueryEXT(GLuint query) {
1682 MakeFunctionUnique("glIsQueryEXT");
1683 return interface_->IsQuery(query);
1684 }
1685
1686 GLboolean GL_BINDING_CALL
1687 MockGLInterface::Mock_glIsRenderbuffer(GLuint renderbuffer) {
1688 MakeFunctionUnique("glIsRenderbuffer");
1689 return interface_->IsRenderbufferEXT(renderbuffer);
1690 }
1691
1692 GLboolean GL_BINDING_CALL
1693 MockGLInterface::Mock_glIsRenderbufferEXT(GLuint renderbuffer) {
1694 MakeFunctionUnique("glIsRenderbufferEXT");
1695 return interface_->IsRenderbufferEXT(renderbuffer);
1696 }
1697
1698 GLboolean GL_BINDING_CALL MockGLInterface::Mock_glIsSampler(GLuint sampler) {
1699 MakeFunctionUnique("glIsSampler");
1700 return interface_->IsSampler(sampler);
1701 }
1702
1703 GLboolean GL_BINDING_CALL MockGLInterface::Mock_glIsShader(GLuint shader) {
1704 MakeFunctionUnique("glIsShader");
1705 return interface_->IsShader(shader);
1706 }
1707
1708 GLboolean GL_BINDING_CALL MockGLInterface::Mock_glIsSync(GLsync sync) {
1709 MakeFunctionUnique("glIsSync");
1710 return interface_->IsSync(sync);
1711 }
1712
1713 GLboolean GL_BINDING_CALL MockGLInterface::Mock_glIsTexture(GLuint texture) {
1714 MakeFunctionUnique("glIsTexture");
1715 return interface_->IsTexture(texture);
1716 }
1717
1718 GLboolean GL_BINDING_CALL
1719 MockGLInterface::Mock_glIsTransformFeedback(GLuint id) {
1720 MakeFunctionUnique("glIsTransformFeedback");
1721 return interface_->IsTransformFeedback(id);
1722 }
1723
1724 GLboolean GL_BINDING_CALL MockGLInterface::Mock_glIsVertexArray(GLuint array) {
1725 MakeFunctionUnique("glIsVertexArray");
1726 return interface_->IsVertexArrayOES(array);
1727 }
1728
1729 GLboolean GL_BINDING_CALL
1730 MockGLInterface::Mock_glIsVertexArrayAPPLE(GLuint array) {
1731 MakeFunctionUnique("glIsVertexArrayAPPLE");
1732 return interface_->IsVertexArrayOES(array);
1733 }
1734
1735 GLboolean GL_BINDING_CALL
1736 MockGLInterface::Mock_glIsVertexArrayOES(GLuint array) {
1737 MakeFunctionUnique("glIsVertexArrayOES");
1738 return interface_->IsVertexArrayOES(array);
1739 }
1740
1741 void GL_BINDING_CALL MockGLInterface::Mock_glLineWidth(GLfloat width) {
1742 MakeFunctionUnique("glLineWidth");
1743 interface_->LineWidth(width);
1744 }
1745
1746 void GL_BINDING_CALL MockGLInterface::Mock_glLinkProgram(GLuint program) {
1747 MakeFunctionUnique("glLinkProgram");
1748 interface_->LinkProgram(program);
1749 }
1750
1751 void* GL_BINDING_CALL MockGLInterface::Mock_glMapBuffer(GLenum target,
1752 GLenum access) {
1753 MakeFunctionUnique("glMapBuffer");
1754 return interface_->MapBuffer(target, access);
1755 }
1756
1757 void* GL_BINDING_CALL MockGLInterface::Mock_glMapBufferOES(GLenum target,
1758 GLenum access) {
1759 MakeFunctionUnique("glMapBufferOES");
1760 return interface_->MapBuffer(target, access);
1761 }
1762
1763 void* GL_BINDING_CALL
1764 MockGLInterface::Mock_glMapBufferRange(GLenum target,
1765 GLintptr offset,
1766 GLsizeiptr length,
1767 GLbitfield access) {
1768 MakeFunctionUnique("glMapBufferRange");
1769 return interface_->MapBufferRange(target, offset, length, access);
1770 }
1771
1772 void* GL_BINDING_CALL
1773 MockGLInterface::Mock_glMapBufferRangeEXT(GLenum target,
1774 GLintptr offset,
1775 GLsizeiptr length,
1776 GLbitfield access) {
1777 MakeFunctionUnique("glMapBufferRangeEXT");
1778 return interface_->MapBufferRange(target, offset, length, access);
1779 }
1780
1781 void GL_BINDING_CALL
1782 MockGLInterface::Mock_glMatrixLoadIdentityEXT(GLenum matrixMode) {
1783 MakeFunctionUnique("glMatrixLoadIdentityEXT");
1784 interface_->MatrixLoadIdentityEXT(matrixMode);
1785 }
1786
1787 void GL_BINDING_CALL MockGLInterface::Mock_glMatrixLoadfEXT(GLenum matrixMode,
1788 const GLfloat* m) {
1789 MakeFunctionUnique("glMatrixLoadfEXT");
1790 interface_->MatrixLoadfEXT(matrixMode, m);
1791 }
1792
1793 void GL_BINDING_CALL
1794 MockGLInterface::Mock_glPathCommandsNV(GLuint path,
1795 GLsizei numCommands,
1796 const GLubyte* commands,
1797 GLsizei numCoords,
1798 GLenum coordType,
1799 const GLvoid* coords) {
1800 MakeFunctionUnique("glPathCommandsNV");
1801 interface_->PathCommandsNV(path, numCommands, commands, numCoords, coordType,
1802 coords);
1803 }
1804
1805 void GL_BINDING_CALL MockGLInterface::Mock_glPathParameterfNV(GLuint path,
1806 GLenum pname,
1807 GLfloat value) {
1808 MakeFunctionUnique("glPathParameterfNV");
1809 interface_->PathParameterfNV(path, pname, value);
1810 }
1811
1812 void GL_BINDING_CALL MockGLInterface::Mock_glPathParameteriNV(GLuint path,
1813 GLenum pname,
1814 GLint value) {
1815 MakeFunctionUnique("glPathParameteriNV");
1816 interface_->PathParameteriNV(path, pname, value);
1817 }
1818
1819 void GL_BINDING_CALL MockGLInterface::Mock_glPathStencilFuncNV(GLenum func,
1820 GLint ref,
1821 GLuint mask) {
1822 MakeFunctionUnique("glPathStencilFuncNV");
1823 interface_->PathStencilFuncNV(func, ref, mask);
1824 }
1825
1826 void GL_BINDING_CALL MockGLInterface::Mock_glPauseTransformFeedback(void) {
1827 MakeFunctionUnique("glPauseTransformFeedback");
1828 interface_->PauseTransformFeedback();
1829 }
1830
1831 void GL_BINDING_CALL MockGLInterface::Mock_glPixelStorei(GLenum pname,
1832 GLint param) {
1833 MakeFunctionUnique("glPixelStorei");
1834 interface_->PixelStorei(pname, param);
1835 }
1836
1837 void GL_BINDING_CALL MockGLInterface::Mock_glPointParameteri(GLenum pname,
1838 GLint param) {
1839 MakeFunctionUnique("glPointParameteri");
1840 interface_->PointParameteri(pname, param);
1841 }
1842
1843 void GL_BINDING_CALL MockGLInterface::Mock_glPolygonOffset(GLfloat factor,
1844 GLfloat units) {
1845 MakeFunctionUnique("glPolygonOffset");
1846 interface_->PolygonOffset(factor, units);
1847 }
1848
1849 void GL_BINDING_CALL MockGLInterface::Mock_glPopGroupMarkerEXT(void) {
1850 MakeFunctionUnique("glPopGroupMarkerEXT");
1851 interface_->PopGroupMarkerEXT();
1852 }
1853
1854 void GL_BINDING_CALL MockGLInterface::Mock_glProgramBinary(GLuint program,
1855 GLenum binaryFormat,
1856 const GLvoid* binary,
1857 GLsizei length) {
1858 MakeFunctionUnique("glProgramBinary");
1859 interface_->ProgramBinary(program, binaryFormat, binary, length);
1860 }
1861
1862 void GL_BINDING_CALL
1863 MockGLInterface::Mock_glProgramBinaryOES(GLuint program,
1864 GLenum binaryFormat,
1865 const GLvoid* binary,
1866 GLsizei length) {
1867 MakeFunctionUnique("glProgramBinaryOES");
1868 interface_->ProgramBinary(program, binaryFormat, binary, length);
1869 }
1870
1871 void GL_BINDING_CALL MockGLInterface::Mock_glProgramParameteri(GLuint program,
1872 GLenum pname,
1873 GLint value) {
1874 MakeFunctionUnique("glProgramParameteri");
1875 interface_->ProgramParameteri(program, pname, value);
1876 }
1877
1878 void GL_BINDING_CALL
1879 MockGLInterface::Mock_glPushGroupMarkerEXT(GLsizei length, const char* marker) {
1880 MakeFunctionUnique("glPushGroupMarkerEXT");
1881 interface_->PushGroupMarkerEXT(length, marker);
1882 }
1883
1884 void GL_BINDING_CALL MockGLInterface::Mock_glQueryCounter(GLuint id,
1885 GLenum target) {
1886 MakeFunctionUnique("glQueryCounter");
1887 interface_->QueryCounter(id, target);
1888 }
1889
1890 void GL_BINDING_CALL MockGLInterface::Mock_glQueryCounterEXT(GLuint id,
1891 GLenum target) {
1892 MakeFunctionUnique("glQueryCounterEXT");
1893 interface_->QueryCounter(id, target);
1894 }
1895
1896 void GL_BINDING_CALL MockGLInterface::Mock_glReadBuffer(GLenum src) {
1897 MakeFunctionUnique("glReadBuffer");
1898 interface_->ReadBuffer(src);
1899 }
1900
1901 void GL_BINDING_CALL MockGLInterface::Mock_glReadPixels(GLint x,
1902 GLint y,
1903 GLsizei width,
1904 GLsizei height,
1905 GLenum format,
1906 GLenum type,
1907 void* pixels) {
1908 MakeFunctionUnique("glReadPixels");
1909 interface_->ReadPixels(x, y, width, height, format, type, pixels);
1910 }
1911
1912 void GL_BINDING_CALL MockGLInterface::Mock_glReleaseShaderCompiler(void) {
1913 MakeFunctionUnique("glReleaseShaderCompiler");
1914 interface_->ReleaseShaderCompiler();
1915 }
1916
1917 void GL_BINDING_CALL
1918 MockGLInterface::Mock_glRenderbufferStorage(GLenum target,
1919 GLenum internalformat,
1920 GLsizei width,
1921 GLsizei height) {
1922 MakeFunctionUnique("glRenderbufferStorage");
1923 interface_->RenderbufferStorageEXT(target, internalformat, width, height);
1924 }
1925
1926 void GL_BINDING_CALL
1927 MockGLInterface::Mock_glRenderbufferStorageEXT(GLenum target,
1928 GLenum internalformat,
1929 GLsizei width,
1930 GLsizei height) {
1931 MakeFunctionUnique("glRenderbufferStorageEXT");
1932 interface_->RenderbufferStorageEXT(target, internalformat, width, height);
1933 }
1934
1935 void GL_BINDING_CALL
1936 MockGLInterface::Mock_glRenderbufferStorageMultisample(GLenum target,
1937 GLsizei samples,
1938 GLenum internalformat,
1939 GLsizei width,
1940 GLsizei height) {
1941 MakeFunctionUnique("glRenderbufferStorageMultisample");
1942 interface_->RenderbufferStorageMultisample(target, samples, internalformat,
1943 width, height);
1944 }
1945
1946 void GL_BINDING_CALL
1947 MockGLInterface::Mock_glRenderbufferStorageMultisampleANGLE(
1948 GLenum target,
1949 GLsizei samples,
1950 GLenum internalformat,
1951 GLsizei width,
1952 GLsizei height) {
1953 MakeFunctionUnique("glRenderbufferStorageMultisampleANGLE");
1954 interface_->RenderbufferStorageMultisampleANGLE(
1955 target, samples, internalformat, width, height);
1956 }
1957
1958 void GL_BINDING_CALL
1959 MockGLInterface::Mock_glRenderbufferStorageMultisampleEXT(GLenum target,
1960 GLsizei samples,
1961 GLenum internalformat,
1962 GLsizei width,
1963 GLsizei height) {
1964 MakeFunctionUnique("glRenderbufferStorageMultisampleEXT");
1965 interface_->RenderbufferStorageMultisampleEXT(target, samples, internalformat,
1966 width, height);
1967 }
1968
1969 void GL_BINDING_CALL
1970 MockGLInterface::Mock_glRenderbufferStorageMultisampleIMG(GLenum target,
1971 GLsizei samples,
1972 GLenum internalformat,
1973 GLsizei width,
1974 GLsizei height) {
1975 MakeFunctionUnique("glRenderbufferStorageMultisampleIMG");
1976 interface_->RenderbufferStorageMultisampleIMG(target, samples, internalformat,
1977 width, height);
1978 }
1979
1980 void GL_BINDING_CALL MockGLInterface::Mock_glResumeTransformFeedback(void) {
1981 MakeFunctionUnique("glResumeTransformFeedback");
1982 interface_->ResumeTransformFeedback();
1983 }
1984
1985 void GL_BINDING_CALL MockGLInterface::Mock_glSampleCoverage(GLclampf value,
1986 GLboolean invert) {
1987 MakeFunctionUnique("glSampleCoverage");
1988 interface_->SampleCoverage(value, invert);
1989 }
1990
1991 void GL_BINDING_CALL MockGLInterface::Mock_glSamplerParameterf(GLuint sampler,
1992 GLenum pname,
1993 GLfloat param) {
1994 MakeFunctionUnique("glSamplerParameterf");
1995 interface_->SamplerParameterf(sampler, pname, param);
1996 }
1997
1998 void GL_BINDING_CALL
1999 MockGLInterface::Mock_glSamplerParameterfv(GLuint sampler,
2000 GLenum pname,
2001 const GLfloat* params) {
2002 MakeFunctionUnique("glSamplerParameterfv");
2003 interface_->SamplerParameterfv(sampler, pname, params);
2004 }
2005
2006 void GL_BINDING_CALL MockGLInterface::Mock_glSamplerParameteri(GLuint sampler,
2007 GLenum pname,
2008 GLint param) {
2009 MakeFunctionUnique("glSamplerParameteri");
2010 interface_->SamplerParameteri(sampler, pname, param);
2011 }
2012
2013 void GL_BINDING_CALL
2014 MockGLInterface::Mock_glSamplerParameteriv(GLuint sampler,
2015 GLenum pname,
2016 const GLint* params) {
2017 MakeFunctionUnique("glSamplerParameteriv");
2018 interface_->SamplerParameteriv(sampler, pname, params);
2019 }
2020
2021 void GL_BINDING_CALL MockGLInterface::Mock_glScissor(GLint x,
2022 GLint y,
2023 GLsizei width,
2024 GLsizei height) {
2025 MakeFunctionUnique("glScissor");
2026 interface_->Scissor(x, y, width, height);
2027 }
2028
2029 void GL_BINDING_CALL MockGLInterface::Mock_glSetFenceAPPLE(GLuint fence) {
2030 MakeFunctionUnique("glSetFenceAPPLE");
2031 interface_->SetFenceAPPLE(fence);
2032 }
2033
2034 void GL_BINDING_CALL MockGLInterface::Mock_glSetFenceNV(GLuint fence,
2035 GLenum condition) {
2036 MakeFunctionUnique("glSetFenceNV");
2037 interface_->SetFenceNV(fence, condition);
2038 }
2039
2040 void GL_BINDING_CALL MockGLInterface::Mock_glShaderBinary(GLsizei n,
2041 const GLuint* shaders,
2042 GLenum binaryformat,
2043 const void* binary,
2044 GLsizei length) {
2045 MakeFunctionUnique("glShaderBinary");
2046 interface_->ShaderBinary(n, shaders, binaryformat, binary, length);
2047 }
2048
2049 void GL_BINDING_CALL
2050 MockGLInterface::Mock_glShaderSource(GLuint shader,
2051 GLsizei count,
2052 const char* const* str,
2053 const GLint* length) {
2054 MakeFunctionUnique("glShaderSource");
2055 interface_->ShaderSource(shader, count, str, length);
2056 }
2057
2058 void GL_BINDING_CALL MockGLInterface::Mock_glStencilFillPathNV(GLuint path,
2059 GLenum fillMode,
2060 GLuint mask) {
2061 MakeFunctionUnique("glStencilFillPathNV");
2062 interface_->StencilFillPathNV(path, fillMode, mask);
2063 }
2064
2065 void GL_BINDING_CALL MockGLInterface::Mock_glStencilFunc(GLenum func,
2066 GLint ref,
2067 GLuint mask) {
2068 MakeFunctionUnique("glStencilFunc");
2069 interface_->StencilFunc(func, ref, mask);
2070 }
2071
2072 void GL_BINDING_CALL MockGLInterface::Mock_glStencilFuncSeparate(GLenum face,
2073 GLenum func,
2074 GLint ref,
2075 GLuint mask) {
2076 MakeFunctionUnique("glStencilFuncSeparate");
2077 interface_->StencilFuncSeparate(face, func, ref, mask);
2078 }
2079
2080 void GL_BINDING_CALL MockGLInterface::Mock_glStencilMask(GLuint mask) {
2081 MakeFunctionUnique("glStencilMask");
2082 interface_->StencilMask(mask);
2083 }
2084
2085 void GL_BINDING_CALL MockGLInterface::Mock_glStencilMaskSeparate(GLenum face,
2086 GLuint mask) {
2087 MakeFunctionUnique("glStencilMaskSeparate");
2088 interface_->StencilMaskSeparate(face, mask);
2089 }
2090
2091 void GL_BINDING_CALL MockGLInterface::Mock_glStencilOp(GLenum fail,
2092 GLenum zfail,
2093 GLenum zpass) {
2094 MakeFunctionUnique("glStencilOp");
2095 interface_->StencilOp(fail, zfail, zpass);
2096 }
2097
2098 void GL_BINDING_CALL MockGLInterface::Mock_glStencilOpSeparate(GLenum face,
2099 GLenum fail,
2100 GLenum zfail,
2101 GLenum zpass) {
2102 MakeFunctionUnique("glStencilOpSeparate");
2103 interface_->StencilOpSeparate(face, fail, zfail, zpass);
2104 }
2105
2106 void GL_BINDING_CALL
2107 MockGLInterface::Mock_glStencilStrokePathNV(GLuint path,
2108 GLint reference,
2109 GLuint mask) {
2110 MakeFunctionUnique("glStencilStrokePathNV");
2111 interface_->StencilStrokePathNV(path, reference, mask);
2112 }
2113
2114 void GL_BINDING_CALL
2115 MockGLInterface::Mock_glStencilThenCoverFillPathNV(GLuint path,
2116 GLenum fillMode,
2117 GLuint mask,
2118 GLenum coverMode) {
2119 MakeFunctionUnique("glStencilThenCoverFillPathNV");
2120 interface_->StencilThenCoverFillPathNV(path, fillMode, mask, coverMode);
2121 }
2122
2123 void GL_BINDING_CALL
2124 MockGLInterface::Mock_glStencilThenCoverStrokePathNV(GLuint path,
2125 GLint reference,
2126 GLuint mask,
2127 GLenum coverMode) {
2128 MakeFunctionUnique("glStencilThenCoverStrokePathNV");
2129 interface_->StencilThenCoverStrokePathNV(path, reference, mask, coverMode);
2130 }
2131
2132 GLboolean GL_BINDING_CALL MockGLInterface::Mock_glTestFenceAPPLE(GLuint fence) {
2133 MakeFunctionUnique("glTestFenceAPPLE");
2134 return interface_->TestFenceAPPLE(fence);
2135 }
2136
2137 GLboolean GL_BINDING_CALL MockGLInterface::Mock_glTestFenceNV(GLuint fence) {
2138 MakeFunctionUnique("glTestFenceNV");
2139 return interface_->TestFenceNV(fence);
2140 }
2141
2142 void GL_BINDING_CALL MockGLInterface::Mock_glTexImage2D(GLenum target,
2143 GLint level,
2144 GLint internalformat,
2145 GLsizei width,
2146 GLsizei height,
2147 GLint border,
2148 GLenum format,
2149 GLenum type,
2150 const void* pixels) {
2151 MakeFunctionUnique("glTexImage2D");
2152 interface_->TexImage2D(target, level, internalformat, width, height, border,
2153 format, type, pixels);
2154 }
2155
2156 void GL_BINDING_CALL MockGLInterface::Mock_glTexImage3D(GLenum target,
2157 GLint level,
2158 GLint internalformat,
2159 GLsizei width,
2160 GLsizei height,
2161 GLsizei depth,
2162 GLint border,
2163 GLenum format,
2164 GLenum type,
2165 const void* pixels) {
2166 MakeFunctionUnique("glTexImage3D");
2167 interface_->TexImage3D(target, level, internalformat, width, height, depth,
2168 border, format, type, pixels);
2169 }
2170
2171 void GL_BINDING_CALL MockGLInterface::Mock_glTexParameterf(GLenum target,
2172 GLenum pname,
2173 GLfloat param) {
2174 MakeFunctionUnique("glTexParameterf");
2175 interface_->TexParameterf(target, pname, param);
2176 }
2177
2178 void GL_BINDING_CALL
2179 MockGLInterface::Mock_glTexParameterfv(GLenum target,
2180 GLenum pname,
2181 const GLfloat* params) {
2182 MakeFunctionUnique("glTexParameterfv");
2183 interface_->TexParameterfv(target, pname, params);
2184 }
2185
2186 void GL_BINDING_CALL MockGLInterface::Mock_glTexParameteri(GLenum target,
2187 GLenum pname,
2188 GLint param) {
2189 MakeFunctionUnique("glTexParameteri");
2190 interface_->TexParameteri(target, pname, param);
2191 }
2192
2193 void GL_BINDING_CALL
2194 MockGLInterface::Mock_glTexParameteriv(GLenum target,
2195 GLenum pname,
2196 const GLint* params) {
2197 MakeFunctionUnique("glTexParameteriv");
2198 interface_->TexParameteriv(target, pname, params);
2199 }
2200
2201 void GL_BINDING_CALL MockGLInterface::Mock_glTexStorage2D(GLenum target,
2202 GLsizei levels,
2203 GLenum internalformat,
2204 GLsizei width,
2205 GLsizei height) {
2206 MakeFunctionUnique("glTexStorage2D");
2207 interface_->TexStorage2DEXT(target, levels, internalformat, width, height);
2208 }
2209
2210 void GL_BINDING_CALL
2211 MockGLInterface::Mock_glTexStorage2DEXT(GLenum target,
2212 GLsizei levels,
2213 GLenum internalformat,
2214 GLsizei width,
2215 GLsizei height) {
2216 MakeFunctionUnique("glTexStorage2DEXT");
2217 interface_->TexStorage2DEXT(target, levels, internalformat, width, height);
2218 }
2219
2220 void GL_BINDING_CALL MockGLInterface::Mock_glTexStorage3D(GLenum target,
2221 GLsizei levels,
2222 GLenum internalformat,
2223 GLsizei width,
2224 GLsizei height,
2225 GLsizei depth) {
2226 MakeFunctionUnique("glTexStorage3D");
2227 interface_->TexStorage3D(target, levels, internalformat, width, height,
2228 depth);
2229 }
2230
2231 void GL_BINDING_CALL MockGLInterface::Mock_glTexSubImage2D(GLenum target,
2232 GLint level,
2233 GLint xoffset,
2234 GLint yoffset,
2235 GLsizei width,
2236 GLsizei height,
2237 GLenum format,
2238 GLenum type,
2239 const void* pixels) {
2240 MakeFunctionUnique("glTexSubImage2D");
2241 interface_->TexSubImage2D(target, level, xoffset, yoffset, width, height,
2242 format, type, pixels);
2243 }
2244
2245 void GL_BINDING_CALL MockGLInterface::Mock_glTexSubImage3D(GLenum target,
2246 GLint level,
2247 GLint xoffset,
2248 GLint yoffset,
2249 GLint zoffset,
2250 GLsizei width,
2251 GLsizei height,
2252 GLsizei depth,
2253 GLenum format,
2254 GLenum type,
2255 const void* pixels) {
2256 MakeFunctionUnique("glTexSubImage3D");
2257 interface_->TexSubImage3D(target, level, xoffset, yoffset, zoffset, width,
2258 height, depth, format, type, pixels);
2259 }
2260
2261 void GL_BINDING_CALL
2262 MockGLInterface::Mock_glTransformFeedbackVaryings(GLuint program,
2263 GLsizei count,
2264 const char* const* varyings,
2265 GLenum bufferMode) {
2266 MakeFunctionUnique("glTransformFeedbackVaryings");
2267 interface_->TransformFeedbackVaryings(program, count, varyings, bufferMode);
2268 }
2269
2270 void GL_BINDING_CALL MockGLInterface::Mock_glUniform1f(GLint location,
2271 GLfloat x) {
2272 MakeFunctionUnique("glUniform1f");
2273 interface_->Uniform1f(location, x);
2274 }
2275
2276 void GL_BINDING_CALL MockGLInterface::Mock_glUniform1fv(GLint location,
2277 GLsizei count,
2278 const GLfloat* v) {
2279 MakeFunctionUnique("glUniform1fv");
2280 interface_->Uniform1fv(location, count, v);
2281 }
2282
2283 void GL_BINDING_CALL MockGLInterface::Mock_glUniform1i(GLint location,
2284 GLint x) {
2285 MakeFunctionUnique("glUniform1i");
2286 interface_->Uniform1i(location, x);
2287 }
2288
2289 void GL_BINDING_CALL MockGLInterface::Mock_glUniform1iv(GLint location,
2290 GLsizei count,
2291 const GLint* v) {
2292 MakeFunctionUnique("glUniform1iv");
2293 interface_->Uniform1iv(location, count, v);
2294 }
2295
2296 void GL_BINDING_CALL MockGLInterface::Mock_glUniform1ui(GLint location,
2297 GLuint v0) {
2298 MakeFunctionUnique("glUniform1ui");
2299 interface_->Uniform1ui(location, v0);
2300 }
2301
2302 void GL_BINDING_CALL MockGLInterface::Mock_glUniform1uiv(GLint location,
2303 GLsizei count,
2304 const GLuint* v) {
2305 MakeFunctionUnique("glUniform1uiv");
2306 interface_->Uniform1uiv(location, count, v);
2307 }
2308
2309 void GL_BINDING_CALL MockGLInterface::Mock_glUniform2f(GLint location,
2310 GLfloat x,
2311 GLfloat y) {
2312 MakeFunctionUnique("glUniform2f");
2313 interface_->Uniform2f(location, x, y);
2314 }
2315
2316 void GL_BINDING_CALL MockGLInterface::Mock_glUniform2fv(GLint location,
2317 GLsizei count,
2318 const GLfloat* v) {
2319 MakeFunctionUnique("glUniform2fv");
2320 interface_->Uniform2fv(location, count, v);
2321 }
2322
2323 void GL_BINDING_CALL MockGLInterface::Mock_glUniform2i(GLint location,
2324 GLint x,
2325 GLint y) {
2326 MakeFunctionUnique("glUniform2i");
2327 interface_->Uniform2i(location, x, y);
2328 }
2329
2330 void GL_BINDING_CALL MockGLInterface::Mock_glUniform2iv(GLint location,
2331 GLsizei count,
2332 const GLint* v) {
2333 MakeFunctionUnique("glUniform2iv");
2334 interface_->Uniform2iv(location, count, v);
2335 }
2336
2337 void GL_BINDING_CALL MockGLInterface::Mock_glUniform2ui(GLint location,
2338 GLuint v0,
2339 GLuint v1) {
2340 MakeFunctionUnique("glUniform2ui");
2341 interface_->Uniform2ui(location, v0, v1);
2342 }
2343
2344 void GL_BINDING_CALL MockGLInterface::Mock_glUniform2uiv(GLint location,
2345 GLsizei count,
2346 const GLuint* v) {
2347 MakeFunctionUnique("glUniform2uiv");
2348 interface_->Uniform2uiv(location, count, v);
2349 }
2350
2351 void GL_BINDING_CALL MockGLInterface::Mock_glUniform3f(GLint location,
2352 GLfloat x,
2353 GLfloat y,
2354 GLfloat z) {
2355 MakeFunctionUnique("glUniform3f");
2356 interface_->Uniform3f(location, x, y, z);
2357 }
2358
2359 void GL_BINDING_CALL MockGLInterface::Mock_glUniform3fv(GLint location,
2360 GLsizei count,
2361 const GLfloat* v) {
2362 MakeFunctionUnique("glUniform3fv");
2363 interface_->Uniform3fv(location, count, v);
2364 }
2365
2366 void GL_BINDING_CALL MockGLInterface::Mock_glUniform3i(GLint location,
2367 GLint x,
2368 GLint y,
2369 GLint z) {
2370 MakeFunctionUnique("glUniform3i");
2371 interface_->Uniform3i(location, x, y, z);
2372 }
2373
2374 void GL_BINDING_CALL MockGLInterface::Mock_glUniform3iv(GLint location,
2375 GLsizei count,
2376 const GLint* v) {
2377 MakeFunctionUnique("glUniform3iv");
2378 interface_->Uniform3iv(location, count, v);
2379 }
2380
2381 void GL_BINDING_CALL MockGLInterface::Mock_glUniform3ui(GLint location,
2382 GLuint v0,
2383 GLuint v1,
2384 GLuint v2) {
2385 MakeFunctionUnique("glUniform3ui");
2386 interface_->Uniform3ui(location, v0, v1, v2);
2387 }
2388
2389 void GL_BINDING_CALL MockGLInterface::Mock_glUniform3uiv(GLint location,
2390 GLsizei count,
2391 const GLuint* v) {
2392 MakeFunctionUnique("glUniform3uiv");
2393 interface_->Uniform3uiv(location, count, v);
2394 }
2395
2396 void GL_BINDING_CALL MockGLInterface::Mock_glUniform4f(GLint location,
2397 GLfloat x,
2398 GLfloat y,
2399 GLfloat z,
2400 GLfloat w) {
2401 MakeFunctionUnique("glUniform4f");
2402 interface_->Uniform4f(location, x, y, z, w);
2403 }
2404
2405 void GL_BINDING_CALL MockGLInterface::Mock_glUniform4fv(GLint location,
2406 GLsizei count,
2407 const GLfloat* v) {
2408 MakeFunctionUnique("glUniform4fv");
2409 interface_->Uniform4fv(location, count, v);
2410 }
2411
2412 void GL_BINDING_CALL MockGLInterface::Mock_glUniform4i(GLint location,
2413 GLint x,
2414 GLint y,
2415 GLint z,
2416 GLint w) {
2417 MakeFunctionUnique("glUniform4i");
2418 interface_->Uniform4i(location, x, y, z, w);
2419 }
2420
2421 void GL_BINDING_CALL MockGLInterface::Mock_glUniform4iv(GLint location,
2422 GLsizei count,
2423 const GLint* v) {
2424 MakeFunctionUnique("glUniform4iv");
2425 interface_->Uniform4iv(location, count, v);
2426 }
2427
2428 void GL_BINDING_CALL MockGLInterface::Mock_glUniform4ui(GLint location,
2429 GLuint v0,
2430 GLuint v1,
2431 GLuint v2,
2432 GLuint v3) {
2433 MakeFunctionUnique("glUniform4ui");
2434 interface_->Uniform4ui(location, v0, v1, v2, v3);
2435 }
2436
2437 void GL_BINDING_CALL MockGLInterface::Mock_glUniform4uiv(GLint location,
2438 GLsizei count,
2439 const GLuint* v) {
2440 MakeFunctionUnique("glUniform4uiv");
2441 interface_->Uniform4uiv(location, count, v);
2442 }
2443
2444 void GL_BINDING_CALL
2445 MockGLInterface::Mock_glUniformBlockBinding(GLuint program,
2446 GLuint uniformBlockIndex,
2447 GLuint uniformBlockBinding) {
2448 MakeFunctionUnique("glUniformBlockBinding");
2449 interface_->UniformBlockBinding(program, uniformBlockIndex,
2450 uniformBlockBinding);
2451 }
2452
2453 void GL_BINDING_CALL
2454 MockGLInterface::Mock_glUniformMatrix2fv(GLint location,
2455 GLsizei count,
2456 GLboolean transpose,
2457 const GLfloat* value) {
2458 MakeFunctionUnique("glUniformMatrix2fv");
2459 interface_->UniformMatrix2fv(location, count, transpose, value);
2460 }
2461
2462 void GL_BINDING_CALL
2463 MockGLInterface::Mock_glUniformMatrix2x3fv(GLint location,
2464 GLsizei count,
2465 GLboolean transpose,
2466 const GLfloat* value) {
2467 MakeFunctionUnique("glUniformMatrix2x3fv");
2468 interface_->UniformMatrix2x3fv(location, count, transpose, value);
2469 }
2470
2471 void GL_BINDING_CALL
2472 MockGLInterface::Mock_glUniformMatrix2x4fv(GLint location,
2473 GLsizei count,
2474 GLboolean transpose,
2475 const GLfloat* value) {
2476 MakeFunctionUnique("glUniformMatrix2x4fv");
2477 interface_->UniformMatrix2x4fv(location, count, transpose, value);
2478 }
2479
2480 void GL_BINDING_CALL
2481 MockGLInterface::Mock_glUniformMatrix3fv(GLint location,
2482 GLsizei count,
2483 GLboolean transpose,
2484 const GLfloat* value) {
2485 MakeFunctionUnique("glUniformMatrix3fv");
2486 interface_->UniformMatrix3fv(location, count, transpose, value);
2487 }
2488
2489 void GL_BINDING_CALL
2490 MockGLInterface::Mock_glUniformMatrix3x2fv(GLint location,
2491 GLsizei count,
2492 GLboolean transpose,
2493 const GLfloat* value) {
2494 MakeFunctionUnique("glUniformMatrix3x2fv");
2495 interface_->UniformMatrix3x2fv(location, count, transpose, value);
2496 }
2497
2498 void GL_BINDING_CALL
2499 MockGLInterface::Mock_glUniformMatrix3x4fv(GLint location,
2500 GLsizei count,
2501 GLboolean transpose,
2502 const GLfloat* value) {
2503 MakeFunctionUnique("glUniformMatrix3x4fv");
2504 interface_->UniformMatrix3x4fv(location, count, transpose, value);
2505 }
2506
2507 void GL_BINDING_CALL
2508 MockGLInterface::Mock_glUniformMatrix4fv(GLint location,
2509 GLsizei count,
2510 GLboolean transpose,
2511 const GLfloat* value) {
2512 MakeFunctionUnique("glUniformMatrix4fv");
2513 interface_->UniformMatrix4fv(location, count, transpose, value);
2514 }
2515
2516 void GL_BINDING_CALL
2517 MockGLInterface::Mock_glUniformMatrix4x2fv(GLint location,
2518 GLsizei count,
2519 GLboolean transpose,
2520 const GLfloat* value) {
2521 MakeFunctionUnique("glUniformMatrix4x2fv");
2522 interface_->UniformMatrix4x2fv(location, count, transpose, value);
2523 }
2524
2525 void GL_BINDING_CALL
2526 MockGLInterface::Mock_glUniformMatrix4x3fv(GLint location,
2527 GLsizei count,
2528 GLboolean transpose,
2529 const GLfloat* value) {
2530 MakeFunctionUnique("glUniformMatrix4x3fv");
2531 interface_->UniformMatrix4x3fv(location, count, transpose, value);
2532 }
2533
2534 GLboolean GL_BINDING_CALL MockGLInterface::Mock_glUnmapBuffer(GLenum target) {
2535 MakeFunctionUnique("glUnmapBuffer");
2536 return interface_->UnmapBuffer(target);
2537 }
2538
2539 GLboolean GL_BINDING_CALL
2540 MockGLInterface::Mock_glUnmapBufferOES(GLenum target) {
2541 MakeFunctionUnique("glUnmapBufferOES");
2542 return interface_->UnmapBuffer(target);
2543 }
2544
2545 void GL_BINDING_CALL MockGLInterface::Mock_glUseProgram(GLuint program) {
2546 MakeFunctionUnique("glUseProgram");
2547 interface_->UseProgram(program);
2548 }
2549
2550 void GL_BINDING_CALL MockGLInterface::Mock_glValidateProgram(GLuint program) {
2551 MakeFunctionUnique("glValidateProgram");
2552 interface_->ValidateProgram(program);
2553 }
2554
2555 void GL_BINDING_CALL MockGLInterface::Mock_glVertexAttrib1f(GLuint indx,
2556 GLfloat x) {
2557 MakeFunctionUnique("glVertexAttrib1f");
2558 interface_->VertexAttrib1f(indx, x);
2559 }
2560
2561 void GL_BINDING_CALL
2562 MockGLInterface::Mock_glVertexAttrib1fv(GLuint indx, const GLfloat* values) {
2563 MakeFunctionUnique("glVertexAttrib1fv");
2564 interface_->VertexAttrib1fv(indx, values);
2565 }
2566
2567 void GL_BINDING_CALL MockGLInterface::Mock_glVertexAttrib2f(GLuint indx,
2568 GLfloat x,
2569 GLfloat y) {
2570 MakeFunctionUnique("glVertexAttrib2f");
2571 interface_->VertexAttrib2f(indx, x, y);
2572 }
2573
2574 void GL_BINDING_CALL
2575 MockGLInterface::Mock_glVertexAttrib2fv(GLuint indx, const GLfloat* values) {
2576 MakeFunctionUnique("glVertexAttrib2fv");
2577 interface_->VertexAttrib2fv(indx, values);
2578 }
2579
2580 void GL_BINDING_CALL MockGLInterface::Mock_glVertexAttrib3f(GLuint indx,
2581 GLfloat x,
2582 GLfloat y,
2583 GLfloat z) {
2584 MakeFunctionUnique("glVertexAttrib3f");
2585 interface_->VertexAttrib3f(indx, x, y, z);
2586 }
2587
2588 void GL_BINDING_CALL
2589 MockGLInterface::Mock_glVertexAttrib3fv(GLuint indx, const GLfloat* values) {
2590 MakeFunctionUnique("glVertexAttrib3fv");
2591 interface_->VertexAttrib3fv(indx, values);
2592 }
2593
2594 void GL_BINDING_CALL MockGLInterface::Mock_glVertexAttrib4f(GLuint indx,
2595 GLfloat x,
2596 GLfloat y,
2597 GLfloat z,
2598 GLfloat w) {
2599 MakeFunctionUnique("glVertexAttrib4f");
2600 interface_->VertexAttrib4f(indx, x, y, z, w);
2601 }
2602
2603 void GL_BINDING_CALL
2604 MockGLInterface::Mock_glVertexAttrib4fv(GLuint indx, const GLfloat* values) {
2605 MakeFunctionUnique("glVertexAttrib4fv");
2606 interface_->VertexAttrib4fv(indx, values);
2607 }
2608
2609 void GL_BINDING_CALL
2610 MockGLInterface::Mock_glVertexAttribDivisor(GLuint index, GLuint divisor) {
2611 MakeFunctionUnique("glVertexAttribDivisor");
2612 interface_->VertexAttribDivisorANGLE(index, divisor);
2613 }
2614
2615 void GL_BINDING_CALL
2616 MockGLInterface::Mock_glVertexAttribDivisorANGLE(GLuint index, GLuint divisor) {
2617 MakeFunctionUnique("glVertexAttribDivisorANGLE");
2618 interface_->VertexAttribDivisorANGLE(index, divisor);
2619 }
2620
2621 void GL_BINDING_CALL
2622 MockGLInterface::Mock_glVertexAttribDivisorARB(GLuint index, GLuint divisor) {
2623 MakeFunctionUnique("glVertexAttribDivisorARB");
2624 interface_->VertexAttribDivisorANGLE(index, divisor);
2625 }
2626
2627 void GL_BINDING_CALL MockGLInterface::Mock_glVertexAttribI4i(GLuint indx,
2628 GLint x,
2629 GLint y,
2630 GLint z,
2631 GLint w) {
2632 MakeFunctionUnique("glVertexAttribI4i");
2633 interface_->VertexAttribI4i(indx, x, y, z, w);
2634 }
2635
2636 void GL_BINDING_CALL
2637 MockGLInterface::Mock_glVertexAttribI4iv(GLuint indx, const GLint* values) {
2638 MakeFunctionUnique("glVertexAttribI4iv");
2639 interface_->VertexAttribI4iv(indx, values);
2640 }
2641
2642 void GL_BINDING_CALL MockGLInterface::Mock_glVertexAttribI4ui(GLuint indx,
2643 GLuint x,
2644 GLuint y,
2645 GLuint z,
2646 GLuint w) {
2647 MakeFunctionUnique("glVertexAttribI4ui");
2648 interface_->VertexAttribI4ui(indx, x, y, z, w);
2649 }
2650
2651 void GL_BINDING_CALL
2652 MockGLInterface::Mock_glVertexAttribI4uiv(GLuint indx, const GLuint* values) {
2653 MakeFunctionUnique("glVertexAttribI4uiv");
2654 interface_->VertexAttribI4uiv(indx, values);
2655 }
2656
2657 void GL_BINDING_CALL
2658 MockGLInterface::Mock_glVertexAttribIPointer(GLuint indx,
2659 GLint size,
2660 GLenum type,
2661 GLsizei stride,
2662 const void* ptr) {
2663 MakeFunctionUnique("glVertexAttribIPointer");
2664 interface_->VertexAttribIPointer(indx, size, type, stride, ptr);
2665 }
2666
2667 void GL_BINDING_CALL
2668 MockGLInterface::Mock_glVertexAttribPointer(GLuint indx,
2669 GLint size,
2670 GLenum type,
2671 GLboolean normalized,
2672 GLsizei stride,
2673 const void* ptr) {
2674 MakeFunctionUnique("glVertexAttribPointer");
2675 interface_->VertexAttribPointer(indx, size, type, normalized, stride, ptr);
2676 }
2677
2678 void GL_BINDING_CALL MockGLInterface::Mock_glViewport(GLint x,
2679 GLint y,
2680 GLsizei width,
2681 GLsizei height) {
2682 MakeFunctionUnique("glViewport");
2683 interface_->Viewport(x, y, width, height);
2684 }
2685
2686 GLenum GL_BINDING_CALL MockGLInterface::Mock_glWaitSync(GLsync sync,
2687 GLbitfield flags,
2688 GLuint64 timeout) {
2689 MakeFunctionUnique("glWaitSync");
2690 return interface_->WaitSync(sync, flags, timeout);
2691 }
2692
2693 static void MockInvalidFunction() {
2694 NOTREACHED();
2695 }
2696
2697 void* GL_BINDING_CALL MockGLInterface::GetGLProcAddress(const char* name) {
2698 if (strcmp(name, "glActiveTexture") == 0)
2699 return reinterpret_cast<void*>(Mock_glActiveTexture);
2700 if (strcmp(name, "glApplyFramebufferAttachmentCMAAINTEL") == 0)
2701 return reinterpret_cast<void*>(Mock_glApplyFramebufferAttachmentCMAAINTEL);
2702 if (strcmp(name, "glAttachShader") == 0)
2703 return reinterpret_cast<void*>(Mock_glAttachShader);
2704 if (strcmp(name, "glBeginQuery") == 0)
2705 return reinterpret_cast<void*>(Mock_glBeginQuery);
2706 if (strcmp(name, "glBeginQueryARB") == 0)
2707 return reinterpret_cast<void*>(Mock_glBeginQueryARB);
2708 if (strcmp(name, "glBeginQueryEXT") == 0)
2709 return reinterpret_cast<void*>(Mock_glBeginQueryEXT);
2710 if (strcmp(name, "glBeginTransformFeedback") == 0)
2711 return reinterpret_cast<void*>(Mock_glBeginTransformFeedback);
2712 if (strcmp(name, "glBindAttribLocation") == 0)
2713 return reinterpret_cast<void*>(Mock_glBindAttribLocation);
2714 if (strcmp(name, "glBindBuffer") == 0)
2715 return reinterpret_cast<void*>(Mock_glBindBuffer);
2716 if (strcmp(name, "glBindBufferBase") == 0)
2717 return reinterpret_cast<void*>(Mock_glBindBufferBase);
2718 if (strcmp(name, "glBindBufferRange") == 0)
2719 return reinterpret_cast<void*>(Mock_glBindBufferRange);
2720 if (strcmp(name, "glBindFragDataLocation") == 0)
2721 return reinterpret_cast<void*>(Mock_glBindFragDataLocation);
2722 if (strcmp(name, "glBindFragDataLocationIndexed") == 0)
2723 return reinterpret_cast<void*>(Mock_glBindFragDataLocationIndexed);
2724 if (strcmp(name, "glBindFramebuffer") == 0)
2725 return reinterpret_cast<void*>(Mock_glBindFramebuffer);
2726 if (strcmp(name, "glBindFramebufferEXT") == 0)
2727 return reinterpret_cast<void*>(Mock_glBindFramebufferEXT);
2728 if (strcmp(name, "glBindRenderbuffer") == 0)
2729 return reinterpret_cast<void*>(Mock_glBindRenderbuffer);
2730 if (strcmp(name, "glBindRenderbufferEXT") == 0)
2731 return reinterpret_cast<void*>(Mock_glBindRenderbufferEXT);
2732 if (strcmp(name, "glBindSampler") == 0)
2733 return reinterpret_cast<void*>(Mock_glBindSampler);
2734 if (strcmp(name, "glBindTexture") == 0)
2735 return reinterpret_cast<void*>(Mock_glBindTexture);
2736 if (strcmp(name, "glBindTransformFeedback") == 0)
2737 return reinterpret_cast<void*>(Mock_glBindTransformFeedback);
2738 if (strcmp(name, "glBindVertexArray") == 0)
2739 return reinterpret_cast<void*>(Mock_glBindVertexArray);
2740 if (strcmp(name, "glBindVertexArrayAPPLE") == 0)
2741 return reinterpret_cast<void*>(Mock_glBindVertexArrayAPPLE);
2742 if (strcmp(name, "glBindVertexArrayOES") == 0)
2743 return reinterpret_cast<void*>(Mock_glBindVertexArrayOES);
2744 if (strcmp(name, "glBlendBarrierKHR") == 0)
2745 return reinterpret_cast<void*>(Mock_glBlendBarrierKHR);
2746 if (strcmp(name, "glBlendBarrierNV") == 0)
2747 return reinterpret_cast<void*>(Mock_glBlendBarrierNV);
2748 if (strcmp(name, "glBlendColor") == 0)
2749 return reinterpret_cast<void*>(Mock_glBlendColor);
2750 if (strcmp(name, "glBlendEquation") == 0)
2751 return reinterpret_cast<void*>(Mock_glBlendEquation);
2752 if (strcmp(name, "glBlendEquationSeparate") == 0)
2753 return reinterpret_cast<void*>(Mock_glBlendEquationSeparate);
2754 if (strcmp(name, "glBlendFunc") == 0)
2755 return reinterpret_cast<void*>(Mock_glBlendFunc);
2756 if (strcmp(name, "glBlendFuncSeparate") == 0)
2757 return reinterpret_cast<void*>(Mock_glBlendFuncSeparate);
2758 if (strcmp(name, "glBlitFramebuffer") == 0)
2759 return reinterpret_cast<void*>(Mock_glBlitFramebuffer);
2760 if (strcmp(name, "glBlitFramebufferANGLE") == 0)
2761 return reinterpret_cast<void*>(Mock_glBlitFramebufferANGLE);
2762 if (strcmp(name, "glBlitFramebufferEXT") == 0)
2763 return reinterpret_cast<void*>(Mock_glBlitFramebufferEXT);
2764 if (strcmp(name, "glBufferData") == 0)
2765 return reinterpret_cast<void*>(Mock_glBufferData);
2766 if (strcmp(name, "glBufferSubData") == 0)
2767 return reinterpret_cast<void*>(Mock_glBufferSubData);
2768 if (strcmp(name, "glCheckFramebufferStatus") == 0)
2769 return reinterpret_cast<void*>(Mock_glCheckFramebufferStatus);
2770 if (strcmp(name, "glCheckFramebufferStatusEXT") == 0)
2771 return reinterpret_cast<void*>(Mock_glCheckFramebufferStatusEXT);
2772 if (strcmp(name, "glClear") == 0)
2773 return reinterpret_cast<void*>(Mock_glClear);
2774 if (strcmp(name, "glClearBufferfi") == 0)
2775 return reinterpret_cast<void*>(Mock_glClearBufferfi);
2776 if (strcmp(name, "glClearBufferfv") == 0)
2777 return reinterpret_cast<void*>(Mock_glClearBufferfv);
2778 if (strcmp(name, "glClearBufferiv") == 0)
2779 return reinterpret_cast<void*>(Mock_glClearBufferiv);
2780 if (strcmp(name, "glClearBufferuiv") == 0)
2781 return reinterpret_cast<void*>(Mock_glClearBufferuiv);
2782 if (strcmp(name, "glClearColor") == 0)
2783 return reinterpret_cast<void*>(Mock_glClearColor);
2784 if (strcmp(name, "glClearDepth") == 0)
2785 return reinterpret_cast<void*>(Mock_glClearDepth);
2786 if (strcmp(name, "glClearDepthf") == 0)
2787 return reinterpret_cast<void*>(Mock_glClearDepthf);
2788 if (strcmp(name, "glClearStencil") == 0)
2789 return reinterpret_cast<void*>(Mock_glClearStencil);
2790 if (strcmp(name, "glClientWaitSync") == 0)
2791 return reinterpret_cast<void*>(Mock_glClientWaitSync);
2792 if (strcmp(name, "glColorMask") == 0)
2793 return reinterpret_cast<void*>(Mock_glColorMask);
2794 if (strcmp(name, "glCompileShader") == 0)
2795 return reinterpret_cast<void*>(Mock_glCompileShader);
2796 if (strcmp(name, "glCompressedTexImage2D") == 0)
2797 return reinterpret_cast<void*>(Mock_glCompressedTexImage2D);
2798 if (strcmp(name, "glCompressedTexImage3D") == 0)
2799 return reinterpret_cast<void*>(Mock_glCompressedTexImage3D);
2800 if (strcmp(name, "glCompressedTexSubImage2D") == 0)
2801 return reinterpret_cast<void*>(Mock_glCompressedTexSubImage2D);
2802 if (strcmp(name, "glCompressedTexSubImage3D") == 0)
2803 return reinterpret_cast<void*>(Mock_glCompressedTexSubImage3D);
2804 if (strcmp(name, "glCopyBufferSubData") == 0)
2805 return reinterpret_cast<void*>(Mock_glCopyBufferSubData);
2806 if (strcmp(name, "glCopyTexImage2D") == 0)
2807 return reinterpret_cast<void*>(Mock_glCopyTexImage2D);
2808 if (strcmp(name, "glCopyTexSubImage2D") == 0)
2809 return reinterpret_cast<void*>(Mock_glCopyTexSubImage2D);
2810 if (strcmp(name, "glCopyTexSubImage3D") == 0)
2811 return reinterpret_cast<void*>(Mock_glCopyTexSubImage3D);
2812 if (strcmp(name, "glCoverFillPathNV") == 0)
2813 return reinterpret_cast<void*>(Mock_glCoverFillPathNV);
2814 if (strcmp(name, "glCoverStrokePathNV") == 0)
2815 return reinterpret_cast<void*>(Mock_glCoverStrokePathNV);
2816 if (strcmp(name, "glCreateProgram") == 0)
2817 return reinterpret_cast<void*>(Mock_glCreateProgram);
2818 if (strcmp(name, "glCreateShader") == 0)
2819 return reinterpret_cast<void*>(Mock_glCreateShader);
2820 if (strcmp(name, "glCullFace") == 0)
2821 return reinterpret_cast<void*>(Mock_glCullFace);
2822 if (strcmp(name, "glDeleteBuffers") == 0)
2823 return reinterpret_cast<void*>(Mock_glDeleteBuffers);
2824 if (strcmp(name, "glDeleteFencesAPPLE") == 0)
2825 return reinterpret_cast<void*>(Mock_glDeleteFencesAPPLE);
2826 if (strcmp(name, "glDeleteFencesNV") == 0)
2827 return reinterpret_cast<void*>(Mock_glDeleteFencesNV);
2828 if (strcmp(name, "glDeleteFramebuffers") == 0)
2829 return reinterpret_cast<void*>(Mock_glDeleteFramebuffers);
2830 if (strcmp(name, "glDeleteFramebuffersEXT") == 0)
2831 return reinterpret_cast<void*>(Mock_glDeleteFramebuffersEXT);
2832 if (strcmp(name, "glDeletePathsNV") == 0)
2833 return reinterpret_cast<void*>(Mock_glDeletePathsNV);
2834 if (strcmp(name, "glDeleteProgram") == 0)
2835 return reinterpret_cast<void*>(Mock_glDeleteProgram);
2836 if (strcmp(name, "glDeleteQueries") == 0)
2837 return reinterpret_cast<void*>(Mock_glDeleteQueries);
2838 if (strcmp(name, "glDeleteQueriesARB") == 0)
2839 return reinterpret_cast<void*>(Mock_glDeleteQueriesARB);
2840 if (strcmp(name, "glDeleteQueriesEXT") == 0)
2841 return reinterpret_cast<void*>(Mock_glDeleteQueriesEXT);
2842 if (strcmp(name, "glDeleteRenderbuffers") == 0)
2843 return reinterpret_cast<void*>(Mock_glDeleteRenderbuffers);
2844 if (strcmp(name, "glDeleteRenderbuffersEXT") == 0)
2845 return reinterpret_cast<void*>(Mock_glDeleteRenderbuffersEXT);
2846 if (strcmp(name, "glDeleteSamplers") == 0)
2847 return reinterpret_cast<void*>(Mock_glDeleteSamplers);
2848 if (strcmp(name, "glDeleteShader") == 0)
2849 return reinterpret_cast<void*>(Mock_glDeleteShader);
2850 if (strcmp(name, "glDeleteSync") == 0)
2851 return reinterpret_cast<void*>(Mock_glDeleteSync);
2852 if (strcmp(name, "glDeleteTextures") == 0)
2853 return reinterpret_cast<void*>(Mock_glDeleteTextures);
2854 if (strcmp(name, "glDeleteTransformFeedbacks") == 0)
2855 return reinterpret_cast<void*>(Mock_glDeleteTransformFeedbacks);
2856 if (strcmp(name, "glDeleteVertexArrays") == 0)
2857 return reinterpret_cast<void*>(Mock_glDeleteVertexArrays);
2858 if (strcmp(name, "glDeleteVertexArraysAPPLE") == 0)
2859 return reinterpret_cast<void*>(Mock_glDeleteVertexArraysAPPLE);
2860 if (strcmp(name, "glDeleteVertexArraysOES") == 0)
2861 return reinterpret_cast<void*>(Mock_glDeleteVertexArraysOES);
2862 if (strcmp(name, "glDepthFunc") == 0)
2863 return reinterpret_cast<void*>(Mock_glDepthFunc);
2864 if (strcmp(name, "glDepthMask") == 0)
2865 return reinterpret_cast<void*>(Mock_glDepthMask);
2866 if (strcmp(name, "glDepthRange") == 0)
2867 return reinterpret_cast<void*>(Mock_glDepthRange);
2868 if (strcmp(name, "glDepthRangef") == 0)
2869 return reinterpret_cast<void*>(Mock_glDepthRangef);
2870 if (strcmp(name, "glDetachShader") == 0)
2871 return reinterpret_cast<void*>(Mock_glDetachShader);
2872 if (strcmp(name, "glDisable") == 0)
2873 return reinterpret_cast<void*>(Mock_glDisable);
2874 if (strcmp(name, "glDisableVertexAttribArray") == 0)
2875 return reinterpret_cast<void*>(Mock_glDisableVertexAttribArray);
2876 if (strcmp(name, "glDiscardFramebufferEXT") == 0)
2877 return reinterpret_cast<void*>(Mock_glDiscardFramebufferEXT);
2878 if (strcmp(name, "glDrawArrays") == 0)
2879 return reinterpret_cast<void*>(Mock_glDrawArrays);
2880 if (strcmp(name, "glDrawArraysInstanced") == 0)
2881 return reinterpret_cast<void*>(Mock_glDrawArraysInstanced);
2882 if (strcmp(name, "glDrawArraysInstancedANGLE") == 0)
2883 return reinterpret_cast<void*>(Mock_glDrawArraysInstancedANGLE);
2884 if (strcmp(name, "glDrawArraysInstancedARB") == 0)
2885 return reinterpret_cast<void*>(Mock_glDrawArraysInstancedARB);
2886 if (strcmp(name, "glDrawBuffer") == 0)
2887 return reinterpret_cast<void*>(Mock_glDrawBuffer);
2888 if (strcmp(name, "glDrawBuffers") == 0)
2889 return reinterpret_cast<void*>(Mock_glDrawBuffers);
2890 if (strcmp(name, "glDrawBuffersARB") == 0)
2891 return reinterpret_cast<void*>(Mock_glDrawBuffersARB);
2892 if (strcmp(name, "glDrawBuffersEXT") == 0)
2893 return reinterpret_cast<void*>(Mock_glDrawBuffersEXT);
2894 if (strcmp(name, "glDrawElements") == 0)
2895 return reinterpret_cast<void*>(Mock_glDrawElements);
2896 if (strcmp(name, "glDrawElementsInstanced") == 0)
2897 return reinterpret_cast<void*>(Mock_glDrawElementsInstanced);
2898 if (strcmp(name, "glDrawElementsInstancedANGLE") == 0)
2899 return reinterpret_cast<void*>(Mock_glDrawElementsInstancedANGLE);
2900 if (strcmp(name, "glDrawElementsInstancedARB") == 0)
2901 return reinterpret_cast<void*>(Mock_glDrawElementsInstancedARB);
2902 if (strcmp(name, "glDrawRangeElements") == 0)
2903 return reinterpret_cast<void*>(Mock_glDrawRangeElements);
2904 if (strcmp(name, "glEGLImageTargetRenderbufferStorageOES") == 0)
2905 return reinterpret_cast<void*>(Mock_glEGLImageTargetRenderbufferStorageOES);
2906 if (strcmp(name, "glEGLImageTargetTexture2DOES") == 0)
2907 return reinterpret_cast<void*>(Mock_glEGLImageTargetTexture2DOES);
2908 if (strcmp(name, "glEnable") == 0)
2909 return reinterpret_cast<void*>(Mock_glEnable);
2910 if (strcmp(name, "glEnableVertexAttribArray") == 0)
2911 return reinterpret_cast<void*>(Mock_glEnableVertexAttribArray);
2912 if (strcmp(name, "glEndQuery") == 0)
2913 return reinterpret_cast<void*>(Mock_glEndQuery);
2914 if (strcmp(name, "glEndQueryARB") == 0)
2915 return reinterpret_cast<void*>(Mock_glEndQueryARB);
2916 if (strcmp(name, "glEndQueryEXT") == 0)
2917 return reinterpret_cast<void*>(Mock_glEndQueryEXT);
2918 if (strcmp(name, "glEndTransformFeedback") == 0)
2919 return reinterpret_cast<void*>(Mock_glEndTransformFeedback);
2920 if (strcmp(name, "glFenceSync") == 0)
2921 return reinterpret_cast<void*>(Mock_glFenceSync);
2922 if (strcmp(name, "glFinish") == 0)
2923 return reinterpret_cast<void*>(Mock_glFinish);
2924 if (strcmp(name, "glFinishFenceAPPLE") == 0)
2925 return reinterpret_cast<void*>(Mock_glFinishFenceAPPLE);
2926 if (strcmp(name, "glFinishFenceNV") == 0)
2927 return reinterpret_cast<void*>(Mock_glFinishFenceNV);
2928 if (strcmp(name, "glFlush") == 0)
2929 return reinterpret_cast<void*>(Mock_glFlush);
2930 if (strcmp(name, "glFlushMappedBufferRange") == 0)
2931 return reinterpret_cast<void*>(Mock_glFlushMappedBufferRange);
2932 if (strcmp(name, "glFramebufferRenderbuffer") == 0)
2933 return reinterpret_cast<void*>(Mock_glFramebufferRenderbuffer);
2934 if (strcmp(name, "glFramebufferRenderbufferEXT") == 0)
2935 return reinterpret_cast<void*>(Mock_glFramebufferRenderbufferEXT);
2936 if (strcmp(name, "glFramebufferTexture2D") == 0)
2937 return reinterpret_cast<void*>(Mock_glFramebufferTexture2D);
2938 if (strcmp(name, "glFramebufferTexture2DEXT") == 0)
2939 return reinterpret_cast<void*>(Mock_glFramebufferTexture2DEXT);
2940 if (strcmp(name, "glFramebufferTexture2DMultisampleEXT") == 0)
2941 return reinterpret_cast<void*>(Mock_glFramebufferTexture2DMultisampleEXT);
2942 if (strcmp(name, "glFramebufferTexture2DMultisampleIMG") == 0)
2943 return reinterpret_cast<void*>(Mock_glFramebufferTexture2DMultisampleIMG);
2944 if (strcmp(name, "glFramebufferTextureLayer") == 0)
2945 return reinterpret_cast<void*>(Mock_glFramebufferTextureLayer);
2946 if (strcmp(name, "glFrontFace") == 0)
2947 return reinterpret_cast<void*>(Mock_glFrontFace);
2948 if (strcmp(name, "glGenBuffers") == 0)
2949 return reinterpret_cast<void*>(Mock_glGenBuffers);
2950 if (strcmp(name, "glGenFencesAPPLE") == 0)
2951 return reinterpret_cast<void*>(Mock_glGenFencesAPPLE);
2952 if (strcmp(name, "glGenFencesNV") == 0)
2953 return reinterpret_cast<void*>(Mock_glGenFencesNV);
2954 if (strcmp(name, "glGenFramebuffers") == 0)
2955 return reinterpret_cast<void*>(Mock_glGenFramebuffers);
2956 if (strcmp(name, "glGenFramebuffersEXT") == 0)
2957 return reinterpret_cast<void*>(Mock_glGenFramebuffersEXT);
2958 if (strcmp(name, "glGenPathsNV") == 0)
2959 return reinterpret_cast<void*>(Mock_glGenPathsNV);
2960 if (strcmp(name, "glGenQueries") == 0)
2961 return reinterpret_cast<void*>(Mock_glGenQueries);
2962 if (strcmp(name, "glGenQueriesARB") == 0)
2963 return reinterpret_cast<void*>(Mock_glGenQueriesARB);
2964 if (strcmp(name, "glGenQueriesEXT") == 0)
2965 return reinterpret_cast<void*>(Mock_glGenQueriesEXT);
2966 if (strcmp(name, "glGenRenderbuffers") == 0)
2967 return reinterpret_cast<void*>(Mock_glGenRenderbuffers);
2968 if (strcmp(name, "glGenRenderbuffersEXT") == 0)
2969 return reinterpret_cast<void*>(Mock_glGenRenderbuffersEXT);
2970 if (strcmp(name, "glGenSamplers") == 0)
2971 return reinterpret_cast<void*>(Mock_glGenSamplers);
2972 if (strcmp(name, "glGenTextures") == 0)
2973 return reinterpret_cast<void*>(Mock_glGenTextures);
2974 if (strcmp(name, "glGenTransformFeedbacks") == 0)
2975 return reinterpret_cast<void*>(Mock_glGenTransformFeedbacks);
2976 if (strcmp(name, "glGenVertexArrays") == 0)
2977 return reinterpret_cast<void*>(Mock_glGenVertexArrays);
2978 if (strcmp(name, "glGenVertexArraysAPPLE") == 0)
2979 return reinterpret_cast<void*>(Mock_glGenVertexArraysAPPLE);
2980 if (strcmp(name, "glGenVertexArraysOES") == 0)
2981 return reinterpret_cast<void*>(Mock_glGenVertexArraysOES);
2982 if (strcmp(name, "glGenerateMipmap") == 0)
2983 return reinterpret_cast<void*>(Mock_glGenerateMipmap);
2984 if (strcmp(name, "glGenerateMipmapEXT") == 0)
2985 return reinterpret_cast<void*>(Mock_glGenerateMipmapEXT);
2986 if (strcmp(name, "glGetActiveAttrib") == 0)
2987 return reinterpret_cast<void*>(Mock_glGetActiveAttrib);
2988 if (strcmp(name, "glGetActiveUniform") == 0)
2989 return reinterpret_cast<void*>(Mock_glGetActiveUniform);
2990 if (strcmp(name, "glGetActiveUniformBlockName") == 0)
2991 return reinterpret_cast<void*>(Mock_glGetActiveUniformBlockName);
2992 if (strcmp(name, "glGetActiveUniformBlockiv") == 0)
2993 return reinterpret_cast<void*>(Mock_glGetActiveUniformBlockiv);
2994 if (strcmp(name, "glGetActiveUniformsiv") == 0)
2995 return reinterpret_cast<void*>(Mock_glGetActiveUniformsiv);
2996 if (strcmp(name, "glGetAttachedShaders") == 0)
2997 return reinterpret_cast<void*>(Mock_glGetAttachedShaders);
2998 if (strcmp(name, "glGetAttribLocation") == 0)
2999 return reinterpret_cast<void*>(Mock_glGetAttribLocation);
3000 if (strcmp(name, "glGetBooleanv") == 0)
3001 return reinterpret_cast<void*>(Mock_glGetBooleanv);
3002 if (strcmp(name, "glGetBufferParameteriv") == 0)
3003 return reinterpret_cast<void*>(Mock_glGetBufferParameteriv);
3004 if (strcmp(name, "glGetError") == 0)
3005 return reinterpret_cast<void*>(Mock_glGetError);
3006 if (strcmp(name, "glGetFenceivNV") == 0)
3007 return reinterpret_cast<void*>(Mock_glGetFenceivNV);
3008 if (strcmp(name, "glGetFloatv") == 0)
3009 return reinterpret_cast<void*>(Mock_glGetFloatv);
3010 if (strcmp(name, "glGetFragDataLocation") == 0)
3011 return reinterpret_cast<void*>(Mock_glGetFragDataLocation);
3012 if (strcmp(name, "glGetFramebufferAttachmentParameteriv") == 0)
3013 return reinterpret_cast<void*>(Mock_glGetFramebufferAttachmentParameteriv);
3014 if (strcmp(name, "glGetFramebufferAttachmentParameterivEXT") == 0)
3015 return reinterpret_cast<void*>(
3016 Mock_glGetFramebufferAttachmentParameterivEXT);
3017 if (strcmp(name, "glGetGraphicsResetStatus") == 0)
3018 return reinterpret_cast<void*>(Mock_glGetGraphicsResetStatus);
3019 if (strcmp(name, "glGetGraphicsResetStatusARB") == 0)
3020 return reinterpret_cast<void*>(Mock_glGetGraphicsResetStatusARB);
3021 if (strcmp(name, "glGetGraphicsResetStatusEXT") == 0)
3022 return reinterpret_cast<void*>(Mock_glGetGraphicsResetStatusEXT);
3023 if (strcmp(name, "glGetGraphicsResetStatusKHR") == 0)
3024 return reinterpret_cast<void*>(Mock_glGetGraphicsResetStatusKHR);
3025 if (strcmp(name, "glGetInteger64i_v") == 0)
3026 return reinterpret_cast<void*>(Mock_glGetInteger64i_v);
3027 if (strcmp(name, "glGetInteger64v") == 0)
3028 return reinterpret_cast<void*>(Mock_glGetInteger64v);
3029 if (strcmp(name, "glGetIntegeri_v") == 0)
3030 return reinterpret_cast<void*>(Mock_glGetIntegeri_v);
3031 if (strcmp(name, "glGetIntegerv") == 0)
3032 return reinterpret_cast<void*>(Mock_glGetIntegerv);
3033 if (strcmp(name, "glGetInternalformativ") == 0)
3034 return reinterpret_cast<void*>(Mock_glGetInternalformativ);
3035 if (strcmp(name, "glGetProgramBinary") == 0)
3036 return reinterpret_cast<void*>(Mock_glGetProgramBinary);
3037 if (strcmp(name, "glGetProgramBinaryOES") == 0)
3038 return reinterpret_cast<void*>(Mock_glGetProgramBinaryOES);
3039 if (strcmp(name, "glGetProgramInfoLog") == 0)
3040 return reinterpret_cast<void*>(Mock_glGetProgramInfoLog);
3041 if (strcmp(name, "glGetProgramResourceLocation") == 0)
3042 return reinterpret_cast<void*>(Mock_glGetProgramResourceLocation);
3043 if (strcmp(name, "glGetProgramiv") == 0)
3044 return reinterpret_cast<void*>(Mock_glGetProgramiv);
3045 if (strcmp(name, "glGetQueryObjecti64v") == 0)
3046 return reinterpret_cast<void*>(Mock_glGetQueryObjecti64v);
3047 if (strcmp(name, "glGetQueryObjecti64vEXT") == 0)
3048 return reinterpret_cast<void*>(Mock_glGetQueryObjecti64vEXT);
3049 if (strcmp(name, "glGetQueryObjectiv") == 0)
3050 return reinterpret_cast<void*>(Mock_glGetQueryObjectiv);
3051 if (strcmp(name, "glGetQueryObjectivARB") == 0)
3052 return reinterpret_cast<void*>(Mock_glGetQueryObjectivARB);
3053 if (strcmp(name, "glGetQueryObjectivEXT") == 0)
3054 return reinterpret_cast<void*>(Mock_glGetQueryObjectivEXT);
3055 if (strcmp(name, "glGetQueryObjectui64v") == 0)
3056 return reinterpret_cast<void*>(Mock_glGetQueryObjectui64v);
3057 if (strcmp(name, "glGetQueryObjectui64vEXT") == 0)
3058 return reinterpret_cast<void*>(Mock_glGetQueryObjectui64vEXT);
3059 if (strcmp(name, "glGetQueryObjectuiv") == 0)
3060 return reinterpret_cast<void*>(Mock_glGetQueryObjectuiv);
3061 if (strcmp(name, "glGetQueryObjectuivARB") == 0)
3062 return reinterpret_cast<void*>(Mock_glGetQueryObjectuivARB);
3063 if (strcmp(name, "glGetQueryObjectuivEXT") == 0)
3064 return reinterpret_cast<void*>(Mock_glGetQueryObjectuivEXT);
3065 if (strcmp(name, "glGetQueryiv") == 0)
3066 return reinterpret_cast<void*>(Mock_glGetQueryiv);
3067 if (strcmp(name, "glGetQueryivARB") == 0)
3068 return reinterpret_cast<void*>(Mock_glGetQueryivARB);
3069 if (strcmp(name, "glGetQueryivEXT") == 0)
3070 return reinterpret_cast<void*>(Mock_glGetQueryivEXT);
3071 if (strcmp(name, "glGetRenderbufferParameteriv") == 0)
3072 return reinterpret_cast<void*>(Mock_glGetRenderbufferParameteriv);
3073 if (strcmp(name, "glGetRenderbufferParameterivEXT") == 0)
3074 return reinterpret_cast<void*>(Mock_glGetRenderbufferParameterivEXT);
3075 if (strcmp(name, "glGetSamplerParameterfv") == 0)
3076 return reinterpret_cast<void*>(Mock_glGetSamplerParameterfv);
3077 if (strcmp(name, "glGetSamplerParameteriv") == 0)
3078 return reinterpret_cast<void*>(Mock_glGetSamplerParameteriv);
3079 if (strcmp(name, "glGetShaderInfoLog") == 0)
3080 return reinterpret_cast<void*>(Mock_glGetShaderInfoLog);
3081 if (strcmp(name, "glGetShaderPrecisionFormat") == 0)
3082 return reinterpret_cast<void*>(Mock_glGetShaderPrecisionFormat);
3083 if (strcmp(name, "glGetShaderSource") == 0)
3084 return reinterpret_cast<void*>(Mock_glGetShaderSource);
3085 if (strcmp(name, "glGetShaderiv") == 0)
3086 return reinterpret_cast<void*>(Mock_glGetShaderiv);
3087 if (strcmp(name, "glGetString") == 0)
3088 return reinterpret_cast<void*>(Mock_glGetString);
3089 if (strcmp(name, "glGetStringi") == 0)
3090 return reinterpret_cast<void*>(Mock_glGetStringi);
3091 if (strcmp(name, "glGetSynciv") == 0)
3092 return reinterpret_cast<void*>(Mock_glGetSynciv);
3093 if (strcmp(name, "glGetTexLevelParameterfv") == 0)
3094 return reinterpret_cast<void*>(Mock_glGetTexLevelParameterfv);
3095 if (strcmp(name, "glGetTexLevelParameteriv") == 0)
3096 return reinterpret_cast<void*>(Mock_glGetTexLevelParameteriv);
3097 if (strcmp(name, "glGetTexParameterfv") == 0)
3098 return reinterpret_cast<void*>(Mock_glGetTexParameterfv);
3099 if (strcmp(name, "glGetTexParameteriv") == 0)
3100 return reinterpret_cast<void*>(Mock_glGetTexParameteriv);
3101 if (strcmp(name, "glGetTransformFeedbackVarying") == 0)
3102 return reinterpret_cast<void*>(Mock_glGetTransformFeedbackVarying);
3103 if (strcmp(name, "glGetTranslatedShaderSourceANGLE") == 0)
3104 return reinterpret_cast<void*>(Mock_glGetTranslatedShaderSourceANGLE);
3105 if (strcmp(name, "glGetUniformBlockIndex") == 0)
3106 return reinterpret_cast<void*>(Mock_glGetUniformBlockIndex);
3107 if (strcmp(name, "glGetUniformIndices") == 0)
3108 return reinterpret_cast<void*>(Mock_glGetUniformIndices);
3109 if (strcmp(name, "glGetUniformLocation") == 0)
3110 return reinterpret_cast<void*>(Mock_glGetUniformLocation);
3111 if (strcmp(name, "glGetUniformfv") == 0)
3112 return reinterpret_cast<void*>(Mock_glGetUniformfv);
3113 if (strcmp(name, "glGetUniformiv") == 0)
3114 return reinterpret_cast<void*>(Mock_glGetUniformiv);
3115 if (strcmp(name, "glGetUniformuiv") == 0)
3116 return reinterpret_cast<void*>(Mock_glGetUniformuiv);
3117 if (strcmp(name, "glGetVertexAttribPointerv") == 0)
3118 return reinterpret_cast<void*>(Mock_glGetVertexAttribPointerv);
3119 if (strcmp(name, "glGetVertexAttribfv") == 0)
3120 return reinterpret_cast<void*>(Mock_glGetVertexAttribfv);
3121 if (strcmp(name, "glGetVertexAttribiv") == 0)
3122 return reinterpret_cast<void*>(Mock_glGetVertexAttribiv);
3123 if (strcmp(name, "glHint") == 0)
3124 return reinterpret_cast<void*>(Mock_glHint);
3125 if (strcmp(name, "glInsertEventMarkerEXT") == 0)
3126 return reinterpret_cast<void*>(Mock_glInsertEventMarkerEXT);
3127 if (strcmp(name, "glInvalidateFramebuffer") == 0)
3128 return reinterpret_cast<void*>(Mock_glInvalidateFramebuffer);
3129 if (strcmp(name, "glInvalidateSubFramebuffer") == 0)
3130 return reinterpret_cast<void*>(Mock_glInvalidateSubFramebuffer);
3131 if (strcmp(name, "glIsBuffer") == 0)
3132 return reinterpret_cast<void*>(Mock_glIsBuffer);
3133 if (strcmp(name, "glIsEnabled") == 0)
3134 return reinterpret_cast<void*>(Mock_glIsEnabled);
3135 if (strcmp(name, "glIsFenceAPPLE") == 0)
3136 return reinterpret_cast<void*>(Mock_glIsFenceAPPLE);
3137 if (strcmp(name, "glIsFenceNV") == 0)
3138 return reinterpret_cast<void*>(Mock_glIsFenceNV);
3139 if (strcmp(name, "glIsFramebuffer") == 0)
3140 return reinterpret_cast<void*>(Mock_glIsFramebuffer);
3141 if (strcmp(name, "glIsFramebufferEXT") == 0)
3142 return reinterpret_cast<void*>(Mock_glIsFramebufferEXT);
3143 if (strcmp(name, "glIsPathNV") == 0)
3144 return reinterpret_cast<void*>(Mock_glIsPathNV);
3145 if (strcmp(name, "glIsProgram") == 0)
3146 return reinterpret_cast<void*>(Mock_glIsProgram);
3147 if (strcmp(name, "glIsQuery") == 0)
3148 return reinterpret_cast<void*>(Mock_glIsQuery);
3149 if (strcmp(name, "glIsQueryARB") == 0)
3150 return reinterpret_cast<void*>(Mock_glIsQueryARB);
3151 if (strcmp(name, "glIsQueryEXT") == 0)
3152 return reinterpret_cast<void*>(Mock_glIsQueryEXT);
3153 if (strcmp(name, "glIsRenderbuffer") == 0)
3154 return reinterpret_cast<void*>(Mock_glIsRenderbuffer);
3155 if (strcmp(name, "glIsRenderbufferEXT") == 0)
3156 return reinterpret_cast<void*>(Mock_glIsRenderbufferEXT);
3157 if (strcmp(name, "glIsSampler") == 0)
3158 return reinterpret_cast<void*>(Mock_glIsSampler);
3159 if (strcmp(name, "glIsShader") == 0)
3160 return reinterpret_cast<void*>(Mock_glIsShader);
3161 if (strcmp(name, "glIsSync") == 0)
3162 return reinterpret_cast<void*>(Mock_glIsSync);
3163 if (strcmp(name, "glIsTexture") == 0)
3164 return reinterpret_cast<void*>(Mock_glIsTexture);
3165 if (strcmp(name, "glIsTransformFeedback") == 0)
3166 return reinterpret_cast<void*>(Mock_glIsTransformFeedback);
3167 if (strcmp(name, "glIsVertexArray") == 0)
3168 return reinterpret_cast<void*>(Mock_glIsVertexArray);
3169 if (strcmp(name, "glIsVertexArrayAPPLE") == 0)
3170 return reinterpret_cast<void*>(Mock_glIsVertexArrayAPPLE);
3171 if (strcmp(name, "glIsVertexArrayOES") == 0)
3172 return reinterpret_cast<void*>(Mock_glIsVertexArrayOES);
3173 if (strcmp(name, "glLineWidth") == 0)
3174 return reinterpret_cast<void*>(Mock_glLineWidth);
3175 if (strcmp(name, "glLinkProgram") == 0)
3176 return reinterpret_cast<void*>(Mock_glLinkProgram);
3177 if (strcmp(name, "glMapBuffer") == 0)
3178 return reinterpret_cast<void*>(Mock_glMapBuffer);
3179 if (strcmp(name, "glMapBufferOES") == 0)
3180 return reinterpret_cast<void*>(Mock_glMapBufferOES);
3181 if (strcmp(name, "glMapBufferRange") == 0)
3182 return reinterpret_cast<void*>(Mock_glMapBufferRange);
3183 if (strcmp(name, "glMapBufferRangeEXT") == 0)
3184 return reinterpret_cast<void*>(Mock_glMapBufferRangeEXT);
3185 if (strcmp(name, "glMatrixLoadIdentityEXT") == 0)
3186 return reinterpret_cast<void*>(Mock_glMatrixLoadIdentityEXT);
3187 if (strcmp(name, "glMatrixLoadfEXT") == 0)
3188 return reinterpret_cast<void*>(Mock_glMatrixLoadfEXT);
3189 if (strcmp(name, "glPathCommandsNV") == 0)
3190 return reinterpret_cast<void*>(Mock_glPathCommandsNV);
3191 if (strcmp(name, "glPathParameterfNV") == 0)
3192 return reinterpret_cast<void*>(Mock_glPathParameterfNV);
3193 if (strcmp(name, "glPathParameteriNV") == 0)
3194 return reinterpret_cast<void*>(Mock_glPathParameteriNV);
3195 if (strcmp(name, "glPathStencilFuncNV") == 0)
3196 return reinterpret_cast<void*>(Mock_glPathStencilFuncNV);
3197 if (strcmp(name, "glPauseTransformFeedback") == 0)
3198 return reinterpret_cast<void*>(Mock_glPauseTransformFeedback);
3199 if (strcmp(name, "glPixelStorei") == 0)
3200 return reinterpret_cast<void*>(Mock_glPixelStorei);
3201 if (strcmp(name, "glPointParameteri") == 0)
3202 return reinterpret_cast<void*>(Mock_glPointParameteri);
3203 if (strcmp(name, "glPolygonOffset") == 0)
3204 return reinterpret_cast<void*>(Mock_glPolygonOffset);
3205 if (strcmp(name, "glPopGroupMarkerEXT") == 0)
3206 return reinterpret_cast<void*>(Mock_glPopGroupMarkerEXT);
3207 if (strcmp(name, "glProgramBinary") == 0)
3208 return reinterpret_cast<void*>(Mock_glProgramBinary);
3209 if (strcmp(name, "glProgramBinaryOES") == 0)
3210 return reinterpret_cast<void*>(Mock_glProgramBinaryOES);
3211 if (strcmp(name, "glProgramParameteri") == 0)
3212 return reinterpret_cast<void*>(Mock_glProgramParameteri);
3213 if (strcmp(name, "glPushGroupMarkerEXT") == 0)
3214 return reinterpret_cast<void*>(Mock_glPushGroupMarkerEXT);
3215 if (strcmp(name, "glQueryCounter") == 0)
3216 return reinterpret_cast<void*>(Mock_glQueryCounter);
3217 if (strcmp(name, "glQueryCounterEXT") == 0)
3218 return reinterpret_cast<void*>(Mock_glQueryCounterEXT);
3219 if (strcmp(name, "glReadBuffer") == 0)
3220 return reinterpret_cast<void*>(Mock_glReadBuffer);
3221 if (strcmp(name, "glReadPixels") == 0)
3222 return reinterpret_cast<void*>(Mock_glReadPixels);
3223 if (strcmp(name, "glReleaseShaderCompiler") == 0)
3224 return reinterpret_cast<void*>(Mock_glReleaseShaderCompiler);
3225 if (strcmp(name, "glRenderbufferStorage") == 0)
3226 return reinterpret_cast<void*>(Mock_glRenderbufferStorage);
3227 if (strcmp(name, "glRenderbufferStorageEXT") == 0)
3228 return reinterpret_cast<void*>(Mock_glRenderbufferStorageEXT);
3229 if (strcmp(name, "glRenderbufferStorageMultisample") == 0)
3230 return reinterpret_cast<void*>(Mock_glRenderbufferStorageMultisample);
3231 if (strcmp(name, "glRenderbufferStorageMultisampleANGLE") == 0)
3232 return reinterpret_cast<void*>(Mock_glRenderbufferStorageMultisampleANGLE);
3233 if (strcmp(name, "glRenderbufferStorageMultisampleEXT") == 0)
3234 return reinterpret_cast<void*>(Mock_glRenderbufferStorageMultisampleEXT);
3235 if (strcmp(name, "glRenderbufferStorageMultisampleIMG") == 0)
3236 return reinterpret_cast<void*>(Mock_glRenderbufferStorageMultisampleIMG);
3237 if (strcmp(name, "glResumeTransformFeedback") == 0)
3238 return reinterpret_cast<void*>(Mock_glResumeTransformFeedback);
3239 if (strcmp(name, "glSampleCoverage") == 0)
3240 return reinterpret_cast<void*>(Mock_glSampleCoverage);
3241 if (strcmp(name, "glSamplerParameterf") == 0)
3242 return reinterpret_cast<void*>(Mock_glSamplerParameterf);
3243 if (strcmp(name, "glSamplerParameterfv") == 0)
3244 return reinterpret_cast<void*>(Mock_glSamplerParameterfv);
3245 if (strcmp(name, "glSamplerParameteri") == 0)
3246 return reinterpret_cast<void*>(Mock_glSamplerParameteri);
3247 if (strcmp(name, "glSamplerParameteriv") == 0)
3248 return reinterpret_cast<void*>(Mock_glSamplerParameteriv);
3249 if (strcmp(name, "glScissor") == 0)
3250 return reinterpret_cast<void*>(Mock_glScissor);
3251 if (strcmp(name, "glSetFenceAPPLE") == 0)
3252 return reinterpret_cast<void*>(Mock_glSetFenceAPPLE);
3253 if (strcmp(name, "glSetFenceNV") == 0)
3254 return reinterpret_cast<void*>(Mock_glSetFenceNV);
3255 if (strcmp(name, "glShaderBinary") == 0)
3256 return reinterpret_cast<void*>(Mock_glShaderBinary);
3257 if (strcmp(name, "glShaderSource") == 0)
3258 return reinterpret_cast<void*>(Mock_glShaderSource);
3259 if (strcmp(name, "glStencilFillPathNV") == 0)
3260 return reinterpret_cast<void*>(Mock_glStencilFillPathNV);
3261 if (strcmp(name, "glStencilFunc") == 0)
3262 return reinterpret_cast<void*>(Mock_glStencilFunc);
3263 if (strcmp(name, "glStencilFuncSeparate") == 0)
3264 return reinterpret_cast<void*>(Mock_glStencilFuncSeparate);
3265 if (strcmp(name, "glStencilMask") == 0)
3266 return reinterpret_cast<void*>(Mock_glStencilMask);
3267 if (strcmp(name, "glStencilMaskSeparate") == 0)
3268 return reinterpret_cast<void*>(Mock_glStencilMaskSeparate);
3269 if (strcmp(name, "glStencilOp") == 0)
3270 return reinterpret_cast<void*>(Mock_glStencilOp);
3271 if (strcmp(name, "glStencilOpSeparate") == 0)
3272 return reinterpret_cast<void*>(Mock_glStencilOpSeparate);
3273 if (strcmp(name, "glStencilStrokePathNV") == 0)
3274 return reinterpret_cast<void*>(Mock_glStencilStrokePathNV);
3275 if (strcmp(name, "glStencilThenCoverFillPathNV") == 0)
3276 return reinterpret_cast<void*>(Mock_glStencilThenCoverFillPathNV);
3277 if (strcmp(name, "glStencilThenCoverStrokePathNV") == 0)
3278 return reinterpret_cast<void*>(Mock_glStencilThenCoverStrokePathNV);
3279 if (strcmp(name, "glTestFenceAPPLE") == 0)
3280 return reinterpret_cast<void*>(Mock_glTestFenceAPPLE);
3281 if (strcmp(name, "glTestFenceNV") == 0)
3282 return reinterpret_cast<void*>(Mock_glTestFenceNV);
3283 if (strcmp(name, "glTexImage2D") == 0)
3284 return reinterpret_cast<void*>(Mock_glTexImage2D);
3285 if (strcmp(name, "glTexImage3D") == 0)
3286 return reinterpret_cast<void*>(Mock_glTexImage3D);
3287 if (strcmp(name, "glTexParameterf") == 0)
3288 return reinterpret_cast<void*>(Mock_glTexParameterf);
3289 if (strcmp(name, "glTexParameterfv") == 0)
3290 return reinterpret_cast<void*>(Mock_glTexParameterfv);
3291 if (strcmp(name, "glTexParameteri") == 0)
3292 return reinterpret_cast<void*>(Mock_glTexParameteri);
3293 if (strcmp(name, "glTexParameteriv") == 0)
3294 return reinterpret_cast<void*>(Mock_glTexParameteriv);
3295 if (strcmp(name, "glTexStorage2D") == 0)
3296 return reinterpret_cast<void*>(Mock_glTexStorage2D);
3297 if (strcmp(name, "glTexStorage2DEXT") == 0)
3298 return reinterpret_cast<void*>(Mock_glTexStorage2DEXT);
3299 if (strcmp(name, "glTexStorage3D") == 0)
3300 return reinterpret_cast<void*>(Mock_glTexStorage3D);
3301 if (strcmp(name, "glTexSubImage2D") == 0)
3302 return reinterpret_cast<void*>(Mock_glTexSubImage2D);
3303 if (strcmp(name, "glTexSubImage3D") == 0)
3304 return reinterpret_cast<void*>(Mock_glTexSubImage3D);
3305 if (strcmp(name, "glTransformFeedbackVaryings") == 0)
3306 return reinterpret_cast<void*>(Mock_glTransformFeedbackVaryings);
3307 if (strcmp(name, "glUniform1f") == 0)
3308 return reinterpret_cast<void*>(Mock_glUniform1f);
3309 if (strcmp(name, "glUniform1fv") == 0)
3310 return reinterpret_cast<void*>(Mock_glUniform1fv);
3311 if (strcmp(name, "glUniform1i") == 0)
3312 return reinterpret_cast<void*>(Mock_glUniform1i);
3313 if (strcmp(name, "glUniform1iv") == 0)
3314 return reinterpret_cast<void*>(Mock_glUniform1iv);
3315 if (strcmp(name, "glUniform1ui") == 0)
3316 return reinterpret_cast<void*>(Mock_glUniform1ui);
3317 if (strcmp(name, "glUniform1uiv") == 0)
3318 return reinterpret_cast<void*>(Mock_glUniform1uiv);
3319 if (strcmp(name, "glUniform2f") == 0)
3320 return reinterpret_cast<void*>(Mock_glUniform2f);
3321 if (strcmp(name, "glUniform2fv") == 0)
3322 return reinterpret_cast<void*>(Mock_glUniform2fv);
3323 if (strcmp(name, "glUniform2i") == 0)
3324 return reinterpret_cast<void*>(Mock_glUniform2i);
3325 if (strcmp(name, "glUniform2iv") == 0)
3326 return reinterpret_cast<void*>(Mock_glUniform2iv);
3327 if (strcmp(name, "glUniform2ui") == 0)
3328 return reinterpret_cast<void*>(Mock_glUniform2ui);
3329 if (strcmp(name, "glUniform2uiv") == 0)
3330 return reinterpret_cast<void*>(Mock_glUniform2uiv);
3331 if (strcmp(name, "glUniform3f") == 0)
3332 return reinterpret_cast<void*>(Mock_glUniform3f);
3333 if (strcmp(name, "glUniform3fv") == 0)
3334 return reinterpret_cast<void*>(Mock_glUniform3fv);
3335 if (strcmp(name, "glUniform3i") == 0)
3336 return reinterpret_cast<void*>(Mock_glUniform3i);
3337 if (strcmp(name, "glUniform3iv") == 0)
3338 return reinterpret_cast<void*>(Mock_glUniform3iv);
3339 if (strcmp(name, "glUniform3ui") == 0)
3340 return reinterpret_cast<void*>(Mock_glUniform3ui);
3341 if (strcmp(name, "glUniform3uiv") == 0)
3342 return reinterpret_cast<void*>(Mock_glUniform3uiv);
3343 if (strcmp(name, "glUniform4f") == 0)
3344 return reinterpret_cast<void*>(Mock_glUniform4f);
3345 if (strcmp(name, "glUniform4fv") == 0)
3346 return reinterpret_cast<void*>(Mock_glUniform4fv);
3347 if (strcmp(name, "glUniform4i") == 0)
3348 return reinterpret_cast<void*>(Mock_glUniform4i);
3349 if (strcmp(name, "glUniform4iv") == 0)
3350 return reinterpret_cast<void*>(Mock_glUniform4iv);
3351 if (strcmp(name, "glUniform4ui") == 0)
3352 return reinterpret_cast<void*>(Mock_glUniform4ui);
3353 if (strcmp(name, "glUniform4uiv") == 0)
3354 return reinterpret_cast<void*>(Mock_glUniform4uiv);
3355 if (strcmp(name, "glUniformBlockBinding") == 0)
3356 return reinterpret_cast<void*>(Mock_glUniformBlockBinding);
3357 if (strcmp(name, "glUniformMatrix2fv") == 0)
3358 return reinterpret_cast<void*>(Mock_glUniformMatrix2fv);
3359 if (strcmp(name, "glUniformMatrix2x3fv") == 0)
3360 return reinterpret_cast<void*>(Mock_glUniformMatrix2x3fv);
3361 if (strcmp(name, "glUniformMatrix2x4fv") == 0)
3362 return reinterpret_cast<void*>(Mock_glUniformMatrix2x4fv);
3363 if (strcmp(name, "glUniformMatrix3fv") == 0)
3364 return reinterpret_cast<void*>(Mock_glUniformMatrix3fv);
3365 if (strcmp(name, "glUniformMatrix3x2fv") == 0)
3366 return reinterpret_cast<void*>(Mock_glUniformMatrix3x2fv);
3367 if (strcmp(name, "glUniformMatrix3x4fv") == 0)
3368 return reinterpret_cast<void*>(Mock_glUniformMatrix3x4fv);
3369 if (strcmp(name, "glUniformMatrix4fv") == 0)
3370 return reinterpret_cast<void*>(Mock_glUniformMatrix4fv);
3371 if (strcmp(name, "glUniformMatrix4x2fv") == 0)
3372 return reinterpret_cast<void*>(Mock_glUniformMatrix4x2fv);
3373 if (strcmp(name, "glUniformMatrix4x3fv") == 0)
3374 return reinterpret_cast<void*>(Mock_glUniformMatrix4x3fv);
3375 if (strcmp(name, "glUnmapBuffer") == 0)
3376 return reinterpret_cast<void*>(Mock_glUnmapBuffer);
3377 if (strcmp(name, "glUnmapBufferOES") == 0)
3378 return reinterpret_cast<void*>(Mock_glUnmapBufferOES);
3379 if (strcmp(name, "glUseProgram") == 0)
3380 return reinterpret_cast<void*>(Mock_glUseProgram);
3381 if (strcmp(name, "glValidateProgram") == 0)
3382 return reinterpret_cast<void*>(Mock_glValidateProgram);
3383 if (strcmp(name, "glVertexAttrib1f") == 0)
3384 return reinterpret_cast<void*>(Mock_glVertexAttrib1f);
3385 if (strcmp(name, "glVertexAttrib1fv") == 0)
3386 return reinterpret_cast<void*>(Mock_glVertexAttrib1fv);
3387 if (strcmp(name, "glVertexAttrib2f") == 0)
3388 return reinterpret_cast<void*>(Mock_glVertexAttrib2f);
3389 if (strcmp(name, "glVertexAttrib2fv") == 0)
3390 return reinterpret_cast<void*>(Mock_glVertexAttrib2fv);
3391 if (strcmp(name, "glVertexAttrib3f") == 0)
3392 return reinterpret_cast<void*>(Mock_glVertexAttrib3f);
3393 if (strcmp(name, "glVertexAttrib3fv") == 0)
3394 return reinterpret_cast<void*>(Mock_glVertexAttrib3fv);
3395 if (strcmp(name, "glVertexAttrib4f") == 0)
3396 return reinterpret_cast<void*>(Mock_glVertexAttrib4f);
3397 if (strcmp(name, "glVertexAttrib4fv") == 0)
3398 return reinterpret_cast<void*>(Mock_glVertexAttrib4fv);
3399 if (strcmp(name, "glVertexAttribDivisor") == 0)
3400 return reinterpret_cast<void*>(Mock_glVertexAttribDivisor);
3401 if (strcmp(name, "glVertexAttribDivisorANGLE") == 0)
3402 return reinterpret_cast<void*>(Mock_glVertexAttribDivisorANGLE);
3403 if (strcmp(name, "glVertexAttribDivisorARB") == 0)
3404 return reinterpret_cast<void*>(Mock_glVertexAttribDivisorARB);
3405 if (strcmp(name, "glVertexAttribI4i") == 0)
3406 return reinterpret_cast<void*>(Mock_glVertexAttribI4i);
3407 if (strcmp(name, "glVertexAttribI4iv") == 0)
3408 return reinterpret_cast<void*>(Mock_glVertexAttribI4iv);
3409 if (strcmp(name, "glVertexAttribI4ui") == 0)
3410 return reinterpret_cast<void*>(Mock_glVertexAttribI4ui);
3411 if (strcmp(name, "glVertexAttribI4uiv") == 0)
3412 return reinterpret_cast<void*>(Mock_glVertexAttribI4uiv);
3413 if (strcmp(name, "glVertexAttribIPointer") == 0)
3414 return reinterpret_cast<void*>(Mock_glVertexAttribIPointer);
3415 if (strcmp(name, "glVertexAttribPointer") == 0)
3416 return reinterpret_cast<void*>(Mock_glVertexAttribPointer);
3417 if (strcmp(name, "glViewport") == 0)
3418 return reinterpret_cast<void*>(Mock_glViewport);
3419 if (strcmp(name, "glWaitSync") == 0)
3420 return reinterpret_cast<void*>(Mock_glWaitSync);
3421 return reinterpret_cast<void*>(&MockInvalidFunction);
3422 }
3423
3424 } // namespace gfx