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