| // GENERATED FILE - DO NOT EDIT. |
| // Generated by generate_entry_points.py using data from gl.xml and gl_angle_ext.xml. |
| // |
| // Copyright 2019 The ANGLE Project Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| // |
| // capture_gles_3_0_autogen.cpp: |
| // Capture functions for the OpenGL ES 3.0 entry points. |
| |
| #include "libANGLE/capture_gles_3_0_autogen.h" |
| |
| #include "libANGLE/Context.h" |
| #include "libANGLE/FrameCapture.h" |
| #include "libANGLE/gl_enum_utils.h" |
| #include "libANGLE/validationES3.h" |
| |
| using namespace angle; |
| |
| namespace gl |
| { |
| |
| CallCapture CaptureBeginQuery(const State &glState, |
| bool isCallValid, |
| QueryType targetPacked, |
| QueryID idPacked) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("targetPacked", ParamType::TQueryType, targetPacked); |
| paramBuffer.addValueParam("idPacked", ParamType::TQueryID, idPacked); |
| |
| return CallCapture(gl::EntryPoint::BeginQuery, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureBeginTransformFeedback(const State &glState, |
| bool isCallValid, |
| PrimitiveMode primitiveModePacked) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("primitiveModePacked", ParamType::TPrimitiveMode, |
| primitiveModePacked); |
| |
| return CallCapture(gl::EntryPoint::BeginTransformFeedback, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureBindBufferBase(const State &glState, |
| bool isCallValid, |
| BufferBinding targetPacked, |
| GLuint index, |
| BufferID bufferPacked) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("targetPacked", ParamType::TBufferBinding, targetPacked); |
| paramBuffer.addValueParam("index", ParamType::TGLuint, index); |
| paramBuffer.addValueParam("bufferPacked", ParamType::TBufferID, bufferPacked); |
| |
| return CallCapture(gl::EntryPoint::BindBufferBase, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureBindBufferRange(const State &glState, |
| bool isCallValid, |
| BufferBinding targetPacked, |
| GLuint index, |
| BufferID bufferPacked, |
| GLintptr offset, |
| GLsizeiptr size) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("targetPacked", ParamType::TBufferBinding, targetPacked); |
| paramBuffer.addValueParam("index", ParamType::TGLuint, index); |
| paramBuffer.addValueParam("bufferPacked", ParamType::TBufferID, bufferPacked); |
| paramBuffer.addValueParam("offset", ParamType::TGLintptr, offset); |
| paramBuffer.addValueParam("size", ParamType::TGLsizeiptr, size); |
| |
| return CallCapture(gl::EntryPoint::BindBufferRange, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureBindSampler(const State &glState, |
| bool isCallValid, |
| GLuint unit, |
| SamplerID samplerPacked) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("unit", ParamType::TGLuint, unit); |
| paramBuffer.addValueParam("samplerPacked", ParamType::TSamplerID, samplerPacked); |
| |
| return CallCapture(gl::EntryPoint::BindSampler, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureBindTransformFeedback(const State &glState, |
| bool isCallValid, |
| GLenum target, |
| TransformFeedbackID idPacked) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addEnumParam("target", GLenumGroup::BindTransformFeedbackTarget, ParamType::TGLenum, |
| target); |
| paramBuffer.addValueParam("idPacked", ParamType::TTransformFeedbackID, idPacked); |
| |
| return CallCapture(gl::EntryPoint::BindTransformFeedback, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureBindVertexArray(const State &glState, |
| bool isCallValid, |
| VertexArrayID arrayPacked) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("arrayPacked", ParamType::TVertexArrayID, arrayPacked); |
| |
| return CallCapture(gl::EntryPoint::BindVertexArray, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureBlitFramebuffer(const State &glState, |
| bool isCallValid, |
| GLint srcX0, |
| GLint srcY0, |
| GLint srcX1, |
| GLint srcY1, |
| GLint dstX0, |
| GLint dstY0, |
| GLint dstX1, |
| GLint dstY1, |
| GLbitfield mask, |
| GLenum filter) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("srcX0", ParamType::TGLint, srcX0); |
| paramBuffer.addValueParam("srcY0", ParamType::TGLint, srcY0); |
| paramBuffer.addValueParam("srcX1", ParamType::TGLint, srcX1); |
| paramBuffer.addValueParam("srcY1", ParamType::TGLint, srcY1); |
| paramBuffer.addValueParam("dstX0", ParamType::TGLint, dstX0); |
| paramBuffer.addValueParam("dstY0", ParamType::TGLint, dstY0); |
| paramBuffer.addValueParam("dstX1", ParamType::TGLint, dstX1); |
| paramBuffer.addValueParam("dstY1", ParamType::TGLint, dstY1); |
| paramBuffer.addEnumParam("mask", GLenumGroup::ClearBufferMask, ParamType::TGLbitfield, mask); |
| paramBuffer.addEnumParam("filter", GLenumGroup::BlitFramebufferFilter, ParamType::TGLenum, |
| filter); |
| |
| return CallCapture(gl::EntryPoint::BlitFramebuffer, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureClearBufferfi(const State &glState, |
| bool isCallValid, |
| GLenum buffer, |
| GLint drawbuffer, |
| GLfloat depth, |
| GLint stencil) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addEnumParam("buffer", GLenumGroup::Buffer, ParamType::TGLenum, buffer); |
| paramBuffer.addValueParam("drawbuffer", ParamType::TGLint, drawbuffer); |
| paramBuffer.addValueParam("depth", ParamType::TGLfloat, depth); |
| paramBuffer.addValueParam("stencil", ParamType::TGLint, stencil); |
| |
| return CallCapture(gl::EntryPoint::ClearBufferfi, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureClearBufferfv(const State &glState, |
| bool isCallValid, |
| GLenum buffer, |
| GLint drawbuffer, |
| const GLfloat *value) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addEnumParam("buffer", GLenumGroup::Buffer, ParamType::TGLenum, buffer); |
| paramBuffer.addValueParam("drawbuffer", ParamType::TGLint, drawbuffer); |
| |
| ParamCapture valueParam("value", ParamType::TGLfloatConstPointer); |
| InitParamValue(ParamType::TGLfloatConstPointer, value, &valueParam.value); |
| CaptureClearBufferfv_value(glState, isCallValid, buffer, drawbuffer, value, &valueParam); |
| paramBuffer.addParam(std::move(valueParam)); |
| |
| return CallCapture(gl::EntryPoint::ClearBufferfv, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureClearBufferiv(const State &glState, |
| bool isCallValid, |
| GLenum buffer, |
| GLint drawbuffer, |
| const GLint *value) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addEnumParam("buffer", GLenumGroup::Buffer, ParamType::TGLenum, buffer); |
| paramBuffer.addValueParam("drawbuffer", ParamType::TGLint, drawbuffer); |
| |
| ParamCapture valueParam("value", ParamType::TGLintConstPointer); |
| InitParamValue(ParamType::TGLintConstPointer, value, &valueParam.value); |
| CaptureClearBufferiv_value(glState, isCallValid, buffer, drawbuffer, value, &valueParam); |
| paramBuffer.addParam(std::move(valueParam)); |
| |
| return CallCapture(gl::EntryPoint::ClearBufferiv, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureClearBufferuiv(const State &glState, |
| bool isCallValid, |
| GLenum buffer, |
| GLint drawbuffer, |
| const GLuint *value) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addEnumParam("buffer", GLenumGroup::Buffer, ParamType::TGLenum, buffer); |
| paramBuffer.addValueParam("drawbuffer", ParamType::TGLint, drawbuffer); |
| |
| ParamCapture valueParam("value", ParamType::TGLuintConstPointer); |
| InitParamValue(ParamType::TGLuintConstPointer, value, &valueParam.value); |
| CaptureClearBufferuiv_value(glState, isCallValid, buffer, drawbuffer, value, &valueParam); |
| paramBuffer.addParam(std::move(valueParam)); |
| |
| return CallCapture(gl::EntryPoint::ClearBufferuiv, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureClientWaitSync(const State &glState, |
| bool isCallValid, |
| GLsync sync, |
| GLbitfield flags, |
| GLuint64 timeout, |
| GLenum returnValue) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("sync", ParamType::TGLsync, sync); |
| paramBuffer.addEnumParam("flags", GLenumGroup::SyncObjectMask, ParamType::TGLbitfield, flags); |
| paramBuffer.addValueParam("timeout", ParamType::TGLuint64, timeout); |
| |
| ParamCapture returnValueCapture("returnValue", ParamType::TGLenum); |
| InitParamValue(ParamType::TGLenum, returnValue, &returnValueCapture.value); |
| paramBuffer.addReturnValue(std::move(returnValueCapture)); |
| |
| return CallCapture(gl::EntryPoint::ClientWaitSync, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureCompressedTexImage3D(const State &glState, |
| bool isCallValid, |
| TextureTarget targetPacked, |
| GLint level, |
| GLenum internalformat, |
| GLsizei width, |
| GLsizei height, |
| GLsizei depth, |
| GLint border, |
| GLsizei imageSize, |
| const void *data) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("targetPacked", ParamType::TTextureTarget, targetPacked); |
| paramBuffer.addValueParam("level", ParamType::TGLint, level); |
| paramBuffer.addEnumParam("internalformat", GLenumGroup::InternalFormat, ParamType::TGLenum, |
| internalformat); |
| paramBuffer.addValueParam("width", ParamType::TGLsizei, width); |
| paramBuffer.addValueParam("height", ParamType::TGLsizei, height); |
| paramBuffer.addValueParam("depth", ParamType::TGLsizei, depth); |
| paramBuffer.addValueParam("border", ParamType::TGLint, border); |
| paramBuffer.addValueParam("imageSize", ParamType::TGLsizei, imageSize); |
| |
| ParamCapture dataParam("data", ParamType::TvoidConstPointer); |
| InitParamValue(ParamType::TvoidConstPointer, data, &dataParam.value); |
| CaptureCompressedTexImage3D_data(glState, isCallValid, targetPacked, level, internalformat, |
| width, height, depth, border, imageSize, data, &dataParam); |
| paramBuffer.addParam(std::move(dataParam)); |
| |
| return CallCapture(gl::EntryPoint::CompressedTexImage3D, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureCompressedTexSubImage3D(const State &glState, |
| bool isCallValid, |
| TextureTarget targetPacked, |
| GLint level, |
| GLint xoffset, |
| GLint yoffset, |
| GLint zoffset, |
| GLsizei width, |
| GLsizei height, |
| GLsizei depth, |
| GLenum format, |
| GLsizei imageSize, |
| const void *data) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("targetPacked", ParamType::TTextureTarget, targetPacked); |
| paramBuffer.addValueParam("level", ParamType::TGLint, level); |
| paramBuffer.addValueParam("xoffset", ParamType::TGLint, xoffset); |
| paramBuffer.addValueParam("yoffset", ParamType::TGLint, yoffset); |
| paramBuffer.addValueParam("zoffset", ParamType::TGLint, zoffset); |
| paramBuffer.addValueParam("width", ParamType::TGLsizei, width); |
| paramBuffer.addValueParam("height", ParamType::TGLsizei, height); |
| paramBuffer.addValueParam("depth", ParamType::TGLsizei, depth); |
| paramBuffer.addEnumParam("format", GLenumGroup::PixelFormat, ParamType::TGLenum, format); |
| paramBuffer.addValueParam("imageSize", ParamType::TGLsizei, imageSize); |
| |
| ParamCapture dataParam("data", ParamType::TvoidConstPointer); |
| InitParamValue(ParamType::TvoidConstPointer, data, &dataParam.value); |
| CaptureCompressedTexSubImage3D_data(glState, isCallValid, targetPacked, level, xoffset, yoffset, |
| zoffset, width, height, depth, format, imageSize, data, |
| &dataParam); |
| paramBuffer.addParam(std::move(dataParam)); |
| |
| return CallCapture(gl::EntryPoint::CompressedTexSubImage3D, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureCopyBufferSubData(const State &glState, |
| bool isCallValid, |
| BufferBinding readTargetPacked, |
| BufferBinding writeTargetPacked, |
| GLintptr readOffset, |
| GLintptr writeOffset, |
| GLsizeiptr size) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("readTargetPacked", ParamType::TBufferBinding, readTargetPacked); |
| paramBuffer.addValueParam("writeTargetPacked", ParamType::TBufferBinding, writeTargetPacked); |
| paramBuffer.addValueParam("readOffset", ParamType::TGLintptr, readOffset); |
| paramBuffer.addValueParam("writeOffset", ParamType::TGLintptr, writeOffset); |
| paramBuffer.addValueParam("size", ParamType::TGLsizeiptr, size); |
| |
| return CallCapture(gl::EntryPoint::CopyBufferSubData, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureCopyTexSubImage3D(const State &glState, |
| bool isCallValid, |
| TextureTarget targetPacked, |
| GLint level, |
| GLint xoffset, |
| GLint yoffset, |
| GLint zoffset, |
| GLint x, |
| GLint y, |
| GLsizei width, |
| GLsizei height) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("targetPacked", ParamType::TTextureTarget, targetPacked); |
| paramBuffer.addValueParam("level", ParamType::TGLint, level); |
| paramBuffer.addValueParam("xoffset", ParamType::TGLint, xoffset); |
| paramBuffer.addValueParam("yoffset", ParamType::TGLint, yoffset); |
| paramBuffer.addValueParam("zoffset", ParamType::TGLint, zoffset); |
| paramBuffer.addValueParam("x", ParamType::TGLint, x); |
| paramBuffer.addValueParam("y", ParamType::TGLint, y); |
| paramBuffer.addValueParam("width", ParamType::TGLsizei, width); |
| paramBuffer.addValueParam("height", ParamType::TGLsizei, height); |
| |
| return CallCapture(gl::EntryPoint::CopyTexSubImage3D, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureDeleteQueries(const State &glState, |
| bool isCallValid, |
| GLsizei n, |
| const QueryID *idsPacked) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("n", ParamType::TGLsizei, n); |
| |
| ParamCapture idsPackedParam("idsPacked", ParamType::TQueryIDConstPointer); |
| InitParamValue(ParamType::TQueryIDConstPointer, idsPacked, &idsPackedParam.value); |
| CaptureDeleteQueries_idsPacked(glState, isCallValid, n, idsPacked, &idsPackedParam); |
| paramBuffer.addParam(std::move(idsPackedParam)); |
| |
| return CallCapture(gl::EntryPoint::DeleteQueries, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureDeleteSamplers(const State &glState, |
| bool isCallValid, |
| GLsizei count, |
| const SamplerID *samplersPacked) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("count", ParamType::TGLsizei, count); |
| |
| ParamCapture samplersPackedParam("samplersPacked", ParamType::TSamplerIDConstPointer); |
| InitParamValue(ParamType::TSamplerIDConstPointer, samplersPacked, &samplersPackedParam.value); |
| CaptureDeleteSamplers_samplersPacked(glState, isCallValid, count, samplersPacked, |
| &samplersPackedParam); |
| paramBuffer.addParam(std::move(samplersPackedParam)); |
| |
| return CallCapture(gl::EntryPoint::DeleteSamplers, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureDeleteSync(const State &glState, bool isCallValid, GLsync sync) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("sync", ParamType::TGLsync, sync); |
| |
| return CallCapture(gl::EntryPoint::DeleteSync, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureDeleteTransformFeedbacks(const State &glState, |
| bool isCallValid, |
| GLsizei n, |
| const TransformFeedbackID *idsPacked) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("n", ParamType::TGLsizei, n); |
| |
| ParamCapture idsPackedParam("idsPacked", ParamType::TTransformFeedbackIDConstPointer); |
| InitParamValue(ParamType::TTransformFeedbackIDConstPointer, idsPacked, &idsPackedParam.value); |
| CaptureDeleteTransformFeedbacks_idsPacked(glState, isCallValid, n, idsPacked, &idsPackedParam); |
| paramBuffer.addParam(std::move(idsPackedParam)); |
| |
| return CallCapture(gl::EntryPoint::DeleteTransformFeedbacks, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureDeleteVertexArrays(const State &glState, |
| bool isCallValid, |
| GLsizei n, |
| const VertexArrayID *arraysPacked) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("n", ParamType::TGLsizei, n); |
| |
| ParamCapture arraysPackedParam("arraysPacked", ParamType::TVertexArrayIDConstPointer); |
| InitParamValue(ParamType::TVertexArrayIDConstPointer, arraysPacked, &arraysPackedParam.value); |
| CaptureDeleteVertexArrays_arraysPacked(glState, isCallValid, n, arraysPacked, |
| &arraysPackedParam); |
| paramBuffer.addParam(std::move(arraysPackedParam)); |
| |
| return CallCapture(gl::EntryPoint::DeleteVertexArrays, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureDrawArraysInstanced(const State &glState, |
| bool isCallValid, |
| PrimitiveMode modePacked, |
| GLint first, |
| GLsizei count, |
| GLsizei instancecount) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("modePacked", ParamType::TPrimitiveMode, modePacked); |
| paramBuffer.addValueParam("first", ParamType::TGLint, first); |
| paramBuffer.addValueParam("count", ParamType::TGLsizei, count); |
| paramBuffer.addValueParam("instancecount", ParamType::TGLsizei, instancecount); |
| |
| return CallCapture(gl::EntryPoint::DrawArraysInstanced, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureDrawBuffers(const State &glState, |
| bool isCallValid, |
| GLsizei n, |
| const GLenum *bufs) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("n", ParamType::TGLsizei, n); |
| |
| ParamCapture bufsParam("bufs", ParamType::TGLenumConstPointer); |
| InitParamValue(ParamType::TGLenumConstPointer, bufs, &bufsParam.value); |
| CaptureDrawBuffers_bufs(glState, isCallValid, n, bufs, &bufsParam); |
| paramBuffer.addParam(std::move(bufsParam)); |
| |
| return CallCapture(gl::EntryPoint::DrawBuffers, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureDrawElementsInstanced(const State &glState, |
| bool isCallValid, |
| PrimitiveMode modePacked, |
| GLsizei count, |
| DrawElementsType typePacked, |
| const void *indices, |
| GLsizei instancecount) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("modePacked", ParamType::TPrimitiveMode, modePacked); |
| paramBuffer.addValueParam("count", ParamType::TGLsizei, count); |
| paramBuffer.addValueParam("typePacked", ParamType::TDrawElementsType, typePacked); |
| |
| ParamCapture indicesParam("indices", ParamType::TvoidConstPointer); |
| InitParamValue(ParamType::TvoidConstPointer, indices, &indicesParam.value); |
| CaptureDrawElementsInstanced_indices(glState, isCallValid, modePacked, count, typePacked, |
| indices, instancecount, &indicesParam); |
| paramBuffer.addParam(std::move(indicesParam)); |
| |
| paramBuffer.addValueParam("instancecount", ParamType::TGLsizei, instancecount); |
| |
| return CallCapture(gl::EntryPoint::DrawElementsInstanced, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureDrawRangeElements(const State &glState, |
| bool isCallValid, |
| PrimitiveMode modePacked, |
| GLuint start, |
| GLuint end, |
| GLsizei count, |
| DrawElementsType typePacked, |
| const void *indices) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("modePacked", ParamType::TPrimitiveMode, modePacked); |
| paramBuffer.addValueParam("start", ParamType::TGLuint, start); |
| paramBuffer.addValueParam("end", ParamType::TGLuint, end); |
| paramBuffer.addValueParam("count", ParamType::TGLsizei, count); |
| paramBuffer.addValueParam("typePacked", ParamType::TDrawElementsType, typePacked); |
| |
| ParamCapture indicesParam("indices", ParamType::TvoidConstPointer); |
| InitParamValue(ParamType::TvoidConstPointer, indices, &indicesParam.value); |
| CaptureDrawRangeElements_indices(glState, isCallValid, modePacked, start, end, count, |
| typePacked, indices, &indicesParam); |
| paramBuffer.addParam(std::move(indicesParam)); |
| |
| return CallCapture(gl::EntryPoint::DrawRangeElements, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureEndQuery(const State &glState, bool isCallValid, QueryType targetPacked) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("targetPacked", ParamType::TQueryType, targetPacked); |
| |
| return CallCapture(gl::EntryPoint::EndQuery, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureEndTransformFeedback(const State &glState, bool isCallValid) |
| { |
| ParamBuffer paramBuffer; |
| |
| return CallCapture(gl::EntryPoint::EndTransformFeedback, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureFenceSync(const State &glState, |
| bool isCallValid, |
| GLenum condition, |
| GLbitfield flags, |
| GLsync returnValue) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addEnumParam("condition", GLenumGroup::SyncCondition, ParamType::TGLenum, |
| condition); |
| paramBuffer.addEnumParam("flags", GLenumGroup::DefaultGroup, ParamType::TGLbitfield, flags); |
| |
| ParamCapture returnValueCapture("returnValue", ParamType::TGLsync); |
| InitParamValue(ParamType::TGLsync, returnValue, &returnValueCapture.value); |
| paramBuffer.addReturnValue(std::move(returnValueCapture)); |
| |
| return CallCapture(gl::EntryPoint::FenceSync, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureFlushMappedBufferRange(const State &glState, |
| bool isCallValid, |
| BufferBinding targetPacked, |
| GLintptr offset, |
| GLsizeiptr length) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("targetPacked", ParamType::TBufferBinding, targetPacked); |
| paramBuffer.addValueParam("offset", ParamType::TGLintptr, offset); |
| paramBuffer.addValueParam("length", ParamType::TGLsizeiptr, length); |
| |
| return CallCapture(gl::EntryPoint::FlushMappedBufferRange, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureFramebufferTextureLayer(const State &glState, |
| bool isCallValid, |
| GLenum target, |
| GLenum attachment, |
| TextureID texturePacked, |
| GLint level, |
| GLint layer) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addEnumParam("target", GLenumGroup::FramebufferTarget, ParamType::TGLenum, target); |
| paramBuffer.addEnumParam("attachment", GLenumGroup::FramebufferAttachment, ParamType::TGLenum, |
| attachment); |
| paramBuffer.addValueParam("texturePacked", ParamType::TTextureID, texturePacked); |
| paramBuffer.addValueParam("level", ParamType::TGLint, level); |
| paramBuffer.addValueParam("layer", ParamType::TGLint, layer); |
| |
| return CallCapture(gl::EntryPoint::FramebufferTextureLayer, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureGenQueries(const State &glState, bool isCallValid, GLsizei n, QueryID *idsPacked) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("n", ParamType::TGLsizei, n); |
| |
| ParamCapture idsPackedParam("idsPacked", ParamType::TQueryIDPointer); |
| InitParamValue(ParamType::TQueryIDPointer, idsPacked, &idsPackedParam.value); |
| CaptureGenQueries_idsPacked(glState, isCallValid, n, idsPacked, &idsPackedParam); |
| paramBuffer.addParam(std::move(idsPackedParam)); |
| |
| return CallCapture(gl::EntryPoint::GenQueries, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureGenSamplers(const State &glState, |
| bool isCallValid, |
| GLsizei count, |
| SamplerID *samplersPacked) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("count", ParamType::TGLsizei, count); |
| |
| ParamCapture samplersPackedParam("samplersPacked", ParamType::TSamplerIDPointer); |
| InitParamValue(ParamType::TSamplerIDPointer, samplersPacked, &samplersPackedParam.value); |
| CaptureGenSamplers_samplersPacked(glState, isCallValid, count, samplersPacked, |
| &samplersPackedParam); |
| paramBuffer.addParam(std::move(samplersPackedParam)); |
| |
| return CallCapture(gl::EntryPoint::GenSamplers, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureGenTransformFeedbacks(const State &glState, |
| bool isCallValid, |
| GLsizei n, |
| TransformFeedbackID *idsPacked) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("n", ParamType::TGLsizei, n); |
| |
| ParamCapture idsPackedParam("idsPacked", ParamType::TTransformFeedbackIDPointer); |
| InitParamValue(ParamType::TTransformFeedbackIDPointer, idsPacked, &idsPackedParam.value); |
| CaptureGenTransformFeedbacks_idsPacked(glState, isCallValid, n, idsPacked, &idsPackedParam); |
| paramBuffer.addParam(std::move(idsPackedParam)); |
| |
| return CallCapture(gl::EntryPoint::GenTransformFeedbacks, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureGenVertexArrays(const State &glState, |
| bool isCallValid, |
| GLsizei n, |
| VertexArrayID *arraysPacked) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("n", ParamType::TGLsizei, n); |
| |
| ParamCapture arraysPackedParam("arraysPacked", ParamType::TVertexArrayIDPointer); |
| InitParamValue(ParamType::TVertexArrayIDPointer, arraysPacked, &arraysPackedParam.value); |
| CaptureGenVertexArrays_arraysPacked(glState, isCallValid, n, arraysPacked, &arraysPackedParam); |
| paramBuffer.addParam(std::move(arraysPackedParam)); |
| |
| return CallCapture(gl::EntryPoint::GenVertexArrays, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureGetActiveUniformBlockName(const State &glState, |
| bool isCallValid, |
| ShaderProgramID programPacked, |
| GLuint uniformBlockIndex, |
| GLsizei bufSize, |
| GLsizei *length, |
| GLchar *uniformBlockName) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked); |
| paramBuffer.addValueParam("uniformBlockIndex", ParamType::TGLuint, uniformBlockIndex); |
| paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize); |
| |
| ParamCapture lengthParam("length", ParamType::TGLsizeiPointer); |
| InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value); |
| CaptureGetActiveUniformBlockName_length(glState, isCallValid, programPacked, uniformBlockIndex, |
| bufSize, length, uniformBlockName, &lengthParam); |
| paramBuffer.addParam(std::move(lengthParam)); |
| |
| ParamCapture uniformBlockNameParam("uniformBlockName", ParamType::TGLcharPointer); |
| InitParamValue(ParamType::TGLcharPointer, uniformBlockName, &uniformBlockNameParam.value); |
| CaptureGetActiveUniformBlockName_uniformBlockName(glState, isCallValid, programPacked, |
| uniformBlockIndex, bufSize, length, |
| uniformBlockName, &uniformBlockNameParam); |
| paramBuffer.addParam(std::move(uniformBlockNameParam)); |
| |
| return CallCapture(gl::EntryPoint::GetActiveUniformBlockName, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureGetActiveUniformBlockiv(const State &glState, |
| bool isCallValid, |
| ShaderProgramID programPacked, |
| GLuint uniformBlockIndex, |
| GLenum pname, |
| GLint *params) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked); |
| paramBuffer.addValueParam("uniformBlockIndex", ParamType::TGLuint, uniformBlockIndex); |
| paramBuffer.addEnumParam("pname", GLenumGroup::UniformBlockPName, ParamType::TGLenum, pname); |
| |
| ParamCapture paramsParam("params", ParamType::TGLintPointer); |
| InitParamValue(ParamType::TGLintPointer, params, ¶msParam.value); |
| CaptureGetActiveUniformBlockiv_params(glState, isCallValid, programPacked, uniformBlockIndex, |
| pname, params, ¶msParam); |
| paramBuffer.addParam(std::move(paramsParam)); |
| |
| return CallCapture(gl::EntryPoint::GetActiveUniformBlockiv, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureGetActiveUniformsiv(const State &glState, |
| bool isCallValid, |
| ShaderProgramID programPacked, |
| GLsizei uniformCount, |
| const GLuint *uniformIndices, |
| GLenum pname, |
| GLint *params) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked); |
| paramBuffer.addValueParam("uniformCount", ParamType::TGLsizei, uniformCount); |
| |
| ParamCapture uniformIndicesParam("uniformIndices", ParamType::TGLuintConstPointer); |
| InitParamValue(ParamType::TGLuintConstPointer, uniformIndices, &uniformIndicesParam.value); |
| CaptureGetActiveUniformsiv_uniformIndices(glState, isCallValid, programPacked, uniformCount, |
| uniformIndices, pname, params, &uniformIndicesParam); |
| paramBuffer.addParam(std::move(uniformIndicesParam)); |
| |
| paramBuffer.addEnumParam("pname", GLenumGroup::UniformPName, ParamType::TGLenum, pname); |
| |
| ParamCapture paramsParam("params", ParamType::TGLintPointer); |
| InitParamValue(ParamType::TGLintPointer, params, ¶msParam.value); |
| CaptureGetActiveUniformsiv_params(glState, isCallValid, programPacked, uniformCount, |
| uniformIndices, pname, params, ¶msParam); |
| paramBuffer.addParam(std::move(paramsParam)); |
| |
| return CallCapture(gl::EntryPoint::GetActiveUniformsiv, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureGetBufferParameteri64v(const State &glState, |
| bool isCallValid, |
| BufferBinding targetPacked, |
| GLenum pname, |
| GLint64 *params) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("targetPacked", ParamType::TBufferBinding, targetPacked); |
| paramBuffer.addEnumParam("pname", GLenumGroup::DefaultGroup, ParamType::TGLenum, pname); |
| |
| ParamCapture paramsParam("params", ParamType::TGLint64Pointer); |
| InitParamValue(ParamType::TGLint64Pointer, params, ¶msParam.value); |
| CaptureGetBufferParameteri64v_params(glState, isCallValid, targetPacked, pname, params, |
| ¶msParam); |
| paramBuffer.addParam(std::move(paramsParam)); |
| |
| return CallCapture(gl::EntryPoint::GetBufferParameteri64v, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureGetBufferPointerv(const State &glState, |
| bool isCallValid, |
| BufferBinding targetPacked, |
| GLenum pname, |
| void **params) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("targetPacked", ParamType::TBufferBinding, targetPacked); |
| paramBuffer.addEnumParam("pname", GLenumGroup::DefaultGroup, ParamType::TGLenum, pname); |
| |
| ParamCapture paramsParam("params", ParamType::TvoidPointerPointer); |
| InitParamValue(ParamType::TvoidPointerPointer, params, ¶msParam.value); |
| CaptureGetBufferPointerv_params(glState, isCallValid, targetPacked, pname, params, |
| ¶msParam); |
| paramBuffer.addParam(std::move(paramsParam)); |
| |
| return CallCapture(gl::EntryPoint::GetBufferPointerv, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureGetFragDataLocation(const State &glState, |
| bool isCallValid, |
| ShaderProgramID programPacked, |
| const GLchar *name, |
| GLint returnValue) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked); |
| |
| ParamCapture nameParam("name", ParamType::TGLcharConstPointer); |
| InitParamValue(ParamType::TGLcharConstPointer, name, &nameParam.value); |
| CaptureGetFragDataLocation_name(glState, isCallValid, programPacked, name, &nameParam); |
| paramBuffer.addParam(std::move(nameParam)); |
| |
| ParamCapture returnValueCapture("returnValue", ParamType::TGLint); |
| InitParamValue(ParamType::TGLint, returnValue, &returnValueCapture.value); |
| paramBuffer.addReturnValue(std::move(returnValueCapture)); |
| |
| return CallCapture(gl::EntryPoint::GetFragDataLocation, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureGetInteger64i_v(const State &glState, |
| bool isCallValid, |
| GLenum target, |
| GLuint index, |
| GLint64 *data) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addEnumParam("target", GLenumGroup::TypeEnum, ParamType::TGLenum, target); |
| paramBuffer.addValueParam("index", ParamType::TGLuint, index); |
| |
| ParamCapture dataParam("data", ParamType::TGLint64Pointer); |
| InitParamValue(ParamType::TGLint64Pointer, data, &dataParam.value); |
| CaptureGetInteger64i_v_data(glState, isCallValid, target, index, data, &dataParam); |
| paramBuffer.addParam(std::move(dataParam)); |
| |
| return CallCapture(gl::EntryPoint::GetInteger64i_v, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureGetInteger64v(const State &glState, |
| bool isCallValid, |
| GLenum pname, |
| GLint64 *data) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addEnumParam("pname", GLenumGroup::GetPName, ParamType::TGLenum, pname); |
| |
| ParamCapture dataParam("data", ParamType::TGLint64Pointer); |
| InitParamValue(ParamType::TGLint64Pointer, data, &dataParam.value); |
| CaptureGetInteger64v_data(glState, isCallValid, pname, data, &dataParam); |
| paramBuffer.addParam(std::move(dataParam)); |
| |
| return CallCapture(gl::EntryPoint::GetInteger64v, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureGetIntegeri_v(const State &glState, |
| bool isCallValid, |
| GLenum target, |
| GLuint index, |
| GLint *data) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addEnumParam("target", GLenumGroup::TypeEnum, ParamType::TGLenum, target); |
| paramBuffer.addValueParam("index", ParamType::TGLuint, index); |
| |
| ParamCapture dataParam("data", ParamType::TGLintPointer); |
| InitParamValue(ParamType::TGLintPointer, data, &dataParam.value); |
| CaptureGetIntegeri_v_data(glState, isCallValid, target, index, data, &dataParam); |
| paramBuffer.addParam(std::move(dataParam)); |
| |
| return CallCapture(gl::EntryPoint::GetIntegeri_v, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureGetInternalformativ(const State &glState, |
| bool isCallValid, |
| GLenum target, |
| GLenum internalformat, |
| GLenum pname, |
| GLsizei bufSize, |
| GLint *params) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addEnumParam("target", GLenumGroup::TextureTarget, ParamType::TGLenum, target); |
| paramBuffer.addEnumParam("internalformat", GLenumGroup::InternalFormat, ParamType::TGLenum, |
| internalformat); |
| paramBuffer.addEnumParam("pname", GLenumGroup::InternalFormatPName, ParamType::TGLenum, pname); |
| paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize); |
| |
| ParamCapture paramsParam("params", ParamType::TGLintPointer); |
| InitParamValue(ParamType::TGLintPointer, params, ¶msParam.value); |
| CaptureGetInternalformativ_params(glState, isCallValid, target, internalformat, pname, bufSize, |
| params, ¶msParam); |
| paramBuffer.addParam(std::move(paramsParam)); |
| |
| return CallCapture(gl::EntryPoint::GetInternalformativ, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureGetProgramBinary(const State &glState, |
| bool isCallValid, |
| ShaderProgramID programPacked, |
| GLsizei bufSize, |
| GLsizei *length, |
| GLenum *binaryFormat, |
| void *binary) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked); |
| paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize); |
| |
| ParamCapture lengthParam("length", ParamType::TGLsizeiPointer); |
| InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value); |
| CaptureGetProgramBinary_length(glState, isCallValid, programPacked, bufSize, length, |
| binaryFormat, binary, &lengthParam); |
| paramBuffer.addParam(std::move(lengthParam)); |
| |
| ParamCapture binaryFormatParam("binaryFormat", ParamType::TGLenumPointer); |
| InitParamValue(ParamType::TGLenumPointer, binaryFormat, &binaryFormatParam.value); |
| CaptureGetProgramBinary_binaryFormat(glState, isCallValid, programPacked, bufSize, length, |
| binaryFormat, binary, &binaryFormatParam); |
| paramBuffer.addParam(std::move(binaryFormatParam)); |
| |
| ParamCapture binaryParam("binary", ParamType::TvoidPointer); |
| InitParamValue(ParamType::TvoidPointer, binary, &binaryParam.value); |
| CaptureGetProgramBinary_binary(glState, isCallValid, programPacked, bufSize, length, |
| binaryFormat, binary, &binaryParam); |
| paramBuffer.addParam(std::move(binaryParam)); |
| |
| return CallCapture(gl::EntryPoint::GetProgramBinary, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureGetQueryObjectuiv(const State &glState, |
| bool isCallValid, |
| QueryID idPacked, |
| GLenum pname, |
| GLuint *params) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("idPacked", ParamType::TQueryID, idPacked); |
| paramBuffer.addEnumParam("pname", GLenumGroup::QueryObjectParameterName, ParamType::TGLenum, |
| pname); |
| |
| ParamCapture paramsParam("params", ParamType::TGLuintPointer); |
| InitParamValue(ParamType::TGLuintPointer, params, ¶msParam.value); |
| CaptureGetQueryObjectuiv_params(glState, isCallValid, idPacked, pname, params, ¶msParam); |
| paramBuffer.addParam(std::move(paramsParam)); |
| |
| return CallCapture(gl::EntryPoint::GetQueryObjectuiv, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureGetQueryiv(const State &glState, |
| bool isCallValid, |
| QueryType targetPacked, |
| GLenum pname, |
| GLint *params) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("targetPacked", ParamType::TQueryType, targetPacked); |
| paramBuffer.addEnumParam("pname", GLenumGroup::QueryParameterName, ParamType::TGLenum, pname); |
| |
| ParamCapture paramsParam("params", ParamType::TGLintPointer); |
| InitParamValue(ParamType::TGLintPointer, params, ¶msParam.value); |
| CaptureGetQueryiv_params(glState, isCallValid, targetPacked, pname, params, ¶msParam); |
| paramBuffer.addParam(std::move(paramsParam)); |
| |
| return CallCapture(gl::EntryPoint::GetQueryiv, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureGetSamplerParameterfv(const State &glState, |
| bool isCallValid, |
| SamplerID samplerPacked, |
| GLenum pname, |
| GLfloat *params) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("samplerPacked", ParamType::TSamplerID, samplerPacked); |
| paramBuffer.addEnumParam("pname", GLenumGroup::SamplerParameterName, ParamType::TGLenum, pname); |
| |
| ParamCapture paramsParam("params", ParamType::TGLfloatPointer); |
| InitParamValue(ParamType::TGLfloatPointer, params, ¶msParam.value); |
| CaptureGetSamplerParameterfv_params(glState, isCallValid, samplerPacked, pname, params, |
| ¶msParam); |
| paramBuffer.addParam(std::move(paramsParam)); |
| |
| return CallCapture(gl::EntryPoint::GetSamplerParameterfv, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureGetSamplerParameteriv(const State &glState, |
| bool isCallValid, |
| SamplerID samplerPacked, |
| GLenum pname, |
| GLint *params) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("samplerPacked", ParamType::TSamplerID, samplerPacked); |
| paramBuffer.addEnumParam("pname", GLenumGroup::SamplerParameterName, ParamType::TGLenum, pname); |
| |
| ParamCapture paramsParam("params", ParamType::TGLintPointer); |
| InitParamValue(ParamType::TGLintPointer, params, ¶msParam.value); |
| CaptureGetSamplerParameteriv_params(glState, isCallValid, samplerPacked, pname, params, |
| ¶msParam); |
| paramBuffer.addParam(std::move(paramsParam)); |
| |
| return CallCapture(gl::EntryPoint::GetSamplerParameteriv, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureGetStringi(const State &glState, |
| bool isCallValid, |
| GLenum name, |
| GLuint index, |
| const GLubyte *returnValue) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addEnumParam("name", GLenumGroup::StringName, ParamType::TGLenum, name); |
| paramBuffer.addValueParam("index", ParamType::TGLuint, index); |
| |
| ParamCapture returnValueCapture("returnValue", ParamType::TGLubyteConstPointer); |
| InitParamValue(ParamType::TGLubyteConstPointer, returnValue, &returnValueCapture.value); |
| paramBuffer.addReturnValue(std::move(returnValueCapture)); |
| |
| return CallCapture(gl::EntryPoint::GetStringi, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureGetSynciv(const State &glState, |
| bool isCallValid, |
| GLsync sync, |
| GLenum pname, |
| GLsizei bufSize, |
| GLsizei *length, |
| GLint *values) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("sync", ParamType::TGLsync, sync); |
| paramBuffer.addEnumParam("pname", GLenumGroup::SyncParameterName, ParamType::TGLenum, pname); |
| paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize); |
| |
| ParamCapture lengthParam("length", ParamType::TGLsizeiPointer); |
| InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value); |
| CaptureGetSynciv_length(glState, isCallValid, sync, pname, bufSize, length, values, |
| &lengthParam); |
| paramBuffer.addParam(std::move(lengthParam)); |
| |
| ParamCapture valuesParam("values", ParamType::TGLintPointer); |
| InitParamValue(ParamType::TGLintPointer, values, &valuesParam.value); |
| CaptureGetSynciv_values(glState, isCallValid, sync, pname, bufSize, length, values, |
| &valuesParam); |
| paramBuffer.addParam(std::move(valuesParam)); |
| |
| return CallCapture(gl::EntryPoint::GetSynciv, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureGetTransformFeedbackVarying(const State &glState, |
| bool isCallValid, |
| ShaderProgramID programPacked, |
| GLuint index, |
| GLsizei bufSize, |
| GLsizei *length, |
| GLsizei *size, |
| GLenum *type, |
| GLchar *name) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked); |
| paramBuffer.addValueParam("index", ParamType::TGLuint, index); |
| paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize); |
| |
| ParamCapture lengthParam("length", ParamType::TGLsizeiPointer); |
| InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value); |
| CaptureGetTransformFeedbackVarying_length(glState, isCallValid, programPacked, index, bufSize, |
| length, size, type, name, &lengthParam); |
| paramBuffer.addParam(std::move(lengthParam)); |
| |
| ParamCapture sizeParam("size", ParamType::TGLsizeiPointer); |
| InitParamValue(ParamType::TGLsizeiPointer, size, &sizeParam.value); |
| CaptureGetTransformFeedbackVarying_size(glState, isCallValid, programPacked, index, bufSize, |
| length, size, type, name, &sizeParam); |
| paramBuffer.addParam(std::move(sizeParam)); |
| |
| ParamCapture typeParam("type", ParamType::TGLenumPointer); |
| InitParamValue(ParamType::TGLenumPointer, type, &typeParam.value); |
| CaptureGetTransformFeedbackVarying_type(glState, isCallValid, programPacked, index, bufSize, |
| length, size, type, name, &typeParam); |
| paramBuffer.addParam(std::move(typeParam)); |
| |
| ParamCapture nameParam("name", ParamType::TGLcharPointer); |
| InitParamValue(ParamType::TGLcharPointer, name, &nameParam.value); |
| CaptureGetTransformFeedbackVarying_name(glState, isCallValid, programPacked, index, bufSize, |
| length, size, type, name, &nameParam); |
| paramBuffer.addParam(std::move(nameParam)); |
| |
| return CallCapture(gl::EntryPoint::GetTransformFeedbackVarying, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureGetUniformBlockIndex(const State &glState, |
| bool isCallValid, |
| ShaderProgramID programPacked, |
| const GLchar *uniformBlockName, |
| GLuint returnValue) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked); |
| |
| ParamCapture uniformBlockNameParam("uniformBlockName", ParamType::TGLcharConstPointer); |
| InitParamValue(ParamType::TGLcharConstPointer, uniformBlockName, &uniformBlockNameParam.value); |
| CaptureGetUniformBlockIndex_uniformBlockName(glState, isCallValid, programPacked, |
| uniformBlockName, &uniformBlockNameParam); |
| paramBuffer.addParam(std::move(uniformBlockNameParam)); |
| |
| ParamCapture returnValueCapture("returnValue", ParamType::TGLuint); |
| InitParamValue(ParamType::TGLuint, returnValue, &returnValueCapture.value); |
| paramBuffer.addReturnValue(std::move(returnValueCapture)); |
| |
| return CallCapture(gl::EntryPoint::GetUniformBlockIndex, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureGetUniformIndices(const State &glState, |
| bool isCallValid, |
| ShaderProgramID programPacked, |
| GLsizei uniformCount, |
| const GLchar *const *uniformNames, |
| GLuint *uniformIndices) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked); |
| paramBuffer.addValueParam("uniformCount", ParamType::TGLsizei, uniformCount); |
| |
| ParamCapture uniformNamesParam("uniformNames", ParamType::TGLcharConstPointerPointer); |
| InitParamValue(ParamType::TGLcharConstPointerPointer, uniformNames, &uniformNamesParam.value); |
| CaptureGetUniformIndices_uniformNames(glState, isCallValid, programPacked, uniformCount, |
| uniformNames, uniformIndices, &uniformNamesParam); |
| paramBuffer.addParam(std::move(uniformNamesParam)); |
| |
| ParamCapture uniformIndicesParam("uniformIndices", ParamType::TGLuintPointer); |
| InitParamValue(ParamType::TGLuintPointer, uniformIndices, &uniformIndicesParam.value); |
| CaptureGetUniformIndices_uniformIndices(glState, isCallValid, programPacked, uniformCount, |
| uniformNames, uniformIndices, &uniformIndicesParam); |
| paramBuffer.addParam(std::move(uniformIndicesParam)); |
| |
| return CallCapture(gl::EntryPoint::GetUniformIndices, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureGetUniformuiv(const State &glState, |
| bool isCallValid, |
| ShaderProgramID programPacked, |
| GLint location, |
| GLuint *params) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked); |
| paramBuffer.addValueParam("location", ParamType::TGLint, location); |
| |
| ParamCapture paramsParam("params", ParamType::TGLuintPointer); |
| InitParamValue(ParamType::TGLuintPointer, params, ¶msParam.value); |
| CaptureGetUniformuiv_params(glState, isCallValid, programPacked, location, params, |
| ¶msParam); |
| paramBuffer.addParam(std::move(paramsParam)); |
| |
| return CallCapture(gl::EntryPoint::GetUniformuiv, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureGetVertexAttribIiv(const State &glState, |
| bool isCallValid, |
| GLuint index, |
| GLenum pname, |
| GLint *params) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("index", ParamType::TGLuint, index); |
| paramBuffer.addEnumParam("pname", GLenumGroup::VertexAttribEnum, ParamType::TGLenum, pname); |
| |
| ParamCapture paramsParam("params", ParamType::TGLintPointer); |
| InitParamValue(ParamType::TGLintPointer, params, ¶msParam.value); |
| CaptureGetVertexAttribIiv_params(glState, isCallValid, index, pname, params, ¶msParam); |
| paramBuffer.addParam(std::move(paramsParam)); |
| |
| return CallCapture(gl::EntryPoint::GetVertexAttribIiv, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureGetVertexAttribIuiv(const State &glState, |
| bool isCallValid, |
| GLuint index, |
| GLenum pname, |
| GLuint *params) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("index", ParamType::TGLuint, index); |
| paramBuffer.addEnumParam("pname", GLenumGroup::VertexAttribEnum, ParamType::TGLenum, pname); |
| |
| ParamCapture paramsParam("params", ParamType::TGLuintPointer); |
| InitParamValue(ParamType::TGLuintPointer, params, ¶msParam.value); |
| CaptureGetVertexAttribIuiv_params(glState, isCallValid, index, pname, params, ¶msParam); |
| paramBuffer.addParam(std::move(paramsParam)); |
| |
| return CallCapture(gl::EntryPoint::GetVertexAttribIuiv, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureInvalidateFramebuffer(const State &glState, |
| bool isCallValid, |
| GLenum target, |
| GLsizei numAttachments, |
| const GLenum *attachments) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addEnumParam("target", GLenumGroup::FramebufferTarget, ParamType::TGLenum, target); |
| paramBuffer.addValueParam("numAttachments", ParamType::TGLsizei, numAttachments); |
| |
| ParamCapture attachmentsParam("attachments", ParamType::TGLenumConstPointer); |
| InitParamValue(ParamType::TGLenumConstPointer, attachments, &attachmentsParam.value); |
| CaptureInvalidateFramebuffer_attachments(glState, isCallValid, target, numAttachments, |
| attachments, &attachmentsParam); |
| paramBuffer.addParam(std::move(attachmentsParam)); |
| |
| return CallCapture(gl::EntryPoint::InvalidateFramebuffer, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureInvalidateSubFramebuffer(const State &glState, |
| bool isCallValid, |
| GLenum target, |
| GLsizei numAttachments, |
| const GLenum *attachments, |
| GLint x, |
| GLint y, |
| GLsizei width, |
| GLsizei height) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addEnumParam("target", GLenumGroup::DefaultGroup, ParamType::TGLenum, target); |
| paramBuffer.addValueParam("numAttachments", ParamType::TGLsizei, numAttachments); |
| |
| ParamCapture attachmentsParam("attachments", ParamType::TGLenumConstPointer); |
| InitParamValue(ParamType::TGLenumConstPointer, attachments, &attachmentsParam.value); |
| CaptureInvalidateSubFramebuffer_attachments(glState, isCallValid, target, numAttachments, |
| attachments, x, y, width, height, |
| &attachmentsParam); |
| paramBuffer.addParam(std::move(attachmentsParam)); |
| |
| paramBuffer.addValueParam("x", ParamType::TGLint, x); |
| paramBuffer.addValueParam("y", ParamType::TGLint, y); |
| paramBuffer.addValueParam("width", ParamType::TGLsizei, width); |
| paramBuffer.addValueParam("height", ParamType::TGLsizei, height); |
| |
| return CallCapture(gl::EntryPoint::InvalidateSubFramebuffer, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureIsQuery(const State &glState, |
| bool isCallValid, |
| QueryID idPacked, |
| GLboolean returnValue) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("idPacked", ParamType::TQueryID, idPacked); |
| |
| ParamCapture returnValueCapture("returnValue", ParamType::TGLboolean); |
| InitParamValue(ParamType::TGLboolean, returnValue, &returnValueCapture.value); |
| paramBuffer.addReturnValue(std::move(returnValueCapture)); |
| |
| return CallCapture(gl::EntryPoint::IsQuery, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureIsSampler(const State &glState, |
| bool isCallValid, |
| SamplerID samplerPacked, |
| GLboolean returnValue) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("samplerPacked", ParamType::TSamplerID, samplerPacked); |
| |
| ParamCapture returnValueCapture("returnValue", ParamType::TGLboolean); |
| InitParamValue(ParamType::TGLboolean, returnValue, &returnValueCapture.value); |
| paramBuffer.addReturnValue(std::move(returnValueCapture)); |
| |
| return CallCapture(gl::EntryPoint::IsSampler, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureIsSync(const State &glState, |
| bool isCallValid, |
| GLsync sync, |
| GLboolean returnValue) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("sync", ParamType::TGLsync, sync); |
| |
| ParamCapture returnValueCapture("returnValue", ParamType::TGLboolean); |
| InitParamValue(ParamType::TGLboolean, returnValue, &returnValueCapture.value); |
| paramBuffer.addReturnValue(std::move(returnValueCapture)); |
| |
| return CallCapture(gl::EntryPoint::IsSync, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureIsTransformFeedback(const State &glState, |
| bool isCallValid, |
| TransformFeedbackID idPacked, |
| GLboolean returnValue) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("idPacked", ParamType::TTransformFeedbackID, idPacked); |
| |
| ParamCapture returnValueCapture("returnValue", ParamType::TGLboolean); |
| InitParamValue(ParamType::TGLboolean, returnValue, &returnValueCapture.value); |
| paramBuffer.addReturnValue(std::move(returnValueCapture)); |
| |
| return CallCapture(gl::EntryPoint::IsTransformFeedback, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureIsVertexArray(const State &glState, |
| bool isCallValid, |
| VertexArrayID arrayPacked, |
| GLboolean returnValue) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("arrayPacked", ParamType::TVertexArrayID, arrayPacked); |
| |
| ParamCapture returnValueCapture("returnValue", ParamType::TGLboolean); |
| InitParamValue(ParamType::TGLboolean, returnValue, &returnValueCapture.value); |
| paramBuffer.addReturnValue(std::move(returnValueCapture)); |
| |
| return CallCapture(gl::EntryPoint::IsVertexArray, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureMapBufferRange(const State &glState, |
| bool isCallValid, |
| BufferBinding targetPacked, |
| GLintptr offset, |
| GLsizeiptr length, |
| GLbitfield access, |
| void *returnValue) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("targetPacked", ParamType::TBufferBinding, targetPacked); |
| paramBuffer.addValueParam("offset", ParamType::TGLintptr, offset); |
| paramBuffer.addValueParam("length", ParamType::TGLsizeiptr, length); |
| paramBuffer.addEnumParam("access", GLenumGroup::BufferAccessMask, ParamType::TGLbitfield, |
| access); |
| |
| ParamCapture returnValueCapture("returnValue", ParamType::TvoidPointer); |
| InitParamValue(ParamType::TvoidPointer, returnValue, &returnValueCapture.value); |
| paramBuffer.addReturnValue(std::move(returnValueCapture)); |
| |
| return CallCapture(gl::EntryPoint::MapBufferRange, std::move(paramBuffer)); |
| } |
| |
| CallCapture CapturePauseTransformFeedback(const State &glState, bool isCallValid) |
| { |
| ParamBuffer paramBuffer; |
| |
| return CallCapture(gl::EntryPoint::PauseTransformFeedback, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureProgramBinary(const State &glState, |
| bool isCallValid, |
| ShaderProgramID programPacked, |
| GLenum binaryFormat, |
| const void *binary, |
| GLsizei length) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked); |
| paramBuffer.addEnumParam("binaryFormat", GLenumGroup::DefaultGroup, ParamType::TGLenum, |
| binaryFormat); |
| |
| ParamCapture binaryParam("binary", ParamType::TvoidConstPointer); |
| InitParamValue(ParamType::TvoidConstPointer, binary, &binaryParam.value); |
| CaptureProgramBinary_binary(glState, isCallValid, programPacked, binaryFormat, binary, length, |
| &binaryParam); |
| paramBuffer.addParam(std::move(binaryParam)); |
| |
| paramBuffer.addValueParam("length", ParamType::TGLsizei, length); |
| |
| return CallCapture(gl::EntryPoint::ProgramBinary, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureProgramParameteri(const State &glState, |
| bool isCallValid, |
| ShaderProgramID programPacked, |
| GLenum pname, |
| GLint value) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked); |
| paramBuffer.addEnumParam("pname", GLenumGroup::ProgramParameterPName, ParamType::TGLenum, |
| pname); |
| paramBuffer.addValueParam("value", ParamType::TGLint, value); |
| |
| return CallCapture(gl::EntryPoint::ProgramParameteri, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureReadBuffer(const State &glState, bool isCallValid, GLenum src) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addEnumParam("src", GLenumGroup::ReadBufferMode, ParamType::TGLenum, src); |
| |
| return CallCapture(gl::EntryPoint::ReadBuffer, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureRenderbufferStorageMultisample(const State &glState, |
| bool isCallValid, |
| GLenum target, |
| GLsizei samples, |
| GLenum internalformat, |
| GLsizei width, |
| GLsizei height) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addEnumParam("target", GLenumGroup::RenderbufferTarget, ParamType::TGLenum, target); |
| paramBuffer.addValueParam("samples", ParamType::TGLsizei, samples); |
| paramBuffer.addEnumParam("internalformat", GLenumGroup::InternalFormat, ParamType::TGLenum, |
| internalformat); |
| paramBuffer.addValueParam("width", ParamType::TGLsizei, width); |
| paramBuffer.addValueParam("height", ParamType::TGLsizei, height); |
| |
| return CallCapture(gl::EntryPoint::RenderbufferStorageMultisample, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureResumeTransformFeedback(const State &glState, bool isCallValid) |
| { |
| ParamBuffer paramBuffer; |
| |
| return CallCapture(gl::EntryPoint::ResumeTransformFeedback, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureSamplerParameterf(const State &glState, |
| bool isCallValid, |
| SamplerID samplerPacked, |
| GLenum pname, |
| GLfloat param) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("samplerPacked", ParamType::TSamplerID, samplerPacked); |
| paramBuffer.addEnumParam("pname", GLenumGroup::SamplerParameterName, ParamType::TGLenum, pname); |
| paramBuffer.addValueParam("param", ParamType::TGLfloat, param); |
| |
| return CallCapture(gl::EntryPoint::SamplerParameterf, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureSamplerParameterfv(const State &glState, |
| bool isCallValid, |
| SamplerID samplerPacked, |
| GLenum pname, |
| const GLfloat *param) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("samplerPacked", ParamType::TSamplerID, samplerPacked); |
| paramBuffer.addEnumParam("pname", GLenumGroup::SamplerParameterName, ParamType::TGLenum, pname); |
| |
| ParamCapture paramParam("param", ParamType::TGLfloatConstPointer); |
| InitParamValue(ParamType::TGLfloatConstPointer, param, ¶mParam.value); |
| CaptureSamplerParameterfv_param(glState, isCallValid, samplerPacked, pname, param, ¶mParam); |
| paramBuffer.addParam(std::move(paramParam)); |
| |
| return CallCapture(gl::EntryPoint::SamplerParameterfv, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureSamplerParameteri(const State &glState, |
| bool isCallValid, |
| SamplerID samplerPacked, |
| GLenum pname, |
| GLint param) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("samplerPacked", ParamType::TSamplerID, samplerPacked); |
| paramBuffer.addEnumParam("pname", GLenumGroup::SamplerParameterName, ParamType::TGLenum, pname); |
| paramBuffer.addValueParam("param", ParamType::TGLint, param); |
| |
| return CallCapture(gl::EntryPoint::SamplerParameteri, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureSamplerParameteriv(const State &glState, |
| bool isCallValid, |
| SamplerID samplerPacked, |
| GLenum pname, |
| const GLint *param) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("samplerPacked", ParamType::TSamplerID, samplerPacked); |
| paramBuffer.addEnumParam("pname", GLenumGroup::SamplerParameterName, ParamType::TGLenum, pname); |
| |
| ParamCapture paramParam("param", ParamType::TGLintConstPointer); |
| InitParamValue(ParamType::TGLintConstPointer, param, ¶mParam.value); |
| CaptureSamplerParameteriv_param(glState, isCallValid, samplerPacked, pname, param, ¶mParam); |
| paramBuffer.addParam(std::move(paramParam)); |
| |
| return CallCapture(gl::EntryPoint::SamplerParameteriv, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureTexImage3D(const State &glState, |
| bool isCallValid, |
| TextureTarget targetPacked, |
| GLint level, |
| GLint internalformat, |
| GLsizei width, |
| GLsizei height, |
| GLsizei depth, |
| GLint border, |
| GLenum format, |
| GLenum type, |
| const void *pixels) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("targetPacked", ParamType::TTextureTarget, targetPacked); |
| paramBuffer.addValueParam("level", ParamType::TGLint, level); |
| paramBuffer.addValueParam("internalformat", ParamType::TGLint, internalformat); |
| paramBuffer.addValueParam("width", ParamType::TGLsizei, width); |
| paramBuffer.addValueParam("height", ParamType::TGLsizei, height); |
| paramBuffer.addValueParam("depth", ParamType::TGLsizei, depth); |
| paramBuffer.addValueParam("border", ParamType::TGLint, border); |
| paramBuffer.addEnumParam("format", GLenumGroup::PixelFormat, ParamType::TGLenum, format); |
| paramBuffer.addEnumParam("type", GLenumGroup::PixelType, ParamType::TGLenum, type); |
| |
| ParamCapture pixelsParam("pixels", ParamType::TvoidConstPointer); |
| InitParamValue(ParamType::TvoidConstPointer, pixels, &pixelsParam.value); |
| CaptureTexImage3D_pixels(glState, isCallValid, targetPacked, level, internalformat, width, |
| height, depth, border, format, type, pixels, &pixelsParam); |
| paramBuffer.addParam(std::move(pixelsParam)); |
| |
| return CallCapture(gl::EntryPoint::TexImage3D, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureTexStorage2D(const State &glState, |
| bool isCallValid, |
| TextureType targetPacked, |
| GLsizei levels, |
| GLenum internalformat, |
| GLsizei width, |
| GLsizei height) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("targetPacked", ParamType::TTextureType, targetPacked); |
| paramBuffer.addValueParam("levels", ParamType::TGLsizei, levels); |
| paramBuffer.addEnumParam("internalformat", GLenumGroup::InternalFormat, ParamType::TGLenum, |
| internalformat); |
| paramBuffer.addValueParam("width", ParamType::TGLsizei, width); |
| paramBuffer.addValueParam("height", ParamType::TGLsizei, height); |
| |
| return CallCapture(gl::EntryPoint::TexStorage2D, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureTexStorage3D(const State &glState, |
| bool isCallValid, |
| TextureType targetPacked, |
| GLsizei levels, |
| GLenum internalformat, |
| GLsizei width, |
| GLsizei height, |
| GLsizei depth) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("targetPacked", ParamType::TTextureType, targetPacked); |
| paramBuffer.addValueParam("levels", ParamType::TGLsizei, levels); |
| paramBuffer.addEnumParam("internalformat", GLenumGroup::InternalFormat, ParamType::TGLenum, |
| internalformat); |
| paramBuffer.addValueParam("width", ParamType::TGLsizei, width); |
| paramBuffer.addValueParam("height", ParamType::TGLsizei, height); |
| paramBuffer.addValueParam("depth", ParamType::TGLsizei, depth); |
| |
| return CallCapture(gl::EntryPoint::TexStorage3D, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureTexSubImage3D(const State &glState, |
| bool isCallValid, |
| TextureTarget targetPacked, |
| GLint level, |
| GLint xoffset, |
| GLint yoffset, |
| GLint zoffset, |
| GLsizei width, |
| GLsizei height, |
| GLsizei depth, |
| GLenum format, |
| GLenum type, |
| const void *pixels) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("targetPacked", ParamType::TTextureTarget, targetPacked); |
| paramBuffer.addValueParam("level", ParamType::TGLint, level); |
| paramBuffer.addValueParam("xoffset", ParamType::TGLint, xoffset); |
| paramBuffer.addValueParam("yoffset", ParamType::TGLint, yoffset); |
| paramBuffer.addValueParam("zoffset", ParamType::TGLint, zoffset); |
| paramBuffer.addValueParam("width", ParamType::TGLsizei, width); |
| paramBuffer.addValueParam("height", ParamType::TGLsizei, height); |
| paramBuffer.addValueParam("depth", ParamType::TGLsizei, depth); |
| paramBuffer.addEnumParam("format", GLenumGroup::PixelFormat, ParamType::TGLenum, format); |
| paramBuffer.addEnumParam("type", GLenumGroup::PixelType, ParamType::TGLenum, type); |
| |
| ParamCapture pixelsParam("pixels", ParamType::TvoidConstPointer); |
| InitParamValue(ParamType::TvoidConstPointer, pixels, &pixelsParam.value); |
| CaptureTexSubImage3D_pixels(glState, isCallValid, targetPacked, level, xoffset, yoffset, |
| zoffset, width, height, depth, format, type, pixels, &pixelsParam); |
| paramBuffer.addParam(std::move(pixelsParam)); |
| |
| return CallCapture(gl::EntryPoint::TexSubImage3D, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureTransformFeedbackVaryings(const State &glState, |
| bool isCallValid, |
| ShaderProgramID programPacked, |
| GLsizei count, |
| const GLchar *const *varyings, |
| GLenum bufferMode) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked); |
| paramBuffer.addValueParam("count", ParamType::TGLsizei, count); |
| |
| ParamCapture varyingsParam("varyings", ParamType::TGLcharConstPointerPointer); |
| InitParamValue(ParamType::TGLcharConstPointerPointer, varyings, &varyingsParam.value); |
| CaptureTransformFeedbackVaryings_varyings(glState, isCallValid, programPacked, count, varyings, |
| bufferMode, &varyingsParam); |
| paramBuffer.addParam(std::move(varyingsParam)); |
| |
| paramBuffer.addEnumParam("bufferMode", GLenumGroup::DefaultGroup, ParamType::TGLenum, |
| bufferMode); |
| |
| return CallCapture(gl::EntryPoint::TransformFeedbackVaryings, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureUniform1ui(const State &glState, bool isCallValid, GLint location, GLuint v0) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("location", ParamType::TGLint, location); |
| paramBuffer.addValueParam("v0", ParamType::TGLuint, v0); |
| |
| return CallCapture(gl::EntryPoint::Uniform1ui, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureUniform1uiv(const State &glState, |
| bool isCallValid, |
| GLint location, |
| GLsizei count, |
| const GLuint *value) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("location", ParamType::TGLint, location); |
| paramBuffer.addValueParam("count", ParamType::TGLsizei, count); |
| |
| ParamCapture valueParam("value", ParamType::TGLuintConstPointer); |
| InitParamValue(ParamType::TGLuintConstPointer, value, &valueParam.value); |
| CaptureUniform1uiv_value(glState, isCallValid, location, count, value, &valueParam); |
| paramBuffer.addParam(std::move(valueParam)); |
| |
| return CallCapture(gl::EntryPoint::Uniform1uiv, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureUniform2ui(const State &glState, |
| bool isCallValid, |
| GLint location, |
| GLuint v0, |
| GLuint v1) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("location", ParamType::TGLint, location); |
| paramBuffer.addValueParam("v0", ParamType::TGLuint, v0); |
| paramBuffer.addValueParam("v1", ParamType::TGLuint, v1); |
| |
| return CallCapture(gl::EntryPoint::Uniform2ui, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureUniform2uiv(const State &glState, |
| bool isCallValid, |
| GLint location, |
| GLsizei count, |
| const GLuint *value) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("location", ParamType::TGLint, location); |
| paramBuffer.addValueParam("count", ParamType::TGLsizei, count); |
| |
| ParamCapture valueParam("value", ParamType::TGLuintConstPointer); |
| InitParamValue(ParamType::TGLuintConstPointer, value, &valueParam.value); |
| CaptureUniform2uiv_value(glState, isCallValid, location, count, value, &valueParam); |
| paramBuffer.addParam(std::move(valueParam)); |
| |
| return CallCapture(gl::EntryPoint::Uniform2uiv, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureUniform3ui(const State &glState, |
| bool isCallValid, |
| GLint location, |
| GLuint v0, |
| GLuint v1, |
| GLuint v2) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("location", ParamType::TGLint, location); |
| paramBuffer.addValueParam("v0", ParamType::TGLuint, v0); |
| paramBuffer.addValueParam("v1", ParamType::TGLuint, v1); |
| paramBuffer.addValueParam("v2", ParamType::TGLuint, v2); |
| |
| return CallCapture(gl::EntryPoint::Uniform3ui, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureUniform3uiv(const State &glState, |
| bool isCallValid, |
| GLint location, |
| GLsizei count, |
| const GLuint *value) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("location", ParamType::TGLint, location); |
| paramBuffer.addValueParam("count", ParamType::TGLsizei, count); |
| |
| ParamCapture valueParam("value", ParamType::TGLuintConstPointer); |
| InitParamValue(ParamType::TGLuintConstPointer, value, &valueParam.value); |
| CaptureUniform3uiv_value(glState, isCallValid, location, count, value, &valueParam); |
| paramBuffer.addParam(std::move(valueParam)); |
| |
| return CallCapture(gl::EntryPoint::Uniform3uiv, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureUniform4ui(const State &glState, |
| bool isCallValid, |
| GLint location, |
| GLuint v0, |
| GLuint v1, |
| GLuint v2, |
| GLuint v3) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("location", ParamType::TGLint, location); |
| paramBuffer.addValueParam("v0", ParamType::TGLuint, v0); |
| paramBuffer.addValueParam("v1", ParamType::TGLuint, v1); |
| paramBuffer.addValueParam("v2", ParamType::TGLuint, v2); |
| paramBuffer.addValueParam("v3", ParamType::TGLuint, v3); |
| |
| return CallCapture(gl::EntryPoint::Uniform4ui, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureUniform4uiv(const State &glState, |
| bool isCallValid, |
| GLint location, |
| GLsizei count, |
| const GLuint *value) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("location", ParamType::TGLint, location); |
| paramBuffer.addValueParam("count", ParamType::TGLsizei, count); |
| |
| ParamCapture valueParam("value", ParamType::TGLuintConstPointer); |
| InitParamValue(ParamType::TGLuintConstPointer, value, &valueParam.value); |
| CaptureUniform4uiv_value(glState, isCallValid, location, count, value, &valueParam); |
| paramBuffer.addParam(std::move(valueParam)); |
| |
| return CallCapture(gl::EntryPoint::Uniform4uiv, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureUniformBlockBinding(const State &glState, |
| bool isCallValid, |
| ShaderProgramID programPacked, |
| GLuint uniformBlockIndex, |
| GLuint uniformBlockBinding) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked); |
| paramBuffer.addValueParam("uniformBlockIndex", ParamType::TGLuint, uniformBlockIndex); |
| paramBuffer.addValueParam("uniformBlockBinding", ParamType::TGLuint, uniformBlockBinding); |
| |
| return CallCapture(gl::EntryPoint::UniformBlockBinding, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureUniformMatrix2x3fv(const State &glState, |
| bool isCallValid, |
| GLint location, |
| GLsizei count, |
| GLboolean transpose, |
| const GLfloat *value) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("location", ParamType::TGLint, location); |
| paramBuffer.addValueParam("count", ParamType::TGLsizei, count); |
| paramBuffer.addValueParam("transpose", ParamType::TGLboolean, transpose); |
| |
| ParamCapture valueParam("value", ParamType::TGLfloatConstPointer); |
| InitParamValue(ParamType::TGLfloatConstPointer, value, &valueParam.value); |
| CaptureUniformMatrix2x3fv_value(glState, isCallValid, location, count, transpose, value, |
| &valueParam); |
| paramBuffer.addParam(std::move(valueParam)); |
| |
| return CallCapture(gl::EntryPoint::UniformMatrix2x3fv, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureUniformMatrix2x4fv(const State &glState, |
| bool isCallValid, |
| GLint location, |
| GLsizei count, |
| GLboolean transpose, |
| const GLfloat *value) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("location", ParamType::TGLint, location); |
| paramBuffer.addValueParam("count", ParamType::TGLsizei, count); |
| paramBuffer.addValueParam("transpose", ParamType::TGLboolean, transpose); |
| |
| ParamCapture valueParam("value", ParamType::TGLfloatConstPointer); |
| InitParamValue(ParamType::TGLfloatConstPointer, value, &valueParam.value); |
| CaptureUniformMatrix2x4fv_value(glState, isCallValid, location, count, transpose, value, |
| &valueParam); |
| paramBuffer.addParam(std::move(valueParam)); |
| |
| return CallCapture(gl::EntryPoint::UniformMatrix2x4fv, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureUniformMatrix3x2fv(const State &glState, |
| bool isCallValid, |
| GLint location, |
| GLsizei count, |
| GLboolean transpose, |
| const GLfloat *value) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("location", ParamType::TGLint, location); |
| paramBuffer.addValueParam("count", ParamType::TGLsizei, count); |
| paramBuffer.addValueParam("transpose", ParamType::TGLboolean, transpose); |
| |
| ParamCapture valueParam("value", ParamType::TGLfloatConstPointer); |
| InitParamValue(ParamType::TGLfloatConstPointer, value, &valueParam.value); |
| CaptureUniformMatrix3x2fv_value(glState, isCallValid, location, count, transpose, value, |
| &valueParam); |
| paramBuffer.addParam(std::move(valueParam)); |
| |
| return CallCapture(gl::EntryPoint::UniformMatrix3x2fv, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureUniformMatrix3x4fv(const State &glState, |
| bool isCallValid, |
| GLint location, |
| GLsizei count, |
| GLboolean transpose, |
| const GLfloat *value) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("location", ParamType::TGLint, location); |
| paramBuffer.addValueParam("count", ParamType::TGLsizei, count); |
| paramBuffer.addValueParam("transpose", ParamType::TGLboolean, transpose); |
| |
| ParamCapture valueParam("value", ParamType::TGLfloatConstPointer); |
| InitParamValue(ParamType::TGLfloatConstPointer, value, &valueParam.value); |
| CaptureUniformMatrix3x4fv_value(glState, isCallValid, location, count, transpose, value, |
| &valueParam); |
| paramBuffer.addParam(std::move(valueParam)); |
| |
| return CallCapture(gl::EntryPoint::UniformMatrix3x4fv, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureUniformMatrix4x2fv(const State &glState, |
| bool isCallValid, |
| GLint location, |
| GLsizei count, |
| GLboolean transpose, |
| const GLfloat *value) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("location", ParamType::TGLint, location); |
| paramBuffer.addValueParam("count", ParamType::TGLsizei, count); |
| paramBuffer.addValueParam("transpose", ParamType::TGLboolean, transpose); |
| |
| ParamCapture valueParam("value", ParamType::TGLfloatConstPointer); |
| InitParamValue(ParamType::TGLfloatConstPointer, value, &valueParam.value); |
| CaptureUniformMatrix4x2fv_value(glState, isCallValid, location, count, transpose, value, |
| &valueParam); |
| paramBuffer.addParam(std::move(valueParam)); |
| |
| return CallCapture(gl::EntryPoint::UniformMatrix4x2fv, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureUniformMatrix4x3fv(const State &glState, |
| bool isCallValid, |
| GLint location, |
| GLsizei count, |
| GLboolean transpose, |
| const GLfloat *value) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("location", ParamType::TGLint, location); |
| paramBuffer.addValueParam("count", ParamType::TGLsizei, count); |
| paramBuffer.addValueParam("transpose", ParamType::TGLboolean, transpose); |
| |
| ParamCapture valueParam("value", ParamType::TGLfloatConstPointer); |
| InitParamValue(ParamType::TGLfloatConstPointer, value, &valueParam.value); |
| CaptureUniformMatrix4x3fv_value(glState, isCallValid, location, count, transpose, value, |
| &valueParam); |
| paramBuffer.addParam(std::move(valueParam)); |
| |
| return CallCapture(gl::EntryPoint::UniformMatrix4x3fv, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureUnmapBuffer(const State &glState, |
| bool isCallValid, |
| BufferBinding targetPacked, |
| GLboolean returnValue) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("targetPacked", ParamType::TBufferBinding, targetPacked); |
| |
| ParamCapture returnValueCapture("returnValue", ParamType::TGLboolean); |
| InitParamValue(ParamType::TGLboolean, returnValue, &returnValueCapture.value); |
| paramBuffer.addReturnValue(std::move(returnValueCapture)); |
| |
| return CallCapture(gl::EntryPoint::UnmapBuffer, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureVertexAttribDivisor(const State &glState, |
| bool isCallValid, |
| GLuint index, |
| GLuint divisor) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("index", ParamType::TGLuint, index); |
| paramBuffer.addValueParam("divisor", ParamType::TGLuint, divisor); |
| |
| return CallCapture(gl::EntryPoint::VertexAttribDivisor, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureVertexAttribI4i(const State &glState, |
| bool isCallValid, |
| GLuint index, |
| GLint x, |
| GLint y, |
| GLint z, |
| GLint w) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("index", ParamType::TGLuint, index); |
| paramBuffer.addValueParam("x", ParamType::TGLint, x); |
| paramBuffer.addValueParam("y", ParamType::TGLint, y); |
| paramBuffer.addValueParam("z", ParamType::TGLint, z); |
| paramBuffer.addValueParam("w", ParamType::TGLint, w); |
| |
| return CallCapture(gl::EntryPoint::VertexAttribI4i, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureVertexAttribI4iv(const State &glState, |
| bool isCallValid, |
| GLuint index, |
| const GLint *v) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("index", ParamType::TGLuint, index); |
| |
| ParamCapture vParam("v", ParamType::TGLintConstPointer); |
| InitParamValue(ParamType::TGLintConstPointer, v, &vParam.value); |
| CaptureVertexAttribI4iv_v(glState, isCallValid, index, v, &vParam); |
| paramBuffer.addParam(std::move(vParam)); |
| |
| return CallCapture(gl::EntryPoint::VertexAttribI4iv, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureVertexAttribI4ui(const State &glState, |
| bool isCallValid, |
| GLuint index, |
| GLuint x, |
| GLuint y, |
| GLuint z, |
| GLuint w) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("index", ParamType::TGLuint, index); |
| paramBuffer.addValueParam("x", ParamType::TGLuint, x); |
| paramBuffer.addValueParam("y", ParamType::TGLuint, y); |
| paramBuffer.addValueParam("z", ParamType::TGLuint, z); |
| paramBuffer.addValueParam("w", ParamType::TGLuint, w); |
| |
| return CallCapture(gl::EntryPoint::VertexAttribI4ui, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureVertexAttribI4uiv(const State &glState, |
| bool isCallValid, |
| GLuint index, |
| const GLuint *v) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("index", ParamType::TGLuint, index); |
| |
| ParamCapture vParam("v", ParamType::TGLuintConstPointer); |
| InitParamValue(ParamType::TGLuintConstPointer, v, &vParam.value); |
| CaptureVertexAttribI4uiv_v(glState, isCallValid, index, v, &vParam); |
| paramBuffer.addParam(std::move(vParam)); |
| |
| return CallCapture(gl::EntryPoint::VertexAttribI4uiv, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureVertexAttribIPointer(const State &glState, |
| bool isCallValid, |
| GLuint index, |
| GLint size, |
| VertexAttribType typePacked, |
| GLsizei stride, |
| const void *pointer) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("index", ParamType::TGLuint, index); |
| paramBuffer.addValueParam("size", ParamType::TGLint, size); |
| paramBuffer.addValueParam("typePacked", ParamType::TVertexAttribType, typePacked); |
| paramBuffer.addValueParam("stride", ParamType::TGLsizei, stride); |
| |
| ParamCapture pointerParam("pointer", ParamType::TvoidConstPointer); |
| InitParamValue(ParamType::TvoidConstPointer, pointer, &pointerParam.value); |
| CaptureVertexAttribIPointer_pointer(glState, isCallValid, index, size, typePacked, stride, |
| pointer, &pointerParam); |
| paramBuffer.addParam(std::move(pointerParam)); |
| |
| return CallCapture(gl::EntryPoint::VertexAttribIPointer, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureWaitSync(const State &glState, |
| bool isCallValid, |
| GLsync sync, |
| GLbitfield flags, |
| GLuint64 timeout) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("sync", ParamType::TGLsync, sync); |
| paramBuffer.addEnumParam("flags", GLenumGroup::DefaultGroup, ParamType::TGLbitfield, flags); |
| paramBuffer.addValueParam("timeout", ParamType::TGLuint64, timeout); |
| |
| return CallCapture(gl::EntryPoint::WaitSync, std::move(paramBuffer)); |
| } |
| |
| } // namespace gl |
