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