swung0x48/MobileGL
1
0
Fork 0
mirror of https://github.com/MobileGL-Dev/MobileGL synced 2026-11-13 04:53:23 +09:00
Code Issues Packages Projects Releases Wiki Activity
Files
bc38b0f7352afbdfbee86028ec598ba920dff190
MobileGL/MobileGL/MG_Protocol/gen/wire_generated.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

4175 lines
148 KiB
C++
Raw Blame History

// automatically generated by the FlatBuffers compiler, do not modify
#ifndef FLATBUFFERS_GENERATED_WIRE_MOBILEGL_PROTOCOL_WIRE_H_
#define FLATBUFFERS_GENERATED_WIRE_MOBILEGL_PROTOCOL_WIRE_H_
#include "flatbuffers/flatbuffers.h"
// Ensure the included flatbuffers.h is the same version as when this file was
// generated, otherwise it may not be compatible.
static_assert(FLATBUFFERS_VERSION_MAJOR == 25 &&
FLATBUFFERS_VERSION_MINOR == 12 &&
FLATBUFFERS_VERSION_REVISION == 19,
"Non-compatible flatbuffers version included");
namespace MobileGL {
namespace Protocol {
namespace Wire {
struct GlClear;
struct GlClearBuilder;
struct ClearColor;
struct ClearColorBuilder;
struct DrawArrays;
struct DrawArraysBuilder;
struct DrawElements;
struct DrawElementsBuilder;
struct BufferSubData;
struct BufferSubDataBuilder;
struct MemoryBarrier;
struct MemoryBarrierBuilder;
struct MemoryBarrierByRegion;
struct MemoryBarrierByRegionBuilder;
struct PatchParameteri;
struct PatchParameteriBuilder;
struct GenerateMipmap;
struct GenerateMipmapBuilder;
struct DispatchCompute;
struct DispatchComputeBuilder;
struct BeginTransformFeedback;
struct BeginTransformFeedbackBuilder;
struct BindTransformFeedback;
struct BindTransformFeedbackBuilder;
struct BlitFramebuffer;
struct BlitFramebufferBuilder;
struct SwapBuffers;
struct SwapBuffersBuilder;
struct DispatchComputeIndirect;
struct DispatchComputeIndirectBuilder;
struct FenceSync;
struct FenceSyncBuilder;
struct DeleteSync;
struct DeleteSyncBuilder;
struct WaitSync;
struct WaitSyncBuilder;
struct DrawArraysInstanced;
struct DrawArraysInstancedBuilder;
struct DrawElementsInstanced;
struct DrawElementsInstancedBuilder;
struct DrawRangeElements;
struct DrawRangeElementsBuilder;
struct BufferRespecify;
struct BufferRespecifyBuilder;
struct DrawArraysIndirect;
struct DrawArraysIndirectBuilder;
struct DrawElementsIndirect;
struct DrawElementsIndirectBuilder;
struct GetString;
struct GetStringBuilder;
struct GetStringi;
struct GetStringiBuilder;
struct TextureRespecify;
struct TextureRespecifyBuilder;
struct TextureSubImage;
struct TextureSubImageBuilder;
struct ReadPixels;
struct ReadPixelsBuilder;
struct BufferReadbackFromGpu;
struct BufferReadbackFromGpuBuilder;
struct MapBufferRange;
struct MapBufferRangeBuilder;
struct UnmapBuffer;
struct UnmapBufferBuilder;
struct EglCreatePbufferSurface;
struct EglCreatePbufferSurfaceBuilder;
struct EglCreateWindowSurface;
struct EglCreateWindowSurfaceBuilder;
struct EglDestroySurface;
struct EglDestroySurfaceBuilder;
struct EglMakeCurrent;
struct EglMakeCurrentBuilder;
struct EglSwapInterval;
struct EglSwapIntervalBuilder;
struct EglResizeSurface;
struct EglResizeSurfaceBuilder;
struct ClientWaitSync;
struct ClientWaitSyncBuilder;
struct BeginTimeElapsedQuery;
struct BeginTimeElapsedQueryBuilder;
struct EndTimeElapsedQuery;
struct EndTimeElapsedQueryBuilder;
struct DeleteBackendQuery;
struct DeleteBackendQueryBuilder;
struct IsQueryResultAvailable;
struct IsQueryResultAvailableBuilder;
struct GetQueryResult64;
struct GetQueryResult64Builder;
struct BeginOcclusionQuery;
struct BeginOcclusionQueryBuilder;
struct EndOcclusionQuery;
struct EndOcclusionQueryBuilder;
struct BeginXfbPrimitivesQuery;
struct BeginXfbPrimitivesQueryBuilder;
struct EndXfbPrimitivesQuery;
struct EndXfbPrimitivesQueryBuilder;
struct DataBlob;
struct DataBlobBuilder;
struct Command;
struct CommandBuilder;
struct ActiveVariable;
struct ActiveVariableBuilder;
struct Message;
struct MessageBuilder;
struct Response;
struct ResponseBuilder;
struct GlClear FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
typedef GlClearBuilder Builder;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_MASK = 4
};
uint32_t mask() const {
return GetField<uint32_t>(VT_MASK, 0);
}
template <bool B = false>
bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<uint32_t>(verifier, VT_MASK, 4) &&
verifier.EndTable();
}
};
struct GlClearBuilder {
typedef GlClear Table;
::flatbuffers::FlatBufferBuilder &fbb_;
::flatbuffers::uoffset_t start_;
void add_mask(uint32_t mask) {
fbb_.AddElement<uint32_t>(GlClear::VT_MASK, mask, 0);
}
explicit GlClearBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
::flatbuffers::Offset<GlClear> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = ::flatbuffers::Offset<GlClear>(end);
return o;
}
};
inline ::flatbuffers::Offset<GlClear> CreateGlClear(
::flatbuffers::FlatBufferBuilder &_fbb,
uint32_t mask = 0) {
GlClearBuilder builder_(_fbb);
builder_.add_mask(mask);
return builder_.Finish();
}
struct ClearColor FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
typedef ClearColorBuilder Builder;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_RED = 4,
VT_GREEN = 6,
VT_BLUE = 8,
VT_ALPHA = 10
};
float red() const {
return GetField<float>(VT_RED, 0.0f);
}
float green() const {
return GetField<float>(VT_GREEN, 0.0f);
}
float blue() const {
return GetField<float>(VT_BLUE, 0.0f);
}
float alpha() const {
return GetField<float>(VT_ALPHA, 0.0f);
}
template <bool B = false>
bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<float>(verifier, VT_RED, 4) &&
VerifyField<float>(verifier, VT_GREEN, 4) &&
VerifyField<float>(verifier, VT_BLUE, 4) &&
VerifyField<float>(verifier, VT_ALPHA, 4) &&
verifier.EndTable();
}
};
struct ClearColorBuilder {
typedef ClearColor Table;
::flatbuffers::FlatBufferBuilder &fbb_;
::flatbuffers::uoffset_t start_;
void add_red(float red) {
fbb_.AddElement<float>(ClearColor::VT_RED, red, 0.0f);
}
void add_green(float green) {
fbb_.AddElement<float>(ClearColor::VT_GREEN, green, 0.0f);
}
void add_blue(float blue) {
fbb_.AddElement<float>(ClearColor::VT_BLUE, blue, 0.0f);
}
void add_alpha(float alpha) {
fbb_.AddElement<float>(ClearColor::VT_ALPHA, alpha, 0.0f);
}
explicit ClearColorBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
::flatbuffers::Offset<ClearColor> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = ::flatbuffers::Offset<ClearColor>(end);
return o;
}
};
inline ::flatbuffers::Offset<ClearColor> CreateClearColor(
::flatbuffers::FlatBufferBuilder &_fbb,
float red = 0.0f,
float green = 0.0f,
float blue = 0.0f,
float alpha = 0.0f) {
ClearColorBuilder builder_(_fbb);
builder_.add_alpha(alpha);
builder_.add_blue(blue);
builder_.add_green(green);
builder_.add_red(red);
return builder_.Finish();
}
struct DrawArrays FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
typedef DrawArraysBuilder Builder;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_MODE = 4,
VT_FIRST = 6,
VT_COUNT = 8
};
uint32_t mode() const {
return GetField<uint32_t>(VT_MODE, 0);
}
int32_t first() const {
return GetField<int32_t>(VT_FIRST, 0);
}
int32_t count() const {
return GetField<int32_t>(VT_COUNT, 0);
}
template <bool B = false>
bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<uint32_t>(verifier, VT_MODE, 4) &&
VerifyField<int32_t>(verifier, VT_FIRST, 4) &&
VerifyField<int32_t>(verifier, VT_COUNT, 4) &&
verifier.EndTable();
}
};
struct DrawArraysBuilder {
typedef DrawArrays Table;
::flatbuffers::FlatBufferBuilder &fbb_;
::flatbuffers::uoffset_t start_;
void add_mode(uint32_t mode) {
fbb_.AddElement<uint32_t>(DrawArrays::VT_MODE, mode, 0);
}
void add_first(int32_t first) {
fbb_.AddElement<int32_t>(DrawArrays::VT_FIRST, first, 0);
}
void add_count(int32_t count) {
fbb_.AddElement<int32_t>(DrawArrays::VT_COUNT, count, 0);
}
explicit DrawArraysBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
::flatbuffers::Offset<DrawArrays> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = ::flatbuffers::Offset<DrawArrays>(end);
return o;
}
};
inline ::flatbuffers::Offset<DrawArrays> CreateDrawArrays(
::flatbuffers::FlatBufferBuilder &_fbb,
uint32_t mode = 0,
int32_t first = 0,
int32_t count = 0) {
DrawArraysBuilder builder_(_fbb);
builder_.add_count(count);
builder_.add_first(first);
builder_.add_mode(mode);
return builder_.Finish();
}
struct DrawElements FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
typedef DrawElementsBuilder Builder;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_MODE = 4,
VT_COUNT = 6,
VT_TYPE = 8,
VT_INDICES_OFFSET = 10
};
uint32_t mode() const {
return GetField<uint32_t>(VT_MODE, 0);
}
int32_t count() const {
return GetField<int32_t>(VT_COUNT, 0);
}
uint32_t type() const {
return GetField<uint32_t>(VT_TYPE, 0);
}
uint64_t indices_offset() const {
return GetField<uint64_t>(VT_INDICES_OFFSET, 0);
}
template <bool B = false>
bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<uint32_t>(verifier, VT_MODE, 4) &&
VerifyField<int32_t>(verifier, VT_COUNT, 4) &&
VerifyField<uint32_t>(verifier, VT_TYPE, 4) &&
VerifyField<uint64_t>(verifier, VT_INDICES_OFFSET, 8) &&
verifier.EndTable();
}
};
struct DrawElementsBuilder {
typedef DrawElements Table;
::flatbuffers::FlatBufferBuilder &fbb_;
::flatbuffers::uoffset_t start_;
void add_mode(uint32_t mode) {
fbb_.AddElement<uint32_t>(DrawElements::VT_MODE, mode, 0);
}
void add_count(int32_t count) {
fbb_.AddElement<int32_t>(DrawElements::VT_COUNT, count, 0);
}
void add_type(uint32_t type) {
fbb_.AddElement<uint32_t>(DrawElements::VT_TYPE, type, 0);
}
void add_indices_offset(uint64_t indices_offset) {
fbb_.AddElement<uint64_t>(DrawElements::VT_INDICES_OFFSET, indices_offset, 0);
}
explicit DrawElementsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
::flatbuffers::Offset<DrawElements> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = ::flatbuffers::Offset<DrawElements>(end);
return o;
}
};
inline ::flatbuffers::Offset<DrawElements> CreateDrawElements(
::flatbuffers::FlatBufferBuilder &_fbb,
uint32_t mode = 0,
int32_t count = 0,
uint32_t type = 0,
uint64_t indices_offset = 0) {
DrawElementsBuilder builder_(_fbb);
builder_.add_indices_offset(indices_offset);
builder_.add_type(type);
builder_.add_count(count);
builder_.add_mode(mode);
return builder_.Finish();
}
struct BufferSubData FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
typedef BufferSubDataBuilder Builder;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_BUFFER_HANDLE = 4,
VT_OFFSET = 6,
VT_SIZE = 8
};
uint64_t buffer_handle() const {
return GetField<uint64_t>(VT_BUFFER_HANDLE, 0);
}
uint64_t offset() const {
return GetField<uint64_t>(VT_OFFSET, 0);
}
uint64_t size() const {
return GetField<uint64_t>(VT_SIZE, 0);
}
template <bool B = false>
bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<uint64_t>(verifier, VT_BUFFER_HANDLE, 8) &&
VerifyField<uint64_t>(verifier, VT_OFFSET, 8) &&
VerifyField<uint64_t>(verifier, VT_SIZE, 8) &&
verifier.EndTable();
}
};
struct BufferSubDataBuilder {
typedef BufferSubData Table;
::flatbuffers::FlatBufferBuilder &fbb_;
::flatbuffers::uoffset_t start_;
void add_buffer_handle(uint64_t buffer_handle) {
fbb_.AddElement<uint64_t>(BufferSubData::VT_BUFFER_HANDLE, buffer_handle, 0);
}
void add_offset(uint64_t offset) {
fbb_.AddElement<uint64_t>(BufferSubData::VT_OFFSET, offset, 0);
}
void add_size(uint64_t size) {
fbb_.AddElement<uint64_t>(BufferSubData::VT_SIZE, size, 0);
}
explicit BufferSubDataBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
::flatbuffers::Offset<BufferSubData> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = ::flatbuffers::Offset<BufferSubData>(end);
return o;
}
};
inline ::flatbuffers::Offset<BufferSubData> CreateBufferSubData(
::flatbuffers::FlatBufferBuilder &_fbb,
uint64_t buffer_handle = 0,
uint64_t offset = 0,
uint64_t size = 0) {
BufferSubDataBuilder builder_(_fbb);
builder_.add_size(size);
builder_.add_offset(offset);
builder_.add_buffer_handle(buffer_handle);
return builder_.Finish();
}
struct MemoryBarrier FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
typedef MemoryBarrierBuilder Builder;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_BARRIERS = 4
};
uint32_t barriers() const {
return GetField<uint32_t>(VT_BARRIERS, 0);
}
template <bool B = false>
bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<uint32_t>(verifier, VT_BARRIERS, 4) &&
verifier.EndTable();
}
};
struct MemoryBarrierBuilder {
typedef MemoryBarrier Table;
::flatbuffers::FlatBufferBuilder &fbb_;
::flatbuffers::uoffset_t start_;
void add_barriers(uint32_t barriers) {
fbb_.AddElement<uint32_t>(MemoryBarrier::VT_BARRIERS, barriers, 0);
}
explicit MemoryBarrierBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
::flatbuffers::Offset<MemoryBarrier> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = ::flatbuffers::Offset<MemoryBarrier>(end);
return o;
}
};
inline ::flatbuffers::Offset<MemoryBarrier> CreateMemoryBarrier(
::flatbuffers::FlatBufferBuilder &_fbb,
uint32_t barriers = 0) {
MemoryBarrierBuilder builder_(_fbb);
builder_.add_barriers(barriers);
return builder_.Finish();
}
struct MemoryBarrierByRegion FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
typedef MemoryBarrierByRegionBuilder Builder;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_BARRIERS = 4
};
uint32_t barriers() const {
return GetField<uint32_t>(VT_BARRIERS, 0);
}
template <bool B = false>
bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<uint32_t>(verifier, VT_BARRIERS, 4) &&
verifier.EndTable();
}
};
struct MemoryBarrierByRegionBuilder {
typedef MemoryBarrierByRegion Table;
::flatbuffers::FlatBufferBuilder &fbb_;
::flatbuffers::uoffset_t start_;
void add_barriers(uint32_t barriers) {
fbb_.AddElement<uint32_t>(MemoryBarrierByRegion::VT_BARRIERS, barriers, 0);
}
explicit MemoryBarrierByRegionBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
::flatbuffers::Offset<MemoryBarrierByRegion> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = ::flatbuffers::Offset<MemoryBarrierByRegion>(end);
return o;
}
};
inline ::flatbuffers::Offset<MemoryBarrierByRegion> CreateMemoryBarrierByRegion(
::flatbuffers::FlatBufferBuilder &_fbb,
uint32_t barriers = 0) {
MemoryBarrierByRegionBuilder builder_(_fbb);
builder_.add_barriers(barriers);
return builder_.Finish();
}
struct PatchParameteri FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
typedef PatchParameteriBuilder Builder;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_PNAME = 4,
VT_VALUE = 6
};
uint32_t pname() const {
return GetField<uint32_t>(VT_PNAME, 0);
}
int32_t value() const {
return GetField<int32_t>(VT_VALUE, 0);
}
template <bool B = false>
bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<uint32_t>(verifier, VT_PNAME, 4) &&
VerifyField<int32_t>(verifier, VT_VALUE, 4) &&
verifier.EndTable();
}
};
struct PatchParameteriBuilder {
typedef PatchParameteri Table;
::flatbuffers::FlatBufferBuilder &fbb_;
::flatbuffers::uoffset_t start_;
void add_pname(uint32_t pname) {
fbb_.AddElement<uint32_t>(PatchParameteri::VT_PNAME, pname, 0);
}
void add_value(int32_t value) {
fbb_.AddElement<int32_t>(PatchParameteri::VT_VALUE, value, 0);
}
explicit PatchParameteriBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
::flatbuffers::Offset<PatchParameteri> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = ::flatbuffers::Offset<PatchParameteri>(end);
return o;
}
};
inline ::flatbuffers::Offset<PatchParameteri> CreatePatchParameteri(
::flatbuffers::FlatBufferBuilder &_fbb,
uint32_t pname = 0,
int32_t value = 0) {
PatchParameteriBuilder builder_(_fbb);
builder_.add_value(value);
builder_.add_pname(pname);
return builder_.Finish();
}
struct GenerateMipmap FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
typedef GenerateMipmapBuilder Builder;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_TARGET = 4
};
uint32_t target() const {
return GetField<uint32_t>(VT_TARGET, 0);
}
template <bool B = false>
bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<uint32_t>(verifier, VT_TARGET, 4) &&
verifier.EndTable();
}
};
struct GenerateMipmapBuilder {
typedef GenerateMipmap Table;
::flatbuffers::FlatBufferBuilder &fbb_;
::flatbuffers::uoffset_t start_;
void add_target(uint32_t target) {
fbb_.AddElement<uint32_t>(GenerateMipmap::VT_TARGET, target, 0);
}
explicit GenerateMipmapBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
::flatbuffers::Offset<GenerateMipmap> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = ::flatbuffers::Offset<GenerateMipmap>(end);
return o;
}
};
inline ::flatbuffers::Offset<GenerateMipmap> CreateGenerateMipmap(
::flatbuffers::FlatBufferBuilder &_fbb,
uint32_t target = 0) {
GenerateMipmapBuilder builder_(_fbb);
builder_.add_target(target);
return builder_.Finish();
}
struct DispatchCompute FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
typedef DispatchComputeBuilder Builder;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_NUM_GROUPS_X = 4,
VT_NUM_GROUPS_Y = 6,
VT_NUM_GROUPS_Z = 8
};
uint32_t num_groups_x() const {
return GetField<uint32_t>(VT_NUM_GROUPS_X, 0);
}
uint32_t num_groups_y() const {
return GetField<uint32_t>(VT_NUM_GROUPS_Y, 0);
}
uint32_t num_groups_z() const {
return GetField<uint32_t>(VT_NUM_GROUPS_Z, 0);
}
template <bool B = false>
bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<uint32_t>(verifier, VT_NUM_GROUPS_X, 4) &&
VerifyField<uint32_t>(verifier, VT_NUM_GROUPS_Y, 4) &&
VerifyField<uint32_t>(verifier, VT_NUM_GROUPS_Z, 4) &&
verifier.EndTable();
}
};
struct DispatchComputeBuilder {
typedef DispatchCompute Table;
::flatbuffers::FlatBufferBuilder &fbb_;
::flatbuffers::uoffset_t start_;
void add_num_groups_x(uint32_t num_groups_x) {
fbb_.AddElement<uint32_t>(DispatchCompute::VT_NUM_GROUPS_X, num_groups_x, 0);
}
void add_num_groups_y(uint32_t num_groups_y) {
fbb_.AddElement<uint32_t>(DispatchCompute::VT_NUM_GROUPS_Y, num_groups_y, 0);
}
void add_num_groups_z(uint32_t num_groups_z) {
fbb_.AddElement<uint32_t>(DispatchCompute::VT_NUM_GROUPS_Z, num_groups_z, 0);
}
explicit DispatchComputeBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
::flatbuffers::Offset<DispatchCompute> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = ::flatbuffers::Offset<DispatchCompute>(end);
return o;
}
};
inline ::flatbuffers::Offset<DispatchCompute> CreateDispatchCompute(
::flatbuffers::FlatBufferBuilder &_fbb,
uint32_t num_groups_x = 0,
uint32_t num_groups_y = 0,
uint32_t num_groups_z = 0) {
DispatchComputeBuilder builder_(_fbb);
builder_.add_num_groups_z(num_groups_z);
builder_.add_num_groups_y(num_groups_y);
builder_.add_num_groups_x(num_groups_x);
return builder_.Finish();
}
struct BeginTransformFeedback FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
typedef BeginTransformFeedbackBuilder Builder;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_PRIMITIVE_MODE = 4
};
uint32_t primitive_mode() const {
return GetField<uint32_t>(VT_PRIMITIVE_MODE, 0);
}
template <bool B = false>
bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<uint32_t>(verifier, VT_PRIMITIVE_MODE, 4) &&
verifier.EndTable();
}
};
struct BeginTransformFeedbackBuilder {
typedef BeginTransformFeedback Table;
::flatbuffers::FlatBufferBuilder &fbb_;
::flatbuffers::uoffset_t start_;
void add_primitive_mode(uint32_t primitive_mode) {
fbb_.AddElement<uint32_t>(BeginTransformFeedback::VT_PRIMITIVE_MODE, primitive_mode, 0);
}
explicit BeginTransformFeedbackBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
::flatbuffers::Offset<BeginTransformFeedback> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = ::flatbuffers::Offset<BeginTransformFeedback>(end);
return o;
}
};
inline ::flatbuffers::Offset<BeginTransformFeedback> CreateBeginTransformFeedback(
::flatbuffers::FlatBufferBuilder &_fbb,
uint32_t primitive_mode = 0) {
BeginTransformFeedbackBuilder builder_(_fbb);
builder_.add_primitive_mode(primitive_mode);
return builder_.Finish();
}
struct BindTransformFeedback FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
typedef BindTransformFeedbackBuilder Builder;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_NAME = 4
};
uint32_t name() const {
return GetField<uint32_t>(VT_NAME, 0);
}
template <bool B = false>
bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<uint32_t>(verifier, VT_NAME, 4) &&
verifier.EndTable();
}
};
struct BindTransformFeedbackBuilder {
typedef BindTransformFeedback Table;
::flatbuffers::FlatBufferBuilder &fbb_;
::flatbuffers::uoffset_t start_;
void add_name(uint32_t name) {
fbb_.AddElement<uint32_t>(BindTransformFeedback::VT_NAME, name, 0);
}
explicit BindTransformFeedbackBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
::flatbuffers::Offset<BindTransformFeedback> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = ::flatbuffers::Offset<BindTransformFeedback>(end);
return o;
}
};
inline ::flatbuffers::Offset<BindTransformFeedback> CreateBindTransformFeedback(
::flatbuffers::FlatBufferBuilder &_fbb,
uint32_t name = 0) {
BindTransformFeedbackBuilder builder_(_fbb);
builder_.add_name(name);
return builder_.Finish();
}
struct BlitFramebuffer FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
typedef BlitFramebufferBuilder Builder;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_READ_FRAMEBUFFER = 4,
VT_DRAW_FRAMEBUFFER = 6,
VT_SRC_X0 = 8,
VT_SRC_Y0 = 10,
VT_SRC_X1 = 12,
VT_SRC_Y1 = 14,
VT_DST_X0 = 16,
VT_DST_Y0 = 18,
VT_DST_X1 = 20,
VT_DST_Y1 = 22,
VT_MASK = 24,
VT_FILTER = 26
};
uint64_t read_framebuffer() const {
return GetField<uint64_t>(VT_READ_FRAMEBUFFER, 0);
}
uint64_t draw_framebuffer() const {
return GetField<uint64_t>(VT_DRAW_FRAMEBUFFER, 0);
}
int32_t src_x0() const {
return GetField<int32_t>(VT_SRC_X0, 0);
}
int32_t src_y0() const {
return GetField<int32_t>(VT_SRC_Y0, 0);
}
int32_t src_x1() const {
return GetField<int32_t>(VT_SRC_X1, 0);
}
int32_t src_y1() const {
return GetField<int32_t>(VT_SRC_Y1, 0);
}
int32_t dst_x0() const {
return GetField<int32_t>(VT_DST_X0, 0);
}
int32_t dst_y0() const {
return GetField<int32_t>(VT_DST_Y0, 0);
}
int32_t dst_x1() const {
return GetField<int32_t>(VT_DST_X1, 0);
}
int32_t dst_y1() const {
return GetField<int32_t>(VT_DST_Y1, 0);
}
uint32_t mask() const {
return GetField<uint32_t>(VT_MASK, 0);
}
uint32_t filter() const {
return GetField<uint32_t>(VT_FILTER, 0);
}
template <bool B = false>
bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<uint64_t>(verifier, VT_READ_FRAMEBUFFER, 8) &&
VerifyField<uint64_t>(verifier, VT_DRAW_FRAMEBUFFER, 8) &&
VerifyField<int32_t>(verifier, VT_SRC_X0, 4) &&
VerifyField<int32_t>(verifier, VT_SRC_Y0, 4) &&
VerifyField<int32_t>(verifier, VT_SRC_X1, 4) &&
VerifyField<int32_t>(verifier, VT_SRC_Y1, 4) &&
VerifyField<int32_t>(verifier, VT_DST_X0, 4) &&
VerifyField<int32_t>(verifier, VT_DST_Y0, 4) &&
VerifyField<int32_t>(verifier, VT_DST_X1, 4) &&
VerifyField<int32_t>(verifier, VT_DST_Y1, 4) &&
VerifyField<uint32_t>(verifier, VT_MASK, 4) &&
VerifyField<uint32_t>(verifier, VT_FILTER, 4) &&
verifier.EndTable();
}
};
struct BlitFramebufferBuilder {
typedef BlitFramebuffer Table;
::flatbuffers::FlatBufferBuilder &fbb_;
::flatbuffers::uoffset_t start_;
void add_read_framebuffer(uint64_t read_framebuffer) {
fbb_.AddElement<uint64_t>(BlitFramebuffer::VT_READ_FRAMEBUFFER, read_framebuffer, 0);
}
void add_draw_framebuffer(uint64_t draw_framebuffer) {
fbb_.AddElement<uint64_t>(BlitFramebuffer::VT_DRAW_FRAMEBUFFER, draw_framebuffer, 0);
}
void add_src_x0(int32_t src_x0) {
fbb_.AddElement<int32_t>(BlitFramebuffer::VT_SRC_X0, src_x0, 0);
}
void add_src_y0(int32_t src_y0) {
fbb_.AddElement<int32_t>(BlitFramebuffer::VT_SRC_Y0, src_y0, 0);
}
void add_src_x1(int32_t src_x1) {
fbb_.AddElement<int32_t>(BlitFramebuffer::VT_SRC_X1, src_x1, 0);
}
void add_src_y1(int32_t src_y1) {
fbb_.AddElement<int32_t>(BlitFramebuffer::VT_SRC_Y1, src_y1, 0);
}
void add_dst_x0(int32_t dst_x0) {
fbb_.AddElement<int32_t>(BlitFramebuffer::VT_DST_X0, dst_x0, 0);
}
void add_dst_y0(int32_t dst_y0) {
fbb_.AddElement<int32_t>(BlitFramebuffer::VT_DST_Y0, dst_y0, 0);
}
void add_dst_x1(int32_t dst_x1) {
fbb_.AddElement<int32_t>(BlitFramebuffer::VT_DST_X1, dst_x1, 0);
}
void add_dst_y1(int32_t dst_y1) {
fbb_.AddElement<int32_t>(BlitFramebuffer::VT_DST_Y1, dst_y1, 0);
}
void add_mask(uint32_t mask) {
fbb_.AddElement<uint32_t>(BlitFramebuffer::VT_MASK, mask, 0);
}
void add_filter(uint32_t filter) {
fbb_.AddElement<uint32_t>(BlitFramebuffer::VT_FILTER, filter, 0);
}
explicit BlitFramebufferBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
::flatbuffers::Offset<BlitFramebuffer> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = ::flatbuffers::Offset<BlitFramebuffer>(end);
return o;
}
};
inline ::flatbuffers::Offset<BlitFramebuffer> CreateBlitFramebuffer(
::flatbuffers::FlatBufferBuilder &_fbb,
uint64_t read_framebuffer = 0,
uint64_t draw_framebuffer = 0,
int32_t src_x0 = 0,
int32_t src_y0 = 0,
int32_t src_x1 = 0,
int32_t src_y1 = 0,
int32_t dst_x0 = 0,
int32_t dst_y0 = 0,
int32_t dst_x1 = 0,
int32_t dst_y1 = 0,
uint32_t mask = 0,
uint32_t filter = 0) {
BlitFramebufferBuilder builder_(_fbb);
builder_.add_draw_framebuffer(draw_framebuffer);
builder_.add_read_framebuffer(read_framebuffer);
builder_.add_filter(filter);
builder_.add_mask(mask);
builder_.add_dst_y1(dst_y1);
builder_.add_dst_x1(dst_x1);
builder_.add_dst_y0(dst_y0);
builder_.add_dst_x0(dst_x0);
builder_.add_src_y1(src_y1);
builder_.add_src_x1(src_x1);
builder_.add_src_y0(src_y0);
builder_.add_src_x0(src_x0);
return builder_.Finish();
}
struct SwapBuffers FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
typedef SwapBuffersBuilder Builder;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_DRAW = 4
};
uint64_t draw() const {
return GetField<uint64_t>(VT_DRAW, 0);
}
template <bool B = false>
bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<uint64_t>(verifier, VT_DRAW, 8) &&
verifier.EndTable();
}
};
struct SwapBuffersBuilder {
typedef SwapBuffers Table;
::flatbuffers::FlatBufferBuilder &fbb_;
::flatbuffers::uoffset_t start_;
void add_draw(uint64_t draw) {
fbb_.AddElement<uint64_t>(SwapBuffers::VT_DRAW, draw, 0);
}
explicit SwapBuffersBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
::flatbuffers::Offset<SwapBuffers> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = ::flatbuffers::Offset<SwapBuffers>(end);
return o;
}
};
inline ::flatbuffers::Offset<SwapBuffers> CreateSwapBuffers(
::flatbuffers::FlatBufferBuilder &_fbb,
uint64_t draw = 0) {
SwapBuffersBuilder builder_(_fbb);
builder_.add_draw(draw);
return builder_.Finish();
}
struct DispatchComputeIndirect FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
typedef DispatchComputeIndirectBuilder Builder;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_INDIRECT_OFFSET = 4
};
uint64_t indirect_offset() const {
return GetField<uint64_t>(VT_INDIRECT_OFFSET, 0);
}
template <bool B = false>
bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<uint64_t>(verifier, VT_INDIRECT_OFFSET, 8) &&
verifier.EndTable();
}
};
struct DispatchComputeIndirectBuilder {
typedef DispatchComputeIndirect Table;
::flatbuffers::FlatBufferBuilder &fbb_;
::flatbuffers::uoffset_t start_;
void add_indirect_offset(uint64_t indirect_offset) {
fbb_.AddElement<uint64_t>(DispatchComputeIndirect::VT_INDIRECT_OFFSET, indirect_offset, 0);
}
explicit DispatchComputeIndirectBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
::flatbuffers::Offset<DispatchComputeIndirect> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = ::flatbuffers::Offset<DispatchComputeIndirect>(end);
return o;
}
};
inline ::flatbuffers::Offset<DispatchComputeIndirect> CreateDispatchComputeIndirect(
::flatbuffers::FlatBufferBuilder &_fbb,
uint64_t indirect_offset = 0) {
DispatchComputeIndirectBuilder builder_(_fbb);
builder_.add_indirect_offset(indirect_offset);
return builder_.Finish();
}
struct FenceSync FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
typedef FenceSyncBuilder Builder;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_CONDITION = 4,
VT_FLAGS = 6
};
uint32_t condition() const {
return GetField<uint32_t>(VT_CONDITION, 0);
}
uint32_t flags() const {
return GetField<uint32_t>(VT_FLAGS, 0);
}
template <bool B = false>
bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<uint32_t>(verifier, VT_CONDITION, 4) &&
VerifyField<uint32_t>(verifier, VT_FLAGS, 4) &&
verifier.EndTable();
}
};
struct FenceSyncBuilder {
typedef FenceSync Table;
::flatbuffers::FlatBufferBuilder &fbb_;
::flatbuffers::uoffset_t start_;
void add_condition(uint32_t condition) {
fbb_.AddElement<uint32_t>(FenceSync::VT_CONDITION, condition, 0);
}
void add_flags(uint32_t flags) {
fbb_.AddElement<uint32_t>(FenceSync::VT_FLAGS, flags, 0);
}
explicit FenceSyncBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
::flatbuffers::Offset<FenceSync> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = ::flatbuffers::Offset<FenceSync>(end);
return o;
}
};
inline ::flatbuffers::Offset<FenceSync> CreateFenceSync(
::flatbuffers::FlatBufferBuilder &_fbb,
uint32_t condition = 0,
uint32_t flags = 0) {
FenceSyncBuilder builder_(_fbb);
builder_.add_flags(flags);
builder_.add_condition(condition);
return builder_.Finish();
}
struct DeleteSync FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
typedef DeleteSyncBuilder Builder;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_SYNC = 4
};
uint64_t sync() const {
return GetField<uint64_t>(VT_SYNC, 0);
}
template <bool B = false>
bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<uint64_t>(verifier, VT_SYNC, 8) &&
verifier.EndTable();
}
};
struct DeleteSyncBuilder {
typedef DeleteSync Table;
::flatbuffers::FlatBufferBuilder &fbb_;
::flatbuffers::uoffset_t start_;
void add_sync(uint64_t sync) {
fbb_.AddElement<uint64_t>(DeleteSync::VT_SYNC, sync, 0);
}
explicit DeleteSyncBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
::flatbuffers::Offset<DeleteSync> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = ::flatbuffers::Offset<DeleteSync>(end);
return o;
}
};
inline ::flatbuffers::Offset<DeleteSync> CreateDeleteSync(
::flatbuffers::FlatBufferBuilder &_fbb,
uint64_t sync = 0) {
DeleteSyncBuilder builder_(_fbb);
builder_.add_sync(sync);
return builder_.Finish();
}
struct WaitSync FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
typedef WaitSyncBuilder Builder;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_SYNC = 4,
VT_FLAGS = 6,
VT_TIMEOUT = 8
};
uint64_t sync() const {
return GetField<uint64_t>(VT_SYNC, 0);
}
uint32_t flags() const {
return GetField<uint32_t>(VT_FLAGS, 0);
}
uint64_t timeout() const {
return GetField<uint64_t>(VT_TIMEOUT, 0);
}
template <bool B = false>
bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<uint64_t>(verifier, VT_SYNC, 8) &&
VerifyField<uint32_t>(verifier, VT_FLAGS, 4) &&
VerifyField<uint64_t>(verifier, VT_TIMEOUT, 8) &&
verifier.EndTable();
}
};
struct WaitSyncBuilder {
typedef WaitSync Table;
::flatbuffers::FlatBufferBuilder &fbb_;
::flatbuffers::uoffset_t start_;
void add_sync(uint64_t sync) {
fbb_.AddElement<uint64_t>(WaitSync::VT_SYNC, sync, 0);
}
void add_flags(uint32_t flags) {
fbb_.AddElement<uint32_t>(WaitSync::VT_FLAGS, flags, 0);
}
void add_timeout(uint64_t timeout) {
fbb_.AddElement<uint64_t>(WaitSync::VT_TIMEOUT, timeout, 0);
}
explicit WaitSyncBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
::flatbuffers::Offset<WaitSync> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = ::flatbuffers::Offset<WaitSync>(end);
return o;
}
};
inline ::flatbuffers::Offset<WaitSync> CreateWaitSync(
::flatbuffers::FlatBufferBuilder &_fbb,
uint64_t sync = 0,
uint32_t flags = 0,
uint64_t timeout = 0) {
WaitSyncBuilder builder_(_fbb);
builder_.add_timeout(timeout);
builder_.add_sync(sync);
builder_.add_flags(flags);
return builder_.Finish();
}
struct DrawArraysInstanced FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
typedef DrawArraysInstancedBuilder Builder;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_MODE = 4,
VT_FIRST = 6,
VT_COUNT = 8,
VT_PRIMCOUNT = 10
};
uint32_t mode() const {
return GetField<uint32_t>(VT_MODE, 0);
}
int32_t first() const {
return GetField<int32_t>(VT_FIRST, 0);
}
int32_t count() const {
return GetField<int32_t>(VT_COUNT, 0);
}
int32_t primcount() const {
return GetField<int32_t>(VT_PRIMCOUNT, 0);
}
template <bool B = false>
bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<uint32_t>(verifier, VT_MODE, 4) &&
VerifyField<int32_t>(verifier, VT_FIRST, 4) &&
VerifyField<int32_t>(verifier, VT_COUNT, 4) &&
VerifyField<int32_t>(verifier, VT_PRIMCOUNT, 4) &&
verifier.EndTable();
}
};
struct DrawArraysInstancedBuilder {
typedef DrawArraysInstanced Table;
::flatbuffers::FlatBufferBuilder &fbb_;
::flatbuffers::uoffset_t start_;
void add_mode(uint32_t mode) {
fbb_.AddElement<uint32_t>(DrawArraysInstanced::VT_MODE, mode, 0);
}
void add_first(int32_t first) {
fbb_.AddElement<int32_t>(DrawArraysInstanced::VT_FIRST, first, 0);
}
void add_count(int32_t count) {
fbb_.AddElement<int32_t>(DrawArraysInstanced::VT_COUNT, count, 0);
}
void add_primcount(int32_t primcount) {
fbb_.AddElement<int32_t>(DrawArraysInstanced::VT_PRIMCOUNT, primcount, 0);
}
explicit DrawArraysInstancedBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
::flatbuffers::Offset<DrawArraysInstanced> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = ::flatbuffers::Offset<DrawArraysInstanced>(end);
return o;
}
};
inline ::flatbuffers::Offset<DrawArraysInstanced> CreateDrawArraysInstanced(
::flatbuffers::FlatBufferBuilder &_fbb,
uint32_t mode = 0,
int32_t first = 0,
int32_t count = 0,
int32_t primcount = 0) {
DrawArraysInstancedBuilder builder_(_fbb);
builder_.add_primcount(primcount);
builder_.add_count(count);
builder_.add_first(first);
builder_.add_mode(mode);
return builder_.Finish();
}
struct DrawElementsInstanced FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
typedef DrawElementsInstancedBuilder Builder;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_MODE = 4,
VT_COUNT = 6,
VT_TYPE = 8,
VT_INDICES_OFFSET = 10,
VT_INSTANCE_COUNT = 12
};
uint32_t mode() const {
return GetField<uint32_t>(VT_MODE, 0);
}
int32_t count() const {
return GetField<int32_t>(VT_COUNT, 0);
}
uint32_t type() const {
return GetField<uint32_t>(VT_TYPE, 0);
}
uint64_t indices_offset() const {
return GetField<uint64_t>(VT_INDICES_OFFSET, 0);
}
int32_t instance_count() const {
return GetField<int32_t>(VT_INSTANCE_COUNT, 0);
}
template <bool B = false>
bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<uint32_t>(verifier, VT_MODE, 4) &&
VerifyField<int32_t>(verifier, VT_COUNT, 4) &&
VerifyField<uint32_t>(verifier, VT_TYPE, 4) &&
VerifyField<uint64_t>(verifier, VT_INDICES_OFFSET, 8) &&
VerifyField<int32_t>(verifier, VT_INSTANCE_COUNT, 4) &&
verifier.EndTable();
}
};
struct DrawElementsInstancedBuilder {
typedef DrawElementsInstanced Table;
::flatbuffers::FlatBufferBuilder &fbb_;
::flatbuffers::uoffset_t start_;
void add_mode(uint32_t mode) {
fbb_.AddElement<uint32_t>(DrawElementsInstanced::VT_MODE, mode, 0);
}
void add_count(int32_t count) {
fbb_.AddElement<int32_t>(DrawElementsInstanced::VT_COUNT, count, 0);
}
void add_type(uint32_t type) {
fbb_.AddElement<uint32_t>(DrawElementsInstanced::VT_TYPE, type, 0);
}
void add_indices_offset(uint64_t indices_offset) {
fbb_.AddElement<uint64_t>(DrawElementsInstanced::VT_INDICES_OFFSET, indices_offset, 0);
}
void add_instance_count(int32_t instance_count) {
fbb_.AddElement<int32_t>(DrawElementsInstanced::VT_INSTANCE_COUNT, instance_count, 0);
}
explicit DrawElementsInstancedBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
::flatbuffers::Offset<DrawElementsInstanced> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = ::flatbuffers::Offset<DrawElementsInstanced>(end);
return o;
}
};
inline ::flatbuffers::Offset<DrawElementsInstanced> CreateDrawElementsInstanced(
::flatbuffers::FlatBufferBuilder &_fbb,
uint32_t mode = 0,
int32_t count = 0,
uint32_t type = 0,
uint64_t indices_offset = 0,
int32_t instance_count = 0) {
DrawElementsInstancedBuilder builder_(_fbb);
builder_.add_indices_offset(indices_offset);
builder_.add_instance_count(instance_count);
builder_.add_type(type);
builder_.add_count(count);
builder_.add_mode(mode);
return builder_.Finish();
}
struct DrawRangeElements FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
typedef DrawRangeElementsBuilder Builder;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_MODE = 4,
VT_START = 6,
VT_END = 8,
VT_COUNT = 10,
VT_TYPE = 12,
VT_INDICES_OFFSET = 14
};
uint32_t mode() const {
return GetField<uint32_t>(VT_MODE, 0);
}
uint32_t start() const {
return GetField<uint32_t>(VT_START, 0);
}
uint32_t end() const {
return GetField<uint32_t>(VT_END, 0);
}
int32_t count() const {
return GetField<int32_t>(VT_COUNT, 0);
}
uint32_t type() const {
return GetField<uint32_t>(VT_TYPE, 0);
}
uint64_t indices_offset() const {
return GetField<uint64_t>(VT_INDICES_OFFSET, 0);
}
template <bool B = false>
bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<uint32_t>(verifier, VT_MODE, 4) &&
VerifyField<uint32_t>(verifier, VT_START, 4) &&
VerifyField<uint32_t>(verifier, VT_END, 4) &&
VerifyField<int32_t>(verifier, VT_COUNT, 4) &&
VerifyField<uint32_t>(verifier, VT_TYPE, 4) &&
VerifyField<uint64_t>(verifier, VT_INDICES_OFFSET, 8) &&
verifier.EndTable();
}
};
struct DrawRangeElementsBuilder {
typedef DrawRangeElements Table;
::flatbuffers::FlatBufferBuilder &fbb_;
::flatbuffers::uoffset_t start_;
void add_mode(uint32_t mode) {
fbb_.AddElement<uint32_t>(DrawRangeElements::VT_MODE, mode, 0);
}
void add_start(uint32_t start) {
fbb_.AddElement<uint32_t>(DrawRangeElements::VT_START, start, 0);
}
void add_end(uint32_t end) {
fbb_.AddElement<uint32_t>(DrawRangeElements::VT_END, end, 0);
}
void add_count(int32_t count) {
fbb_.AddElement<int32_t>(DrawRangeElements::VT_COUNT, count, 0);
}
void add_type(uint32_t type) {
fbb_.AddElement<uint32_t>(DrawRangeElements::VT_TYPE, type, 0);
}
void add_indices_offset(uint64_t indices_offset) {
fbb_.AddElement<uint64_t>(DrawRangeElements::VT_INDICES_OFFSET, indices_offset, 0);
}
explicit DrawRangeElementsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
::flatbuffers::Offset<DrawRangeElements> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = ::flatbuffers::Offset<DrawRangeElements>(end);
return o;
}
};
inline ::flatbuffers::Offset<DrawRangeElements> CreateDrawRangeElements(
::flatbuffers::FlatBufferBuilder &_fbb,
uint32_t mode = 0,
uint32_t start = 0,
uint32_t end = 0,
int32_t count = 0,
uint32_t type = 0,
uint64_t indices_offset = 0) {
DrawRangeElementsBuilder builder_(_fbb);
builder_.add_indices_offset(indices_offset);
builder_.add_type(type);
builder_.add_count(count);
builder_.add_end(end);
builder_.add_start(start);
builder_.add_mode(mode);
return builder_.Finish();
}
struct BufferRespecify FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
typedef BufferRespecifyBuilder Builder;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_BUFFER_HANDLE = 4,
VT_SIZE = 6,
VT_USAGE = 8
};
uint64_t buffer_handle() const {
return GetField<uint64_t>(VT_BUFFER_HANDLE, 0);
}
uint64_t size() const {
return GetField<uint64_t>(VT_SIZE, 0);
}
uint32_t usage() const {
return GetField<uint32_t>(VT_USAGE, 0);
}
template <bool B = false>
bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<uint64_t>(verifier, VT_BUFFER_HANDLE, 8) &&
VerifyField<uint64_t>(verifier, VT_SIZE, 8) &&
VerifyField<uint32_t>(verifier, VT_USAGE, 4) &&
verifier.EndTable();
}
};
struct BufferRespecifyBuilder {
typedef BufferRespecify Table;
::flatbuffers::FlatBufferBuilder &fbb_;
::flatbuffers::uoffset_t start_;
void add_buffer_handle(uint64_t buffer_handle) {
fbb_.AddElement<uint64_t>(BufferRespecify::VT_BUFFER_HANDLE, buffer_handle, 0);
}
void add_size(uint64_t size) {
fbb_.AddElement<uint64_t>(BufferRespecify::VT_SIZE, size, 0);
}
void add_usage(uint32_t usage) {
fbb_.AddElement<uint32_t>(BufferRespecify::VT_USAGE, usage, 0);
}
explicit BufferRespecifyBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
::flatbuffers::Offset<BufferRespecify> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = ::flatbuffers::Offset<BufferRespecify>(end);
return o;
}
};
inline ::flatbuffers::Offset<BufferRespecify> CreateBufferRespecify(
::flatbuffers::FlatBufferBuilder &_fbb,
uint64_t buffer_handle = 0,
uint64_t size = 0,
uint32_t usage = 0) {
BufferRespecifyBuilder builder_(_fbb);
builder_.add_size(size);
builder_.add_buffer_handle(buffer_handle);
builder_.add_usage(usage);
return builder_.Finish();
}
struct DrawArraysIndirect FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
typedef DrawArraysIndirectBuilder Builder;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_MODE = 4,
VT_SHM_OFFSET = 6
};
uint32_t mode() const {
return GetField<uint32_t>(VT_MODE, 0);
}
uint64_t shm_offset() const {
return GetField<uint64_t>(VT_SHM_OFFSET, 0);
}
template <bool B = false>
bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<uint32_t>(verifier, VT_MODE, 4) &&
VerifyField<uint64_t>(verifier, VT_SHM_OFFSET, 8) &&
verifier.EndTable();
}
};
struct DrawArraysIndirectBuilder {
typedef DrawArraysIndirect Table;
::flatbuffers::FlatBufferBuilder &fbb_;
::flatbuffers::uoffset_t start_;
void add_mode(uint32_t mode) {
fbb_.AddElement<uint32_t>(DrawArraysIndirect::VT_MODE, mode, 0);
}
void add_shm_offset(uint64_t shm_offset) {
fbb_.AddElement<uint64_t>(DrawArraysIndirect::VT_SHM_OFFSET, shm_offset, 0);
}
explicit DrawArraysIndirectBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
::flatbuffers::Offset<DrawArraysIndirect> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = ::flatbuffers::Offset<DrawArraysIndirect>(end);
return o;
}
};
inline ::flatbuffers::Offset<DrawArraysIndirect> CreateDrawArraysIndirect(
::flatbuffers::FlatBufferBuilder &_fbb,
uint32_t mode = 0,
uint64_t shm_offset = 0) {
DrawArraysIndirectBuilder builder_(_fbb);
builder_.add_shm_offset(shm_offset);
builder_.add_mode(mode);
return builder_.Finish();
}
struct DrawElementsIndirect FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
typedef DrawElementsIndirectBuilder Builder;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_MODE = 4,
VT_TYPE = 6,
VT_SHM_OFFSET = 8
};
uint32_t mode() const {
return GetField<uint32_t>(VT_MODE, 0);
}
uint32_t type() const {
return GetField<uint32_t>(VT_TYPE, 0);
}
uint64_t shm_offset() const {
return GetField<uint64_t>(VT_SHM_OFFSET, 0);
}
template <bool B = false>
bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<uint32_t>(verifier, VT_MODE, 4) &&
VerifyField<uint32_t>(verifier, VT_TYPE, 4) &&
VerifyField<uint64_t>(verifier, VT_SHM_OFFSET, 8) &&
verifier.EndTable();
}
};
struct DrawElementsIndirectBuilder {
typedef DrawElementsIndirect Table;
::flatbuffers::FlatBufferBuilder &fbb_;
::flatbuffers::uoffset_t start_;
void add_mode(uint32_t mode) {
fbb_.AddElement<uint32_t>(DrawElementsIndirect::VT_MODE, mode, 0);
}
void add_type(uint32_t type) {
fbb_.AddElement<uint32_t>(DrawElementsIndirect::VT_TYPE, type, 0);
}
void add_shm_offset(uint64_t shm_offset) {
fbb_.AddElement<uint64_t>(DrawElementsIndirect::VT_SHM_OFFSET, shm_offset, 0);
}
explicit DrawElementsIndirectBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
::flatbuffers::Offset<DrawElementsIndirect> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = ::flatbuffers::Offset<DrawElementsIndirect>(end);
return o;
}
};
inline ::flatbuffers::Offset<DrawElementsIndirect> CreateDrawElementsIndirect(
::flatbuffers::FlatBufferBuilder &_fbb,
uint32_t mode = 0,
uint32_t type = 0,
uint64_t shm_offset = 0) {
DrawElementsIndirectBuilder builder_(_fbb);
builder_.add_shm_offset(shm_offset);
builder_.add_type(type);
builder_.add_mode(mode);
return builder_.Finish();
}
struct GetString FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
typedef GetStringBuilder Builder;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_PNAME = 4
};
uint32_t pname() const {
return GetField<uint32_t>(VT_PNAME, 0);
}
template <bool B = false>
bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<uint32_t>(verifier, VT_PNAME, 4) &&
verifier.EndTable();
}
};
struct GetStringBuilder {
typedef GetString Table;
::flatbuffers::FlatBufferBuilder &fbb_;
::flatbuffers::uoffset_t start_;
void add_pname(uint32_t pname) {
fbb_.AddElement<uint32_t>(GetString::VT_PNAME, pname, 0);
}
explicit GetStringBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
::flatbuffers::Offset<GetString> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = ::flatbuffers::Offset<GetString>(end);
return o;
}
};
inline ::flatbuffers::Offset<GetString> CreateGetString(
::flatbuffers::FlatBufferBuilder &_fbb,
uint32_t pname = 0) {
GetStringBuilder builder_(_fbb);
builder_.add_pname(pname);
return builder_.Finish();
}
struct GetStringi FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
typedef GetStringiBuilder Builder;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_PNAME = 4,
VT_INDEX = 6
};
uint32_t pname() const {
return GetField<uint32_t>(VT_PNAME, 0);
}
uint32_t index() const {
return GetField<uint32_t>(VT_INDEX, 0);
}
template <bool B = false>
bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<uint32_t>(verifier, VT_PNAME, 4) &&
VerifyField<uint32_t>(verifier, VT_INDEX, 4) &&
verifier.EndTable();
}
};
struct GetStringiBuilder {
typedef GetStringi Table;
::flatbuffers::FlatBufferBuilder &fbb_;
::flatbuffers::uoffset_t start_;
void add_pname(uint32_t pname) {
fbb_.AddElement<uint32_t>(GetStringi::VT_PNAME, pname, 0);
}
void add_index(uint32_t index) {
fbb_.AddElement<uint32_t>(GetStringi::VT_INDEX, index, 0);
}
explicit GetStringiBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
::flatbuffers::Offset<GetStringi> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = ::flatbuffers::Offset<GetStringi>(end);
return o;
}
};
inline ::flatbuffers::Offset<GetStringi> CreateGetStringi(
::flatbuffers::FlatBufferBuilder &_fbb,
uint32_t pname = 0,
uint32_t index = 0) {
GetStringiBuilder builder_(_fbb);
builder_.add_index(index);
builder_.add_pname(pname);
return builder_.Finish();
}
struct TextureRespecify FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
typedef TextureRespecifyBuilder Builder;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_TEXTURE = 4,
VT_LEVEL = 6,
VT_FORMAT = 8,
VT_TYPE = 10,
VT_WIDTH = 12,
VT_HEIGHT = 14,
VT_DEPTH = 16,
VT_DATA_SIZE = 18
};
uint64_t texture() const {
return GetField<uint64_t>(VT_TEXTURE, 0);
}
uint32_t level() const {
return GetField<uint32_t>(VT_LEVEL, 0);
}
uint32_t format() const {
return GetField<uint32_t>(VT_FORMAT, 0);
}
uint32_t type() const {
return GetField<uint32_t>(VT_TYPE, 0);
}
uint32_t width() const {
return GetField<uint32_t>(VT_WIDTH, 0);
}
uint32_t height() const {
return GetField<uint32_t>(VT_HEIGHT, 0);
}
uint32_t depth() const {
return GetField<uint32_t>(VT_DEPTH, 0);
}
uint64_t data_size() const {
return GetField<uint64_t>(VT_DATA_SIZE, 0);
}
template <bool B = false>
bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<uint64_t>(verifier, VT_TEXTURE, 8) &&
VerifyField<uint32_t>(verifier, VT_LEVEL, 4) &&
VerifyField<uint32_t>(verifier, VT_FORMAT, 4) &&
VerifyField<uint32_t>(verifier, VT_TYPE, 4) &&
VerifyField<uint32_t>(verifier, VT_WIDTH, 4) &&
VerifyField<uint32_t>(verifier, VT_HEIGHT, 4) &&
VerifyField<uint32_t>(verifier, VT_DEPTH, 4) &&
VerifyField<uint64_t>(verifier, VT_DATA_SIZE, 8) &&
verifier.EndTable();
}
};
struct TextureRespecifyBuilder {
typedef TextureRespecify Table;
::flatbuffers::FlatBufferBuilder &fbb_;
::flatbuffers::uoffset_t start_;
void add_texture(uint64_t texture) {
fbb_.AddElement<uint64_t>(TextureRespecify::VT_TEXTURE, texture, 0);
}
void add_level(uint32_t level) {
fbb_.AddElement<uint32_t>(TextureRespecify::VT_LEVEL, level, 0);
}
void add_format(uint32_t format) {
fbb_.AddElement<uint32_t>(TextureRespecify::VT_FORMAT, format, 0);
}
void add_type(uint32_t type) {
fbb_.AddElement<uint32_t>(TextureRespecify::VT_TYPE, type, 0);
}
void add_width(uint32_t width) {
fbb_.AddElement<uint32_t>(TextureRespecify::VT_WIDTH, width, 0);
}
void add_height(uint32_t height) {
fbb_.AddElement<uint32_t>(TextureRespecify::VT_HEIGHT, height, 0);
}
void add_depth(uint32_t depth) {
fbb_.AddElement<uint32_t>(TextureRespecify::VT_DEPTH, depth, 0);
}
void add_data_size(uint64_t data_size) {
fbb_.AddElement<uint64_t>(TextureRespecify::VT_DATA_SIZE, data_size, 0);
}
explicit TextureRespecifyBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
::flatbuffers::Offset<TextureRespecify> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = ::flatbuffers::Offset<TextureRespecify>(end);
return o;
}
};
inline ::flatbuffers::Offset<TextureRespecify> CreateTextureRespecify(
::flatbuffers::FlatBufferBuilder &_fbb,
uint64_t texture = 0,
uint32_t level = 0,
uint32_t format = 0,
uint32_t type = 0,
uint32_t width = 0,
uint32_t height = 0,
uint32_t depth = 0,
uint64_t data_size = 0) {
TextureRespecifyBuilder builder_(_fbb);
builder_.add_data_size(data_size);
builder_.add_texture(texture);
builder_.add_depth(depth);
builder_.add_height(height);
builder_.add_width(width);
builder_.add_type(type);
builder_.add_format(format);
builder_.add_level(level);
return builder_.Finish();
}
struct TextureSubImage FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
typedef TextureSubImageBuilder Builder;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_TEXTURE = 4,
VT_LEVEL = 6,
VT_FORMAT = 8,
VT_TYPE = 10,
VT_WIDTH = 12,
VT_HEIGHT = 14,
VT_DEPTH = 16,
VT_DATA_SIZE = 18
};
uint64_t texture() const {
return GetField<uint64_t>(VT_TEXTURE, 0);
}
uint32_t level() const {
return GetField<uint32_t>(VT_LEVEL, 0);
}
uint32_t format() const {
return GetField<uint32_t>(VT_FORMAT, 0);
}
uint32_t type() const {
return GetField<uint32_t>(VT_TYPE, 0);
}
uint32_t width() const {
return GetField<uint32_t>(VT_WIDTH, 0);
}
uint32_t height() const {
return GetField<uint32_t>(VT_HEIGHT, 0);
}
uint32_t depth() const {
return GetField<uint32_t>(VT_DEPTH, 0);
}
uint64_t data_size() const {
return GetField<uint64_t>(VT_DATA_SIZE, 0);
}
template <bool B = false>
bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<uint64_t>(verifier, VT_TEXTURE, 8) &&
VerifyField<uint32_t>(verifier, VT_LEVEL, 4) &&
VerifyField<uint32_t>(verifier, VT_FORMAT, 4) &&
VerifyField<uint32_t>(verifier, VT_TYPE, 4) &&
VerifyField<uint32_t>(verifier, VT_WIDTH, 4) &&
VerifyField<uint32_t>(verifier, VT_HEIGHT, 4) &&
VerifyField<uint32_t>(verifier, VT_DEPTH, 4) &&
VerifyField<uint64_t>(verifier, VT_DATA_SIZE, 8) &&
verifier.EndTable();
}
};
struct TextureSubImageBuilder {
typedef TextureSubImage Table;
::flatbuffers::FlatBufferBuilder &fbb_;
::flatbuffers::uoffset_t start_;
void add_texture(uint64_t texture) {
fbb_.AddElement<uint64_t>(TextureSubImage::VT_TEXTURE, texture, 0);
}
void add_level(uint32_t level) {
fbb_.AddElement<uint32_t>(TextureSubImage::VT_LEVEL, level, 0);
}
void add_format(uint32_t format) {
fbb_.AddElement<uint32_t>(TextureSubImage::VT_FORMAT, format, 0);
}
void add_type(uint32_t type) {
fbb_.AddElement<uint32_t>(TextureSubImage::VT_TYPE, type, 0);
}
void add_width(uint32_t width) {
fbb_.AddElement<uint32_t>(TextureSubImage::VT_WIDTH, width, 0);
}
void add_height(uint32_t height) {
fbb_.AddElement<uint32_t>(TextureSubImage::VT_HEIGHT, height, 0);
}
void add_depth(uint32_t depth) {
fbb_.AddElement<uint32_t>(TextureSubImage::VT_DEPTH, depth, 0);
}
void add_data_size(uint64_t data_size) {
fbb_.AddElement<uint64_t>(TextureSubImage::VT_DATA_SIZE, data_size, 0);
}
explicit TextureSubImageBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
::flatbuffers::Offset<TextureSubImage> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = ::flatbuffers::Offset<TextureSubImage>(end);
return o;
}
};
inline ::flatbuffers::Offset<TextureSubImage> CreateTextureSubImage(
::flatbuffers::FlatBufferBuilder &_fbb,
uint64_t texture = 0,
uint32_t level = 0,
uint32_t format = 0,
uint32_t type = 0,
uint32_t width = 0,
uint32_t height = 0,
uint32_t depth = 0,
uint64_t data_size = 0) {
TextureSubImageBuilder builder_(_fbb);
builder_.add_data_size(data_size);
builder_.add_texture(texture);
builder_.add_depth(depth);
builder_.add_height(height);
builder_.add_width(width);
builder_.add_type(type);
builder_.add_format(format);
builder_.add_level(level);
return builder_.Finish();
}
struct ReadPixels FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
typedef ReadPixelsBuilder Builder;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_X = 4,
VT_Y = 6,
VT_WIDTH = 8,
VT_HEIGHT = 10,
VT_FORMAT = 12,
VT_TYPE = 14
};
int32_t x() const {
return GetField<int32_t>(VT_X, 0);
}
int32_t y() const {
return GetField<int32_t>(VT_Y, 0);
}
int32_t width() const {
return GetField<int32_t>(VT_WIDTH, 0);
}
int32_t height() const {
return GetField<int32_t>(VT_HEIGHT, 0);
}
uint32_t format() const {
return GetField<uint32_t>(VT_FORMAT, 0);
}
uint32_t type() const {
return GetField<uint32_t>(VT_TYPE, 0);
}
template <bool B = false>
bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<int32_t>(verifier, VT_X, 4) &&
VerifyField<int32_t>(verifier, VT_Y, 4) &&
VerifyField<int32_t>(verifier, VT_WIDTH, 4) &&
VerifyField<int32_t>(verifier, VT_HEIGHT, 4) &&
VerifyField<uint32_t>(verifier, VT_FORMAT, 4) &&
VerifyField<uint32_t>(verifier, VT_TYPE, 4) &&
verifier.EndTable();
}
};
struct ReadPixelsBuilder {
typedef ReadPixels Table;
::flatbuffers::FlatBufferBuilder &fbb_;
::flatbuffers::uoffset_t start_;
void add_x(int32_t x) {
fbb_.AddElement<int32_t>(ReadPixels::VT_X, x, 0);
}
void add_y(int32_t y) {
fbb_.AddElement<int32_t>(ReadPixels::VT_Y, y, 0);
}
void add_width(int32_t width) {
fbb_.AddElement<int32_t>(ReadPixels::VT_WIDTH, width, 0);
}
void add_height(int32_t height) {
fbb_.AddElement<int32_t>(ReadPixels::VT_HEIGHT, height, 0);
}
void add_format(uint32_t format) {
fbb_.AddElement<uint32_t>(ReadPixels::VT_FORMAT, format, 0);
}
void add_type(uint32_t type) {
fbb_.AddElement<uint32_t>(ReadPixels::VT_TYPE, type, 0);
}
explicit ReadPixelsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
::flatbuffers::Offset<ReadPixels> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = ::flatbuffers::Offset<ReadPixels>(end);
return o;
}
};
inline ::flatbuffers::Offset<ReadPixels> CreateReadPixels(
::flatbuffers::FlatBufferBuilder &_fbb,
int32_t x = 0,
int32_t y = 0,
int32_t width = 0,
int32_t height = 0,
uint32_t format = 0,
uint32_t type = 0) {
ReadPixelsBuilder builder_(_fbb);
builder_.add_type(type);
builder_.add_format(format);
builder_.add_height(height);
builder_.add_width(width);
builder_.add_y(y);
builder_.add_x(x);
return builder_.Finish();
}
struct BufferReadbackFromGpu FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
typedef BufferReadbackFromGpuBuilder Builder;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_BUFFER_HANDLE = 4,
VT_OFFSET = 6,
VT_SIZE = 8
};
uint64_t buffer_handle() const {
return GetField<uint64_t>(VT_BUFFER_HANDLE, 0);
}
uint64_t offset() const {
return GetField<uint64_t>(VT_OFFSET, 0);
}
uint64_t size() const {
return GetField<uint64_t>(VT_SIZE, 0);
}
template <bool B = false>
bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<uint64_t>(verifier, VT_BUFFER_HANDLE, 8) &&
VerifyField<uint64_t>(verifier, VT_OFFSET, 8) &&
VerifyField<uint64_t>(verifier, VT_SIZE, 8) &&
verifier.EndTable();
}
};
struct BufferReadbackFromGpuBuilder {
typedef BufferReadbackFromGpu Table;
::flatbuffers::FlatBufferBuilder &fbb_;
::flatbuffers::uoffset_t start_;
void add_buffer_handle(uint64_t buffer_handle) {
fbb_.AddElement<uint64_t>(BufferReadbackFromGpu::VT_BUFFER_HANDLE, buffer_handle, 0);
}
void add_offset(uint64_t offset) {
fbb_.AddElement<uint64_t>(BufferReadbackFromGpu::VT_OFFSET, offset, 0);
}
void add_size(uint64_t size) {
fbb_.AddElement<uint64_t>(BufferReadbackFromGpu::VT_SIZE, size, 0);
}
explicit BufferReadbackFromGpuBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
::flatbuffers::Offset<BufferReadbackFromGpu> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = ::flatbuffers::Offset<BufferReadbackFromGpu>(end);
return o;
}
};
inline ::flatbuffers::Offset<BufferReadbackFromGpu> CreateBufferReadbackFromGpu(
::flatbuffers::FlatBufferBuilder &_fbb,
uint64_t buffer_handle = 0,
uint64_t offset = 0,
uint64_t size = 0) {
BufferReadbackFromGpuBuilder builder_(_fbb);
builder_.add_size(size);
builder_.add_offset(offset);
builder_.add_buffer_handle(buffer_handle);
return builder_.Finish();
}
struct MapBufferRange FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
typedef MapBufferRangeBuilder Builder;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_BUFFER_HANDLE = 4,
VT_OFFSET = 6,
VT_SIZE = 8,
VT_ACCESS = 10
};
uint64_t buffer_handle() const {
return GetField<uint64_t>(VT_BUFFER_HANDLE, 0);
}
uint64_t offset() const {
return GetField<uint64_t>(VT_OFFSET, 0);
}
uint64_t size() const {
return GetField<uint64_t>(VT_SIZE, 0);
}
uint32_t access() const {
return GetField<uint32_t>(VT_ACCESS, 0);
}
template <bool B = false>
bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<uint64_t>(verifier, VT_BUFFER_HANDLE, 8) &&
VerifyField<uint64_t>(verifier, VT_OFFSET, 8) &&
VerifyField<uint64_t>(verifier, VT_SIZE, 8) &&
VerifyField<uint32_t>(verifier, VT_ACCESS, 4) &&
verifier.EndTable();
}
};
struct MapBufferRangeBuilder {
typedef MapBufferRange Table;
::flatbuffers::FlatBufferBuilder &fbb_;
::flatbuffers::uoffset_t start_;
void add_buffer_handle(uint64_t buffer_handle) {
fbb_.AddElement<uint64_t>(MapBufferRange::VT_BUFFER_HANDLE, buffer_handle, 0);
}
void add_offset(uint64_t offset) {
fbb_.AddElement<uint64_t>(MapBufferRange::VT_OFFSET, offset, 0);
}
void add_size(uint64_t size) {
fbb_.AddElement<uint64_t>(MapBufferRange::VT_SIZE, size, 0);
}
void add_access(uint32_t access) {
fbb_.AddElement<uint32_t>(MapBufferRange::VT_ACCESS, access, 0);
}
explicit MapBufferRangeBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
::flatbuffers::Offset<MapBufferRange> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = ::flatbuffers::Offset<MapBufferRange>(end);
return o;
}
};
inline ::flatbuffers::Offset<MapBufferRange> CreateMapBufferRange(
::flatbuffers::FlatBufferBuilder &_fbb,
uint64_t buffer_handle = 0,
uint64_t offset = 0,
uint64_t size = 0,
uint32_t access = 0) {
MapBufferRangeBuilder builder_(_fbb);
builder_.add_size(size);
builder_.add_offset(offset);
builder_.add_buffer_handle(buffer_handle);
builder_.add_access(access);
return builder_.Finish();
}
struct UnmapBuffer FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
typedef UnmapBufferBuilder Builder;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_BUFFER_HANDLE = 4,
VT_OFFSET = 6,
VT_SIZE = 8
};
uint64_t buffer_handle() const {
return GetField<uint64_t>(VT_BUFFER_HANDLE, 0);
}
uint64_t offset() const {
return GetField<uint64_t>(VT_OFFSET, 0);
}
uint64_t size() const {
return GetField<uint64_t>(VT_SIZE, 0);
}
template <bool B = false>
bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<uint64_t>(verifier, VT_BUFFER_HANDLE, 8) &&
VerifyField<uint64_t>(verifier, VT_OFFSET, 8) &&
VerifyField<uint64_t>(verifier, VT_SIZE, 8) &&
verifier.EndTable();
}
};
struct UnmapBufferBuilder {
typedef UnmapBuffer Table;
::flatbuffers::FlatBufferBuilder &fbb_;
::flatbuffers::uoffset_t start_;
void add_buffer_handle(uint64_t buffer_handle) {
fbb_.AddElement<uint64_t>(UnmapBuffer::VT_BUFFER_HANDLE, buffer_handle, 0);
}
void add_offset(uint64_t offset) {
fbb_.AddElement<uint64_t>(UnmapBuffer::VT_OFFSET, offset, 0);
}
void add_size(uint64_t size) {
fbb_.AddElement<uint64_t>(UnmapBuffer::VT_SIZE, size, 0);
}
explicit UnmapBufferBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
::flatbuffers::Offset<UnmapBuffer> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = ::flatbuffers::Offset<UnmapBuffer>(end);
return o;
}
};
inline ::flatbuffers::Offset<UnmapBuffer> CreateUnmapBuffer(
::flatbuffers::FlatBufferBuilder &_fbb,
uint64_t buffer_handle = 0,
uint64_t offset = 0,
uint64_t size = 0) {
UnmapBufferBuilder builder_(_fbb);
builder_.add_size(size);
builder_.add_offset(offset);
builder_.add_buffer_handle(buffer_handle);
return builder_.Finish();
}
struct EglCreatePbufferSurface FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
typedef EglCreatePbufferSurfaceBuilder Builder;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_DISPLAY = 4,
VT_SURFACE = 6,
VT_WIDTH = 8,
VT_HEIGHT = 10
};
uint64_t display() const {
return GetField<uint64_t>(VT_DISPLAY, 0);
}
uint64_t surface() const {
return GetField<uint64_t>(VT_SURFACE, 0);
}
int32_t width() const {
return GetField<int32_t>(VT_WIDTH, 0);
}
int32_t height() const {
return GetField<int32_t>(VT_HEIGHT, 0);
}
template <bool B = false>
bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<uint64_t>(verifier, VT_DISPLAY, 8) &&
VerifyField<uint64_t>(verifier, VT_SURFACE, 8) &&
VerifyField<int32_t>(verifier, VT_WIDTH, 4) &&
VerifyField<int32_t>(verifier, VT_HEIGHT, 4) &&
verifier.EndTable();
}
};
struct EglCreatePbufferSurfaceBuilder {
typedef EglCreatePbufferSurface Table;
::flatbuffers::FlatBufferBuilder &fbb_;
::flatbuffers::uoffset_t start_;
void add_display(uint64_t display) {
fbb_.AddElement<uint64_t>(EglCreatePbufferSurface::VT_DISPLAY, display, 0);
}
void add_surface(uint64_t surface) {
fbb_.AddElement<uint64_t>(EglCreatePbufferSurface::VT_SURFACE, surface, 0);
}
void add_width(int32_t width) {
fbb_.AddElement<int32_t>(EglCreatePbufferSurface::VT_WIDTH, width, 0);
}
void add_height(int32_t height) {
fbb_.AddElement<int32_t>(EglCreatePbufferSurface::VT_HEIGHT, height, 0);
}
explicit EglCreatePbufferSurfaceBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
::flatbuffers::Offset<EglCreatePbufferSurface> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = ::flatbuffers::Offset<EglCreatePbufferSurface>(end);
return o;
}
};
inline ::flatbuffers::Offset<EglCreatePbufferSurface> CreateEglCreatePbufferSurface(
::flatbuffers::FlatBufferBuilder &_fbb,
uint64_t display = 0,
uint64_t surface = 0,
int32_t width = 0,
int32_t height = 0) {
EglCreatePbufferSurfaceBuilder builder_(_fbb);
builder_.add_surface(surface);
builder_.add_display(display);
builder_.add_height(height);
builder_.add_width(width);
return builder_.Finish();
}
struct EglCreateWindowSurface FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
typedef EglCreateWindowSurfaceBuilder Builder;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_DISPLAY = 4,
VT_SURFACE = 6,
VT_NATIVE_WINDOW = 8
};
uint64_t display() const {
return GetField<uint64_t>(VT_DISPLAY, 0);
}
uint64_t surface() const {
return GetField<uint64_t>(VT_SURFACE, 0);
}
uint64_t native_window() const {
return GetField<uint64_t>(VT_NATIVE_WINDOW, 0);
}
template <bool B = false>
bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<uint64_t>(verifier, VT_DISPLAY, 8) &&
VerifyField<uint64_t>(verifier, VT_SURFACE, 8) &&
VerifyField<uint64_t>(verifier, VT_NATIVE_WINDOW, 8) &&
verifier.EndTable();
}
};
struct EglCreateWindowSurfaceBuilder {
typedef EglCreateWindowSurface Table;
::flatbuffers::FlatBufferBuilder &fbb_;
::flatbuffers::uoffset_t start_;
void add_display(uint64_t display) {
fbb_.AddElement<uint64_t>(EglCreateWindowSurface::VT_DISPLAY, display, 0);
}
void add_surface(uint64_t surface) {
fbb_.AddElement<uint64_t>(EglCreateWindowSurface::VT_SURFACE, surface, 0);
}
void add_native_window(uint64_t native_window) {
fbb_.AddElement<uint64_t>(EglCreateWindowSurface::VT_NATIVE_WINDOW, native_window, 0);
}
explicit EglCreateWindowSurfaceBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
::flatbuffers::Offset<EglCreateWindowSurface> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = ::flatbuffers::Offset<EglCreateWindowSurface>(end);
return o;
}
};
inline ::flatbuffers::Offset<EglCreateWindowSurface> CreateEglCreateWindowSurface(
::flatbuffers::FlatBufferBuilder &_fbb,
uint64_t display = 0,
uint64_t surface = 0,
uint64_t native_window = 0) {
EglCreateWindowSurfaceBuilder builder_(_fbb);
builder_.add_native_window(native_window);
builder_.add_surface(surface);
builder_.add_display(display);
return builder_.Finish();
}
struct EglDestroySurface FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
typedef EglDestroySurfaceBuilder Builder;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_DISPLAY = 4,
VT_SURFACE = 6
};
uint64_t display() const {
return GetField<uint64_t>(VT_DISPLAY, 0);
}
uint64_t surface() const {
return GetField<uint64_t>(VT_SURFACE, 0);
}
template <bool B = false>
bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<uint64_t>(verifier, VT_DISPLAY, 8) &&
VerifyField<uint64_t>(verifier, VT_SURFACE, 8) &&
verifier.EndTable();
}
};
struct EglDestroySurfaceBuilder {
typedef EglDestroySurface Table;
::flatbuffers::FlatBufferBuilder &fbb_;
::flatbuffers::uoffset_t start_;
void add_display(uint64_t display) {
fbb_.AddElement<uint64_t>(EglDestroySurface::VT_DISPLAY, display, 0);
}
void add_surface(uint64_t surface) {
fbb_.AddElement<uint64_t>(EglDestroySurface::VT_SURFACE, surface, 0);
}
explicit EglDestroySurfaceBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
::flatbuffers::Offset<EglDestroySurface> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = ::flatbuffers::Offset<EglDestroySurface>(end);
return o;
}
};
inline ::flatbuffers::Offset<EglDestroySurface> CreateEglDestroySurface(
::flatbuffers::FlatBufferBuilder &_fbb,
uint64_t display = 0,
uint64_t surface = 0) {
EglDestroySurfaceBuilder builder_(_fbb);
builder_.add_surface(surface);
builder_.add_display(display);
return builder_.Finish();
}
struct EglMakeCurrent FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
typedef EglMakeCurrentBuilder Builder;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_SESSION = 4,
VT_DRAW = 6,
VT_READ = 8
};
uint64_t session() const {
return GetField<uint64_t>(VT_SESSION, 0);
}
uint64_t draw() const {
return GetField<uint64_t>(VT_DRAW, 0);
}
uint64_t read() const {
return GetField<uint64_t>(VT_READ, 0);
}
template <bool B = false>
bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<uint64_t>(verifier, VT_SESSION, 8) &&
VerifyField<uint64_t>(verifier, VT_DRAW, 8) &&
VerifyField<uint64_t>(verifier, VT_READ, 8) &&
verifier.EndTable();
}
};
struct EglMakeCurrentBuilder {
typedef EglMakeCurrent Table;
::flatbuffers::FlatBufferBuilder &fbb_;
::flatbuffers::uoffset_t start_;
void add_session(uint64_t session) {
fbb_.AddElement<uint64_t>(EglMakeCurrent::VT_SESSION, session, 0);
}
void add_draw(uint64_t draw) {
fbb_.AddElement<uint64_t>(EglMakeCurrent::VT_DRAW, draw, 0);
}
void add_read(uint64_t read) {
fbb_.AddElement<uint64_t>(EglMakeCurrent::VT_READ, read, 0);
}
explicit EglMakeCurrentBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
::flatbuffers::Offset<EglMakeCurrent> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = ::flatbuffers::Offset<EglMakeCurrent>(end);
return o;
}
};
inline ::flatbuffers::Offset<EglMakeCurrent> CreateEglMakeCurrent(
::flatbuffers::FlatBufferBuilder &_fbb,
uint64_t session = 0,
uint64_t draw = 0,
uint64_t read = 0) {
EglMakeCurrentBuilder builder_(_fbb);
builder_.add_read(read);
builder_.add_draw(draw);
builder_.add_session(session);
return builder_.Finish();
}
struct EglSwapInterval FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
typedef EglSwapIntervalBuilder Builder;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_INTERVAL = 4
};
int32_t interval() const {
return GetField<int32_t>(VT_INTERVAL, 0);
}
template <bool B = false>
bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<int32_t>(verifier, VT_INTERVAL, 4) &&
verifier.EndTable();
}
};
struct EglSwapIntervalBuilder {
typedef EglSwapInterval Table;
::flatbuffers::FlatBufferBuilder &fbb_;
::flatbuffers::uoffset_t start_;
void add_interval(int32_t interval) {
fbb_.AddElement<int32_t>(EglSwapInterval::VT_INTERVAL, interval, 0);
}
explicit EglSwapIntervalBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
::flatbuffers::Offset<EglSwapInterval> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = ::flatbuffers::Offset<EglSwapInterval>(end);
return o;
}
};
inline ::flatbuffers::Offset<EglSwapInterval> CreateEglSwapInterval(
::flatbuffers::FlatBufferBuilder &_fbb,
int32_t interval = 0) {
EglSwapIntervalBuilder builder_(_fbb);
builder_.add_interval(interval);
return builder_.Finish();
}
struct EglResizeSurface FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
typedef EglResizeSurfaceBuilder Builder;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_DISPLAY = 4,
VT_SURFACE = 6,
VT_WIDTH = 8,
VT_HEIGHT = 10
};
uint64_t display() const {
return GetField<uint64_t>(VT_DISPLAY, 0);
}
uint64_t surface() const {
return GetField<uint64_t>(VT_SURFACE, 0);
}
uint32_t width() const {
return GetField<uint32_t>(VT_WIDTH, 0);
}
uint32_t height() const {
return GetField<uint32_t>(VT_HEIGHT, 0);
}
template <bool B = false>
bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<uint64_t>(verifier, VT_DISPLAY, 8) &&
VerifyField<uint64_t>(verifier, VT_SURFACE, 8) &&
VerifyField<uint32_t>(verifier, VT_WIDTH, 4) &&
VerifyField<uint32_t>(verifier, VT_HEIGHT, 4) &&
verifier.EndTable();
}
};
struct EglResizeSurfaceBuilder {
typedef EglResizeSurface Table;
::flatbuffers::FlatBufferBuilder &fbb_;
::flatbuffers::uoffset_t start_;
void add_display(uint64_t display) {
fbb_.AddElement<uint64_t>(EglResizeSurface::VT_DISPLAY, display, 0);
}
void add_surface(uint64_t surface) {
fbb_.AddElement<uint64_t>(EglResizeSurface::VT_SURFACE, surface, 0);
}
void add_width(uint32_t width) {
fbb_.AddElement<uint32_t>(EglResizeSurface::VT_WIDTH, width, 0);
}
void add_height(uint32_t height) {
fbb_.AddElement<uint32_t>(EglResizeSurface::VT_HEIGHT, height, 0);
}
explicit EglResizeSurfaceBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
::flatbuffers::Offset<EglResizeSurface> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = ::flatbuffers::Offset<EglResizeSurface>(end);
return o;
}
};
inline ::flatbuffers::Offset<EglResizeSurface> CreateEglResizeSurface(
::flatbuffers::FlatBufferBuilder &_fbb,
uint64_t display = 0,
uint64_t surface = 0,
uint32_t width = 0,
uint32_t height = 0) {
EglResizeSurfaceBuilder builder_(_fbb);
builder_.add_surface(surface);
builder_.add_display(display);
builder_.add_height(height);
builder_.add_width(width);
return builder_.Finish();
}
struct ClientWaitSync FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
typedef ClientWaitSyncBuilder Builder;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_SYNC = 4,
VT_FLAGS = 6,
VT_TIMEOUT = 8
};
uint64_t sync() const {
return GetField<uint64_t>(VT_SYNC, 0);
}
uint32_t flags() const {
return GetField<uint32_t>(VT_FLAGS, 0);
}
uint64_t timeout() const {
return GetField<uint64_t>(VT_TIMEOUT, 0);
}
template <bool B = false>
bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<uint64_t>(verifier, VT_SYNC, 8) &&
VerifyField<uint32_t>(verifier, VT_FLAGS, 4) &&
VerifyField<uint64_t>(verifier, VT_TIMEOUT, 8) &&
verifier.EndTable();
}
};
struct ClientWaitSyncBuilder {
typedef ClientWaitSync Table;
::flatbuffers::FlatBufferBuilder &fbb_;
::flatbuffers::uoffset_t start_;
void add_sync(uint64_t sync) {
fbb_.AddElement<uint64_t>(ClientWaitSync::VT_SYNC, sync, 0);
}
void add_flags(uint32_t flags) {
fbb_.AddElement<uint32_t>(ClientWaitSync::VT_FLAGS, flags, 0);
}
void add_timeout(uint64_t timeout) {
fbb_.AddElement<uint64_t>(ClientWaitSync::VT_TIMEOUT, timeout, 0);
}
explicit ClientWaitSyncBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
::flatbuffers::Offset<ClientWaitSync> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = ::flatbuffers::Offset<ClientWaitSync>(end);
return o;
}
};
inline ::flatbuffers::Offset<ClientWaitSync> CreateClientWaitSync(
::flatbuffers::FlatBufferBuilder &_fbb,
uint64_t sync = 0,
uint32_t flags = 0,
uint64_t timeout = 0) {
ClientWaitSyncBuilder builder_(_fbb);
builder_.add_timeout(timeout);
builder_.add_sync(sync);
builder_.add_flags(flags);
return builder_.Finish();
}
struct BeginTimeElapsedQuery FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
typedef BeginTimeElapsedQueryBuilder Builder;
template <bool B = false>
bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
return VerifyTableStart(verifier) &&
verifier.EndTable();
}
};
struct BeginTimeElapsedQueryBuilder {
typedef BeginTimeElapsedQuery Table;
::flatbuffers::FlatBufferBuilder &fbb_;
::flatbuffers::uoffset_t start_;
explicit BeginTimeElapsedQueryBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
::flatbuffers::Offset<BeginTimeElapsedQuery> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = ::flatbuffers::Offset<BeginTimeElapsedQuery>(end);
return o;
}
};
inline ::flatbuffers::Offset<BeginTimeElapsedQuery> CreateBeginTimeElapsedQuery(
::flatbuffers::FlatBufferBuilder &_fbb) {
BeginTimeElapsedQueryBuilder builder_(_fbb);
return builder_.Finish();
}
struct EndTimeElapsedQuery FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
typedef EndTimeElapsedQueryBuilder Builder;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_QUERY = 4
};
uint64_t query() const {
return GetField<uint64_t>(VT_QUERY, 0);
}
template <bool B = false>
bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<uint64_t>(verifier, VT_QUERY, 8) &&
verifier.EndTable();
}
};
struct EndTimeElapsedQueryBuilder {
typedef EndTimeElapsedQuery Table;
::flatbuffers::FlatBufferBuilder &fbb_;
::flatbuffers::uoffset_t start_;
void add_query(uint64_t query) {
fbb_.AddElement<uint64_t>(EndTimeElapsedQuery::VT_QUERY, query, 0);
}
explicit EndTimeElapsedQueryBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
::flatbuffers::Offset<EndTimeElapsedQuery> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = ::flatbuffers::Offset<EndTimeElapsedQuery>(end);
return o;
}
};
inline ::flatbuffers::Offset<EndTimeElapsedQuery> CreateEndTimeElapsedQuery(
::flatbuffers::FlatBufferBuilder &_fbb,
uint64_t query = 0) {
EndTimeElapsedQueryBuilder builder_(_fbb);
builder_.add_query(query);
return builder_.Finish();
}
struct DeleteBackendQuery FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
typedef DeleteBackendQueryBuilder Builder;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_QUERY = 4
};
uint64_t query() const {
return GetField<uint64_t>(VT_QUERY, 0);
}
template <bool B = false>
bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<uint64_t>(verifier, VT_QUERY, 8) &&
verifier.EndTable();
}
};
struct DeleteBackendQueryBuilder {
typedef DeleteBackendQuery Table;
::flatbuffers::FlatBufferBuilder &fbb_;
::flatbuffers::uoffset_t start_;
void add_query(uint64_t query) {
fbb_.AddElement<uint64_t>(DeleteBackendQuery::VT_QUERY, query, 0);
}
explicit DeleteBackendQueryBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
::flatbuffers::Offset<DeleteBackendQuery> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = ::flatbuffers::Offset<DeleteBackendQuery>(end);
return o;
}
};
inline ::flatbuffers::Offset<DeleteBackendQuery> CreateDeleteBackendQuery(
::flatbuffers::FlatBufferBuilder &_fbb,
uint64_t query = 0) {
DeleteBackendQueryBuilder builder_(_fbb);
builder_.add_query(query);
return builder_.Finish();
}
struct IsQueryResultAvailable FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
typedef IsQueryResultAvailableBuilder Builder;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_QUERY = 4
};
uint64_t query() const {
return GetField<uint64_t>(VT_QUERY, 0);
}
template <bool B = false>
bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<uint64_t>(verifier, VT_QUERY, 8) &&
verifier.EndTable();
}
};
struct IsQueryResultAvailableBuilder {
typedef IsQueryResultAvailable Table;
::flatbuffers::FlatBufferBuilder &fbb_;
::flatbuffers::uoffset_t start_;
void add_query(uint64_t query) {
fbb_.AddElement<uint64_t>(IsQueryResultAvailable::VT_QUERY, query, 0);
}
explicit IsQueryResultAvailableBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
::flatbuffers::Offset<IsQueryResultAvailable> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = ::flatbuffers::Offset<IsQueryResultAvailable>(end);
return o;
}
};
inline ::flatbuffers::Offset<IsQueryResultAvailable> CreateIsQueryResultAvailable(
::flatbuffers::FlatBufferBuilder &_fbb,
uint64_t query = 0) {
IsQueryResultAvailableBuilder builder_(_fbb);
builder_.add_query(query);
return builder_.Finish();
}
struct GetQueryResult64 FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
typedef GetQueryResult64Builder Builder;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_QUERY = 4,
VT_WAIT = 6
};
uint64_t query() const {
return GetField<uint64_t>(VT_QUERY, 0);
}
uint32_t wait() const {
return GetField<uint32_t>(VT_WAIT, 0);
}
template <bool B = false>
bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<uint64_t>(verifier, VT_QUERY, 8) &&
VerifyField<uint32_t>(verifier, VT_WAIT, 4) &&
verifier.EndTable();
}
};
struct GetQueryResult64Builder {
typedef GetQueryResult64 Table;
::flatbuffers::FlatBufferBuilder &fbb_;
::flatbuffers::uoffset_t start_;
void add_query(uint64_t query) {
fbb_.AddElement<uint64_t>(GetQueryResult64::VT_QUERY, query, 0);
}
void add_wait(uint32_t wait) {
fbb_.AddElement<uint32_t>(GetQueryResult64::VT_WAIT, wait, 0);
}
explicit GetQueryResult64Builder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
::flatbuffers::Offset<GetQueryResult64> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = ::flatbuffers::Offset<GetQueryResult64>(end);
return o;
}
};
inline ::flatbuffers::Offset<GetQueryResult64> CreateGetQueryResult64(
::flatbuffers::FlatBufferBuilder &_fbb,
uint64_t query = 0,
uint32_t wait = 0) {
GetQueryResult64Builder builder_(_fbb);
builder_.add_query(query);
builder_.add_wait(wait);
return builder_.Finish();
}
struct BeginOcclusionQuery FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
typedef BeginOcclusionQueryBuilder Builder;
template <bool B = false>
bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
return VerifyTableStart(verifier) &&
verifier.EndTable();
}
};
struct BeginOcclusionQueryBuilder {
typedef BeginOcclusionQuery Table;
::flatbuffers::FlatBufferBuilder &fbb_;
::flatbuffers::uoffset_t start_;
explicit BeginOcclusionQueryBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
::flatbuffers::Offset<BeginOcclusionQuery> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = ::flatbuffers::Offset<BeginOcclusionQuery>(end);
return o;
}
};
inline ::flatbuffers::Offset<BeginOcclusionQuery> CreateBeginOcclusionQuery(
::flatbuffers::FlatBufferBuilder &_fbb) {
BeginOcclusionQueryBuilder builder_(_fbb);
return builder_.Finish();
}
struct EndOcclusionQuery FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
typedef EndOcclusionQueryBuilder Builder;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_QUERY = 4
};
uint64_t query() const {
return GetField<uint64_t>(VT_QUERY, 0);
}
template <bool B = false>
bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<uint64_t>(verifier, VT_QUERY, 8) &&
verifier.EndTable();
}
};
struct EndOcclusionQueryBuilder {
typedef EndOcclusionQuery Table;
::flatbuffers::FlatBufferBuilder &fbb_;
::flatbuffers::uoffset_t start_;
void add_query(uint64_t query) {
fbb_.AddElement<uint64_t>(EndOcclusionQuery::VT_QUERY, query, 0);
}
explicit EndOcclusionQueryBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
::flatbuffers::Offset<EndOcclusionQuery> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = ::flatbuffers::Offset<EndOcclusionQuery>(end);
return o;
}
};
inline ::flatbuffers::Offset<EndOcclusionQuery> CreateEndOcclusionQuery(
::flatbuffers::FlatBufferBuilder &_fbb,
uint64_t query = 0) {
EndOcclusionQueryBuilder builder_(_fbb);
builder_.add_query(query);
return builder_.Finish();
}
struct BeginXfbPrimitivesQuery FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
typedef BeginXfbPrimitivesQueryBuilder Builder;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_GENERATED = 4
};
uint32_t generated() const {
return GetField<uint32_t>(VT_GENERATED, 0);
}
template <bool B = false>
bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<uint32_t>(verifier, VT_GENERATED, 4) &&
verifier.EndTable();
}
};
struct BeginXfbPrimitivesQueryBuilder {
typedef BeginXfbPrimitivesQuery Table;
::flatbuffers::FlatBufferBuilder &fbb_;
::flatbuffers::uoffset_t start_;
void add_generated(uint32_t generated) {
fbb_.AddElement<uint32_t>(BeginXfbPrimitivesQuery::VT_GENERATED, generated, 0);
}
explicit BeginXfbPrimitivesQueryBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
::flatbuffers::Offset<BeginXfbPrimitivesQuery> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = ::flatbuffers::Offset<BeginXfbPrimitivesQuery>(end);
return o;
}
};
inline ::flatbuffers::Offset<BeginXfbPrimitivesQuery> CreateBeginXfbPrimitivesQuery(
::flatbuffers::FlatBufferBuilder &_fbb,
uint32_t generated = 0) {
BeginXfbPrimitivesQueryBuilder builder_(_fbb);
builder_.add_generated(generated);
return builder_.Finish();
}
struct EndXfbPrimitivesQuery FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
typedef EndXfbPrimitivesQueryBuilder Builder;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_QUERY = 4
};
uint64_t query() const {
return GetField<uint64_t>(VT_QUERY, 0);
}
template <bool B = false>
bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<uint64_t>(verifier, VT_QUERY, 8) &&
verifier.EndTable();
}
};
struct EndXfbPrimitivesQueryBuilder {
typedef EndXfbPrimitivesQuery Table;
::flatbuffers::FlatBufferBuilder &fbb_;
::flatbuffers::uoffset_t start_;
void add_query(uint64_t query) {
fbb_.AddElement<uint64_t>(EndXfbPrimitivesQuery::VT_QUERY, query, 0);
}
explicit EndXfbPrimitivesQueryBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
::flatbuffers::Offset<EndXfbPrimitivesQuery> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = ::flatbuffers::Offset<EndXfbPrimitivesQuery>(end);
return o;
}
};
inline ::flatbuffers::Offset<EndXfbPrimitivesQuery> CreateEndXfbPrimitivesQuery(
::flatbuffers::FlatBufferBuilder &_fbb,
uint64_t query = 0) {
EndXfbPrimitivesQueryBuilder builder_(_fbb);
builder_.add_query(query);
return builder_.Finish();
}
struct DataBlob FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
typedef DataBlobBuilder Builder;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_OFFSET = 4,
VT_SIZE = 6
};
uint64_t offset() const {
return GetField<uint64_t>(VT_OFFSET, 0);
}
uint64_t size() const {
return GetField<uint64_t>(VT_SIZE, 0);
}
template <bool B = false>
bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<uint64_t>(verifier, VT_OFFSET, 8) &&
VerifyField<uint64_t>(verifier, VT_SIZE, 8) &&
verifier.EndTable();
}
};
struct DataBlobBuilder {
typedef DataBlob Table;
::flatbuffers::FlatBufferBuilder &fbb_;
::flatbuffers::uoffset_t start_;
void add_offset(uint64_t offset) {
fbb_.AddElement<uint64_t>(DataBlob::VT_OFFSET, offset, 0);
}
void add_size(uint64_t size) {
fbb_.AddElement<uint64_t>(DataBlob::VT_SIZE, size, 0);
}
explicit DataBlobBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
::flatbuffers::Offset<DataBlob> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = ::flatbuffers::Offset<DataBlob>(end);
return o;
}
};
inline ::flatbuffers::Offset<DataBlob> CreateDataBlob(
::flatbuffers::FlatBufferBuilder &_fbb,
uint64_t offset = 0,
uint64_t size = 0) {
DataBlobBuilder builder_(_fbb);
builder_.add_size(size);
builder_.add_offset(offset);
return builder_.Finish();
}
struct Command FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
typedef CommandBuilder Builder;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_OPCODE = 4,
VT_SESSION_ID = 6,
VT_TOKEN = 8,
VT_CLEAR = 10,
VT_CLEAR_COLOR = 12,
VT_DRAW_ARRAYS = 14,
VT_DRAW_ELEMENTS = 16,
VT_BUFFER_SUB_DATA = 18,
VT_MEMORY_BARRIER = 20,
VT_MEMORY_BARRIER_BY_REGION = 22,
VT_PATCH_PARAMETERI = 24,
VT_GENERATE_MIPMAP = 26,
VT_DISPATCH_COMPUTE = 28,
VT_BEGIN_TRANSFORM_FEEDBACK = 30,
VT_BIND_TRANSFORM_FEEDBACK = 32,
VT_BLIT_FRAMEBUFFER = 34,
VT_SWAP_BUFFERS = 36,
VT_DATA = 38,
VT_DISPATCH_COMPUTE_INDIRECT = 40,
VT_FENCE_SYNC = 42,
VT_DELETE_SYNC = 44,
VT_WAIT_SYNC = 46,
VT_DRAW_ARRAYS_INSTANCED = 48,
VT_DRAW_ELEMENTS_INSTANCED = 50,
VT_DRAW_RANGE_ELEMENTS = 52,
VT_BUFFER_RESPECIFY = 54,
VT_DRAW_ARRAYS_INDIRECT = 56,
VT_DRAW_ELEMENTS_INDIRECT = 58,
VT_GET_STRING = 60,
VT_GET_STRINGI = 62,
VT_TEXTURE_RESPECIFY = 64,
VT_TEXTURE_SUB_IMAGE = 66,
VT_READ_PIXELS = 68,
VT_BUFFER_READBACK_FROM_GPU = 70,
VT_MAP_BUFFER_RANGE = 72,
VT_UNMAP_BUFFER = 74,
VT_EGL_CREATE_PBUFFER_SURFACE = 76,
VT_EGL_CREATE_WINDOW_SURFACE = 78,
VT_EGL_DESTROY_SURFACE = 80,
VT_EGL_MAKE_CURRENT = 82,
VT_EGL_SWAP_INTERVAL = 84,
VT_EGL_RESIZE_SURFACE = 86,
VT_CLIENT_WAIT_SYNC = 88,
VT_BEGIN_TIME_ELAPSED_QUERY = 90,
VT_END_TIME_ELAPSED_QUERY = 92,
VT_DELETE_BACKEND_QUERY = 94,
VT_IS_QUERY_RESULT_AVAILABLE = 96,
VT_GET_QUERY_RESULT64 = 98,
VT_BEGIN_OCCLUSION_QUERY = 100,
VT_END_OCCLUSION_QUERY = 102,
VT_BEGIN_XFB_PRIMITIVES_QUERY = 104,
VT_END_XFB_PRIMITIVES_QUERY = 106,
VT_ACTIVE_ATTRIB = 108,
VT_ACTIVE_UNIFORM = 110,
VT_PAYLOAD_BYTES = 112,
VT_OUT_CAPACITY = 114
};
uint32_t opcode() const {
return GetField<uint32_t>(VT_OPCODE, 0);
}
uint64_t session_id() const {
return GetField<uint64_t>(VT_SESSION_ID, 0);
}
uint64_t token() const {
return GetField<uint64_t>(VT_TOKEN, 0);
}
const MobileGL::Protocol::Wire::GlClear *clear() const {
return GetPointer<const MobileGL::Protocol::Wire::GlClear *>(VT_CLEAR);
}
const MobileGL::Protocol::Wire::ClearColor *clear_color() const {
return GetPointer<const MobileGL::Protocol::Wire::ClearColor *>(VT_CLEAR_COLOR);
}
const MobileGL::Protocol::Wire::DrawArrays *draw_arrays() const {
return GetPointer<const MobileGL::Protocol::Wire::DrawArrays *>(VT_DRAW_ARRAYS);
}
const MobileGL::Protocol::Wire::DrawElements *draw_elements() const {
return GetPointer<const MobileGL::Protocol::Wire::DrawElements *>(VT_DRAW_ELEMENTS);
}
const MobileGL::Protocol::Wire::BufferSubData *buffer_sub_data() const {
return GetPointer<const MobileGL::Protocol::Wire::BufferSubData *>(VT_BUFFER_SUB_DATA);
}
const MobileGL::Protocol::Wire::MemoryBarrier *memory_barrier() const {
return GetPointer<const MobileGL::Protocol::Wire::MemoryBarrier *>(VT_MEMORY_BARRIER);
}
const MobileGL::Protocol::Wire::MemoryBarrierByRegion *memory_barrier_by_region() const {
return GetPointer<const MobileGL::Protocol::Wire::MemoryBarrierByRegion *>(VT_MEMORY_BARRIER_BY_REGION);
}
const MobileGL::Protocol::Wire::PatchParameteri *patch_parameteri() const {
return GetPointer<const MobileGL::Protocol::Wire::PatchParameteri *>(VT_PATCH_PARAMETERI);
}
const MobileGL::Protocol::Wire::GenerateMipmap *generate_mipmap() const {
return GetPointer<const MobileGL::Protocol::Wire::GenerateMipmap *>(VT_GENERATE_MIPMAP);
}
const MobileGL::Protocol::Wire::DispatchCompute *dispatch_compute() const {
return GetPointer<const MobileGL::Protocol::Wire::DispatchCompute *>(VT_DISPATCH_COMPUTE);
}
const MobileGL::Protocol::Wire::BeginTransformFeedback *begin_transform_feedback() const {
return GetPointer<const MobileGL::Protocol::Wire::BeginTransformFeedback *>(VT_BEGIN_TRANSFORM_FEEDBACK);
}
const MobileGL::Protocol::Wire::BindTransformFeedback *bind_transform_feedback() const {
return GetPointer<const MobileGL::Protocol::Wire::BindTransformFeedback *>(VT_BIND_TRANSFORM_FEEDBACK);
}
const MobileGL::Protocol::Wire::BlitFramebuffer *blit_framebuffer() const {
return GetPointer<const MobileGL::Protocol::Wire::BlitFramebuffer *>(VT_BLIT_FRAMEBUFFER);
}
const MobileGL::Protocol::Wire::SwapBuffers *swap_buffers() const {
return GetPointer<const MobileGL::Protocol::Wire::SwapBuffers *>(VT_SWAP_BUFFERS);
}
const MobileGL::Protocol::Wire::DataBlob *data() const {
return GetPointer<const MobileGL::Protocol::Wire::DataBlob *>(VT_DATA);
}
const MobileGL::Protocol::Wire::DispatchComputeIndirect *dispatch_compute_indirect() const {
return GetPointer<const MobileGL::Protocol::Wire::DispatchComputeIndirect *>(VT_DISPATCH_COMPUTE_INDIRECT);
}
const MobileGL::Protocol::Wire::FenceSync *fence_sync() const {
return GetPointer<const MobileGL::Protocol::Wire::FenceSync *>(VT_FENCE_SYNC);
}
const MobileGL::Protocol::Wire::DeleteSync *delete_sync() const {
return GetPointer<const MobileGL::Protocol::Wire::DeleteSync *>(VT_DELETE_SYNC);
}
const MobileGL::Protocol::Wire::WaitSync *wait_sync() const {
return GetPointer<const MobileGL::Protocol::Wire::WaitSync *>(VT_WAIT_SYNC);
}
const MobileGL::Protocol::Wire::DrawArraysInstanced *draw_arrays_instanced() const {
return GetPointer<const MobileGL::Protocol::Wire::DrawArraysInstanced *>(VT_DRAW_ARRAYS_INSTANCED);
}
const MobileGL::Protocol::Wire::DrawElementsInstanced *draw_elements_instanced() const {
return GetPointer<const MobileGL::Protocol::Wire::DrawElementsInstanced *>(VT_DRAW_ELEMENTS_INSTANCED);
}
const MobileGL::Protocol::Wire::DrawRangeElements *draw_range_elements() const {
return GetPointer<const MobileGL::Protocol::Wire::DrawRangeElements *>(VT_DRAW_RANGE_ELEMENTS);
}
const MobileGL::Protocol::Wire::BufferRespecify *buffer_respecify() const {
return GetPointer<const MobileGL::Protocol::Wire::BufferRespecify *>(VT_BUFFER_RESPECIFY);
}
const MobileGL::Protocol::Wire::DrawArraysIndirect *draw_arrays_indirect() const {
return GetPointer<const MobileGL::Protocol::Wire::DrawArraysIndirect *>(VT_DRAW_ARRAYS_INDIRECT);
}
const MobileGL::Protocol::Wire::DrawElementsIndirect *draw_elements_indirect() const {
return GetPointer<const MobileGL::Protocol::Wire::DrawElementsIndirect *>(VT_DRAW_ELEMENTS_INDIRECT);
}
const MobileGL::Protocol::Wire::GetString *get_string() const {
return GetPointer<const MobileGL::Protocol::Wire::GetString *>(VT_GET_STRING);
}
const MobileGL::Protocol::Wire::GetStringi *get_stringi() const {
return GetPointer<const MobileGL::Protocol::Wire::GetStringi *>(VT_GET_STRINGI);
}
const MobileGL::Protocol::Wire::TextureRespecify *texture_respecify() const {
return GetPointer<const MobileGL::Protocol::Wire::TextureRespecify *>(VT_TEXTURE_RESPECIFY);
}
const MobileGL::Protocol::Wire::TextureSubImage *texture_sub_image() const {
return GetPointer<const MobileGL::Protocol::Wire::TextureSubImage *>(VT_TEXTURE_SUB_IMAGE);
}
const MobileGL::Protocol::Wire::ReadPixels *read_pixels() const {
return GetPointer<const MobileGL::Protocol::Wire::ReadPixels *>(VT_READ_PIXELS);
}
const MobileGL::Protocol::Wire::BufferReadbackFromGpu *buffer_readback_from_gpu() const {
return GetPointer<const MobileGL::Protocol::Wire::BufferReadbackFromGpu *>(VT_BUFFER_READBACK_FROM_GPU);
}
const MobileGL::Protocol::Wire::MapBufferRange *map_buffer_range() const {
return GetPointer<const MobileGL::Protocol::Wire::MapBufferRange *>(VT_MAP_BUFFER_RANGE);
}
const MobileGL::Protocol::Wire::UnmapBuffer *unmap_buffer() const {
return GetPointer<const MobileGL::Protocol::Wire::UnmapBuffer *>(VT_UNMAP_BUFFER);
}
const MobileGL::Protocol::Wire::EglCreatePbufferSurface *egl_create_pbuffer_surface() const {
return GetPointer<const MobileGL::Protocol::Wire::EglCreatePbufferSurface *>(VT_EGL_CREATE_PBUFFER_SURFACE);
}
const MobileGL::Protocol::Wire::EglCreateWindowSurface *egl_create_window_surface() const {
return GetPointer<const MobileGL::Protocol::Wire::EglCreateWindowSurface *>(VT_EGL_CREATE_WINDOW_SURFACE);
}
const MobileGL::Protocol::Wire::EglDestroySurface *egl_destroy_surface() const {
return GetPointer<const MobileGL::Protocol::Wire::EglDestroySurface *>(VT_EGL_DESTROY_SURFACE);
}
const MobileGL::Protocol::Wire::EglMakeCurrent *egl_make_current() const {
return GetPointer<const MobileGL::Protocol::Wire::EglMakeCurrent *>(VT_EGL_MAKE_CURRENT);
}
const MobileGL::Protocol::Wire::EglSwapInterval *egl_swap_interval() const {
return GetPointer<const MobileGL::Protocol::Wire::EglSwapInterval *>(VT_EGL_SWAP_INTERVAL);
}
const MobileGL::Protocol::Wire::EglResizeSurface *egl_resize_surface() const {
return GetPointer<const MobileGL::Protocol::Wire::EglResizeSurface *>(VT_EGL_RESIZE_SURFACE);
}
const MobileGL::Protocol::Wire::ClientWaitSync *client_wait_sync() const {
return GetPointer<const MobileGL::Protocol::Wire::ClientWaitSync *>(VT_CLIENT_WAIT_SYNC);
}
const MobileGL::Protocol::Wire::BeginTimeElapsedQuery *begin_time_elapsed_query() const {
return GetPointer<const MobileGL::Protocol::Wire::BeginTimeElapsedQuery *>(VT_BEGIN_TIME_ELAPSED_QUERY);
}
const MobileGL::Protocol::Wire::EndTimeElapsedQuery *end_time_elapsed_query() const {
return GetPointer<const MobileGL::Protocol::Wire::EndTimeElapsedQuery *>(VT_END_TIME_ELAPSED_QUERY);
}
const MobileGL::Protocol::Wire::DeleteBackendQuery *delete_backend_query() const {
return GetPointer<const MobileGL::Protocol::Wire::DeleteBackendQuery *>(VT_DELETE_BACKEND_QUERY);
}
const MobileGL::Protocol::Wire::IsQueryResultAvailable *is_query_result_available() const {
return GetPointer<const MobileGL::Protocol::Wire::IsQueryResultAvailable *>(VT_IS_QUERY_RESULT_AVAILABLE);
}
const MobileGL::Protocol::Wire::GetQueryResult64 *get_query_result64() const {
return GetPointer<const MobileGL::Protocol::Wire::GetQueryResult64 *>(VT_GET_QUERY_RESULT64);
}
const MobileGL::Protocol::Wire::BeginOcclusionQuery *begin_occlusion_query() const {
return GetPointer<const MobileGL::Protocol::Wire::BeginOcclusionQuery *>(VT_BEGIN_OCCLUSION_QUERY);
}
const MobileGL::Protocol::Wire::EndOcclusionQuery *end_occlusion_query() const {
return GetPointer<const MobileGL::Protocol::Wire::EndOcclusionQuery *>(VT_END_OCCLUSION_QUERY);
}
const MobileGL::Protocol::Wire::BeginXfbPrimitivesQuery *begin_xfb_primitives_query() const {
return GetPointer<const MobileGL::Protocol::Wire::BeginXfbPrimitivesQuery *>(VT_BEGIN_XFB_PRIMITIVES_QUERY);
}
const MobileGL::Protocol::Wire::EndXfbPrimitivesQuery *end_xfb_primitives_query() const {
return GetPointer<const MobileGL::Protocol::Wire::EndXfbPrimitivesQuery *>(VT_END_XFB_PRIMITIVES_QUERY);
}
const MobileGL::Protocol::Wire::ActiveVariable *active_attrib() const {
return GetPointer<const MobileGL::Protocol::Wire::ActiveVariable *>(VT_ACTIVE_ATTRIB);
}
const MobileGL::Protocol::Wire::ActiveVariable *active_uniform() const {
return GetPointer<const MobileGL::Protocol::Wire::ActiveVariable *>(VT_ACTIVE_UNIFORM);
}
const ::flatbuffers::Vector<uint8_t> *payload_bytes() const {
return GetPointer<const ::flatbuffers::Vector<uint8_t> *>(VT_PAYLOAD_BYTES);
}
uint32_t out_capacity() const {
return GetField<uint32_t>(VT_OUT_CAPACITY, 0);
}
template <bool B = false>
bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<uint32_t>(verifier, VT_OPCODE, 4) &&
VerifyField<uint64_t>(verifier, VT_SESSION_ID, 8) &&
VerifyField<uint64_t>(verifier, VT_TOKEN, 8) &&
VerifyOffset(verifier, VT_CLEAR) &&
verifier.VerifyTable(clear()) &&
VerifyOffset(verifier, VT_CLEAR_COLOR) &&
verifier.VerifyTable(clear_color()) &&
VerifyOffset(verifier, VT_DRAW_ARRAYS) &&
verifier.VerifyTable(draw_arrays()) &&
VerifyOffset(verifier, VT_DRAW_ELEMENTS) &&
verifier.VerifyTable(draw_elements()) &&
VerifyOffset(verifier, VT_BUFFER_SUB_DATA) &&
verifier.VerifyTable(buffer_sub_data()) &&
VerifyOffset(verifier, VT_MEMORY_BARRIER) &&
verifier.VerifyTable(memory_barrier()) &&
VerifyOffset(verifier, VT_MEMORY_BARRIER_BY_REGION) &&
verifier.VerifyTable(memory_barrier_by_region()) &&
VerifyOffset(verifier, VT_PATCH_PARAMETERI) &&
verifier.VerifyTable(patch_parameteri()) &&
VerifyOffset(verifier, VT_GENERATE_MIPMAP) &&
verifier.VerifyTable(generate_mipmap()) &&
VerifyOffset(verifier, VT_DISPATCH_COMPUTE) &&
verifier.VerifyTable(dispatch_compute()) &&
VerifyOffset(verifier, VT_BEGIN_TRANSFORM_FEEDBACK) &&
verifier.VerifyTable(begin_transform_feedback()) &&
VerifyOffset(verifier, VT_BIND_TRANSFORM_FEEDBACK) &&
verifier.VerifyTable(bind_transform_feedback()) &&
VerifyOffset(verifier, VT_BLIT_FRAMEBUFFER) &&
verifier.VerifyTable(blit_framebuffer()) &&
VerifyOffset(verifier, VT_SWAP_BUFFERS) &&
verifier.VerifyTable(swap_buffers()) &&
VerifyOffset(verifier, VT_DATA) &&
verifier.VerifyTable(data()) &&
VerifyOffset(verifier, VT_DISPATCH_COMPUTE_INDIRECT) &&
verifier.VerifyTable(dispatch_compute_indirect()) &&
VerifyOffset(verifier, VT_FENCE_SYNC) &&
verifier.VerifyTable(fence_sync()) &&
VerifyOffset(verifier, VT_DELETE_SYNC) &&
verifier.VerifyTable(delete_sync()) &&
VerifyOffset(verifier, VT_WAIT_SYNC) &&
verifier.VerifyTable(wait_sync()) &&
VerifyOffset(verifier, VT_DRAW_ARRAYS_INSTANCED) &&
verifier.VerifyTable(draw_arrays_instanced()) &&
VerifyOffset(verifier, VT_DRAW_ELEMENTS_INSTANCED) &&
verifier.VerifyTable(draw_elements_instanced()) &&
VerifyOffset(verifier, VT_DRAW_RANGE_ELEMENTS) &&
verifier.VerifyTable(draw_range_elements()) &&
VerifyOffset(verifier, VT_BUFFER_RESPECIFY) &&
verifier.VerifyTable(buffer_respecify()) &&
VerifyOffset(verifier, VT_DRAW_ARRAYS_INDIRECT) &&
verifier.VerifyTable(draw_arrays_indirect()) &&
VerifyOffset(verifier, VT_DRAW_ELEMENTS_INDIRECT) &&
verifier.VerifyTable(draw_elements_indirect()) &&
VerifyOffset(verifier, VT_GET_STRING) &&
verifier.VerifyTable(get_string()) &&
VerifyOffset(verifier, VT_GET_STRINGI) &&
verifier.VerifyTable(get_stringi()) &&
VerifyOffset(verifier, VT_TEXTURE_RESPECIFY) &&
verifier.VerifyTable(texture_respecify()) &&
VerifyOffset(verifier, VT_TEXTURE_SUB_IMAGE) &&
verifier.VerifyTable(texture_sub_image()) &&
VerifyOffset(verifier, VT_READ_PIXELS) &&
verifier.VerifyTable(read_pixels()) &&
VerifyOffset(verifier, VT_BUFFER_READBACK_FROM_GPU) &&
verifier.VerifyTable(buffer_readback_from_gpu()) &&
VerifyOffset(verifier, VT_MAP_BUFFER_RANGE) &&
verifier.VerifyTable(map_buffer_range()) &&
VerifyOffset(verifier, VT_UNMAP_BUFFER) &&
verifier.VerifyTable(unmap_buffer()) &&
VerifyOffset(verifier, VT_EGL_CREATE_PBUFFER_SURFACE) &&
verifier.VerifyTable(egl_create_pbuffer_surface()) &&
VerifyOffset(verifier, VT_EGL_CREATE_WINDOW_SURFACE) &&
verifier.VerifyTable(egl_create_window_surface()) &&
VerifyOffset(verifier, VT_EGL_DESTROY_SURFACE) &&
verifier.VerifyTable(egl_destroy_surface()) &&
VerifyOffset(verifier, VT_EGL_MAKE_CURRENT) &&
verifier.VerifyTable(egl_make_current()) &&
VerifyOffset(verifier, VT_EGL_SWAP_INTERVAL) &&
verifier.VerifyTable(egl_swap_interval()) &&
VerifyOffset(verifier, VT_EGL_RESIZE_SURFACE) &&
verifier.VerifyTable(egl_resize_surface()) &&
VerifyOffset(verifier, VT_CLIENT_WAIT_SYNC) &&
verifier.VerifyTable(client_wait_sync()) &&
VerifyOffset(verifier, VT_BEGIN_TIME_ELAPSED_QUERY) &&
verifier.VerifyTable(begin_time_elapsed_query()) &&
VerifyOffset(verifier, VT_END_TIME_ELAPSED_QUERY) &&
verifier.VerifyTable(end_time_elapsed_query()) &&
VerifyOffset(verifier, VT_DELETE_BACKEND_QUERY) &&
verifier.VerifyTable(delete_backend_query()) &&
VerifyOffset(verifier, VT_IS_QUERY_RESULT_AVAILABLE) &&
verifier.VerifyTable(is_query_result_available()) &&
VerifyOffset(verifier, VT_GET_QUERY_RESULT64) &&
verifier.VerifyTable(get_query_result64()) &&
VerifyOffset(verifier, VT_BEGIN_OCCLUSION_QUERY) &&
verifier.VerifyTable(begin_occlusion_query()) &&
VerifyOffset(verifier, VT_END_OCCLUSION_QUERY) &&
verifier.VerifyTable(end_occlusion_query()) &&
VerifyOffset(verifier, VT_BEGIN_XFB_PRIMITIVES_QUERY) &&
verifier.VerifyTable(begin_xfb_primitives_query()) &&
VerifyOffset(verifier, VT_END_XFB_PRIMITIVES_QUERY) &&
verifier.VerifyTable(end_xfb_primitives_query()) &&
VerifyOffset(verifier, VT_ACTIVE_ATTRIB) &&
verifier.VerifyTable(active_attrib()) &&
VerifyOffset(verifier, VT_ACTIVE_UNIFORM) &&
verifier.VerifyTable(active_uniform()) &&
VerifyOffset(verifier, VT_PAYLOAD_BYTES) &&
verifier.VerifyVector(payload_bytes()) &&
VerifyField<uint32_t>(verifier, VT_OUT_CAPACITY, 4) &&
verifier.EndTable();
}
};
struct CommandBuilder {
typedef Command Table;
::flatbuffers::FlatBufferBuilder &fbb_;
::flatbuffers::uoffset_t start_;
void add_opcode(uint32_t opcode) {
fbb_.AddElement<uint32_t>(Command::VT_OPCODE, opcode, 0);
}
void add_session_id(uint64_t session_id) {
fbb_.AddElement<uint64_t>(Command::VT_SESSION_ID, session_id, 0);
}
void add_token(uint64_t token) {
fbb_.AddElement<uint64_t>(Command::VT_TOKEN, token, 0);
}
void add_clear(::flatbuffers::Offset<MobileGL::Protocol::Wire::GlClear> clear) {
fbb_.AddOffset(Command::VT_CLEAR, clear);
}
void add_clear_color(::flatbuffers::Offset<MobileGL::Protocol::Wire::ClearColor> clear_color) {
fbb_.AddOffset(Command::VT_CLEAR_COLOR, clear_color);
}
void add_draw_arrays(::flatbuffers::Offset<MobileGL::Protocol::Wire::DrawArrays> draw_arrays) {
fbb_.AddOffset(Command::VT_DRAW_ARRAYS, draw_arrays);
}
void add_draw_elements(::flatbuffers::Offset<MobileGL::Protocol::Wire::DrawElements> draw_elements) {
fbb_.AddOffset(Command::VT_DRAW_ELEMENTS, draw_elements);
}
void add_buffer_sub_data(::flatbuffers::Offset<MobileGL::Protocol::Wire::BufferSubData> buffer_sub_data) {
fbb_.AddOffset(Command::VT_BUFFER_SUB_DATA, buffer_sub_data);
}
void add_memory_barrier(::flatbuffers::Offset<MobileGL::Protocol::Wire::MemoryBarrier> memory_barrier) {
fbb_.AddOffset(Command::VT_MEMORY_BARRIER, memory_barrier);
}
void add_memory_barrier_by_region(::flatbuffers::Offset<MobileGL::Protocol::Wire::MemoryBarrierByRegion> memory_barrier_by_region) {
fbb_.AddOffset(Command::VT_MEMORY_BARRIER_BY_REGION, memory_barrier_by_region);
}
void add_patch_parameteri(::flatbuffers::Offset<MobileGL::Protocol::Wire::PatchParameteri> patch_parameteri) {
fbb_.AddOffset(Command::VT_PATCH_PARAMETERI, patch_parameteri);
}
void add_generate_mipmap(::flatbuffers::Offset<MobileGL::Protocol::Wire::GenerateMipmap> generate_mipmap) {
fbb_.AddOffset(Command::VT_GENERATE_MIPMAP, generate_mipmap);
}
void add_dispatch_compute(::flatbuffers::Offset<MobileGL::Protocol::Wire::DispatchCompute> dispatch_compute) {
fbb_.AddOffset(Command::VT_DISPATCH_COMPUTE, dispatch_compute);
}
void add_begin_transform_feedback(::flatbuffers::Offset<MobileGL::Protocol::Wire::BeginTransformFeedback> begin_transform_feedback) {
fbb_.AddOffset(Command::VT_BEGIN_TRANSFORM_FEEDBACK, begin_transform_feedback);
}
void add_bind_transform_feedback(::flatbuffers::Offset<MobileGL::Protocol::Wire::BindTransformFeedback> bind_transform_feedback) {
fbb_.AddOffset(Command::VT_BIND_TRANSFORM_FEEDBACK, bind_transform_feedback);
}
void add_blit_framebuffer(::flatbuffers::Offset<MobileGL::Protocol::Wire::BlitFramebuffer> blit_framebuffer) {
fbb_.AddOffset(Command::VT_BLIT_FRAMEBUFFER, blit_framebuffer);
}
void add_swap_buffers(::flatbuffers::Offset<MobileGL::Protocol::Wire::SwapBuffers> swap_buffers) {
fbb_.AddOffset(Command::VT_SWAP_BUFFERS, swap_buffers);
}
void add_data(::flatbuffers::Offset<MobileGL::Protocol::Wire::DataBlob> data) {
fbb_.AddOffset(Command::VT_DATA, data);
}
void add_dispatch_compute_indirect(::flatbuffers::Offset<MobileGL::Protocol::Wire::DispatchComputeIndirect> dispatch_compute_indirect) {
fbb_.AddOffset(Command::VT_DISPATCH_COMPUTE_INDIRECT, dispatch_compute_indirect);
}
void add_fence_sync(::flatbuffers::Offset<MobileGL::Protocol::Wire::FenceSync> fence_sync) {
fbb_.AddOffset(Command::VT_FENCE_SYNC, fence_sync);
}
void add_delete_sync(::flatbuffers::Offset<MobileGL::Protocol::Wire::DeleteSync> delete_sync) {
fbb_.AddOffset(Command::VT_DELETE_SYNC, delete_sync);
}
void add_wait_sync(::flatbuffers::Offset<MobileGL::Protocol::Wire::WaitSync> wait_sync) {
fbb_.AddOffset(Command::VT_WAIT_SYNC, wait_sync);
}
void add_draw_arrays_instanced(::flatbuffers::Offset<MobileGL::Protocol::Wire::DrawArraysInstanced> draw_arrays_instanced) {
fbb_.AddOffset(Command::VT_DRAW_ARRAYS_INSTANCED, draw_arrays_instanced);
}
void add_draw_elements_instanced(::flatbuffers::Offset<MobileGL::Protocol::Wire::DrawElementsInstanced> draw_elements_instanced) {
fbb_.AddOffset(Command::VT_DRAW_ELEMENTS_INSTANCED, draw_elements_instanced);
}
void add_draw_range_elements(::flatbuffers::Offset<MobileGL::Protocol::Wire::DrawRangeElements> draw_range_elements) {
fbb_.AddOffset(Command::VT_DRAW_RANGE_ELEMENTS, draw_range_elements);
}
void add_buffer_respecify(::flatbuffers::Offset<MobileGL::Protocol::Wire::BufferRespecify> buffer_respecify) {
fbb_.AddOffset(Command::VT_BUFFER_RESPECIFY, buffer_respecify);
}
void add_draw_arrays_indirect(::flatbuffers::Offset<MobileGL::Protocol::Wire::DrawArraysIndirect> draw_arrays_indirect) {
fbb_.AddOffset(Command::VT_DRAW_ARRAYS_INDIRECT, draw_arrays_indirect);
}
void add_draw_elements_indirect(::flatbuffers::Offset<MobileGL::Protocol::Wire::DrawElementsIndirect> draw_elements_indirect) {
fbb_.AddOffset(Command::VT_DRAW_ELEMENTS_INDIRECT, draw_elements_indirect);
}
void add_get_string(::flatbuffers::Offset<MobileGL::Protocol::Wire::GetString> get_string) {
fbb_.AddOffset(Command::VT_GET_STRING, get_string);
}
void add_get_stringi(::flatbuffers::Offset<MobileGL::Protocol::Wire::GetStringi> get_stringi) {
fbb_.AddOffset(Command::VT_GET_STRINGI, get_stringi);
}
void add_texture_respecify(::flatbuffers::Offset<MobileGL::Protocol::Wire::TextureRespecify> texture_respecify) {
fbb_.AddOffset(Command::VT_TEXTURE_RESPECIFY, texture_respecify);
}
void add_texture_sub_image(::flatbuffers::Offset<MobileGL::Protocol::Wire::TextureSubImage> texture_sub_image) {
fbb_.AddOffset(Command::VT_TEXTURE_SUB_IMAGE, texture_sub_image);
}
void add_read_pixels(::flatbuffers::Offset<MobileGL::Protocol::Wire::ReadPixels> read_pixels) {
fbb_.AddOffset(Command::VT_READ_PIXELS, read_pixels);
}
void add_buffer_readback_from_gpu(::flatbuffers::Offset<MobileGL::Protocol::Wire::BufferReadbackFromGpu> buffer_readback_from_gpu) {
fbb_.AddOffset(Command::VT_BUFFER_READBACK_FROM_GPU, buffer_readback_from_gpu);
}
void add_map_buffer_range(::flatbuffers::Offset<MobileGL::Protocol::Wire::MapBufferRange> map_buffer_range) {
fbb_.AddOffset(Command::VT_MAP_BUFFER_RANGE, map_buffer_range);
}
void add_unmap_buffer(::flatbuffers::Offset<MobileGL::Protocol::Wire::UnmapBuffer> unmap_buffer) {
fbb_.AddOffset(Command::VT_UNMAP_BUFFER, unmap_buffer);
}
void add_egl_create_pbuffer_surface(::flatbuffers::Offset<MobileGL::Protocol::Wire::EglCreatePbufferSurface> egl_create_pbuffer_surface) {
fbb_.AddOffset(Command::VT_EGL_CREATE_PBUFFER_SURFACE, egl_create_pbuffer_surface);
}
void add_egl_create_window_surface(::flatbuffers::Offset<MobileGL::Protocol::Wire::EglCreateWindowSurface> egl_create_window_surface) {
fbb_.AddOffset(Command::VT_EGL_CREATE_WINDOW_SURFACE, egl_create_window_surface);
}
void add_egl_destroy_surface(::flatbuffers::Offset<MobileGL::Protocol::Wire::EglDestroySurface> egl_destroy_surface) {
fbb_.AddOffset(Command::VT_EGL_DESTROY_SURFACE, egl_destroy_surface);
}
void add_egl_make_current(::flatbuffers::Offset<MobileGL::Protocol::Wire::EglMakeCurrent> egl_make_current) {
fbb_.AddOffset(Command::VT_EGL_MAKE_CURRENT, egl_make_current);
}
void add_egl_swap_interval(::flatbuffers::Offset<MobileGL::Protocol::Wire::EglSwapInterval> egl_swap_interval) {
fbb_.AddOffset(Command::VT_EGL_SWAP_INTERVAL, egl_swap_interval);
}
void add_egl_resize_surface(::flatbuffers::Offset<MobileGL::Protocol::Wire::EglResizeSurface> egl_resize_surface) {
fbb_.AddOffset(Command::VT_EGL_RESIZE_SURFACE, egl_resize_surface);
}
void add_client_wait_sync(::flatbuffers::Offset<MobileGL::Protocol::Wire::ClientWaitSync> client_wait_sync) {
fbb_.AddOffset(Command::VT_CLIENT_WAIT_SYNC, client_wait_sync);
}
void add_begin_time_elapsed_query(::flatbuffers::Offset<MobileGL::Protocol::Wire::BeginTimeElapsedQuery> begin_time_elapsed_query) {
fbb_.AddOffset(Command::VT_BEGIN_TIME_ELAPSED_QUERY, begin_time_elapsed_query);
}
void add_end_time_elapsed_query(::flatbuffers::Offset<MobileGL::Protocol::Wire::EndTimeElapsedQuery> end_time_elapsed_query) {
fbb_.AddOffset(Command::VT_END_TIME_ELAPSED_QUERY, end_time_elapsed_query);
}
void add_delete_backend_query(::flatbuffers::Offset<MobileGL::Protocol::Wire::DeleteBackendQuery> delete_backend_query) {
fbb_.AddOffset(Command::VT_DELETE_BACKEND_QUERY, delete_backend_query);
}
void add_is_query_result_available(::flatbuffers::Offset<MobileGL::Protocol::Wire::IsQueryResultAvailable> is_query_result_available) {
fbb_.AddOffset(Command::VT_IS_QUERY_RESULT_AVAILABLE, is_query_result_available);
}
void add_get_query_result64(::flatbuffers::Offset<MobileGL::Protocol::Wire::GetQueryResult64> get_query_result64) {
fbb_.AddOffset(Command::VT_GET_QUERY_RESULT64, get_query_result64);
}
void add_begin_occlusion_query(::flatbuffers::Offset<MobileGL::Protocol::Wire::BeginOcclusionQuery> begin_occlusion_query) {
fbb_.AddOffset(Command::VT_BEGIN_OCCLUSION_QUERY, begin_occlusion_query);
}
void add_end_occlusion_query(::flatbuffers::Offset<MobileGL::Protocol::Wire::EndOcclusionQuery> end_occlusion_query) {
fbb_.AddOffset(Command::VT_END_OCCLUSION_QUERY, end_occlusion_query);
}
void add_begin_xfb_primitives_query(::flatbuffers::Offset<MobileGL::Protocol::Wire::BeginXfbPrimitivesQuery> begin_xfb_primitives_query) {
fbb_.AddOffset(Command::VT_BEGIN_XFB_PRIMITIVES_QUERY, begin_xfb_primitives_query);
}
void add_end_xfb_primitives_query(::flatbuffers::Offset<MobileGL::Protocol::Wire::EndXfbPrimitivesQuery> end_xfb_primitives_query) {
fbb_.AddOffset(Command::VT_END_XFB_PRIMITIVES_QUERY, end_xfb_primitives_query);
}
void add_active_attrib(::flatbuffers::Offset<MobileGL::Protocol::Wire::ActiveVariable> active_attrib) {
fbb_.AddOffset(Command::VT_ACTIVE_ATTRIB, active_attrib);
}
void add_active_uniform(::flatbuffers::Offset<MobileGL::Protocol::Wire::ActiveVariable> active_uniform) {
fbb_.AddOffset(Command::VT_ACTIVE_UNIFORM, active_uniform);
}
void add_payload_bytes(::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> payload_bytes) {
fbb_.AddOffset(Command::VT_PAYLOAD_BYTES, payload_bytes);
}
void add_out_capacity(uint32_t out_capacity) {
fbb_.AddElement<uint32_t>(Command::VT_OUT_CAPACITY, out_capacity, 0);
}
explicit CommandBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
::flatbuffers::Offset<Command> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = ::flatbuffers::Offset<Command>(end);
return o;
}
};
inline ::flatbuffers::Offset<Command> CreateCommand(
::flatbuffers::FlatBufferBuilder &_fbb,
uint32_t opcode = 0,
uint64_t session_id = 0,
uint64_t token = 0,
::flatbuffers::Offset<MobileGL::Protocol::Wire::GlClear> clear = 0,
::flatbuffers::Offset<MobileGL::Protocol::Wire::ClearColor> clear_color = 0,
::flatbuffers::Offset<MobileGL::Protocol::Wire::DrawArrays> draw_arrays = 0,
::flatbuffers::Offset<MobileGL::Protocol::Wire::DrawElements> draw_elements = 0,
::flatbuffers::Offset<MobileGL::Protocol::Wire::BufferSubData> buffer_sub_data = 0,
::flatbuffers::Offset<MobileGL::Protocol::Wire::MemoryBarrier> memory_barrier = 0,
::flatbuffers::Offset<MobileGL::Protocol::Wire::MemoryBarrierByRegion> memory_barrier_by_region = 0,
::flatbuffers::Offset<MobileGL::Protocol::Wire::PatchParameteri> patch_parameteri = 0,
::flatbuffers::Offset<MobileGL::Protocol::Wire::GenerateMipmap> generate_mipmap = 0,
::flatbuffers::Offset<MobileGL::Protocol::Wire::DispatchCompute> dispatch_compute = 0,
::flatbuffers::Offset<MobileGL::Protocol::Wire::BeginTransformFeedback> begin_transform_feedback = 0,
::flatbuffers::Offset<MobileGL::Protocol::Wire::BindTransformFeedback> bind_transform_feedback = 0,
::flatbuffers::Offset<MobileGL::Protocol::Wire::BlitFramebuffer> blit_framebuffer = 0,
::flatbuffers::Offset<MobileGL::Protocol::Wire::SwapBuffers> swap_buffers = 0,
::flatbuffers::Offset<MobileGL::Protocol::Wire::DataBlob> data = 0,
::flatbuffers::Offset<MobileGL::Protocol::Wire::DispatchComputeIndirect> dispatch_compute_indirect = 0,
::flatbuffers::Offset<MobileGL::Protocol::Wire::FenceSync> fence_sync = 0,
::flatbuffers::Offset<MobileGL::Protocol::Wire::DeleteSync> delete_sync = 0,
::flatbuffers::Offset<MobileGL::Protocol::Wire::WaitSync> wait_sync = 0,
::flatbuffers::Offset<MobileGL::Protocol::Wire::DrawArraysInstanced> draw_arrays_instanced = 0,
::flatbuffers::Offset<MobileGL::Protocol::Wire::DrawElementsInstanced> draw_elements_instanced = 0,
::flatbuffers::Offset<MobileGL::Protocol::Wire::DrawRangeElements> draw_range_elements = 0,
::flatbuffers::Offset<MobileGL::Protocol::Wire::BufferRespecify> buffer_respecify = 0,
::flatbuffers::Offset<MobileGL::Protocol::Wire::DrawArraysIndirect> draw_arrays_indirect = 0,
::flatbuffers::Offset<MobileGL::Protocol::Wire::DrawElementsIndirect> draw_elements_indirect = 0,
::flatbuffers::Offset<MobileGL::Protocol::Wire::GetString> get_string = 0,
::flatbuffers::Offset<MobileGL::Protocol::Wire::GetStringi> get_stringi = 0,
::flatbuffers::Offset<MobileGL::Protocol::Wire::TextureRespecify> texture_respecify = 0,
::flatbuffers::Offset<MobileGL::Protocol::Wire::TextureSubImage> texture_sub_image = 0,
::flatbuffers::Offset<MobileGL::Protocol::Wire::ReadPixels> read_pixels = 0,
::flatbuffers::Offset<MobileGL::Protocol::Wire::BufferReadbackFromGpu> buffer_readback_from_gpu = 0,
::flatbuffers::Offset<MobileGL::Protocol::Wire::MapBufferRange> map_buffer_range = 0,
::flatbuffers::Offset<MobileGL::Protocol::Wire::UnmapBuffer> unmap_buffer = 0,
::flatbuffers::Offset<MobileGL::Protocol::Wire::EglCreatePbufferSurface> egl_create_pbuffer_surface = 0,
::flatbuffers::Offset<MobileGL::Protocol::Wire::EglCreateWindowSurface> egl_create_window_surface = 0,
::flatbuffers::Offset<MobileGL::Protocol::Wire::EglDestroySurface> egl_destroy_surface = 0,
::flatbuffers::Offset<MobileGL::Protocol::Wire::EglMakeCurrent> egl_make_current = 0,
::flatbuffers::Offset<MobileGL::Protocol::Wire::EglSwapInterval> egl_swap_interval = 0,
::flatbuffers::Offset<MobileGL::Protocol::Wire::EglResizeSurface> egl_resize_surface = 0,
::flatbuffers::Offset<MobileGL::Protocol::Wire::ClientWaitSync> client_wait_sync = 0,
::flatbuffers::Offset<MobileGL::Protocol::Wire::BeginTimeElapsedQuery> begin_time_elapsed_query = 0,
::flatbuffers::Offset<MobileGL::Protocol::Wire::EndTimeElapsedQuery> end_time_elapsed_query = 0,
::flatbuffers::Offset<MobileGL::Protocol::Wire::DeleteBackendQuery> delete_backend_query = 0,
::flatbuffers::Offset<MobileGL::Protocol::Wire::IsQueryResultAvailable> is_query_result_available = 0,
::flatbuffers::Offset<MobileGL::Protocol::Wire::GetQueryResult64> get_query_result64 = 0,
::flatbuffers::Offset<MobileGL::Protocol::Wire::BeginOcclusionQuery> begin_occlusion_query = 0,
::flatbuffers::Offset<MobileGL::Protocol::Wire::EndOcclusionQuery> end_occlusion_query = 0,
::flatbuffers::Offset<MobileGL::Protocol::Wire::BeginXfbPrimitivesQuery> begin_xfb_primitives_query = 0,
::flatbuffers::Offset<MobileGL::Protocol::Wire::EndXfbPrimitivesQuery> end_xfb_primitives_query = 0,
::flatbuffers::Offset<MobileGL::Protocol::Wire::ActiveVariable> active_attrib = 0,
::flatbuffers::Offset<MobileGL::Protocol::Wire::ActiveVariable> active_uniform = 0,
::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> payload_bytes = 0,
uint32_t out_capacity = 0) {
CommandBuilder builder_(_fbb);
builder_.add_token(token);
builder_.add_session_id(session_id);
builder_.add_out_capacity(out_capacity);
builder_.add_payload_bytes(payload_bytes);
builder_.add_active_uniform(active_uniform);
builder_.add_active_attrib(active_attrib);
builder_.add_end_xfb_primitives_query(end_xfb_primitives_query);
builder_.add_begin_xfb_primitives_query(begin_xfb_primitives_query);
builder_.add_end_occlusion_query(end_occlusion_query);
builder_.add_begin_occlusion_query(begin_occlusion_query);
builder_.add_get_query_result64(get_query_result64);
builder_.add_is_query_result_available(is_query_result_available);
builder_.add_delete_backend_query(delete_backend_query);
builder_.add_end_time_elapsed_query(end_time_elapsed_query);
builder_.add_begin_time_elapsed_query(begin_time_elapsed_query);
builder_.add_client_wait_sync(client_wait_sync);
builder_.add_egl_resize_surface(egl_resize_surface);
builder_.add_egl_swap_interval(egl_swap_interval);
builder_.add_egl_make_current(egl_make_current);
builder_.add_egl_destroy_surface(egl_destroy_surface);
builder_.add_egl_create_window_surface(egl_create_window_surface);
builder_.add_egl_create_pbuffer_surface(egl_create_pbuffer_surface);
builder_.add_unmap_buffer(unmap_buffer);
builder_.add_map_buffer_range(map_buffer_range);
builder_.add_buffer_readback_from_gpu(buffer_readback_from_gpu);
builder_.add_read_pixels(read_pixels);
builder_.add_texture_sub_image(texture_sub_image);
builder_.add_texture_respecify(texture_respecify);
builder_.add_get_stringi(get_stringi);
builder_.add_get_string(get_string);
builder_.add_draw_elements_indirect(draw_elements_indirect);
builder_.add_draw_arrays_indirect(draw_arrays_indirect);
builder_.add_buffer_respecify(buffer_respecify);
builder_.add_draw_range_elements(draw_range_elements);
builder_.add_draw_elements_instanced(draw_elements_instanced);
builder_.add_draw_arrays_instanced(draw_arrays_instanced);
builder_.add_wait_sync(wait_sync);
builder_.add_delete_sync(delete_sync);
builder_.add_fence_sync(fence_sync);
builder_.add_dispatch_compute_indirect(dispatch_compute_indirect);
builder_.add_data(data);
builder_.add_swap_buffers(swap_buffers);
builder_.add_blit_framebuffer(blit_framebuffer);
builder_.add_bind_transform_feedback(bind_transform_feedback);
builder_.add_begin_transform_feedback(begin_transform_feedback);
builder_.add_dispatch_compute(dispatch_compute);
builder_.add_generate_mipmap(generate_mipmap);
builder_.add_patch_parameteri(patch_parameteri);
builder_.add_memory_barrier_by_region(memory_barrier_by_region);
builder_.add_memory_barrier(memory_barrier);
builder_.add_buffer_sub_data(buffer_sub_data);
builder_.add_draw_elements(draw_elements);
builder_.add_draw_arrays(draw_arrays);
builder_.add_clear_color(clear_color);
builder_.add_clear(clear);
builder_.add_opcode(opcode);
return builder_.Finish();
}
inline ::flatbuffers::Offset<Command> CreateCommandDirect(
::flatbuffers::FlatBufferBuilder &_fbb,
uint32_t opcode = 0,
uint64_t session_id = 0,
uint64_t token = 0,
::flatbuffers::Offset<MobileGL::Protocol::Wire::GlClear> clear = 0,
::flatbuffers::Offset<MobileGL::Protocol::Wire::ClearColor> clear_color = 0,
::flatbuffers::Offset<MobileGL::Protocol::Wire::DrawArrays> draw_arrays = 0,
::flatbuffers::Offset<MobileGL::Protocol::Wire::DrawElements> draw_elements = 0,
::flatbuffers::Offset<MobileGL::Protocol::Wire::BufferSubData> buffer_sub_data = 0,
::flatbuffers::Offset<MobileGL::Protocol::Wire::MemoryBarrier> memory_barrier = 0,
::flatbuffers::Offset<MobileGL::Protocol::Wire::MemoryBarrierByRegion> memory_barrier_by_region = 0,
::flatbuffers::Offset<MobileGL::Protocol::Wire::PatchParameteri> patch_parameteri = 0,
::flatbuffers::Offset<MobileGL::Protocol::Wire::GenerateMipmap> generate_mipmap = 0,
::flatbuffers::Offset<MobileGL::Protocol::Wire::DispatchCompute> dispatch_compute = 0,
::flatbuffers::Offset<MobileGL::Protocol::Wire::BeginTransformFeedback> begin_transform_feedback = 0,
::flatbuffers::Offset<MobileGL::Protocol::Wire::BindTransformFeedback> bind_transform_feedback = 0,
::flatbuffers::Offset<MobileGL::Protocol::Wire::BlitFramebuffer> blit_framebuffer = 0,
::flatbuffers::Offset<MobileGL::Protocol::Wire::SwapBuffers> swap_buffers = 0,
::flatbuffers::Offset<MobileGL::Protocol::Wire::DataBlob> data = 0,
::flatbuffers::Offset<MobileGL::Protocol::Wire::DispatchComputeIndirect> dispatch_compute_indirect = 0,
::flatbuffers::Offset<MobileGL::Protocol::Wire::FenceSync> fence_sync = 0,
::flatbuffers::Offset<MobileGL::Protocol::Wire::DeleteSync> delete_sync = 0,
::flatbuffers::Offset<MobileGL::Protocol::Wire::WaitSync> wait_sync = 0,
::flatbuffers::Offset<MobileGL::Protocol::Wire::DrawArraysInstanced> draw_arrays_instanced = 0,
::flatbuffers::Offset<MobileGL::Protocol::Wire::DrawElementsInstanced> draw_elements_instanced = 0,
::flatbuffers::Offset<MobileGL::Protocol::Wire::DrawRangeElements> draw_range_elements = 0,
::flatbuffers::Offset<MobileGL::Protocol::Wire::BufferRespecify> buffer_respecify = 0,
::flatbuffers::Offset<MobileGL::Protocol::Wire::DrawArraysIndirect> draw_arrays_indirect = 0,
::flatbuffers::Offset<MobileGL::Protocol::Wire::DrawElementsIndirect> draw_elements_indirect = 0,
::flatbuffers::Offset<MobileGL::Protocol::Wire::GetString> get_string = 0,
::flatbuffers::Offset<MobileGL::Protocol::Wire::GetStringi> get_stringi = 0,
::flatbuffers::Offset<MobileGL::Protocol::Wire::TextureRespecify> texture_respecify = 0,
::flatbuffers::Offset<MobileGL::Protocol::Wire::TextureSubImage> texture_sub_image = 0,
::flatbuffers::Offset<MobileGL::Protocol::Wire::ReadPixels> read_pixels = 0,
::flatbuffers::Offset<MobileGL::Protocol::Wire::BufferReadbackFromGpu> buffer_readback_from_gpu = 0,
::flatbuffers::Offset<MobileGL::Protocol::Wire::MapBufferRange> map_buffer_range = 0,
::flatbuffers::Offset<MobileGL::Protocol::Wire::UnmapBuffer> unmap_buffer = 0,
::flatbuffers::Offset<MobileGL::Protocol::Wire::EglCreatePbufferSurface> egl_create_pbuffer_surface = 0,
::flatbuffers::Offset<MobileGL::Protocol::Wire::EglCreateWindowSurface> egl_create_window_surface = 0,
::flatbuffers::Offset<MobileGL::Protocol::Wire::EglDestroySurface> egl_destroy_surface = 0,
::flatbuffers::Offset<MobileGL::Protocol::Wire::EglMakeCurrent> egl_make_current = 0,
::flatbuffers::Offset<MobileGL::Protocol::Wire::EglSwapInterval> egl_swap_interval = 0,
::flatbuffers::Offset<MobileGL::Protocol::Wire::EglResizeSurface> egl_resize_surface = 0,
::flatbuffers::Offset<MobileGL::Protocol::Wire::ClientWaitSync> client_wait_sync = 0,
::flatbuffers::Offset<MobileGL::Protocol::Wire::BeginTimeElapsedQuery> begin_time_elapsed_query = 0,
::flatbuffers::Offset<MobileGL::Protocol::Wire::EndTimeElapsedQuery> end_time_elapsed_query = 0,
::flatbuffers::Offset<MobileGL::Protocol::Wire::DeleteBackendQuery> delete_backend_query = 0,
::flatbuffers::Offset<MobileGL::Protocol::Wire::IsQueryResultAvailable> is_query_result_available = 0,
::flatbuffers::Offset<MobileGL::Protocol::Wire::GetQueryResult64> get_query_result64 = 0,
::flatbuffers::Offset<MobileGL::Protocol::Wire::BeginOcclusionQuery> begin_occlusion_query = 0,
::flatbuffers::Offset<MobileGL::Protocol::Wire::EndOcclusionQuery> end_occlusion_query = 0,
::flatbuffers::Offset<MobileGL::Protocol::Wire::BeginXfbPrimitivesQuery> begin_xfb_primitives_query = 0,
::flatbuffers::Offset<MobileGL::Protocol::Wire::EndXfbPrimitivesQuery> end_xfb_primitives_query = 0,
::flatbuffers::Offset<MobileGL::Protocol::Wire::ActiveVariable> active_attrib = 0,
::flatbuffers::Offset<MobileGL::Protocol::Wire::ActiveVariable> active_uniform = 0,
const std::vector<uint8_t> *payload_bytes = nullptr,
uint32_t out_capacity = 0) {
auto payload_bytes__ = payload_bytes ? _fbb.CreateVector<uint8_t>(*payload_bytes) : 0;
return MobileGL::Protocol::Wire::CreateCommand(
_fbb,
opcode,
session_id,
token,
clear,
clear_color,
draw_arrays,
draw_elements,
buffer_sub_data,
memory_barrier,
memory_barrier_by_region,
patch_parameteri,
generate_mipmap,
dispatch_compute,
begin_transform_feedback,
bind_transform_feedback,
blit_framebuffer,
swap_buffers,
data,
dispatch_compute_indirect,
fence_sync,
delete_sync,
wait_sync,
draw_arrays_instanced,
draw_elements_instanced,
draw_range_elements,
buffer_respecify,
draw_arrays_indirect,
draw_elements_indirect,
get_string,
get_stringi,
texture_respecify,
texture_sub_image,
read_pixels,
buffer_readback_from_gpu,
map_buffer_range,
unmap_buffer,
egl_create_pbuffer_surface,
egl_create_window_surface,
egl_destroy_surface,
egl_make_current,
egl_swap_interval,
egl_resize_surface,
client_wait_sync,
begin_time_elapsed_query,
end_time_elapsed_query,
delete_backend_query,
is_query_result_available,
get_query_result64,
begin_occlusion_query,
end_occlusion_query,
begin_xfb_primitives_query,
end_xfb_primitives_query,
active_attrib,
active_uniform,
payload_bytes__,
out_capacity);
}
struct ActiveVariable FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
typedef ActiveVariableBuilder Builder;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_PROGRAM = 4,
VT_INDEX = 6,
VT_BUF_SIZE = 8
};
uint32_t program() const {
return GetField<uint32_t>(VT_PROGRAM, 0);
}
uint32_t index() const {
return GetField<uint32_t>(VT_INDEX, 0);
}
uint32_t buf_size() const {
return GetField<uint32_t>(VT_BUF_SIZE, 0);
}
template <bool B = false>
bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<uint32_t>(verifier, VT_PROGRAM, 4) &&
VerifyField<uint32_t>(verifier, VT_INDEX, 4) &&
VerifyField<uint32_t>(verifier, VT_BUF_SIZE, 4) &&
verifier.EndTable();
}
};
struct ActiveVariableBuilder {
typedef ActiveVariable Table;
::flatbuffers::FlatBufferBuilder &fbb_;
::flatbuffers::uoffset_t start_;
void add_program(uint32_t program) {
fbb_.AddElement<uint32_t>(ActiveVariable::VT_PROGRAM, program, 0);
}
void add_index(uint32_t index) {
fbb_.AddElement<uint32_t>(ActiveVariable::VT_INDEX, index, 0);
}
void add_buf_size(uint32_t buf_size) {
fbb_.AddElement<uint32_t>(ActiveVariable::VT_BUF_SIZE, buf_size, 0);
}
explicit ActiveVariableBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
::flatbuffers::Offset<ActiveVariable> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = ::flatbuffers::Offset<ActiveVariable>(end);
return o;
}
};
inline ::flatbuffers::Offset<ActiveVariable> CreateActiveVariable(
::flatbuffers::FlatBufferBuilder &_fbb,
uint32_t program = 0,
uint32_t index = 0,
uint32_t buf_size = 0) {
ActiveVariableBuilder builder_(_fbb);
builder_.add_buf_size(buf_size);
builder_.add_index(index);
builder_.add_program(program);
return builder_.Finish();
}
struct Message FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
typedef MessageBuilder Builder;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_COMMAND = 4,
VT_SHM_COUNT = 6,
VT_COMMANDS = 8
};
const MobileGL::Protocol::Wire::Command *command() const {
return GetPointer<const MobileGL::Protocol::Wire::Command *>(VT_COMMAND);
}
uint32_t shm_count() const {
return GetField<uint32_t>(VT_SHM_COUNT, 0);
}
const ::flatbuffers::Vector<::flatbuffers::Offset<MobileGL::Protocol::Wire::Command>> *commands() const {
return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<MobileGL::Protocol::Wire::Command>> *>(VT_COMMANDS);
}
template <bool B = false>
bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
return VerifyTableStart(verifier) &&
VerifyOffset(verifier, VT_COMMAND) &&
verifier.VerifyTable(command()) &&
VerifyField<uint32_t>(verifier, VT_SHM_COUNT, 4) &&
VerifyOffset(verifier, VT_COMMANDS) &&
verifier.VerifyVector(commands()) &&
verifier.VerifyVectorOfTables(commands()) &&
verifier.EndTable();
}
};
struct MessageBuilder {
typedef Message Table;
::flatbuffers::FlatBufferBuilder &fbb_;
::flatbuffers::uoffset_t start_;
void add_command(::flatbuffers::Offset<MobileGL::Protocol::Wire::Command> command) {
fbb_.AddOffset(Message::VT_COMMAND, command);
}
void add_shm_count(uint32_t shm_count) {
fbb_.AddElement<uint32_t>(Message::VT_SHM_COUNT, shm_count, 0);
}
void add_commands(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<MobileGL::Protocol::Wire::Command>>> commands) {
fbb_.AddOffset(Message::VT_COMMANDS, commands);
}
explicit MessageBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
::flatbuffers::Offset<Message> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = ::flatbuffers::Offset<Message>(end);
return o;
}
};
inline ::flatbuffers::Offset<Message> CreateMessage(
::flatbuffers::FlatBufferBuilder &_fbb,
::flatbuffers::Offset<MobileGL::Protocol::Wire::Command> command = 0,
uint32_t shm_count = 0,
::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<MobileGL::Protocol::Wire::Command>>> commands = 0) {
MessageBuilder builder_(_fbb);
builder_.add_commands(commands);
builder_.add_shm_count(shm_count);
builder_.add_command(command);
return builder_.Finish();
}
inline ::flatbuffers::Offset<Message> CreateMessageDirect(
::flatbuffers::FlatBufferBuilder &_fbb,
::flatbuffers::Offset<MobileGL::Protocol::Wire::Command> command = 0,
uint32_t shm_count = 0,
const std::vector<::flatbuffers::Offset<MobileGL::Protocol::Wire::Command>> *commands = nullptr) {
auto commands__ = commands ? _fbb.CreateVector<::flatbuffers::Offset<MobileGL::Protocol::Wire::Command>>(*commands) : 0;
return MobileGL::Protocol::Wire::CreateMessage(
_fbb,
command,
shm_count,
commands__);
}
struct Response FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
typedef ResponseBuilder Builder;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_STATUS = 4,
VT_TOKEN = 6,
VT_SESSION_ID = 8,
VT_DATA_BYTE = 10,
VT_SYNC = 12,
VT_STRING_VALUE = 14,
VT_RET_SHM_COUNT = 16,
VT_QUERY_NS = 18,
VT_RET_I64 = 20,
VT_RET_BYTES = 22
};
uint32_t status() const {
return GetField<uint32_t>(VT_STATUS, 0);
}
uint64_t token() const {
return GetField<uint64_t>(VT_TOKEN, 0);
}
uint64_t session_id() const {
return GetField<uint64_t>(VT_SESSION_ID, 0);
}
uint32_t data_byte() const {
return GetField<uint32_t>(VT_DATA_BYTE, 0);
}
uint64_t sync() const {
return GetField<uint64_t>(VT_SYNC, 0);
}
const ::flatbuffers::String *string_value() const {
return GetPointer<const ::flatbuffers::String *>(VT_STRING_VALUE);
}
uint32_t ret_shm_count() const {
return GetField<uint32_t>(VT_RET_SHM_COUNT, 0);
}
uint64_t query_ns() const {
return GetField<uint64_t>(VT_QUERY_NS, 0);
}
int64_t ret_i64() const {
return GetField<int64_t>(VT_RET_I64, 0);
}
const ::flatbuffers::Vector<uint8_t> *ret_bytes() const {
return GetPointer<const ::flatbuffers::Vector<uint8_t> *>(VT_RET_BYTES);
}
template <bool B = false>
bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<uint32_t>(verifier, VT_STATUS, 4) &&
VerifyField<uint64_t>(verifier, VT_TOKEN, 8) &&
VerifyField<uint64_t>(verifier, VT_SESSION_ID, 8) &&
VerifyField<uint32_t>(verifier, VT_DATA_BYTE, 4) &&
VerifyField<uint64_t>(verifier, VT_SYNC, 8) &&
VerifyOffset(verifier, VT_STRING_VALUE) &&
verifier.VerifyString(string_value()) &&
VerifyField<uint32_t>(verifier, VT_RET_SHM_COUNT, 4) &&
VerifyField<uint64_t>(verifier, VT_QUERY_NS, 8) &&
VerifyField<int64_t>(verifier, VT_RET_I64, 8) &&
VerifyOffset(verifier, VT_RET_BYTES) &&
verifier.VerifyVector(ret_bytes()) &&
verifier.EndTable();
}
};
struct ResponseBuilder {
typedef Response Table;
::flatbuffers::FlatBufferBuilder &fbb_;
::flatbuffers::uoffset_t start_;
void add_status(uint32_t status) {
fbb_.AddElement<uint32_t>(Response::VT_STATUS, status, 0);
}
void add_token(uint64_t token) {
fbb_.AddElement<uint64_t>(Response::VT_TOKEN, token, 0);
}
void add_session_id(uint64_t session_id) {
fbb_.AddElement<uint64_t>(Response::VT_SESSION_ID, session_id, 0);
}
void add_data_byte(uint32_t data_byte) {
fbb_.AddElement<uint32_t>(Response::VT_DATA_BYTE, data_byte, 0);
}
void add_sync(uint64_t sync) {
fbb_.AddElement<uint64_t>(Response::VT_SYNC, sync, 0);
}
void add_string_value(::flatbuffers::Offset<::flatbuffers::String> string_value) {
fbb_.AddOffset(Response::VT_STRING_VALUE, string_value);
}
void add_ret_shm_count(uint32_t ret_shm_count) {
fbb_.AddElement<uint32_t>(Response::VT_RET_SHM_COUNT, ret_shm_count, 0);
}
void add_query_ns(uint64_t query_ns) {
fbb_.AddElement<uint64_t>(Response::VT_QUERY_NS, query_ns, 0);
}
void add_ret_i64(int64_t ret_i64) {
fbb_.AddElement<int64_t>(Response::VT_RET_I64, ret_i64, 0);
}
void add_ret_bytes(::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> ret_bytes) {
fbb_.AddOffset(Response::VT_RET_BYTES, ret_bytes);
}
explicit ResponseBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
::flatbuffers::Offset<Response> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = ::flatbuffers::Offset<Response>(end);
return o;
}
};
inline ::flatbuffers::Offset<Response> CreateResponse(
::flatbuffers::FlatBufferBuilder &_fbb,
uint32_t status = 0,
uint64_t token = 0,
uint64_t session_id = 0,
uint32_t data_byte = 0,
uint64_t sync = 0,
::flatbuffers::Offset<::flatbuffers::String> string_value = 0,
uint32_t ret_shm_count = 0,
uint64_t query_ns = 0,
int64_t ret_i64 = 0,
::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> ret_bytes = 0) {
ResponseBuilder builder_(_fbb);
builder_.add_ret_i64(ret_i64);
builder_.add_query_ns(query_ns);
builder_.add_sync(sync);
builder_.add_session_id(session_id);
builder_.add_token(token);
builder_.add_ret_bytes(ret_bytes);
builder_.add_ret_shm_count(ret_shm_count);
builder_.add_string_value(string_value);
builder_.add_data_byte(data_byte);
builder_.add_status(status);
return builder_.Finish();
}
inline ::flatbuffers::Offset<Response> CreateResponseDirect(
::flatbuffers::FlatBufferBuilder &_fbb,
uint32_t status = 0,
uint64_t token = 0,
uint64_t session_id = 0,
uint32_t data_byte = 0,
uint64_t sync = 0,
const char *string_value = nullptr,
uint32_t ret_shm_count = 0,
uint64_t query_ns = 0,
int64_t ret_i64 = 0,
const std::vector<uint8_t> *ret_bytes = nullptr) {
auto string_value__ = string_value ? _fbb.CreateString(string_value) : 0;
auto ret_bytes__ = ret_bytes ? _fbb.CreateVector<uint8_t>(*ret_bytes) : 0;
return MobileGL::Protocol::Wire::CreateResponse(
_fbb,
status,
token,
session_id,
data_byte,
sync,
string_value__,
ret_shm_count,
query_ns,
ret_i64,
ret_bytes__);
}
inline const MobileGL::Protocol::Wire::Message *GetMessage(const void *buf) {
return ::flatbuffers::GetRoot<MobileGL::Protocol::Wire::Message>(buf);
}
inline const MobileGL::Protocol::Wire::Message *GetSizePrefixedMessage(const void *buf) {
return ::flatbuffers::GetSizePrefixedRoot<MobileGL::Protocol::Wire::Message>(buf);
}
template <bool B = false>
inline bool VerifyMessageBuffer(
::flatbuffers::VerifierTemplate<B> &verifier) {
return verifier.template VerifyBuffer<MobileGL::Protocol::Wire::Message>(nullptr);
}
template <bool B = false>
inline bool VerifySizePrefixedMessageBuffer(
::flatbuffers::VerifierTemplate<B> &verifier) {
return verifier.template VerifySizePrefixedBuffer<MobileGL::Protocol::Wire::Message>(nullptr);
}
inline void FinishMessageBuffer(
::flatbuffers::FlatBufferBuilder &fbb,
::flatbuffers::Offset<MobileGL::Protocol::Wire::Message> root) {
fbb.Finish(root);
}
inline void FinishSizePrefixedMessageBuffer(
::flatbuffers::FlatBufferBuilder &fbb,
::flatbuffers::Offset<MobileGL::Protocol::Wire::Message> root) {
fbb.FinishSizePrefixed(root);
}
} // namespace Wire
} // namespace Protocol
} // namespace MobileGL
#endif // FLATBUFFERS_GENERATED_WIRE_MOBILEGL_PROTOCOL_WIRE_H_
Reference in New Issue View Git Blame Copy Permalink