swung0x48/MobileGL
1
0
Fork 0
mirror of https://github.com/MobileGL-Dev/MobileGL synced 2026-11-07 01:53:24 +09:00
Code Issues Packages Projects Releases Wiki Activity
Files
4e48702f26f5297b33e192b40cf8d1d2395b6aa2
MobileGL/MobileGL/MG_Client/generated_wire_client.h
T
BZLZHH 4e48702f26 [Feat] (MG_Remote): a record can tell the server its answer will never be read - the bit works and cuts a frame's replies by 92%, and it proves the window's real blocker is the FIFO drain, not the pool depth 
The create window could not collect its deferred answers. The previous commit
diagnosed that as the reply pool being 8 slots deep against 55,903 replies in one
frame, and left a no-reply bit as the way out. This lands that bit, measures it on
the device, and reports that the diagnosis was half wrong.

WHAT LANDED. ClientSession::EmitAndWaitTails takes a second question beside
wantReply: willReadReply. They are not the same question and the window is the case
that separates them - it emits with wantReply=false and READS the answer later, so
its records must still be answered. kRecNoReply (RingRecordFlags bit 5, which
aliases kOptional in the call-flag space; the flag-space asserts were extended and
the alias named) is stamped when willReadReply is false, and the decoder skips
PostReply while keeping every acceptance counter - "nobody reads the answer" is not
"nothing happened". The two illegal combinations are Fatal by name.

Three call sites say it: SetTextureParams for a confirmed object, the respecify
row's fire-and-forget half, and sub-data where MGPipeSubDataWantsItsReply decides.

MEASURED ON THE DEVICE (aikjs4s8cys8ba7l, rebuilt APK + client, both halves new):
    server:  skipped=50,001   answered=4,521        (a frame's replies: 55,903 -> 4,543)
    client:  Reply frames received seen=4,501, latest seq=97,181
    frame-sent: identical per op, records untouched
    create row: by_op 2 = 9,070 (was 4,536)  - because the drain's blocking take is
               now counted, so the row's number stays honest instead of reading as
               "create stopped waiting" while the waiting merely moved
AND THE WINDOW STILL READ BACK NOTHING: readfail 8,951 -> 8,872, i.e. -0.9%.

THE REAL CAUSE, from the miss probe:
    P12miss n=1     want=310 replySeq=1504   ring=[1175..1504]
    P12miss n=9001  want=310 replySeq=102915 ring=[102866..102915]
want=310 every time. The drain is STRICTLY FIFO and a failed read has no way out -
it retries the same head for ever. Any reply buffer is bounded by design (8 pool
slots, or the 8-frame ring the stream link now keeps), so with 4,536 deferred
answers at least one is overwritten before it is read, and that one wedges the
window permanently. Cutting the churn by two orders of magnitude does not help: it
turns a certainty into a certainty. That is the constraint, not the depth.

THE FIX IS NAMED AND NOT TAKEN (the goal this work ran under stops here on purpose).
On a failed read of the head, abandon it: MGPipeNoteHandleUnpublished +
NoteCreateSuspect + pop - the DECLINE path reused for "unknown". The window then
self-heals through the blocking path and the object merely gets slower. It needs its
own gate: a failed read must let the window ADVANCE.

Gates, all green (172 + 13 + 22 + 103):
  PipeWireCodecTest.TheNoReplyBitSkipsTheAnswerAndKeepsTheAcceptanceRecord - the skip,
    the kept tally, the answered/skipped split, and the negative control that a record
    WITHOUT the bit is still answered (a server that stopped answering everything
    would otherwise pass)
  RemoteClientControls.ACreateWindowDefersTheAnswersAndTheWindowOffDoesNot - now also
    asserts the answers CAME BACK (answers_taken=11, outstanding=1, fallbacks=0 against
    12 records). RED-ONCE PROVED: giving the window's creates the literal
    "fire-and-forget => skip" predicate makes this case fail.
  RingTest - the sixth and last flag alias, and the hand-written exhaustiveness list
    extended (with a note that it is only as exhaustive as that list).
  Server side: AnsweredRecords()/SkippedAnswers() - the number that made this
    debuggable, since a wire change whose effect is invisible is undebuggable.

Client-first is safe: an old server ignores bit 5 and replies as before, so the two
cross-version directions degrade to today's behaviour - this is "both ends must
upgrade to take EFFECT", not "to avoid breaking". Hit that in practice first.
2026-09-26 02:00:44 +08:00

10895 lines
816 KiB
C++
Raw Blame History

// MobileGL - MobileGL/MG_Client/generated_wire_client.h
// Copyright (c) 2025-2026 MobileGL-Dev
// Licensed under the GNU Lesser General Public License v3.0:
// SPDX-License-Identifier: LGPL-3.0-only
// End of Source File Header
#pragma once
#include <vector>
#include "MG_Client/Client.h"
#include "MG_Protocol/generated_opcodes.h"
#include "MG_Protocol/gen/wire_full_generated.h"
// GENERATED by scripts/generate_wire_client.py
namespace MobileGL::Client::Wire {
inline constexpr uint32_t kWireClientWrappedCount = 1208u;
inline Bool SendEglBindAPI(Uint64 sessionId, uint32_t api, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenEglBindAPI(builder, api);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::eglBindAPI), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendEglBindTexImage(Uint64 sessionId, uint64_t dpy, uint64_t surface, int32_t buffer, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenEglBindTexImage(builder, dpy, surface, buffer);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::eglBindTexImage), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendEglChooseConfig(Uint64 sessionId, uint64_t dpy, const std::vector<int32_t>& attrib_list, int32_t config_size, Uint64 token, MobileGLShmHandle* shm = nullptr, Uint32 outCapacity = 0) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenEglChooseConfig(builder, dpy, builder.CreateVector(attrib_list), 0, config_size, 0);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::eglChooseConfig), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm, outCapacity);
}
inline Bool SendEglClientWaitSync(Uint64 sessionId, uint64_t dpy, uint64_t sync, int32_t flags, int64_t timeout, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenEglClientWaitSync(builder, dpy, sync, flags, timeout);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::eglClientWaitSync), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendEglCopyBuffers(Uint64 sessionId, uint64_t dpy, uint64_t surface, uint64_t target, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenEglCopyBuffers(builder, dpy, surface, target);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::eglCopyBuffers), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendEglCreateContext(Uint64 sessionId, uint64_t dpy, uint64_t config, uint64_t shareCtx, const std::vector<int32_t>& attrib_list, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenEglCreateContext(builder, dpy, config, shareCtx, builder.CreateVector(attrib_list));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::eglCreateContext), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendEglCreateImage(Uint64 sessionId, uint64_t dpy, uint64_t ctx, uint32_t target, uint64_t buffer, const std::vector<uint64_t>& attrib_list, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenEglCreateImage(builder, dpy, ctx, target, buffer, builder.CreateVector(attrib_list));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::eglCreateImage), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendEglCreatePbufferFromClientBuffer(Uint64 sessionId, uint64_t dpy, uint32_t buftype, uint64_t buffer, uint64_t config, const std::vector<int32_t>& attrib_list, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenEglCreatePbufferFromClientBuffer(builder, dpy, buftype, buffer, config, builder.CreateVector(attrib_list));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::eglCreatePbufferFromClientBuffer), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendEglCreatePbufferSurface(Uint64 sessionId, uint64_t dpy, uint64_t config, const std::vector<int32_t>& attrib_list, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenEglCreatePbufferSurface(builder, dpy, config, builder.CreateVector(attrib_list));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::eglCreatePbufferSurface), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendEglCreatePixmapSurface(Uint64 sessionId, uint64_t dpy, uint64_t config, uint64_t pixmap, const std::vector<int32_t>& attrib_list, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenEglCreatePixmapSurface(builder, dpy, config, pixmap, builder.CreateVector(attrib_list));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::eglCreatePixmapSurface), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendEglCreatePlatformPixmapSurface(Uint64 sessionId, uint64_t dpy, uint64_t config, uint64_t native_pixmap, const std::vector<uint64_t>& attrib_list, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenEglCreatePlatformPixmapSurface(builder, dpy, config, native_pixmap, builder.CreateVector(attrib_list));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::eglCreatePlatformPixmapSurface), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendEglCreatePlatformWindowSurface(Uint64 sessionId, uint64_t dpy, uint64_t config, uint64_t native_window, const std::vector<uint64_t>& attrib_list, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenEglCreatePlatformWindowSurface(builder, dpy, config, native_window, builder.CreateVector(attrib_list));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::eglCreatePlatformWindowSurface), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendEglCreateSync(Uint64 sessionId, uint64_t dpy, uint32_t type, const std::vector<uint64_t>& attrib_list, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenEglCreateSync(builder, dpy, type, builder.CreateVector(attrib_list));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::eglCreateSync), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendEglCreateWindowSurface(Uint64 sessionId, uint64_t dpy, uint64_t config, uint64_t window, const std::vector<int32_t>& attrib_list, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenEglCreateWindowSurface(builder, dpy, config, window, builder.CreateVector(attrib_list));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::eglCreateWindowSurface), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendEglDestroyContext(Uint64 sessionId, uint64_t dpy, uint64_t ctx, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenEglDestroyContext(builder, dpy, ctx);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::eglDestroyContext), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendEglDestroyImage(Uint64 sessionId, uint64_t dpy, uint64_t image, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenEglDestroyImage(builder, dpy, image);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::eglDestroyImage), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendEglDestroySurface(Uint64 sessionId, uint64_t dpy, uint64_t surface, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenEglDestroySurface(builder, dpy, surface);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::eglDestroySurface), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendEglDestroySync(Uint64 sessionId, uint64_t dpy, uint64_t sync, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenEglDestroySync(builder, dpy, sync);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::eglDestroySync), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendEglGetConfigAttrib(Uint64 sessionId, uint64_t dpy, uint64_t config, int32_t attribute, Uint64 token, MobileGLShmHandle* shm = nullptr, Uint32 outCapacity = 0) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenEglGetConfigAttrib(builder, dpy, config, attribute, 0);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::eglGetConfigAttrib), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm, outCapacity);
}
inline Bool SendEglGetConfigs(Uint64 sessionId, uint64_t dpy, int32_t config_size, Uint64 token, MobileGLShmHandle* shm = nullptr, Uint32 outCapacity = 0) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenEglGetConfigs(builder, dpy, 0, config_size, 0);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::eglGetConfigs), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm, outCapacity);
}
inline Bool SendEglGetCurrentSurface(Uint64 sessionId, int32_t readdraw, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenEglGetCurrentSurface(builder, readdraw);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::eglGetCurrentSurface), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendEglGetDisplay(Uint64 sessionId, uint64_t display, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenEglGetDisplay(builder, display);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::eglGetDisplay), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendEglGetError(Uint64 sessionId, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenEglGetError(builder);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::eglGetError), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendEglGetPlatformDisplay(Uint64 sessionId, uint32_t platform, uint64_t native_display, const std::vector<uint64_t>& attrib_list, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenEglGetPlatformDisplay(builder, platform, native_display, builder.CreateVector(attrib_list));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::eglGetPlatformDisplay), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendEglGetPlatformDisplayEXT(Uint64 sessionId, uint32_t platform, uint64_t native_display, const std::vector<int32_t>& attrib_list, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenEglGetPlatformDisplayEXT(builder, platform, native_display, builder.CreateVector(attrib_list));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::eglGetPlatformDisplayEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendEglGetSyncAttrib(Uint64 sessionId, uint64_t dpy, uint64_t sync, int32_t attribute, Uint64 token, MobileGLShmHandle* shm = nullptr, Uint32 outCapacity = 0) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenEglGetSyncAttrib(builder, dpy, sync, attribute, 0);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::eglGetSyncAttrib), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm, outCapacity);
}
inline Bool SendEglInitialize(Uint64 sessionId, uint64_t dpy, Uint64 token, MobileGLShmHandle* shm = nullptr, Uint32 outCapacity = 0) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenEglInitialize(builder, dpy, 0, 0);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::eglInitialize), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm, outCapacity);
}
inline Bool SendEglMakeCurrent(Uint64 sessionId, uint64_t dpy, uint64_t draw, uint64_t read, uint64_t ctx, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenEglMakeCurrent(builder, dpy, draw, read, ctx);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::eglMakeCurrent), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendEglQueryContext(Uint64 sessionId, uint64_t dpy, uint64_t ctx, int32_t attribute, Uint64 token, MobileGLShmHandle* shm = nullptr, Uint32 outCapacity = 0) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenEglQueryContext(builder, dpy, ctx, attribute, 0);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::eglQueryContext), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm, outCapacity);
}
inline Bool SendEglQueryString(Uint64 sessionId, uint64_t display, int32_t name, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenEglQueryString(builder, display, name);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::eglQueryString), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendEglQuerySurface(Uint64 sessionId, uint64_t display, uint64_t surface, int32_t attribute, Uint64 token, MobileGLShmHandle* shm = nullptr, Uint32 outCapacity = 0) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenEglQuerySurface(builder, display, surface, attribute, 0);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::eglQuerySurface), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm, outCapacity);
}
inline Bool SendEglReleaseTexImage(Uint64 sessionId, uint64_t dpy, uint64_t surface, int32_t buffer, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenEglReleaseTexImage(builder, dpy, surface, buffer);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::eglReleaseTexImage), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendEglSurfaceAttrib(Uint64 sessionId, uint64_t dpy, uint64_t surface, int32_t attribute, int32_t value, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenEglSurfaceAttrib(builder, dpy, surface, attribute, value);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::eglSurfaceAttrib), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendEglSwapBuffers(Uint64 sessionId, uint64_t dpy, uint64_t draw, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenEglSwapBuffers(builder, dpy, draw);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::eglSwapBuffers), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendEglSwapInterval(Uint64 sessionId, uint64_t dpy, int32_t interval, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenEglSwapInterval(builder, dpy, interval);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::eglSwapInterval), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendEglTerminate(Uint64 sessionId, uint64_t dpy, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenEglTerminate(builder, dpy);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::eglTerminate), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendEglWaitNative(Uint64 sessionId, int32_t engine, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenEglWaitNative(builder, engine);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::eglWaitNative), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendEglWaitSync(Uint64 sessionId, uint64_t dpy, uint64_t sync, int32_t flags, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenEglWaitSync(builder, dpy, sync, flags);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::eglWaitSync), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlActiveProgramEXT(Uint64 sessionId, uint32_t program, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenActiveProgramEXT(builder, program);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glActiveProgramEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlActiveShaderProgram(Uint64 sessionId, uint32_t pipeline, uint32_t program, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenActiveShaderProgram(builder, pipeline, program);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glActiveShaderProgram), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlActiveTexture(Uint64 sessionId, uint32_t texture, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenActiveTexture(builder, texture);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glActiveTexture), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlAttachShader(Uint64 sessionId, uint32_t program, uint32_t shader, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenAttachShader(builder, program, shader);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glAttachShader), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlBeginConditionalRender(Uint64 sessionId, uint32_t id, uint32_t mode, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenBeginConditionalRender(builder, id, mode);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glBeginConditionalRender), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlBeginConditionalRenderNV(Uint64 sessionId, uint32_t id, uint32_t mode, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenBeginConditionalRenderNV(builder, id, mode);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glBeginConditionalRenderNV), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlBeginPerfMonitorAMD(Uint64 sessionId, uint32_t monitor, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenBeginPerfMonitorAMD(builder, monitor);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glBeginPerfMonitorAMD), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlBeginPerfQueryINTEL(Uint64 sessionId, uint32_t queryHandle, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenBeginPerfQueryINTEL(builder, queryHandle);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glBeginPerfQueryINTEL), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlBeginQuery(Uint64 sessionId, uint32_t target, uint32_t id, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenBeginQuery(builder, target, id);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glBeginQuery), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlBeginQueryIndexed(Uint64 sessionId, uint32_t target, uint32_t index, uint32_t id, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenBeginQueryIndexed(builder, target, index, id);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glBeginQueryIndexed), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlBeginTransformFeedback(Uint64 sessionId, uint32_t primitiveMode, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenBeginTransformFeedback(builder, primitiveMode);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glBeginTransformFeedback), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlBindAttribLocation(Uint64 sessionId, uint32_t program, uint32_t index, const char* name, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenBindAttribLocation(builder, program, index, builder.CreateString(name));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glBindAttribLocation), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlBindBuffer(Uint64 sessionId, uint32_t target, uint32_t buffer, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenBindBuffer(builder, target, buffer);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glBindBuffer), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlBindBufferBase(Uint64 sessionId, uint32_t target, uint32_t index, uint32_t buffer, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenBindBufferBase(builder, target, index, buffer);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glBindBufferBase), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlBindBufferRange(Uint64 sessionId, uint32_t target, uint32_t index, uint32_t buffer, int64_t offset, uint64_t size, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenBindBufferRange(builder, target, index, buffer, offset, size);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glBindBufferRange), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlBindBuffersBase(Uint64 sessionId, uint32_t target, uint32_t first, int32_t count, const std::vector<uint32_t>& buffers, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenBindBuffersBase(builder, target, first, count, builder.CreateVector(buffers));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glBindBuffersBase), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlBindFragDataLocation(Uint64 sessionId, uint32_t program, uint32_t color, const char* name, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenBindFragDataLocation(builder, program, color, builder.CreateString(name));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glBindFragDataLocation), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlBindFragDataLocationIndexed(Uint64 sessionId, uint32_t program, uint32_t colorNumber, uint32_t index, const char* name, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenBindFragDataLocationIndexed(builder, program, colorNumber, index, builder.CreateString(name));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glBindFragDataLocationIndexed), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlBindFramebuffer(Uint64 sessionId, uint32_t target, uint32_t framebuffer, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenBindFramebuffer(builder, target, framebuffer);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glBindFramebuffer), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlBindImageTexture(Uint64 sessionId, uint32_t unit, uint32_t texture, int32_t level, bool layered, int32_t layer, uint32_t access, uint32_t format, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenBindImageTexture(builder, unit, texture, level, layered, layer, access, format);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glBindImageTexture), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlBindImageTextures(Uint64 sessionId, uint32_t first, int32_t count, const std::vector<uint32_t>& textures, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenBindImageTextures(builder, first, count, builder.CreateVector(textures));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glBindImageTextures), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlBindMultiTextureEXT(Uint64 sessionId, uint32_t texunit, uint32_t target, uint32_t texture, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenBindMultiTextureEXT(builder, texunit, target, texture);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glBindMultiTextureEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlBindProgramPipeline(Uint64 sessionId, uint32_t pipeline, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenBindProgramPipeline(builder, pipeline);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glBindProgramPipeline), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlBindRenderbuffer(Uint64 sessionId, uint32_t target, uint32_t renderbuffer, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenBindRenderbuffer(builder, target, renderbuffer);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glBindRenderbuffer), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlBindSampler(Uint64 sessionId, uint32_t unit, uint32_t sampler, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenBindSampler(builder, unit, sampler);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glBindSampler), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlBindSamplers(Uint64 sessionId, uint32_t first, int32_t count, const std::vector<uint32_t>& samplers, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenBindSamplers(builder, first, count, builder.CreateVector(samplers));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glBindSamplers), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlBindShadingRateImageNV(Uint64 sessionId, uint32_t texture, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenBindShadingRateImageNV(builder, texture);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glBindShadingRateImageNV), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlBindTexture(Uint64 sessionId, uint32_t target, uint32_t texture, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenBindTexture(builder, target, texture);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glBindTexture), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlBindTextureUnit(Uint64 sessionId, uint32_t unit, uint32_t texture, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenBindTextureUnit(builder, unit, texture);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glBindTextureUnit), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlBindTextures(Uint64 sessionId, uint32_t first, int32_t count, const std::vector<uint32_t>& textures, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenBindTextures(builder, first, count, builder.CreateVector(textures));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glBindTextures), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlBindTransformFeedback(Uint64 sessionId, uint32_t target, uint32_t id, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenBindTransformFeedback(builder, target, id);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glBindTransformFeedback), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlBindVertexArray(Uint64 sessionId, uint32_t array, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenBindVertexArray(builder, array);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glBindVertexArray), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlBindVertexBuffer(Uint64 sessionId, uint32_t bindingindex, uint32_t buffer, int64_t offset, int32_t stride, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenBindVertexBuffer(builder, bindingindex, buffer, offset, stride);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glBindVertexBuffer), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlBlendColor(Uint64 sessionId, float red, float green, float blue, float alpha, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenBlendColor(builder, red, green, blue, alpha);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glBlendColor), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlBlendEquation(Uint64 sessionId, uint32_t mode, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenBlendEquation(builder, mode);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glBlendEquation), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlBlendEquationSeparate(Uint64 sessionId, uint32_t modeRGB, uint32_t modeAlpha, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenBlendEquationSeparate(builder, modeRGB, modeAlpha);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glBlendEquationSeparate), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlBlendEquationSeparatei(Uint64 sessionId, uint32_t buf, uint32_t modeRGB, uint32_t modeAlpha, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenBlendEquationSeparatei(builder, buf, modeRGB, modeAlpha);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glBlendEquationSeparatei), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlBlendEquationSeparateiARB(Uint64 sessionId, uint32_t buf, uint32_t modeRGB, uint32_t modeAlpha, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenBlendEquationSeparateiARB(builder, buf, modeRGB, modeAlpha);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glBlendEquationSeparateiARB), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlBlendEquationi(Uint64 sessionId, uint32_t buf, uint32_t mode, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenBlendEquationi(builder, buf, mode);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glBlendEquationi), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlBlendEquationiARB(Uint64 sessionId, uint32_t buf, uint32_t mode, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenBlendEquationiARB(builder, buf, mode);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glBlendEquationiARB), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlBlendFunc(Uint64 sessionId, uint32_t sfactor, uint32_t dfactor, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenBlendFunc(builder, sfactor, dfactor);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glBlendFunc), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlBlendFuncSeparate(Uint64 sessionId, uint32_t sfactorRGB, uint32_t dfactorRGB, uint32_t sfactorAlpha, uint32_t dfactorAlpha, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenBlendFuncSeparate(builder, sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glBlendFuncSeparate), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlBlendFuncSeparatei(Uint64 sessionId, uint32_t buf, uint32_t srcRGB, uint32_t dstRGB, uint32_t srcAlpha, uint32_t dstAlpha, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenBlendFuncSeparatei(builder, buf, srcRGB, dstRGB, srcAlpha, dstAlpha);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glBlendFuncSeparatei), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlBlendFuncSeparateiARB(Uint64 sessionId, uint32_t buf, uint32_t srcRGB, uint32_t dstRGB, uint32_t srcAlpha, uint32_t dstAlpha, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenBlendFuncSeparateiARB(builder, buf, srcRGB, dstRGB, srcAlpha, dstAlpha);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glBlendFuncSeparateiARB), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlBlendFunci(Uint64 sessionId, uint32_t buf, uint32_t src, uint32_t dst, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenBlendFunci(builder, buf, src, dst);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glBlendFunci), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlBlendFunciARB(Uint64 sessionId, uint32_t buf, uint32_t src, uint32_t dst, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenBlendFunciARB(builder, buf, src, dst);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glBlendFunciARB), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlBlendParameteriNV(Uint64 sessionId, uint32_t pname, int32_t value, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenBlendParameteriNV(builder, pname, value);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glBlendParameteriNV), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlBlitFramebuffer(Uint64 sessionId, int32_t srcX0, int32_t srcY0, int32_t srcX1, int32_t srcY1, int32_t dstX0, int32_t dstY0, int32_t dstX1, int32_t dstY1, uint32_t mask, uint32_t filter, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenBlitFramebuffer(builder, srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glBlitFramebuffer), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlBlitNamedFramebuffer(Uint64 sessionId, uint32_t readFramebuffer, uint32_t drawFramebuffer, int32_t srcX0, int32_t srcY0, int32_t srcX1, int32_t srcY1, int32_t dstX0, int32_t dstY0, int32_t dstX1, int32_t dstY1, uint32_t mask, uint32_t filter, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenBlitNamedFramebuffer(builder, readFramebuffer, drawFramebuffer, srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glBlitNamedFramebuffer), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlBufferAddressRangeNV(Uint64 sessionId, uint32_t pname, uint32_t index, uint64_t address, uint64_t length, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenBufferAddressRangeNV(builder, pname, index, address, length);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glBufferAddressRangeNV), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlBufferAttachMemoryNV(Uint64 sessionId, uint32_t target, uint32_t memory, uint64_t offset, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenBufferAttachMemoryNV(builder, target, memory, offset);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glBufferAttachMemoryNV), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlBufferData(Uint64 sessionId, uint32_t target, uint64_t size, uint32_t usage, Uint64 token, MobileGLShmHandle* shm) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenBufferData(builder, target, size, MobileGL::Protocol::WireFull::CreateShmRegion(builder, 0, shm == nullptr ? 0 : shm->size), usage);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glBufferData), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlBufferPageCommitmentARB(Uint64 sessionId, uint32_t target, int64_t offset, uint64_t size, bool commit, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenBufferPageCommitmentARB(builder, target, offset, size, commit);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glBufferPageCommitmentARB), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlBufferPageCommitmentMemNV(Uint64 sessionId, uint32_t target, int64_t offset, uint64_t size, uint32_t memory, uint64_t memOffset, bool commit, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenBufferPageCommitmentMemNV(builder, target, offset, size, memory, memOffset, commit);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glBufferPageCommitmentMemNV), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlBufferStorage(Uint64 sessionId, uint32_t target, uint64_t size, uint32_t flags, Uint64 token, MobileGLShmHandle* shm) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenBufferStorage(builder, target, size, MobileGL::Protocol::WireFull::CreateShmRegion(builder, 0, shm == nullptr ? 0 : shm->size), flags);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glBufferStorage), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlBufferSubData(Uint64 sessionId, uint32_t target, int64_t offset, uint64_t size, Uint64 token, MobileGLShmHandle* shm) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenBufferSubData(builder, target, offset, size, MobileGL::Protocol::WireFull::CreateShmRegion(builder, 0, shm == nullptr ? 0 : shm->size));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glBufferSubData), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlCallCommandListNV(Uint64 sessionId, uint32_t list, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenCallCommandListNV(builder, list);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glCallCommandListNV), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlCheckFramebufferStatus(Uint64 sessionId, uint32_t target, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenCheckFramebufferStatus(builder, target);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glCheckFramebufferStatus), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlCheckNamedFramebufferStatus(Uint64 sessionId, uint32_t framebuffer, uint32_t target, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenCheckNamedFramebufferStatus(builder, framebuffer, target);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glCheckNamedFramebufferStatus), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlCheckNamedFramebufferStatusEXT(Uint64 sessionId, uint32_t framebuffer, uint32_t target, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenCheckNamedFramebufferStatusEXT(builder, framebuffer, target);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glCheckNamedFramebufferStatusEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlClampColor(Uint64 sessionId, uint32_t target, uint32_t clamp, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenClampColor(builder, target, clamp);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glClampColor), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlClear(Uint64 sessionId, uint32_t mask, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenClear(builder, mask);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glClear), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlClearBufferData(Uint64 sessionId, uint32_t target, uint32_t internalformat, uint32_t format, uint32_t type, Uint64 token, MobileGLShmHandle* shm) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenClearBufferData(builder, target, internalformat, format, type, MobileGL::Protocol::WireFull::CreateShmRegion(builder, 0, shm == nullptr ? 0 : shm->size));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glClearBufferData), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlClearBufferSubData(Uint64 sessionId, uint32_t target, uint32_t internalformat, int64_t offset, uint64_t size, uint32_t format, uint32_t type, Uint64 token, MobileGLShmHandle* shm) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenClearBufferSubData(builder, target, internalformat, offset, size, format, type, MobileGL::Protocol::WireFull::CreateShmRegion(builder, 0, shm == nullptr ? 0 : shm->size));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glClearBufferSubData), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlClearBufferfi(Uint64 sessionId, uint32_t buffer, int32_t drawbuffer, float depth, int32_t stencil, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenClearBufferfi(builder, buffer, drawbuffer, depth, stencil);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glClearBufferfi), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlClearBufferfv(Uint64 sessionId, uint32_t buffer, int32_t drawbuffer, const std::vector<float>& value, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenClearBufferfv(builder, buffer, drawbuffer, builder.CreateVector(value));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glClearBufferfv), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlClearBufferiv(Uint64 sessionId, uint32_t buffer, int32_t drawbuffer, const std::vector<int32_t>& value, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenClearBufferiv(builder, buffer, drawbuffer, builder.CreateVector(value));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glClearBufferiv), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlClearBufferuiv(Uint64 sessionId, uint32_t buffer, int32_t drawbuffer, const std::vector<uint32_t>& value, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenClearBufferuiv(builder, buffer, drawbuffer, builder.CreateVector(value));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glClearBufferuiv), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlClearColor(Uint64 sessionId, float red, float green, float blue, float alpha, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenClearColor(builder, red, green, blue, alpha);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glClearColor), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlClearDepth(Uint64 sessionId, double depth, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenClearDepth(builder, depth);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glClearDepth), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlClearDepthdNV(Uint64 sessionId, double depth, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenClearDepthdNV(builder, depth);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glClearDepthdNV), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlClearDepthf(Uint64 sessionId, float d, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenClearDepthf(builder, d);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glClearDepthf), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlClearNamedBufferData(Uint64 sessionId, uint32_t buffer, uint32_t internalformat, uint32_t format, uint32_t type, Uint64 token, MobileGLShmHandle* shm) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenClearNamedBufferData(builder, buffer, internalformat, format, type, MobileGL::Protocol::WireFull::CreateShmRegion(builder, 0, shm == nullptr ? 0 : shm->size));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glClearNamedBufferData), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlClearNamedBufferDataEXT(Uint64 sessionId, uint32_t buffer, uint32_t internalformat, uint32_t format, uint32_t type, Uint64 token, MobileGLShmHandle* shm) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenClearNamedBufferDataEXT(builder, buffer, internalformat, format, type, MobileGL::Protocol::WireFull::CreateShmRegion(builder, 0, shm == nullptr ? 0 : shm->size));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glClearNamedBufferDataEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlClearNamedBufferSubData(Uint64 sessionId, uint32_t buffer, uint32_t internalformat, int64_t offset, uint64_t size, uint32_t format, uint32_t type, Uint64 token, MobileGLShmHandle* shm) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenClearNamedBufferSubData(builder, buffer, internalformat, offset, size, format, type, MobileGL::Protocol::WireFull::CreateShmRegion(builder, 0, shm == nullptr ? 0 : shm->size));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glClearNamedBufferSubData), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlClearNamedBufferSubDataEXT(Uint64 sessionId, uint32_t buffer, uint32_t internalformat, uint64_t offset, uint64_t size, uint32_t format, uint32_t type, Uint64 token, MobileGLShmHandle* shm) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenClearNamedBufferSubDataEXT(builder, buffer, internalformat, offset, size, format, type, MobileGL::Protocol::WireFull::CreateShmRegion(builder, 0, shm == nullptr ? 0 : shm->size));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glClearNamedBufferSubDataEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlClearNamedFramebufferfi(Uint64 sessionId, uint32_t framebuffer, uint32_t buffer, int32_t drawbuffer, float depth, int32_t stencil, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenClearNamedFramebufferfi(builder, framebuffer, buffer, drawbuffer, depth, stencil);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glClearNamedFramebufferfi), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlClearNamedFramebufferfv(Uint64 sessionId, uint32_t framebuffer, uint32_t buffer, int32_t drawbuffer, const std::vector<float>& value, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenClearNamedFramebufferfv(builder, framebuffer, buffer, drawbuffer, builder.CreateVector(value));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glClearNamedFramebufferfv), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlClearNamedFramebufferiv(Uint64 sessionId, uint32_t framebuffer, uint32_t buffer, int32_t drawbuffer, const std::vector<int32_t>& value, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenClearNamedFramebufferiv(builder, framebuffer, buffer, drawbuffer, builder.CreateVector(value));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glClearNamedFramebufferiv), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlClearNamedFramebufferuiv(Uint64 sessionId, uint32_t framebuffer, uint32_t buffer, int32_t drawbuffer, const std::vector<uint32_t>& value, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenClearNamedFramebufferuiv(builder, framebuffer, buffer, drawbuffer, builder.CreateVector(value));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glClearNamedFramebufferuiv), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlClearStencil(Uint64 sessionId, int32_t s, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenClearStencil(builder, s);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glClearStencil), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlClearTexImage(Uint64 sessionId, uint32_t texture, int32_t level, uint32_t format, uint32_t type, Uint64 token, MobileGLShmHandle* shm) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenClearTexImage(builder, texture, level, format, type, MobileGL::Protocol::WireFull::CreateShmRegion(builder, 0, shm == nullptr ? 0 : shm->size));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glClearTexImage), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlClearTexSubImage(Uint64 sessionId, uint32_t texture, int32_t level, int32_t xoffset, int32_t yoffset, int32_t zoffset, int32_t width, int32_t height, int32_t depth, uint32_t format, uint32_t type, Uint64 token, MobileGLShmHandle* shm) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenClearTexSubImage(builder, texture, level, xoffset, yoffset, zoffset, width, height, depth, format, type, MobileGL::Protocol::WireFull::CreateShmRegion(builder, 0, shm == nullptr ? 0 : shm->size));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glClearTexSubImage), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlClientAttribDefaultEXT(Uint64 sessionId, uint32_t mask, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenClientAttribDefaultEXT(builder, mask);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glClientAttribDefaultEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlClientWaitSync(Uint64 sessionId, uint64_t sync, uint32_t flags, uint64_t timeout, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenClientWaitSync(builder, sync, flags, timeout);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glClientWaitSync), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlClipControl(Uint64 sessionId, uint32_t origin, uint32_t depth, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenClipControl(builder, origin, depth);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glClipControl), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlColorFormatNV(Uint64 sessionId, int32_t size, uint32_t type, int32_t stride, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenColorFormatNV(builder, size, type, stride);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glColorFormatNV), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlColorMask(Uint64 sessionId, bool red, bool green, bool blue, bool alpha, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenColorMask(builder, red, green, blue, alpha);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glColorMask), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlColorMaski(Uint64 sessionId, uint32_t index, bool r, bool g, bool b, bool a, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenColorMaski(builder, index, r, g, b, a);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glColorMaski), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlCommandListSegmentsNV(Uint64 sessionId, uint32_t list, uint32_t segments, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenCommandListSegmentsNV(builder, list, segments);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glCommandListSegmentsNV), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlCompileCommandListNV(Uint64 sessionId, uint32_t list, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenCompileCommandListNV(builder, list);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glCompileCommandListNV), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlCompileShader(Uint64 sessionId, uint32_t shader, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenCompileShader(builder, shader);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glCompileShader), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlCompressedMultiTexImage1DEXT(Uint64 sessionId, uint32_t texunit, uint32_t target, int32_t level, uint32_t internalformat, int32_t width, int32_t border, int32_t imageSize, Uint64 token, MobileGLShmHandle* shm) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenCompressedMultiTexImage1DEXT(builder, texunit, target, level, internalformat, width, border, imageSize, MobileGL::Protocol::WireFull::CreateShmRegion(builder, 0, shm == nullptr ? 0 : shm->size));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glCompressedMultiTexImage1DEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlCompressedMultiTexImage2DEXT(Uint64 sessionId, uint32_t texunit, uint32_t target, int32_t level, uint32_t internalformat, int32_t width, int32_t height, int32_t border, int32_t imageSize, Uint64 token, MobileGLShmHandle* shm) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenCompressedMultiTexImage2DEXT(builder, texunit, target, level, internalformat, width, height, border, imageSize, MobileGL::Protocol::WireFull::CreateShmRegion(builder, 0, shm == nullptr ? 0 : shm->size));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glCompressedMultiTexImage2DEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlCompressedMultiTexImage3DEXT(Uint64 sessionId, uint32_t texunit, uint32_t target, int32_t level, uint32_t internalformat, int32_t width, int32_t height, int32_t depth, int32_t border, int32_t imageSize, Uint64 token, MobileGLShmHandle* shm) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenCompressedMultiTexImage3DEXT(builder, texunit, target, level, internalformat, width, height, depth, border, imageSize, MobileGL::Protocol::WireFull::CreateShmRegion(builder, 0, shm == nullptr ? 0 : shm->size));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glCompressedMultiTexImage3DEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlCompressedMultiTexSubImage1DEXT(Uint64 sessionId, uint32_t texunit, uint32_t target, int32_t level, int32_t xoffset, int32_t width, uint32_t format, int32_t imageSize, Uint64 token, MobileGLShmHandle* shm) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenCompressedMultiTexSubImage1DEXT(builder, texunit, target, level, xoffset, width, format, imageSize, MobileGL::Protocol::WireFull::CreateShmRegion(builder, 0, shm == nullptr ? 0 : shm->size));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glCompressedMultiTexSubImage1DEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlCompressedMultiTexSubImage2DEXT(Uint64 sessionId, uint32_t texunit, uint32_t target, int32_t level, int32_t xoffset, int32_t yoffset, int32_t width, int32_t height, uint32_t format, int32_t imageSize, Uint64 token, MobileGLShmHandle* shm) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenCompressedMultiTexSubImage2DEXT(builder, texunit, target, level, xoffset, yoffset, width, height, format, imageSize, MobileGL::Protocol::WireFull::CreateShmRegion(builder, 0, shm == nullptr ? 0 : shm->size));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glCompressedMultiTexSubImage2DEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlCompressedMultiTexSubImage3DEXT(Uint64 sessionId, uint32_t texunit, uint32_t target, int32_t level, int32_t xoffset, int32_t yoffset, int32_t zoffset, int32_t width, int32_t height, int32_t depth, uint32_t format, int32_t imageSize, Uint64 token, MobileGLShmHandle* shm) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenCompressedMultiTexSubImage3DEXT(builder, texunit, target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, MobileGL::Protocol::WireFull::CreateShmRegion(builder, 0, shm == nullptr ? 0 : shm->size));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glCompressedMultiTexSubImage3DEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlCompressedTexImage1D(Uint64 sessionId, uint32_t target, int32_t level, uint32_t internalformat, int32_t width, int32_t border, int32_t imageSize, Uint64 token, MobileGLShmHandle* shm) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenCompressedTexImage1D(builder, target, level, internalformat, width, border, imageSize, MobileGL::Protocol::WireFull::CreateShmRegion(builder, 0, shm == nullptr ? 0 : shm->size));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glCompressedTexImage1D), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlCompressedTexImage2D(Uint64 sessionId, uint32_t target, int32_t level, uint32_t internalformat, int32_t width, int32_t height, int32_t border, int32_t imageSize, Uint64 token, MobileGLShmHandle* shm) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenCompressedTexImage2D(builder, target, level, internalformat, width, height, border, imageSize, MobileGL::Protocol::WireFull::CreateShmRegion(builder, 0, shm == nullptr ? 0 : shm->size));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glCompressedTexImage2D), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlCompressedTexImage3D(Uint64 sessionId, uint32_t target, int32_t level, uint32_t internalformat, int32_t width, int32_t height, int32_t depth, int32_t border, int32_t imageSize, Uint64 token, MobileGLShmHandle* shm) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenCompressedTexImage3D(builder, target, level, internalformat, width, height, depth, border, imageSize, MobileGL::Protocol::WireFull::CreateShmRegion(builder, 0, shm == nullptr ? 0 : shm->size));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glCompressedTexImage3D), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlCompressedTexSubImage1D(Uint64 sessionId, uint32_t target, int32_t level, int32_t xoffset, int32_t width, uint32_t format, int32_t imageSize, Uint64 token, MobileGLShmHandle* shm) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenCompressedTexSubImage1D(builder, target, level, xoffset, width, format, imageSize, MobileGL::Protocol::WireFull::CreateShmRegion(builder, 0, shm == nullptr ? 0 : shm->size));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glCompressedTexSubImage1D), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlCompressedTexSubImage2D(Uint64 sessionId, uint32_t target, int32_t level, int32_t xoffset, int32_t yoffset, int32_t width, int32_t height, uint32_t format, int32_t imageSize, Uint64 token, MobileGLShmHandle* shm) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenCompressedTexSubImage2D(builder, target, level, xoffset, yoffset, width, height, format, imageSize, MobileGL::Protocol::WireFull::CreateShmRegion(builder, 0, shm == nullptr ? 0 : shm->size));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glCompressedTexSubImage2D), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlCompressedTexSubImage3D(Uint64 sessionId, uint32_t target, int32_t level, int32_t xoffset, int32_t yoffset, int32_t zoffset, int32_t width, int32_t height, int32_t depth, uint32_t format, int32_t imageSize, Uint64 token, MobileGLShmHandle* shm) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenCompressedTexSubImage3D(builder, target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, MobileGL::Protocol::WireFull::CreateShmRegion(builder, 0, shm == nullptr ? 0 : shm->size));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glCompressedTexSubImage3D), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlCompressedTextureImage1DEXT(Uint64 sessionId, uint32_t texture, uint32_t target, int32_t level, uint32_t internalformat, int32_t width, int32_t border, int32_t imageSize, Uint64 token, MobileGLShmHandle* shm) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenCompressedTextureImage1DEXT(builder, texture, target, level, internalformat, width, border, imageSize, MobileGL::Protocol::WireFull::CreateShmRegion(builder, 0, shm == nullptr ? 0 : shm->size));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glCompressedTextureImage1DEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlCompressedTextureImage2DEXT(Uint64 sessionId, uint32_t texture, uint32_t target, int32_t level, uint32_t internalformat, int32_t width, int32_t height, int32_t border, int32_t imageSize, Uint64 token, MobileGLShmHandle* shm) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenCompressedTextureImage2DEXT(builder, texture, target, level, internalformat, width, height, border, imageSize, MobileGL::Protocol::WireFull::CreateShmRegion(builder, 0, shm == nullptr ? 0 : shm->size));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glCompressedTextureImage2DEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlCompressedTextureImage3DEXT(Uint64 sessionId, uint32_t texture, uint32_t target, int32_t level, uint32_t internalformat, int32_t width, int32_t height, int32_t depth, int32_t border, int32_t imageSize, Uint64 token, MobileGLShmHandle* shm) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenCompressedTextureImage3DEXT(builder, texture, target, level, internalformat, width, height, depth, border, imageSize, MobileGL::Protocol::WireFull::CreateShmRegion(builder, 0, shm == nullptr ? 0 : shm->size));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glCompressedTextureImage3DEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlCompressedTextureSubImage1D(Uint64 sessionId, uint32_t texture, int32_t level, int32_t xoffset, int32_t width, uint32_t format, int32_t imageSize, Uint64 token, MobileGLShmHandle* shm) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenCompressedTextureSubImage1D(builder, texture, level, xoffset, width, format, imageSize, MobileGL::Protocol::WireFull::CreateShmRegion(builder, 0, shm == nullptr ? 0 : shm->size));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glCompressedTextureSubImage1D), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlCompressedTextureSubImage1DEXT(Uint64 sessionId, uint32_t texture, uint32_t target, int32_t level, int32_t xoffset, int32_t width, uint32_t format, int32_t imageSize, Uint64 token, MobileGLShmHandle* shm) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenCompressedTextureSubImage1DEXT(builder, texture, target, level, xoffset, width, format, imageSize, MobileGL::Protocol::WireFull::CreateShmRegion(builder, 0, shm == nullptr ? 0 : shm->size));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glCompressedTextureSubImage1DEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlCompressedTextureSubImage2D(Uint64 sessionId, uint32_t texture, int32_t level, int32_t xoffset, int32_t yoffset, int32_t width, int32_t height, uint32_t format, int32_t imageSize, Uint64 token, MobileGLShmHandle* shm) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenCompressedTextureSubImage2D(builder, texture, level, xoffset, yoffset, width, height, format, imageSize, MobileGL::Protocol::WireFull::CreateShmRegion(builder, 0, shm == nullptr ? 0 : shm->size));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glCompressedTextureSubImage2D), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlCompressedTextureSubImage2DEXT(Uint64 sessionId, uint32_t texture, uint32_t target, int32_t level, int32_t xoffset, int32_t yoffset, int32_t width, int32_t height, uint32_t format, int32_t imageSize, Uint64 token, MobileGLShmHandle* shm) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenCompressedTextureSubImage2DEXT(builder, texture, target, level, xoffset, yoffset, width, height, format, imageSize, MobileGL::Protocol::WireFull::CreateShmRegion(builder, 0, shm == nullptr ? 0 : shm->size));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glCompressedTextureSubImage2DEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlCompressedTextureSubImage3D(Uint64 sessionId, uint32_t texture, int32_t level, int32_t xoffset, int32_t yoffset, int32_t zoffset, int32_t width, int32_t height, int32_t depth, uint32_t format, int32_t imageSize, Uint64 token, MobileGLShmHandle* shm) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenCompressedTextureSubImage3D(builder, texture, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, MobileGL::Protocol::WireFull::CreateShmRegion(builder, 0, shm == nullptr ? 0 : shm->size));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glCompressedTextureSubImage3D), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlCompressedTextureSubImage3DEXT(Uint64 sessionId, uint32_t texture, uint32_t target, int32_t level, int32_t xoffset, int32_t yoffset, int32_t zoffset, int32_t width, int32_t height, int32_t depth, uint32_t format, int32_t imageSize, Uint64 token, MobileGLShmHandle* shm) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenCompressedTextureSubImage3DEXT(builder, texture, target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, MobileGL::Protocol::WireFull::CreateShmRegion(builder, 0, shm == nullptr ? 0 : shm->size));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glCompressedTextureSubImage3DEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlConservativeRasterParameterfNV(Uint64 sessionId, uint32_t pname, float value, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenConservativeRasterParameterfNV(builder, pname, value);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glConservativeRasterParameterfNV), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlConservativeRasterParameteriNV(Uint64 sessionId, uint32_t pname, int32_t param, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenConservativeRasterParameteriNV(builder, pname, param);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glConservativeRasterParameteriNV), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlCopyBufferSubData(Uint64 sessionId, uint32_t readTarget, uint32_t writeTarget, int64_t readOffset, int64_t writeOffset, uint64_t size, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenCopyBufferSubData(builder, readTarget, writeTarget, readOffset, writeOffset, size);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glCopyBufferSubData), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlCopyImageSubData(Uint64 sessionId, uint32_t srcName, uint32_t srcTarget, int32_t srcLevel, int32_t srcX, int32_t srcY, int32_t srcZ, uint32_t dstName, uint32_t dstTarget, int32_t dstLevel, int32_t dstX, int32_t dstY, int32_t dstZ, int32_t srcWidth, int32_t srcHeight, int32_t srcDepth, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenCopyImageSubData(builder, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glCopyImageSubData), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlCopyMultiTexImage1DEXT(Uint64 sessionId, uint32_t texunit, uint32_t target, int32_t level, uint32_t internalformat, int32_t x, int32_t y, int32_t width, int32_t border, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenCopyMultiTexImage1DEXT(builder, texunit, target, level, internalformat, x, y, width, border);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glCopyMultiTexImage1DEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlCopyMultiTexImage2DEXT(Uint64 sessionId, uint32_t texunit, uint32_t target, int32_t level, uint32_t internalformat, int32_t x, int32_t y, int32_t width, int32_t height, int32_t border, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenCopyMultiTexImage2DEXT(builder, texunit, target, level, internalformat, x, y, width, height, border);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glCopyMultiTexImage2DEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlCopyMultiTexSubImage1DEXT(Uint64 sessionId, uint32_t texunit, uint32_t target, int32_t level, int32_t xoffset, int32_t x, int32_t y, int32_t width, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenCopyMultiTexSubImage1DEXT(builder, texunit, target, level, xoffset, x, y, width);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glCopyMultiTexSubImage1DEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlCopyMultiTexSubImage2DEXT(Uint64 sessionId, uint32_t texunit, uint32_t target, int32_t level, int32_t xoffset, int32_t yoffset, int32_t x, int32_t y, int32_t width, int32_t height, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenCopyMultiTexSubImage2DEXT(builder, texunit, target, level, xoffset, yoffset, x, y, width, height);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glCopyMultiTexSubImage2DEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlCopyMultiTexSubImage3DEXT(Uint64 sessionId, uint32_t texunit, uint32_t target, int32_t level, int32_t xoffset, int32_t yoffset, int32_t zoffset, int32_t x, int32_t y, int32_t width, int32_t height, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenCopyMultiTexSubImage3DEXT(builder, texunit, target, level, xoffset, yoffset, zoffset, x, y, width, height);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glCopyMultiTexSubImage3DEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlCopyNamedBufferSubData(Uint64 sessionId, uint32_t readBuffer, uint32_t writeBuffer, int64_t readOffset, int64_t writeOffset, uint64_t size, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenCopyNamedBufferSubData(builder, readBuffer, writeBuffer, readOffset, writeOffset, size);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glCopyNamedBufferSubData), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlCopyPathNV(Uint64 sessionId, uint32_t resultPath, uint32_t srcPath, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenCopyPathNV(builder, resultPath, srcPath);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glCopyPathNV), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlCopyTexImage1D(Uint64 sessionId, uint32_t target, int32_t level, uint32_t internalformat, int32_t x, int32_t y, int32_t width, int32_t border, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenCopyTexImage1D(builder, target, level, internalformat, x, y, width, border);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glCopyTexImage1D), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlCopyTexImage2D(Uint64 sessionId, uint32_t target, int32_t level, uint32_t internalformat, int32_t x, int32_t y, int32_t width, int32_t height, int32_t border, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenCopyTexImage2D(builder, target, level, internalformat, x, y, width, height, border);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glCopyTexImage2D), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlCopyTexSubImage1D(Uint64 sessionId, uint32_t target, int32_t level, int32_t xoffset, int32_t x, int32_t y, int32_t width, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenCopyTexSubImage1D(builder, target, level, xoffset, x, y, width);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glCopyTexSubImage1D), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlCopyTexSubImage2D(Uint64 sessionId, uint32_t target, int32_t level, int32_t xoffset, int32_t yoffset, int32_t x, int32_t y, int32_t width, int32_t height, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenCopyTexSubImage2D(builder, target, level, xoffset, yoffset, x, y, width, height);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glCopyTexSubImage2D), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlCopyTexSubImage3D(Uint64 sessionId, uint32_t target, int32_t level, int32_t xoffset, int32_t yoffset, int32_t zoffset, int32_t x, int32_t y, int32_t width, int32_t height, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenCopyTexSubImage3D(builder, target, level, xoffset, yoffset, zoffset, x, y, width, height);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glCopyTexSubImage3D), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlCopyTextureImage1DEXT(Uint64 sessionId, uint32_t texture, uint32_t target, int32_t level, uint32_t internalformat, int32_t x, int32_t y, int32_t width, int32_t border, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenCopyTextureImage1DEXT(builder, texture, target, level, internalformat, x, y, width, border);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glCopyTextureImage1DEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlCopyTextureImage2DEXT(Uint64 sessionId, uint32_t texture, uint32_t target, int32_t level, uint32_t internalformat, int32_t x, int32_t y, int32_t width, int32_t height, int32_t border, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenCopyTextureImage2DEXT(builder, texture, target, level, internalformat, x, y, width, height, border);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glCopyTextureImage2DEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlCopyTextureSubImage1D(Uint64 sessionId, uint32_t texture, int32_t level, int32_t xoffset, int32_t x, int32_t y, int32_t width, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenCopyTextureSubImage1D(builder, texture, level, xoffset, x, y, width);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glCopyTextureSubImage1D), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlCopyTextureSubImage1DEXT(Uint64 sessionId, uint32_t texture, uint32_t target, int32_t level, int32_t xoffset, int32_t x, int32_t y, int32_t width, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenCopyTextureSubImage1DEXT(builder, texture, target, level, xoffset, x, y, width);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glCopyTextureSubImage1DEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlCopyTextureSubImage2D(Uint64 sessionId, uint32_t texture, int32_t level, int32_t xoffset, int32_t yoffset, int32_t x, int32_t y, int32_t width, int32_t height, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenCopyTextureSubImage2D(builder, texture, level, xoffset, yoffset, x, y, width, height);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glCopyTextureSubImage2D), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlCopyTextureSubImage2DEXT(Uint64 sessionId, uint32_t texture, uint32_t target, int32_t level, int32_t xoffset, int32_t yoffset, int32_t x, int32_t y, int32_t width, int32_t height, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenCopyTextureSubImage2DEXT(builder, texture, target, level, xoffset, yoffset, x, y, width, height);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glCopyTextureSubImage2DEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlCopyTextureSubImage3D(Uint64 sessionId, uint32_t texture, int32_t level, int32_t xoffset, int32_t yoffset, int32_t zoffset, int32_t x, int32_t y, int32_t width, int32_t height, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenCopyTextureSubImage3D(builder, texture, level, xoffset, yoffset, zoffset, x, y, width, height);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glCopyTextureSubImage3D), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlCopyTextureSubImage3DEXT(Uint64 sessionId, uint32_t texture, uint32_t target, int32_t level, int32_t xoffset, int32_t yoffset, int32_t zoffset, int32_t x, int32_t y, int32_t width, int32_t height, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenCopyTextureSubImage3DEXT(builder, texture, target, level, xoffset, yoffset, zoffset, x, y, width, height);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glCopyTextureSubImage3DEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlCoverFillPathInstancedNV(Uint64 sessionId, int32_t numPaths, uint32_t pathNameType, uint32_t pathBase, uint32_t coverMode, uint32_t transformType, const std::vector<float>& transformValues, Uint64 token, MobileGLShmHandle* shm) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenCoverFillPathInstancedNV(builder, numPaths, pathNameType, MobileGL::Protocol::WireFull::CreateShmRegion(builder, 0, shm == nullptr ? 0 : shm->size), pathBase, coverMode, transformType, builder.CreateVector(transformValues));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glCoverFillPathInstancedNV), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlCoverFillPathNV(Uint64 sessionId, uint32_t path, uint32_t coverMode, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenCoverFillPathNV(builder, path, coverMode);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glCoverFillPathNV), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlCoverStrokePathInstancedNV(Uint64 sessionId, int32_t numPaths, uint32_t pathNameType, uint32_t pathBase, uint32_t coverMode, uint32_t transformType, const std::vector<float>& transformValues, Uint64 token, MobileGLShmHandle* shm) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenCoverStrokePathInstancedNV(builder, numPaths, pathNameType, MobileGL::Protocol::WireFull::CreateShmRegion(builder, 0, shm == nullptr ? 0 : shm->size), pathBase, coverMode, transformType, builder.CreateVector(transformValues));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glCoverStrokePathInstancedNV), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlCoverStrokePathNV(Uint64 sessionId, uint32_t path, uint32_t coverMode, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenCoverStrokePathNV(builder, path, coverMode);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glCoverStrokePathNV), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlCoverageModulationNV(Uint64 sessionId, uint32_t components, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenCoverageModulationNV(builder, components);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glCoverageModulationNV), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlCoverageModulationTableNV(Uint64 sessionId, int32_t n, const std::vector<float>& v, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenCoverageModulationTableNV(builder, n, builder.CreateVector(v));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glCoverageModulationTableNV), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlCreateBuffers(Uint64 sessionId, int32_t n, Uint64 token, MobileGLShmHandle* shm = nullptr, Uint32 outCapacity = 0) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenCreateBuffers(builder, n, 0);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glCreateBuffers), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm, outCapacity);
}
inline Bool SendGlCreateCommandListsNV(Uint64 sessionId, int32_t n, Uint64 token, MobileGLShmHandle* shm = nullptr, Uint32 outCapacity = 0) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenCreateCommandListsNV(builder, n, 0);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glCreateCommandListsNV), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm, outCapacity);
}
inline Bool SendGlCreateFramebuffers(Uint64 sessionId, int32_t n, Uint64 token, MobileGLShmHandle* shm = nullptr, Uint32 outCapacity = 0) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenCreateFramebuffers(builder, n, 0);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glCreateFramebuffers), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm, outCapacity);
}
inline Bool SendGlCreatePerfQueryINTEL(Uint64 sessionId, uint32_t queryId, Uint64 token, MobileGLShmHandle* shm = nullptr, Uint32 outCapacity = 0) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenCreatePerfQueryINTEL(builder, queryId, 0);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glCreatePerfQueryINTEL), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm, outCapacity);
}
inline Bool SendGlCreateProgramPipelines(Uint64 sessionId, int32_t n, Uint64 token, MobileGLShmHandle* shm = nullptr, Uint32 outCapacity = 0) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenCreateProgramPipelines(builder, n, 0);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glCreateProgramPipelines), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm, outCapacity);
}
inline Bool SendGlCreateQueries(Uint64 sessionId, uint32_t target, int32_t n, Uint64 token, MobileGLShmHandle* shm = nullptr, Uint32 outCapacity = 0) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenCreateQueries(builder, target, n, 0);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glCreateQueries), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm, outCapacity);
}
inline Bool SendGlCreateRenderbuffers(Uint64 sessionId, int32_t n, Uint64 token, MobileGLShmHandle* shm = nullptr, Uint32 outCapacity = 0) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenCreateRenderbuffers(builder, n, 0);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glCreateRenderbuffers), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm, outCapacity);
}
inline Bool SendGlCreateSamplers(Uint64 sessionId, int32_t n, Uint64 token, MobileGLShmHandle* shm = nullptr, Uint32 outCapacity = 0) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenCreateSamplers(builder, n, 0);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glCreateSamplers), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm, outCapacity);
}
inline Bool SendGlCreateShader(Uint64 sessionId, uint32_t type, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenCreateShader(builder, type);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glCreateShader), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlCreateShaderProgramEXT(Uint64 sessionId, uint32_t type, const char* string, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenCreateShaderProgramEXT(builder, type, builder.CreateString(string));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glCreateShaderProgramEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlCreateStatesNV(Uint64 sessionId, int32_t n, Uint64 token, MobileGLShmHandle* shm = nullptr, Uint32 outCapacity = 0) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenCreateStatesNV(builder, n, 0);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glCreateStatesNV), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm, outCapacity);
}
inline Bool SendGlCreateTextures(Uint64 sessionId, uint32_t target, int32_t n, Uint64 token, MobileGLShmHandle* shm = nullptr, Uint32 outCapacity = 0) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenCreateTextures(builder, target, n, 0);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glCreateTextures), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm, outCapacity);
}
inline Bool SendGlCreateTransformFeedbacks(Uint64 sessionId, int32_t n, Uint64 token, MobileGLShmHandle* shm = nullptr, Uint32 outCapacity = 0) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenCreateTransformFeedbacks(builder, n, 0);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glCreateTransformFeedbacks), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm, outCapacity);
}
inline Bool SendGlCreateVertexArrays(Uint64 sessionId, int32_t n, Uint64 token, MobileGLShmHandle* shm = nullptr, Uint32 outCapacity = 0) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenCreateVertexArrays(builder, n, 0);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glCreateVertexArrays), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm, outCapacity);
}
inline Bool SendGlCullFace(Uint64 sessionId, uint32_t mode, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenCullFace(builder, mode);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glCullFace), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlDebugMessageControl(Uint64 sessionId, uint32_t source, uint32_t type, uint32_t severity, int32_t count, const std::vector<uint32_t>& ids, bool enabled, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenDebugMessageControl(builder, source, type, severity, count, builder.CreateVector(ids), enabled);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glDebugMessageControl), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlDebugMessageInsert(Uint64 sessionId, uint32_t source, uint32_t type, uint32_t id, uint32_t severity, int32_t length, const char* buf, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenDebugMessageInsert(builder, source, type, id, severity, length, builder.CreateString(buf));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glDebugMessageInsert), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlDeleteBuffers(Uint64 sessionId, int32_t n, const std::vector<uint32_t>& buffers, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenDeleteBuffers(builder, n, builder.CreateVector(buffers));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glDeleteBuffers), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlDeleteCommandListsNV(Uint64 sessionId, int32_t n, const std::vector<uint32_t>& lists, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenDeleteCommandListsNV(builder, n, builder.CreateVector(lists));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glDeleteCommandListsNV), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlDeleteFramebuffers(Uint64 sessionId, int32_t n, const std::vector<uint32_t>& framebuffers, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenDeleteFramebuffers(builder, n, builder.CreateVector(framebuffers));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glDeleteFramebuffers), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlDeleteNamedStringARB(Uint64 sessionId, int32_t namelen, const char* name, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenDeleteNamedStringARB(builder, namelen, builder.CreateString(name));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glDeleteNamedStringARB), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlDeletePathsNV(Uint64 sessionId, uint32_t path, int32_t range, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenDeletePathsNV(builder, path, range);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glDeletePathsNV), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlDeletePerfMonitorsAMD(Uint64 sessionId, int32_t n, Uint64 token, MobileGLShmHandle* shm = nullptr, Uint32 outCapacity = 0) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenDeletePerfMonitorsAMD(builder, n, 0);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glDeletePerfMonitorsAMD), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm, outCapacity);
}
inline Bool SendGlDeletePerfQueryINTEL(Uint64 sessionId, uint32_t queryHandle, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenDeletePerfQueryINTEL(builder, queryHandle);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glDeletePerfQueryINTEL), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlDeleteProgram(Uint64 sessionId, uint32_t program, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenDeleteProgram(builder, program);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glDeleteProgram), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlDeleteProgramPipelines(Uint64 sessionId, int32_t n, const std::vector<uint32_t>& pipelines, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenDeleteProgramPipelines(builder, n, builder.CreateVector(pipelines));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glDeleteProgramPipelines), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlDeleteQueries(Uint64 sessionId, int32_t n, const std::vector<uint32_t>& ids, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenDeleteQueries(builder, n, builder.CreateVector(ids));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glDeleteQueries), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlDeleteRenderbuffers(Uint64 sessionId, int32_t n, const std::vector<uint32_t>& renderbuffers, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenDeleteRenderbuffers(builder, n, builder.CreateVector(renderbuffers));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glDeleteRenderbuffers), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlDeleteSamplers(Uint64 sessionId, int32_t count, const std::vector<uint32_t>& samplers, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenDeleteSamplers(builder, count, builder.CreateVector(samplers));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glDeleteSamplers), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlDeleteShader(Uint64 sessionId, uint32_t shader, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenDeleteShader(builder, shader);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glDeleteShader), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlDeleteStatesNV(Uint64 sessionId, int32_t n, const std::vector<uint32_t>& states, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenDeleteStatesNV(builder, n, builder.CreateVector(states));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glDeleteStatesNV), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlDeleteSync(Uint64 sessionId, uint64_t sync, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenDeleteSync(builder, sync);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glDeleteSync), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlDeleteTextures(Uint64 sessionId, int32_t n, const std::vector<uint32_t>& textures, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenDeleteTextures(builder, n, builder.CreateVector(textures));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glDeleteTextures), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlDeleteTransformFeedbacks(Uint64 sessionId, int32_t n, const std::vector<uint32_t>& ids, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenDeleteTransformFeedbacks(builder, n, builder.CreateVector(ids));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glDeleteTransformFeedbacks), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlDeleteVertexArrays(Uint64 sessionId, int32_t n, const std::vector<uint32_t>& arrays, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenDeleteVertexArrays(builder, n, builder.CreateVector(arrays));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glDeleteVertexArrays), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlDepthBoundsdNV(Uint64 sessionId, double zmin, double zmax, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenDepthBoundsdNV(builder, zmin, zmax);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glDepthBoundsdNV), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlDepthFunc(Uint64 sessionId, uint32_t func, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenDepthFunc(builder, func);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glDepthFunc), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlDepthMask(Uint64 sessionId, bool flag, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenDepthMask(builder, flag);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glDepthMask), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlDepthRange(Uint64 sessionId, double near_val, double far_val, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenDepthRange(builder, near_val, far_val);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glDepthRange), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlDepthRangeArraydvNV(Uint64 sessionId, uint32_t first, int32_t count, const std::vector<double>& v, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenDepthRangeArraydvNV(builder, first, count, builder.CreateVector(v));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glDepthRangeArraydvNV), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlDepthRangeArrayv(Uint64 sessionId, uint32_t first, int32_t count, const std::vector<double>& v, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenDepthRangeArrayv(builder, first, count, builder.CreateVector(v));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glDepthRangeArrayv), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlDepthRangeIndexed(Uint64 sessionId, uint32_t index, double n, double f, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenDepthRangeIndexed(builder, index, n, f);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glDepthRangeIndexed), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlDepthRangeIndexeddNV(Uint64 sessionId, uint32_t index, double n, double f, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenDepthRangeIndexeddNV(builder, index, n, f);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glDepthRangeIndexeddNV), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlDepthRangedNV(Uint64 sessionId, double zNear, double zFar, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenDepthRangedNV(builder, zNear, zFar);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glDepthRangedNV), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlDepthRangef(Uint64 sessionId, float n, float f, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenDepthRangef(builder, n, f);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glDepthRangef), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlDetachShader(Uint64 sessionId, uint32_t program, uint32_t shader, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenDetachShader(builder, program, shader);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glDetachShader), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlDisable(Uint64 sessionId, uint32_t cap, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenDisable(builder, cap);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glDisable), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlDisableClientStateIndexedEXT(Uint64 sessionId, uint32_t array, uint32_t index, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenDisableClientStateIndexedEXT(builder, array, index);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glDisableClientStateIndexedEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlDisableClientStateiEXT(Uint64 sessionId, uint32_t array, uint32_t index, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenDisableClientStateiEXT(builder, array, index);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glDisableClientStateiEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlDisableIndexedEXT(Uint64 sessionId, uint32_t target, uint32_t index, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenDisableIndexedEXT(builder, target, index);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glDisableIndexedEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlDisableVertexArrayAttrib(Uint64 sessionId, uint32_t vaobj, uint32_t index, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenDisableVertexArrayAttrib(builder, vaobj, index);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glDisableVertexArrayAttrib), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlDisableVertexArrayAttribEXT(Uint64 sessionId, uint32_t vaobj, uint32_t index, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenDisableVertexArrayAttribEXT(builder, vaobj, index);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glDisableVertexArrayAttribEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlDisableVertexArrayEXT(Uint64 sessionId, uint32_t vaobj, uint32_t array, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenDisableVertexArrayEXT(builder, vaobj, array);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glDisableVertexArrayEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlDisableVertexAttribArray(Uint64 sessionId, uint32_t index, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenDisableVertexAttribArray(builder, index);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glDisableVertexAttribArray), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlDisablei(Uint64 sessionId, uint32_t target, uint32_t index, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenDisablei(builder, target, index);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glDisablei), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlDispatchCompute(Uint64 sessionId, uint32_t num_groups_x, uint32_t num_groups_y, uint32_t num_groups_z, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenDispatchCompute(builder, num_groups_x, num_groups_y, num_groups_z);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glDispatchCompute), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlDispatchComputeGroupSizeARB(Uint64 sessionId, uint32_t num_groups_x, uint32_t num_groups_y, uint32_t num_groups_z, uint32_t group_size_x, uint32_t group_size_y, uint32_t group_size_z, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenDispatchComputeGroupSizeARB(builder, num_groups_x, num_groups_y, num_groups_z, group_size_x, group_size_y, group_size_z);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glDispatchComputeGroupSizeARB), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlDispatchComputeIndirect(Uint64 sessionId, int64_t indirect, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenDispatchComputeIndirect(builder, indirect);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glDispatchComputeIndirect), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlDrawArrays(Uint64 sessionId, uint32_t mode, int32_t first, int32_t count, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenDrawArrays(builder, mode, first, count);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glDrawArrays), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlDrawArraysIndirect(Uint64 sessionId, uint32_t mode, Uint64 token, MobileGLShmHandle* shm) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenDrawArraysIndirect(builder, mode, MobileGL::Protocol::WireFull::CreateShmRegion(builder, 0, shm == nullptr ? 0 : shm->size));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glDrawArraysIndirect), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlDrawArraysInstanced(Uint64 sessionId, uint32_t mode, int32_t first, int32_t count, int32_t instancecount, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenDrawArraysInstanced(builder, mode, first, count, instancecount);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glDrawArraysInstanced), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlDrawArraysInstancedBaseInstance(Uint64 sessionId, uint32_t mode, int32_t first, int32_t count, int32_t instancecount, uint32_t baseinstance, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenDrawArraysInstancedBaseInstance(builder, mode, first, count, instancecount, baseinstance);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glDrawArraysInstancedBaseInstance), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlDrawBuffer(Uint64 sessionId, uint32_t mode, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenDrawBuffer(builder, mode);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glDrawBuffer), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlDrawBuffers(Uint64 sessionId, int32_t n, const std::vector<uint32_t>& bufs, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenDrawBuffers(builder, n, builder.CreateVector(bufs));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glDrawBuffers), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlDrawCommandsAddressNV(Uint64 sessionId, uint32_t primitiveMode, const std::vector<uint64_t>& indirects, const std::vector<int32_t>& sizes, uint32_t count, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenDrawCommandsAddressNV(builder, primitiveMode, builder.CreateVector(indirects), builder.CreateVector(sizes), count);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glDrawCommandsAddressNV), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlDrawCommandsStatesAddressNV(Uint64 sessionId, const std::vector<uint64_t>& indirects, const std::vector<int32_t>& sizes, const std::vector<uint32_t>& states, const std::vector<uint32_t>& fbos, uint32_t count, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenDrawCommandsStatesAddressNV(builder, builder.CreateVector(indirects), builder.CreateVector(sizes), builder.CreateVector(states), builder.CreateVector(fbos), count);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glDrawCommandsStatesAddressNV), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlDrawElements(Uint64 sessionId, uint32_t mode, int32_t count, uint32_t type, Uint64 token, MobileGLShmHandle* shm) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenDrawElements(builder, mode, count, type, MobileGL::Protocol::WireFull::CreateShmRegion(builder, 0, shm == nullptr ? 0 : shm->size));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glDrawElements), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlDrawElementsBaseVertex(Uint64 sessionId, uint32_t mode, int32_t count, uint32_t type, int32_t basevertex, Uint64 token, MobileGLShmHandle* shm) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenDrawElementsBaseVertex(builder, mode, count, type, MobileGL::Protocol::WireFull::CreateShmRegion(builder, 0, shm == nullptr ? 0 : shm->size), basevertex);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glDrawElementsBaseVertex), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlDrawElementsIndirect(Uint64 sessionId, uint32_t mode, uint32_t type, Uint64 token, MobileGLShmHandle* shm) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenDrawElementsIndirect(builder, mode, type, MobileGL::Protocol::WireFull::CreateShmRegion(builder, 0, shm == nullptr ? 0 : shm->size));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glDrawElementsIndirect), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlDrawElementsInstanced(Uint64 sessionId, uint32_t mode, int32_t count, uint32_t type, int32_t instancecount, Uint64 token, MobileGLShmHandle* shm) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenDrawElementsInstanced(builder, mode, count, type, MobileGL::Protocol::WireFull::CreateShmRegion(builder, 0, shm == nullptr ? 0 : shm->size), instancecount);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glDrawElementsInstanced), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlDrawElementsInstancedBaseInstance(Uint64 sessionId, uint32_t mode, int32_t count, uint32_t type, int32_t instancecount, uint32_t baseinstance, Uint64 token, MobileGLShmHandle* shm) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenDrawElementsInstancedBaseInstance(builder, mode, count, type, MobileGL::Protocol::WireFull::CreateShmRegion(builder, 0, shm == nullptr ? 0 : shm->size), instancecount, baseinstance);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glDrawElementsInstancedBaseInstance), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlDrawElementsInstancedBaseVertex(Uint64 sessionId, uint32_t mode, int32_t count, uint32_t type, int32_t instancecount, int32_t basevertex, Uint64 token, MobileGLShmHandle* shm) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenDrawElementsInstancedBaseVertex(builder, mode, count, type, MobileGL::Protocol::WireFull::CreateShmRegion(builder, 0, shm == nullptr ? 0 : shm->size), instancecount, basevertex);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glDrawElementsInstancedBaseVertex), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlDrawElementsInstancedBaseVertexBaseInstance(Uint64 sessionId, uint32_t mode, int32_t count, uint32_t type, int32_t instancecount, int32_t basevertex, uint32_t baseinstance, Uint64 token, MobileGLShmHandle* shm) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenDrawElementsInstancedBaseVertexBaseInstance(builder, mode, count, type, MobileGL::Protocol::WireFull::CreateShmRegion(builder, 0, shm == nullptr ? 0 : shm->size), instancecount, basevertex, baseinstance);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glDrawElementsInstancedBaseVertexBaseInstance), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlDrawMeshTasksIndirectNV(Uint64 sessionId, int64_t indirect, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenDrawMeshTasksIndirectNV(builder, indirect);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glDrawMeshTasksIndirectNV), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlDrawMeshTasksNV(Uint64 sessionId, uint32_t first, uint32_t count, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenDrawMeshTasksNV(builder, first, count);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glDrawMeshTasksNV), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlDrawRangeElements(Uint64 sessionId, uint32_t mode, uint32_t start, uint32_t end, int32_t count, uint32_t type, Uint64 token, MobileGLShmHandle* shm) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenDrawRangeElements(builder, mode, start, end, count, type, MobileGL::Protocol::WireFull::CreateShmRegion(builder, 0, shm == nullptr ? 0 : shm->size));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glDrawRangeElements), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlDrawRangeElementsBaseVertex(Uint64 sessionId, uint32_t mode, uint32_t start, uint32_t end, int32_t count, uint32_t type, int32_t basevertex, Uint64 token, MobileGLShmHandle* shm) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenDrawRangeElementsBaseVertex(builder, mode, start, end, count, type, MobileGL::Protocol::WireFull::CreateShmRegion(builder, 0, shm == nullptr ? 0 : shm->size), basevertex);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glDrawRangeElementsBaseVertex), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlDrawTransformFeedback(Uint64 sessionId, uint32_t mode, uint32_t id, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenDrawTransformFeedback(builder, mode, id);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glDrawTransformFeedback), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlDrawTransformFeedbackInstanced(Uint64 sessionId, uint32_t mode, uint32_t id, int32_t instancecount, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenDrawTransformFeedbackInstanced(builder, mode, id, instancecount);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glDrawTransformFeedbackInstanced), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlDrawTransformFeedbackStream(Uint64 sessionId, uint32_t mode, uint32_t id, uint32_t stream, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenDrawTransformFeedbackStream(builder, mode, id, stream);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glDrawTransformFeedbackStream), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlDrawTransformFeedbackStreamInstanced(Uint64 sessionId, uint32_t mode, uint32_t id, uint32_t stream, int32_t instancecount, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenDrawTransformFeedbackStreamInstanced(builder, mode, id, stream, instancecount);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glDrawTransformFeedbackStreamInstanced), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlDrawVkImageNV(Uint64 sessionId, uint64_t vkImage, uint32_t sampler, float x0, float y0, float x1, float y1, float z, float s0, float t0, float s1, float t1, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenDrawVkImageNV(builder, vkImage, sampler, x0, y0, x1, y1, z, s0, t0, s1, t1);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glDrawVkImageNV), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlEdgeFlagFormatNV(Uint64 sessionId, int32_t stride, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenEdgeFlagFormatNV(builder, stride);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glEdgeFlagFormatNV), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlEnable(Uint64 sessionId, uint32_t cap, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenEnable(builder, cap);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glEnable), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlEnableClientStateIndexedEXT(Uint64 sessionId, uint32_t array, uint32_t index, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenEnableClientStateIndexedEXT(builder, array, index);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glEnableClientStateIndexedEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlEnableClientStateiEXT(Uint64 sessionId, uint32_t array, uint32_t index, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenEnableClientStateiEXT(builder, array, index);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glEnableClientStateiEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlEnableIndexedEXT(Uint64 sessionId, uint32_t target, uint32_t index, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenEnableIndexedEXT(builder, target, index);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glEnableIndexedEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlEnableVertexArrayAttrib(Uint64 sessionId, uint32_t vaobj, uint32_t index, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenEnableVertexArrayAttrib(builder, vaobj, index);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glEnableVertexArrayAttrib), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlEnableVertexArrayAttribEXT(Uint64 sessionId, uint32_t vaobj, uint32_t index, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenEnableVertexArrayAttribEXT(builder, vaobj, index);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glEnableVertexArrayAttribEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlEnableVertexArrayEXT(Uint64 sessionId, uint32_t vaobj, uint32_t array, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenEnableVertexArrayEXT(builder, vaobj, array);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glEnableVertexArrayEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlEnableVertexAttribArray(Uint64 sessionId, uint32_t index, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenEnableVertexAttribArray(builder, index);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glEnableVertexAttribArray), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlEnablei(Uint64 sessionId, uint32_t target, uint32_t index, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenEnablei(builder, target, index);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glEnablei), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlEndPerfMonitorAMD(Uint64 sessionId, uint32_t monitor, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenEndPerfMonitorAMD(builder, monitor);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glEndPerfMonitorAMD), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlEndPerfQueryINTEL(Uint64 sessionId, uint32_t queryHandle, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenEndPerfQueryINTEL(builder, queryHandle);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glEndPerfQueryINTEL), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlEndQuery(Uint64 sessionId, uint32_t target, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenEndQuery(builder, target);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glEndQuery), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlEndQueryIndexed(Uint64 sessionId, uint32_t target, uint32_t index, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenEndQueryIndexed(builder, target, index);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glEndQueryIndexed), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlFenceSync(Uint64 sessionId, uint32_t condition, uint32_t flags, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenFenceSync(builder, condition, flags);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glFenceSync), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlFlushMappedBufferRange(Uint64 sessionId, uint32_t target, int64_t offset, uint64_t length, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenFlushMappedBufferRange(builder, target, offset, length);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glFlushMappedBufferRange), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlFlushMappedNamedBufferRange(Uint64 sessionId, uint32_t buffer, int64_t offset, uint64_t length, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenFlushMappedNamedBufferRange(builder, buffer, offset, length);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glFlushMappedNamedBufferRange), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlFlushMappedNamedBufferRangeEXT(Uint64 sessionId, uint32_t buffer, int64_t offset, uint64_t length, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenFlushMappedNamedBufferRangeEXT(builder, buffer, offset, length);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glFlushMappedNamedBufferRangeEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlFogCoordFormatNV(Uint64 sessionId, uint32_t type, int32_t stride, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenFogCoordFormatNV(builder, type, stride);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glFogCoordFormatNV), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlFragmentCoverageColorNV(Uint64 sessionId, uint32_t color, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenFragmentCoverageColorNV(builder, color);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glFragmentCoverageColorNV), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlFramebufferDrawBufferEXT(Uint64 sessionId, uint32_t framebuffer, uint32_t mode, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenFramebufferDrawBufferEXT(builder, framebuffer, mode);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glFramebufferDrawBufferEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlFramebufferDrawBuffersEXT(Uint64 sessionId, uint32_t framebuffer, int32_t n, const std::vector<uint32_t>& bufs, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenFramebufferDrawBuffersEXT(builder, framebuffer, n, builder.CreateVector(bufs));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glFramebufferDrawBuffersEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlFramebufferParameteri(Uint64 sessionId, uint32_t target, uint32_t pname, int32_t param, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenFramebufferParameteri(builder, target, pname, param);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glFramebufferParameteri), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlFramebufferParameteriMESA(Uint64 sessionId, uint32_t target, uint32_t pname, int32_t param, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenFramebufferParameteriMESA(builder, target, pname, param);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glFramebufferParameteriMESA), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlFramebufferReadBufferEXT(Uint64 sessionId, uint32_t framebuffer, uint32_t mode, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenFramebufferReadBufferEXT(builder, framebuffer, mode);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glFramebufferReadBufferEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlFramebufferRenderbuffer(Uint64 sessionId, uint32_t target, uint32_t attachment, uint32_t renderbuffertarget, uint32_t renderbuffer, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenFramebufferRenderbuffer(builder, target, attachment, renderbuffertarget, renderbuffer);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glFramebufferRenderbuffer), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlFramebufferSampleLocationsfvARB(Uint64 sessionId, uint32_t target, uint32_t start, int32_t count, const std::vector<float>& v, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenFramebufferSampleLocationsfvARB(builder, target, start, count, builder.CreateVector(v));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glFramebufferSampleLocationsfvARB), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlFramebufferSampleLocationsfvNV(Uint64 sessionId, uint32_t target, uint32_t start, int32_t count, const std::vector<float>& v, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenFramebufferSampleLocationsfvNV(builder, target, start, count, builder.CreateVector(v));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glFramebufferSampleLocationsfvNV), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlFramebufferTexture(Uint64 sessionId, uint32_t target, uint32_t attachment, uint32_t texture, int32_t level, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenFramebufferTexture(builder, target, attachment, texture, level);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glFramebufferTexture), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlFramebufferTexture1D(Uint64 sessionId, uint32_t target, uint32_t attachment, uint32_t textarget, uint32_t texture, int32_t level, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenFramebufferTexture1D(builder, target, attachment, textarget, texture, level);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glFramebufferTexture1D), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlFramebufferTexture1DEXT(Uint64 sessionId, uint32_t target, uint32_t attachment, uint32_t textarget, uint32_t texture, int32_t level, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenFramebufferTexture1DEXT(builder, target, attachment, textarget, texture, level);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glFramebufferTexture1DEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlFramebufferTexture2D(Uint64 sessionId, uint32_t target, uint32_t attachment, uint32_t textarget, uint32_t texture, int32_t level, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenFramebufferTexture2D(builder, target, attachment, textarget, texture, level);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glFramebufferTexture2D), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlFramebufferTexture3D(Uint64 sessionId, uint32_t target, uint32_t attachment, uint32_t textarget, uint32_t texture, int32_t level, int32_t zoffset, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenFramebufferTexture3D(builder, target, attachment, textarget, texture, level, zoffset);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glFramebufferTexture3D), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlFramebufferTexture3DEXT(Uint64 sessionId, uint32_t target, uint32_t attachment, uint32_t textarget, uint32_t texture, int32_t level, int32_t zoffset, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenFramebufferTexture3DEXT(builder, target, attachment, textarget, texture, level, zoffset);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glFramebufferTexture3DEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlFramebufferTextureFaceARB(Uint64 sessionId, uint32_t target, uint32_t attachment, uint32_t texture, int32_t level, uint32_t face, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenFramebufferTextureFaceARB(builder, target, attachment, texture, level, face);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glFramebufferTextureFaceARB), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlFramebufferTextureLayer(Uint64 sessionId, uint32_t target, uint32_t attachment, uint32_t texture, int32_t level, int32_t layer, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenFramebufferTextureLayer(builder, target, attachment, texture, level, layer);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glFramebufferTextureLayer), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlFramebufferTextureMultiviewOVR(Uint64 sessionId, uint32_t target, uint32_t attachment, uint32_t texture, int32_t level, int32_t baseViewIndex, int32_t numViews, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenFramebufferTextureMultiviewOVR(builder, target, attachment, texture, level, baseViewIndex, numViews);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glFramebufferTextureMultiviewOVR), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlFrontFace(Uint64 sessionId, uint32_t mode, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenFrontFace(builder, mode);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glFrontFace), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlGenBuffers(Uint64 sessionId, int32_t n, Uint64 token, MobileGLShmHandle* shm = nullptr, Uint32 outCapacity = 0) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGenBuffers(builder, n, 0);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGenBuffers), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm, outCapacity);
}
inline Bool SendGlGenFramebuffers(Uint64 sessionId, int32_t n, Uint64 token, MobileGLShmHandle* shm = nullptr, Uint32 outCapacity = 0) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGenFramebuffers(builder, n, 0);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGenFramebuffers), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm, outCapacity);
}
inline Bool SendGlGenPathsNV(Uint64 sessionId, int32_t range, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGenPathsNV(builder, range);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGenPathsNV), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlGenPerfMonitorsAMD(Uint64 sessionId, int32_t n, Uint64 token, MobileGLShmHandle* shm = nullptr, Uint32 outCapacity = 0) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGenPerfMonitorsAMD(builder, n, 0);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGenPerfMonitorsAMD), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm, outCapacity);
}
inline Bool SendGlGenProgramPipelines(Uint64 sessionId, int32_t n, Uint64 token, MobileGLShmHandle* shm = nullptr, Uint32 outCapacity = 0) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGenProgramPipelines(builder, n, 0);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGenProgramPipelines), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm, outCapacity);
}
inline Bool SendGlGenQueries(Uint64 sessionId, int32_t n, Uint64 token, MobileGLShmHandle* shm = nullptr, Uint32 outCapacity = 0) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGenQueries(builder, n, 0);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGenQueries), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm, outCapacity);
}
inline Bool SendGlGenRenderbuffers(Uint64 sessionId, int32_t n, Uint64 token, MobileGLShmHandle* shm = nullptr, Uint32 outCapacity = 0) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGenRenderbuffers(builder, n, 0);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGenRenderbuffers), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm, outCapacity);
}
inline Bool SendGlGenSamplers(Uint64 sessionId, int32_t count, Uint64 token, MobileGLShmHandle* shm = nullptr, Uint32 outCapacity = 0) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGenSamplers(builder, count, 0);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGenSamplers), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm, outCapacity);
}
inline Bool SendGlGenTextures(Uint64 sessionId, int32_t n, Uint64 token, MobileGLShmHandle* shm = nullptr, Uint32 outCapacity = 0) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGenTextures(builder, n, 0);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGenTextures), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm, outCapacity);
}
inline Bool SendGlGenTransformFeedbacks(Uint64 sessionId, int32_t n, Uint64 token, MobileGLShmHandle* shm = nullptr, Uint32 outCapacity = 0) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGenTransformFeedbacks(builder, n, 0);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGenTransformFeedbacks), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm, outCapacity);
}
inline Bool SendGlGenVertexArrays(Uint64 sessionId, int32_t n, Uint64 token, MobileGLShmHandle* shm = nullptr, Uint32 outCapacity = 0) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGenVertexArrays(builder, n, 0);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGenVertexArrays), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm, outCapacity);
}
inline Bool SendGlGenerateMipmap(Uint64 sessionId, uint32_t target, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGenerateMipmap(builder, target);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGenerateMipmap), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlGenerateMultiTexMipmapEXT(Uint64 sessionId, uint32_t texunit, uint32_t target, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGenerateMultiTexMipmapEXT(builder, texunit, target);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGenerateMultiTexMipmapEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlGenerateTextureMipmap(Uint64 sessionId, uint32_t texture, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGenerateTextureMipmap(builder, texture);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGenerateTextureMipmap), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlGenerateTextureMipmapEXT(Uint64 sessionId, uint32_t texture, uint32_t target, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGenerateTextureMipmapEXT(builder, texture, target);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGenerateTextureMipmapEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlGetActiveAtomicCounterBufferiv(Uint64 sessionId, uint32_t program, uint32_t bufferIndex, uint32_t pname, Uint64 token, MobileGLShmHandle* shm = nullptr, Uint32 outCapacity = 0) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGetActiveAtomicCounterBufferiv(builder, program, bufferIndex, pname, 0);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGetActiveAtomicCounterBufferiv), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm, outCapacity);
}
inline Bool SendGlGetActiveAttrib(Uint64 sessionId, uint32_t program, uint32_t index, int32_t bufSize, const char* name, Uint64 token, MobileGLShmHandle* shm = nullptr, Uint32 outCapacity = 0) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGetActiveAttrib(builder, program, index, bufSize, 0, 0, 0, builder.CreateString(name));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGetActiveAttrib), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm, outCapacity);
}
inline Bool SendGlGetActiveSubroutineName(Uint64 sessionId, uint32_t program, uint32_t shadertype, uint32_t index, int32_t bufSize, const char* name, Uint64 token, MobileGLShmHandle* shm = nullptr, Uint32 outCapacity = 0) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGetActiveSubroutineName(builder, program, shadertype, index, bufSize, 0, builder.CreateString(name));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGetActiveSubroutineName), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm, outCapacity);
}
inline Bool SendGlGetActiveSubroutineUniformName(Uint64 sessionId, uint32_t program, uint32_t shadertype, uint32_t index, int32_t bufSize, const char* name, Uint64 token, MobileGLShmHandle* shm = nullptr, Uint32 outCapacity = 0) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGetActiveSubroutineUniformName(builder, program, shadertype, index, bufSize, 0, builder.CreateString(name));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGetActiveSubroutineUniformName), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm, outCapacity);
}
inline Bool SendGlGetActiveSubroutineUniformiv(Uint64 sessionId, uint32_t program, uint32_t shadertype, uint32_t index, uint32_t pname, Uint64 token, MobileGLShmHandle* shm = nullptr, Uint32 outCapacity = 0) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGetActiveSubroutineUniformiv(builder, program, shadertype, index, pname, 0);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGetActiveSubroutineUniformiv), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm, outCapacity);
}
inline Bool SendGlGetActiveUniform(Uint64 sessionId, uint32_t program, uint32_t index, int32_t bufSize, const char* name, Uint64 token, MobileGLShmHandle* shm = nullptr, Uint32 outCapacity = 0) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGetActiveUniform(builder, program, index, bufSize, 0, 0, 0, builder.CreateString(name));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGetActiveUniform), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm, outCapacity);
}
inline Bool SendGlGetActiveUniformBlockName(Uint64 sessionId, uint32_t program, uint32_t uniformBlockIndex, int32_t bufSize, const char* uniformBlockName, Uint64 token, MobileGLShmHandle* shm = nullptr, Uint32 outCapacity = 0) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGetActiveUniformBlockName(builder, program, uniformBlockIndex, bufSize, 0, builder.CreateString(uniformBlockName));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGetActiveUniformBlockName), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm, outCapacity);
}
inline Bool SendGlGetActiveUniformBlockiv(Uint64 sessionId, uint32_t program, uint32_t uniformBlockIndex, uint32_t pname, Uint64 token, MobileGLShmHandle* shm = nullptr, Uint32 outCapacity = 0) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGetActiveUniformBlockiv(builder, program, uniformBlockIndex, pname, 0);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGetActiveUniformBlockiv), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm, outCapacity);
}
inline Bool SendGlGetActiveUniformName(Uint64 sessionId, uint32_t program, uint32_t uniformIndex, int32_t bufSize, const char* uniformName, Uint64 token, MobileGLShmHandle* shm = nullptr, Uint32 outCapacity = 0) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGetActiveUniformName(builder, program, uniformIndex, bufSize, 0, builder.CreateString(uniformName));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGetActiveUniformName), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm, outCapacity);
}
inline Bool SendGlGetActiveUniformsiv(Uint64 sessionId, uint32_t program, int32_t uniformCount, const std::vector<uint32_t>& uniformIndices, uint32_t pname, Uint64 token, MobileGLShmHandle* shm = nullptr, Uint32 outCapacity = 0) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGetActiveUniformsiv(builder, program, uniformCount, builder.CreateVector(uniformIndices), pname, 0);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGetActiveUniformsiv), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm, outCapacity);
}
inline Bool SendGlGetAttachedShaders(Uint64 sessionId, uint32_t program, int32_t maxCount, Uint64 token, MobileGLShmHandle* shm = nullptr, Uint32 outCapacity = 0) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGetAttachedShaders(builder, program, maxCount, 0, 0);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGetAttachedShaders), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm, outCapacity);
}
inline Bool SendGlGetAttribLocation(Uint64 sessionId, uint32_t program, const char* name, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGetAttribLocation(builder, program, builder.CreateString(name));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGetAttribLocation), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlGetBooleanIndexedvEXT(Uint64 sessionId, uint32_t target, uint32_t index, Uint64 token, MobileGLShmHandle* shm = nullptr, Uint32 outCapacity = 0) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGetBooleanIndexedvEXT(builder, target, index, 0);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGetBooleanIndexedvEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm, outCapacity);
}
inline Bool SendGlGetBooleani_v(Uint64 sessionId, uint32_t target, uint32_t index, Uint64 token, MobileGLShmHandle* shm = nullptr, Uint32 outCapacity = 0) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGetBooleani_v(builder, target, index, 0);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGetBooleani_v), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm, outCapacity);
}
inline Bool SendGlGetBooleanv(Uint64 sessionId, uint32_t pname, Uint64 token, MobileGLShmHandle* shm = nullptr, Uint32 outCapacity = 0) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGetBooleanv(builder, pname, 0);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGetBooleanv), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm, outCapacity);
}
inline Bool SendGlGetBufferParameteri64v(Uint64 sessionId, uint32_t target, uint32_t pname, Uint64 token, MobileGLShmHandle* shm = nullptr, Uint32 outCapacity = 0) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGetBufferParameteri64v(builder, target, pname, 0);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGetBufferParameteri64v), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm, outCapacity);
}
inline Bool SendGlGetBufferParameteriv(Uint64 sessionId, uint32_t target, uint32_t pname, Uint64 token, MobileGLShmHandle* shm = nullptr, Uint32 outCapacity = 0) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGetBufferParameteriv(builder, target, pname, 0);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGetBufferParameteriv), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm, outCapacity);
}
inline Bool SendGlGetBufferParameterui64vNV(Uint64 sessionId, uint32_t target, uint32_t pname, Uint64 token, MobileGLShmHandle* shm = nullptr, Uint32 outCapacity = 0) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGetBufferParameterui64vNV(builder, target, pname, 0);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGetBufferParameterui64vNV), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm, outCapacity);
}
inline Bool SendGlGetBufferSubData(Uint64 sessionId, uint32_t target, int64_t offset, uint64_t size, Uint64 token, MobileGLShmHandle* shm) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGetBufferSubData(builder, target, offset, size, MobileGL::Protocol::WireFull::CreateShmRegion(builder, 0, shm == nullptr ? 0 : shm->size));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGetBufferSubData), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlGetCommandHeaderNV(Uint64 sessionId, uint32_t tokenID, uint32_t size, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGetCommandHeaderNV(builder, tokenID, size);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGetCommandHeaderNV), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlGetCompressedMultiTexImageEXT(Uint64 sessionId, uint32_t texunit, uint32_t target, int32_t lod, Uint64 token, MobileGLShmHandle* shm) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGetCompressedMultiTexImageEXT(builder, texunit, target, lod, MobileGL::Protocol::WireFull::CreateShmRegion(builder, 0, shm == nullptr ? 0 : shm->size));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGetCompressedMultiTexImageEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlGetCompressedTexImage(Uint64 sessionId, uint32_t target, int32_t level, Uint64 token, MobileGLShmHandle* shm) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGetCompressedTexImage(builder, target, level, MobileGL::Protocol::WireFull::CreateShmRegion(builder, 0, shm == nullptr ? 0 : shm->size));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGetCompressedTexImage), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlGetCompressedTextureImage(Uint64 sessionId, uint32_t texture, int32_t level, int32_t bufSize, Uint64 token, MobileGLShmHandle* shm) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGetCompressedTextureImage(builder, texture, level, bufSize, MobileGL::Protocol::WireFull::CreateShmRegion(builder, 0, shm == nullptr ? 0 : shm->size));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGetCompressedTextureImage), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlGetCompressedTextureImageEXT(Uint64 sessionId, uint32_t texture, uint32_t target, int32_t lod, Uint64 token, MobileGLShmHandle* shm) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGetCompressedTextureImageEXT(builder, texture, target, lod, MobileGL::Protocol::WireFull::CreateShmRegion(builder, 0, shm == nullptr ? 0 : shm->size));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGetCompressedTextureImageEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlGetCompressedTextureSubImage(Uint64 sessionId, uint32_t texture, int32_t level, int32_t xoffset, int32_t yoffset, int32_t zoffset, int32_t width, int32_t height, int32_t depth, int32_t bufSize, Uint64 token, MobileGLShmHandle* shm) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGetCompressedTextureSubImage(builder, texture, level, xoffset, yoffset, zoffset, width, height, depth, bufSize, MobileGL::Protocol::WireFull::CreateShmRegion(builder, 0, shm == nullptr ? 0 : shm->size));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGetCompressedTextureSubImage), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlGetCoverageModulationTableNV(Uint64 sessionId, int32_t bufSize, Uint64 token, MobileGLShmHandle* shm = nullptr, Uint32 outCapacity = 0) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGetCoverageModulationTableNV(builder, bufSize, 0);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGetCoverageModulationTableNV), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm, outCapacity);
}
inline Bool SendGlGetDebugMessageLog(Uint64 sessionId, uint32_t count, int32_t bufSize, const char* messageLog, Uint64 token, MobileGLShmHandle* shm = nullptr, Uint32 outCapacity = 0) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGetDebugMessageLog(builder, count, bufSize, 0, 0, 0, 0, 0, builder.CreateString(messageLog));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGetDebugMessageLog), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm, outCapacity);
}
inline Bool SendGlGetDoubleIndexedvEXT(Uint64 sessionId, uint32_t target, uint32_t index, Uint64 token, MobileGLShmHandle* shm = nullptr, Uint32 outCapacity = 0) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGetDoubleIndexedvEXT(builder, target, index, 0);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGetDoubleIndexedvEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm, outCapacity);
}
inline Bool SendGlGetDoublei_v(Uint64 sessionId, uint32_t target, uint32_t index, Uint64 token, MobileGLShmHandle* shm = nullptr, Uint32 outCapacity = 0) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGetDoublei_v(builder, target, index, 0);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGetDoublei_v), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm, outCapacity);
}
inline Bool SendGlGetDoublei_vEXT(Uint64 sessionId, uint32_t pname, uint32_t index, Uint64 token, MobileGLShmHandle* shm = nullptr, Uint32 outCapacity = 0) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGetDoublei_vEXT(builder, pname, index, 0);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGetDoublei_vEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm, outCapacity);
}
inline Bool SendGlGetDoublev(Uint64 sessionId, uint32_t pname, Uint64 token, MobileGLShmHandle* shm = nullptr, Uint32 outCapacity = 0) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGetDoublev(builder, pname, 0);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGetDoublev), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm, outCapacity);
}
inline Bool SendGlGetFirstPerfQueryIdINTEL(Uint64 sessionId, Uint64 token, MobileGLShmHandle* shm = nullptr, Uint32 outCapacity = 0) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGetFirstPerfQueryIdINTEL(builder, 0);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGetFirstPerfQueryIdINTEL), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm, outCapacity);
}
inline Bool SendGlGetFloatIndexedvEXT(Uint64 sessionId, uint32_t target, uint32_t index, Uint64 token, MobileGLShmHandle* shm = nullptr, Uint32 outCapacity = 0) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGetFloatIndexedvEXT(builder, target, index, 0);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGetFloatIndexedvEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm, outCapacity);
}
inline Bool SendGlGetFloati_v(Uint64 sessionId, uint32_t target, uint32_t index, Uint64 token, MobileGLShmHandle* shm = nullptr, Uint32 outCapacity = 0) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGetFloati_v(builder, target, index, 0);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGetFloati_v), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm, outCapacity);
}
inline Bool SendGlGetFloati_vEXT(Uint64 sessionId, uint32_t pname, uint32_t index, Uint64 token, MobileGLShmHandle* shm = nullptr, Uint32 outCapacity = 0) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGetFloati_vEXT(builder, pname, index, 0);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGetFloati_vEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm, outCapacity);
}
inline Bool SendGlGetFloatv(Uint64 sessionId, uint32_t pname, Uint64 token, MobileGLShmHandle* shm = nullptr, Uint32 outCapacity = 0) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGetFloatv(builder, pname, 0);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGetFloatv), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm, outCapacity);
}
inline Bool SendGlGetFragDataIndex(Uint64 sessionId, uint32_t program, const char* name, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGetFragDataIndex(builder, program, builder.CreateString(name));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGetFragDataIndex), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlGetFragDataLocation(Uint64 sessionId, uint32_t program, const char* name, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGetFragDataLocation(builder, program, builder.CreateString(name));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGetFragDataLocation), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlGetFramebufferAttachmentParameteriv(Uint64 sessionId, uint32_t target, uint32_t attachment, uint32_t pname, Uint64 token, MobileGLShmHandle* shm = nullptr, Uint32 outCapacity = 0) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGetFramebufferAttachmentParameteriv(builder, target, attachment, pname, 0);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGetFramebufferAttachmentParameteriv), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm, outCapacity);
}
inline Bool SendGlGetFramebufferParameteriv(Uint64 sessionId, uint32_t target, uint32_t pname, Uint64 token, MobileGLShmHandle* shm = nullptr, Uint32 outCapacity = 0) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGetFramebufferParameteriv(builder, target, pname, 0);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGetFramebufferParameteriv), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm, outCapacity);
}
inline Bool SendGlGetFramebufferParameterivMESA(Uint64 sessionId, uint32_t target, uint32_t pname, Uint64 token, MobileGLShmHandle* shm = nullptr, Uint32 outCapacity = 0) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGetFramebufferParameterivMESA(builder, target, pname, 0);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGetFramebufferParameterivMESA), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm, outCapacity);
}
inline Bool SendGlGetImageHandleARB(Uint64 sessionId, uint32_t texture, int32_t level, bool layered, int32_t layer, uint32_t format, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGetImageHandleARB(builder, texture, level, layered, layer, format);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGetImageHandleARB), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlGetImageHandleNV(Uint64 sessionId, uint32_t texture, int32_t level, bool layered, int32_t layer, uint32_t format, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGetImageHandleNV(builder, texture, level, layered, layer, format);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGetImageHandleNV), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlGetInteger64i_v(Uint64 sessionId, uint32_t target, uint32_t index, Uint64 token, MobileGLShmHandle* shm = nullptr, Uint32 outCapacity = 0) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGetInteger64i_v(builder, target, index, 0);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGetInteger64i_v), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm, outCapacity);
}
inline Bool SendGlGetInteger64v(Uint64 sessionId, uint32_t pname, Uint64 token, MobileGLShmHandle* shm = nullptr, Uint32 outCapacity = 0) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGetInteger64v(builder, pname, 0);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGetInteger64v), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm, outCapacity);
}
inline Bool SendGlGetIntegerIndexedvEXT(Uint64 sessionId, uint32_t target, uint32_t index, Uint64 token, MobileGLShmHandle* shm = nullptr, Uint32 outCapacity = 0) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGetIntegerIndexedvEXT(builder, target, index, 0);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGetIntegerIndexedvEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm, outCapacity);
}
inline Bool SendGlGetIntegeri_v(Uint64 sessionId, uint32_t target, uint32_t index, Uint64 token, MobileGLShmHandle* shm = nullptr, Uint32 outCapacity = 0) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGetIntegeri_v(builder, target, index, 0);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGetIntegeri_v), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm, outCapacity);
}
inline Bool SendGlGetIntegerui64i_vNV(Uint64 sessionId, uint32_t value, uint32_t index, Uint64 token, MobileGLShmHandle* shm = nullptr, Uint32 outCapacity = 0) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGetIntegerui64i_vNV(builder, value, index, 0);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGetIntegerui64i_vNV), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm, outCapacity);
}
inline Bool SendGlGetIntegerui64vNV(Uint64 sessionId, uint32_t value, Uint64 token, MobileGLShmHandle* shm = nullptr, Uint32 outCapacity = 0) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGetIntegerui64vNV(builder, value, 0);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGetIntegerui64vNV), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm, outCapacity);
}
inline Bool SendGlGetIntegerv(Uint64 sessionId, uint32_t pname, Uint64 token, MobileGLShmHandle* shm = nullptr, Uint32 outCapacity = 0) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGetIntegerv(builder, pname, 0);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGetIntegerv), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm, outCapacity);
}
inline Bool SendGlGetInternalformatSampleivNV(Uint64 sessionId, uint32_t target, uint32_t internalformat, int32_t samples, uint32_t pname, int32_t count, Uint64 token, MobileGLShmHandle* shm = nullptr, Uint32 outCapacity = 0) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGetInternalformatSampleivNV(builder, target, internalformat, samples, pname, count, 0);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGetInternalformatSampleivNV), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm, outCapacity);
}
inline Bool SendGlGetInternalformati64v(Uint64 sessionId, uint32_t target, uint32_t internalformat, uint32_t pname, int32_t count, Uint64 token, MobileGLShmHandle* shm = nullptr, Uint32 outCapacity = 0) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGetInternalformati64v(builder, target, internalformat, pname, count, 0);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGetInternalformati64v), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm, outCapacity);
}
inline Bool SendGlGetInternalformativ(Uint64 sessionId, uint32_t target, uint32_t internalformat, uint32_t pname, int32_t bufSize, Uint64 token, MobileGLShmHandle* shm = nullptr, Uint32 outCapacity = 0) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGetInternalformativ(builder, target, internalformat, pname, bufSize, 0);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGetInternalformativ), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm, outCapacity);
}
inline Bool SendGlGetMemoryObjectDetachedResourcesuivNV(Uint64 sessionId, uint32_t memory, uint32_t pname, int32_t first, int32_t count, Uint64 token, MobileGLShmHandle* shm = nullptr, Uint32 outCapacity = 0) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGetMemoryObjectDetachedResourcesuivNV(builder, memory, pname, first, count, 0);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGetMemoryObjectDetachedResourcesuivNV), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm, outCapacity);
}
inline Bool SendGlGetMultiTexEnvfvEXT(Uint64 sessionId, uint32_t texunit, uint32_t target, uint32_t pname, Uint64 token, MobileGLShmHandle* shm = nullptr, Uint32 outCapacity = 0) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGetMultiTexEnvfvEXT(builder, texunit, target, pname, 0);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGetMultiTexEnvfvEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm, outCapacity);
}
inline Bool SendGlGetMultiTexEnvivEXT(Uint64 sessionId, uint32_t texunit, uint32_t target, uint32_t pname, Uint64 token, MobileGLShmHandle* shm = nullptr, Uint32 outCapacity = 0) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGetMultiTexEnvivEXT(builder, texunit, target, pname, 0);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGetMultiTexEnvivEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm, outCapacity);
}
inline Bool SendGlGetMultiTexGendvEXT(Uint64 sessionId, uint32_t texunit, uint32_t coord, uint32_t pname, Uint64 token, MobileGLShmHandle* shm = nullptr, Uint32 outCapacity = 0) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGetMultiTexGendvEXT(builder, texunit, coord, pname, 0);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGetMultiTexGendvEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm, outCapacity);
}
inline Bool SendGlGetMultiTexGenfvEXT(Uint64 sessionId, uint32_t texunit, uint32_t coord, uint32_t pname, Uint64 token, MobileGLShmHandle* shm = nullptr, Uint32 outCapacity = 0) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGetMultiTexGenfvEXT(builder, texunit, coord, pname, 0);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGetMultiTexGenfvEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm, outCapacity);
}
inline Bool SendGlGetMultiTexGenivEXT(Uint64 sessionId, uint32_t texunit, uint32_t coord, uint32_t pname, Uint64 token, MobileGLShmHandle* shm = nullptr, Uint32 outCapacity = 0) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGetMultiTexGenivEXT(builder, texunit, coord, pname, 0);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGetMultiTexGenivEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm, outCapacity);
}
inline Bool SendGlGetMultiTexImageEXT(Uint64 sessionId, uint32_t texunit, uint32_t target, int32_t level, uint32_t format, uint32_t type, Uint64 token, MobileGLShmHandle* shm) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGetMultiTexImageEXT(builder, texunit, target, level, format, type, MobileGL::Protocol::WireFull::CreateShmRegion(builder, 0, shm == nullptr ? 0 : shm->size));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGetMultiTexImageEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlGetMultiTexLevelParameterfvEXT(Uint64 sessionId, uint32_t texunit, uint32_t target, int32_t level, uint32_t pname, Uint64 token, MobileGLShmHandle* shm = nullptr, Uint32 outCapacity = 0) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGetMultiTexLevelParameterfvEXT(builder, texunit, target, level, pname, 0);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGetMultiTexLevelParameterfvEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm, outCapacity);
}
inline Bool SendGlGetMultiTexLevelParameterivEXT(Uint64 sessionId, uint32_t texunit, uint32_t target, int32_t level, uint32_t pname, Uint64 token, MobileGLShmHandle* shm = nullptr, Uint32 outCapacity = 0) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGetMultiTexLevelParameterivEXT(builder, texunit, target, level, pname, 0);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGetMultiTexLevelParameterivEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm, outCapacity);
}
inline Bool SendGlGetMultiTexParameterIivEXT(Uint64 sessionId, uint32_t texunit, uint32_t target, uint32_t pname, Uint64 token, MobileGLShmHandle* shm = nullptr, Uint32 outCapacity = 0) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGetMultiTexParameterIivEXT(builder, texunit, target, pname, 0);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGetMultiTexParameterIivEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm, outCapacity);
}
inline Bool SendGlGetMultiTexParameterIuivEXT(Uint64 sessionId, uint32_t texunit, uint32_t target, uint32_t pname, Uint64 token, MobileGLShmHandle* shm = nullptr, Uint32 outCapacity = 0) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGetMultiTexParameterIuivEXT(builder, texunit, target, pname, 0);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGetMultiTexParameterIuivEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm, outCapacity);
}
inline Bool SendGlGetMultiTexParameterfvEXT(Uint64 sessionId, uint32_t texunit, uint32_t target, uint32_t pname, Uint64 token, MobileGLShmHandle* shm = nullptr, Uint32 outCapacity = 0) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGetMultiTexParameterfvEXT(builder, texunit, target, pname, 0);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGetMultiTexParameterfvEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm, outCapacity);
}
inline Bool SendGlGetMultiTexParameterivEXT(Uint64 sessionId, uint32_t texunit, uint32_t target, uint32_t pname, Uint64 token, MobileGLShmHandle* shm = nullptr, Uint32 outCapacity = 0) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGetMultiTexParameterivEXT(builder, texunit, target, pname, 0);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGetMultiTexParameterivEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm, outCapacity);
}
inline Bool SendGlGetMultisamplefv(Uint64 sessionId, uint32_t pname, uint32_t index, Uint64 token, MobileGLShmHandle* shm = nullptr, Uint32 outCapacity = 0) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGetMultisamplefv(builder, pname, index, 0);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGetMultisamplefv), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm, outCapacity);
}
inline Bool SendGlGetNamedBufferParameteri64v(Uint64 sessionId, uint32_t buffer, uint32_t pname, Uint64 token, MobileGLShmHandle* shm = nullptr, Uint32 outCapacity = 0) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGetNamedBufferParameteri64v(builder, buffer, pname, 0);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGetNamedBufferParameteri64v), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm, outCapacity);
}
inline Bool SendGlGetNamedBufferParameteriv(Uint64 sessionId, uint32_t buffer, uint32_t pname, Uint64 token, MobileGLShmHandle* shm = nullptr, Uint32 outCapacity = 0) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGetNamedBufferParameteriv(builder, buffer, pname, 0);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGetNamedBufferParameteriv), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm, outCapacity);
}
inline Bool SendGlGetNamedBufferParameterivEXT(Uint64 sessionId, uint32_t buffer, uint32_t pname, Uint64 token, MobileGLShmHandle* shm = nullptr, Uint32 outCapacity = 0) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGetNamedBufferParameterivEXT(builder, buffer, pname, 0);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGetNamedBufferParameterivEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm, outCapacity);
}
inline Bool SendGlGetNamedBufferParameterui64vNV(Uint64 sessionId, uint32_t buffer, uint32_t pname, Uint64 token, MobileGLShmHandle* shm = nullptr, Uint32 outCapacity = 0) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGetNamedBufferParameterui64vNV(builder, buffer, pname, 0);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGetNamedBufferParameterui64vNV), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm, outCapacity);
}
inline Bool SendGlGetNamedBufferSubData(Uint64 sessionId, uint32_t buffer, int64_t offset, uint64_t size, Uint64 token, MobileGLShmHandle* shm) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGetNamedBufferSubData(builder, buffer, offset, size, MobileGL::Protocol::WireFull::CreateShmRegion(builder, 0, shm == nullptr ? 0 : shm->size));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGetNamedBufferSubData), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlGetNamedBufferSubDataEXT(Uint64 sessionId, uint32_t buffer, int64_t offset, uint64_t size, Uint64 token, MobileGLShmHandle* shm) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGetNamedBufferSubDataEXT(builder, buffer, offset, size, MobileGL::Protocol::WireFull::CreateShmRegion(builder, 0, shm == nullptr ? 0 : shm->size));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGetNamedBufferSubDataEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlGetNamedFramebufferAttachmentParameteriv(Uint64 sessionId, uint32_t framebuffer, uint32_t attachment, uint32_t pname, Uint64 token, MobileGLShmHandle* shm = nullptr, Uint32 outCapacity = 0) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGetNamedFramebufferAttachmentParameteriv(builder, framebuffer, attachment, pname, 0);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGetNamedFramebufferAttachmentParameteriv), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm, outCapacity);
}
inline Bool SendGlGetNamedFramebufferAttachmentParameterivEXT(Uint64 sessionId, uint32_t framebuffer, uint32_t attachment, uint32_t pname, Uint64 token, MobileGLShmHandle* shm = nullptr, Uint32 outCapacity = 0) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGetNamedFramebufferAttachmentParameterivEXT(builder, framebuffer, attachment, pname, 0);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGetNamedFramebufferAttachmentParameterivEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm, outCapacity);
}
inline Bool SendGlGetNamedFramebufferParameteriv(Uint64 sessionId, uint32_t framebuffer, uint32_t pname, Uint64 token, MobileGLShmHandle* shm = nullptr, Uint32 outCapacity = 0) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGetNamedFramebufferParameteriv(builder, framebuffer, pname, 0);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGetNamedFramebufferParameteriv), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm, outCapacity);
}
inline Bool SendGlGetNamedFramebufferParameterivEXT(Uint64 sessionId, uint32_t framebuffer, uint32_t pname, Uint64 token, MobileGLShmHandle* shm = nullptr, Uint32 outCapacity = 0) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGetNamedFramebufferParameterivEXT(builder, framebuffer, pname, 0);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGetNamedFramebufferParameterivEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm, outCapacity);
}
inline Bool SendGlGetNamedProgramLocalParameterIivEXT(Uint64 sessionId, uint32_t program, uint32_t target, uint32_t index, Uint64 token, MobileGLShmHandle* shm = nullptr, Uint32 outCapacity = 0) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGetNamedProgramLocalParameterIivEXT(builder, program, target, index, 0);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGetNamedProgramLocalParameterIivEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm, outCapacity);
}
inline Bool SendGlGetNamedProgramLocalParameterIuivEXT(Uint64 sessionId, uint32_t program, uint32_t target, uint32_t index, Uint64 token, MobileGLShmHandle* shm = nullptr, Uint32 outCapacity = 0) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGetNamedProgramLocalParameterIuivEXT(builder, program, target, index, 0);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGetNamedProgramLocalParameterIuivEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm, outCapacity);
}
inline Bool SendGlGetNamedProgramLocalParameterdvEXT(Uint64 sessionId, uint32_t program, uint32_t target, uint32_t index, Uint64 token, MobileGLShmHandle* shm = nullptr, Uint32 outCapacity = 0) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGetNamedProgramLocalParameterdvEXT(builder, program, target, index, 0);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGetNamedProgramLocalParameterdvEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm, outCapacity);
}
inline Bool SendGlGetNamedProgramLocalParameterfvEXT(Uint64 sessionId, uint32_t program, uint32_t target, uint32_t index, Uint64 token, MobileGLShmHandle* shm = nullptr, Uint32 outCapacity = 0) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGetNamedProgramLocalParameterfvEXT(builder, program, target, index, 0);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGetNamedProgramLocalParameterfvEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm, outCapacity);
}
inline Bool SendGlGetNamedProgramStringEXT(Uint64 sessionId, uint32_t program, uint32_t target, uint32_t pname, Uint64 token, MobileGLShmHandle* shm) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGetNamedProgramStringEXT(builder, program, target, pname, MobileGL::Protocol::WireFull::CreateShmRegion(builder, 0, shm == nullptr ? 0 : shm->size));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGetNamedProgramStringEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlGetNamedProgramivEXT(Uint64 sessionId, uint32_t program, uint32_t target, uint32_t pname, Uint64 token, MobileGLShmHandle* shm = nullptr, Uint32 outCapacity = 0) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGetNamedProgramivEXT(builder, program, target, pname, 0);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGetNamedProgramivEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm, outCapacity);
}
inline Bool SendGlGetNamedRenderbufferParameteriv(Uint64 sessionId, uint32_t renderbuffer, uint32_t pname, Uint64 token, MobileGLShmHandle* shm = nullptr, Uint32 outCapacity = 0) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGetNamedRenderbufferParameteriv(builder, renderbuffer, pname, 0);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGetNamedRenderbufferParameteriv), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm, outCapacity);
}
inline Bool SendGlGetNamedRenderbufferParameterivEXT(Uint64 sessionId, uint32_t renderbuffer, uint32_t pname, Uint64 token, MobileGLShmHandle* shm = nullptr, Uint32 outCapacity = 0) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGetNamedRenderbufferParameterivEXT(builder, renderbuffer, pname, 0);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGetNamedRenderbufferParameterivEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm, outCapacity);
}
inline Bool SendGlGetNamedStringARB(Uint64 sessionId, int32_t namelen, const char* name, int32_t bufSize, const char* string, Uint64 token, MobileGLShmHandle* shm = nullptr, Uint32 outCapacity = 0) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGetNamedStringARB(builder, namelen, builder.CreateString(name), bufSize, 0, builder.CreateString(string));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGetNamedStringARB), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm, outCapacity);
}
inline Bool SendGlGetNamedStringivARB(Uint64 sessionId, int32_t namelen, const char* name, uint32_t pname, Uint64 token, MobileGLShmHandle* shm = nullptr, Uint32 outCapacity = 0) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGetNamedStringivARB(builder, namelen, builder.CreateString(name), pname, 0);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGetNamedStringivARB), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm, outCapacity);
}
inline Bool SendGlGetNextPerfQueryIdINTEL(Uint64 sessionId, uint32_t queryId, Uint64 token, MobileGLShmHandle* shm = nullptr, Uint32 outCapacity = 0) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGetNextPerfQueryIdINTEL(builder, queryId, 0);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGetNextPerfQueryIdINTEL), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm, outCapacity);
}
inline Bool SendGlGetObjectLabel(Uint64 sessionId, uint32_t identifier, uint32_t name, int32_t bufSize, const char* label, Uint64 token, MobileGLShmHandle* shm = nullptr, Uint32 outCapacity = 0) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGetObjectLabel(builder, identifier, name, bufSize, 0, builder.CreateString(label));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGetObjectLabel), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm, outCapacity);
}
inline Bool SendGlGetObjectPtrLabel(Uint64 sessionId, int32_t bufSize, const char* label, Uint64 token, MobileGLShmHandle* shm, Uint32 outCapacity = 0) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGetObjectPtrLabel(builder, MobileGL::Protocol::WireFull::CreateShmRegion(builder, 0, shm == nullptr ? 0 : shm->size), bufSize, 0, builder.CreateString(label));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGetObjectPtrLabel), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm, outCapacity);
}
inline Bool SendGlGetPathCommandsNV(Uint64 sessionId, uint32_t path, Uint64 token, MobileGLShmHandle* shm = nullptr, Uint32 outCapacity = 0) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGetPathCommandsNV(builder, path, 0);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGetPathCommandsNV), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm, outCapacity);
}
inline Bool SendGlGetPathCoordsNV(Uint64 sessionId, uint32_t path, Uint64 token, MobileGLShmHandle* shm = nullptr, Uint32 outCapacity = 0) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGetPathCoordsNV(builder, path, 0);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGetPathCoordsNV), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm, outCapacity);
}
inline Bool SendGlGetPathDashArrayNV(Uint64 sessionId, uint32_t path, Uint64 token, MobileGLShmHandle* shm = nullptr, Uint32 outCapacity = 0) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGetPathDashArrayNV(builder, path, 0);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGetPathDashArrayNV), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm, outCapacity);
}
inline Bool SendGlGetPathLengthNV(Uint64 sessionId, uint32_t path, int32_t startSegment, int32_t numSegments, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGetPathLengthNV(builder, path, startSegment, numSegments);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGetPathLengthNV), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlGetPathMetricRangeNV(Uint64 sessionId, uint32_t metricQueryMask, uint32_t firstPathName, int32_t numPaths, int32_t stride, Uint64 token, MobileGLShmHandle* shm = nullptr, Uint32 outCapacity = 0) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGetPathMetricRangeNV(builder, metricQueryMask, firstPathName, numPaths, stride, 0);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGetPathMetricRangeNV), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm, outCapacity);
}
inline Bool SendGlGetPathMetricsNV(Uint64 sessionId, uint32_t metricQueryMask, int32_t numPaths, uint32_t pathNameType, uint32_t pathBase, int32_t stride, Uint64 token, MobileGLShmHandle* shm, Uint32 outCapacity = 0) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGetPathMetricsNV(builder, metricQueryMask, numPaths, pathNameType, MobileGL::Protocol::WireFull::CreateShmRegion(builder, 0, shm == nullptr ? 0 : shm->size), pathBase, stride, 0);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGetPathMetricsNV), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm, outCapacity);
}
inline Bool SendGlGetPathParameterfvNV(Uint64 sessionId, uint32_t path, uint32_t pname, Uint64 token, MobileGLShmHandle* shm = nullptr, Uint32 outCapacity = 0) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGetPathParameterfvNV(builder, path, pname, 0);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGetPathParameterfvNV), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm, outCapacity);
}
inline Bool SendGlGetPathParameterivNV(Uint64 sessionId, uint32_t path, uint32_t pname, Uint64 token, MobileGLShmHandle* shm = nullptr, Uint32 outCapacity = 0) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGetPathParameterivNV(builder, path, pname, 0);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGetPathParameterivNV), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm, outCapacity);
}
inline Bool SendGlGetPathSpacingNV(Uint64 sessionId, uint32_t pathListMode, int32_t numPaths, uint32_t pathNameType, uint32_t pathBase, float advanceScale, float kerningScale, uint32_t transformType, Uint64 token, MobileGLShmHandle* shm, Uint32 outCapacity = 0) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGetPathSpacingNV(builder, pathListMode, numPaths, pathNameType, MobileGL::Protocol::WireFull::CreateShmRegion(builder, 0, shm == nullptr ? 0 : shm->size), pathBase, advanceScale, kerningScale, transformType, 0);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGetPathSpacingNV), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm, outCapacity);
}
inline Bool SendGlGetPerfCounterInfoINTEL(Uint64 sessionId, uint32_t queryId, uint32_t counterId, uint32_t counterNameLength, const char* counterName, uint32_t counterDescLength, const char* counterDesc, Uint64 token, MobileGLShmHandle* shm = nullptr, Uint32 outCapacity = 0) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGetPerfCounterInfoINTEL(builder, queryId, counterId, counterNameLength, builder.CreateString(counterName), counterDescLength, builder.CreateString(counterDesc), 0, 0, 0, 0, 0);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGetPerfCounterInfoINTEL), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm, outCapacity);
}
inline Bool SendGlGetPerfMonitorCounterDataAMD(Uint64 sessionId, uint32_t monitor, uint32_t pname, int32_t dataSize, Uint64 token, MobileGLShmHandle* shm = nullptr, Uint32 outCapacity = 0) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGetPerfMonitorCounterDataAMD(builder, monitor, pname, dataSize, 0, 0);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGetPerfMonitorCounterDataAMD), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm, outCapacity);
}
inline Bool SendGlGetPerfMonitorCounterInfoAMD(Uint64 sessionId, uint32_t group, uint32_t counter, uint32_t pname, Uint64 token, MobileGLShmHandle* shm) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGetPerfMonitorCounterInfoAMD(builder, group, counter, pname, MobileGL::Protocol::WireFull::CreateShmRegion(builder, 0, shm == nullptr ? 0 : shm->size));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGetPerfMonitorCounterInfoAMD), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlGetPerfMonitorCounterStringAMD(Uint64 sessionId, uint32_t group, uint32_t counter, int32_t bufSize, const char* counterString, Uint64 token, MobileGLShmHandle* shm = nullptr, Uint32 outCapacity = 0) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGetPerfMonitorCounterStringAMD(builder, group, counter, bufSize, 0, builder.CreateString(counterString));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGetPerfMonitorCounterStringAMD), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm, outCapacity);
}
inline Bool SendGlGetPerfMonitorCountersAMD(Uint64 sessionId, uint32_t group, int32_t counterSize, Uint64 token, MobileGLShmHandle* shm = nullptr, Uint32 outCapacity = 0) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGetPerfMonitorCountersAMD(builder, group, 0, 0, counterSize, 0);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGetPerfMonitorCountersAMD), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm, outCapacity);
}
inline Bool SendGlGetPerfMonitorGroupStringAMD(Uint64 sessionId, uint32_t group, int32_t bufSize, const char* groupString, Uint64 token, MobileGLShmHandle* shm = nullptr, Uint32 outCapacity = 0) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGetPerfMonitorGroupStringAMD(builder, group, bufSize, 0, builder.CreateString(groupString));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGetPerfMonitorGroupStringAMD), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm, outCapacity);
}
inline Bool SendGlGetPerfMonitorGroupsAMD(Uint64 sessionId, int32_t groupsSize, Uint64 token, MobileGLShmHandle* shm = nullptr, Uint32 outCapacity = 0) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGetPerfMonitorGroupsAMD(builder, 0, groupsSize, 0);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGetPerfMonitorGroupsAMD), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm, outCapacity);
}
inline Bool SendGlGetPerfQueryDataINTEL(Uint64 sessionId, uint32_t queryHandle, uint32_t flags, int32_t dataSize, Uint64 token, MobileGLShmHandle* shm, Uint32 outCapacity = 0) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGetPerfQueryDataINTEL(builder, queryHandle, flags, dataSize, MobileGL::Protocol::WireFull::CreateShmRegion(builder, 0, shm == nullptr ? 0 : shm->size), 0);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGetPerfQueryDataINTEL), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm, outCapacity);
}
inline Bool SendGlGetPerfQueryIdByNameINTEL(Uint64 sessionId, const char* queryName, Uint64 token, MobileGLShmHandle* shm = nullptr, Uint32 outCapacity = 0) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGetPerfQueryIdByNameINTEL(builder, builder.CreateString(queryName), 0);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGetPerfQueryIdByNameINTEL), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm, outCapacity);
}
inline Bool SendGlGetPerfQueryInfoINTEL(Uint64 sessionId, uint32_t queryId, uint32_t queryNameLength, const char* queryName, Uint64 token, MobileGLShmHandle* shm = nullptr, Uint32 outCapacity = 0) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGetPerfQueryInfoINTEL(builder, queryId, queryNameLength, builder.CreateString(queryName), 0, 0, 0, 0);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGetPerfQueryInfoINTEL), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm, outCapacity);
}
inline Bool SendGlGetProgramBinary(Uint64 sessionId, uint32_t program, int32_t bufSize, Uint64 token, MobileGLShmHandle* shm, Uint32 outCapacity = 0) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGetProgramBinary(builder, program, bufSize, 0, 0, MobileGL::Protocol::WireFull::CreateShmRegion(builder, 0, shm == nullptr ? 0 : shm->size));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGetProgramBinary), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm, outCapacity);
}
inline Bool SendGlGetProgramInfoLog(Uint64 sessionId, uint32_t program, int32_t bufSize, const char* infoLog, Uint64 token, MobileGLShmHandle* shm = nullptr, Uint32 outCapacity = 0) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGetProgramInfoLog(builder, program, bufSize, 0, builder.CreateString(infoLog));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGetProgramInfoLog), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm, outCapacity);
}
inline Bool SendGlGetProgramInterfaceiv(Uint64 sessionId, uint32_t program, uint32_t programInterface, uint32_t pname, Uint64 token, MobileGLShmHandle* shm = nullptr, Uint32 outCapacity = 0) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGetProgramInterfaceiv(builder, program, programInterface, pname, 0);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGetProgramInterfaceiv), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm, outCapacity);
}
inline Bool SendGlGetProgramPipelineInfoLog(Uint64 sessionId, uint32_t pipeline, int32_t bufSize, const char* infoLog, Uint64 token, MobileGLShmHandle* shm = nullptr, Uint32 outCapacity = 0) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGetProgramPipelineInfoLog(builder, pipeline, bufSize, 0, builder.CreateString(infoLog));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGetProgramPipelineInfoLog), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm, outCapacity);
}
inline Bool SendGlGetProgramPipelineiv(Uint64 sessionId, uint32_t pipeline, uint32_t pname, Uint64 token, MobileGLShmHandle* shm = nullptr, Uint32 outCapacity = 0) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGetProgramPipelineiv(builder, pipeline, pname, 0);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGetProgramPipelineiv), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm, outCapacity);
}
inline Bool SendGlGetProgramResourceIndex(Uint64 sessionId, uint32_t program, uint32_t programInterface, const char* name, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGetProgramResourceIndex(builder, program, programInterface, builder.CreateString(name));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGetProgramResourceIndex), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlGetProgramResourceLocation(Uint64 sessionId, uint32_t program, uint32_t programInterface, const char* name, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGetProgramResourceLocation(builder, program, programInterface, builder.CreateString(name));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGetProgramResourceLocation), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlGetProgramResourceLocationIndex(Uint64 sessionId, uint32_t program, uint32_t programInterface, const char* name, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGetProgramResourceLocationIndex(builder, program, programInterface, builder.CreateString(name));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGetProgramResourceLocationIndex), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlGetProgramResourceName(Uint64 sessionId, uint32_t program, uint32_t programInterface, uint32_t index, int32_t bufSize, const char* name, Uint64 token, MobileGLShmHandle* shm = nullptr, Uint32 outCapacity = 0) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGetProgramResourceName(builder, program, programInterface, index, bufSize, 0, builder.CreateString(name));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGetProgramResourceName), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm, outCapacity);
}
inline Bool SendGlGetProgramResourcefvNV(Uint64 sessionId, uint32_t program, uint32_t programInterface, uint32_t index, int32_t propCount, const std::vector<uint32_t>& props, int32_t count, Uint64 token, MobileGLShmHandle* shm = nullptr, Uint32 outCapacity = 0) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGetProgramResourcefvNV(builder, program, programInterface, index, propCount, builder.CreateVector(props), count, 0, 0);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGetProgramResourcefvNV), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm, outCapacity);
}
inline Bool SendGlGetProgramResourceiv(Uint64 sessionId, uint32_t program, uint32_t programInterface, uint32_t index, int32_t propCount, const std::vector<uint32_t>& props, int32_t bufSize, Uint64 token, MobileGLShmHandle* shm = nullptr, Uint32 outCapacity = 0) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGetProgramResourceiv(builder, program, programInterface, index, propCount, builder.CreateVector(props), bufSize, 0, 0);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGetProgramResourceiv), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm, outCapacity);
}
inline Bool SendGlGetProgramStageiv(Uint64 sessionId, uint32_t program, uint32_t shadertype, uint32_t pname, Uint64 token, MobileGLShmHandle* shm = nullptr, Uint32 outCapacity = 0) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGetProgramStageiv(builder, program, shadertype, pname, 0);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGetProgramStageiv), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm, outCapacity);
}
inline Bool SendGlGetProgramiv(Uint64 sessionId, uint32_t program, uint32_t pname, Uint64 token, MobileGLShmHandle* shm = nullptr, Uint32 outCapacity = 0) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGetProgramiv(builder, program, pname, 0);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGetProgramiv), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm, outCapacity);
}
inline Bool SendGlGetQueryBufferObjecti64v(Uint64 sessionId, uint32_t id, uint32_t buffer, uint32_t pname, int64_t offset, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGetQueryBufferObjecti64v(builder, id, buffer, pname, offset);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGetQueryBufferObjecti64v), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlGetQueryBufferObjectiv(Uint64 sessionId, uint32_t id, uint32_t buffer, uint32_t pname, int64_t offset, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGetQueryBufferObjectiv(builder, id, buffer, pname, offset);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGetQueryBufferObjectiv), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlGetQueryBufferObjectui64v(Uint64 sessionId, uint32_t id, uint32_t buffer, uint32_t pname, int64_t offset, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGetQueryBufferObjectui64v(builder, id, buffer, pname, offset);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGetQueryBufferObjectui64v), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlGetQueryBufferObjectuiv(Uint64 sessionId, uint32_t id, uint32_t buffer, uint32_t pname, int64_t offset, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGetQueryBufferObjectuiv(builder, id, buffer, pname, offset);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGetQueryBufferObjectuiv), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlGetQueryIndexediv(Uint64 sessionId, uint32_t target, uint32_t index, uint32_t pname, Uint64 token, MobileGLShmHandle* shm = nullptr, Uint32 outCapacity = 0) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGetQueryIndexediv(builder, target, index, pname, 0);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGetQueryIndexediv), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm, outCapacity);
}
inline Bool SendGlGetQueryObjecti64v(Uint64 sessionId, uint32_t id, uint32_t pname, Uint64 token, MobileGLShmHandle* shm = nullptr, Uint32 outCapacity = 0) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGetQueryObjecti64v(builder, id, pname, 0);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGetQueryObjecti64v), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm, outCapacity);
}
inline Bool SendGlGetQueryObjectiv(Uint64 sessionId, uint32_t id, uint32_t pname, Uint64 token, MobileGLShmHandle* shm = nullptr, Uint32 outCapacity = 0) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGetQueryObjectiv(builder, id, pname, 0);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGetQueryObjectiv), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm, outCapacity);
}
inline Bool SendGlGetQueryObjectui64v(Uint64 sessionId, uint32_t id, uint32_t pname, Uint64 token, MobileGLShmHandle* shm = nullptr, Uint32 outCapacity = 0) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGetQueryObjectui64v(builder, id, pname, 0);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGetQueryObjectui64v), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm, outCapacity);
}
inline Bool SendGlGetQueryObjectuiv(Uint64 sessionId, uint32_t id, uint32_t pname, Uint64 token, MobileGLShmHandle* shm = nullptr, Uint32 outCapacity = 0) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGetQueryObjectuiv(builder, id, pname, 0);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGetQueryObjectuiv), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm, outCapacity);
}
inline Bool SendGlGetQueryiv(Uint64 sessionId, uint32_t target, uint32_t pname, Uint64 token, MobileGLShmHandle* shm = nullptr, Uint32 outCapacity = 0) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGetQueryiv(builder, target, pname, 0);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGetQueryiv), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm, outCapacity);
}
inline Bool SendGlGetRenderbufferParameteriv(Uint64 sessionId, uint32_t target, uint32_t pname, Uint64 token, MobileGLShmHandle* shm = nullptr, Uint32 outCapacity = 0) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGetRenderbufferParameteriv(builder, target, pname, 0);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGetRenderbufferParameteriv), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm, outCapacity);
}
inline Bool SendGlGetSamplerParameterIiv(Uint64 sessionId, uint32_t sampler, uint32_t pname, Uint64 token, MobileGLShmHandle* shm = nullptr, Uint32 outCapacity = 0) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGetSamplerParameterIiv(builder, sampler, pname, 0);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGetSamplerParameterIiv), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm, outCapacity);
}
inline Bool SendGlGetSamplerParameterIuiv(Uint64 sessionId, uint32_t sampler, uint32_t pname, Uint64 token, MobileGLShmHandle* shm = nullptr, Uint32 outCapacity = 0) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGetSamplerParameterIuiv(builder, sampler, pname, 0);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGetSamplerParameterIuiv), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm, outCapacity);
}
inline Bool SendGlGetSamplerParameterfv(Uint64 sessionId, uint32_t sampler, uint32_t pname, Uint64 token, MobileGLShmHandle* shm = nullptr, Uint32 outCapacity = 0) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGetSamplerParameterfv(builder, sampler, pname, 0);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGetSamplerParameterfv), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm, outCapacity);
}
inline Bool SendGlGetSamplerParameteriv(Uint64 sessionId, uint32_t sampler, uint32_t pname, Uint64 token, MobileGLShmHandle* shm = nullptr, Uint32 outCapacity = 0) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGetSamplerParameteriv(builder, sampler, pname, 0);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGetSamplerParameteriv), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm, outCapacity);
}
inline Bool SendGlGetShaderInfoLog(Uint64 sessionId, uint32_t shader, int32_t bufSize, const char* infoLog, Uint64 token, MobileGLShmHandle* shm = nullptr, Uint32 outCapacity = 0) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGetShaderInfoLog(builder, shader, bufSize, 0, builder.CreateString(infoLog));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGetShaderInfoLog), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm, outCapacity);
}
inline Bool SendGlGetShaderPrecisionFormat(Uint64 sessionId, uint32_t shadertype, uint32_t precisiontype, Uint64 token, MobileGLShmHandle* shm = nullptr, Uint32 outCapacity = 0) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGetShaderPrecisionFormat(builder, shadertype, precisiontype, 0, 0);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGetShaderPrecisionFormat), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm, outCapacity);
}
inline Bool SendGlGetShaderSource(Uint64 sessionId, uint32_t shader, int32_t bufSize, const char* source, Uint64 token, MobileGLShmHandle* shm = nullptr, Uint32 outCapacity = 0) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGetShaderSource(builder, shader, bufSize, 0, builder.CreateString(source));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGetShaderSource), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm, outCapacity);
}
inline Bool SendGlGetShaderiv(Uint64 sessionId, uint32_t shader, uint32_t pname, Uint64 token, MobileGLShmHandle* shm = nullptr, Uint32 outCapacity = 0) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGetShaderiv(builder, shader, pname, 0);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGetShaderiv), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm, outCapacity);
}
inline Bool SendGlGetShadingRateImagePaletteNV(Uint64 sessionId, uint32_t viewport, uint32_t entry, Uint64 token, MobileGLShmHandle* shm = nullptr, Uint32 outCapacity = 0) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGetShadingRateImagePaletteNV(builder, viewport, entry, 0);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGetShadingRateImagePaletteNV), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm, outCapacity);
}
inline Bool SendGlGetShadingRateSampleLocationivNV(Uint64 sessionId, uint32_t rate, uint32_t samples, uint32_t index, Uint64 token, MobileGLShmHandle* shm = nullptr, Uint32 outCapacity = 0) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGetShadingRateSampleLocationivNV(builder, rate, samples, index, 0);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGetShadingRateSampleLocationivNV), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm, outCapacity);
}
inline Bool SendGlGetStageIndexNV(Uint64 sessionId, uint32_t shadertype, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGetStageIndexNV(builder, shadertype);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGetStageIndexNV), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlGetString(Uint64 sessionId, uint32_t name, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGetString(builder, name);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGetString), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlGetStringi(Uint64 sessionId, uint32_t name, uint32_t index, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGetStringi(builder, name, index);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGetStringi), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlGetSubroutineIndex(Uint64 sessionId, uint32_t program, uint32_t shadertype, const char* name, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGetSubroutineIndex(builder, program, shadertype, builder.CreateString(name));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGetSubroutineIndex), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlGetSubroutineUniformLocation(Uint64 sessionId, uint32_t program, uint32_t shadertype, const char* name, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGetSubroutineUniformLocation(builder, program, shadertype, builder.CreateString(name));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGetSubroutineUniformLocation), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlGetSynciv(Uint64 sessionId, uint64_t sync, uint32_t pname, int32_t bufSize, Uint64 token, MobileGLShmHandle* shm = nullptr, Uint32 outCapacity = 0) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGetSynciv(builder, sync, pname, bufSize, 0, 0);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGetSynciv), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm, outCapacity);
}
inline Bool SendGlGetTexImage(Uint64 sessionId, uint32_t target, int32_t level, uint32_t format, uint32_t type, Uint64 token, MobileGLShmHandle* shm) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGetTexImage(builder, target, level, format, type, MobileGL::Protocol::WireFull::CreateShmRegion(builder, 0, shm == nullptr ? 0 : shm->size));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGetTexImage), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlGetTexLevelParameterfv(Uint64 sessionId, uint32_t target, int32_t level, uint32_t pname, Uint64 token, MobileGLShmHandle* shm = nullptr, Uint32 outCapacity = 0) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGetTexLevelParameterfv(builder, target, level, pname, 0);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGetTexLevelParameterfv), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm, outCapacity);
}
inline Bool SendGlGetTexLevelParameteriv(Uint64 sessionId, uint32_t target, int32_t level, uint32_t pname, Uint64 token, MobileGLShmHandle* shm = nullptr, Uint32 outCapacity = 0) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGetTexLevelParameteriv(builder, target, level, pname, 0);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGetTexLevelParameteriv), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm, outCapacity);
}
inline Bool SendGlGetTexParameterIiv(Uint64 sessionId, uint32_t target, uint32_t pname, Uint64 token, MobileGLShmHandle* shm = nullptr, Uint32 outCapacity = 0) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGetTexParameterIiv(builder, target, pname, 0);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGetTexParameterIiv), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm, outCapacity);
}
inline Bool SendGlGetTexParameterIuiv(Uint64 sessionId, uint32_t target, uint32_t pname, Uint64 token, MobileGLShmHandle* shm = nullptr, Uint32 outCapacity = 0) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGetTexParameterIuiv(builder, target, pname, 0);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGetTexParameterIuiv), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm, outCapacity);
}
inline Bool SendGlGetTexParameterfv(Uint64 sessionId, uint32_t target, uint32_t pname, Uint64 token, MobileGLShmHandle* shm = nullptr, Uint32 outCapacity = 0) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGetTexParameterfv(builder, target, pname, 0);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGetTexParameterfv), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm, outCapacity);
}
inline Bool SendGlGetTexParameteriv(Uint64 sessionId, uint32_t target, uint32_t pname, Uint64 token, MobileGLShmHandle* shm = nullptr, Uint32 outCapacity = 0) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGetTexParameteriv(builder, target, pname, 0);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGetTexParameteriv), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm, outCapacity);
}
inline Bool SendGlGetTextureHandleARB(Uint64 sessionId, uint32_t texture, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGetTextureHandleARB(builder, texture);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGetTextureHandleARB), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlGetTextureHandleNV(Uint64 sessionId, uint32_t texture, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGetTextureHandleNV(builder, texture);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGetTextureHandleNV), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlGetTextureImage(Uint64 sessionId, uint32_t texture, int32_t level, uint32_t format, uint32_t type, int32_t bufSize, Uint64 token, MobileGLShmHandle* shm) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGetTextureImage(builder, texture, level, format, type, bufSize, MobileGL::Protocol::WireFull::CreateShmRegion(builder, 0, shm == nullptr ? 0 : shm->size));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGetTextureImage), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlGetTextureImageEXT(Uint64 sessionId, uint32_t texture, uint32_t target, int32_t level, uint32_t format, uint32_t type, Uint64 token, MobileGLShmHandle* shm) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGetTextureImageEXT(builder, texture, target, level, format, type, MobileGL::Protocol::WireFull::CreateShmRegion(builder, 0, shm == nullptr ? 0 : shm->size));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGetTextureImageEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlGetTextureLevelParameterfv(Uint64 sessionId, uint32_t texture, int32_t level, uint32_t pname, Uint64 token, MobileGLShmHandle* shm = nullptr, Uint32 outCapacity = 0) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGetTextureLevelParameterfv(builder, texture, level, pname, 0);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGetTextureLevelParameterfv), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm, outCapacity);
}
inline Bool SendGlGetTextureLevelParameterfvEXT(Uint64 sessionId, uint32_t texture, uint32_t target, int32_t level, uint32_t pname, Uint64 token, MobileGLShmHandle* shm = nullptr, Uint32 outCapacity = 0) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGetTextureLevelParameterfvEXT(builder, texture, target, level, pname, 0);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGetTextureLevelParameterfvEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm, outCapacity);
}
inline Bool SendGlGetTextureLevelParameteriv(Uint64 sessionId, uint32_t texture, int32_t level, uint32_t pname, Uint64 token, MobileGLShmHandle* shm = nullptr, Uint32 outCapacity = 0) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGetTextureLevelParameteriv(builder, texture, level, pname, 0);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGetTextureLevelParameteriv), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm, outCapacity);
}
inline Bool SendGlGetTextureLevelParameterivEXT(Uint64 sessionId, uint32_t texture, uint32_t target, int32_t level, uint32_t pname, Uint64 token, MobileGLShmHandle* shm = nullptr, Uint32 outCapacity = 0) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGetTextureLevelParameterivEXT(builder, texture, target, level, pname, 0);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGetTextureLevelParameterivEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm, outCapacity);
}
inline Bool SendGlGetTextureParameterIiv(Uint64 sessionId, uint32_t texture, uint32_t pname, Uint64 token, MobileGLShmHandle* shm = nullptr, Uint32 outCapacity = 0) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGetTextureParameterIiv(builder, texture, pname, 0);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGetTextureParameterIiv), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm, outCapacity);
}
inline Bool SendGlGetTextureParameterIivEXT(Uint64 sessionId, uint32_t texture, uint32_t target, uint32_t pname, Uint64 token, MobileGLShmHandle* shm = nullptr, Uint32 outCapacity = 0) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGetTextureParameterIivEXT(builder, texture, target, pname, 0);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGetTextureParameterIivEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm, outCapacity);
}
inline Bool SendGlGetTextureParameterIuiv(Uint64 sessionId, uint32_t texture, uint32_t pname, Uint64 token, MobileGLShmHandle* shm = nullptr, Uint32 outCapacity = 0) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGetTextureParameterIuiv(builder, texture, pname, 0);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGetTextureParameterIuiv), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm, outCapacity);
}
inline Bool SendGlGetTextureParameterIuivEXT(Uint64 sessionId, uint32_t texture, uint32_t target, uint32_t pname, Uint64 token, MobileGLShmHandle* shm = nullptr, Uint32 outCapacity = 0) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGetTextureParameterIuivEXT(builder, texture, target, pname, 0);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGetTextureParameterIuivEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm, outCapacity);
}
inline Bool SendGlGetTextureParameterfv(Uint64 sessionId, uint32_t texture, uint32_t pname, Uint64 token, MobileGLShmHandle* shm = nullptr, Uint32 outCapacity = 0) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGetTextureParameterfv(builder, texture, pname, 0);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGetTextureParameterfv), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm, outCapacity);
}
inline Bool SendGlGetTextureParameterfvEXT(Uint64 sessionId, uint32_t texture, uint32_t target, uint32_t pname, Uint64 token, MobileGLShmHandle* shm = nullptr, Uint32 outCapacity = 0) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGetTextureParameterfvEXT(builder, texture, target, pname, 0);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGetTextureParameterfvEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm, outCapacity);
}
inline Bool SendGlGetTextureParameteriv(Uint64 sessionId, uint32_t texture, uint32_t pname, Uint64 token, MobileGLShmHandle* shm = nullptr, Uint32 outCapacity = 0) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGetTextureParameteriv(builder, texture, pname, 0);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGetTextureParameteriv), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm, outCapacity);
}
inline Bool SendGlGetTextureParameterivEXT(Uint64 sessionId, uint32_t texture, uint32_t target, uint32_t pname, Uint64 token, MobileGLShmHandle* shm = nullptr, Uint32 outCapacity = 0) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGetTextureParameterivEXT(builder, texture, target, pname, 0);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGetTextureParameterivEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm, outCapacity);
}
inline Bool SendGlGetTextureSamplerHandleARB(Uint64 sessionId, uint32_t texture, uint32_t sampler, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGetTextureSamplerHandleARB(builder, texture, sampler);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGetTextureSamplerHandleARB), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlGetTextureSamplerHandleNV(Uint64 sessionId, uint32_t texture, uint32_t sampler, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGetTextureSamplerHandleNV(builder, texture, sampler);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGetTextureSamplerHandleNV), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlGetTextureSubImage(Uint64 sessionId, uint32_t texture, int32_t level, int32_t xoffset, int32_t yoffset, int32_t zoffset, int32_t width, int32_t height, int32_t depth, uint32_t format, uint32_t type, int32_t bufSize, Uint64 token, MobileGLShmHandle* shm) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGetTextureSubImage(builder, texture, level, xoffset, yoffset, zoffset, width, height, depth, format, type, bufSize, MobileGL::Protocol::WireFull::CreateShmRegion(builder, 0, shm == nullptr ? 0 : shm->size));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGetTextureSubImage), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlGetTransformFeedbackVarying(Uint64 sessionId, uint32_t program, uint32_t index, int32_t bufSize, const char* name, Uint64 token, MobileGLShmHandle* shm = nullptr, Uint32 outCapacity = 0) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGetTransformFeedbackVarying(builder, program, index, bufSize, 0, 0, 0, builder.CreateString(name));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGetTransformFeedbackVarying), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm, outCapacity);
}
inline Bool SendGlGetTransformFeedbacki64_v(Uint64 sessionId, uint32_t xfb, uint32_t pname, uint32_t index, Uint64 token, MobileGLShmHandle* shm = nullptr, Uint32 outCapacity = 0) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGetTransformFeedbacki64_v(builder, xfb, pname, index, 0);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGetTransformFeedbacki64_v), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm, outCapacity);
}
inline Bool SendGlGetTransformFeedbacki_v(Uint64 sessionId, uint32_t xfb, uint32_t pname, uint32_t index, Uint64 token, MobileGLShmHandle* shm = nullptr, Uint32 outCapacity = 0) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGetTransformFeedbacki_v(builder, xfb, pname, index, 0);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGetTransformFeedbacki_v), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm, outCapacity);
}
inline Bool SendGlGetTransformFeedbackiv(Uint64 sessionId, uint32_t xfb, uint32_t pname, Uint64 token, MobileGLShmHandle* shm = nullptr, Uint32 outCapacity = 0) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGetTransformFeedbackiv(builder, xfb, pname, 0);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGetTransformFeedbackiv), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm, outCapacity);
}
inline Bool SendGlGetUniformBlockIndex(Uint64 sessionId, uint32_t program, const char* uniformBlockName, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGetUniformBlockIndex(builder, program, builder.CreateString(uniformBlockName));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGetUniformBlockIndex), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlGetUniformLocation(Uint64 sessionId, uint32_t program, const char* name, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGetUniformLocation(builder, program, builder.CreateString(name));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGetUniformLocation), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlGetUniformSubroutineuiv(Uint64 sessionId, uint32_t shadertype, int32_t location, Uint64 token, MobileGLShmHandle* shm = nullptr, Uint32 outCapacity = 0) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGetUniformSubroutineuiv(builder, shadertype, location, 0);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGetUniformSubroutineuiv), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm, outCapacity);
}
inline Bool SendGlGetUniformdv(Uint64 sessionId, uint32_t program, int32_t location, Uint64 token, MobileGLShmHandle* shm = nullptr, Uint32 outCapacity = 0) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGetUniformdv(builder, program, location, 0);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGetUniformdv), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm, outCapacity);
}
inline Bool SendGlGetUniformfv(Uint64 sessionId, uint32_t program, int32_t location, Uint64 token, MobileGLShmHandle* shm = nullptr, Uint32 outCapacity = 0) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGetUniformfv(builder, program, location, 0);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGetUniformfv), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm, outCapacity);
}
inline Bool SendGlGetUniformi64vARB(Uint64 sessionId, uint32_t program, int32_t location, Uint64 token, MobileGLShmHandle* shm = nullptr, Uint32 outCapacity = 0) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGetUniformi64vARB(builder, program, location, 0);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGetUniformi64vARB), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm, outCapacity);
}
inline Bool SendGlGetUniformi64vNV(Uint64 sessionId, uint32_t program, int32_t location, Uint64 token, MobileGLShmHandle* shm = nullptr, Uint32 outCapacity = 0) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGetUniformi64vNV(builder, program, location, 0);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGetUniformi64vNV), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm, outCapacity);
}
inline Bool SendGlGetUniformiv(Uint64 sessionId, uint32_t program, int32_t location, Uint64 token, MobileGLShmHandle* shm = nullptr, Uint32 outCapacity = 0) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGetUniformiv(builder, program, location, 0);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGetUniformiv), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm, outCapacity);
}
inline Bool SendGlGetUniformui64vARB(Uint64 sessionId, uint32_t program, int32_t location, Uint64 token, MobileGLShmHandle* shm = nullptr, Uint32 outCapacity = 0) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGetUniformui64vARB(builder, program, location, 0);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGetUniformui64vARB), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm, outCapacity);
}
inline Bool SendGlGetUniformui64vNV(Uint64 sessionId, uint32_t program, int32_t location, Uint64 token, MobileGLShmHandle* shm = nullptr, Uint32 outCapacity = 0) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGetUniformui64vNV(builder, program, location, 0);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGetUniformui64vNV), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm, outCapacity);
}
inline Bool SendGlGetUniformuiv(Uint64 sessionId, uint32_t program, int32_t location, Uint64 token, MobileGLShmHandle* shm = nullptr, Uint32 outCapacity = 0) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGetUniformuiv(builder, program, location, 0);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGetUniformuiv), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm, outCapacity);
}
inline Bool SendGlGetVertexArrayIndexed64iv(Uint64 sessionId, uint32_t vaobj, uint32_t index, uint32_t pname, Uint64 token, MobileGLShmHandle* shm = nullptr, Uint32 outCapacity = 0) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGetVertexArrayIndexed64iv(builder, vaobj, index, pname, 0);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGetVertexArrayIndexed64iv), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm, outCapacity);
}
inline Bool SendGlGetVertexArrayIndexediv(Uint64 sessionId, uint32_t vaobj, uint32_t index, uint32_t pname, Uint64 token, MobileGLShmHandle* shm = nullptr, Uint32 outCapacity = 0) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGetVertexArrayIndexediv(builder, vaobj, index, pname, 0);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGetVertexArrayIndexediv), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm, outCapacity);
}
inline Bool SendGlGetVertexArrayIntegeri_vEXT(Uint64 sessionId, uint32_t vaobj, uint32_t index, uint32_t pname, Uint64 token, MobileGLShmHandle* shm = nullptr, Uint32 outCapacity = 0) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGetVertexArrayIntegeri_vEXT(builder, vaobj, index, pname, 0);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGetVertexArrayIntegeri_vEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm, outCapacity);
}
inline Bool SendGlGetVertexArrayIntegervEXT(Uint64 sessionId, uint32_t vaobj, uint32_t pname, Uint64 token, MobileGLShmHandle* shm = nullptr, Uint32 outCapacity = 0) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGetVertexArrayIntegervEXT(builder, vaobj, pname, 0);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGetVertexArrayIntegervEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm, outCapacity);
}
inline Bool SendGlGetVertexArrayiv(Uint64 sessionId, uint32_t vaobj, uint32_t pname, Uint64 token, MobileGLShmHandle* shm = nullptr, Uint32 outCapacity = 0) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGetVertexArrayiv(builder, vaobj, pname, 0);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGetVertexArrayiv), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm, outCapacity);
}
inline Bool SendGlGetVertexAttribIiv(Uint64 sessionId, uint32_t index, uint32_t pname, Uint64 token, MobileGLShmHandle* shm = nullptr, Uint32 outCapacity = 0) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGetVertexAttribIiv(builder, index, pname, 0);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGetVertexAttribIiv), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm, outCapacity);
}
inline Bool SendGlGetVertexAttribIuiv(Uint64 sessionId, uint32_t index, uint32_t pname, Uint64 token, MobileGLShmHandle* shm = nullptr, Uint32 outCapacity = 0) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGetVertexAttribIuiv(builder, index, pname, 0);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGetVertexAttribIuiv), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm, outCapacity);
}
inline Bool SendGlGetVertexAttribLdv(Uint64 sessionId, uint32_t index, uint32_t pname, Uint64 token, MobileGLShmHandle* shm = nullptr, Uint32 outCapacity = 0) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGetVertexAttribLdv(builder, index, pname, 0);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGetVertexAttribLdv), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm, outCapacity);
}
inline Bool SendGlGetVertexAttribLi64vNV(Uint64 sessionId, uint32_t index, uint32_t pname, Uint64 token, MobileGLShmHandle* shm = nullptr, Uint32 outCapacity = 0) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGetVertexAttribLi64vNV(builder, index, pname, 0);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGetVertexAttribLi64vNV), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm, outCapacity);
}
inline Bool SendGlGetVertexAttribLui64vARB(Uint64 sessionId, uint32_t index, uint32_t pname, Uint64 token, MobileGLShmHandle* shm = nullptr, Uint32 outCapacity = 0) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGetVertexAttribLui64vARB(builder, index, pname, 0);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGetVertexAttribLui64vARB), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm, outCapacity);
}
inline Bool SendGlGetVertexAttribLui64vNV(Uint64 sessionId, uint32_t index, uint32_t pname, Uint64 token, MobileGLShmHandle* shm = nullptr, Uint32 outCapacity = 0) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGetVertexAttribLui64vNV(builder, index, pname, 0);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGetVertexAttribLui64vNV), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm, outCapacity);
}
inline Bool SendGlGetVertexAttribdv(Uint64 sessionId, uint32_t index, uint32_t pname, Uint64 token, MobileGLShmHandle* shm = nullptr, Uint32 outCapacity = 0) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGetVertexAttribdv(builder, index, pname, 0);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGetVertexAttribdv), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm, outCapacity);
}
inline Bool SendGlGetVertexAttribfv(Uint64 sessionId, uint32_t index, uint32_t pname, Uint64 token, MobileGLShmHandle* shm = nullptr, Uint32 outCapacity = 0) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGetVertexAttribfv(builder, index, pname, 0);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGetVertexAttribfv), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm, outCapacity);
}
inline Bool SendGlGetVertexAttribiv(Uint64 sessionId, uint32_t index, uint32_t pname, Uint64 token, MobileGLShmHandle* shm = nullptr, Uint32 outCapacity = 0) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGetVertexAttribiv(builder, index, pname, 0);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGetVertexAttribiv), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm, outCapacity);
}
inline Bool SendGlGetVkProcAddrNV(Uint64 sessionId, const char* name, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGetVkProcAddrNV(builder, builder.CreateString(name));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGetVkProcAddrNV), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlGetnCompressedTexImage(Uint64 sessionId, uint32_t target, int32_t lod, int32_t bufSize, Uint64 token, MobileGLShmHandle* shm) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGetnCompressedTexImage(builder, target, lod, bufSize, MobileGL::Protocol::WireFull::CreateShmRegion(builder, 0, shm == nullptr ? 0 : shm->size));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGetnCompressedTexImage), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlGetnCompressedTexImageARB(Uint64 sessionId, uint32_t target, int32_t lod, int32_t bufSize, Uint64 token, MobileGLShmHandle* shm) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGetnCompressedTexImageARB(builder, target, lod, bufSize, MobileGL::Protocol::WireFull::CreateShmRegion(builder, 0, shm == nullptr ? 0 : shm->size));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGetnCompressedTexImageARB), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlGetnTexImage(Uint64 sessionId, uint32_t target, int32_t level, uint32_t format, uint32_t type, int32_t bufSize, Uint64 token, MobileGLShmHandle* shm) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGetnTexImage(builder, target, level, format, type, bufSize, MobileGL::Protocol::WireFull::CreateShmRegion(builder, 0, shm == nullptr ? 0 : shm->size));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGetnTexImage), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlGetnTexImageARB(Uint64 sessionId, uint32_t target, int32_t level, uint32_t format, uint32_t type, int32_t bufSize, Uint64 token, MobileGLShmHandle* shm) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGetnTexImageARB(builder, target, level, format, type, bufSize, MobileGL::Protocol::WireFull::CreateShmRegion(builder, 0, shm == nullptr ? 0 : shm->size));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGetnTexImageARB), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlGetnUniformdv(Uint64 sessionId, uint32_t program, int32_t location, int32_t bufSize, Uint64 token, MobileGLShmHandle* shm = nullptr, Uint32 outCapacity = 0) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGetnUniformdv(builder, program, location, bufSize, 0);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGetnUniformdv), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm, outCapacity);
}
inline Bool SendGlGetnUniformdvARB(Uint64 sessionId, uint32_t program, int32_t location, int32_t bufSize, Uint64 token, MobileGLShmHandle* shm = nullptr, Uint32 outCapacity = 0) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGetnUniformdvARB(builder, program, location, bufSize, 0);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGetnUniformdvARB), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm, outCapacity);
}
inline Bool SendGlGetnUniformfv(Uint64 sessionId, uint32_t program, int32_t location, int32_t bufSize, Uint64 token, MobileGLShmHandle* shm = nullptr, Uint32 outCapacity = 0) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGetnUniformfv(builder, program, location, bufSize, 0);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGetnUniformfv), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm, outCapacity);
}
inline Bool SendGlGetnUniformi64vARB(Uint64 sessionId, uint32_t program, int32_t location, int32_t bufSize, Uint64 token, MobileGLShmHandle* shm = nullptr, Uint32 outCapacity = 0) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGetnUniformi64vARB(builder, program, location, bufSize, 0);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGetnUniformi64vARB), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm, outCapacity);
}
inline Bool SendGlGetnUniformiv(Uint64 sessionId, uint32_t program, int32_t location, int32_t bufSize, Uint64 token, MobileGLShmHandle* shm = nullptr, Uint32 outCapacity = 0) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGetnUniformiv(builder, program, location, bufSize, 0);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGetnUniformiv), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm, outCapacity);
}
inline Bool SendGlGetnUniformui64vARB(Uint64 sessionId, uint32_t program, int32_t location, int32_t bufSize, Uint64 token, MobileGLShmHandle* shm = nullptr, Uint32 outCapacity = 0) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGetnUniformui64vARB(builder, program, location, bufSize, 0);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGetnUniformui64vARB), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm, outCapacity);
}
inline Bool SendGlGetnUniformuiv(Uint64 sessionId, uint32_t program, int32_t location, int32_t bufSize, Uint64 token, MobileGLShmHandle* shm = nullptr, Uint32 outCapacity = 0) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenGetnUniformuiv(builder, program, location, bufSize, 0);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glGetnUniformuiv), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm, outCapacity);
}
inline Bool SendGlHint(Uint64 sessionId, uint32_t target, uint32_t mode, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenHint(builder, target, mode);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glHint), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlIndexFormatNV(Uint64 sessionId, uint32_t type, int32_t stride, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenIndexFormatNV(builder, type, stride);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glIndexFormatNV), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlInsertEventMarkerEXT(Uint64 sessionId, int32_t length, const char* marker, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenInsertEventMarkerEXT(builder, length, builder.CreateString(marker));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glInsertEventMarkerEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlInterpolatePathsNV(Uint64 sessionId, uint32_t resultPath, uint32_t pathA, uint32_t pathB, float weight, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenInterpolatePathsNV(builder, resultPath, pathA, pathB, weight);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glInterpolatePathsNV), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlInvalidateBufferData(Uint64 sessionId, uint32_t buffer, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenInvalidateBufferData(builder, buffer);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glInvalidateBufferData), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlInvalidateBufferSubData(Uint64 sessionId, uint32_t buffer, int64_t offset, uint64_t length, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenInvalidateBufferSubData(builder, buffer, offset, length);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glInvalidateBufferSubData), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlInvalidateFramebuffer(Uint64 sessionId, uint32_t target, int32_t numAttachments, const std::vector<uint32_t>& attachments, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenInvalidateFramebuffer(builder, target, numAttachments, builder.CreateVector(attachments));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glInvalidateFramebuffer), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlInvalidateNamedFramebufferData(Uint64 sessionId, uint32_t framebuffer, int32_t numAttachments, const std::vector<uint32_t>& attachments, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenInvalidateNamedFramebufferData(builder, framebuffer, numAttachments, builder.CreateVector(attachments));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glInvalidateNamedFramebufferData), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlInvalidateNamedFramebufferSubData(Uint64 sessionId, uint32_t framebuffer, int32_t numAttachments, const std::vector<uint32_t>& attachments, int32_t x, int32_t y, int32_t width, int32_t height, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenInvalidateNamedFramebufferSubData(builder, framebuffer, numAttachments, builder.CreateVector(attachments), x, y, width, height);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glInvalidateNamedFramebufferSubData), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlInvalidateSubFramebuffer(Uint64 sessionId, uint32_t target, int32_t numAttachments, const std::vector<uint32_t>& attachments, int32_t x, int32_t y, int32_t width, int32_t height, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenInvalidateSubFramebuffer(builder, target, numAttachments, builder.CreateVector(attachments), x, y, width, height);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glInvalidateSubFramebuffer), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlInvalidateTexImage(Uint64 sessionId, uint32_t texture, int32_t level, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenInvalidateTexImage(builder, texture, level);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glInvalidateTexImage), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlInvalidateTexSubImage(Uint64 sessionId, uint32_t texture, int32_t level, int32_t xoffset, int32_t yoffset, int32_t zoffset, int32_t width, int32_t height, int32_t depth, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenInvalidateTexSubImage(builder, texture, level, xoffset, yoffset, zoffset, width, height, depth);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glInvalidateTexSubImage), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlIsBuffer(Uint64 sessionId, uint32_t buffer, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenIsBuffer(builder, buffer);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glIsBuffer), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlIsBufferResidentNV(Uint64 sessionId, uint32_t target, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenIsBufferResidentNV(builder, target);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glIsBufferResidentNV), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlIsCommandListNV(Uint64 sessionId, uint32_t list, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenIsCommandListNV(builder, list);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glIsCommandListNV), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlIsEnabled(Uint64 sessionId, uint32_t cap, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenIsEnabled(builder, cap);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glIsEnabled), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlIsEnabledIndexedEXT(Uint64 sessionId, uint32_t target, uint32_t index, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenIsEnabledIndexedEXT(builder, target, index);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glIsEnabledIndexedEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlIsEnabledi(Uint64 sessionId, uint32_t target, uint32_t index, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenIsEnabledi(builder, target, index);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glIsEnabledi), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlIsFramebuffer(Uint64 sessionId, uint32_t framebuffer, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenIsFramebuffer(builder, framebuffer);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glIsFramebuffer), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlIsImageHandleResidentARB(Uint64 sessionId, uint64_t handle, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenIsImageHandleResidentARB(builder, handle);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glIsImageHandleResidentARB), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlIsImageHandleResidentNV(Uint64 sessionId, uint64_t handle, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenIsImageHandleResidentNV(builder, handle);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glIsImageHandleResidentNV), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlIsNamedBufferResidentNV(Uint64 sessionId, uint32_t buffer, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenIsNamedBufferResidentNV(builder, buffer);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glIsNamedBufferResidentNV), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlIsNamedStringARB(Uint64 sessionId, int32_t namelen, const char* name, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenIsNamedStringARB(builder, namelen, builder.CreateString(name));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glIsNamedStringARB), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlIsPathNV(Uint64 sessionId, uint32_t path, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenIsPathNV(builder, path);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glIsPathNV), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlIsPointInFillPathNV(Uint64 sessionId, uint32_t path, uint32_t mask, float x, float y, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenIsPointInFillPathNV(builder, path, mask, x, y);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glIsPointInFillPathNV), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlIsPointInStrokePathNV(Uint64 sessionId, uint32_t path, float x, float y, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenIsPointInStrokePathNV(builder, path, x, y);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glIsPointInStrokePathNV), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlIsProgram(Uint64 sessionId, uint32_t program, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenIsProgram(builder, program);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glIsProgram), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlIsProgramPipeline(Uint64 sessionId, uint32_t pipeline, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenIsProgramPipeline(builder, pipeline);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glIsProgramPipeline), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlIsQuery(Uint64 sessionId, uint32_t id, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenIsQuery(builder, id);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glIsQuery), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlIsRenderbuffer(Uint64 sessionId, uint32_t renderbuffer, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenIsRenderbuffer(builder, renderbuffer);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glIsRenderbuffer), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlIsSampler(Uint64 sessionId, uint32_t sampler, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenIsSampler(builder, sampler);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glIsSampler), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlIsShader(Uint64 sessionId, uint32_t shader, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenIsShader(builder, shader);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glIsShader), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlIsStateNV(Uint64 sessionId, uint32_t state, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenIsStateNV(builder, state);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glIsStateNV), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlIsSync(Uint64 sessionId, uint64_t sync, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenIsSync(builder, sync);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glIsSync), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlIsTexture(Uint64 sessionId, uint32_t texture, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenIsTexture(builder, texture);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glIsTexture), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlIsTextureHandleResidentARB(Uint64 sessionId, uint64_t handle, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenIsTextureHandleResidentARB(builder, handle);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glIsTextureHandleResidentARB), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlIsTextureHandleResidentNV(Uint64 sessionId, uint64_t handle, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenIsTextureHandleResidentNV(builder, handle);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glIsTextureHandleResidentNV), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlIsTransformFeedback(Uint64 sessionId, uint32_t id, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenIsTransformFeedback(builder, id);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glIsTransformFeedback), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlIsVertexArray(Uint64 sessionId, uint32_t array, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenIsVertexArray(builder, array);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glIsVertexArray), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlLabelObjectEXT(Uint64 sessionId, uint32_t type, uint32_t object, int32_t length, const char* label, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenLabelObjectEXT(builder, type, object, length, builder.CreateString(label));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glLabelObjectEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlLineWidth(Uint64 sessionId, float width, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenLineWidth(builder, width);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glLineWidth), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlLinkProgram(Uint64 sessionId, uint32_t program, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenLinkProgram(builder, program);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glLinkProgram), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlLogicOp(Uint64 sessionId, uint32_t opcode, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenLogicOp(builder, opcode);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glLogicOp), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlMakeBufferNonResidentNV(Uint64 sessionId, uint32_t target, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenMakeBufferNonResidentNV(builder, target);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glMakeBufferNonResidentNV), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlMakeBufferResidentNV(Uint64 sessionId, uint32_t target, uint32_t access, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenMakeBufferResidentNV(builder, target, access);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glMakeBufferResidentNV), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlMakeImageHandleNonResidentARB(Uint64 sessionId, uint64_t handle, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenMakeImageHandleNonResidentARB(builder, handle);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glMakeImageHandleNonResidentARB), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlMakeImageHandleNonResidentNV(Uint64 sessionId, uint64_t handle, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenMakeImageHandleNonResidentNV(builder, handle);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glMakeImageHandleNonResidentNV), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlMakeImageHandleResidentARB(Uint64 sessionId, uint64_t handle, uint32_t access, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenMakeImageHandleResidentARB(builder, handle, access);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glMakeImageHandleResidentARB), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlMakeImageHandleResidentNV(Uint64 sessionId, uint64_t handle, uint32_t access, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenMakeImageHandleResidentNV(builder, handle, access);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glMakeImageHandleResidentNV), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlMakeNamedBufferNonResidentNV(Uint64 sessionId, uint32_t buffer, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenMakeNamedBufferNonResidentNV(builder, buffer);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glMakeNamedBufferNonResidentNV), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlMakeNamedBufferResidentNV(Uint64 sessionId, uint32_t buffer, uint32_t access, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenMakeNamedBufferResidentNV(builder, buffer, access);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glMakeNamedBufferResidentNV), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlMakeTextureHandleNonResidentARB(Uint64 sessionId, uint64_t handle, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenMakeTextureHandleNonResidentARB(builder, handle);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glMakeTextureHandleNonResidentARB), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlMakeTextureHandleNonResidentNV(Uint64 sessionId, uint64_t handle, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenMakeTextureHandleNonResidentNV(builder, handle);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glMakeTextureHandleNonResidentNV), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlMakeTextureHandleResidentARB(Uint64 sessionId, uint64_t handle, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenMakeTextureHandleResidentARB(builder, handle);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glMakeTextureHandleResidentARB), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlMakeTextureHandleResidentNV(Uint64 sessionId, uint64_t handle, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenMakeTextureHandleResidentNV(builder, handle);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glMakeTextureHandleResidentNV), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlMapBuffer(Uint64 sessionId, uint32_t target, uint32_t access, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenMapBuffer(builder, target, access);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glMapBuffer), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlMapBufferRange(Uint64 sessionId, uint32_t target, int64_t offset, uint64_t length, uint32_t access, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenMapBufferRange(builder, target, offset, length, access);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glMapBufferRange), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlMatrixFrustumEXT(Uint64 sessionId, uint32_t mode, double left, double right, double bottom, double top, double zNear, double zFar, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenMatrixFrustumEXT(builder, mode, left, right, bottom, top, zNear, zFar);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glMatrixFrustumEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlMatrixLoad3x2fNV(Uint64 sessionId, uint32_t matrixMode, const std::vector<float>& m, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenMatrixLoad3x2fNV(builder, matrixMode, builder.CreateVector(m));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glMatrixLoad3x2fNV), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlMatrixLoad3x3fNV(Uint64 sessionId, uint32_t matrixMode, const std::vector<float>& m, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenMatrixLoad3x3fNV(builder, matrixMode, builder.CreateVector(m));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glMatrixLoad3x3fNV), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlMatrixLoadIdentityEXT(Uint64 sessionId, uint32_t mode, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenMatrixLoadIdentityEXT(builder, mode);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glMatrixLoadIdentityEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlMatrixLoadTranspose3x3fNV(Uint64 sessionId, uint32_t matrixMode, const std::vector<float>& m, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenMatrixLoadTranspose3x3fNV(builder, matrixMode, builder.CreateVector(m));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glMatrixLoadTranspose3x3fNV), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlMatrixLoadTransposedEXT(Uint64 sessionId, uint32_t mode, const std::vector<double>& m, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenMatrixLoadTransposedEXT(builder, mode, builder.CreateVector(m));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glMatrixLoadTransposedEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlMatrixLoadTransposefEXT(Uint64 sessionId, uint32_t mode, const std::vector<float>& m, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenMatrixLoadTransposefEXT(builder, mode, builder.CreateVector(m));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glMatrixLoadTransposefEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlMatrixLoaddEXT(Uint64 sessionId, uint32_t mode, const std::vector<double>& m, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenMatrixLoaddEXT(builder, mode, builder.CreateVector(m));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glMatrixLoaddEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlMatrixLoadfEXT(Uint64 sessionId, uint32_t mode, const std::vector<float>& m, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenMatrixLoadfEXT(builder, mode, builder.CreateVector(m));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glMatrixLoadfEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlMatrixMult3x2fNV(Uint64 sessionId, uint32_t matrixMode, const std::vector<float>& m, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenMatrixMult3x2fNV(builder, matrixMode, builder.CreateVector(m));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glMatrixMult3x2fNV), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlMatrixMult3x3fNV(Uint64 sessionId, uint32_t matrixMode, const std::vector<float>& m, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenMatrixMult3x3fNV(builder, matrixMode, builder.CreateVector(m));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glMatrixMult3x3fNV), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlMatrixMultTranspose3x3fNV(Uint64 sessionId, uint32_t matrixMode, const std::vector<float>& m, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenMatrixMultTranspose3x3fNV(builder, matrixMode, builder.CreateVector(m));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glMatrixMultTranspose3x3fNV), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlMatrixMultTransposedEXT(Uint64 sessionId, uint32_t mode, const std::vector<double>& m, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenMatrixMultTransposedEXT(builder, mode, builder.CreateVector(m));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glMatrixMultTransposedEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlMatrixMultTransposefEXT(Uint64 sessionId, uint32_t mode, const std::vector<float>& m, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenMatrixMultTransposefEXT(builder, mode, builder.CreateVector(m));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glMatrixMultTransposefEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlMatrixMultdEXT(Uint64 sessionId, uint32_t mode, const std::vector<double>& m, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenMatrixMultdEXT(builder, mode, builder.CreateVector(m));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glMatrixMultdEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlMatrixMultfEXT(Uint64 sessionId, uint32_t mode, const std::vector<float>& m, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenMatrixMultfEXT(builder, mode, builder.CreateVector(m));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glMatrixMultfEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlMatrixOrthoEXT(Uint64 sessionId, uint32_t mode, double left, double right, double bottom, double top, double zNear, double zFar, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenMatrixOrthoEXT(builder, mode, left, right, bottom, top, zNear, zFar);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glMatrixOrthoEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlMatrixPopEXT(Uint64 sessionId, uint32_t mode, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenMatrixPopEXT(builder, mode);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glMatrixPopEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlMatrixPushEXT(Uint64 sessionId, uint32_t mode, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenMatrixPushEXT(builder, mode);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glMatrixPushEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlMatrixRotatedEXT(Uint64 sessionId, uint32_t mode, double ane, double x, double y, double z, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenMatrixRotatedEXT(builder, mode, ane, x, y, z);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glMatrixRotatedEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlMatrixRotatefEXT(Uint64 sessionId, uint32_t mode, float ane, float x, float y, float z, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenMatrixRotatefEXT(builder, mode, ane, x, y, z);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glMatrixRotatefEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlMatrixScaledEXT(Uint64 sessionId, uint32_t mode, double x, double y, double z, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenMatrixScaledEXT(builder, mode, x, y, z);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glMatrixScaledEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlMatrixScalefEXT(Uint64 sessionId, uint32_t mode, float x, float y, float z, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenMatrixScalefEXT(builder, mode, x, y, z);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glMatrixScalefEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlMatrixTranslatedEXT(Uint64 sessionId, uint32_t mode, double x, double y, double z, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenMatrixTranslatedEXT(builder, mode, x, y, z);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glMatrixTranslatedEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlMatrixTranslatefEXT(Uint64 sessionId, uint32_t mode, float x, float y, float z, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenMatrixTranslatefEXT(builder, mode, x, y, z);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glMatrixTranslatefEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlMaxShaderCompilerThreadsARB(Uint64 sessionId, uint32_t count, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenMaxShaderCompilerThreadsARB(builder, count);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glMaxShaderCompilerThreadsARB), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlMaxShaderCompilerThreadsKHR(Uint64 sessionId, uint32_t count, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenMaxShaderCompilerThreadsKHR(builder, count);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glMaxShaderCompilerThreadsKHR), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlMemoryBarrier(Uint64 sessionId, uint32_t barriers, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenMemoryBarrier(builder, barriers);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glMemoryBarrier), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlMemoryBarrierByRegion(Uint64 sessionId, uint32_t barriers, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenMemoryBarrierByRegion(builder, barriers);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glMemoryBarrierByRegion), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlMinSampleShading(Uint64 sessionId, float value, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenMinSampleShading(builder, value);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glMinSampleShading), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlMultiDrawArrays(Uint64 sessionId, uint32_t mode, const std::vector<int32_t>& first, const std::vector<int32_t>& count, int32_t drawcount, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenMultiDrawArrays(builder, mode, builder.CreateVector(first), builder.CreateVector(count), drawcount);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glMultiDrawArrays), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlMultiDrawArraysIndirect(Uint64 sessionId, uint32_t mode, int32_t drawcount, int32_t stride, Uint64 token, MobileGLShmHandle* shm) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenMultiDrawArraysIndirect(builder, mode, MobileGL::Protocol::WireFull::CreateShmRegion(builder, 0, shm == nullptr ? 0 : shm->size), drawcount, stride);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glMultiDrawArraysIndirect), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlMultiDrawArraysIndirectBindlessCountNV(Uint64 sessionId, uint32_t mode, int32_t drawCount, int32_t maxDrawCount, int32_t stride, int32_t vertexBufferCount, Uint64 token, MobileGLShmHandle* shm) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenMultiDrawArraysIndirectBindlessCountNV(builder, mode, MobileGL::Protocol::WireFull::CreateShmRegion(builder, 0, shm == nullptr ? 0 : shm->size), drawCount, maxDrawCount, stride, vertexBufferCount);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glMultiDrawArraysIndirectBindlessCountNV), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlMultiDrawArraysIndirectBindlessNV(Uint64 sessionId, uint32_t mode, int32_t drawCount, int32_t stride, int32_t vertexBufferCount, Uint64 token, MobileGLShmHandle* shm) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenMultiDrawArraysIndirectBindlessNV(builder, mode, MobileGL::Protocol::WireFull::CreateShmRegion(builder, 0, shm == nullptr ? 0 : shm->size), drawCount, stride, vertexBufferCount);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glMultiDrawArraysIndirectBindlessNV), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlMultiDrawArraysIndirectCount(Uint64 sessionId, uint32_t mode, int64_t drawcount, int32_t maxdrawcount, int32_t stride, Uint64 token, MobileGLShmHandle* shm) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenMultiDrawArraysIndirectCount(builder, mode, MobileGL::Protocol::WireFull::CreateShmRegion(builder, 0, shm == nullptr ? 0 : shm->size), drawcount, maxdrawcount, stride);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glMultiDrawArraysIndirectCount), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlMultiDrawArraysIndirectCountARB(Uint64 sessionId, uint32_t mode, int64_t drawcount, int32_t maxdrawcount, int32_t stride, Uint64 token, MobileGLShmHandle* shm) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenMultiDrawArraysIndirectCountARB(builder, mode, MobileGL::Protocol::WireFull::CreateShmRegion(builder, 0, shm == nullptr ? 0 : shm->size), drawcount, maxdrawcount, stride);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glMultiDrawArraysIndirectCountARB), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlMultiDrawElementsIndirect(Uint64 sessionId, uint32_t mode, uint32_t type, int32_t drawcount, int32_t stride, Uint64 token, MobileGLShmHandle* shm) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenMultiDrawElementsIndirect(builder, mode, type, MobileGL::Protocol::WireFull::CreateShmRegion(builder, 0, shm == nullptr ? 0 : shm->size), drawcount, stride);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glMultiDrawElementsIndirect), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlMultiDrawElementsIndirectBindlessCountNV(Uint64 sessionId, uint32_t mode, uint32_t type, int32_t drawCount, int32_t maxDrawCount, int32_t stride, int32_t vertexBufferCount, Uint64 token, MobileGLShmHandle* shm) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenMultiDrawElementsIndirectBindlessCountNV(builder, mode, type, MobileGL::Protocol::WireFull::CreateShmRegion(builder, 0, shm == nullptr ? 0 : shm->size), drawCount, maxDrawCount, stride, vertexBufferCount);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glMultiDrawElementsIndirectBindlessCountNV), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlMultiDrawElementsIndirectBindlessNV(Uint64 sessionId, uint32_t mode, uint32_t type, int32_t drawCount, int32_t stride, int32_t vertexBufferCount, Uint64 token, MobileGLShmHandle* shm) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenMultiDrawElementsIndirectBindlessNV(builder, mode, type, MobileGL::Protocol::WireFull::CreateShmRegion(builder, 0, shm == nullptr ? 0 : shm->size), drawCount, stride, vertexBufferCount);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glMultiDrawElementsIndirectBindlessNV), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlMultiDrawElementsIndirectCount(Uint64 sessionId, uint32_t mode, uint32_t type, int64_t drawcount, int32_t maxdrawcount, int32_t stride, Uint64 token, MobileGLShmHandle* shm) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenMultiDrawElementsIndirectCount(builder, mode, type, MobileGL::Protocol::WireFull::CreateShmRegion(builder, 0, shm == nullptr ? 0 : shm->size), drawcount, maxdrawcount, stride);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glMultiDrawElementsIndirectCount), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlMultiDrawElementsIndirectCountARB(Uint64 sessionId, uint32_t mode, uint32_t type, int64_t drawcount, int32_t maxdrawcount, int32_t stride, Uint64 token, MobileGLShmHandle* shm) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenMultiDrawElementsIndirectCountARB(builder, mode, type, MobileGL::Protocol::WireFull::CreateShmRegion(builder, 0, shm == nullptr ? 0 : shm->size), drawcount, maxdrawcount, stride);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glMultiDrawElementsIndirectCountARB), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlMultiDrawMeshTasksIndirectCountNV(Uint64 sessionId, int64_t indirect, int64_t drawcount, int32_t maxdrawcount, int32_t stride, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenMultiDrawMeshTasksIndirectCountNV(builder, indirect, drawcount, maxdrawcount, stride);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glMultiDrawMeshTasksIndirectCountNV), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlMultiDrawMeshTasksIndirectNV(Uint64 sessionId, int64_t indirect, int32_t drawcount, int32_t stride, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenMultiDrawMeshTasksIndirectNV(builder, indirect, drawcount, stride);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glMultiDrawMeshTasksIndirectNV), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlMultiTexBufferEXT(Uint64 sessionId, uint32_t texunit, uint32_t target, uint32_t internalformat, uint32_t buffer, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenMultiTexBufferEXT(builder, texunit, target, internalformat, buffer);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glMultiTexBufferEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlMultiTexCoordPointerEXT(Uint64 sessionId, uint32_t texunit, int32_t size, uint32_t type, int32_t stride, Uint64 token, MobileGLShmHandle* shm) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenMultiTexCoordPointerEXT(builder, texunit, size, type, stride, MobileGL::Protocol::WireFull::CreateShmRegion(builder, 0, shm == nullptr ? 0 : shm->size));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glMultiTexCoordPointerEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlMultiTexEnvfEXT(Uint64 sessionId, uint32_t texunit, uint32_t target, uint32_t pname, float param, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenMultiTexEnvfEXT(builder, texunit, target, pname, param);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glMultiTexEnvfEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlMultiTexEnvfvEXT(Uint64 sessionId, uint32_t texunit, uint32_t target, uint32_t pname, const std::vector<float>& params, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenMultiTexEnvfvEXT(builder, texunit, target, pname, builder.CreateVector(params));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glMultiTexEnvfvEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlMultiTexEnviEXT(Uint64 sessionId, uint32_t texunit, uint32_t target, uint32_t pname, int32_t param, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenMultiTexEnviEXT(builder, texunit, target, pname, param);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glMultiTexEnviEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlMultiTexEnvivEXT(Uint64 sessionId, uint32_t texunit, uint32_t target, uint32_t pname, const std::vector<int32_t>& params, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenMultiTexEnvivEXT(builder, texunit, target, pname, builder.CreateVector(params));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glMultiTexEnvivEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlMultiTexGendEXT(Uint64 sessionId, uint32_t texunit, uint32_t coord, uint32_t pname, double param, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenMultiTexGendEXT(builder, texunit, coord, pname, param);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glMultiTexGendEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlMultiTexGendvEXT(Uint64 sessionId, uint32_t texunit, uint32_t coord, uint32_t pname, const std::vector<double>& params, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenMultiTexGendvEXT(builder, texunit, coord, pname, builder.CreateVector(params));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glMultiTexGendvEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlMultiTexGenfEXT(Uint64 sessionId, uint32_t texunit, uint32_t coord, uint32_t pname, float param, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenMultiTexGenfEXT(builder, texunit, coord, pname, param);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glMultiTexGenfEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlMultiTexGenfvEXT(Uint64 sessionId, uint32_t texunit, uint32_t coord, uint32_t pname, const std::vector<float>& params, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenMultiTexGenfvEXT(builder, texunit, coord, pname, builder.CreateVector(params));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glMultiTexGenfvEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlMultiTexGeniEXT(Uint64 sessionId, uint32_t texunit, uint32_t coord, uint32_t pname, int32_t param, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenMultiTexGeniEXT(builder, texunit, coord, pname, param);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glMultiTexGeniEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlMultiTexGenivEXT(Uint64 sessionId, uint32_t texunit, uint32_t coord, uint32_t pname, const std::vector<int32_t>& params, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenMultiTexGenivEXT(builder, texunit, coord, pname, builder.CreateVector(params));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glMultiTexGenivEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlMultiTexImage1DEXT(Uint64 sessionId, uint32_t texunit, uint32_t target, int32_t level, int32_t internalformat, int32_t width, int32_t border, uint32_t format, uint32_t type, Uint64 token, MobileGLShmHandle* shm) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenMultiTexImage1DEXT(builder, texunit, target, level, internalformat, width, border, format, type, MobileGL::Protocol::WireFull::CreateShmRegion(builder, 0, shm == nullptr ? 0 : shm->size));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glMultiTexImage1DEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlMultiTexImage2DEXT(Uint64 sessionId, uint32_t texunit, uint32_t target, int32_t level, int32_t internalformat, int32_t width, int32_t height, int32_t border, uint32_t format, uint32_t type, Uint64 token, MobileGLShmHandle* shm) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenMultiTexImage2DEXT(builder, texunit, target, level, internalformat, width, height, border, format, type, MobileGL::Protocol::WireFull::CreateShmRegion(builder, 0, shm == nullptr ? 0 : shm->size));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glMultiTexImage2DEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlMultiTexImage3DEXT(Uint64 sessionId, uint32_t texunit, uint32_t target, int32_t level, int32_t internalformat, int32_t width, int32_t height, int32_t depth, int32_t border, uint32_t format, uint32_t type, Uint64 token, MobileGLShmHandle* shm) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenMultiTexImage3DEXT(builder, texunit, target, level, internalformat, width, height, depth, border, format, type, MobileGL::Protocol::WireFull::CreateShmRegion(builder, 0, shm == nullptr ? 0 : shm->size));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glMultiTexImage3DEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlMultiTexParameterIivEXT(Uint64 sessionId, uint32_t texunit, uint32_t target, uint32_t pname, const std::vector<int32_t>& params, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenMultiTexParameterIivEXT(builder, texunit, target, pname, builder.CreateVector(params));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glMultiTexParameterIivEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlMultiTexParameterIuivEXT(Uint64 sessionId, uint32_t texunit, uint32_t target, uint32_t pname, const std::vector<uint32_t>& params, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenMultiTexParameterIuivEXT(builder, texunit, target, pname, builder.CreateVector(params));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glMultiTexParameterIuivEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlMultiTexParameterfEXT(Uint64 sessionId, uint32_t texunit, uint32_t target, uint32_t pname, float param, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenMultiTexParameterfEXT(builder, texunit, target, pname, param);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glMultiTexParameterfEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlMultiTexParameterfvEXT(Uint64 sessionId, uint32_t texunit, uint32_t target, uint32_t pname, const std::vector<float>& params, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenMultiTexParameterfvEXT(builder, texunit, target, pname, builder.CreateVector(params));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glMultiTexParameterfvEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlMultiTexParameteriEXT(Uint64 sessionId, uint32_t texunit, uint32_t target, uint32_t pname, int32_t param, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenMultiTexParameteriEXT(builder, texunit, target, pname, param);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glMultiTexParameteriEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlMultiTexParameterivEXT(Uint64 sessionId, uint32_t texunit, uint32_t target, uint32_t pname, const std::vector<int32_t>& params, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenMultiTexParameterivEXT(builder, texunit, target, pname, builder.CreateVector(params));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glMultiTexParameterivEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlMultiTexRenderbufferEXT(Uint64 sessionId, uint32_t texunit, uint32_t target, uint32_t renderbuffer, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenMultiTexRenderbufferEXT(builder, texunit, target, renderbuffer);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glMultiTexRenderbufferEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlMultiTexSubImage1DEXT(Uint64 sessionId, uint32_t texunit, uint32_t target, int32_t level, int32_t xoffset, int32_t width, uint32_t format, uint32_t type, Uint64 token, MobileGLShmHandle* shm) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenMultiTexSubImage1DEXT(builder, texunit, target, level, xoffset, width, format, type, MobileGL::Protocol::WireFull::CreateShmRegion(builder, 0, shm == nullptr ? 0 : shm->size));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glMultiTexSubImage1DEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlMultiTexSubImage2DEXT(Uint64 sessionId, uint32_t texunit, uint32_t target, int32_t level, int32_t xoffset, int32_t yoffset, int32_t width, int32_t height, uint32_t format, uint32_t type, Uint64 token, MobileGLShmHandle* shm) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenMultiTexSubImage2DEXT(builder, texunit, target, level, xoffset, yoffset, width, height, format, type, MobileGL::Protocol::WireFull::CreateShmRegion(builder, 0, shm == nullptr ? 0 : shm->size));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glMultiTexSubImage2DEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlMultiTexSubImage3DEXT(Uint64 sessionId, uint32_t texunit, uint32_t target, int32_t level, int32_t xoffset, int32_t yoffset, int32_t zoffset, int32_t width, int32_t height, int32_t depth, uint32_t format, uint32_t type, Uint64 token, MobileGLShmHandle* shm) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenMultiTexSubImage3DEXT(builder, texunit, target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, MobileGL::Protocol::WireFull::CreateShmRegion(builder, 0, shm == nullptr ? 0 : shm->size));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glMultiTexSubImage3DEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlNamedBufferAttachMemoryNV(Uint64 sessionId, uint32_t buffer, uint32_t memory, uint64_t offset, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenNamedBufferAttachMemoryNV(builder, buffer, memory, offset);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glNamedBufferAttachMemoryNV), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlNamedBufferData(Uint64 sessionId, uint32_t buffer, uint64_t size, uint32_t usage, Uint64 token, MobileGLShmHandle* shm) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenNamedBufferData(builder, buffer, size, MobileGL::Protocol::WireFull::CreateShmRegion(builder, 0, shm == nullptr ? 0 : shm->size), usage);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glNamedBufferData), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlNamedBufferDataEXT(Uint64 sessionId, uint32_t buffer, uint64_t size, uint32_t usage, Uint64 token, MobileGLShmHandle* shm) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenNamedBufferDataEXT(builder, buffer, size, MobileGL::Protocol::WireFull::CreateShmRegion(builder, 0, shm == nullptr ? 0 : shm->size), usage);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glNamedBufferDataEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlNamedBufferPageCommitmentARB(Uint64 sessionId, uint32_t buffer, int64_t offset, uint64_t size, bool commit, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenNamedBufferPageCommitmentARB(builder, buffer, offset, size, commit);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glNamedBufferPageCommitmentARB), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlNamedBufferPageCommitmentEXT(Uint64 sessionId, uint32_t buffer, int64_t offset, uint64_t size, bool commit, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenNamedBufferPageCommitmentEXT(builder, buffer, offset, size, commit);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glNamedBufferPageCommitmentEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlNamedBufferPageCommitmentMemNV(Uint64 sessionId, uint32_t buffer, int64_t offset, uint64_t size, uint32_t memory, uint64_t memOffset, bool commit, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenNamedBufferPageCommitmentMemNV(builder, buffer, offset, size, memory, memOffset, commit);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glNamedBufferPageCommitmentMemNV), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlNamedBufferStorage(Uint64 sessionId, uint32_t buffer, uint64_t size, uint32_t flags, Uint64 token, MobileGLShmHandle* shm) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenNamedBufferStorage(builder, buffer, size, MobileGL::Protocol::WireFull::CreateShmRegion(builder, 0, shm == nullptr ? 0 : shm->size), flags);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glNamedBufferStorage), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlNamedBufferStorageEXT(Uint64 sessionId, uint32_t buffer, uint64_t size, uint32_t flags, Uint64 token, MobileGLShmHandle* shm) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenNamedBufferStorageEXT(builder, buffer, size, MobileGL::Protocol::WireFull::CreateShmRegion(builder, 0, shm == nullptr ? 0 : shm->size), flags);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glNamedBufferStorageEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlNamedBufferSubData(Uint64 sessionId, uint32_t buffer, int64_t offset, uint64_t size, Uint64 token, MobileGLShmHandle* shm) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenNamedBufferSubData(builder, buffer, offset, size, MobileGL::Protocol::WireFull::CreateShmRegion(builder, 0, shm == nullptr ? 0 : shm->size));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glNamedBufferSubData), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlNamedBufferSubDataEXT(Uint64 sessionId, uint32_t buffer, int64_t offset, uint64_t size, Uint64 token, MobileGLShmHandle* shm) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenNamedBufferSubDataEXT(builder, buffer, offset, size, MobileGL::Protocol::WireFull::CreateShmRegion(builder, 0, shm == nullptr ? 0 : shm->size));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glNamedBufferSubDataEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlNamedCopyBufferSubDataEXT(Uint64 sessionId, uint32_t readBuffer, uint32_t writeBuffer, int64_t readOffset, int64_t writeOffset, uint64_t size, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenNamedCopyBufferSubDataEXT(builder, readBuffer, writeBuffer, readOffset, writeOffset, size);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glNamedCopyBufferSubDataEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlNamedFramebufferDrawBuffer(Uint64 sessionId, uint32_t framebuffer, uint32_t buf, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenNamedFramebufferDrawBuffer(builder, framebuffer, buf);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glNamedFramebufferDrawBuffer), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlNamedFramebufferDrawBuffers(Uint64 sessionId, uint32_t framebuffer, int32_t n, const std::vector<uint32_t>& bufs, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenNamedFramebufferDrawBuffers(builder, framebuffer, n, builder.CreateVector(bufs));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glNamedFramebufferDrawBuffers), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlNamedFramebufferParameteri(Uint64 sessionId, uint32_t framebuffer, uint32_t pname, int32_t param, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenNamedFramebufferParameteri(builder, framebuffer, pname, param);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glNamedFramebufferParameteri), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlNamedFramebufferParameteriEXT(Uint64 sessionId, uint32_t framebuffer, uint32_t pname, int32_t param, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenNamedFramebufferParameteriEXT(builder, framebuffer, pname, param);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glNamedFramebufferParameteriEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlNamedFramebufferReadBuffer(Uint64 sessionId, uint32_t framebuffer, uint32_t src, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenNamedFramebufferReadBuffer(builder, framebuffer, src);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glNamedFramebufferReadBuffer), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlNamedFramebufferRenderbuffer(Uint64 sessionId, uint32_t framebuffer, uint32_t attachment, uint32_t renderbuffertarget, uint32_t renderbuffer, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenNamedFramebufferRenderbuffer(builder, framebuffer, attachment, renderbuffertarget, renderbuffer);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glNamedFramebufferRenderbuffer), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlNamedFramebufferRenderbufferEXT(Uint64 sessionId, uint32_t framebuffer, uint32_t attachment, uint32_t renderbuffertarget, uint32_t renderbuffer, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenNamedFramebufferRenderbufferEXT(builder, framebuffer, attachment, renderbuffertarget, renderbuffer);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glNamedFramebufferRenderbufferEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlNamedFramebufferSampleLocationsfvARB(Uint64 sessionId, uint32_t framebuffer, uint32_t start, int32_t count, const std::vector<float>& v, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenNamedFramebufferSampleLocationsfvARB(builder, framebuffer, start, count, builder.CreateVector(v));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glNamedFramebufferSampleLocationsfvARB), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlNamedFramebufferSampleLocationsfvNV(Uint64 sessionId, uint32_t framebuffer, uint32_t start, int32_t count, const std::vector<float>& v, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenNamedFramebufferSampleLocationsfvNV(builder, framebuffer, start, count, builder.CreateVector(v));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glNamedFramebufferSampleLocationsfvNV), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlNamedFramebufferTexture(Uint64 sessionId, uint32_t framebuffer, uint32_t attachment, uint32_t texture, int32_t level, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenNamedFramebufferTexture(builder, framebuffer, attachment, texture, level);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glNamedFramebufferTexture), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlNamedFramebufferTexture1DEXT(Uint64 sessionId, uint32_t framebuffer, uint32_t attachment, uint32_t textarget, uint32_t texture, int32_t level, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenNamedFramebufferTexture1DEXT(builder, framebuffer, attachment, textarget, texture, level);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glNamedFramebufferTexture1DEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlNamedFramebufferTexture2DEXT(Uint64 sessionId, uint32_t framebuffer, uint32_t attachment, uint32_t textarget, uint32_t texture, int32_t level, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenNamedFramebufferTexture2DEXT(builder, framebuffer, attachment, textarget, texture, level);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glNamedFramebufferTexture2DEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlNamedFramebufferTexture3DEXT(Uint64 sessionId, uint32_t framebuffer, uint32_t attachment, uint32_t textarget, uint32_t texture, int32_t level, int32_t zoffset, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenNamedFramebufferTexture3DEXT(builder, framebuffer, attachment, textarget, texture, level, zoffset);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glNamedFramebufferTexture3DEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlNamedFramebufferTextureEXT(Uint64 sessionId, uint32_t framebuffer, uint32_t attachment, uint32_t texture, int32_t level, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenNamedFramebufferTextureEXT(builder, framebuffer, attachment, texture, level);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glNamedFramebufferTextureEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlNamedFramebufferTextureFaceEXT(Uint64 sessionId, uint32_t framebuffer, uint32_t attachment, uint32_t texture, int32_t level, uint32_t face, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenNamedFramebufferTextureFaceEXT(builder, framebuffer, attachment, texture, level, face);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glNamedFramebufferTextureFaceEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlNamedFramebufferTextureLayer(Uint64 sessionId, uint32_t framebuffer, uint32_t attachment, uint32_t texture, int32_t level, int32_t layer, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenNamedFramebufferTextureLayer(builder, framebuffer, attachment, texture, level, layer);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glNamedFramebufferTextureLayer), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlNamedFramebufferTextureLayerEXT(Uint64 sessionId, uint32_t framebuffer, uint32_t attachment, uint32_t texture, int32_t level, int32_t layer, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenNamedFramebufferTextureLayerEXT(builder, framebuffer, attachment, texture, level, layer);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glNamedFramebufferTextureLayerEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlNamedProgramLocalParameter4dEXT(Uint64 sessionId, uint32_t program, uint32_t target, uint32_t index, double x, double y, double z, double w, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenNamedProgramLocalParameter4dEXT(builder, program, target, index, x, y, z, w);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glNamedProgramLocalParameter4dEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlNamedProgramLocalParameter4dvEXT(Uint64 sessionId, uint32_t program, uint32_t target, uint32_t index, const std::vector<double>& params, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenNamedProgramLocalParameter4dvEXT(builder, program, target, index, builder.CreateVector(params));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glNamedProgramLocalParameter4dvEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlNamedProgramLocalParameter4fEXT(Uint64 sessionId, uint32_t program, uint32_t target, uint32_t index, float x, float y, float z, float w, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenNamedProgramLocalParameter4fEXT(builder, program, target, index, x, y, z, w);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glNamedProgramLocalParameter4fEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlNamedProgramLocalParameter4fvEXT(Uint64 sessionId, uint32_t program, uint32_t target, uint32_t index, const std::vector<float>& params, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenNamedProgramLocalParameter4fvEXT(builder, program, target, index, builder.CreateVector(params));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glNamedProgramLocalParameter4fvEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlNamedProgramLocalParameterI4iEXT(Uint64 sessionId, uint32_t program, uint32_t target, uint32_t index, int32_t x, int32_t y, int32_t z, int32_t w, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenNamedProgramLocalParameterI4iEXT(builder, program, target, index, x, y, z, w);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glNamedProgramLocalParameterI4iEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlNamedProgramLocalParameterI4ivEXT(Uint64 sessionId, uint32_t program, uint32_t target, uint32_t index, const std::vector<int32_t>& params, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenNamedProgramLocalParameterI4ivEXT(builder, program, target, index, builder.CreateVector(params));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glNamedProgramLocalParameterI4ivEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlNamedProgramLocalParameterI4uiEXT(Uint64 sessionId, uint32_t program, uint32_t target, uint32_t index, uint32_t x, uint32_t y, uint32_t z, uint32_t w, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenNamedProgramLocalParameterI4uiEXT(builder, program, target, index, x, y, z, w);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glNamedProgramLocalParameterI4uiEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlNamedProgramLocalParameterI4uivEXT(Uint64 sessionId, uint32_t program, uint32_t target, uint32_t index, const std::vector<uint32_t>& params, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenNamedProgramLocalParameterI4uivEXT(builder, program, target, index, builder.CreateVector(params));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glNamedProgramLocalParameterI4uivEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlNamedProgramLocalParameters4fvEXT(Uint64 sessionId, uint32_t program, uint32_t target, uint32_t index, int32_t count, const std::vector<float>& params, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenNamedProgramLocalParameters4fvEXT(builder, program, target, index, count, builder.CreateVector(params));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glNamedProgramLocalParameters4fvEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlNamedProgramLocalParametersI4ivEXT(Uint64 sessionId, uint32_t program, uint32_t target, uint32_t index, int32_t count, const std::vector<int32_t>& params, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenNamedProgramLocalParametersI4ivEXT(builder, program, target, index, count, builder.CreateVector(params));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glNamedProgramLocalParametersI4ivEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlNamedProgramLocalParametersI4uivEXT(Uint64 sessionId, uint32_t program, uint32_t target, uint32_t index, int32_t count, const std::vector<uint32_t>& params, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenNamedProgramLocalParametersI4uivEXT(builder, program, target, index, count, builder.CreateVector(params));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glNamedProgramLocalParametersI4uivEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlNamedProgramStringEXT(Uint64 sessionId, uint32_t program, uint32_t target, uint32_t format, int32_t len, Uint64 token, MobileGLShmHandle* shm) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenNamedProgramStringEXT(builder, program, target, format, len, MobileGL::Protocol::WireFull::CreateShmRegion(builder, 0, shm == nullptr ? 0 : shm->size));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glNamedProgramStringEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlNamedRenderbufferStorage(Uint64 sessionId, uint32_t renderbuffer, uint32_t internalformat, int32_t width, int32_t height, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenNamedRenderbufferStorage(builder, renderbuffer, internalformat, width, height);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glNamedRenderbufferStorage), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlNamedRenderbufferStorageEXT(Uint64 sessionId, uint32_t renderbuffer, uint32_t internalformat, int32_t width, int32_t height, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenNamedRenderbufferStorageEXT(builder, renderbuffer, internalformat, width, height);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glNamedRenderbufferStorageEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlNamedRenderbufferStorageMultisample(Uint64 sessionId, uint32_t renderbuffer, int32_t samples, uint32_t internalformat, int32_t width, int32_t height, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenNamedRenderbufferStorageMultisample(builder, renderbuffer, samples, internalformat, width, height);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glNamedRenderbufferStorageMultisample), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlNamedRenderbufferStorageMultisampleAdvancedAMD(Uint64 sessionId, uint32_t renderbuffer, int32_t samples, int32_t storageSamples, uint32_t internalformat, int32_t width, int32_t height, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenNamedRenderbufferStorageMultisampleAdvancedAMD(builder, renderbuffer, samples, storageSamples, internalformat, width, height);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glNamedRenderbufferStorageMultisampleAdvancedAMD), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlNamedRenderbufferStorageMultisampleCoverageEXT(Uint64 sessionId, uint32_t renderbuffer, int32_t coverageSamples, int32_t colorSamples, uint32_t internalformat, int32_t width, int32_t height, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenNamedRenderbufferStorageMultisampleCoverageEXT(builder, renderbuffer, coverageSamples, colorSamples, internalformat, width, height);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glNamedRenderbufferStorageMultisampleCoverageEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlNamedRenderbufferStorageMultisampleEXT(Uint64 sessionId, uint32_t renderbuffer, int32_t samples, uint32_t internalformat, int32_t width, int32_t height, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenNamedRenderbufferStorageMultisampleEXT(builder, renderbuffer, samples, internalformat, width, height);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glNamedRenderbufferStorageMultisampleEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlNamedStringARB(Uint64 sessionId, uint32_t type, int32_t namelen, const char* name, int32_t strinen, const char* string, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenNamedStringARB(builder, type, namelen, builder.CreateString(name), strinen, builder.CreateString(string));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glNamedStringARB), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlNormalFormatNV(Uint64 sessionId, uint32_t type, int32_t stride, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenNormalFormatNV(builder, type, stride);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glNormalFormatNV), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlObjectLabel(Uint64 sessionId, uint32_t identifier, uint32_t name, int32_t length, const char* label, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenObjectLabel(builder, identifier, name, length, builder.CreateString(label));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glObjectLabel), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlObjectPtrLabel(Uint64 sessionId, int32_t length, const char* label, Uint64 token, MobileGLShmHandle* shm) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenObjectPtrLabel(builder, MobileGL::Protocol::WireFull::CreateShmRegion(builder, 0, shm == nullptr ? 0 : shm->size), length, builder.CreateString(label));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glObjectPtrLabel), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlPatchParameterfv(Uint64 sessionId, uint32_t pname, const std::vector<float>& values, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenPatchParameterfv(builder, pname, builder.CreateVector(values));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glPatchParameterfv), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlPatchParameteri(Uint64 sessionId, uint32_t pname, int32_t value, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenPatchParameteri(builder, pname, value);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glPatchParameteri), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlPathCommandsNV(Uint64 sessionId, uint32_t path, int32_t numCommands, const std::vector<uint32_t>& commands, int32_t numCoords, uint32_t coordType, Uint64 token, MobileGLShmHandle* shm) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenPathCommandsNV(builder, path, numCommands, builder.CreateVector(commands), numCoords, coordType, MobileGL::Protocol::WireFull::CreateShmRegion(builder, 0, shm == nullptr ? 0 : shm->size));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glPathCommandsNV), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlPathCoordsNV(Uint64 sessionId, uint32_t path, int32_t numCoords, uint32_t coordType, Uint64 token, MobileGLShmHandle* shm) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenPathCoordsNV(builder, path, numCoords, coordType, MobileGL::Protocol::WireFull::CreateShmRegion(builder, 0, shm == nullptr ? 0 : shm->size));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glPathCoordsNV), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlPathCoverDepthFuncNV(Uint64 sessionId, uint32_t func, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenPathCoverDepthFuncNV(builder, func);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glPathCoverDepthFuncNV), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlPathDashArrayNV(Uint64 sessionId, uint32_t path, int32_t dashCount, const std::vector<float>& dashArray, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenPathDashArrayNV(builder, path, dashCount, builder.CreateVector(dashArray));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glPathDashArrayNV), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlPathGlyphIndexArrayNV(Uint64 sessionId, uint32_t firstPathName, uint32_t fontTarget, uint32_t fontStyle, uint32_t firstGlyphIndex, int32_t numGlyphs, uint32_t pathParameterTemplate, float emScale, Uint64 token, MobileGLShmHandle* shm) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenPathGlyphIndexArrayNV(builder, firstPathName, fontTarget, MobileGL::Protocol::WireFull::CreateShmRegion(builder, 0, shm == nullptr ? 0 : shm->size), fontStyle, firstGlyphIndex, numGlyphs, pathParameterTemplate, emScale);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glPathGlyphIndexArrayNV), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlPathGlyphIndexRangeNV(Uint64 sessionId, uint32_t fontTarget, uint32_t fontStyle, uint32_t pathParameterTemplate, float emScale, Uint64 token, MobileGLShmHandle* shm, Uint32 outCapacity = 0) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenPathGlyphIndexRangeNV(builder, fontTarget, MobileGL::Protocol::WireFull::CreateShmRegion(builder, 0, shm == nullptr ? 0 : shm->size), fontStyle, pathParameterTemplate, emScale, 0);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glPathGlyphIndexRangeNV), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm, outCapacity);
}
inline Bool SendGlPathGlyphRangeNV(Uint64 sessionId, uint32_t firstPathName, uint32_t fontTarget, uint32_t fontStyle, uint32_t firstGlyph, int32_t numGlyphs, uint32_t handleMissingGlyphs, uint32_t pathParameterTemplate, float emScale, Uint64 token, MobileGLShmHandle* shm) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenPathGlyphRangeNV(builder, firstPathName, fontTarget, MobileGL::Protocol::WireFull::CreateShmRegion(builder, 0, shm == nullptr ? 0 : shm->size), fontStyle, firstGlyph, numGlyphs, handleMissingGlyphs, pathParameterTemplate, emScale);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glPathGlyphRangeNV), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlPathMemoryGlyphIndexArrayNV(Uint64 sessionId, uint32_t firstPathName, uint32_t fontTarget, uint64_t fontSize, int32_t faceIndex, uint32_t firstGlyphIndex, int32_t numGlyphs, uint32_t pathParameterTemplate, float emScale, Uint64 token, MobileGLShmHandle* shm) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenPathMemoryGlyphIndexArrayNV(builder, firstPathName, fontTarget, fontSize, MobileGL::Protocol::WireFull::CreateShmRegion(builder, 0, shm == nullptr ? 0 : shm->size), faceIndex, firstGlyphIndex, numGlyphs, pathParameterTemplate, emScale);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glPathMemoryGlyphIndexArrayNV), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlPathParameterfNV(Uint64 sessionId, uint32_t path, uint32_t pname, float value, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenPathParameterfNV(builder, path, pname, value);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glPathParameterfNV), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlPathParameterfvNV(Uint64 sessionId, uint32_t path, uint32_t pname, const std::vector<float>& value, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenPathParameterfvNV(builder, path, pname, builder.CreateVector(value));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glPathParameterfvNV), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlPathParameteriNV(Uint64 sessionId, uint32_t path, uint32_t pname, int32_t value, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenPathParameteriNV(builder, path, pname, value);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glPathParameteriNV), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlPathParameterivNV(Uint64 sessionId, uint32_t path, uint32_t pname, const std::vector<int32_t>& value, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenPathParameterivNV(builder, path, pname, builder.CreateVector(value));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glPathParameterivNV), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlPathStencilDepthOffsetNV(Uint64 sessionId, float factor, float units, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenPathStencilDepthOffsetNV(builder, factor, units);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glPathStencilDepthOffsetNV), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlPathStencilFuncNV(Uint64 sessionId, uint32_t func, int32_t ref, uint32_t mask, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenPathStencilFuncNV(builder, func, ref, mask);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glPathStencilFuncNV), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlPathStringNV(Uint64 sessionId, uint32_t path, uint32_t format, int32_t length, Uint64 token, MobileGLShmHandle* shm) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenPathStringNV(builder, path, format, length, MobileGL::Protocol::WireFull::CreateShmRegion(builder, 0, shm == nullptr ? 0 : shm->size));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glPathStringNV), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlPathSubCommandsNV(Uint64 sessionId, uint32_t path, int32_t commandStart, int32_t commandsToDelete, int32_t numCommands, const std::vector<uint32_t>& commands, int32_t numCoords, uint32_t coordType, Uint64 token, MobileGLShmHandle* shm) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenPathSubCommandsNV(builder, path, commandStart, commandsToDelete, numCommands, builder.CreateVector(commands), numCoords, coordType, MobileGL::Protocol::WireFull::CreateShmRegion(builder, 0, shm == nullptr ? 0 : shm->size));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glPathSubCommandsNV), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlPathSubCoordsNV(Uint64 sessionId, uint32_t path, int32_t coordStart, int32_t numCoords, uint32_t coordType, Uint64 token, MobileGLShmHandle* shm) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenPathSubCoordsNV(builder, path, coordStart, numCoords, coordType, MobileGL::Protocol::WireFull::CreateShmRegion(builder, 0, shm == nullptr ? 0 : shm->size));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glPathSubCoordsNV), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlPixelStoref(Uint64 sessionId, uint32_t pname, float param, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenPixelStoref(builder, pname, param);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glPixelStoref), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlPixelStorei(Uint64 sessionId, uint32_t pname, int32_t param, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenPixelStorei(builder, pname, param);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glPixelStorei), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlPointAlongPathNV(Uint64 sessionId, uint32_t path, int32_t startSegment, int32_t numSegments, float distance, Uint64 token, MobileGLShmHandle* shm = nullptr, Uint32 outCapacity = 0) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenPointAlongPathNV(builder, path, startSegment, numSegments, distance, 0, 0, 0, 0);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glPointAlongPathNV), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm, outCapacity);
}
inline Bool SendGlPointParameterf(Uint64 sessionId, uint32_t pname, float param, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenPointParameterf(builder, pname, param);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glPointParameterf), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlPointParameterfv(Uint64 sessionId, uint32_t pname, const std::vector<float>& params, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenPointParameterfv(builder, pname, builder.CreateVector(params));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glPointParameterfv), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlPointParameteri(Uint64 sessionId, uint32_t pname, int32_t param, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenPointParameteri(builder, pname, param);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glPointParameteri), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlPointParameteriv(Uint64 sessionId, uint32_t pname, const std::vector<int32_t>& params, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenPointParameteriv(builder, pname, builder.CreateVector(params));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glPointParameteriv), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlPointSize(Uint64 sessionId, float size, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenPointSize(builder, size);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glPointSize), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlPolygonMode(Uint64 sessionId, uint32_t face, uint32_t mode, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenPolygonMode(builder, face, mode);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glPolygonMode), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlPolygonOffset(Uint64 sessionId, float factor, float units, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenPolygonOffset(builder, factor, units);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glPolygonOffset), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlPolygonOffsetClamp(Uint64 sessionId, float factor, float units, float clamp, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenPolygonOffsetClamp(builder, factor, units, clamp);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glPolygonOffsetClamp), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlPolygonOffsetClampEXT(Uint64 sessionId, float factor, float units, float clamp, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenPolygonOffsetClampEXT(builder, factor, units, clamp);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glPolygonOffsetClampEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlPrimitiveBoundingBoxARB(Uint64 sessionId, float minX, float minY, float minZ, float minW, float maxX, float maxY, float maxZ, float maxW, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenPrimitiveBoundingBoxARB(builder, minX, minY, minZ, minW, maxX, maxY, maxZ, maxW);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glPrimitiveBoundingBoxARB), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlPrimitiveRestartIndex(Uint64 sessionId, uint32_t index, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenPrimitiveRestartIndex(builder, index);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glPrimitiveRestartIndex), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlProgramBinary(Uint64 sessionId, uint32_t program, uint32_t binaryFormat, int32_t length, Uint64 token, MobileGLShmHandle* shm) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenProgramBinary(builder, program, binaryFormat, MobileGL::Protocol::WireFull::CreateShmRegion(builder, 0, shm == nullptr ? 0 : shm->size), length);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glProgramBinary), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlProgramParameteri(Uint64 sessionId, uint32_t program, uint32_t pname, int32_t value, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenProgramParameteri(builder, program, pname, value);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glProgramParameteri), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlProgramPathFragmentInputGenNV(Uint64 sessionId, uint32_t program, int32_t location, uint32_t genMode, int32_t components, const std::vector<float>& coeffs, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenProgramPathFragmentInputGenNV(builder, program, location, genMode, components, builder.CreateVector(coeffs));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glProgramPathFragmentInputGenNV), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlProgramUniform1d(Uint64 sessionId, uint32_t program, int32_t location, double v0, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenProgramUniform1d(builder, program, location, v0);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glProgramUniform1d), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlProgramUniform1dEXT(Uint64 sessionId, uint32_t program, int32_t location, double x, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenProgramUniform1dEXT(builder, program, location, x);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glProgramUniform1dEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlProgramUniform1dv(Uint64 sessionId, uint32_t program, int32_t location, int32_t count, const std::vector<double>& value, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenProgramUniform1dv(builder, program, location, count, builder.CreateVector(value));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glProgramUniform1dv), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlProgramUniform1dvEXT(Uint64 sessionId, uint32_t program, int32_t location, int32_t count, const std::vector<double>& value, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenProgramUniform1dvEXT(builder, program, location, count, builder.CreateVector(value));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glProgramUniform1dvEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlProgramUniform1f(Uint64 sessionId, uint32_t program, int32_t location, float v0, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenProgramUniform1f(builder, program, location, v0);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glProgramUniform1f), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlProgramUniform1fv(Uint64 sessionId, uint32_t program, int32_t location, int32_t count, const std::vector<float>& value, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenProgramUniform1fv(builder, program, location, count, builder.CreateVector(value));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glProgramUniform1fv), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlProgramUniform1i(Uint64 sessionId, uint32_t program, int32_t location, int32_t v0, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenProgramUniform1i(builder, program, location, v0);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glProgramUniform1i), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlProgramUniform1i64ARB(Uint64 sessionId, uint32_t program, int32_t location, int64_t x, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenProgramUniform1i64ARB(builder, program, location, x);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glProgramUniform1i64ARB), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlProgramUniform1i64NV(Uint64 sessionId, uint32_t program, int32_t location, int64_t x, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenProgramUniform1i64NV(builder, program, location, x);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glProgramUniform1i64NV), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlProgramUniform1i64vARB(Uint64 sessionId, uint32_t program, int32_t location, int32_t count, const std::vector<int64_t>& value, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenProgramUniform1i64vARB(builder, program, location, count, builder.CreateVector(value));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glProgramUniform1i64vARB), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlProgramUniform1i64vNV(Uint64 sessionId, uint32_t program, int32_t location, int32_t count, const std::vector<int64_t>& value, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenProgramUniform1i64vNV(builder, program, location, count, builder.CreateVector(value));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glProgramUniform1i64vNV), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlProgramUniform1iv(Uint64 sessionId, uint32_t program, int32_t location, int32_t count, const std::vector<int32_t>& value, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenProgramUniform1iv(builder, program, location, count, builder.CreateVector(value));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glProgramUniform1iv), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlProgramUniform1ui(Uint64 sessionId, uint32_t program, int32_t location, uint32_t v0, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenProgramUniform1ui(builder, program, location, v0);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glProgramUniform1ui), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlProgramUniform1ui64ARB(Uint64 sessionId, uint32_t program, int32_t location, uint64_t x, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenProgramUniform1ui64ARB(builder, program, location, x);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glProgramUniform1ui64ARB), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlProgramUniform1ui64NV(Uint64 sessionId, uint32_t program, int32_t location, uint64_t x, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenProgramUniform1ui64NV(builder, program, location, x);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glProgramUniform1ui64NV), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlProgramUniform1ui64vARB(Uint64 sessionId, uint32_t program, int32_t location, int32_t count, const std::vector<uint64_t>& value, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenProgramUniform1ui64vARB(builder, program, location, count, builder.CreateVector(value));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glProgramUniform1ui64vARB), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlProgramUniform1ui64vNV(Uint64 sessionId, uint32_t program, int32_t location, int32_t count, const std::vector<uint64_t>& value, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenProgramUniform1ui64vNV(builder, program, location, count, builder.CreateVector(value));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glProgramUniform1ui64vNV), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlProgramUniform1uiv(Uint64 sessionId, uint32_t program, int32_t location, int32_t count, const std::vector<uint32_t>& value, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenProgramUniform1uiv(builder, program, location, count, builder.CreateVector(value));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glProgramUniform1uiv), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlProgramUniform2d(Uint64 sessionId, uint32_t program, int32_t location, double v0, double v1, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenProgramUniform2d(builder, program, location, v0, v1);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glProgramUniform2d), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlProgramUniform2dEXT(Uint64 sessionId, uint32_t program, int32_t location, double x, double y, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenProgramUniform2dEXT(builder, program, location, x, y);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glProgramUniform2dEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlProgramUniform2dv(Uint64 sessionId, uint32_t program, int32_t location, int32_t count, const std::vector<double>& value, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenProgramUniform2dv(builder, program, location, count, builder.CreateVector(value));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glProgramUniform2dv), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlProgramUniform2dvEXT(Uint64 sessionId, uint32_t program, int32_t location, int32_t count, const std::vector<double>& value, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenProgramUniform2dvEXT(builder, program, location, count, builder.CreateVector(value));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glProgramUniform2dvEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlProgramUniform2f(Uint64 sessionId, uint32_t program, int32_t location, float v0, float v1, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenProgramUniform2f(builder, program, location, v0, v1);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glProgramUniform2f), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlProgramUniform2fv(Uint64 sessionId, uint32_t program, int32_t location, int32_t count, const std::vector<float>& value, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenProgramUniform2fv(builder, program, location, count, builder.CreateVector(value));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glProgramUniform2fv), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlProgramUniform2i(Uint64 sessionId, uint32_t program, int32_t location, int32_t v0, int32_t v1, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenProgramUniform2i(builder, program, location, v0, v1);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glProgramUniform2i), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlProgramUniform2i64ARB(Uint64 sessionId, uint32_t program, int32_t location, int64_t x, int64_t y, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenProgramUniform2i64ARB(builder, program, location, x, y);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glProgramUniform2i64ARB), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlProgramUniform2i64NV(Uint64 sessionId, uint32_t program, int32_t location, int64_t x, int64_t y, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenProgramUniform2i64NV(builder, program, location, x, y);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glProgramUniform2i64NV), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlProgramUniform2i64vARB(Uint64 sessionId, uint32_t program, int32_t location, int32_t count, const std::vector<int64_t>& value, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenProgramUniform2i64vARB(builder, program, location, count, builder.CreateVector(value));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glProgramUniform2i64vARB), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlProgramUniform2i64vNV(Uint64 sessionId, uint32_t program, int32_t location, int32_t count, const std::vector<int64_t>& value, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenProgramUniform2i64vNV(builder, program, location, count, builder.CreateVector(value));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glProgramUniform2i64vNV), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlProgramUniform2iv(Uint64 sessionId, uint32_t program, int32_t location, int32_t count, const std::vector<int32_t>& value, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenProgramUniform2iv(builder, program, location, count, builder.CreateVector(value));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glProgramUniform2iv), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlProgramUniform2ui(Uint64 sessionId, uint32_t program, int32_t location, uint32_t v0, uint32_t v1, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenProgramUniform2ui(builder, program, location, v0, v1);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glProgramUniform2ui), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlProgramUniform2ui64ARB(Uint64 sessionId, uint32_t program, int32_t location, uint64_t x, uint64_t y, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenProgramUniform2ui64ARB(builder, program, location, x, y);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glProgramUniform2ui64ARB), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlProgramUniform2ui64NV(Uint64 sessionId, uint32_t program, int32_t location, uint64_t x, uint64_t y, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenProgramUniform2ui64NV(builder, program, location, x, y);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glProgramUniform2ui64NV), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlProgramUniform2ui64vARB(Uint64 sessionId, uint32_t program, int32_t location, int32_t count, const std::vector<uint64_t>& value, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenProgramUniform2ui64vARB(builder, program, location, count, builder.CreateVector(value));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glProgramUniform2ui64vARB), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlProgramUniform2ui64vNV(Uint64 sessionId, uint32_t program, int32_t location, int32_t count, const std::vector<uint64_t>& value, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenProgramUniform2ui64vNV(builder, program, location, count, builder.CreateVector(value));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glProgramUniform2ui64vNV), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlProgramUniform2uiv(Uint64 sessionId, uint32_t program, int32_t location, int32_t count, const std::vector<uint32_t>& value, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenProgramUniform2uiv(builder, program, location, count, builder.CreateVector(value));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glProgramUniform2uiv), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlProgramUniform3d(Uint64 sessionId, uint32_t program, int32_t location, double v0, double v1, double v2, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenProgramUniform3d(builder, program, location, v0, v1, v2);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glProgramUniform3d), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlProgramUniform3dEXT(Uint64 sessionId, uint32_t program, int32_t location, double x, double y, double z, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenProgramUniform3dEXT(builder, program, location, x, y, z);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glProgramUniform3dEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlProgramUniform3dv(Uint64 sessionId, uint32_t program, int32_t location, int32_t count, const std::vector<double>& value, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenProgramUniform3dv(builder, program, location, count, builder.CreateVector(value));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glProgramUniform3dv), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlProgramUniform3dvEXT(Uint64 sessionId, uint32_t program, int32_t location, int32_t count, const std::vector<double>& value, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenProgramUniform3dvEXT(builder, program, location, count, builder.CreateVector(value));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glProgramUniform3dvEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlProgramUniform3f(Uint64 sessionId, uint32_t program, int32_t location, float v0, float v1, float v2, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenProgramUniform3f(builder, program, location, v0, v1, v2);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glProgramUniform3f), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlProgramUniform3fv(Uint64 sessionId, uint32_t program, int32_t location, int32_t count, const std::vector<float>& value, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenProgramUniform3fv(builder, program, location, count, builder.CreateVector(value));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glProgramUniform3fv), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlProgramUniform3i(Uint64 sessionId, uint32_t program, int32_t location, int32_t v0, int32_t v1, int32_t v2, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenProgramUniform3i(builder, program, location, v0, v1, v2);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glProgramUniform3i), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlProgramUniform3i64ARB(Uint64 sessionId, uint32_t program, int32_t location, int64_t x, int64_t y, int64_t z, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenProgramUniform3i64ARB(builder, program, location, x, y, z);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glProgramUniform3i64ARB), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlProgramUniform3i64NV(Uint64 sessionId, uint32_t program, int32_t location, int64_t x, int64_t y, int64_t z, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenProgramUniform3i64NV(builder, program, location, x, y, z);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glProgramUniform3i64NV), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlProgramUniform3i64vARB(Uint64 sessionId, uint32_t program, int32_t location, int32_t count, const std::vector<int64_t>& value, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenProgramUniform3i64vARB(builder, program, location, count, builder.CreateVector(value));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glProgramUniform3i64vARB), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlProgramUniform3i64vNV(Uint64 sessionId, uint32_t program, int32_t location, int32_t count, const std::vector<int64_t>& value, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenProgramUniform3i64vNV(builder, program, location, count, builder.CreateVector(value));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glProgramUniform3i64vNV), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlProgramUniform3iv(Uint64 sessionId, uint32_t program, int32_t location, int32_t count, const std::vector<int32_t>& value, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenProgramUniform3iv(builder, program, location, count, builder.CreateVector(value));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glProgramUniform3iv), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlProgramUniform3ui(Uint64 sessionId, uint32_t program, int32_t location, uint32_t v0, uint32_t v1, uint32_t v2, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenProgramUniform3ui(builder, program, location, v0, v1, v2);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glProgramUniform3ui), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlProgramUniform3ui64ARB(Uint64 sessionId, uint32_t program, int32_t location, uint64_t x, uint64_t y, uint64_t z, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenProgramUniform3ui64ARB(builder, program, location, x, y, z);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glProgramUniform3ui64ARB), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlProgramUniform3ui64NV(Uint64 sessionId, uint32_t program, int32_t location, uint64_t x, uint64_t y, uint64_t z, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenProgramUniform3ui64NV(builder, program, location, x, y, z);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glProgramUniform3ui64NV), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlProgramUniform3ui64vARB(Uint64 sessionId, uint32_t program, int32_t location, int32_t count, const std::vector<uint64_t>& value, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenProgramUniform3ui64vARB(builder, program, location, count, builder.CreateVector(value));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glProgramUniform3ui64vARB), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlProgramUniform3ui64vNV(Uint64 sessionId, uint32_t program, int32_t location, int32_t count, const std::vector<uint64_t>& value, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenProgramUniform3ui64vNV(builder, program, location, count, builder.CreateVector(value));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glProgramUniform3ui64vNV), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlProgramUniform3uiv(Uint64 sessionId, uint32_t program, int32_t location, int32_t count, const std::vector<uint32_t>& value, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenProgramUniform3uiv(builder, program, location, count, builder.CreateVector(value));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glProgramUniform3uiv), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlProgramUniform4d(Uint64 sessionId, uint32_t program, int32_t location, double v0, double v1, double v2, double v3, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenProgramUniform4d(builder, program, location, v0, v1, v2, v3);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glProgramUniform4d), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlProgramUniform4dEXT(Uint64 sessionId, uint32_t program, int32_t location, double x, double y, double z, double w, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenProgramUniform4dEXT(builder, program, location, x, y, z, w);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glProgramUniform4dEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlProgramUniform4dv(Uint64 sessionId, uint32_t program, int32_t location, int32_t count, const std::vector<double>& value, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenProgramUniform4dv(builder, program, location, count, builder.CreateVector(value));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glProgramUniform4dv), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlProgramUniform4dvEXT(Uint64 sessionId, uint32_t program, int32_t location, int32_t count, const std::vector<double>& value, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenProgramUniform4dvEXT(builder, program, location, count, builder.CreateVector(value));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glProgramUniform4dvEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlProgramUniform4f(Uint64 sessionId, uint32_t program, int32_t location, float v0, float v1, float v2, float v3, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenProgramUniform4f(builder, program, location, v0, v1, v2, v3);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glProgramUniform4f), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlProgramUniform4fv(Uint64 sessionId, uint32_t program, int32_t location, int32_t count, const std::vector<float>& value, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenProgramUniform4fv(builder, program, location, count, builder.CreateVector(value));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glProgramUniform4fv), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlProgramUniform4i(Uint64 sessionId, uint32_t program, int32_t location, int32_t v0, int32_t v1, int32_t v2, int32_t v3, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenProgramUniform4i(builder, program, location, v0, v1, v2, v3);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glProgramUniform4i), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlProgramUniform4i64ARB(Uint64 sessionId, uint32_t program, int32_t location, int64_t x, int64_t y, int64_t z, int64_t w, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenProgramUniform4i64ARB(builder, program, location, x, y, z, w);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glProgramUniform4i64ARB), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlProgramUniform4i64NV(Uint64 sessionId, uint32_t program, int32_t location, int64_t x, int64_t y, int64_t z, int64_t w, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenProgramUniform4i64NV(builder, program, location, x, y, z, w);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glProgramUniform4i64NV), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlProgramUniform4i64vARB(Uint64 sessionId, uint32_t program, int32_t location, int32_t count, const std::vector<int64_t>& value, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenProgramUniform4i64vARB(builder, program, location, count, builder.CreateVector(value));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glProgramUniform4i64vARB), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlProgramUniform4i64vNV(Uint64 sessionId, uint32_t program, int32_t location, int32_t count, const std::vector<int64_t>& value, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenProgramUniform4i64vNV(builder, program, location, count, builder.CreateVector(value));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glProgramUniform4i64vNV), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlProgramUniform4iv(Uint64 sessionId, uint32_t program, int32_t location, int32_t count, const std::vector<int32_t>& value, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenProgramUniform4iv(builder, program, location, count, builder.CreateVector(value));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glProgramUniform4iv), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlProgramUniform4ui(Uint64 sessionId, uint32_t program, int32_t location, uint32_t v0, uint32_t v1, uint32_t v2, uint32_t v3, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenProgramUniform4ui(builder, program, location, v0, v1, v2, v3);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glProgramUniform4ui), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlProgramUniform4ui64ARB(Uint64 sessionId, uint32_t program, int32_t location, uint64_t x, uint64_t y, uint64_t z, uint64_t w, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenProgramUniform4ui64ARB(builder, program, location, x, y, z, w);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glProgramUniform4ui64ARB), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlProgramUniform4ui64NV(Uint64 sessionId, uint32_t program, int32_t location, uint64_t x, uint64_t y, uint64_t z, uint64_t w, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenProgramUniform4ui64NV(builder, program, location, x, y, z, w);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glProgramUniform4ui64NV), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlProgramUniform4ui64vARB(Uint64 sessionId, uint32_t program, int32_t location, int32_t count, const std::vector<uint64_t>& value, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenProgramUniform4ui64vARB(builder, program, location, count, builder.CreateVector(value));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glProgramUniform4ui64vARB), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlProgramUniform4ui64vNV(Uint64 sessionId, uint32_t program, int32_t location, int32_t count, const std::vector<uint64_t>& value, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenProgramUniform4ui64vNV(builder, program, location, count, builder.CreateVector(value));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glProgramUniform4ui64vNV), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlProgramUniform4uiv(Uint64 sessionId, uint32_t program, int32_t location, int32_t count, const std::vector<uint32_t>& value, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenProgramUniform4uiv(builder, program, location, count, builder.CreateVector(value));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glProgramUniform4uiv), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlProgramUniformHandleui64ARB(Uint64 sessionId, uint32_t program, int32_t location, uint64_t value, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenProgramUniformHandleui64ARB(builder, program, location, value);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glProgramUniformHandleui64ARB), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlProgramUniformHandleui64NV(Uint64 sessionId, uint32_t program, int32_t location, uint64_t value, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenProgramUniformHandleui64NV(builder, program, location, value);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glProgramUniformHandleui64NV), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlProgramUniformHandleui64vARB(Uint64 sessionId, uint32_t program, int32_t location, int32_t count, const std::vector<uint64_t>& values, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenProgramUniformHandleui64vARB(builder, program, location, count, builder.CreateVector(values));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glProgramUniformHandleui64vARB), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlProgramUniformHandleui64vNV(Uint64 sessionId, uint32_t program, int32_t location, int32_t count, const std::vector<uint64_t>& values, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenProgramUniformHandleui64vNV(builder, program, location, count, builder.CreateVector(values));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glProgramUniformHandleui64vNV), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlProgramUniformMatrix2dv(Uint64 sessionId, uint32_t program, int32_t location, int32_t count, bool transpose, const std::vector<double>& value, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenProgramUniformMatrix2dv(builder, program, location, count, transpose, builder.CreateVector(value));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glProgramUniformMatrix2dv), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlProgramUniformMatrix2dvEXT(Uint64 sessionId, uint32_t program, int32_t location, int32_t count, bool transpose, const std::vector<double>& value, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenProgramUniformMatrix2dvEXT(builder, program, location, count, transpose, builder.CreateVector(value));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glProgramUniformMatrix2dvEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlProgramUniformMatrix2fv(Uint64 sessionId, uint32_t program, int32_t location, int32_t count, bool transpose, const std::vector<float>& value, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenProgramUniformMatrix2fv(builder, program, location, count, transpose, builder.CreateVector(value));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glProgramUniformMatrix2fv), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlProgramUniformMatrix2x3dv(Uint64 sessionId, uint32_t program, int32_t location, int32_t count, bool transpose, const std::vector<double>& value, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenProgramUniformMatrix2x3dv(builder, program, location, count, transpose, builder.CreateVector(value));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glProgramUniformMatrix2x3dv), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlProgramUniformMatrix2x3dvEXT(Uint64 sessionId, uint32_t program, int32_t location, int32_t count, bool transpose, const std::vector<double>& value, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenProgramUniformMatrix2x3dvEXT(builder, program, location, count, transpose, builder.CreateVector(value));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glProgramUniformMatrix2x3dvEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlProgramUniformMatrix2x3fv(Uint64 sessionId, uint32_t program, int32_t location, int32_t count, bool transpose, const std::vector<float>& value, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenProgramUniformMatrix2x3fv(builder, program, location, count, transpose, builder.CreateVector(value));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glProgramUniformMatrix2x3fv), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlProgramUniformMatrix2x4dv(Uint64 sessionId, uint32_t program, int32_t location, int32_t count, bool transpose, const std::vector<double>& value, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenProgramUniformMatrix2x4dv(builder, program, location, count, transpose, builder.CreateVector(value));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glProgramUniformMatrix2x4dv), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlProgramUniformMatrix2x4dvEXT(Uint64 sessionId, uint32_t program, int32_t location, int32_t count, bool transpose, const std::vector<double>& value, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenProgramUniformMatrix2x4dvEXT(builder, program, location, count, transpose, builder.CreateVector(value));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glProgramUniformMatrix2x4dvEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlProgramUniformMatrix2x4fv(Uint64 sessionId, uint32_t program, int32_t location, int32_t count, bool transpose, const std::vector<float>& value, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenProgramUniformMatrix2x4fv(builder, program, location, count, transpose, builder.CreateVector(value));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glProgramUniformMatrix2x4fv), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlProgramUniformMatrix3dv(Uint64 sessionId, uint32_t program, int32_t location, int32_t count, bool transpose, const std::vector<double>& value, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenProgramUniformMatrix3dv(builder, program, location, count, transpose, builder.CreateVector(value));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glProgramUniformMatrix3dv), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlProgramUniformMatrix3dvEXT(Uint64 sessionId, uint32_t program, int32_t location, int32_t count, bool transpose, const std::vector<double>& value, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenProgramUniformMatrix3dvEXT(builder, program, location, count, transpose, builder.CreateVector(value));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glProgramUniformMatrix3dvEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlProgramUniformMatrix3fv(Uint64 sessionId, uint32_t program, int32_t location, int32_t count, bool transpose, const std::vector<float>& value, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenProgramUniformMatrix3fv(builder, program, location, count, transpose, builder.CreateVector(value));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glProgramUniformMatrix3fv), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlProgramUniformMatrix3x2dv(Uint64 sessionId, uint32_t program, int32_t location, int32_t count, bool transpose, const std::vector<double>& value, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenProgramUniformMatrix3x2dv(builder, program, location, count, transpose, builder.CreateVector(value));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glProgramUniformMatrix3x2dv), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlProgramUniformMatrix3x2dvEXT(Uint64 sessionId, uint32_t program, int32_t location, int32_t count, bool transpose, const std::vector<double>& value, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenProgramUniformMatrix3x2dvEXT(builder, program, location, count, transpose, builder.CreateVector(value));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glProgramUniformMatrix3x2dvEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlProgramUniformMatrix3x2fv(Uint64 sessionId, uint32_t program, int32_t location, int32_t count, bool transpose, const std::vector<float>& value, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenProgramUniformMatrix3x2fv(builder, program, location, count, transpose, builder.CreateVector(value));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glProgramUniformMatrix3x2fv), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlProgramUniformMatrix3x4dv(Uint64 sessionId, uint32_t program, int32_t location, int32_t count, bool transpose, const std::vector<double>& value, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenProgramUniformMatrix3x4dv(builder, program, location, count, transpose, builder.CreateVector(value));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glProgramUniformMatrix3x4dv), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlProgramUniformMatrix3x4dvEXT(Uint64 sessionId, uint32_t program, int32_t location, int32_t count, bool transpose, const std::vector<double>& value, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenProgramUniformMatrix3x4dvEXT(builder, program, location, count, transpose, builder.CreateVector(value));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glProgramUniformMatrix3x4dvEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlProgramUniformMatrix3x4fv(Uint64 sessionId, uint32_t program, int32_t location, int32_t count, bool transpose, const std::vector<float>& value, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenProgramUniformMatrix3x4fv(builder, program, location, count, transpose, builder.CreateVector(value));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glProgramUniformMatrix3x4fv), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlProgramUniformMatrix4dv(Uint64 sessionId, uint32_t program, int32_t location, int32_t count, bool transpose, const std::vector<double>& value, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenProgramUniformMatrix4dv(builder, program, location, count, transpose, builder.CreateVector(value));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glProgramUniformMatrix4dv), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlProgramUniformMatrix4dvEXT(Uint64 sessionId, uint32_t program, int32_t location, int32_t count, bool transpose, const std::vector<double>& value, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenProgramUniformMatrix4dvEXT(builder, program, location, count, transpose, builder.CreateVector(value));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glProgramUniformMatrix4dvEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlProgramUniformMatrix4fv(Uint64 sessionId, uint32_t program, int32_t location, int32_t count, bool transpose, const std::vector<float>& value, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenProgramUniformMatrix4fv(builder, program, location, count, transpose, builder.CreateVector(value));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glProgramUniformMatrix4fv), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlProgramUniformMatrix4x2dv(Uint64 sessionId, uint32_t program, int32_t location, int32_t count, bool transpose, const std::vector<double>& value, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenProgramUniformMatrix4x2dv(builder, program, location, count, transpose, builder.CreateVector(value));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glProgramUniformMatrix4x2dv), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlProgramUniformMatrix4x2dvEXT(Uint64 sessionId, uint32_t program, int32_t location, int32_t count, bool transpose, const std::vector<double>& value, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenProgramUniformMatrix4x2dvEXT(builder, program, location, count, transpose, builder.CreateVector(value));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glProgramUniformMatrix4x2dvEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlProgramUniformMatrix4x2fv(Uint64 sessionId, uint32_t program, int32_t location, int32_t count, bool transpose, const std::vector<float>& value, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenProgramUniformMatrix4x2fv(builder, program, location, count, transpose, builder.CreateVector(value));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glProgramUniformMatrix4x2fv), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlProgramUniformMatrix4x3dv(Uint64 sessionId, uint32_t program, int32_t location, int32_t count, bool transpose, const std::vector<double>& value, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenProgramUniformMatrix4x3dv(builder, program, location, count, transpose, builder.CreateVector(value));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glProgramUniformMatrix4x3dv), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlProgramUniformMatrix4x3dvEXT(Uint64 sessionId, uint32_t program, int32_t location, int32_t count, bool transpose, const std::vector<double>& value, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenProgramUniformMatrix4x3dvEXT(builder, program, location, count, transpose, builder.CreateVector(value));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glProgramUniformMatrix4x3dvEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlProgramUniformMatrix4x3fv(Uint64 sessionId, uint32_t program, int32_t location, int32_t count, bool transpose, const std::vector<float>& value, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenProgramUniformMatrix4x3fv(builder, program, location, count, transpose, builder.CreateVector(value));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glProgramUniformMatrix4x3fv), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlProgramUniformui64NV(Uint64 sessionId, uint32_t program, int32_t location, uint64_t value, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenProgramUniformui64NV(builder, program, location, value);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glProgramUniformui64NV), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlProgramUniformui64vNV(Uint64 sessionId, uint32_t program, int32_t location, int32_t count, const std::vector<uint64_t>& value, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenProgramUniformui64vNV(builder, program, location, count, builder.CreateVector(value));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glProgramUniformui64vNV), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlProvokingVertex(Uint64 sessionId, uint32_t mode, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenProvokingVertex(builder, mode);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glProvokingVertex), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlPushClientAttribDefaultEXT(Uint64 sessionId, uint32_t mask, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenPushClientAttribDefaultEXT(builder, mask);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glPushClientAttribDefaultEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlPushDebugGroup(Uint64 sessionId, uint32_t source, uint32_t id, int32_t length, const char* message, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenPushDebugGroup(builder, source, id, length, builder.CreateString(message));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glPushDebugGroup), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlPushGroupMarkerEXT(Uint64 sessionId, int32_t length, const char* marker, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenPushGroupMarkerEXT(builder, length, builder.CreateString(marker));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glPushGroupMarkerEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlQueryCounter(Uint64 sessionId, uint32_t id, uint32_t target, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenQueryCounter(builder, id, target);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glQueryCounter), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlRasterSamplesEXT(Uint64 sessionId, uint32_t samples, bool fixedsamplelocations, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenRasterSamplesEXT(builder, samples, fixedsamplelocations);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glRasterSamplesEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlReadBuffer(Uint64 sessionId, uint32_t src, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenReadBuffer(builder, src);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glReadBuffer), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlReadPixels(Uint64 sessionId, int32_t x, int32_t y, int32_t width, int32_t height, uint32_t format, uint32_t type, Uint64 token, MobileGLShmHandle* shm) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenReadPixels(builder, x, y, width, height, format, type, MobileGL::Protocol::WireFull::CreateShmRegion(builder, 0, shm == nullptr ? 0 : shm->size));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glReadPixels), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlReadnPixels(Uint64 sessionId, int32_t x, int32_t y, int32_t width, int32_t height, uint32_t format, uint32_t type, int32_t bufSize, Uint64 token, MobileGLShmHandle* shm) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenReadnPixels(builder, x, y, width, height, format, type, bufSize, MobileGL::Protocol::WireFull::CreateShmRegion(builder, 0, shm == nullptr ? 0 : shm->size));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glReadnPixels), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlRenderbufferStorage(Uint64 sessionId, uint32_t target, uint32_t internalformat, int32_t width, int32_t height, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenRenderbufferStorage(builder, target, internalformat, width, height);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glRenderbufferStorage), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlRenderbufferStorageMultisample(Uint64 sessionId, uint32_t target, int32_t samples, uint32_t internalformat, int32_t width, int32_t height, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenRenderbufferStorageMultisample(builder, target, samples, internalformat, width, height);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glRenderbufferStorageMultisample), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlRenderbufferStorageMultisampleAdvancedAMD(Uint64 sessionId, uint32_t target, int32_t samples, int32_t storageSamples, uint32_t internalformat, int32_t width, int32_t height, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenRenderbufferStorageMultisampleAdvancedAMD(builder, target, samples, storageSamples, internalformat, width, height);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glRenderbufferStorageMultisampleAdvancedAMD), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlRenderbufferStorageMultisampleCoverageNV(Uint64 sessionId, uint32_t target, int32_t coverageSamples, int32_t colorSamples, uint32_t internalformat, int32_t width, int32_t height, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenRenderbufferStorageMultisampleCoverageNV(builder, target, coverageSamples, colorSamples, internalformat, width, height);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glRenderbufferStorageMultisampleCoverageNV), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlResetMemoryObjectParameterNV(Uint64 sessionId, uint32_t memory, uint32_t pname, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenResetMemoryObjectParameterNV(builder, memory, pname);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glResetMemoryObjectParameterNV), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlSampleCoverage(Uint64 sessionId, float value, bool invert, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenSampleCoverage(builder, value, invert);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glSampleCoverage), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlSampleMaski(Uint64 sessionId, uint32_t maskNumber, uint32_t mask, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenSampleMaski(builder, maskNumber, mask);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glSampleMaski), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlSamplerParameterIiv(Uint64 sessionId, uint32_t sampler, uint32_t pname, const std::vector<int32_t>& param, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenSamplerParameterIiv(builder, sampler, pname, builder.CreateVector(param));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glSamplerParameterIiv), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlSamplerParameterIuiv(Uint64 sessionId, uint32_t sampler, uint32_t pname, const std::vector<uint32_t>& param, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenSamplerParameterIuiv(builder, sampler, pname, builder.CreateVector(param));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glSamplerParameterIuiv), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlSamplerParameterf(Uint64 sessionId, uint32_t sampler, uint32_t pname, float param, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenSamplerParameterf(builder, sampler, pname, param);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glSamplerParameterf), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlSamplerParameterfv(Uint64 sessionId, uint32_t sampler, uint32_t pname, const std::vector<float>& param, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenSamplerParameterfv(builder, sampler, pname, builder.CreateVector(param));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glSamplerParameterfv), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlSamplerParameteri(Uint64 sessionId, uint32_t sampler, uint32_t pname, int32_t param, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenSamplerParameteri(builder, sampler, pname, param);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glSamplerParameteri), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlSamplerParameteriv(Uint64 sessionId, uint32_t sampler, uint32_t pname, const std::vector<int32_t>& param, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenSamplerParameteriv(builder, sampler, pname, builder.CreateVector(param));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glSamplerParameteriv), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlScissor(Uint64 sessionId, int32_t x, int32_t y, int32_t width, int32_t height, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenScissor(builder, x, y, width, height);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glScissor), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlScissorArrayv(Uint64 sessionId, uint32_t first, int32_t count, const std::vector<int32_t>& v, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenScissorArrayv(builder, first, count, builder.CreateVector(v));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glScissorArrayv), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlScissorExclusiveArrayvNV(Uint64 sessionId, uint32_t first, int32_t count, const std::vector<int32_t>& v, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenScissorExclusiveArrayvNV(builder, first, count, builder.CreateVector(v));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glScissorExclusiveArrayvNV), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlScissorExclusiveNV(Uint64 sessionId, int32_t x, int32_t y, int32_t width, int32_t height, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenScissorExclusiveNV(builder, x, y, width, height);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glScissorExclusiveNV), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlScissorIndexed(Uint64 sessionId, uint32_t index, int32_t left, int32_t bottom, int32_t width, int32_t height, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenScissorIndexed(builder, index, left, bottom, width, height);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glScissorIndexed), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlScissorIndexedv(Uint64 sessionId, uint32_t index, const std::vector<int32_t>& v, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenScissorIndexedv(builder, index, builder.CreateVector(v));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glScissorIndexedv), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlSecondaryColorFormatNV(Uint64 sessionId, int32_t size, uint32_t type, int32_t stride, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenSecondaryColorFormatNV(builder, size, type, stride);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glSecondaryColorFormatNV), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlSelectPerfMonitorCountersAMD(Uint64 sessionId, uint32_t monitor, bool enable, uint32_t group, int32_t numCounters, Uint64 token, MobileGLShmHandle* shm = nullptr, Uint32 outCapacity = 0) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenSelectPerfMonitorCountersAMD(builder, monitor, enable, group, numCounters, 0);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glSelectPerfMonitorCountersAMD), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm, outCapacity);
}
inline Bool SendGlShaderBinary(Uint64 sessionId, int32_t count, const std::vector<uint32_t>& shaders, uint32_t binaryformat, int32_t length, Uint64 token, MobileGLShmHandle* shm) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenShaderBinary(builder, count, builder.CreateVector(shaders), binaryformat, MobileGL::Protocol::WireFull::CreateShmRegion(builder, 0, shm == nullptr ? 0 : shm->size), length);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glShaderBinary), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlShaderStorageBlockBinding(Uint64 sessionId, uint32_t program, uint32_t storageBlockIndex, uint32_t storageBlockBinding, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenShaderStorageBlockBinding(builder, program, storageBlockIndex, storageBlockBinding);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glShaderStorageBlockBinding), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlShadingRateImageBarrierNV(Uint64 sessionId, bool synchronize, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenShadingRateImageBarrierNV(builder, synchronize);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glShadingRateImageBarrierNV), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlShadingRateImagePaletteNV(Uint64 sessionId, uint32_t viewport, uint32_t first, int32_t count, const std::vector<uint32_t>& rates, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenShadingRateImagePaletteNV(builder, viewport, first, count, builder.CreateVector(rates));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glShadingRateImagePaletteNV), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlShadingRateSampleOrderCustomNV(Uint64 sessionId, uint32_t rate, uint32_t samples, const std::vector<int32_t>& locations, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenShadingRateSampleOrderCustomNV(builder, rate, samples, builder.CreateVector(locations));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glShadingRateSampleOrderCustomNV), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlShadingRateSampleOrderNV(Uint64 sessionId, uint32_t order, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenShadingRateSampleOrderNV(builder, order);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glShadingRateSampleOrderNV), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlSignalVkFenceNV(Uint64 sessionId, uint64_t vkFence, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenSignalVkFenceNV(builder, vkFence);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glSignalVkFenceNV), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlSignalVkSemaphoreNV(Uint64 sessionId, uint64_t vkSemaphore, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenSignalVkSemaphoreNV(builder, vkSemaphore);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glSignalVkSemaphoreNV), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlSpecializeShader(Uint64 sessionId, uint32_t shader, const char* pEntryPoint, uint32_t numSpecializationConstants, const std::vector<uint32_t>& pConstantIndex, const std::vector<uint32_t>& pConstantValue, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenSpecializeShader(builder, shader, builder.CreateString(pEntryPoint), numSpecializationConstants, builder.CreateVector(pConstantIndex), builder.CreateVector(pConstantValue));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glSpecializeShader), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlSpecializeShaderARB(Uint64 sessionId, uint32_t shader, const char* pEntryPoint, uint32_t numSpecializationConstants, const std::vector<uint32_t>& pConstantIndex, const std::vector<uint32_t>& pConstantValue, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenSpecializeShaderARB(builder, shader, builder.CreateString(pEntryPoint), numSpecializationConstants, builder.CreateVector(pConstantIndex), builder.CreateVector(pConstantValue));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glSpecializeShaderARB), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlStateCaptureNV(Uint64 sessionId, uint32_t state, uint32_t mode, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenStateCaptureNV(builder, state, mode);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glStateCaptureNV), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlStencilFillPathInstancedNV(Uint64 sessionId, int32_t numPaths, uint32_t pathNameType, uint32_t pathBase, uint32_t fillMode, uint32_t mask, uint32_t transformType, const std::vector<float>& transformValues, Uint64 token, MobileGLShmHandle* shm) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenStencilFillPathInstancedNV(builder, numPaths, pathNameType, MobileGL::Protocol::WireFull::CreateShmRegion(builder, 0, shm == nullptr ? 0 : shm->size), pathBase, fillMode, mask, transformType, builder.CreateVector(transformValues));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glStencilFillPathInstancedNV), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlStencilFillPathNV(Uint64 sessionId, uint32_t path, uint32_t fillMode, uint32_t mask, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenStencilFillPathNV(builder, path, fillMode, mask);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glStencilFillPathNV), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlStencilFunc(Uint64 sessionId, uint32_t func, int32_t ref, uint32_t mask, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenStencilFunc(builder, func, ref, mask);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glStencilFunc), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlStencilFuncSeparate(Uint64 sessionId, uint32_t face, uint32_t func, int32_t ref, uint32_t mask, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenStencilFuncSeparate(builder, face, func, ref, mask);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glStencilFuncSeparate), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlStencilMask(Uint64 sessionId, uint32_t mask, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenStencilMask(builder, mask);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glStencilMask), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlStencilMaskSeparate(Uint64 sessionId, uint32_t face, uint32_t mask, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenStencilMaskSeparate(builder, face, mask);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glStencilMaskSeparate), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlStencilOp(Uint64 sessionId, uint32_t fail, uint32_t zfail, uint32_t zpass, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenStencilOp(builder, fail, zfail, zpass);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glStencilOp), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlStencilOpSeparate(Uint64 sessionId, uint32_t face, uint32_t sfail, uint32_t dpfail, uint32_t dppass, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenStencilOpSeparate(builder, face, sfail, dpfail, dppass);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glStencilOpSeparate), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlStencilStrokePathInstancedNV(Uint64 sessionId, int32_t numPaths, uint32_t pathNameType, uint32_t pathBase, int32_t reference, uint32_t mask, uint32_t transformType, const std::vector<float>& transformValues, Uint64 token, MobileGLShmHandle* shm) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenStencilStrokePathInstancedNV(builder, numPaths, pathNameType, MobileGL::Protocol::WireFull::CreateShmRegion(builder, 0, shm == nullptr ? 0 : shm->size), pathBase, reference, mask, transformType, builder.CreateVector(transformValues));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glStencilStrokePathInstancedNV), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlStencilStrokePathNV(Uint64 sessionId, uint32_t path, int32_t reference, uint32_t mask, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenStencilStrokePathNV(builder, path, reference, mask);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glStencilStrokePathNV), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlStencilThenCoverFillPathInstancedNV(Uint64 sessionId, int32_t numPaths, uint32_t pathNameType, uint32_t pathBase, uint32_t fillMode, uint32_t mask, uint32_t coverMode, uint32_t transformType, const std::vector<float>& transformValues, Uint64 token, MobileGLShmHandle* shm) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenStencilThenCoverFillPathInstancedNV(builder, numPaths, pathNameType, MobileGL::Protocol::WireFull::CreateShmRegion(builder, 0, shm == nullptr ? 0 : shm->size), pathBase, fillMode, mask, coverMode, transformType, builder.CreateVector(transformValues));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glStencilThenCoverFillPathInstancedNV), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlStencilThenCoverFillPathNV(Uint64 sessionId, uint32_t path, uint32_t fillMode, uint32_t mask, uint32_t coverMode, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenStencilThenCoverFillPathNV(builder, path, fillMode, mask, coverMode);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glStencilThenCoverFillPathNV), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlStencilThenCoverStrokePathInstancedNV(Uint64 sessionId, int32_t numPaths, uint32_t pathNameType, uint32_t pathBase, int32_t reference, uint32_t mask, uint32_t coverMode, uint32_t transformType, const std::vector<float>& transformValues, Uint64 token, MobileGLShmHandle* shm) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenStencilThenCoverStrokePathInstancedNV(builder, numPaths, pathNameType, MobileGL::Protocol::WireFull::CreateShmRegion(builder, 0, shm == nullptr ? 0 : shm->size), pathBase, reference, mask, coverMode, transformType, builder.CreateVector(transformValues));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glStencilThenCoverStrokePathInstancedNV), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlStencilThenCoverStrokePathNV(Uint64 sessionId, uint32_t path, int32_t reference, uint32_t mask, uint32_t coverMode, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenStencilThenCoverStrokePathNV(builder, path, reference, mask, coverMode);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glStencilThenCoverStrokePathNV), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlSubpixelPrecisionBiasNV(Uint64 sessionId, uint32_t xbits, uint32_t ybits, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenSubpixelPrecisionBiasNV(builder, xbits, ybits);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glSubpixelPrecisionBiasNV), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlTexAttachMemoryNV(Uint64 sessionId, uint32_t target, uint32_t memory, uint64_t offset, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenTexAttachMemoryNV(builder, target, memory, offset);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glTexAttachMemoryNV), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlTexBuffer(Uint64 sessionId, uint32_t target, uint32_t internalformat, uint32_t buffer, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenTexBuffer(builder, target, internalformat, buffer);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glTexBuffer), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlTexBufferRange(Uint64 sessionId, uint32_t target, uint32_t internalformat, uint32_t buffer, int64_t offset, uint64_t size, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenTexBufferRange(builder, target, internalformat, buffer, offset, size);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glTexBufferRange), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlTexCoordFormatNV(Uint64 sessionId, int32_t size, uint32_t type, int32_t stride, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenTexCoordFormatNV(builder, size, type, stride);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glTexCoordFormatNV), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlTexImage1D(Uint64 sessionId, uint32_t target, int32_t level, int32_t internalFormat, int32_t width, int32_t border, uint32_t format, uint32_t type, Uint64 token, MobileGLShmHandle* shm) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenTexImage1D(builder, target, level, internalFormat, width, border, format, type, MobileGL::Protocol::WireFull::CreateShmRegion(builder, 0, shm == nullptr ? 0 : shm->size));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glTexImage1D), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlTexImage2D(Uint64 sessionId, uint32_t target, int32_t level, int32_t internalformat, int32_t width, int32_t height, int32_t border, uint32_t format, uint32_t type, Uint64 token, MobileGLShmHandle* shm) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenTexImage2D(builder, target, level, internalformat, width, height, border, format, type, MobileGL::Protocol::WireFull::CreateShmRegion(builder, 0, shm == nullptr ? 0 : shm->size));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glTexImage2D), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlTexImage2DMultisample(Uint64 sessionId, uint32_t target, int32_t samples, uint32_t internalformat, int32_t width, int32_t height, bool fixedsamplelocations, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenTexImage2DMultisample(builder, target, samples, internalformat, width, height, fixedsamplelocations);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glTexImage2DMultisample), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlTexImage3D(Uint64 sessionId, uint32_t target, int32_t level, int32_t internalformat, int32_t width, int32_t height, int32_t depth, int32_t border, uint32_t format, uint32_t type, Uint64 token, MobileGLShmHandle* shm) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenTexImage3D(builder, target, level, internalformat, width, height, depth, border, format, type, MobileGL::Protocol::WireFull::CreateShmRegion(builder, 0, shm == nullptr ? 0 : shm->size));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glTexImage3D), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlTexImage3DMultisample(Uint64 sessionId, uint32_t target, int32_t samples, uint32_t internalformat, int32_t width, int32_t height, int32_t depth, bool fixedsamplelocations, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenTexImage3DMultisample(builder, target, samples, internalformat, width, height, depth, fixedsamplelocations);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glTexImage3DMultisample), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlTexPageCommitmentARB(Uint64 sessionId, uint32_t target, int32_t level, int32_t xoffset, int32_t yoffset, int32_t zoffset, int32_t width, int32_t height, int32_t depth, bool commit, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenTexPageCommitmentARB(builder, target, level, xoffset, yoffset, zoffset, width, height, depth, commit);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glTexPageCommitmentARB), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlTexPageCommitmentMemNV(Uint64 sessionId, uint32_t target, int32_t layer, int32_t level, int32_t xoffset, int32_t yoffset, int32_t zoffset, int32_t width, int32_t height, int32_t depth, uint32_t memory, uint64_t offset, bool commit, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenTexPageCommitmentMemNV(builder, target, layer, level, xoffset, yoffset, zoffset, width, height, depth, memory, offset, commit);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glTexPageCommitmentMemNV), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlTexParameterIiv(Uint64 sessionId, uint32_t target, uint32_t pname, const std::vector<int32_t>& params, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenTexParameterIiv(builder, target, pname, builder.CreateVector(params));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glTexParameterIiv), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlTexParameterIuiv(Uint64 sessionId, uint32_t target, uint32_t pname, const std::vector<uint32_t>& params, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenTexParameterIuiv(builder, target, pname, builder.CreateVector(params));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glTexParameterIuiv), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlTexParameterf(Uint64 sessionId, uint32_t target, uint32_t pname, float param, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenTexParameterf(builder, target, pname, param);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glTexParameterf), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlTexParameterfv(Uint64 sessionId, uint32_t target, uint32_t pname, const std::vector<float>& params, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenTexParameterfv(builder, target, pname, builder.CreateVector(params));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glTexParameterfv), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlTexParameteri(Uint64 sessionId, uint32_t target, uint32_t pname, int32_t param, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenTexParameteri(builder, target, pname, param);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glTexParameteri), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlTexParameteriv(Uint64 sessionId, uint32_t target, uint32_t pname, const std::vector<int32_t>& params, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenTexParameteriv(builder, target, pname, builder.CreateVector(params));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glTexParameteriv), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlTexStorage1DEXT(Uint64 sessionId, uint32_t target, int32_t levels, uint32_t internalformat, int32_t width, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenTexStorage1DEXT(builder, target, levels, internalformat, width);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glTexStorage1DEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlTexStorage2D(Uint64 sessionId, uint32_t target, int32_t levels, uint32_t internalformat, int32_t width, int32_t height, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenTexStorage2D(builder, target, levels, internalformat, width, height);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glTexStorage2D), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlTexStorage2DMultisample(Uint64 sessionId, uint32_t target, int32_t samples, uint32_t internalformat, int32_t width, int32_t height, bool fixedsamplelocations, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenTexStorage2DMultisample(builder, target, samples, internalformat, width, height, fixedsamplelocations);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glTexStorage2DMultisample), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlTexStorage3D(Uint64 sessionId, uint32_t target, int32_t levels, uint32_t internalformat, int32_t width, int32_t height, int32_t depth, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenTexStorage3D(builder, target, levels, internalformat, width, height, depth);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glTexStorage3D), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlTexStorage3DMultisample(Uint64 sessionId, uint32_t target, int32_t samples, uint32_t internalformat, int32_t width, int32_t height, int32_t depth, bool fixedsamplelocations, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenTexStorage3DMultisample(builder, target, samples, internalformat, width, height, depth, fixedsamplelocations);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glTexStorage3DMultisample), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlTexSubImage1D(Uint64 sessionId, uint32_t target, int32_t level, int32_t xoffset, int32_t width, uint32_t format, uint32_t type, Uint64 token, MobileGLShmHandle* shm) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenTexSubImage1D(builder, target, level, xoffset, width, format, type, MobileGL::Protocol::WireFull::CreateShmRegion(builder, 0, shm == nullptr ? 0 : shm->size));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glTexSubImage1D), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlTexSubImage2D(Uint64 sessionId, uint32_t target, int32_t level, int32_t xoffset, int32_t yoffset, int32_t width, int32_t height, uint32_t format, uint32_t type, Uint64 token, MobileGLShmHandle* shm) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenTexSubImage2D(builder, target, level, xoffset, yoffset, width, height, format, type, MobileGL::Protocol::WireFull::CreateShmRegion(builder, 0, shm == nullptr ? 0 : shm->size));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glTexSubImage2D), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlTexSubImage3D(Uint64 sessionId, uint32_t target, int32_t level, int32_t xoffset, int32_t yoffset, int32_t zoffset, int32_t width, int32_t height, int32_t depth, uint32_t format, uint32_t type, Uint64 token, MobileGLShmHandle* shm) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenTexSubImage3D(builder, target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, MobileGL::Protocol::WireFull::CreateShmRegion(builder, 0, shm == nullptr ? 0 : shm->size));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glTexSubImage3D), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlTextureAttachMemoryNV(Uint64 sessionId, uint32_t texture, uint32_t memory, uint64_t offset, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenTextureAttachMemoryNV(builder, texture, memory, offset);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glTextureAttachMemoryNV), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlTextureBuffer(Uint64 sessionId, uint32_t texture, uint32_t internalformat, uint32_t buffer, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenTextureBuffer(builder, texture, internalformat, buffer);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glTextureBuffer), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlTextureBufferEXT(Uint64 sessionId, uint32_t texture, uint32_t target, uint32_t internalformat, uint32_t buffer, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenTextureBufferEXT(builder, texture, target, internalformat, buffer);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glTextureBufferEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlTextureBufferRange(Uint64 sessionId, uint32_t texture, uint32_t internalformat, uint32_t buffer, int64_t offset, uint64_t size, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenTextureBufferRange(builder, texture, internalformat, buffer, offset, size);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glTextureBufferRange), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlTextureBufferRangeEXT(Uint64 sessionId, uint32_t texture, uint32_t target, uint32_t internalformat, uint32_t buffer, int64_t offset, uint64_t size, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenTextureBufferRangeEXT(builder, texture, target, internalformat, buffer, offset, size);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glTextureBufferRangeEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlTextureImage1DEXT(Uint64 sessionId, uint32_t texture, uint32_t target, int32_t level, int32_t internalformat, int32_t width, int32_t border, uint32_t format, uint32_t type, Uint64 token, MobileGLShmHandle* shm) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenTextureImage1DEXT(builder, texture, target, level, internalformat, width, border, format, type, MobileGL::Protocol::WireFull::CreateShmRegion(builder, 0, shm == nullptr ? 0 : shm->size));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glTextureImage1DEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlTextureImage2DEXT(Uint64 sessionId, uint32_t texture, uint32_t target, int32_t level, int32_t internalformat, int32_t width, int32_t height, int32_t border, uint32_t format, uint32_t type, Uint64 token, MobileGLShmHandle* shm) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenTextureImage2DEXT(builder, texture, target, level, internalformat, width, height, border, format, type, MobileGL::Protocol::WireFull::CreateShmRegion(builder, 0, shm == nullptr ? 0 : shm->size));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glTextureImage2DEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlTextureImage3DEXT(Uint64 sessionId, uint32_t texture, uint32_t target, int32_t level, int32_t internalformat, int32_t width, int32_t height, int32_t depth, int32_t border, uint32_t format, uint32_t type, Uint64 token, MobileGLShmHandle* shm) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenTextureImage3DEXT(builder, texture, target, level, internalformat, width, height, depth, border, format, type, MobileGL::Protocol::WireFull::CreateShmRegion(builder, 0, shm == nullptr ? 0 : shm->size));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glTextureImage3DEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlTexturePageCommitmentEXT(Uint64 sessionId, uint32_t texture, int32_t level, int32_t xoffset, int32_t yoffset, int32_t zoffset, int32_t width, int32_t height, int32_t depth, bool commit, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenTexturePageCommitmentEXT(builder, texture, level, xoffset, yoffset, zoffset, width, height, depth, commit);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glTexturePageCommitmentEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlTexturePageCommitmentMemNV(Uint64 sessionId, uint32_t texture, int32_t layer, int32_t level, int32_t xoffset, int32_t yoffset, int32_t zoffset, int32_t width, int32_t height, int32_t depth, uint32_t memory, uint64_t offset, bool commit, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenTexturePageCommitmentMemNV(builder, texture, layer, level, xoffset, yoffset, zoffset, width, height, depth, memory, offset, commit);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glTexturePageCommitmentMemNV), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlTextureParameterIiv(Uint64 sessionId, uint32_t texture, uint32_t pname, const std::vector<int32_t>& params, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenTextureParameterIiv(builder, texture, pname, builder.CreateVector(params));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glTextureParameterIiv), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlTextureParameterIivEXT(Uint64 sessionId, uint32_t texture, uint32_t target, uint32_t pname, const std::vector<int32_t>& params, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenTextureParameterIivEXT(builder, texture, target, pname, builder.CreateVector(params));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glTextureParameterIivEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlTextureParameterIuiv(Uint64 sessionId, uint32_t texture, uint32_t pname, const std::vector<uint32_t>& params, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenTextureParameterIuiv(builder, texture, pname, builder.CreateVector(params));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glTextureParameterIuiv), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlTextureParameterIuivEXT(Uint64 sessionId, uint32_t texture, uint32_t target, uint32_t pname, const std::vector<uint32_t>& params, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenTextureParameterIuivEXT(builder, texture, target, pname, builder.CreateVector(params));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glTextureParameterIuivEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlTextureParameterf(Uint64 sessionId, uint32_t texture, uint32_t pname, float param, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenTextureParameterf(builder, texture, pname, param);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glTextureParameterf), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlTextureParameterfEXT(Uint64 sessionId, uint32_t texture, uint32_t target, uint32_t pname, float param, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenTextureParameterfEXT(builder, texture, target, pname, param);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glTextureParameterfEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlTextureParameterfv(Uint64 sessionId, uint32_t texture, uint32_t pname, const std::vector<float>& param, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenTextureParameterfv(builder, texture, pname, builder.CreateVector(param));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glTextureParameterfv), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlTextureParameterfvEXT(Uint64 sessionId, uint32_t texture, uint32_t target, uint32_t pname, const std::vector<float>& params, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenTextureParameterfvEXT(builder, texture, target, pname, builder.CreateVector(params));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glTextureParameterfvEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlTextureParameteri(Uint64 sessionId, uint32_t texture, uint32_t pname, int32_t param, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenTextureParameteri(builder, texture, pname, param);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glTextureParameteri), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlTextureParameteriEXT(Uint64 sessionId, uint32_t texture, uint32_t target, uint32_t pname, int32_t param, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenTextureParameteriEXT(builder, texture, target, pname, param);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glTextureParameteriEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlTextureParameteriv(Uint64 sessionId, uint32_t texture, uint32_t pname, const std::vector<int32_t>& param, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenTextureParameteriv(builder, texture, pname, builder.CreateVector(param));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glTextureParameteriv), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlTextureParameterivEXT(Uint64 sessionId, uint32_t texture, uint32_t target, uint32_t pname, const std::vector<int32_t>& params, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenTextureParameterivEXT(builder, texture, target, pname, builder.CreateVector(params));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glTextureParameterivEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlTextureRenderbufferEXT(Uint64 sessionId, uint32_t texture, uint32_t target, uint32_t renderbuffer, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenTextureRenderbufferEXT(builder, texture, target, renderbuffer);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glTextureRenderbufferEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlTextureStorage1D(Uint64 sessionId, uint32_t texture, int32_t levels, uint32_t internalformat, int32_t width, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenTextureStorage1D(builder, texture, levels, internalformat, width);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glTextureStorage1D), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlTextureStorage1DEXT(Uint64 sessionId, uint32_t texture, uint32_t target, int32_t levels, uint32_t internalformat, int32_t width, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenTextureStorage1DEXT(builder, texture, target, levels, internalformat, width);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glTextureStorage1DEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlTextureStorage2D(Uint64 sessionId, uint32_t texture, int32_t levels, uint32_t internalformat, int32_t width, int32_t height, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenTextureStorage2D(builder, texture, levels, internalformat, width, height);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glTextureStorage2D), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlTextureStorage2DEXT(Uint64 sessionId, uint32_t texture, uint32_t target, int32_t levels, uint32_t internalformat, int32_t width, int32_t height, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenTextureStorage2DEXT(builder, texture, target, levels, internalformat, width, height);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glTextureStorage2DEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlTextureStorage2DMultisample(Uint64 sessionId, uint32_t texture, int32_t samples, uint32_t internalformat, int32_t width, int32_t height, bool fixedsamplelocations, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenTextureStorage2DMultisample(builder, texture, samples, internalformat, width, height, fixedsamplelocations);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glTextureStorage2DMultisample), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlTextureStorage2DMultisampleEXT(Uint64 sessionId, uint32_t texture, uint32_t target, int32_t samples, uint32_t internalformat, int32_t width, int32_t height, bool fixedsamplelocations, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenTextureStorage2DMultisampleEXT(builder, texture, target, samples, internalformat, width, height, fixedsamplelocations);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glTextureStorage2DMultisampleEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlTextureStorage3D(Uint64 sessionId, uint32_t texture, int32_t levels, uint32_t internalformat, int32_t width, int32_t height, int32_t depth, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenTextureStorage3D(builder, texture, levels, internalformat, width, height, depth);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glTextureStorage3D), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlTextureStorage3DEXT(Uint64 sessionId, uint32_t texture, uint32_t target, int32_t levels, uint32_t internalformat, int32_t width, int32_t height, int32_t depth, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenTextureStorage3DEXT(builder, texture, target, levels, internalformat, width, height, depth);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glTextureStorage3DEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlTextureStorage3DMultisample(Uint64 sessionId, uint32_t texture, int32_t samples, uint32_t internalformat, int32_t width, int32_t height, int32_t depth, bool fixedsamplelocations, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenTextureStorage3DMultisample(builder, texture, samples, internalformat, width, height, depth, fixedsamplelocations);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glTextureStorage3DMultisample), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlTextureStorage3DMultisampleEXT(Uint64 sessionId, uint32_t texture, uint32_t target, int32_t samples, uint32_t internalformat, int32_t width, int32_t height, int32_t depth, bool fixedsamplelocations, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenTextureStorage3DMultisampleEXT(builder, texture, target, samples, internalformat, width, height, depth, fixedsamplelocations);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glTextureStorage3DMultisampleEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlTextureSubImage1D(Uint64 sessionId, uint32_t texture, int32_t level, int32_t xoffset, int32_t width, uint32_t format, uint32_t type, Uint64 token, MobileGLShmHandle* shm) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenTextureSubImage1D(builder, texture, level, xoffset, width, format, type, MobileGL::Protocol::WireFull::CreateShmRegion(builder, 0, shm == nullptr ? 0 : shm->size));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glTextureSubImage1D), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlTextureSubImage1DEXT(Uint64 sessionId, uint32_t texture, uint32_t target, int32_t level, int32_t xoffset, int32_t width, uint32_t format, uint32_t type, Uint64 token, MobileGLShmHandle* shm) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenTextureSubImage1DEXT(builder, texture, target, level, xoffset, width, format, type, MobileGL::Protocol::WireFull::CreateShmRegion(builder, 0, shm == nullptr ? 0 : shm->size));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glTextureSubImage1DEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlTextureSubImage2D(Uint64 sessionId, uint32_t texture, int32_t level, int32_t xoffset, int32_t yoffset, int32_t width, int32_t height, uint32_t format, uint32_t type, Uint64 token, MobileGLShmHandle* shm) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenTextureSubImage2D(builder, texture, level, xoffset, yoffset, width, height, format, type, MobileGL::Protocol::WireFull::CreateShmRegion(builder, 0, shm == nullptr ? 0 : shm->size));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glTextureSubImage2D), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlTextureSubImage2DEXT(Uint64 sessionId, uint32_t texture, uint32_t target, int32_t level, int32_t xoffset, int32_t yoffset, int32_t width, int32_t height, uint32_t format, uint32_t type, Uint64 token, MobileGLShmHandle* shm) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenTextureSubImage2DEXT(builder, texture, target, level, xoffset, yoffset, width, height, format, type, MobileGL::Protocol::WireFull::CreateShmRegion(builder, 0, shm == nullptr ? 0 : shm->size));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glTextureSubImage2DEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlTextureSubImage3D(Uint64 sessionId, uint32_t texture, int32_t level, int32_t xoffset, int32_t yoffset, int32_t zoffset, int32_t width, int32_t height, int32_t depth, uint32_t format, uint32_t type, Uint64 token, MobileGLShmHandle* shm) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenTextureSubImage3D(builder, texture, level, xoffset, yoffset, zoffset, width, height, depth, format, type, MobileGL::Protocol::WireFull::CreateShmRegion(builder, 0, shm == nullptr ? 0 : shm->size));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glTextureSubImage3D), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlTextureSubImage3DEXT(Uint64 sessionId, uint32_t texture, uint32_t target, int32_t level, int32_t xoffset, int32_t yoffset, int32_t zoffset, int32_t width, int32_t height, int32_t depth, uint32_t format, uint32_t type, Uint64 token, MobileGLShmHandle* shm) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenTextureSubImage3DEXT(builder, texture, target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, MobileGL::Protocol::WireFull::CreateShmRegion(builder, 0, shm == nullptr ? 0 : shm->size));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glTextureSubImage3DEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlTextureView(Uint64 sessionId, uint32_t texture, uint32_t target, uint32_t origtexture, uint32_t internalformat, uint32_t minlevel, uint32_t numlevels, uint32_t minlayer, uint32_t numlayers, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenTextureView(builder, texture, target, origtexture, internalformat, minlevel, numlevels, minlayer, numlayers);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glTextureView), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlTransformFeedbackBufferBase(Uint64 sessionId, uint32_t xfb, uint32_t index, uint32_t buffer, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenTransformFeedbackBufferBase(builder, xfb, index, buffer);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glTransformFeedbackBufferBase), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlTransformFeedbackBufferRange(Uint64 sessionId, uint32_t xfb, uint32_t index, uint32_t buffer, int64_t offset, uint64_t size, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenTransformFeedbackBufferRange(builder, xfb, index, buffer, offset, size);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glTransformFeedbackBufferRange), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlTransformPathNV(Uint64 sessionId, uint32_t resultPath, uint32_t srcPath, uint32_t transformType, const std::vector<float>& transformValues, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenTransformPathNV(builder, resultPath, srcPath, transformType, builder.CreateVector(transformValues));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glTransformPathNV), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlUniform1d(Uint64 sessionId, int32_t location, double x, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenUniform1d(builder, location, x);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glUniform1d), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlUniform1dv(Uint64 sessionId, int32_t location, int32_t count, const std::vector<double>& value, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenUniform1dv(builder, location, count, builder.CreateVector(value));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glUniform1dv), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlUniform1f(Uint64 sessionId, int32_t location, float v0, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenUniform1f(builder, location, v0);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glUniform1f), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlUniform1fv(Uint64 sessionId, int32_t location, int32_t count, const std::vector<float>& value, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenUniform1fv(builder, location, count, builder.CreateVector(value));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glUniform1fv), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlUniform1i(Uint64 sessionId, int32_t location, int32_t v0, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenUniform1i(builder, location, v0);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glUniform1i), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlUniform1i64ARB(Uint64 sessionId, int32_t location, int64_t x, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenUniform1i64ARB(builder, location, x);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glUniform1i64ARB), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlUniform1i64NV(Uint64 sessionId, int32_t location, int64_t x, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenUniform1i64NV(builder, location, x);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glUniform1i64NV), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlUniform1i64vARB(Uint64 sessionId, int32_t location, int32_t count, const std::vector<int64_t>& value, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenUniform1i64vARB(builder, location, count, builder.CreateVector(value));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glUniform1i64vARB), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlUniform1i64vNV(Uint64 sessionId, int32_t location, int32_t count, const std::vector<int64_t>& value, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenUniform1i64vNV(builder, location, count, builder.CreateVector(value));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glUniform1i64vNV), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlUniform1iv(Uint64 sessionId, int32_t location, int32_t count, const std::vector<int32_t>& value, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenUniform1iv(builder, location, count, builder.CreateVector(value));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glUniform1iv), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlUniform1ui(Uint64 sessionId, int32_t location, uint32_t v0, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenUniform1ui(builder, location, v0);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glUniform1ui), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlUniform1ui64ARB(Uint64 sessionId, int32_t location, uint64_t x, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenUniform1ui64ARB(builder, location, x);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glUniform1ui64ARB), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlUniform1ui64NV(Uint64 sessionId, int32_t location, uint64_t x, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenUniform1ui64NV(builder, location, x);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glUniform1ui64NV), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlUniform1ui64vARB(Uint64 sessionId, int32_t location, int32_t count, const std::vector<uint64_t>& value, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenUniform1ui64vARB(builder, location, count, builder.CreateVector(value));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glUniform1ui64vARB), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlUniform1ui64vNV(Uint64 sessionId, int32_t location, int32_t count, const std::vector<uint64_t>& value, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenUniform1ui64vNV(builder, location, count, builder.CreateVector(value));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glUniform1ui64vNV), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlUniform1uiv(Uint64 sessionId, int32_t location, int32_t count, const std::vector<uint32_t>& value, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenUniform1uiv(builder, location, count, builder.CreateVector(value));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glUniform1uiv), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlUniform2d(Uint64 sessionId, int32_t location, double x, double y, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenUniform2d(builder, location, x, y);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glUniform2d), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlUniform2dv(Uint64 sessionId, int32_t location, int32_t count, const std::vector<double>& value, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenUniform2dv(builder, location, count, builder.CreateVector(value));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glUniform2dv), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlUniform2f(Uint64 sessionId, int32_t location, float v0, float v1, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenUniform2f(builder, location, v0, v1);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glUniform2f), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlUniform2fv(Uint64 sessionId, int32_t location, int32_t count, const std::vector<float>& value, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenUniform2fv(builder, location, count, builder.CreateVector(value));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glUniform2fv), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlUniform2i(Uint64 sessionId, int32_t location, int32_t v0, int32_t v1, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenUniform2i(builder, location, v0, v1);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glUniform2i), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlUniform2i64ARB(Uint64 sessionId, int32_t location, int64_t x, int64_t y, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenUniform2i64ARB(builder, location, x, y);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glUniform2i64ARB), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlUniform2i64NV(Uint64 sessionId, int32_t location, int64_t x, int64_t y, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenUniform2i64NV(builder, location, x, y);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glUniform2i64NV), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlUniform2i64vARB(Uint64 sessionId, int32_t location, int32_t count, const std::vector<int64_t>& value, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenUniform2i64vARB(builder, location, count, builder.CreateVector(value));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glUniform2i64vARB), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlUniform2i64vNV(Uint64 sessionId, int32_t location, int32_t count, const std::vector<int64_t>& value, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenUniform2i64vNV(builder, location, count, builder.CreateVector(value));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glUniform2i64vNV), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlUniform2iv(Uint64 sessionId, int32_t location, int32_t count, const std::vector<int32_t>& value, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenUniform2iv(builder, location, count, builder.CreateVector(value));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glUniform2iv), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlUniform2ui(Uint64 sessionId, int32_t location, uint32_t v0, uint32_t v1, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenUniform2ui(builder, location, v0, v1);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glUniform2ui), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlUniform2ui64ARB(Uint64 sessionId, int32_t location, uint64_t x, uint64_t y, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenUniform2ui64ARB(builder, location, x, y);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glUniform2ui64ARB), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlUniform2ui64NV(Uint64 sessionId, int32_t location, uint64_t x, uint64_t y, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenUniform2ui64NV(builder, location, x, y);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glUniform2ui64NV), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlUniform2ui64vARB(Uint64 sessionId, int32_t location, int32_t count, const std::vector<uint64_t>& value, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenUniform2ui64vARB(builder, location, count, builder.CreateVector(value));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glUniform2ui64vARB), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlUniform2ui64vNV(Uint64 sessionId, int32_t location, int32_t count, const std::vector<uint64_t>& value, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenUniform2ui64vNV(builder, location, count, builder.CreateVector(value));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glUniform2ui64vNV), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlUniform2uiv(Uint64 sessionId, int32_t location, int32_t count, const std::vector<uint32_t>& value, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenUniform2uiv(builder, location, count, builder.CreateVector(value));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glUniform2uiv), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlUniform3d(Uint64 sessionId, int32_t location, double x, double y, double z, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenUniform3d(builder, location, x, y, z);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glUniform3d), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlUniform3dv(Uint64 sessionId, int32_t location, int32_t count, const std::vector<double>& value, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenUniform3dv(builder, location, count, builder.CreateVector(value));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glUniform3dv), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlUniform3f(Uint64 sessionId, int32_t location, float v0, float v1, float v2, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenUniform3f(builder, location, v0, v1, v2);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glUniform3f), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlUniform3fv(Uint64 sessionId, int32_t location, int32_t count, const std::vector<float>& value, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenUniform3fv(builder, location, count, builder.CreateVector(value));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glUniform3fv), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlUniform3i(Uint64 sessionId, int32_t location, int32_t v0, int32_t v1, int32_t v2, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenUniform3i(builder, location, v0, v1, v2);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glUniform3i), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlUniform3i64ARB(Uint64 sessionId, int32_t location, int64_t x, int64_t y, int64_t z, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenUniform3i64ARB(builder, location, x, y, z);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glUniform3i64ARB), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlUniform3i64NV(Uint64 sessionId, int32_t location, int64_t x, int64_t y, int64_t z, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenUniform3i64NV(builder, location, x, y, z);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glUniform3i64NV), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlUniform3i64vARB(Uint64 sessionId, int32_t location, int32_t count, const std::vector<int64_t>& value, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenUniform3i64vARB(builder, location, count, builder.CreateVector(value));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glUniform3i64vARB), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlUniform3i64vNV(Uint64 sessionId, int32_t location, int32_t count, const std::vector<int64_t>& value, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenUniform3i64vNV(builder, location, count, builder.CreateVector(value));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glUniform3i64vNV), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlUniform3iv(Uint64 sessionId, int32_t location, int32_t count, const std::vector<int32_t>& value, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenUniform3iv(builder, location, count, builder.CreateVector(value));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glUniform3iv), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlUniform3ui(Uint64 sessionId, int32_t location, uint32_t v0, uint32_t v1, uint32_t v2, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenUniform3ui(builder, location, v0, v1, v2);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glUniform3ui), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlUniform3ui64ARB(Uint64 sessionId, int32_t location, uint64_t x, uint64_t y, uint64_t z, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenUniform3ui64ARB(builder, location, x, y, z);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glUniform3ui64ARB), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlUniform3ui64NV(Uint64 sessionId, int32_t location, uint64_t x, uint64_t y, uint64_t z, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenUniform3ui64NV(builder, location, x, y, z);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glUniform3ui64NV), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlUniform3ui64vARB(Uint64 sessionId, int32_t location, int32_t count, const std::vector<uint64_t>& value, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenUniform3ui64vARB(builder, location, count, builder.CreateVector(value));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glUniform3ui64vARB), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlUniform3ui64vNV(Uint64 sessionId, int32_t location, int32_t count, const std::vector<uint64_t>& value, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenUniform3ui64vNV(builder, location, count, builder.CreateVector(value));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glUniform3ui64vNV), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlUniform3uiv(Uint64 sessionId, int32_t location, int32_t count, const std::vector<uint32_t>& value, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenUniform3uiv(builder, location, count, builder.CreateVector(value));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glUniform3uiv), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlUniform4d(Uint64 sessionId, int32_t location, double x, double y, double z, double w, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenUniform4d(builder, location, x, y, z, w);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glUniform4d), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlUniform4dv(Uint64 sessionId, int32_t location, int32_t count, const std::vector<double>& value, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenUniform4dv(builder, location, count, builder.CreateVector(value));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glUniform4dv), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlUniform4f(Uint64 sessionId, int32_t location, float v0, float v1, float v2, float v3, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenUniform4f(builder, location, v0, v1, v2, v3);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glUniform4f), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlUniform4fv(Uint64 sessionId, int32_t location, int32_t count, const std::vector<float>& value, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenUniform4fv(builder, location, count, builder.CreateVector(value));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glUniform4fv), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlUniform4i(Uint64 sessionId, int32_t location, int32_t v0, int32_t v1, int32_t v2, int32_t v3, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenUniform4i(builder, location, v0, v1, v2, v3);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glUniform4i), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlUniform4i64ARB(Uint64 sessionId, int32_t location, int64_t x, int64_t y, int64_t z, int64_t w, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenUniform4i64ARB(builder, location, x, y, z, w);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glUniform4i64ARB), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlUniform4i64NV(Uint64 sessionId, int32_t location, int64_t x, int64_t y, int64_t z, int64_t w, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenUniform4i64NV(builder, location, x, y, z, w);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glUniform4i64NV), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlUniform4i64vARB(Uint64 sessionId, int32_t location, int32_t count, const std::vector<int64_t>& value, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenUniform4i64vARB(builder, location, count, builder.CreateVector(value));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glUniform4i64vARB), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlUniform4i64vNV(Uint64 sessionId, int32_t location, int32_t count, const std::vector<int64_t>& value, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenUniform4i64vNV(builder, location, count, builder.CreateVector(value));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glUniform4i64vNV), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlUniform4iv(Uint64 sessionId, int32_t location, int32_t count, const std::vector<int32_t>& value, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenUniform4iv(builder, location, count, builder.CreateVector(value));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glUniform4iv), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlUniform4ui(Uint64 sessionId, int32_t location, uint32_t v0, uint32_t v1, uint32_t v2, uint32_t v3, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenUniform4ui(builder, location, v0, v1, v2, v3);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glUniform4ui), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlUniform4ui64ARB(Uint64 sessionId, int32_t location, uint64_t x, uint64_t y, uint64_t z, uint64_t w, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenUniform4ui64ARB(builder, location, x, y, z, w);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glUniform4ui64ARB), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlUniform4ui64NV(Uint64 sessionId, int32_t location, uint64_t x, uint64_t y, uint64_t z, uint64_t w, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenUniform4ui64NV(builder, location, x, y, z, w);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glUniform4ui64NV), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlUniform4ui64vARB(Uint64 sessionId, int32_t location, int32_t count, const std::vector<uint64_t>& value, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenUniform4ui64vARB(builder, location, count, builder.CreateVector(value));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glUniform4ui64vARB), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlUniform4ui64vNV(Uint64 sessionId, int32_t location, int32_t count, const std::vector<uint64_t>& value, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenUniform4ui64vNV(builder, location, count, builder.CreateVector(value));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glUniform4ui64vNV), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlUniform4uiv(Uint64 sessionId, int32_t location, int32_t count, const std::vector<uint32_t>& value, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenUniform4uiv(builder, location, count, builder.CreateVector(value));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glUniform4uiv), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlUniformBlockBinding(Uint64 sessionId, uint32_t program, uint32_t uniformBlockIndex, uint32_t uniformBlockBinding, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenUniformBlockBinding(builder, program, uniformBlockIndex, uniformBlockBinding);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glUniformBlockBinding), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlUniformHandleui64ARB(Uint64 sessionId, int32_t location, uint64_t value, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenUniformHandleui64ARB(builder, location, value);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glUniformHandleui64ARB), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlUniformHandleui64NV(Uint64 sessionId, int32_t location, uint64_t value, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenUniformHandleui64NV(builder, location, value);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glUniformHandleui64NV), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlUniformHandleui64vARB(Uint64 sessionId, int32_t location, int32_t count, const std::vector<uint64_t>& value, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenUniformHandleui64vARB(builder, location, count, builder.CreateVector(value));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glUniformHandleui64vARB), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlUniformHandleui64vNV(Uint64 sessionId, int32_t location, int32_t count, const std::vector<uint64_t>& value, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenUniformHandleui64vNV(builder, location, count, builder.CreateVector(value));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glUniformHandleui64vNV), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlUniformMatrix2dv(Uint64 sessionId, int32_t location, int32_t count, bool transpose, const std::vector<double>& value, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenUniformMatrix2dv(builder, location, count, transpose, builder.CreateVector(value));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glUniformMatrix2dv), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlUniformMatrix2fv(Uint64 sessionId, int32_t location, int32_t count, bool transpose, const std::vector<float>& value, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenUniformMatrix2fv(builder, location, count, transpose, builder.CreateVector(value));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glUniformMatrix2fv), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlUniformMatrix2x3dv(Uint64 sessionId, int32_t location, int32_t count, bool transpose, const std::vector<double>& value, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenUniformMatrix2x3dv(builder, location, count, transpose, builder.CreateVector(value));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glUniformMatrix2x3dv), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlUniformMatrix2x3fv(Uint64 sessionId, int32_t location, int32_t count, bool transpose, const std::vector<float>& value, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenUniformMatrix2x3fv(builder, location, count, transpose, builder.CreateVector(value));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glUniformMatrix2x3fv), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlUniformMatrix2x4dv(Uint64 sessionId, int32_t location, int32_t count, bool transpose, const std::vector<double>& value, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenUniformMatrix2x4dv(builder, location, count, transpose, builder.CreateVector(value));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glUniformMatrix2x4dv), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlUniformMatrix2x4fv(Uint64 sessionId, int32_t location, int32_t count, bool transpose, const std::vector<float>& value, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenUniformMatrix2x4fv(builder, location, count, transpose, builder.CreateVector(value));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glUniformMatrix2x4fv), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlUniformMatrix3dv(Uint64 sessionId, int32_t location, int32_t count, bool transpose, const std::vector<double>& value, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenUniformMatrix3dv(builder, location, count, transpose, builder.CreateVector(value));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glUniformMatrix3dv), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlUniformMatrix3fv(Uint64 sessionId, int32_t location, int32_t count, bool transpose, const std::vector<float>& value, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenUniformMatrix3fv(builder, location, count, transpose, builder.CreateVector(value));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glUniformMatrix3fv), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlUniformMatrix3x2dv(Uint64 sessionId, int32_t location, int32_t count, bool transpose, const std::vector<double>& value, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenUniformMatrix3x2dv(builder, location, count, transpose, builder.CreateVector(value));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glUniformMatrix3x2dv), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlUniformMatrix3x2fv(Uint64 sessionId, int32_t location, int32_t count, bool transpose, const std::vector<float>& value, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenUniformMatrix3x2fv(builder, location, count, transpose, builder.CreateVector(value));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glUniformMatrix3x2fv), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlUniformMatrix3x4dv(Uint64 sessionId, int32_t location, int32_t count, bool transpose, const std::vector<double>& value, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenUniformMatrix3x4dv(builder, location, count, transpose, builder.CreateVector(value));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glUniformMatrix3x4dv), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlUniformMatrix3x4fv(Uint64 sessionId, int32_t location, int32_t count, bool transpose, const std::vector<float>& value, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenUniformMatrix3x4fv(builder, location, count, transpose, builder.CreateVector(value));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glUniformMatrix3x4fv), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlUniformMatrix4dv(Uint64 sessionId, int32_t location, int32_t count, bool transpose, const std::vector<double>& value, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenUniformMatrix4dv(builder, location, count, transpose, builder.CreateVector(value));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glUniformMatrix4dv), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlUniformMatrix4fv(Uint64 sessionId, int32_t location, int32_t count, bool transpose, const std::vector<float>& value, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenUniformMatrix4fv(builder, location, count, transpose, builder.CreateVector(value));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glUniformMatrix4fv), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlUniformMatrix4x2dv(Uint64 sessionId, int32_t location, int32_t count, bool transpose, const std::vector<double>& value, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenUniformMatrix4x2dv(builder, location, count, transpose, builder.CreateVector(value));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glUniformMatrix4x2dv), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlUniformMatrix4x2fv(Uint64 sessionId, int32_t location, int32_t count, bool transpose, const std::vector<float>& value, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenUniformMatrix4x2fv(builder, location, count, transpose, builder.CreateVector(value));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glUniformMatrix4x2fv), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlUniformMatrix4x3dv(Uint64 sessionId, int32_t location, int32_t count, bool transpose, const std::vector<double>& value, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenUniformMatrix4x3dv(builder, location, count, transpose, builder.CreateVector(value));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glUniformMatrix4x3dv), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlUniformMatrix4x3fv(Uint64 sessionId, int32_t location, int32_t count, bool transpose, const std::vector<float>& value, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenUniformMatrix4x3fv(builder, location, count, transpose, builder.CreateVector(value));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glUniformMatrix4x3fv), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlUniformSubroutinesuiv(Uint64 sessionId, uint32_t shadertype, int32_t count, const std::vector<uint32_t>& indices, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenUniformSubroutinesuiv(builder, shadertype, count, builder.CreateVector(indices));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glUniformSubroutinesuiv), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlUniformui64NV(Uint64 sessionId, int32_t location, uint64_t value, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenUniformui64NV(builder, location, value);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glUniformui64NV), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlUniformui64vNV(Uint64 sessionId, int32_t location, int32_t count, const std::vector<uint64_t>& value, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenUniformui64vNV(builder, location, count, builder.CreateVector(value));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glUniformui64vNV), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlUnmapBuffer(Uint64 sessionId, uint32_t target, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenUnmapBuffer(builder, target);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glUnmapBuffer), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlUnmapNamedBuffer(Uint64 sessionId, uint32_t buffer, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenUnmapNamedBuffer(builder, buffer);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glUnmapNamedBuffer), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlUnmapNamedBufferEXT(Uint64 sessionId, uint32_t buffer, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenUnmapNamedBufferEXT(builder, buffer);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glUnmapNamedBufferEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlUseProgram(Uint64 sessionId, uint32_t program, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenUseProgram(builder, program);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glUseProgram), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlUseProgramStages(Uint64 sessionId, uint32_t pipeline, uint32_t stages, uint32_t program, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenUseProgramStages(builder, pipeline, stages, program);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glUseProgramStages), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlUseShaderProgramEXT(Uint64 sessionId, uint32_t type, uint32_t program, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenUseShaderProgramEXT(builder, type, program);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glUseShaderProgramEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlValidateProgram(Uint64 sessionId, uint32_t program, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenValidateProgram(builder, program);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glValidateProgram), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlValidateProgramPipeline(Uint64 sessionId, uint32_t pipeline, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenValidateProgramPipeline(builder, pipeline);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glValidateProgramPipeline), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlVertexArrayAttribBinding(Uint64 sessionId, uint32_t vaobj, uint32_t attribindex, uint32_t bindingindex, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenVertexArrayAttribBinding(builder, vaobj, attribindex, bindingindex);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glVertexArrayAttribBinding), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlVertexArrayAttribFormat(Uint64 sessionId, uint32_t vaobj, uint32_t attribindex, int32_t size, uint32_t type, bool normalized, uint32_t relativeoffset, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenVertexArrayAttribFormat(builder, vaobj, attribindex, size, type, normalized, relativeoffset);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glVertexArrayAttribFormat), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlVertexArrayAttribIFormat(Uint64 sessionId, uint32_t vaobj, uint32_t attribindex, int32_t size, uint32_t type, uint32_t relativeoffset, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenVertexArrayAttribIFormat(builder, vaobj, attribindex, size, type, relativeoffset);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glVertexArrayAttribIFormat), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlVertexArrayAttribLFormat(Uint64 sessionId, uint32_t vaobj, uint32_t attribindex, int32_t size, uint32_t type, uint32_t relativeoffset, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenVertexArrayAttribLFormat(builder, vaobj, attribindex, size, type, relativeoffset);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glVertexArrayAttribLFormat), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlVertexArrayBindVertexBufferEXT(Uint64 sessionId, uint32_t vaobj, uint32_t bindingindex, uint32_t buffer, int64_t offset, int32_t stride, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenVertexArrayBindVertexBufferEXT(builder, vaobj, bindingindex, buffer, offset, stride);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glVertexArrayBindVertexBufferEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlVertexArrayBindingDivisor(Uint64 sessionId, uint32_t vaobj, uint32_t bindingindex, uint32_t divisor, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenVertexArrayBindingDivisor(builder, vaobj, bindingindex, divisor);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glVertexArrayBindingDivisor), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlVertexArrayColorOffsetEXT(Uint64 sessionId, uint32_t vaobj, uint32_t buffer, int32_t size, uint32_t type, int32_t stride, int64_t offset, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenVertexArrayColorOffsetEXT(builder, vaobj, buffer, size, type, stride, offset);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glVertexArrayColorOffsetEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlVertexArrayEdgeFlagOffsetEXT(Uint64 sessionId, uint32_t vaobj, uint32_t buffer, int32_t stride, int64_t offset, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenVertexArrayEdgeFlagOffsetEXT(builder, vaobj, buffer, stride, offset);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glVertexArrayEdgeFlagOffsetEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlVertexArrayElementBuffer(Uint64 sessionId, uint32_t vaobj, uint32_t buffer, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenVertexArrayElementBuffer(builder, vaobj, buffer);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glVertexArrayElementBuffer), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlVertexArrayFogCoordOffsetEXT(Uint64 sessionId, uint32_t vaobj, uint32_t buffer, uint32_t type, int32_t stride, int64_t offset, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenVertexArrayFogCoordOffsetEXT(builder, vaobj, buffer, type, stride, offset);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glVertexArrayFogCoordOffsetEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlVertexArrayIndexOffsetEXT(Uint64 sessionId, uint32_t vaobj, uint32_t buffer, uint32_t type, int32_t stride, int64_t offset, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenVertexArrayIndexOffsetEXT(builder, vaobj, buffer, type, stride, offset);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glVertexArrayIndexOffsetEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlVertexArrayMultiTexCoordOffsetEXT(Uint64 sessionId, uint32_t vaobj, uint32_t buffer, uint32_t texunit, int32_t size, uint32_t type, int32_t stride, int64_t offset, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenVertexArrayMultiTexCoordOffsetEXT(builder, vaobj, buffer, texunit, size, type, stride, offset);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glVertexArrayMultiTexCoordOffsetEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlVertexArrayNormalOffsetEXT(Uint64 sessionId, uint32_t vaobj, uint32_t buffer, uint32_t type, int32_t stride, int64_t offset, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenVertexArrayNormalOffsetEXT(builder, vaobj, buffer, type, stride, offset);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glVertexArrayNormalOffsetEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlVertexArraySecondaryColorOffsetEXT(Uint64 sessionId, uint32_t vaobj, uint32_t buffer, int32_t size, uint32_t type, int32_t stride, int64_t offset, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenVertexArraySecondaryColorOffsetEXT(builder, vaobj, buffer, size, type, stride, offset);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glVertexArraySecondaryColorOffsetEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlVertexArrayTexCoordOffsetEXT(Uint64 sessionId, uint32_t vaobj, uint32_t buffer, int32_t size, uint32_t type, int32_t stride, int64_t offset, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenVertexArrayTexCoordOffsetEXT(builder, vaobj, buffer, size, type, stride, offset);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glVertexArrayTexCoordOffsetEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlVertexArrayVertexAttribBindingEXT(Uint64 sessionId, uint32_t vaobj, uint32_t attribindex, uint32_t bindingindex, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenVertexArrayVertexAttribBindingEXT(builder, vaobj, attribindex, bindingindex);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glVertexArrayVertexAttribBindingEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlVertexArrayVertexAttribDivisorEXT(Uint64 sessionId, uint32_t vaobj, uint32_t index, uint32_t divisor, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenVertexArrayVertexAttribDivisorEXT(builder, vaobj, index, divisor);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glVertexArrayVertexAttribDivisorEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlVertexArrayVertexAttribFormatEXT(Uint64 sessionId, uint32_t vaobj, uint32_t attribindex, int32_t size, uint32_t type, bool normalized, uint32_t relativeoffset, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenVertexArrayVertexAttribFormatEXT(builder, vaobj, attribindex, size, type, normalized, relativeoffset);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glVertexArrayVertexAttribFormatEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlVertexArrayVertexAttribIFormatEXT(Uint64 sessionId, uint32_t vaobj, uint32_t attribindex, int32_t size, uint32_t type, uint32_t relativeoffset, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenVertexArrayVertexAttribIFormatEXT(builder, vaobj, attribindex, size, type, relativeoffset);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glVertexArrayVertexAttribIFormatEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlVertexArrayVertexAttribIOffsetEXT(Uint64 sessionId, uint32_t vaobj, uint32_t buffer, uint32_t index, int32_t size, uint32_t type, int32_t stride, int64_t offset, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenVertexArrayVertexAttribIOffsetEXT(builder, vaobj, buffer, index, size, type, stride, offset);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glVertexArrayVertexAttribIOffsetEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlVertexArrayVertexAttribLFormatEXT(Uint64 sessionId, uint32_t vaobj, uint32_t attribindex, int32_t size, uint32_t type, uint32_t relativeoffset, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenVertexArrayVertexAttribLFormatEXT(builder, vaobj, attribindex, size, type, relativeoffset);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glVertexArrayVertexAttribLFormatEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlVertexArrayVertexAttribLOffsetEXT(Uint64 sessionId, uint32_t vaobj, uint32_t buffer, uint32_t index, int32_t size, uint32_t type, int32_t stride, int64_t offset, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenVertexArrayVertexAttribLOffsetEXT(builder, vaobj, buffer, index, size, type, stride, offset);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glVertexArrayVertexAttribLOffsetEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlVertexArrayVertexAttribOffsetEXT(Uint64 sessionId, uint32_t vaobj, uint32_t buffer, uint32_t index, int32_t size, uint32_t type, bool normalized, int32_t stride, int64_t offset, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenVertexArrayVertexAttribOffsetEXT(builder, vaobj, buffer, index, size, type, normalized, stride, offset);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glVertexArrayVertexAttribOffsetEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlVertexArrayVertexBindingDivisorEXT(Uint64 sessionId, uint32_t vaobj, uint32_t bindingindex, uint32_t divisor, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenVertexArrayVertexBindingDivisorEXT(builder, vaobj, bindingindex, divisor);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glVertexArrayVertexBindingDivisorEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlVertexArrayVertexBuffer(Uint64 sessionId, uint32_t vaobj, uint32_t bindingindex, uint32_t buffer, int64_t offset, int32_t stride, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenVertexArrayVertexBuffer(builder, vaobj, bindingindex, buffer, offset, stride);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glVertexArrayVertexBuffer), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlVertexArrayVertexOffsetEXT(Uint64 sessionId, uint32_t vaobj, uint32_t buffer, int32_t size, uint32_t type, int32_t stride, int64_t offset, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenVertexArrayVertexOffsetEXT(builder, vaobj, buffer, size, type, stride, offset);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glVertexArrayVertexOffsetEXT), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlVertexAttrib1d(Uint64 sessionId, uint32_t index, double x, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenVertexAttrib1d(builder, index, x);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glVertexAttrib1d), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlVertexAttrib1dv(Uint64 sessionId, uint32_t index, const std::vector<double>& v, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenVertexAttrib1dv(builder, index, builder.CreateVector(v));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glVertexAttrib1dv), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlVertexAttrib1f(Uint64 sessionId, uint32_t index, float x, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenVertexAttrib1f(builder, index, x);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glVertexAttrib1f), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlVertexAttrib1fv(Uint64 sessionId, uint32_t index, const std::vector<float>& v, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenVertexAttrib1fv(builder, index, builder.CreateVector(v));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glVertexAttrib1fv), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlVertexAttrib1s(Uint64 sessionId, uint32_t index, int32_t x, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenVertexAttrib1s(builder, index, x);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glVertexAttrib1s), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlVertexAttrib1sv(Uint64 sessionId, uint32_t index, const std::vector<int32_t>& v, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenVertexAttrib1sv(builder, index, builder.CreateVector(v));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glVertexAttrib1sv), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlVertexAttrib2d(Uint64 sessionId, uint32_t index, double x, double y, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenVertexAttrib2d(builder, index, x, y);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glVertexAttrib2d), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlVertexAttrib2dv(Uint64 sessionId, uint32_t index, const std::vector<double>& v, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenVertexAttrib2dv(builder, index, builder.CreateVector(v));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glVertexAttrib2dv), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlVertexAttrib2f(Uint64 sessionId, uint32_t index, float x, float y, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenVertexAttrib2f(builder, index, x, y);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glVertexAttrib2f), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlVertexAttrib2fv(Uint64 sessionId, uint32_t index, const std::vector<float>& v, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenVertexAttrib2fv(builder, index, builder.CreateVector(v));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glVertexAttrib2fv), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlVertexAttrib2s(Uint64 sessionId, uint32_t index, int32_t x, int32_t y, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenVertexAttrib2s(builder, index, x, y);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glVertexAttrib2s), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlVertexAttrib2sv(Uint64 sessionId, uint32_t index, const std::vector<int32_t>& v, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenVertexAttrib2sv(builder, index, builder.CreateVector(v));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glVertexAttrib2sv), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlVertexAttrib3d(Uint64 sessionId, uint32_t index, double x, double y, double z, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenVertexAttrib3d(builder, index, x, y, z);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glVertexAttrib3d), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlVertexAttrib3dv(Uint64 sessionId, uint32_t index, const std::vector<double>& v, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenVertexAttrib3dv(builder, index, builder.CreateVector(v));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glVertexAttrib3dv), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlVertexAttrib3f(Uint64 sessionId, uint32_t index, float x, float y, float z, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenVertexAttrib3f(builder, index, x, y, z);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glVertexAttrib3f), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlVertexAttrib3fv(Uint64 sessionId, uint32_t index, const std::vector<float>& v, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenVertexAttrib3fv(builder, index, builder.CreateVector(v));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glVertexAttrib3fv), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlVertexAttrib3s(Uint64 sessionId, uint32_t index, int32_t x, int32_t y, int32_t z, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenVertexAttrib3s(builder, index, x, y, z);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glVertexAttrib3s), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlVertexAttrib3sv(Uint64 sessionId, uint32_t index, const std::vector<int32_t>& v, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenVertexAttrib3sv(builder, index, builder.CreateVector(v));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glVertexAttrib3sv), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlVertexAttrib4Nbv(Uint64 sessionId, uint32_t index, const std::vector<int32_t>& v, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenVertexAttrib4Nbv(builder, index, builder.CreateVector(v));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glVertexAttrib4Nbv), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlVertexAttrib4Niv(Uint64 sessionId, uint32_t index, const std::vector<int32_t>& v, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenVertexAttrib4Niv(builder, index, builder.CreateVector(v));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glVertexAttrib4Niv), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlVertexAttrib4Nsv(Uint64 sessionId, uint32_t index, const std::vector<int32_t>& v, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenVertexAttrib4Nsv(builder, index, builder.CreateVector(v));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glVertexAttrib4Nsv), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlVertexAttrib4Nub(Uint64 sessionId, uint32_t index, uint32_t x, uint32_t y, uint32_t z, uint32_t w, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenVertexAttrib4Nub(builder, index, x, y, z, w);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glVertexAttrib4Nub), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlVertexAttrib4Nubv(Uint64 sessionId, uint32_t index, const std::vector<uint32_t>& v, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenVertexAttrib4Nubv(builder, index, builder.CreateVector(v));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glVertexAttrib4Nubv), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlVertexAttrib4Nuiv(Uint64 sessionId, uint32_t index, const std::vector<uint32_t>& v, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenVertexAttrib4Nuiv(builder, index, builder.CreateVector(v));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glVertexAttrib4Nuiv), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlVertexAttrib4Nusv(Uint64 sessionId, uint32_t index, const std::vector<uint32_t>& v, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenVertexAttrib4Nusv(builder, index, builder.CreateVector(v));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glVertexAttrib4Nusv), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlVertexAttrib4bv(Uint64 sessionId, uint32_t index, const std::vector<int32_t>& v, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenVertexAttrib4bv(builder, index, builder.CreateVector(v));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glVertexAttrib4bv), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlVertexAttrib4d(Uint64 sessionId, uint32_t index, double x, double y, double z, double w, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenVertexAttrib4d(builder, index, x, y, z, w);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glVertexAttrib4d), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlVertexAttrib4dv(Uint64 sessionId, uint32_t index, const std::vector<double>& v, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenVertexAttrib4dv(builder, index, builder.CreateVector(v));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glVertexAttrib4dv), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlVertexAttrib4f(Uint64 sessionId, uint32_t index, float x, float y, float z, float w, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenVertexAttrib4f(builder, index, x, y, z, w);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glVertexAttrib4f), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlVertexAttrib4fv(Uint64 sessionId, uint32_t index, const std::vector<float>& v, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenVertexAttrib4fv(builder, index, builder.CreateVector(v));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glVertexAttrib4fv), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlVertexAttrib4iv(Uint64 sessionId, uint32_t index, const std::vector<int32_t>& v, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenVertexAttrib4iv(builder, index, builder.CreateVector(v));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glVertexAttrib4iv), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlVertexAttrib4s(Uint64 sessionId, uint32_t index, int32_t x, int32_t y, int32_t z, int32_t w, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenVertexAttrib4s(builder, index, x, y, z, w);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glVertexAttrib4s), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlVertexAttrib4sv(Uint64 sessionId, uint32_t index, const std::vector<int32_t>& v, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenVertexAttrib4sv(builder, index, builder.CreateVector(v));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glVertexAttrib4sv), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlVertexAttrib4ubv(Uint64 sessionId, uint32_t index, const std::vector<uint32_t>& v, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenVertexAttrib4ubv(builder, index, builder.CreateVector(v));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glVertexAttrib4ubv), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlVertexAttrib4uiv(Uint64 sessionId, uint32_t index, const std::vector<uint32_t>& v, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenVertexAttrib4uiv(builder, index, builder.CreateVector(v));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glVertexAttrib4uiv), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlVertexAttrib4usv(Uint64 sessionId, uint32_t index, const std::vector<uint32_t>& v, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenVertexAttrib4usv(builder, index, builder.CreateVector(v));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glVertexAttrib4usv), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlVertexAttribBinding(Uint64 sessionId, uint32_t attribindex, uint32_t bindingindex, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenVertexAttribBinding(builder, attribindex, bindingindex);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glVertexAttribBinding), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlVertexAttribDivisor(Uint64 sessionId, uint32_t index, uint32_t divisor, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenVertexAttribDivisor(builder, index, divisor);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glVertexAttribDivisor), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlVertexAttribFormat(Uint64 sessionId, uint32_t attribindex, int32_t size, uint32_t type, bool normalized, uint32_t relativeoffset, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenVertexAttribFormat(builder, attribindex, size, type, normalized, relativeoffset);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glVertexAttribFormat), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlVertexAttribFormatNV(Uint64 sessionId, uint32_t index, int32_t size, uint32_t type, bool normalized, int32_t stride, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenVertexAttribFormatNV(builder, index, size, type, normalized, stride);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glVertexAttribFormatNV), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlVertexAttribI1i(Uint64 sessionId, uint32_t index, int32_t x, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenVertexAttribI1i(builder, index, x);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glVertexAttribI1i), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlVertexAttribI1iv(Uint64 sessionId, uint32_t index, const std::vector<int32_t>& v, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenVertexAttribI1iv(builder, index, builder.CreateVector(v));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glVertexAttribI1iv), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlVertexAttribI1ui(Uint64 sessionId, uint32_t index, uint32_t x, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenVertexAttribI1ui(builder, index, x);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glVertexAttribI1ui), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlVertexAttribI1uiv(Uint64 sessionId, uint32_t index, const std::vector<uint32_t>& v, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenVertexAttribI1uiv(builder, index, builder.CreateVector(v));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glVertexAttribI1uiv), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlVertexAttribI2i(Uint64 sessionId, uint32_t index, int32_t x, int32_t y, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenVertexAttribI2i(builder, index, x, y);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glVertexAttribI2i), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlVertexAttribI2iv(Uint64 sessionId, uint32_t index, const std::vector<int32_t>& v, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenVertexAttribI2iv(builder, index, builder.CreateVector(v));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glVertexAttribI2iv), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlVertexAttribI2ui(Uint64 sessionId, uint32_t index, uint32_t x, uint32_t y, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenVertexAttribI2ui(builder, index, x, y);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glVertexAttribI2ui), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlVertexAttribI2uiv(Uint64 sessionId, uint32_t index, const std::vector<uint32_t>& v, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenVertexAttribI2uiv(builder, index, builder.CreateVector(v));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glVertexAttribI2uiv), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlVertexAttribI3i(Uint64 sessionId, uint32_t index, int32_t x, int32_t y, int32_t z, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenVertexAttribI3i(builder, index, x, y, z);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glVertexAttribI3i), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlVertexAttribI3iv(Uint64 sessionId, uint32_t index, const std::vector<int32_t>& v, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenVertexAttribI3iv(builder, index, builder.CreateVector(v));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glVertexAttribI3iv), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlVertexAttribI3ui(Uint64 sessionId, uint32_t index, uint32_t x, uint32_t y, uint32_t z, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenVertexAttribI3ui(builder, index, x, y, z);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glVertexAttribI3ui), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlVertexAttribI3uiv(Uint64 sessionId, uint32_t index, const std::vector<uint32_t>& v, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenVertexAttribI3uiv(builder, index, builder.CreateVector(v));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glVertexAttribI3uiv), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlVertexAttribI4bv(Uint64 sessionId, uint32_t index, const std::vector<int32_t>& v, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenVertexAttribI4bv(builder, index, builder.CreateVector(v));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glVertexAttribI4bv), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlVertexAttribI4i(Uint64 sessionId, uint32_t index, int32_t x, int32_t y, int32_t z, int32_t w, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenVertexAttribI4i(builder, index, x, y, z, w);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glVertexAttribI4i), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlVertexAttribI4iv(Uint64 sessionId, uint32_t index, const std::vector<int32_t>& v, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenVertexAttribI4iv(builder, index, builder.CreateVector(v));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glVertexAttribI4iv), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlVertexAttribI4sv(Uint64 sessionId, uint32_t index, const std::vector<int32_t>& v, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenVertexAttribI4sv(builder, index, builder.CreateVector(v));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glVertexAttribI4sv), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlVertexAttribI4ubv(Uint64 sessionId, uint32_t index, const std::vector<uint32_t>& v, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenVertexAttribI4ubv(builder, index, builder.CreateVector(v));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glVertexAttribI4ubv), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlVertexAttribI4ui(Uint64 sessionId, uint32_t index, uint32_t x, uint32_t y, uint32_t z, uint32_t w, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenVertexAttribI4ui(builder, index, x, y, z, w);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glVertexAttribI4ui), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlVertexAttribI4uiv(Uint64 sessionId, uint32_t index, const std::vector<uint32_t>& v, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenVertexAttribI4uiv(builder, index, builder.CreateVector(v));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glVertexAttribI4uiv), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlVertexAttribI4usv(Uint64 sessionId, uint32_t index, const std::vector<uint32_t>& v, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenVertexAttribI4usv(builder, index, builder.CreateVector(v));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glVertexAttribI4usv), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlVertexAttribIFormat(Uint64 sessionId, uint32_t attribindex, int32_t size, uint32_t type, uint32_t relativeoffset, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenVertexAttribIFormat(builder, attribindex, size, type, relativeoffset);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glVertexAttribIFormat), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlVertexAttribIFormatNV(Uint64 sessionId, uint32_t index, int32_t size, uint32_t type, int32_t stride, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenVertexAttribIFormatNV(builder, index, size, type, stride);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glVertexAttribIFormatNV), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlVertexAttribIPointer(Uint64 sessionId, uint32_t index, int32_t size, uint32_t type, int32_t stride, Uint64 token, MobileGLShmHandle* shm) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenVertexAttribIPointer(builder, index, size, type, stride, MobileGL::Protocol::WireFull::CreateShmRegion(builder, 0, shm == nullptr ? 0 : shm->size));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glVertexAttribIPointer), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlVertexAttribL1d(Uint64 sessionId, uint32_t index, double x, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenVertexAttribL1d(builder, index, x);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glVertexAttribL1d), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlVertexAttribL1dv(Uint64 sessionId, uint32_t index, const std::vector<double>& v, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenVertexAttribL1dv(builder, index, builder.CreateVector(v));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glVertexAttribL1dv), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlVertexAttribL1i64NV(Uint64 sessionId, uint32_t index, int64_t x, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenVertexAttribL1i64NV(builder, index, x);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glVertexAttribL1i64NV), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlVertexAttribL1i64vNV(Uint64 sessionId, uint32_t index, const std::vector<int64_t>& v, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenVertexAttribL1i64vNV(builder, index, builder.CreateVector(v));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glVertexAttribL1i64vNV), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlVertexAttribL1ui64ARB(Uint64 sessionId, uint32_t index, uint64_t x, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenVertexAttribL1ui64ARB(builder, index, x);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glVertexAttribL1ui64ARB), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlVertexAttribL1ui64NV(Uint64 sessionId, uint32_t index, uint64_t x, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenVertexAttribL1ui64NV(builder, index, x);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glVertexAttribL1ui64NV), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlVertexAttribL1ui64vARB(Uint64 sessionId, uint32_t index, const std::vector<uint64_t>& v, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenVertexAttribL1ui64vARB(builder, index, builder.CreateVector(v));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glVertexAttribL1ui64vARB), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlVertexAttribL1ui64vNV(Uint64 sessionId, uint32_t index, const std::vector<uint64_t>& v, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenVertexAttribL1ui64vNV(builder, index, builder.CreateVector(v));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glVertexAttribL1ui64vNV), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlVertexAttribL2d(Uint64 sessionId, uint32_t index, double x, double y, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenVertexAttribL2d(builder, index, x, y);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glVertexAttribL2d), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlVertexAttribL2dv(Uint64 sessionId, uint32_t index, const std::vector<double>& v, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenVertexAttribL2dv(builder, index, builder.CreateVector(v));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glVertexAttribL2dv), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlVertexAttribL2i64NV(Uint64 sessionId, uint32_t index, int64_t x, int64_t y, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenVertexAttribL2i64NV(builder, index, x, y);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glVertexAttribL2i64NV), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlVertexAttribL2i64vNV(Uint64 sessionId, uint32_t index, const std::vector<int64_t>& v, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenVertexAttribL2i64vNV(builder, index, builder.CreateVector(v));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glVertexAttribL2i64vNV), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlVertexAttribL2ui64NV(Uint64 sessionId, uint32_t index, uint64_t x, uint64_t y, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenVertexAttribL2ui64NV(builder, index, x, y);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glVertexAttribL2ui64NV), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlVertexAttribL2ui64vNV(Uint64 sessionId, uint32_t index, const std::vector<uint64_t>& v, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenVertexAttribL2ui64vNV(builder, index, builder.CreateVector(v));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glVertexAttribL2ui64vNV), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlVertexAttribL3d(Uint64 sessionId, uint32_t index, double x, double y, double z, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenVertexAttribL3d(builder, index, x, y, z);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glVertexAttribL3d), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlVertexAttribL3dv(Uint64 sessionId, uint32_t index, const std::vector<double>& v, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenVertexAttribL3dv(builder, index, builder.CreateVector(v));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glVertexAttribL3dv), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlVertexAttribL3i64NV(Uint64 sessionId, uint32_t index, int64_t x, int64_t y, int64_t z, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenVertexAttribL3i64NV(builder, index, x, y, z);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glVertexAttribL3i64NV), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlVertexAttribL3i64vNV(Uint64 sessionId, uint32_t index, const std::vector<int64_t>& v, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenVertexAttribL3i64vNV(builder, index, builder.CreateVector(v));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glVertexAttribL3i64vNV), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlVertexAttribL3ui64NV(Uint64 sessionId, uint32_t index, uint64_t x, uint64_t y, uint64_t z, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenVertexAttribL3ui64NV(builder, index, x, y, z);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glVertexAttribL3ui64NV), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlVertexAttribL3ui64vNV(Uint64 sessionId, uint32_t index, const std::vector<uint64_t>& v, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenVertexAttribL3ui64vNV(builder, index, builder.CreateVector(v));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glVertexAttribL3ui64vNV), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlVertexAttribL4d(Uint64 sessionId, uint32_t index, double x, double y, double z, double w, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenVertexAttribL4d(builder, index, x, y, z, w);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glVertexAttribL4d), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlVertexAttribL4dv(Uint64 sessionId, uint32_t index, const std::vector<double>& v, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenVertexAttribL4dv(builder, index, builder.CreateVector(v));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glVertexAttribL4dv), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlVertexAttribL4i64NV(Uint64 sessionId, uint32_t index, int64_t x, int64_t y, int64_t z, int64_t w, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenVertexAttribL4i64NV(builder, index, x, y, z, w);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glVertexAttribL4i64NV), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlVertexAttribL4i64vNV(Uint64 sessionId, uint32_t index, const std::vector<int64_t>& v, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenVertexAttribL4i64vNV(builder, index, builder.CreateVector(v));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glVertexAttribL4i64vNV), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlVertexAttribL4ui64NV(Uint64 sessionId, uint32_t index, uint64_t x, uint64_t y, uint64_t z, uint64_t w, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenVertexAttribL4ui64NV(builder, index, x, y, z, w);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glVertexAttribL4ui64NV), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlVertexAttribL4ui64vNV(Uint64 sessionId, uint32_t index, const std::vector<uint64_t>& v, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenVertexAttribL4ui64vNV(builder, index, builder.CreateVector(v));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glVertexAttribL4ui64vNV), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlVertexAttribLFormat(Uint64 sessionId, uint32_t attribindex, int32_t size, uint32_t type, uint32_t relativeoffset, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenVertexAttribLFormat(builder, attribindex, size, type, relativeoffset);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glVertexAttribLFormat), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlVertexAttribLFormatNV(Uint64 sessionId, uint32_t index, int32_t size, uint32_t type, int32_t stride, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenVertexAttribLFormatNV(builder, index, size, type, stride);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glVertexAttribLFormatNV), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlVertexAttribLPointer(Uint64 sessionId, uint32_t index, int32_t size, uint32_t type, int32_t stride, Uint64 token, MobileGLShmHandle* shm) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenVertexAttribLPointer(builder, index, size, type, stride, MobileGL::Protocol::WireFull::CreateShmRegion(builder, 0, shm == nullptr ? 0 : shm->size));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glVertexAttribLPointer), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlVertexAttribP1ui(Uint64 sessionId, uint32_t index, uint32_t type, bool normalized, uint32_t value, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenVertexAttribP1ui(builder, index, type, normalized, value);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glVertexAttribP1ui), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlVertexAttribP1uiv(Uint64 sessionId, uint32_t index, uint32_t type, bool normalized, const std::vector<uint32_t>& value, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenVertexAttribP1uiv(builder, index, type, normalized, builder.CreateVector(value));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glVertexAttribP1uiv), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlVertexAttribP2ui(Uint64 sessionId, uint32_t index, uint32_t type, bool normalized, uint32_t value, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenVertexAttribP2ui(builder, index, type, normalized, value);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glVertexAttribP2ui), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlVertexAttribP2uiv(Uint64 sessionId, uint32_t index, uint32_t type, bool normalized, const std::vector<uint32_t>& value, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenVertexAttribP2uiv(builder, index, type, normalized, builder.CreateVector(value));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glVertexAttribP2uiv), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlVertexAttribP3ui(Uint64 sessionId, uint32_t index, uint32_t type, bool normalized, uint32_t value, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenVertexAttribP3ui(builder, index, type, normalized, value);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glVertexAttribP3ui), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlVertexAttribP3uiv(Uint64 sessionId, uint32_t index, uint32_t type, bool normalized, const std::vector<uint32_t>& value, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenVertexAttribP3uiv(builder, index, type, normalized, builder.CreateVector(value));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glVertexAttribP3uiv), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlVertexAttribP4ui(Uint64 sessionId, uint32_t index, uint32_t type, bool normalized, uint32_t value, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenVertexAttribP4ui(builder, index, type, normalized, value);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glVertexAttribP4ui), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlVertexAttribP4uiv(Uint64 sessionId, uint32_t index, uint32_t type, bool normalized, const std::vector<uint32_t>& value, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenVertexAttribP4uiv(builder, index, type, normalized, builder.CreateVector(value));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glVertexAttribP4uiv), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlVertexAttribPointer(Uint64 sessionId, uint32_t index, int32_t size, uint32_t type, bool normalized, int32_t stride, Uint64 token, MobileGLShmHandle* shm) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenVertexAttribPointer(builder, index, size, type, normalized, stride, MobileGL::Protocol::WireFull::CreateShmRegion(builder, 0, shm == nullptr ? 0 : shm->size));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glVertexAttribPointer), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlVertexBindingDivisor(Uint64 sessionId, uint32_t bindingindex, uint32_t divisor, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenVertexBindingDivisor(builder, bindingindex, divisor);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glVertexBindingDivisor), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlVertexFormatNV(Uint64 sessionId, int32_t size, uint32_t type, int32_t stride, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenVertexFormatNV(builder, size, type, stride);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glVertexFormatNV), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlViewport(Uint64 sessionId, int32_t x, int32_t y, int32_t width, int32_t height, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenViewport(builder, x, y, width, height);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glViewport), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlViewportArrayv(Uint64 sessionId, uint32_t first, int32_t count, const std::vector<float>& v, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenViewportArrayv(builder, first, count, builder.CreateVector(v));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glViewportArrayv), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlViewportIndexedf(Uint64 sessionId, uint32_t index, float x, float y, float w, float h, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenViewportIndexedf(builder, index, x, y, w, h);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glViewportIndexedf), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlViewportIndexedfv(Uint64 sessionId, uint32_t index, const std::vector<float>& v, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenViewportIndexedfv(builder, index, builder.CreateVector(v));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glViewportIndexedfv), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlViewportPositionWScaleNV(Uint64 sessionId, uint32_t index, float xcoeff, float ycoeff, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenViewportPositionWScaleNV(builder, index, xcoeff, ycoeff);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glViewportPositionWScaleNV), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlViewportSwizzleNV(Uint64 sessionId, uint32_t index, uint32_t swizzlex, uint32_t swizzley, uint32_t swizzlez, uint32_t swizzlew, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenViewportSwizzleNV(builder, index, swizzlex, swizzley, swizzlez, swizzlew);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glViewportSwizzleNV), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlWaitSync(Uint64 sessionId, uint64_t sync, uint32_t flags, uint64_t timeout, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenWaitSync(builder, sync, flags, timeout);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glWaitSync), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlWaitVkSemaphoreNV(Uint64 sessionId, uint64_t vkSemaphore, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenWaitVkSemaphoreNV(builder, vkSemaphore);
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glWaitVkSemaphoreNV), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
inline Bool SendGlWeightPathsNV(Uint64 sessionId, uint32_t resultPath, int32_t numPaths, const std::vector<uint32_t>& paths, const std::vector<float>& weights, Uint64 token, MobileGLShmHandle* shm = nullptr) {
flatbuffers::FlatBufferBuilder builder;
auto payload = MobileGL::Protocol::WireFull::CreateGenWeightPathsNV(builder, resultPath, numPaths, builder.CreateVector(paths), builder.CreateVector(weights));
builder.Finish(payload);
return MobileGL::Client::SendWirePayload(sessionId, static_cast<uint32_t>(MobileGL::Protocol::MobileGLOpcode::glWeightPathsNV), token,
builder.GetBufferPointer(),
static_cast<Uint32>(builder.GetSize()), shm);
}
} // namespace MobileGL::Client::Wire
// End of File
Reference in New Issue View Git Blame Copy Permalink