1 // GENERATED FILE - DO NOT EDIT.
2 // Generated by generate_entry_points.py using data from gl.xml and gl_angle_ext.xml.
3 //
4 // Copyright 2020 The ANGLE Project Authors. All rights reserved.
5 // Use of this source code is governed by a BSD-style license that can be
6 // found in the LICENSE file.
7 //
8 // capture_gles_3_2_autogen.cpp:
9 // Capture functions for the OpenGL ES 3.2 entry points.
10
11 #include "libANGLE/capture_gles_3_2_autogen.h"
12
13 #include "libANGLE/Context.h"
14 #include "libANGLE/FrameCapture.h"
15 #include "libANGLE/gl_enum_utils.h"
16 #include "libANGLE/validationES32.h"
17
18 using namespace angle;
19
20 namespace gl
21 {
22
CaptureBlendBarrier(const State & glState,bool isCallValid)23 CallCapture CaptureBlendBarrier(const State &glState, bool isCallValid)
24 {
25 ParamBuffer paramBuffer;
26
27 return CallCapture(gl::EntryPoint::BlendBarrier, std::move(paramBuffer));
28 }
29
CaptureBlendEquationSeparatei(const State & glState,bool isCallValid,GLuint buf,GLenum modeRGB,GLenum modeAlpha)30 CallCapture CaptureBlendEquationSeparatei(const State &glState,
31 bool isCallValid,
32 GLuint buf,
33 GLenum modeRGB,
34 GLenum modeAlpha)
35 {
36 ParamBuffer paramBuffer;
37
38 paramBuffer.addValueParam("buf", ParamType::TGLuint, buf);
39 paramBuffer.addEnumParam("modeRGB", GLenumGroup::BlendEquationModeEXT, ParamType::TGLenum,
40 modeRGB);
41 paramBuffer.addEnumParam("modeAlpha", GLenumGroup::BlendEquationModeEXT, ParamType::TGLenum,
42 modeAlpha);
43
44 return CallCapture(gl::EntryPoint::BlendEquationSeparatei, std::move(paramBuffer));
45 }
46
CaptureBlendEquationi(const State & glState,bool isCallValid,GLuint buf,GLenum mode)47 CallCapture CaptureBlendEquationi(const State &glState, bool isCallValid, GLuint buf, GLenum mode)
48 {
49 ParamBuffer paramBuffer;
50
51 paramBuffer.addValueParam("buf", ParamType::TGLuint, buf);
52 paramBuffer.addEnumParam("mode", GLenumGroup::BlendEquationModeEXT, ParamType::TGLenum, mode);
53
54 return CallCapture(gl::EntryPoint::BlendEquationi, std::move(paramBuffer));
55 }
56
CaptureBlendFuncSeparatei(const State & glState,bool isCallValid,GLuint buf,GLenum srcRGB,GLenum dstRGB,GLenum srcAlpha,GLenum dstAlpha)57 CallCapture CaptureBlendFuncSeparatei(const State &glState,
58 bool isCallValid,
59 GLuint buf,
60 GLenum srcRGB,
61 GLenum dstRGB,
62 GLenum srcAlpha,
63 GLenum dstAlpha)
64 {
65 ParamBuffer paramBuffer;
66
67 paramBuffer.addValueParam("buf", ParamType::TGLuint, buf);
68 paramBuffer.addEnumParam("srcRGB", GLenumGroup::BlendingFactor, ParamType::TGLenum, srcRGB);
69 paramBuffer.addEnumParam("dstRGB", GLenumGroup::BlendingFactor, ParamType::TGLenum, dstRGB);
70 paramBuffer.addEnumParam("srcAlpha", GLenumGroup::BlendingFactor, ParamType::TGLenum, srcAlpha);
71 paramBuffer.addEnumParam("dstAlpha", GLenumGroup::BlendingFactor, ParamType::TGLenum, dstAlpha);
72
73 return CallCapture(gl::EntryPoint::BlendFuncSeparatei, std::move(paramBuffer));
74 }
75
CaptureBlendFunci(const State & glState,bool isCallValid,GLuint buf,GLenum src,GLenum dst)76 CallCapture CaptureBlendFunci(const State &glState,
77 bool isCallValid,
78 GLuint buf,
79 GLenum src,
80 GLenum dst)
81 {
82 ParamBuffer paramBuffer;
83
84 paramBuffer.addValueParam("buf", ParamType::TGLuint, buf);
85 paramBuffer.addEnumParam("src", GLenumGroup::BlendingFactor, ParamType::TGLenum, src);
86 paramBuffer.addEnumParam("dst", GLenumGroup::BlendingFactor, ParamType::TGLenum, dst);
87
88 return CallCapture(gl::EntryPoint::BlendFunci, std::move(paramBuffer));
89 }
90
CaptureColorMaski(const State & glState,bool isCallValid,GLuint index,GLboolean r,GLboolean g,GLboolean b,GLboolean a)91 CallCapture CaptureColorMaski(const State &glState,
92 bool isCallValid,
93 GLuint index,
94 GLboolean r,
95 GLboolean g,
96 GLboolean b,
97 GLboolean a)
98 {
99 ParamBuffer paramBuffer;
100
101 paramBuffer.addValueParam("index", ParamType::TGLuint, index);
102 paramBuffer.addValueParam("r", ParamType::TGLboolean, r);
103 paramBuffer.addValueParam("g", ParamType::TGLboolean, g);
104 paramBuffer.addValueParam("b", ParamType::TGLboolean, b);
105 paramBuffer.addValueParam("a", ParamType::TGLboolean, a);
106
107 return CallCapture(gl::EntryPoint::ColorMaski, std::move(paramBuffer));
108 }
109
CaptureCopyImageSubData(const State & glState,bool isCallValid,GLuint srcName,GLenum srcTarget,GLint srcLevel,GLint srcX,GLint srcY,GLint srcZ,GLuint dstName,GLenum dstTarget,GLint dstLevel,GLint dstX,GLint dstY,GLint dstZ,GLsizei srcWidth,GLsizei srcHeight,GLsizei srcDepth)110 CallCapture CaptureCopyImageSubData(const State &glState,
111 bool isCallValid,
112 GLuint srcName,
113 GLenum srcTarget,
114 GLint srcLevel,
115 GLint srcX,
116 GLint srcY,
117 GLint srcZ,
118 GLuint dstName,
119 GLenum dstTarget,
120 GLint dstLevel,
121 GLint dstX,
122 GLint dstY,
123 GLint dstZ,
124 GLsizei srcWidth,
125 GLsizei srcHeight,
126 GLsizei srcDepth)
127 {
128 ParamBuffer paramBuffer;
129
130 paramBuffer.addValueParam("srcName", ParamType::TGLuint, srcName);
131 paramBuffer.addEnumParam("srcTarget", GLenumGroup::CopyBufferSubDataTarget, ParamType::TGLenum,
132 srcTarget);
133 paramBuffer.addValueParam("srcLevel", ParamType::TGLint, srcLevel);
134 paramBuffer.addValueParam("srcX", ParamType::TGLint, srcX);
135 paramBuffer.addValueParam("srcY", ParamType::TGLint, srcY);
136 paramBuffer.addValueParam("srcZ", ParamType::TGLint, srcZ);
137 paramBuffer.addValueParam("dstName", ParamType::TGLuint, dstName);
138 paramBuffer.addEnumParam("dstTarget", GLenumGroup::CopyBufferSubDataTarget, ParamType::TGLenum,
139 dstTarget);
140 paramBuffer.addValueParam("dstLevel", ParamType::TGLint, dstLevel);
141 paramBuffer.addValueParam("dstX", ParamType::TGLint, dstX);
142 paramBuffer.addValueParam("dstY", ParamType::TGLint, dstY);
143 paramBuffer.addValueParam("dstZ", ParamType::TGLint, dstZ);
144 paramBuffer.addValueParam("srcWidth", ParamType::TGLsizei, srcWidth);
145 paramBuffer.addValueParam("srcHeight", ParamType::TGLsizei, srcHeight);
146 paramBuffer.addValueParam("srcDepth", ParamType::TGLsizei, srcDepth);
147
148 return CallCapture(gl::EntryPoint::CopyImageSubData, std::move(paramBuffer));
149 }
150
CaptureDebugMessageCallback(const State & glState,bool isCallValid,GLDEBUGPROC callback,const void * userParam)151 CallCapture CaptureDebugMessageCallback(const State &glState,
152 bool isCallValid,
153 GLDEBUGPROC callback,
154 const void *userParam)
155 {
156 ParamBuffer paramBuffer;
157
158 paramBuffer.addValueParam("callback", ParamType::TGLDEBUGPROC, callback);
159
160 ParamCapture userParamParam("userParam", ParamType::TvoidConstPointer);
161 InitParamValue(ParamType::TvoidConstPointer, userParam, &userParamParam.value);
162 CaptureDebugMessageCallback_userParam(glState, isCallValid, callback, userParam,
163 &userParamParam);
164 paramBuffer.addParam(std::move(userParamParam));
165
166 return CallCapture(gl::EntryPoint::DebugMessageCallback, std::move(paramBuffer));
167 }
168
CaptureDebugMessageControl(const State & glState,bool isCallValid,GLenum source,GLenum type,GLenum severity,GLsizei count,const GLuint * ids,GLboolean enabled)169 CallCapture CaptureDebugMessageControl(const State &glState,
170 bool isCallValid,
171 GLenum source,
172 GLenum type,
173 GLenum severity,
174 GLsizei count,
175 const GLuint *ids,
176 GLboolean enabled)
177 {
178 ParamBuffer paramBuffer;
179
180 paramBuffer.addEnumParam("source", GLenumGroup::DebugSource, ParamType::TGLenum, source);
181 paramBuffer.addEnumParam("type", GLenumGroup::DebugType, ParamType::TGLenum, type);
182 paramBuffer.addEnumParam("severity", GLenumGroup::DebugSeverity, ParamType::TGLenum, severity);
183 paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
184
185 ParamCapture idsParam("ids", ParamType::TGLuintConstPointer);
186 InitParamValue(ParamType::TGLuintConstPointer, ids, &idsParam.value);
187 CaptureDebugMessageControl_ids(glState, isCallValid, source, type, severity, count, ids,
188 enabled, &idsParam);
189 paramBuffer.addParam(std::move(idsParam));
190
191 paramBuffer.addValueParam("enabled", ParamType::TGLboolean, enabled);
192
193 return CallCapture(gl::EntryPoint::DebugMessageControl, std::move(paramBuffer));
194 }
195
CaptureDebugMessageInsert(const State & glState,bool isCallValid,GLenum source,GLenum type,GLuint id,GLenum severity,GLsizei length,const GLchar * buf)196 CallCapture CaptureDebugMessageInsert(const State &glState,
197 bool isCallValid,
198 GLenum source,
199 GLenum type,
200 GLuint id,
201 GLenum severity,
202 GLsizei length,
203 const GLchar *buf)
204 {
205 ParamBuffer paramBuffer;
206
207 paramBuffer.addEnumParam("source", GLenumGroup::DebugSource, ParamType::TGLenum, source);
208 paramBuffer.addEnumParam("type", GLenumGroup::DebugType, ParamType::TGLenum, type);
209 paramBuffer.addValueParam("id", ParamType::TGLuint, id);
210 paramBuffer.addEnumParam("severity", GLenumGroup::DebugSeverity, ParamType::TGLenum, severity);
211 paramBuffer.addValueParam("length", ParamType::TGLsizei, length);
212
213 ParamCapture bufParam("buf", ParamType::TGLcharConstPointer);
214 InitParamValue(ParamType::TGLcharConstPointer, buf, &bufParam.value);
215 CaptureDebugMessageInsert_buf(glState, isCallValid, source, type, id, severity, length, buf,
216 &bufParam);
217 paramBuffer.addParam(std::move(bufParam));
218
219 return CallCapture(gl::EntryPoint::DebugMessageInsert, std::move(paramBuffer));
220 }
221
CaptureDisablei(const State & glState,bool isCallValid,GLenum target,GLuint index)222 CallCapture CaptureDisablei(const State &glState, bool isCallValid, GLenum target, GLuint index)
223 {
224 ParamBuffer paramBuffer;
225
226 paramBuffer.addEnumParam("target", GLenumGroup::EnableCap, ParamType::TGLenum, target);
227 paramBuffer.addValueParam("index", ParamType::TGLuint, index);
228
229 return CallCapture(gl::EntryPoint::Disablei, std::move(paramBuffer));
230 }
231
CaptureDrawElementsBaseVertex(const State & glState,bool isCallValid,PrimitiveMode modePacked,GLsizei count,DrawElementsType typePacked,const void * indices,GLint basevertex)232 CallCapture CaptureDrawElementsBaseVertex(const State &glState,
233 bool isCallValid,
234 PrimitiveMode modePacked,
235 GLsizei count,
236 DrawElementsType typePacked,
237 const void *indices,
238 GLint basevertex)
239 {
240 ParamBuffer paramBuffer;
241
242 paramBuffer.addValueParam("modePacked", ParamType::TPrimitiveMode, modePacked);
243 paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
244 paramBuffer.addValueParam("typePacked", ParamType::TDrawElementsType, typePacked);
245
246 ParamCapture indicesParam("indices", ParamType::TvoidConstPointer);
247 InitParamValue(ParamType::TvoidConstPointer, indices, &indicesParam.value);
248 CaptureDrawElementsBaseVertex_indices(glState, isCallValid, modePacked, count, typePacked,
249 indices, basevertex, &indicesParam);
250 paramBuffer.addParam(std::move(indicesParam));
251
252 paramBuffer.addValueParam("basevertex", ParamType::TGLint, basevertex);
253
254 return CallCapture(gl::EntryPoint::DrawElementsBaseVertex, std::move(paramBuffer));
255 }
256
CaptureDrawElementsInstancedBaseVertex(const State & glState,bool isCallValid,PrimitiveMode modePacked,GLsizei count,DrawElementsType typePacked,const void * indices,GLsizei instancecount,GLint basevertex)257 CallCapture CaptureDrawElementsInstancedBaseVertex(const State &glState,
258 bool isCallValid,
259 PrimitiveMode modePacked,
260 GLsizei count,
261 DrawElementsType typePacked,
262 const void *indices,
263 GLsizei instancecount,
264 GLint basevertex)
265 {
266 ParamBuffer paramBuffer;
267
268 paramBuffer.addValueParam("modePacked", ParamType::TPrimitiveMode, modePacked);
269 paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
270 paramBuffer.addValueParam("typePacked", ParamType::TDrawElementsType, typePacked);
271
272 ParamCapture indicesParam("indices", ParamType::TvoidConstPointer);
273 InitParamValue(ParamType::TvoidConstPointer, indices, &indicesParam.value);
274 CaptureDrawElementsInstancedBaseVertex_indices(glState, isCallValid, modePacked, count,
275 typePacked, indices, instancecount, basevertex,
276 &indicesParam);
277 paramBuffer.addParam(std::move(indicesParam));
278
279 paramBuffer.addValueParam("instancecount", ParamType::TGLsizei, instancecount);
280 paramBuffer.addValueParam("basevertex", ParamType::TGLint, basevertex);
281
282 return CallCapture(gl::EntryPoint::DrawElementsInstancedBaseVertex, std::move(paramBuffer));
283 }
284
CaptureDrawRangeElementsBaseVertex(const State & glState,bool isCallValid,PrimitiveMode modePacked,GLuint start,GLuint end,GLsizei count,DrawElementsType typePacked,const void * indices,GLint basevertex)285 CallCapture CaptureDrawRangeElementsBaseVertex(const State &glState,
286 bool isCallValid,
287 PrimitiveMode modePacked,
288 GLuint start,
289 GLuint end,
290 GLsizei count,
291 DrawElementsType typePacked,
292 const void *indices,
293 GLint basevertex)
294 {
295 ParamBuffer paramBuffer;
296
297 paramBuffer.addValueParam("modePacked", ParamType::TPrimitiveMode, modePacked);
298 paramBuffer.addValueParam("start", ParamType::TGLuint, start);
299 paramBuffer.addValueParam("end", ParamType::TGLuint, end);
300 paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
301 paramBuffer.addValueParam("typePacked", ParamType::TDrawElementsType, typePacked);
302
303 ParamCapture indicesParam("indices", ParamType::TvoidConstPointer);
304 InitParamValue(ParamType::TvoidConstPointer, indices, &indicesParam.value);
305 CaptureDrawRangeElementsBaseVertex_indices(glState, isCallValid, modePacked, start, end, count,
306 typePacked, indices, basevertex, &indicesParam);
307 paramBuffer.addParam(std::move(indicesParam));
308
309 paramBuffer.addValueParam("basevertex", ParamType::TGLint, basevertex);
310
311 return CallCapture(gl::EntryPoint::DrawRangeElementsBaseVertex, std::move(paramBuffer));
312 }
313
CaptureEnablei(const State & glState,bool isCallValid,GLenum target,GLuint index)314 CallCapture CaptureEnablei(const State &glState, bool isCallValid, GLenum target, GLuint index)
315 {
316 ParamBuffer paramBuffer;
317
318 paramBuffer.addEnumParam("target", GLenumGroup::EnableCap, ParamType::TGLenum, target);
319 paramBuffer.addValueParam("index", ParamType::TGLuint, index);
320
321 return CallCapture(gl::EntryPoint::Enablei, std::move(paramBuffer));
322 }
323
CaptureFramebufferTexture(const State & glState,bool isCallValid,GLenum target,GLenum attachment,TextureID texturePacked,GLint level)324 CallCapture CaptureFramebufferTexture(const State &glState,
325 bool isCallValid,
326 GLenum target,
327 GLenum attachment,
328 TextureID texturePacked,
329 GLint level)
330 {
331 ParamBuffer paramBuffer;
332
333 paramBuffer.addEnumParam("target", GLenumGroup::FramebufferTarget, ParamType::TGLenum, target);
334 paramBuffer.addEnumParam("attachment", GLenumGroup::FramebufferAttachment, ParamType::TGLenum,
335 attachment);
336 paramBuffer.addValueParam("texturePacked", ParamType::TTextureID, texturePacked);
337 paramBuffer.addValueParam("level", ParamType::TGLint, level);
338
339 return CallCapture(gl::EntryPoint::FramebufferTexture, std::move(paramBuffer));
340 }
341
CaptureGetDebugMessageLog(const State & glState,bool isCallValid,GLuint count,GLsizei bufSize,GLenum * sources,GLenum * types,GLuint * ids,GLenum * severities,GLsizei * lengths,GLchar * messageLog,GLuint returnValue)342 CallCapture CaptureGetDebugMessageLog(const State &glState,
343 bool isCallValid,
344 GLuint count,
345 GLsizei bufSize,
346 GLenum *sources,
347 GLenum *types,
348 GLuint *ids,
349 GLenum *severities,
350 GLsizei *lengths,
351 GLchar *messageLog,
352 GLuint returnValue)
353 {
354 ParamBuffer paramBuffer;
355
356 paramBuffer.addValueParam("count", ParamType::TGLuint, count);
357 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
358
359 ParamCapture sourcesParam("sources", ParamType::TGLenumPointer);
360 InitParamValue(ParamType::TGLenumPointer, sources, &sourcesParam.value);
361 CaptureGetDebugMessageLog_sources(glState, isCallValid, count, bufSize, sources, types, ids,
362 severities, lengths, messageLog, &sourcesParam);
363 paramBuffer.addParam(std::move(sourcesParam));
364
365 ParamCapture typesParam("types", ParamType::TGLenumPointer);
366 InitParamValue(ParamType::TGLenumPointer, types, &typesParam.value);
367 CaptureGetDebugMessageLog_types(glState, isCallValid, count, bufSize, sources, types, ids,
368 severities, lengths, messageLog, &typesParam);
369 paramBuffer.addParam(std::move(typesParam));
370
371 ParamCapture idsParam("ids", ParamType::TGLuintPointer);
372 InitParamValue(ParamType::TGLuintPointer, ids, &idsParam.value);
373 CaptureGetDebugMessageLog_ids(glState, isCallValid, count, bufSize, sources, types, ids,
374 severities, lengths, messageLog, &idsParam);
375 paramBuffer.addParam(std::move(idsParam));
376
377 ParamCapture severitiesParam("severities", ParamType::TGLenumPointer);
378 InitParamValue(ParamType::TGLenumPointer, severities, &severitiesParam.value);
379 CaptureGetDebugMessageLog_severities(glState, isCallValid, count, bufSize, sources, types, ids,
380 severities, lengths, messageLog, &severitiesParam);
381 paramBuffer.addParam(std::move(severitiesParam));
382
383 ParamCapture lengthsParam("lengths", ParamType::TGLsizeiPointer);
384 InitParamValue(ParamType::TGLsizeiPointer, lengths, &lengthsParam.value);
385 CaptureGetDebugMessageLog_lengths(glState, isCallValid, count, bufSize, sources, types, ids,
386 severities, lengths, messageLog, &lengthsParam);
387 paramBuffer.addParam(std::move(lengthsParam));
388
389 ParamCapture messageLogParam("messageLog", ParamType::TGLcharPointer);
390 InitParamValue(ParamType::TGLcharPointer, messageLog, &messageLogParam.value);
391 CaptureGetDebugMessageLog_messageLog(glState, isCallValid, count, bufSize, sources, types, ids,
392 severities, lengths, messageLog, &messageLogParam);
393 paramBuffer.addParam(std::move(messageLogParam));
394
395 ParamCapture returnValueCapture("returnValue", ParamType::TGLuint);
396 InitParamValue(ParamType::TGLuint, returnValue, &returnValueCapture.value);
397 paramBuffer.addReturnValue(std::move(returnValueCapture));
398
399 return CallCapture(gl::EntryPoint::GetDebugMessageLog, std::move(paramBuffer));
400 }
401
CaptureGetGraphicsResetStatus(const State & glState,bool isCallValid,GLenum returnValue)402 CallCapture CaptureGetGraphicsResetStatus(const State &glState,
403 bool isCallValid,
404 GLenum returnValue)
405 {
406 ParamBuffer paramBuffer;
407
408 ParamCapture returnValueCapture("returnValue", ParamType::TGLenum);
409 InitParamValue(ParamType::TGLenum, returnValue, &returnValueCapture.value);
410 paramBuffer.addReturnValue(std::move(returnValueCapture));
411
412 return CallCapture(gl::EntryPoint::GetGraphicsResetStatus, std::move(paramBuffer));
413 }
414
CaptureGetObjectLabel(const State & glState,bool isCallValid,GLenum identifier,GLuint name,GLsizei bufSize,GLsizei * length,GLchar * label)415 CallCapture CaptureGetObjectLabel(const State &glState,
416 bool isCallValid,
417 GLenum identifier,
418 GLuint name,
419 GLsizei bufSize,
420 GLsizei *length,
421 GLchar *label)
422 {
423 ParamBuffer paramBuffer;
424
425 paramBuffer.addEnumParam("identifier", GLenumGroup::DefaultGroup, ParamType::TGLenum,
426 identifier);
427 paramBuffer.addValueParam("name", ParamType::TGLuint, name);
428 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
429
430 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
431 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
432 CaptureGetObjectLabel_length(glState, isCallValid, identifier, name, bufSize, length, label,
433 &lengthParam);
434 paramBuffer.addParam(std::move(lengthParam));
435
436 ParamCapture labelParam("label", ParamType::TGLcharPointer);
437 InitParamValue(ParamType::TGLcharPointer, label, &labelParam.value);
438 CaptureGetObjectLabel_label(glState, isCallValid, identifier, name, bufSize, length, label,
439 &labelParam);
440 paramBuffer.addParam(std::move(labelParam));
441
442 return CallCapture(gl::EntryPoint::GetObjectLabel, std::move(paramBuffer));
443 }
444
CaptureGetObjectPtrLabel(const State & glState,bool isCallValid,const void * ptr,GLsizei bufSize,GLsizei * length,GLchar * label)445 CallCapture CaptureGetObjectPtrLabel(const State &glState,
446 bool isCallValid,
447 const void *ptr,
448 GLsizei bufSize,
449 GLsizei *length,
450 GLchar *label)
451 {
452 ParamBuffer paramBuffer;
453
454 ParamCapture ptrParam("ptr", ParamType::TvoidConstPointer);
455 InitParamValue(ParamType::TvoidConstPointer, ptr, &ptrParam.value);
456 CaptureGetObjectPtrLabel_ptr(glState, isCallValid, ptr, bufSize, length, label, &ptrParam);
457 paramBuffer.addParam(std::move(ptrParam));
458
459 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
460
461 ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
462 InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
463 CaptureGetObjectPtrLabel_length(glState, isCallValid, ptr, bufSize, length, label,
464 &lengthParam);
465 paramBuffer.addParam(std::move(lengthParam));
466
467 ParamCapture labelParam("label", ParamType::TGLcharPointer);
468 InitParamValue(ParamType::TGLcharPointer, label, &labelParam.value);
469 CaptureGetObjectPtrLabel_label(glState, isCallValid, ptr, bufSize, length, label, &labelParam);
470 paramBuffer.addParam(std::move(labelParam));
471
472 return CallCapture(gl::EntryPoint::GetObjectPtrLabel, std::move(paramBuffer));
473 }
474
CaptureGetPointerv(const State & glState,bool isCallValid,GLenum pname,void ** params)475 CallCapture CaptureGetPointerv(const State &glState, bool isCallValid, GLenum pname, void **params)
476 {
477 ParamBuffer paramBuffer;
478
479 paramBuffer.addEnumParam("pname", GLenumGroup::GetPointervPName, ParamType::TGLenum, pname);
480
481 ParamCapture paramsParam("params", ParamType::TvoidPointerPointer);
482 InitParamValue(ParamType::TvoidPointerPointer, params, ¶msParam.value);
483 CaptureGetPointerv_params(glState, isCallValid, pname, params, ¶msParam);
484 paramBuffer.addParam(std::move(paramsParam));
485
486 return CallCapture(gl::EntryPoint::GetPointerv, std::move(paramBuffer));
487 }
488
CaptureGetSamplerParameterIiv(const State & glState,bool isCallValid,SamplerID samplerPacked,GLenum pname,GLint * params)489 CallCapture CaptureGetSamplerParameterIiv(const State &glState,
490 bool isCallValid,
491 SamplerID samplerPacked,
492 GLenum pname,
493 GLint *params)
494 {
495 ParamBuffer paramBuffer;
496
497 paramBuffer.addValueParam("samplerPacked", ParamType::TSamplerID, samplerPacked);
498 paramBuffer.addEnumParam("pname", GLenumGroup::SamplerParameterName, ParamType::TGLenum, pname);
499
500 ParamCapture paramsParam("params", ParamType::TGLintPointer);
501 InitParamValue(ParamType::TGLintPointer, params, ¶msParam.value);
502 CaptureGetSamplerParameterIiv_params(glState, isCallValid, samplerPacked, pname, params,
503 ¶msParam);
504 paramBuffer.addParam(std::move(paramsParam));
505
506 return CallCapture(gl::EntryPoint::GetSamplerParameterIiv, std::move(paramBuffer));
507 }
508
CaptureGetSamplerParameterIuiv(const State & glState,bool isCallValid,SamplerID samplerPacked,GLenum pname,GLuint * params)509 CallCapture CaptureGetSamplerParameterIuiv(const State &glState,
510 bool isCallValid,
511 SamplerID samplerPacked,
512 GLenum pname,
513 GLuint *params)
514 {
515 ParamBuffer paramBuffer;
516
517 paramBuffer.addValueParam("samplerPacked", ParamType::TSamplerID, samplerPacked);
518 paramBuffer.addEnumParam("pname", GLenumGroup::SamplerParameterName, ParamType::TGLenum, pname);
519
520 ParamCapture paramsParam("params", ParamType::TGLuintPointer);
521 InitParamValue(ParamType::TGLuintPointer, params, ¶msParam.value);
522 CaptureGetSamplerParameterIuiv_params(glState, isCallValid, samplerPacked, pname, params,
523 ¶msParam);
524 paramBuffer.addParam(std::move(paramsParam));
525
526 return CallCapture(gl::EntryPoint::GetSamplerParameterIuiv, std::move(paramBuffer));
527 }
528
CaptureGetTexParameterIiv(const State & glState,bool isCallValid,TextureType targetPacked,GLenum pname,GLint * params)529 CallCapture CaptureGetTexParameterIiv(const State &glState,
530 bool isCallValid,
531 TextureType targetPacked,
532 GLenum pname,
533 GLint *params)
534 {
535 ParamBuffer paramBuffer;
536
537 paramBuffer.addValueParam("targetPacked", ParamType::TTextureType, targetPacked);
538 paramBuffer.addEnumParam("pname", GLenumGroup::GetTextureParameter, ParamType::TGLenum, pname);
539
540 ParamCapture paramsParam("params", ParamType::TGLintPointer);
541 InitParamValue(ParamType::TGLintPointer, params, ¶msParam.value);
542 CaptureGetTexParameterIiv_params(glState, isCallValid, targetPacked, pname, params,
543 ¶msParam);
544 paramBuffer.addParam(std::move(paramsParam));
545
546 return CallCapture(gl::EntryPoint::GetTexParameterIiv, std::move(paramBuffer));
547 }
548
CaptureGetTexParameterIuiv(const State & glState,bool isCallValid,TextureType targetPacked,GLenum pname,GLuint * params)549 CallCapture CaptureGetTexParameterIuiv(const State &glState,
550 bool isCallValid,
551 TextureType targetPacked,
552 GLenum pname,
553 GLuint *params)
554 {
555 ParamBuffer paramBuffer;
556
557 paramBuffer.addValueParam("targetPacked", ParamType::TTextureType, targetPacked);
558 paramBuffer.addEnumParam("pname", GLenumGroup::GetTextureParameter, ParamType::TGLenum, pname);
559
560 ParamCapture paramsParam("params", ParamType::TGLuintPointer);
561 InitParamValue(ParamType::TGLuintPointer, params, ¶msParam.value);
562 CaptureGetTexParameterIuiv_params(glState, isCallValid, targetPacked, pname, params,
563 ¶msParam);
564 paramBuffer.addParam(std::move(paramsParam));
565
566 return CallCapture(gl::EntryPoint::GetTexParameterIuiv, std::move(paramBuffer));
567 }
568
CaptureGetnUniformfv(const State & glState,bool isCallValid,ShaderProgramID programPacked,UniformLocation locationPacked,GLsizei bufSize,GLfloat * params)569 CallCapture CaptureGetnUniformfv(const State &glState,
570 bool isCallValid,
571 ShaderProgramID programPacked,
572 UniformLocation locationPacked,
573 GLsizei bufSize,
574 GLfloat *params)
575 {
576 ParamBuffer paramBuffer;
577
578 paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
579 paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
580 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
581
582 ParamCapture paramsParam("params", ParamType::TGLfloatPointer);
583 InitParamValue(ParamType::TGLfloatPointer, params, ¶msParam.value);
584 CaptureGetnUniformfv_params(glState, isCallValid, programPacked, locationPacked, bufSize,
585 params, ¶msParam);
586 paramBuffer.addParam(std::move(paramsParam));
587
588 return CallCapture(gl::EntryPoint::GetnUniformfv, std::move(paramBuffer));
589 }
590
CaptureGetnUniformiv(const State & glState,bool isCallValid,ShaderProgramID programPacked,UniformLocation locationPacked,GLsizei bufSize,GLint * params)591 CallCapture CaptureGetnUniformiv(const State &glState,
592 bool isCallValid,
593 ShaderProgramID programPacked,
594 UniformLocation locationPacked,
595 GLsizei bufSize,
596 GLint *params)
597 {
598 ParamBuffer paramBuffer;
599
600 paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
601 paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
602 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
603
604 ParamCapture paramsParam("params", ParamType::TGLintPointer);
605 InitParamValue(ParamType::TGLintPointer, params, ¶msParam.value);
606 CaptureGetnUniformiv_params(glState, isCallValid, programPacked, locationPacked, bufSize,
607 params, ¶msParam);
608 paramBuffer.addParam(std::move(paramsParam));
609
610 return CallCapture(gl::EntryPoint::GetnUniformiv, std::move(paramBuffer));
611 }
612
CaptureGetnUniformuiv(const State & glState,bool isCallValid,ShaderProgramID programPacked,UniformLocation locationPacked,GLsizei bufSize,GLuint * params)613 CallCapture CaptureGetnUniformuiv(const State &glState,
614 bool isCallValid,
615 ShaderProgramID programPacked,
616 UniformLocation locationPacked,
617 GLsizei bufSize,
618 GLuint *params)
619 {
620 ParamBuffer paramBuffer;
621
622 paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
623 paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
624 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
625
626 ParamCapture paramsParam("params", ParamType::TGLuintPointer);
627 InitParamValue(ParamType::TGLuintPointer, params, ¶msParam.value);
628 CaptureGetnUniformuiv_params(glState, isCallValid, programPacked, locationPacked, bufSize,
629 params, ¶msParam);
630 paramBuffer.addParam(std::move(paramsParam));
631
632 return CallCapture(gl::EntryPoint::GetnUniformuiv, std::move(paramBuffer));
633 }
634
CaptureIsEnabledi(const State & glState,bool isCallValid,GLenum target,GLuint index,GLboolean returnValue)635 CallCapture CaptureIsEnabledi(const State &glState,
636 bool isCallValid,
637 GLenum target,
638 GLuint index,
639 GLboolean returnValue)
640 {
641 ParamBuffer paramBuffer;
642
643 paramBuffer.addEnumParam("target", GLenumGroup::EnableCap, ParamType::TGLenum, target);
644 paramBuffer.addValueParam("index", ParamType::TGLuint, index);
645
646 ParamCapture returnValueCapture("returnValue", ParamType::TGLboolean);
647 InitParamValue(ParamType::TGLboolean, returnValue, &returnValueCapture.value);
648 paramBuffer.addReturnValue(std::move(returnValueCapture));
649
650 return CallCapture(gl::EntryPoint::IsEnabledi, std::move(paramBuffer));
651 }
652
CaptureMinSampleShading(const State & glState,bool isCallValid,GLfloat value)653 CallCapture CaptureMinSampleShading(const State &glState, bool isCallValid, GLfloat value)
654 {
655 ParamBuffer paramBuffer;
656
657 paramBuffer.addValueParam("value", ParamType::TGLfloat, value);
658
659 return CallCapture(gl::EntryPoint::MinSampleShading, std::move(paramBuffer));
660 }
661
CaptureObjectLabel(const State & glState,bool isCallValid,GLenum identifier,GLuint name,GLsizei length,const GLchar * label)662 CallCapture CaptureObjectLabel(const State &glState,
663 bool isCallValid,
664 GLenum identifier,
665 GLuint name,
666 GLsizei length,
667 const GLchar *label)
668 {
669 ParamBuffer paramBuffer;
670
671 paramBuffer.addEnumParam("identifier", GLenumGroup::ObjectIdentifier, ParamType::TGLenum,
672 identifier);
673 paramBuffer.addValueParam("name", ParamType::TGLuint, name);
674 paramBuffer.addValueParam("length", ParamType::TGLsizei, length);
675
676 ParamCapture labelParam("label", ParamType::TGLcharConstPointer);
677 InitParamValue(ParamType::TGLcharConstPointer, label, &labelParam.value);
678 CaptureObjectLabel_label(glState, isCallValid, identifier, name, length, label, &labelParam);
679 paramBuffer.addParam(std::move(labelParam));
680
681 return CallCapture(gl::EntryPoint::ObjectLabel, std::move(paramBuffer));
682 }
683
CaptureObjectPtrLabel(const State & glState,bool isCallValid,const void * ptr,GLsizei length,const GLchar * label)684 CallCapture CaptureObjectPtrLabel(const State &glState,
685 bool isCallValid,
686 const void *ptr,
687 GLsizei length,
688 const GLchar *label)
689 {
690 ParamBuffer paramBuffer;
691
692 ParamCapture ptrParam("ptr", ParamType::TvoidConstPointer);
693 InitParamValue(ParamType::TvoidConstPointer, ptr, &ptrParam.value);
694 CaptureObjectPtrLabel_ptr(glState, isCallValid, ptr, length, label, &ptrParam);
695 paramBuffer.addParam(std::move(ptrParam));
696
697 paramBuffer.addValueParam("length", ParamType::TGLsizei, length);
698
699 ParamCapture labelParam("label", ParamType::TGLcharConstPointer);
700 InitParamValue(ParamType::TGLcharConstPointer, label, &labelParam.value);
701 CaptureObjectPtrLabel_label(glState, isCallValid, ptr, length, label, &labelParam);
702 paramBuffer.addParam(std::move(labelParam));
703
704 return CallCapture(gl::EntryPoint::ObjectPtrLabel, std::move(paramBuffer));
705 }
706
CapturePatchParameteri(const State & glState,bool isCallValid,GLenum pname,GLint value)707 CallCapture CapturePatchParameteri(const State &glState,
708 bool isCallValid,
709 GLenum pname,
710 GLint value)
711 {
712 ParamBuffer paramBuffer;
713
714 paramBuffer.addEnumParam("pname", GLenumGroup::PatchParameterName, ParamType::TGLenum, pname);
715 paramBuffer.addValueParam("value", ParamType::TGLint, value);
716
717 return CallCapture(gl::EntryPoint::PatchParameteri, std::move(paramBuffer));
718 }
719
CapturePopDebugGroup(const State & glState,bool isCallValid)720 CallCapture CapturePopDebugGroup(const State &glState, bool isCallValid)
721 {
722 ParamBuffer paramBuffer;
723
724 return CallCapture(gl::EntryPoint::PopDebugGroup, std::move(paramBuffer));
725 }
726
CapturePrimitiveBoundingBox(const State & glState,bool isCallValid,GLfloat minX,GLfloat minY,GLfloat minZ,GLfloat minW,GLfloat maxX,GLfloat maxY,GLfloat maxZ,GLfloat maxW)727 CallCapture CapturePrimitiveBoundingBox(const State &glState,
728 bool isCallValid,
729 GLfloat minX,
730 GLfloat minY,
731 GLfloat minZ,
732 GLfloat minW,
733 GLfloat maxX,
734 GLfloat maxY,
735 GLfloat maxZ,
736 GLfloat maxW)
737 {
738 ParamBuffer paramBuffer;
739
740 paramBuffer.addValueParam("minX", ParamType::TGLfloat, minX);
741 paramBuffer.addValueParam("minY", ParamType::TGLfloat, minY);
742 paramBuffer.addValueParam("minZ", ParamType::TGLfloat, minZ);
743 paramBuffer.addValueParam("minW", ParamType::TGLfloat, minW);
744 paramBuffer.addValueParam("maxX", ParamType::TGLfloat, maxX);
745 paramBuffer.addValueParam("maxY", ParamType::TGLfloat, maxY);
746 paramBuffer.addValueParam("maxZ", ParamType::TGLfloat, maxZ);
747 paramBuffer.addValueParam("maxW", ParamType::TGLfloat, maxW);
748
749 return CallCapture(gl::EntryPoint::PrimitiveBoundingBox, std::move(paramBuffer));
750 }
751
CapturePushDebugGroup(const State & glState,bool isCallValid,GLenum source,GLuint id,GLsizei length,const GLchar * message)752 CallCapture CapturePushDebugGroup(const State &glState,
753 bool isCallValid,
754 GLenum source,
755 GLuint id,
756 GLsizei length,
757 const GLchar *message)
758 {
759 ParamBuffer paramBuffer;
760
761 paramBuffer.addEnumParam("source", GLenumGroup::DebugSource, ParamType::TGLenum, source);
762 paramBuffer.addValueParam("id", ParamType::TGLuint, id);
763 paramBuffer.addValueParam("length", ParamType::TGLsizei, length);
764
765 ParamCapture messageParam("message", ParamType::TGLcharConstPointer);
766 InitParamValue(ParamType::TGLcharConstPointer, message, &messageParam.value);
767 CapturePushDebugGroup_message(glState, isCallValid, source, id, length, message, &messageParam);
768 paramBuffer.addParam(std::move(messageParam));
769
770 return CallCapture(gl::EntryPoint::PushDebugGroup, std::move(paramBuffer));
771 }
772
CaptureReadnPixels(const State & glState,bool isCallValid,GLint x,GLint y,GLsizei width,GLsizei height,GLenum format,GLenum type,GLsizei bufSize,void * data)773 CallCapture CaptureReadnPixels(const State &glState,
774 bool isCallValid,
775 GLint x,
776 GLint y,
777 GLsizei width,
778 GLsizei height,
779 GLenum format,
780 GLenum type,
781 GLsizei bufSize,
782 void *data)
783 {
784 ParamBuffer paramBuffer;
785
786 paramBuffer.addValueParam("x", ParamType::TGLint, x);
787 paramBuffer.addValueParam("y", ParamType::TGLint, y);
788 paramBuffer.addValueParam("width", ParamType::TGLsizei, width);
789 paramBuffer.addValueParam("height", ParamType::TGLsizei, height);
790 paramBuffer.addEnumParam("format", GLenumGroup::PixelFormat, ParamType::TGLenum, format);
791 paramBuffer.addEnumParam("type", GLenumGroup::PixelType, ParamType::TGLenum, type);
792 paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
793
794 ParamCapture dataParam("data", ParamType::TvoidPointer);
795 InitParamValue(ParamType::TvoidPointer, data, &dataParam.value);
796 CaptureReadnPixels_data(glState, isCallValid, x, y, width, height, format, type, bufSize, data,
797 &dataParam);
798 paramBuffer.addParam(std::move(dataParam));
799
800 return CallCapture(gl::EntryPoint::ReadnPixels, std::move(paramBuffer));
801 }
802
CaptureSamplerParameterIiv(const State & glState,bool isCallValid,SamplerID samplerPacked,GLenum pname,const GLint * param)803 CallCapture CaptureSamplerParameterIiv(const State &glState,
804 bool isCallValid,
805 SamplerID samplerPacked,
806 GLenum pname,
807 const GLint *param)
808 {
809 ParamBuffer paramBuffer;
810
811 paramBuffer.addValueParam("samplerPacked", ParamType::TSamplerID, samplerPacked);
812 paramBuffer.addEnumParam("pname", GLenumGroup::SamplerParameterName, ParamType::TGLenum, pname);
813
814 ParamCapture paramParam("param", ParamType::TGLintConstPointer);
815 InitParamValue(ParamType::TGLintConstPointer, param, ¶mParam.value);
816 CaptureSamplerParameterIiv_param(glState, isCallValid, samplerPacked, pname, param,
817 ¶mParam);
818 paramBuffer.addParam(std::move(paramParam));
819
820 return CallCapture(gl::EntryPoint::SamplerParameterIiv, std::move(paramBuffer));
821 }
822
CaptureSamplerParameterIuiv(const State & glState,bool isCallValid,SamplerID samplerPacked,GLenum pname,const GLuint * param)823 CallCapture CaptureSamplerParameterIuiv(const State &glState,
824 bool isCallValid,
825 SamplerID samplerPacked,
826 GLenum pname,
827 const GLuint *param)
828 {
829 ParamBuffer paramBuffer;
830
831 paramBuffer.addValueParam("samplerPacked", ParamType::TSamplerID, samplerPacked);
832 paramBuffer.addEnumParam("pname", GLenumGroup::SamplerParameterName, ParamType::TGLenum, pname);
833
834 ParamCapture paramParam("param", ParamType::TGLuintConstPointer);
835 InitParamValue(ParamType::TGLuintConstPointer, param, ¶mParam.value);
836 CaptureSamplerParameterIuiv_param(glState, isCallValid, samplerPacked, pname, param,
837 ¶mParam);
838 paramBuffer.addParam(std::move(paramParam));
839
840 return CallCapture(gl::EntryPoint::SamplerParameterIuiv, std::move(paramBuffer));
841 }
842
CaptureTexBuffer(const State & glState,bool isCallValid,GLenum target,GLenum internalformat,BufferID bufferPacked)843 CallCapture CaptureTexBuffer(const State &glState,
844 bool isCallValid,
845 GLenum target,
846 GLenum internalformat,
847 BufferID bufferPacked)
848 {
849 ParamBuffer paramBuffer;
850
851 paramBuffer.addEnumParam("target", GLenumGroup::TextureTarget, ParamType::TGLenum, target);
852 paramBuffer.addEnumParam("internalformat", GLenumGroup::InternalFormat, ParamType::TGLenum,
853 internalformat);
854 paramBuffer.addValueParam("bufferPacked", ParamType::TBufferID, bufferPacked);
855
856 return CallCapture(gl::EntryPoint::TexBuffer, std::move(paramBuffer));
857 }
858
CaptureTexBufferRange(const State & glState,bool isCallValid,GLenum target,GLenum internalformat,BufferID bufferPacked,GLintptr offset,GLsizeiptr size)859 CallCapture CaptureTexBufferRange(const State &glState,
860 bool isCallValid,
861 GLenum target,
862 GLenum internalformat,
863 BufferID bufferPacked,
864 GLintptr offset,
865 GLsizeiptr size)
866 {
867 ParamBuffer paramBuffer;
868
869 paramBuffer.addEnumParam("target", GLenumGroup::TextureTarget, ParamType::TGLenum, target);
870 paramBuffer.addEnumParam("internalformat", GLenumGroup::InternalFormat, ParamType::TGLenum,
871 internalformat);
872 paramBuffer.addValueParam("bufferPacked", ParamType::TBufferID, bufferPacked);
873 paramBuffer.addValueParam("offset", ParamType::TGLintptr, offset);
874 paramBuffer.addValueParam("size", ParamType::TGLsizeiptr, size);
875
876 return CallCapture(gl::EntryPoint::TexBufferRange, std::move(paramBuffer));
877 }
878
CaptureTexParameterIiv(const State & glState,bool isCallValid,TextureType targetPacked,GLenum pname,const GLint * params)879 CallCapture CaptureTexParameterIiv(const State &glState,
880 bool isCallValid,
881 TextureType targetPacked,
882 GLenum pname,
883 const GLint *params)
884 {
885 ParamBuffer paramBuffer;
886
887 paramBuffer.addValueParam("targetPacked", ParamType::TTextureType, targetPacked);
888 paramBuffer.addEnumParam("pname", GLenumGroup::TextureParameterName, ParamType::TGLenum, pname);
889
890 ParamCapture paramsParam("params", ParamType::TGLintConstPointer);
891 InitParamValue(ParamType::TGLintConstPointer, params, ¶msParam.value);
892 CaptureTexParameterIiv_params(glState, isCallValid, targetPacked, pname, params, ¶msParam);
893 paramBuffer.addParam(std::move(paramsParam));
894
895 return CallCapture(gl::EntryPoint::TexParameterIiv, std::move(paramBuffer));
896 }
897
CaptureTexParameterIuiv(const State & glState,bool isCallValid,TextureType targetPacked,GLenum pname,const GLuint * params)898 CallCapture CaptureTexParameterIuiv(const State &glState,
899 bool isCallValid,
900 TextureType targetPacked,
901 GLenum pname,
902 const GLuint *params)
903 {
904 ParamBuffer paramBuffer;
905
906 paramBuffer.addValueParam("targetPacked", ParamType::TTextureType, targetPacked);
907 paramBuffer.addEnumParam("pname", GLenumGroup::TextureParameterName, ParamType::TGLenum, pname);
908
909 ParamCapture paramsParam("params", ParamType::TGLuintConstPointer);
910 InitParamValue(ParamType::TGLuintConstPointer, params, ¶msParam.value);
911 CaptureTexParameterIuiv_params(glState, isCallValid, targetPacked, pname, params, ¶msParam);
912 paramBuffer.addParam(std::move(paramsParam));
913
914 return CallCapture(gl::EntryPoint::TexParameterIuiv, std::move(paramBuffer));
915 }
916
CaptureTexStorage3DMultisample(const State & glState,bool isCallValid,TextureType targetPacked,GLsizei samples,GLenum internalformat,GLsizei width,GLsizei height,GLsizei depth,GLboolean fixedsamplelocations)917 CallCapture CaptureTexStorage3DMultisample(const State &glState,
918 bool isCallValid,
919 TextureType targetPacked,
920 GLsizei samples,
921 GLenum internalformat,
922 GLsizei width,
923 GLsizei height,
924 GLsizei depth,
925 GLboolean fixedsamplelocations)
926 {
927 ParamBuffer paramBuffer;
928
929 paramBuffer.addValueParam("targetPacked", ParamType::TTextureType, targetPacked);
930 paramBuffer.addValueParam("samples", ParamType::TGLsizei, samples);
931 paramBuffer.addEnumParam("internalformat", GLenumGroup::InternalFormat, ParamType::TGLenum,
932 internalformat);
933 paramBuffer.addValueParam("width", ParamType::TGLsizei, width);
934 paramBuffer.addValueParam("height", ParamType::TGLsizei, height);
935 paramBuffer.addValueParam("depth", ParamType::TGLsizei, depth);
936 paramBuffer.addValueParam("fixedsamplelocations", ParamType::TGLboolean, fixedsamplelocations);
937
938 return CallCapture(gl::EntryPoint::TexStorage3DMultisample, std::move(paramBuffer));
939 }
940
941 } // namespace gl
942