1 //
2 // Copyright 2019 The ANGLE Project Authors. All rights reserved.
3 // Use of this source code is governed by a BSD-style license that can be
4 // found in the LICENSE file.
5 //
6 // capture_gles2_params.cpp:
7 // Pointer parameter capture functions for the OpenGL ES 2.0 entry points.
8
9 #include "libANGLE/capture_gles_2_0_autogen.h"
10
11 #include "libANGLE/Context.h"
12 #include "libANGLE/Shader.h"
13 #include "libANGLE/formatutils.h"
14
15 using namespace angle;
16
17 namespace gl
18 {
19 // Parameter Captures
20
CaptureBindAttribLocation_name(const Context * context,bool isCallValid,GLuint program,GLuint index,const GLchar * name,ParamCapture * paramCapture)21 void CaptureBindAttribLocation_name(const Context *context,
22 bool isCallValid,
23 GLuint program,
24 GLuint index,
25 const GLchar *name,
26 ParamCapture *paramCapture)
27 {
28 CaptureString(name, paramCapture);
29 }
30
CaptureBufferData_data(const Context * context,bool isCallValid,BufferBinding targetPacked,GLsizeiptr size,const void * data,BufferUsage usagePacked,ParamCapture * paramCapture)31 void CaptureBufferData_data(const Context *context,
32 bool isCallValid,
33 BufferBinding targetPacked,
34 GLsizeiptr size,
35 const void *data,
36 BufferUsage usagePacked,
37 ParamCapture *paramCapture)
38 {
39 if (data)
40 {
41 CaptureMemory(data, size, paramCapture);
42 }
43 }
44
CaptureBufferSubData_data(const Context * context,bool isCallValid,BufferBinding targetPacked,GLintptr offset,GLsizeiptr size,const void * data,ParamCapture * paramCapture)45 void CaptureBufferSubData_data(const Context *context,
46 bool isCallValid,
47 BufferBinding targetPacked,
48 GLintptr offset,
49 GLsizeiptr size,
50 const void *data,
51 ParamCapture *paramCapture)
52 {
53 CaptureMemory(data, size, paramCapture);
54 }
55
CaptureCompressedTexImage2D_data(const Context * context,bool isCallValid,TextureTarget targetPacked,GLint level,GLenum internalformat,GLsizei width,GLsizei height,GLint border,GLsizei imageSize,const void * data,ParamCapture * paramCapture)56 void CaptureCompressedTexImage2D_data(const Context *context,
57 bool isCallValid,
58 TextureTarget targetPacked,
59 GLint level,
60 GLenum internalformat,
61 GLsizei width,
62 GLsizei height,
63 GLint border,
64 GLsizei imageSize,
65 const void *data,
66 ParamCapture *paramCapture)
67 {
68 if (context->getState().getTargetBuffer(gl::BufferBinding::PixelUnpack))
69 {
70 return;
71 }
72
73 if (!data)
74 {
75 return;
76 }
77
78 CaptureMemory(data, imageSize, paramCapture);
79 }
80
CaptureCompressedTexSubImage2D_data(const Context * context,bool isCallValid,TextureTarget targetPacked,GLint level,GLint xoffset,GLint yoffset,GLsizei width,GLsizei height,GLenum format,GLsizei imageSize,const void * data,ParamCapture * paramCapture)81 void CaptureCompressedTexSubImage2D_data(const Context *context,
82 bool isCallValid,
83 TextureTarget targetPacked,
84 GLint level,
85 GLint xoffset,
86 GLint yoffset,
87 GLsizei width,
88 GLsizei height,
89 GLenum format,
90 GLsizei imageSize,
91 const void *data,
92 ParamCapture *paramCapture)
93 {
94 UNIMPLEMENTED();
95 }
96
CaptureDeleteBuffers_buffersPacked(const Context * context,bool isCallValid,GLsizei n,const BufferID * buffers,ParamCapture * paramCapture)97 void CaptureDeleteBuffers_buffersPacked(const Context *context,
98 bool isCallValid,
99 GLsizei n,
100 const BufferID *buffers,
101 ParamCapture *paramCapture)
102 {
103 UNIMPLEMENTED();
104 }
105
CaptureDeleteFramebuffers_framebuffers(const Context * context,bool isCallValid,GLsizei n,const GLuint * framebuffers,ParamCapture * paramCapture)106 void CaptureDeleteFramebuffers_framebuffers(const Context *context,
107 bool isCallValid,
108 GLsizei n,
109 const GLuint *framebuffers,
110 ParamCapture *paramCapture)
111 {
112 UNIMPLEMENTED();
113 }
114
CaptureDeleteRenderbuffers_renderbuffersPacked(const Context * context,bool isCallValid,GLsizei n,const RenderbufferID * renderbuffers,ParamCapture * paramCapture)115 void CaptureDeleteRenderbuffers_renderbuffersPacked(const Context *context,
116 bool isCallValid,
117 GLsizei n,
118 const RenderbufferID *renderbuffers,
119 ParamCapture *paramCapture)
120 {
121 UNIMPLEMENTED();
122 }
123
CaptureDeleteTextures_texturesPacked(const Context * context,bool isCallValid,GLsizei n,const TextureID * textures,ParamCapture * paramCapture)124 void CaptureDeleteTextures_texturesPacked(const Context *context,
125 bool isCallValid,
126 GLsizei n,
127 const TextureID *textures,
128 ParamCapture *paramCapture)
129 {
130 CaptureMemory(textures, sizeof(GLuint) * n, paramCapture);
131 }
132
CaptureDrawElements_indices(const Context * context,bool isCallValid,PrimitiveMode modePacked,GLsizei count,DrawElementsType typePacked,const void * indices,ParamCapture * paramCapture)133 void CaptureDrawElements_indices(const Context *context,
134 bool isCallValid,
135 PrimitiveMode modePacked,
136 GLsizei count,
137 DrawElementsType typePacked,
138 const void *indices,
139 ParamCapture *paramCapture)
140 {
141 if (context->getState().getVertexArray()->getElementArrayBuffer())
142 {
143 paramCapture->value.voidConstPointerVal = indices;
144 }
145 else
146 {
147 GLuint typeSize = gl::GetDrawElementsTypeSize(typePacked);
148 CaptureMemory(indices, typeSize * count, paramCapture);
149 paramCapture->value.voidConstPointerVal = paramCapture->data[0].data();
150 }
151 }
152
CaptureGenBuffers_buffersPacked(const Context * context,bool isCallValid,GLsizei n,BufferID * buffers,ParamCapture * paramCapture)153 void CaptureGenBuffers_buffersPacked(const Context *context,
154 bool isCallValid,
155 GLsizei n,
156 BufferID *buffers,
157 ParamCapture *paramCapture)
158 {
159 paramCapture->readBufferSizeBytes = sizeof(GLuint) * n;
160 }
161
CaptureGenFramebuffers_framebuffers(const Context * context,bool isCallValid,GLsizei n,GLuint * framebuffers,ParamCapture * paramCapture)162 void CaptureGenFramebuffers_framebuffers(const Context *context,
163 bool isCallValid,
164 GLsizei n,
165 GLuint *framebuffers,
166 ParamCapture *paramCapture)
167 {
168 paramCapture->readBufferSizeBytes = sizeof(GLuint) * n;
169 }
170
CaptureGenRenderbuffers_renderbuffersPacked(const Context * context,bool isCallValid,GLsizei n,RenderbufferID * renderbuffers,ParamCapture * paramCapture)171 void CaptureGenRenderbuffers_renderbuffersPacked(const Context *context,
172 bool isCallValid,
173 GLsizei n,
174 RenderbufferID *renderbuffers,
175 ParamCapture *paramCapture)
176 {
177 paramCapture->readBufferSizeBytes = sizeof(RenderbufferID) * n;
178 }
179
CaptureGenTextures_texturesPacked(const Context * context,bool isCallValid,GLsizei n,TextureID * textures,ParamCapture * paramCapture)180 void CaptureGenTextures_texturesPacked(const Context *context,
181 bool isCallValid,
182 GLsizei n,
183 TextureID *textures,
184 ParamCapture *paramCapture)
185 {
186 paramCapture->readBufferSizeBytes = sizeof(GLuint) * n;
187 }
188
CaptureGetActiveAttrib_length(const Context * context,bool isCallValid,GLuint program,GLuint index,GLsizei bufSize,GLsizei * length,GLint * size,GLenum * type,GLchar * name,ParamCapture * paramCapture)189 void CaptureGetActiveAttrib_length(const Context *context,
190 bool isCallValid,
191 GLuint program,
192 GLuint index,
193 GLsizei bufSize,
194 GLsizei *length,
195 GLint *size,
196 GLenum *type,
197 GLchar *name,
198 ParamCapture *paramCapture)
199 {
200 UNIMPLEMENTED();
201 }
202
CaptureGetActiveAttrib_size(const Context * context,bool isCallValid,GLuint program,GLuint index,GLsizei bufSize,GLsizei * length,GLint * size,GLenum * type,GLchar * name,ParamCapture * paramCapture)203 void CaptureGetActiveAttrib_size(const Context *context,
204 bool isCallValid,
205 GLuint program,
206 GLuint index,
207 GLsizei bufSize,
208 GLsizei *length,
209 GLint *size,
210 GLenum *type,
211 GLchar *name,
212 ParamCapture *paramCapture)
213 {
214 UNIMPLEMENTED();
215 }
216
CaptureGetActiveAttrib_type(const Context * context,bool isCallValid,GLuint program,GLuint index,GLsizei bufSize,GLsizei * length,GLint * size,GLenum * type,GLchar * name,ParamCapture * paramCapture)217 void CaptureGetActiveAttrib_type(const Context *context,
218 bool isCallValid,
219 GLuint program,
220 GLuint index,
221 GLsizei bufSize,
222 GLsizei *length,
223 GLint *size,
224 GLenum *type,
225 GLchar *name,
226 ParamCapture *paramCapture)
227 {
228 UNIMPLEMENTED();
229 }
230
CaptureGetActiveAttrib_name(const Context * context,bool isCallValid,GLuint program,GLuint index,GLsizei bufSize,GLsizei * length,GLint * size,GLenum * type,GLchar * name,ParamCapture * paramCapture)231 void CaptureGetActiveAttrib_name(const Context *context,
232 bool isCallValid,
233 GLuint program,
234 GLuint index,
235 GLsizei bufSize,
236 GLsizei *length,
237 GLint *size,
238 GLenum *type,
239 GLchar *name,
240 ParamCapture *paramCapture)
241 {
242 UNIMPLEMENTED();
243 }
244
CaptureGetActiveUniform_length(const Context * context,bool isCallValid,GLuint program,GLuint index,GLsizei bufSize,GLsizei * length,GLint * size,GLenum * type,GLchar * name,ParamCapture * paramCapture)245 void CaptureGetActiveUniform_length(const Context *context,
246 bool isCallValid,
247 GLuint program,
248 GLuint index,
249 GLsizei bufSize,
250 GLsizei *length,
251 GLint *size,
252 GLenum *type,
253 GLchar *name,
254 ParamCapture *paramCapture)
255 {
256 UNIMPLEMENTED();
257 }
258
CaptureGetActiveUniform_size(const Context * context,bool isCallValid,GLuint program,GLuint index,GLsizei bufSize,GLsizei * length,GLint * size,GLenum * type,GLchar * name,ParamCapture * paramCapture)259 void CaptureGetActiveUniform_size(const Context *context,
260 bool isCallValid,
261 GLuint program,
262 GLuint index,
263 GLsizei bufSize,
264 GLsizei *length,
265 GLint *size,
266 GLenum *type,
267 GLchar *name,
268 ParamCapture *paramCapture)
269 {
270 UNIMPLEMENTED();
271 }
272
CaptureGetActiveUniform_type(const Context * context,bool isCallValid,GLuint program,GLuint index,GLsizei bufSize,GLsizei * length,GLint * size,GLenum * type,GLchar * name,ParamCapture * paramCapture)273 void CaptureGetActiveUniform_type(const Context *context,
274 bool isCallValid,
275 GLuint program,
276 GLuint index,
277 GLsizei bufSize,
278 GLsizei *length,
279 GLint *size,
280 GLenum *type,
281 GLchar *name,
282 ParamCapture *paramCapture)
283 {
284 UNIMPLEMENTED();
285 }
286
CaptureGetActiveUniform_name(const Context * context,bool isCallValid,GLuint program,GLuint index,GLsizei bufSize,GLsizei * length,GLint * size,GLenum * type,GLchar * name,ParamCapture * paramCapture)287 void CaptureGetActiveUniform_name(const Context *context,
288 bool isCallValid,
289 GLuint program,
290 GLuint index,
291 GLsizei bufSize,
292 GLsizei *length,
293 GLint *size,
294 GLenum *type,
295 GLchar *name,
296 ParamCapture *paramCapture)
297 {
298 UNIMPLEMENTED();
299 }
300
CaptureGetAttachedShaders_count(const Context * context,bool isCallValid,GLuint program,GLsizei maxCount,GLsizei * count,GLuint * shaders,ParamCapture * paramCapture)301 void CaptureGetAttachedShaders_count(const Context *context,
302 bool isCallValid,
303 GLuint program,
304 GLsizei maxCount,
305 GLsizei *count,
306 GLuint *shaders,
307 ParamCapture *paramCapture)
308 {
309 UNIMPLEMENTED();
310 }
311
CaptureGetAttachedShaders_shaders(const Context * context,bool isCallValid,GLuint program,GLsizei maxCount,GLsizei * count,GLuint * shaders,ParamCapture * paramCapture)312 void CaptureGetAttachedShaders_shaders(const Context *context,
313 bool isCallValid,
314 GLuint program,
315 GLsizei maxCount,
316 GLsizei *count,
317 GLuint *shaders,
318 ParamCapture *paramCapture)
319 {
320 UNIMPLEMENTED();
321 }
322
CaptureGetAttribLocation_name(const Context * context,bool isCallValid,GLuint program,const GLchar * name,ParamCapture * paramCapture)323 void CaptureGetAttribLocation_name(const Context *context,
324 bool isCallValid,
325 GLuint program,
326 const GLchar *name,
327 ParamCapture *paramCapture)
328 {
329 CaptureString(name, paramCapture);
330 }
331
CaptureGetBooleanv_data(const Context * context,bool isCallValid,GLenum pname,GLboolean * data,ParamCapture * paramCapture)332 void CaptureGetBooleanv_data(const Context *context,
333 bool isCallValid,
334 GLenum pname,
335 GLboolean *data,
336 ParamCapture *paramCapture)
337 {
338 GLenum type;
339 unsigned int numParams;
340 context->getQueryParameterInfo(pname, &type, &numParams);
341 paramCapture->readBufferSizeBytes = sizeof(GLboolean) * numParams;
342 }
343
CaptureGetBufferParameteriv_params(const Context * context,bool isCallValid,BufferBinding targetPacked,GLenum pname,GLint * params,ParamCapture * paramCapture)344 void CaptureGetBufferParameteriv_params(const Context *context,
345 bool isCallValid,
346 BufferBinding targetPacked,
347 GLenum pname,
348 GLint *params,
349 ParamCapture *paramCapture)
350 {
351 UNIMPLEMENTED();
352 }
353
CaptureGetFloatv_data(const Context * context,bool isCallValid,GLenum pname,GLfloat * data,ParamCapture * paramCapture)354 void CaptureGetFloatv_data(const Context *context,
355 bool isCallValid,
356 GLenum pname,
357 GLfloat *data,
358 ParamCapture *paramCapture)
359 {
360 UNIMPLEMENTED();
361 }
362
CaptureGetFramebufferAttachmentParameteriv_params(const Context * context,bool isCallValid,GLenum target,GLenum attachment,GLenum pname,GLint * params,ParamCapture * paramCapture)363 void CaptureGetFramebufferAttachmentParameteriv_params(const Context *context,
364 bool isCallValid,
365 GLenum target,
366 GLenum attachment,
367 GLenum pname,
368 GLint *params,
369 ParamCapture *paramCapture)
370 {
371 UNIMPLEMENTED();
372 }
373
CaptureGetIntegerv_data(const Context * context,bool isCallValid,GLenum pname,GLint * data,ParamCapture * paramCapture)374 void CaptureGetIntegerv_data(const Context *context,
375 bool isCallValid,
376 GLenum pname,
377 GLint *data,
378 ParamCapture *paramCapture)
379 {
380 GLenum type;
381 unsigned int numParams;
382 context->getQueryParameterInfo(pname, &type, &numParams);
383 paramCapture->readBufferSizeBytes = sizeof(GLint) * numParams;
384 }
385
CaptureGetProgramInfoLog_length(const Context * context,bool isCallValid,GLuint program,GLsizei bufSize,GLsizei * length,GLchar * infoLog,ParamCapture * paramCapture)386 void CaptureGetProgramInfoLog_length(const Context *context,
387 bool isCallValid,
388 GLuint program,
389 GLsizei bufSize,
390 GLsizei *length,
391 GLchar *infoLog,
392 ParamCapture *paramCapture)
393 {
394 paramCapture->readBufferSizeBytes = sizeof(GLsizei);
395 }
396
CaptureGetProgramInfoLog_infoLog(const Context * context,bool isCallValid,GLuint program,GLsizei bufSize,GLsizei * length,GLchar * infoLog,ParamCapture * paramCapture)397 void CaptureGetProgramInfoLog_infoLog(const Context *context,
398 bool isCallValid,
399 GLuint program,
400 GLsizei bufSize,
401 GLsizei *length,
402 GLchar *infoLog,
403 ParamCapture *paramCapture)
404 {
405 gl::Program *programObj = context->getProgramResolveLink(program);
406 ASSERT(programObj);
407 paramCapture->readBufferSizeBytes = programObj->getInfoLogLength() + 1;
408 }
409
CaptureGetProgramiv_params(const Context * context,bool isCallValid,GLuint program,GLenum pname,GLint * params,ParamCapture * paramCapture)410 void CaptureGetProgramiv_params(const Context *context,
411 bool isCallValid,
412 GLuint program,
413 GLenum pname,
414 GLint *params,
415 ParamCapture *paramCapture)
416 {
417 if (params)
418 {
419 paramCapture->readBufferSizeBytes = sizeof(GLint);
420 }
421 }
422
CaptureGetRenderbufferParameteriv_params(const Context * context,bool isCallValid,GLenum target,GLenum pname,GLint * params,ParamCapture * paramCapture)423 void CaptureGetRenderbufferParameteriv_params(const Context *context,
424 bool isCallValid,
425 GLenum target,
426 GLenum pname,
427 GLint *params,
428 ParamCapture *paramCapture)
429 {
430 UNIMPLEMENTED();
431 }
432
CaptureGetShaderInfoLog_length(const Context * context,bool isCallValid,GLuint shader,GLsizei bufSize,GLsizei * length,GLchar * infoLog,ParamCapture * paramCapture)433 void CaptureGetShaderInfoLog_length(const Context *context,
434 bool isCallValid,
435 GLuint shader,
436 GLsizei bufSize,
437 GLsizei *length,
438 GLchar *infoLog,
439 ParamCapture *paramCapture)
440 {
441 paramCapture->readBufferSizeBytes = sizeof(GLsizei);
442 }
443
CaptureGetShaderInfoLog_infoLog(const Context * context,bool isCallValid,GLuint shader,GLsizei bufSize,GLsizei * length,GLchar * infoLog,ParamCapture * paramCapture)444 void CaptureGetShaderInfoLog_infoLog(const Context *context,
445 bool isCallValid,
446 GLuint shader,
447 GLsizei bufSize,
448 GLsizei *length,
449 GLchar *infoLog,
450 ParamCapture *paramCapture)
451 {
452 gl::Shader *shaderObj = context->getShader(shader);
453 ASSERT(shaderObj);
454 paramCapture->readBufferSizeBytes = shaderObj->getInfoLogLength() + 1;
455 }
456
CaptureGetShaderPrecisionFormat_range(const Context * context,bool isCallValid,GLenum shadertype,GLenum precisiontype,GLint * range,GLint * precision,ParamCapture * paramCapture)457 void CaptureGetShaderPrecisionFormat_range(const Context *context,
458 bool isCallValid,
459 GLenum shadertype,
460 GLenum precisiontype,
461 GLint *range,
462 GLint *precision,
463 ParamCapture *paramCapture)
464 {
465 UNIMPLEMENTED();
466 }
467
CaptureGetShaderPrecisionFormat_precision(const Context * context,bool isCallValid,GLenum shadertype,GLenum precisiontype,GLint * range,GLint * precision,ParamCapture * paramCapture)468 void CaptureGetShaderPrecisionFormat_precision(const Context *context,
469 bool isCallValid,
470 GLenum shadertype,
471 GLenum precisiontype,
472 GLint *range,
473 GLint *precision,
474 ParamCapture *paramCapture)
475 {
476 UNIMPLEMENTED();
477 }
478
CaptureGetShaderSource_length(const Context * context,bool isCallValid,GLuint shader,GLsizei bufSize,GLsizei * length,GLchar * source,ParamCapture * paramCapture)479 void CaptureGetShaderSource_length(const Context *context,
480 bool isCallValid,
481 GLuint shader,
482 GLsizei bufSize,
483 GLsizei *length,
484 GLchar *source,
485 ParamCapture *paramCapture)
486 {
487 UNIMPLEMENTED();
488 }
489
CaptureGetShaderSource_source(const Context * context,bool isCallValid,GLuint shader,GLsizei bufSize,GLsizei * length,GLchar * source,ParamCapture * paramCapture)490 void CaptureGetShaderSource_source(const Context *context,
491 bool isCallValid,
492 GLuint shader,
493 GLsizei bufSize,
494 GLsizei *length,
495 GLchar *source,
496 ParamCapture *paramCapture)
497 {
498 UNIMPLEMENTED();
499 }
500
CaptureGetShaderiv_params(const Context * context,bool isCallValid,GLuint shader,GLenum pname,GLint * params,ParamCapture * paramCapture)501 void CaptureGetShaderiv_params(const Context *context,
502 bool isCallValid,
503 GLuint shader,
504 GLenum pname,
505 GLint *params,
506 ParamCapture *paramCapture)
507 {
508 if (params)
509 {
510 paramCapture->readBufferSizeBytes = sizeof(GLint);
511 }
512 }
513
CaptureGetTexParameterfv_params(const Context * context,bool isCallValid,TextureType targetPacked,GLenum pname,GLfloat * params,ParamCapture * paramCapture)514 void CaptureGetTexParameterfv_params(const Context *context,
515 bool isCallValid,
516 TextureType targetPacked,
517 GLenum pname,
518 GLfloat *params,
519 ParamCapture *paramCapture)
520 {
521 UNIMPLEMENTED();
522 }
523
CaptureGetTexParameteriv_params(const Context * context,bool isCallValid,TextureType targetPacked,GLenum pname,GLint * params,ParamCapture * paramCapture)524 void CaptureGetTexParameteriv_params(const Context *context,
525 bool isCallValid,
526 TextureType targetPacked,
527 GLenum pname,
528 GLint *params,
529 ParamCapture *paramCapture)
530 {
531 UNIMPLEMENTED();
532 }
533
CaptureGetUniformLocation_name(const Context * context,bool isCallValid,GLuint program,const GLchar * name,ParamCapture * paramCapture)534 void CaptureGetUniformLocation_name(const Context *context,
535 bool isCallValid,
536 GLuint program,
537 const GLchar *name,
538 ParamCapture *paramCapture)
539 {
540 CaptureString(name, paramCapture);
541 }
542
CaptureGetUniformfv_params(const Context * context,bool isCallValid,GLuint program,GLint location,GLfloat * params,ParamCapture * paramCapture)543 void CaptureGetUniformfv_params(const Context *context,
544 bool isCallValid,
545 GLuint program,
546 GLint location,
547 GLfloat *params,
548 ParamCapture *paramCapture)
549 {
550 UNIMPLEMENTED();
551 }
552
CaptureGetUniformiv_params(const Context * context,bool isCallValid,GLuint program,GLint location,GLint * params,ParamCapture * paramCapture)553 void CaptureGetUniformiv_params(const Context *context,
554 bool isCallValid,
555 GLuint program,
556 GLint location,
557 GLint *params,
558 ParamCapture *paramCapture)
559 {
560 UNIMPLEMENTED();
561 }
562
CaptureGetVertexAttribPointerv_pointer(const Context * context,bool isCallValid,GLuint index,GLenum pname,void ** pointer,ParamCapture * paramCapture)563 void CaptureGetVertexAttribPointerv_pointer(const Context *context,
564 bool isCallValid,
565 GLuint index,
566 GLenum pname,
567 void **pointer,
568 ParamCapture *paramCapture)
569 {
570 paramCapture->readBufferSizeBytes = sizeof(void *);
571 }
572
CaptureGetVertexAttribfv_params(const Context * context,bool isCallValid,GLuint index,GLenum pname,GLfloat * params,ParamCapture * paramCapture)573 void CaptureGetVertexAttribfv_params(const Context *context,
574 bool isCallValid,
575 GLuint index,
576 GLenum pname,
577 GLfloat *params,
578 ParamCapture *paramCapture)
579 {
580 // Can be up to 4 current state values.
581 paramCapture->readBufferSizeBytes = sizeof(GLfloat) * 4;
582 }
583
CaptureGetVertexAttribiv_params(const Context * context,bool isCallValid,GLuint index,GLenum pname,GLint * params,ParamCapture * paramCapture)584 void CaptureGetVertexAttribiv_params(const Context *context,
585 bool isCallValid,
586 GLuint index,
587 GLenum pname,
588 GLint *params,
589 ParamCapture *paramCapture)
590 {
591 // Can be up to 4 current state values.
592 paramCapture->readBufferSizeBytes = sizeof(GLint) * 4;
593 }
594
CaptureReadPixels_pixels(const Context * context,bool isCallValid,GLint x,GLint y,GLsizei width,GLsizei height,GLenum format,GLenum type,void * pixels,ParamCapture * paramCapture)595 void CaptureReadPixels_pixels(const Context *context,
596 bool isCallValid,
597 GLint x,
598 GLint y,
599 GLsizei width,
600 GLsizei height,
601 GLenum format,
602 GLenum type,
603 void *pixels,
604 ParamCapture *paramCapture)
605 {
606 // Use a conservative upper bound instead of an exact size to be simple.
607 static constexpr GLsizei kMaxPixelSize = 32;
608 paramCapture->readBufferSizeBytes = kMaxPixelSize * width * height;
609 }
610
CaptureShaderBinary_shaders(const Context * context,bool isCallValid,GLsizei count,const GLuint * shaders,GLenum binaryformat,const void * binary,GLsizei length,ParamCapture * paramCapture)611 void CaptureShaderBinary_shaders(const Context *context,
612 bool isCallValid,
613 GLsizei count,
614 const GLuint *shaders,
615 GLenum binaryformat,
616 const void *binary,
617 GLsizei length,
618 ParamCapture *paramCapture)
619 {
620 UNIMPLEMENTED();
621 }
622
CaptureShaderBinary_binary(const Context * context,bool isCallValid,GLsizei count,const GLuint * shaders,GLenum binaryformat,const void * binary,GLsizei length,ParamCapture * paramCapture)623 void CaptureShaderBinary_binary(const Context *context,
624 bool isCallValid,
625 GLsizei count,
626 const GLuint *shaders,
627 GLenum binaryformat,
628 const void *binary,
629 GLsizei length,
630 ParamCapture *paramCapture)
631 {
632 UNIMPLEMENTED();
633 }
634
CaptureShaderSource_string(const Context * context,bool isCallValid,GLuint shader,GLsizei count,const GLchar * const * string,const GLint * length,ParamCapture * paramCapture)635 void CaptureShaderSource_string(const Context *context,
636 bool isCallValid,
637 GLuint shader,
638 GLsizei count,
639 const GLchar *const *string,
640 const GLint *length,
641 ParamCapture *paramCapture)
642 {
643 for (GLsizei index = 0; index < count; ++index)
644 {
645 size_t len = length ? length[index] : strlen(string[index]);
646 CaptureMemory(string[index], len, paramCapture);
647 }
648 }
649
CaptureShaderSource_length(const Context * context,bool isCallValid,GLuint shader,GLsizei count,const GLchar * const * string,const GLint * length,ParamCapture * paramCapture)650 void CaptureShaderSource_length(const Context *context,
651 bool isCallValid,
652 GLuint shader,
653 GLsizei count,
654 const GLchar *const *string,
655 const GLint *length,
656 ParamCapture *paramCapture)
657 {
658 if (!length)
659 return;
660
661 for (GLsizei index = 0; index < count; ++index)
662 {
663 CaptureMemory(&length[index], sizeof(GLint), paramCapture);
664 }
665 }
666
CaptureTexImage2D_pixels(const Context * context,bool isCallValid,TextureTarget targetPacked,GLint level,GLint internalformat,GLsizei width,GLsizei height,GLint border,GLenum format,GLenum type,const void * pixels,ParamCapture * paramCapture)667 void CaptureTexImage2D_pixels(const Context *context,
668 bool isCallValid,
669 TextureTarget targetPacked,
670 GLint level,
671 GLint internalformat,
672 GLsizei width,
673 GLsizei height,
674 GLint border,
675 GLenum format,
676 GLenum type,
677 const void *pixels,
678 ParamCapture *paramCapture)
679 {
680 if (context->getState().getTargetBuffer(gl::BufferBinding::PixelUnpack))
681 {
682 return;
683 }
684
685 if (!pixels)
686 {
687 return;
688 }
689
690 const gl::InternalFormat &internalFormatInfo = gl::GetInternalFormatInfo(format, type);
691 const gl::PixelUnpackState &unpack = context->getState().getUnpackState();
692
693 GLuint srcRowPitch = 0;
694 (void)internalFormatInfo.computeRowPitch(type, width, unpack.alignment, unpack.rowLength,
695 &srcRowPitch);
696 GLuint srcDepthPitch = 0;
697 (void)internalFormatInfo.computeDepthPitch(height, unpack.imageHeight, srcRowPitch,
698 &srcDepthPitch);
699 GLuint srcSkipBytes = 0;
700 (void)internalFormatInfo.computeSkipBytes(type, srcRowPitch, srcDepthPitch, unpack, false,
701 &srcSkipBytes);
702
703 size_t captureSize = srcRowPitch * height + srcSkipBytes;
704 CaptureMemory(pixels, captureSize, paramCapture);
705 }
706
CaptureTexParameterfv_params(const Context * context,bool isCallValid,TextureType targetPacked,GLenum pname,const GLfloat * params,ParamCapture * paramCapture)707 void CaptureTexParameterfv_params(const Context *context,
708 bool isCallValid,
709 TextureType targetPacked,
710 GLenum pname,
711 const GLfloat *params,
712 ParamCapture *paramCapture)
713 {
714 UNIMPLEMENTED();
715 }
716
CaptureTexParameteriv_params(const Context * context,bool isCallValid,TextureType targetPacked,GLenum pname,const GLint * params,ParamCapture * paramCapture)717 void CaptureTexParameteriv_params(const Context *context,
718 bool isCallValid,
719 TextureType targetPacked,
720 GLenum pname,
721 const GLint *params,
722 ParamCapture *paramCapture)
723 {
724 UNIMPLEMENTED();
725 }
726
CaptureTexSubImage2D_pixels(const Context * context,bool isCallValid,TextureTarget targetPacked,GLint level,GLint xoffset,GLint yoffset,GLsizei width,GLsizei height,GLenum format,GLenum type,const void * pixels,ParamCapture * paramCapture)727 void CaptureTexSubImage2D_pixels(const Context *context,
728 bool isCallValid,
729 TextureTarget targetPacked,
730 GLint level,
731 GLint xoffset,
732 GLint yoffset,
733 GLsizei width,
734 GLsizei height,
735 GLenum format,
736 GLenum type,
737 const void *pixels,
738 ParamCapture *paramCapture)
739 {
740 UNIMPLEMENTED();
741 }
742
CaptureUniform1fv_value(const Context * context,bool isCallValid,GLint location,GLsizei count,const GLfloat * value,ParamCapture * paramCapture)743 void CaptureUniform1fv_value(const Context *context,
744 bool isCallValid,
745 GLint location,
746 GLsizei count,
747 const GLfloat *value,
748 ParamCapture *paramCapture)
749 {
750 CaptureMemory(value, count * sizeof(GLfloat), paramCapture);
751 }
752
CaptureUniform1iv_value(const Context * context,bool isCallValid,GLint location,GLsizei count,const GLint * value,ParamCapture * paramCapture)753 void CaptureUniform1iv_value(const Context *context,
754 bool isCallValid,
755 GLint location,
756 GLsizei count,
757 const GLint *value,
758 ParamCapture *paramCapture)
759 {
760 CaptureMemory(value, count * sizeof(GLint), paramCapture);
761 }
762
CaptureUniform2fv_value(const Context * context,bool isCallValid,GLint location,GLsizei count,const GLfloat * value,ParamCapture * paramCapture)763 void CaptureUniform2fv_value(const Context *context,
764 bool isCallValid,
765 GLint location,
766 GLsizei count,
767 const GLfloat *value,
768 ParamCapture *paramCapture)
769 {
770 CaptureMemory(value, count * sizeof(GLfloat) * 2, paramCapture);
771 }
772
CaptureUniform2iv_value(const Context * context,bool isCallValid,GLint location,GLsizei count,const GLint * value,ParamCapture * paramCapture)773 void CaptureUniform2iv_value(const Context *context,
774 bool isCallValid,
775 GLint location,
776 GLsizei count,
777 const GLint *value,
778 ParamCapture *paramCapture)
779 {
780 CaptureMemory(value, count * sizeof(GLint) * 2, paramCapture);
781 }
782
CaptureUniform3fv_value(const Context * context,bool isCallValid,GLint location,GLsizei count,const GLfloat * value,ParamCapture * paramCapture)783 void CaptureUniform3fv_value(const Context *context,
784 bool isCallValid,
785 GLint location,
786 GLsizei count,
787 const GLfloat *value,
788 ParamCapture *paramCapture)
789 {
790 CaptureMemory(value, count * sizeof(GLfloat) * 3, paramCapture);
791 }
792
CaptureUniform3iv_value(const Context * context,bool isCallValid,GLint location,GLsizei count,const GLint * value,ParamCapture * paramCapture)793 void CaptureUniform3iv_value(const Context *context,
794 bool isCallValid,
795 GLint location,
796 GLsizei count,
797 const GLint *value,
798 ParamCapture *paramCapture)
799 {
800 CaptureMemory(value, count * sizeof(GLint) * 3, paramCapture);
801 }
802
CaptureUniform4fv_value(const Context * context,bool isCallValid,GLint location,GLsizei count,const GLfloat * value,ParamCapture * paramCapture)803 void CaptureUniform4fv_value(const Context *context,
804 bool isCallValid,
805 GLint location,
806 GLsizei count,
807 const GLfloat *value,
808 ParamCapture *paramCapture)
809 {
810 CaptureMemory(value, count * sizeof(GLfloat) * 4, paramCapture);
811 }
812
CaptureUniform4iv_value(const Context * context,bool isCallValid,GLint location,GLsizei count,const GLint * value,ParamCapture * paramCapture)813 void CaptureUniform4iv_value(const Context *context,
814 bool isCallValid,
815 GLint location,
816 GLsizei count,
817 const GLint *value,
818 ParamCapture *paramCapture)
819 {
820 CaptureMemory(value, count * sizeof(GLint) * 4, paramCapture);
821 }
822
CaptureUniformMatrix2fv_value(const Context * context,bool isCallValid,GLint location,GLsizei count,GLboolean transpose,const GLfloat * value,ParamCapture * paramCapture)823 void CaptureUniformMatrix2fv_value(const Context *context,
824 bool isCallValid,
825 GLint location,
826 GLsizei count,
827 GLboolean transpose,
828 const GLfloat *value,
829 ParamCapture *paramCapture)
830 {
831 CaptureMemory(value, count * sizeof(GLfloat) * 4, paramCapture);
832 }
833
CaptureUniformMatrix3fv_value(const Context * context,bool isCallValid,GLint location,GLsizei count,GLboolean transpose,const GLfloat * value,ParamCapture * paramCapture)834 void CaptureUniformMatrix3fv_value(const Context *context,
835 bool isCallValid,
836 GLint location,
837 GLsizei count,
838 GLboolean transpose,
839 const GLfloat *value,
840 ParamCapture *paramCapture)
841 {
842 CaptureMemory(value, count * sizeof(GLfloat) * 9, paramCapture);
843 }
844
CaptureUniformMatrix4fv_value(const Context * context,bool isCallValid,GLint location,GLsizei count,GLboolean transpose,const GLfloat * value,ParamCapture * paramCapture)845 void CaptureUniformMatrix4fv_value(const Context *context,
846 bool isCallValid,
847 GLint location,
848 GLsizei count,
849 GLboolean transpose,
850 const GLfloat *value,
851 ParamCapture *paramCapture)
852 {
853 CaptureMemory(value, count * sizeof(GLfloat) * 16, paramCapture);
854 }
855
CaptureVertexAttrib1fv_v(const Context * context,bool isCallValid,GLuint index,const GLfloat * v,ParamCapture * paramCapture)856 void CaptureVertexAttrib1fv_v(const Context *context,
857 bool isCallValid,
858 GLuint index,
859 const GLfloat *v,
860 ParamCapture *paramCapture)
861 {
862 UNIMPLEMENTED();
863 }
864
CaptureVertexAttrib2fv_v(const Context * context,bool isCallValid,GLuint index,const GLfloat * v,ParamCapture * paramCapture)865 void CaptureVertexAttrib2fv_v(const Context *context,
866 bool isCallValid,
867 GLuint index,
868 const GLfloat *v,
869 ParamCapture *paramCapture)
870 {
871 UNIMPLEMENTED();
872 }
873
CaptureVertexAttrib3fv_v(const Context * context,bool isCallValid,GLuint index,const GLfloat * v,ParamCapture * paramCapture)874 void CaptureVertexAttrib3fv_v(const Context *context,
875 bool isCallValid,
876 GLuint index,
877 const GLfloat *v,
878 ParamCapture *paramCapture)
879 {
880 UNIMPLEMENTED();
881 }
882
CaptureVertexAttrib4fv_v(const Context * context,bool isCallValid,GLuint index,const GLfloat * v,ParamCapture * paramCapture)883 void CaptureVertexAttrib4fv_v(const Context *context,
884 bool isCallValid,
885 GLuint index,
886 const GLfloat *v,
887 ParamCapture *paramCapture)
888 {
889 UNIMPLEMENTED();
890 }
891
CaptureVertexAttribPointer_pointer(const Context * context,bool isCallValid,GLuint index,GLint size,VertexAttribType typePacked,GLboolean normalized,GLsizei stride,const void * pointer,ParamCapture * paramCapture)892 void CaptureVertexAttribPointer_pointer(const Context *context,
893 bool isCallValid,
894 GLuint index,
895 GLint size,
896 VertexAttribType typePacked,
897 GLboolean normalized,
898 GLsizei stride,
899 const void *pointer,
900 ParamCapture *paramCapture)
901 {
902 paramCapture->value.voidConstPointerVal = pointer;
903 if (!context->getState().getTargetBuffer(gl::BufferBinding::Array))
904 {
905 paramCapture->arrayClientPointerIndex = index;
906 }
907 }
908 } // namespace gl
909