[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.
This commit is contained in:
BZLZHH
2026-09-26 02:00:44 +08:00
parent 7c822cdc85
commit 4e48702f26
77 changed files with 270328 additions and 23 deletions
@@ -0,0 +1,37 @@
# automatically generated by the FlatBuffers compiler, do not modify
# namespace: Wire
import flatbuffers
from flatbuffers.compat import import_numpy
np = import_numpy()
class BeginOcclusionQuery(object):
__slots__ = ['_tab']
@classmethod
def GetRootAs(cls, buf, offset=0):
n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
x = BeginOcclusionQuery()
x.Init(buf, n + offset)
return x
@classmethod
def GetRootAsBeginOcclusionQuery(cls, buf, offset=0):
"""This method is deprecated. Please switch to GetRootAs."""
return cls.GetRootAs(buf, offset)
# BeginOcclusionQuery
def Init(self, buf, pos):
self._tab = flatbuffers.table.Table(buf, pos)
def BeginOcclusionQueryStart(builder):
builder.StartObject(0)
def Start(builder):
BeginOcclusionQueryStart(builder)
def BeginOcclusionQueryEnd(builder):
return builder.EndObject()
def End(builder):
return BeginOcclusionQueryEnd(builder)
@@ -0,0 +1,37 @@
# automatically generated by the FlatBuffers compiler, do not modify
# namespace: Wire
import flatbuffers
from flatbuffers.compat import import_numpy
np = import_numpy()
class BeginTimeElapsedQuery(object):
__slots__ = ['_tab']
@classmethod
def GetRootAs(cls, buf, offset=0):
n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
x = BeginTimeElapsedQuery()
x.Init(buf, n + offset)
return x
@classmethod
def GetRootAsBeginTimeElapsedQuery(cls, buf, offset=0):
"""This method is deprecated. Please switch to GetRootAs."""
return cls.GetRootAs(buf, offset)
# BeginTimeElapsedQuery
def Init(self, buf, pos):
self._tab = flatbuffers.table.Table(buf, pos)
def BeginTimeElapsedQueryStart(builder):
builder.StartObject(0)
def Start(builder):
BeginTimeElapsedQueryStart(builder)
def BeginTimeElapsedQueryEnd(builder):
return builder.EndObject()
def End(builder):
return BeginTimeElapsedQueryEnd(builder)
@@ -0,0 +1,50 @@
# automatically generated by the FlatBuffers compiler, do not modify
# namespace: Wire
import flatbuffers
from flatbuffers.compat import import_numpy
np = import_numpy()
class BeginTransformFeedback(object):
__slots__ = ['_tab']
@classmethod
def GetRootAs(cls, buf, offset=0):
n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
x = BeginTransformFeedback()
x.Init(buf, n + offset)
return x
@classmethod
def GetRootAsBeginTransformFeedback(cls, buf, offset=0):
"""This method is deprecated. Please switch to GetRootAs."""
return cls.GetRootAs(buf, offset)
# BeginTransformFeedback
def Init(self, buf, pos):
self._tab = flatbuffers.table.Table(buf, pos)
# BeginTransformFeedback
def PrimitiveMode(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos)
return 0
def BeginTransformFeedbackStart(builder):
builder.StartObject(1)
def Start(builder):
BeginTransformFeedbackStart(builder)
def BeginTransformFeedbackAddPrimitiveMode(builder, primitiveMode):
builder.PrependUint32Slot(0, primitiveMode, 0)
def AddPrimitiveMode(builder, primitiveMode):
BeginTransformFeedbackAddPrimitiveMode(builder, primitiveMode)
def BeginTransformFeedbackEnd(builder):
return builder.EndObject()
def End(builder):
return BeginTransformFeedbackEnd(builder)
@@ -0,0 +1,50 @@
# automatically generated by the FlatBuffers compiler, do not modify
# namespace: Wire
import flatbuffers
from flatbuffers.compat import import_numpy
np = import_numpy()
class BeginXfbPrimitivesQuery(object):
__slots__ = ['_tab']
@classmethod
def GetRootAs(cls, buf, offset=0):
n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
x = BeginXfbPrimitivesQuery()
x.Init(buf, n + offset)
return x
@classmethod
def GetRootAsBeginXfbPrimitivesQuery(cls, buf, offset=0):
"""This method is deprecated. Please switch to GetRootAs."""
return cls.GetRootAs(buf, offset)
# BeginXfbPrimitivesQuery
def Init(self, buf, pos):
self._tab = flatbuffers.table.Table(buf, pos)
# BeginXfbPrimitivesQuery
def Generated(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos)
return 0
def BeginXfbPrimitivesQueryStart(builder):
builder.StartObject(1)
def Start(builder):
BeginXfbPrimitivesQueryStart(builder)
def BeginXfbPrimitivesQueryAddGenerated(builder, generated):
builder.PrependUint32Slot(0, generated, 0)
def AddGenerated(builder, generated):
BeginXfbPrimitivesQueryAddGenerated(builder, generated)
def BeginXfbPrimitivesQueryEnd(builder):
return builder.EndObject()
def End(builder):
return BeginXfbPrimitivesQueryEnd(builder)
@@ -0,0 +1,50 @@
# automatically generated by the FlatBuffers compiler, do not modify
# namespace: Wire
import flatbuffers
from flatbuffers.compat import import_numpy
np = import_numpy()
class BindTransformFeedback(object):
__slots__ = ['_tab']
@classmethod
def GetRootAs(cls, buf, offset=0):
n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
x = BindTransformFeedback()
x.Init(buf, n + offset)
return x
@classmethod
def GetRootAsBindTransformFeedback(cls, buf, offset=0):
"""This method is deprecated. Please switch to GetRootAs."""
return cls.GetRootAs(buf, offset)
# BindTransformFeedback
def Init(self, buf, pos):
self._tab = flatbuffers.table.Table(buf, pos)
# BindTransformFeedback
def Name(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos)
return 0
def BindTransformFeedbackStart(builder):
builder.StartObject(1)
def Start(builder):
BindTransformFeedbackStart(builder)
def BindTransformFeedbackAddName(builder, name):
builder.PrependUint32Slot(0, name, 0)
def AddName(builder, name):
BindTransformFeedbackAddName(builder, name)
def BindTransformFeedbackEnd(builder):
return builder.EndObject()
def End(builder):
return BindTransformFeedbackEnd(builder)
@@ -0,0 +1,193 @@
# automatically generated by the FlatBuffers compiler, do not modify
# namespace: Wire
import flatbuffers
from flatbuffers.compat import import_numpy
np = import_numpy()
class BlitFramebuffer(object):
__slots__ = ['_tab']
@classmethod
def GetRootAs(cls, buf, offset=0):
n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
x = BlitFramebuffer()
x.Init(buf, n + offset)
return x
@classmethod
def GetRootAsBlitFramebuffer(cls, buf, offset=0):
"""This method is deprecated. Please switch to GetRootAs."""
return cls.GetRootAs(buf, offset)
# BlitFramebuffer
def Init(self, buf, pos):
self._tab = flatbuffers.table.Table(buf, pos)
# BlitFramebuffer
def ReadFramebuffer(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
return 0
# BlitFramebuffer
def DrawFramebuffer(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
return 0
# BlitFramebuffer
def SrcX0(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos)
return 0
# BlitFramebuffer
def SrcY0(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos)
return 0
# BlitFramebuffer
def SrcX1(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos)
return 0
# BlitFramebuffer
def SrcY1(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos)
return 0
# BlitFramebuffer
def DstX0(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos)
return 0
# BlitFramebuffer
def DstY0(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos)
return 0
# BlitFramebuffer
def DstX1(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(20))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos)
return 0
# BlitFramebuffer
def DstY1(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(22))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos)
return 0
# BlitFramebuffer
def Mask(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(24))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos)
return 0
# BlitFramebuffer
def Filter(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(26))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos)
return 0
def BlitFramebufferStart(builder):
builder.StartObject(12)
def Start(builder):
BlitFramebufferStart(builder)
def BlitFramebufferAddReadFramebuffer(builder, readFramebuffer):
builder.PrependUint64Slot(0, readFramebuffer, 0)
def AddReadFramebuffer(builder, readFramebuffer):
BlitFramebufferAddReadFramebuffer(builder, readFramebuffer)
def BlitFramebufferAddDrawFramebuffer(builder, drawFramebuffer):
builder.PrependUint64Slot(1, drawFramebuffer, 0)
def AddDrawFramebuffer(builder, drawFramebuffer):
BlitFramebufferAddDrawFramebuffer(builder, drawFramebuffer)
def BlitFramebufferAddSrcX0(builder, srcX0):
builder.PrependInt32Slot(2, srcX0, 0)
def AddSrcX0(builder, srcX0):
BlitFramebufferAddSrcX0(builder, srcX0)
def BlitFramebufferAddSrcY0(builder, srcY0):
builder.PrependInt32Slot(3, srcY0, 0)
def AddSrcY0(builder, srcY0):
BlitFramebufferAddSrcY0(builder, srcY0)
def BlitFramebufferAddSrcX1(builder, srcX1):
builder.PrependInt32Slot(4, srcX1, 0)
def AddSrcX1(builder, srcX1):
BlitFramebufferAddSrcX1(builder, srcX1)
def BlitFramebufferAddSrcY1(builder, srcY1):
builder.PrependInt32Slot(5, srcY1, 0)
def AddSrcY1(builder, srcY1):
BlitFramebufferAddSrcY1(builder, srcY1)
def BlitFramebufferAddDstX0(builder, dstX0):
builder.PrependInt32Slot(6, dstX0, 0)
def AddDstX0(builder, dstX0):
BlitFramebufferAddDstX0(builder, dstX0)
def BlitFramebufferAddDstY0(builder, dstY0):
builder.PrependInt32Slot(7, dstY0, 0)
def AddDstY0(builder, dstY0):
BlitFramebufferAddDstY0(builder, dstY0)
def BlitFramebufferAddDstX1(builder, dstX1):
builder.PrependInt32Slot(8, dstX1, 0)
def AddDstX1(builder, dstX1):
BlitFramebufferAddDstX1(builder, dstX1)
def BlitFramebufferAddDstY1(builder, dstY1):
builder.PrependInt32Slot(9, dstY1, 0)
def AddDstY1(builder, dstY1):
BlitFramebufferAddDstY1(builder, dstY1)
def BlitFramebufferAddMask(builder, mask):
builder.PrependUint32Slot(10, mask, 0)
def AddMask(builder, mask):
BlitFramebufferAddMask(builder, mask)
def BlitFramebufferAddFilter(builder, filter):
builder.PrependUint32Slot(11, filter, 0)
def AddFilter(builder, filter):
BlitFramebufferAddFilter(builder, filter)
def BlitFramebufferEnd(builder):
return builder.EndObject()
def End(builder):
return BlitFramebufferEnd(builder)
@@ -0,0 +1,76 @@
# automatically generated by the FlatBuffers compiler, do not modify
# namespace: Wire
import flatbuffers
from flatbuffers.compat import import_numpy
np = import_numpy()
class BufferReadbackFromGpu(object):
__slots__ = ['_tab']
@classmethod
def GetRootAs(cls, buf, offset=0):
n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
x = BufferReadbackFromGpu()
x.Init(buf, n + offset)
return x
@classmethod
def GetRootAsBufferReadbackFromGpu(cls, buf, offset=0):
"""This method is deprecated. Please switch to GetRootAs."""
return cls.GetRootAs(buf, offset)
# BufferReadbackFromGpu
def Init(self, buf, pos):
self._tab = flatbuffers.table.Table(buf, pos)
# BufferReadbackFromGpu
def BufferHandle(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
return 0
# BufferReadbackFromGpu
def Offset(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
return 0
# BufferReadbackFromGpu
def Size(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
return 0
def BufferReadbackFromGpuStart(builder):
builder.StartObject(3)
def Start(builder):
BufferReadbackFromGpuStart(builder)
def BufferReadbackFromGpuAddBufferHandle(builder, bufferHandle):
builder.PrependUint64Slot(0, bufferHandle, 0)
def AddBufferHandle(builder, bufferHandle):
BufferReadbackFromGpuAddBufferHandle(builder, bufferHandle)
def BufferReadbackFromGpuAddOffset(builder, offset):
builder.PrependUint64Slot(1, offset, 0)
def AddOffset(builder, offset):
BufferReadbackFromGpuAddOffset(builder, offset)
def BufferReadbackFromGpuAddSize(builder, size):
builder.PrependUint64Slot(2, size, 0)
def AddSize(builder, size):
BufferReadbackFromGpuAddSize(builder, size)
def BufferReadbackFromGpuEnd(builder):
return builder.EndObject()
def End(builder):
return BufferReadbackFromGpuEnd(builder)
@@ -0,0 +1,76 @@
# automatically generated by the FlatBuffers compiler, do not modify
# namespace: Wire
import flatbuffers
from flatbuffers.compat import import_numpy
np = import_numpy()
class BufferRespecify(object):
__slots__ = ['_tab']
@classmethod
def GetRootAs(cls, buf, offset=0):
n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
x = BufferRespecify()
x.Init(buf, n + offset)
return x
@classmethod
def GetRootAsBufferRespecify(cls, buf, offset=0):
"""This method is deprecated. Please switch to GetRootAs."""
return cls.GetRootAs(buf, offset)
# BufferRespecify
def Init(self, buf, pos):
self._tab = flatbuffers.table.Table(buf, pos)
# BufferRespecify
def BufferHandle(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
return 0
# BufferRespecify
def Size(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
return 0
# BufferRespecify
def Usage(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos)
return 0
def BufferRespecifyStart(builder):
builder.StartObject(3)
def Start(builder):
BufferRespecifyStart(builder)
def BufferRespecifyAddBufferHandle(builder, bufferHandle):
builder.PrependUint64Slot(0, bufferHandle, 0)
def AddBufferHandle(builder, bufferHandle):
BufferRespecifyAddBufferHandle(builder, bufferHandle)
def BufferRespecifyAddSize(builder, size):
builder.PrependUint64Slot(1, size, 0)
def AddSize(builder, size):
BufferRespecifyAddSize(builder, size)
def BufferRespecifyAddUsage(builder, usage):
builder.PrependUint32Slot(2, usage, 0)
def AddUsage(builder, usage):
BufferRespecifyAddUsage(builder, usage)
def BufferRespecifyEnd(builder):
return builder.EndObject()
def End(builder):
return BufferRespecifyEnd(builder)
@@ -0,0 +1,76 @@
# automatically generated by the FlatBuffers compiler, do not modify
# namespace: Wire
import flatbuffers
from flatbuffers.compat import import_numpy
np = import_numpy()
class BufferSubData(object):
__slots__ = ['_tab']
@classmethod
def GetRootAs(cls, buf, offset=0):
n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
x = BufferSubData()
x.Init(buf, n + offset)
return x
@classmethod
def GetRootAsBufferSubData(cls, buf, offset=0):
"""This method is deprecated. Please switch to GetRootAs."""
return cls.GetRootAs(buf, offset)
# BufferSubData
def Init(self, buf, pos):
self._tab = flatbuffers.table.Table(buf, pos)
# BufferSubData
def BufferHandle(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
return 0
# BufferSubData
def Offset(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
return 0
# BufferSubData
def Size(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
return 0
def BufferSubDataStart(builder):
builder.StartObject(3)
def Start(builder):
BufferSubDataStart(builder)
def BufferSubDataAddBufferHandle(builder, bufferHandle):
builder.PrependUint64Slot(0, bufferHandle, 0)
def AddBufferHandle(builder, bufferHandle):
BufferSubDataAddBufferHandle(builder, bufferHandle)
def BufferSubDataAddOffset(builder, offset):
builder.PrependUint64Slot(1, offset, 0)
def AddOffset(builder, offset):
BufferSubDataAddOffset(builder, offset)
def BufferSubDataAddSize(builder, size):
builder.PrependUint64Slot(2, size, 0)
def AddSize(builder, size):
BufferSubDataAddSize(builder, size)
def BufferSubDataEnd(builder):
return builder.EndObject()
def End(builder):
return BufferSubDataEnd(builder)
@@ -0,0 +1,89 @@
# automatically generated by the FlatBuffers compiler, do not modify
# namespace: Wire
import flatbuffers
from flatbuffers.compat import import_numpy
np = import_numpy()
class ClearColor(object):
__slots__ = ['_tab']
@classmethod
def GetRootAs(cls, buf, offset=0):
n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
x = ClearColor()
x.Init(buf, n + offset)
return x
@classmethod
def GetRootAsClearColor(cls, buf, offset=0):
"""This method is deprecated. Please switch to GetRootAs."""
return cls.GetRootAs(buf, offset)
# ClearColor
def Init(self, buf, pos):
self._tab = flatbuffers.table.Table(buf, pos)
# ClearColor
def Red(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Float32Flags, o + self._tab.Pos)
return 0.0
# ClearColor
def Green(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Float32Flags, o + self._tab.Pos)
return 0.0
# ClearColor
def Blue(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Float32Flags, o + self._tab.Pos)
return 0.0
# ClearColor
def Alpha(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Float32Flags, o + self._tab.Pos)
return 0.0
def ClearColorStart(builder):
builder.StartObject(4)
def Start(builder):
ClearColorStart(builder)
def ClearColorAddRed(builder, red):
builder.PrependFloat32Slot(0, red, 0.0)
def AddRed(builder, red):
ClearColorAddRed(builder, red)
def ClearColorAddGreen(builder, green):
builder.PrependFloat32Slot(1, green, 0.0)
def AddGreen(builder, green):
ClearColorAddGreen(builder, green)
def ClearColorAddBlue(builder, blue):
builder.PrependFloat32Slot(2, blue, 0.0)
def AddBlue(builder, blue):
ClearColorAddBlue(builder, blue)
def ClearColorAddAlpha(builder, alpha):
builder.PrependFloat32Slot(3, alpha, 0.0)
def AddAlpha(builder, alpha):
ClearColorAddAlpha(builder, alpha)
def ClearColorEnd(builder):
return builder.EndObject()
def End(builder):
return ClearColorEnd(builder)
@@ -0,0 +1,76 @@
# automatically generated by the FlatBuffers compiler, do not modify
# namespace: Wire
import flatbuffers
from flatbuffers.compat import import_numpy
np = import_numpy()
class ClientWaitSync(object):
__slots__ = ['_tab']
@classmethod
def GetRootAs(cls, buf, offset=0):
n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
x = ClientWaitSync()
x.Init(buf, n + offset)
return x
@classmethod
def GetRootAsClientWaitSync(cls, buf, offset=0):
"""This method is deprecated. Please switch to GetRootAs."""
return cls.GetRootAs(buf, offset)
# ClientWaitSync
def Init(self, buf, pos):
self._tab = flatbuffers.table.Table(buf, pos)
# ClientWaitSync
def Sync(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
return 0
# ClientWaitSync
def Flags(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos)
return 0
# ClientWaitSync
def Timeout(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
return 0
def ClientWaitSyncStart(builder):
builder.StartObject(3)
def Start(builder):
ClientWaitSyncStart(builder)
def ClientWaitSyncAddSync(builder, sync):
builder.PrependUint64Slot(0, sync, 0)
def AddSync(builder, sync):
ClientWaitSyncAddSync(builder, sync)
def ClientWaitSyncAddFlags(builder, flags):
builder.PrependUint32Slot(1, flags, 0)
def AddFlags(builder, flags):
ClientWaitSyncAddFlags(builder, flags)
def ClientWaitSyncAddTimeout(builder, timeout):
builder.PrependUint64Slot(2, timeout, 0)
def AddTimeout(builder, timeout):
ClientWaitSyncAddTimeout(builder, timeout)
def ClientWaitSyncEnd(builder):
return builder.EndObject()
def End(builder):
return ClientWaitSyncEnd(builder)
@@ -0,0 +1,875 @@
# automatically generated by the FlatBuffers compiler, do not modify
# namespace: Wire
import flatbuffers
from flatbuffers.compat import import_numpy
np = import_numpy()
class Command(object):
__slots__ = ['_tab']
@classmethod
def GetRootAs(cls, buf, offset=0):
n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
x = Command()
x.Init(buf, n + offset)
return x
@classmethod
def GetRootAsCommand(cls, buf, offset=0):
"""This method is deprecated. Please switch to GetRootAs."""
return cls.GetRootAs(buf, offset)
# Command
def Init(self, buf, pos):
self._tab = flatbuffers.table.Table(buf, pos)
# Command
def Opcode(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos)
return 0
# Command
def SessionId(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
return 0
# Command
def Token(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
return 0
# Command
def Clear(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
if o != 0:
x = self._tab.Indirect(o + self._tab.Pos)
from MobileGL.Protocol.Wire.GlClear import GlClear
obj = GlClear()
obj.Init(self._tab.Bytes, x)
return obj
return None
# Command
def ClearColor(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
if o != 0:
x = self._tab.Indirect(o + self._tab.Pos)
from MobileGL.Protocol.Wire.ClearColor import ClearColor
obj = ClearColor()
obj.Init(self._tab.Bytes, x)
return obj
return None
# Command
def DrawArrays(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
if o != 0:
x = self._tab.Indirect(o + self._tab.Pos)
from MobileGL.Protocol.Wire.DrawArrays import DrawArrays
obj = DrawArrays()
obj.Init(self._tab.Bytes, x)
return obj
return None
# Command
def DrawElements(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16))
if o != 0:
x = self._tab.Indirect(o + self._tab.Pos)
from MobileGL.Protocol.Wire.DrawElements import DrawElements
obj = DrawElements()
obj.Init(self._tab.Bytes, x)
return obj
return None
# Command
def BufferSubData(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18))
if o != 0:
x = self._tab.Indirect(o + self._tab.Pos)
from MobileGL.Protocol.Wire.BufferSubData import BufferSubData
obj = BufferSubData()
obj.Init(self._tab.Bytes, x)
return obj
return None
# Command
def MemoryBarrier(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(20))
if o != 0:
x = self._tab.Indirect(o + self._tab.Pos)
from MobileGL.Protocol.Wire.MemoryBarrier import MemoryBarrier
obj = MemoryBarrier()
obj.Init(self._tab.Bytes, x)
return obj
return None
# Command
def MemoryBarrierByRegion(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(22))
if o != 0:
x = self._tab.Indirect(o + self._tab.Pos)
from MobileGL.Protocol.Wire.MemoryBarrierByRegion import MemoryBarrierByRegion
obj = MemoryBarrierByRegion()
obj.Init(self._tab.Bytes, x)
return obj
return None
# Command
def PatchParameteri(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(24))
if o != 0:
x = self._tab.Indirect(o + self._tab.Pos)
from MobileGL.Protocol.Wire.PatchParameteri import PatchParameteri
obj = PatchParameteri()
obj.Init(self._tab.Bytes, x)
return obj
return None
# Command
def GenerateMipmap(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(26))
if o != 0:
x = self._tab.Indirect(o + self._tab.Pos)
from MobileGL.Protocol.Wire.GenerateMipmap import GenerateMipmap
obj = GenerateMipmap()
obj.Init(self._tab.Bytes, x)
return obj
return None
# Command
def DispatchCompute(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(28))
if o != 0:
x = self._tab.Indirect(o + self._tab.Pos)
from MobileGL.Protocol.Wire.DispatchCompute import DispatchCompute
obj = DispatchCompute()
obj.Init(self._tab.Bytes, x)
return obj
return None
# Command
def BeginTransformFeedback(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(30))
if o != 0:
x = self._tab.Indirect(o + self._tab.Pos)
from MobileGL.Protocol.Wire.BeginTransformFeedback import BeginTransformFeedback
obj = BeginTransformFeedback()
obj.Init(self._tab.Bytes, x)
return obj
return None
# Command
def BindTransformFeedback(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(32))
if o != 0:
x = self._tab.Indirect(o + self._tab.Pos)
from MobileGL.Protocol.Wire.BindTransformFeedback import BindTransformFeedback
obj = BindTransformFeedback()
obj.Init(self._tab.Bytes, x)
return obj
return None
# Command
def BlitFramebuffer(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(34))
if o != 0:
x = self._tab.Indirect(o + self._tab.Pos)
from MobileGL.Protocol.Wire.BlitFramebuffer import BlitFramebuffer
obj = BlitFramebuffer()
obj.Init(self._tab.Bytes, x)
return obj
return None
# Command
def SwapBuffers(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(36))
if o != 0:
x = self._tab.Indirect(o + self._tab.Pos)
from MobileGL.Protocol.Wire.SwapBuffers import SwapBuffers
obj = SwapBuffers()
obj.Init(self._tab.Bytes, x)
return obj
return None
# Command
def Data(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(38))
if o != 0:
x = self._tab.Indirect(o + self._tab.Pos)
from MobileGL.Protocol.Wire.DataBlob import DataBlob
obj = DataBlob()
obj.Init(self._tab.Bytes, x)
return obj
return None
# Command
def DispatchComputeIndirect(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(40))
if o != 0:
x = self._tab.Indirect(o + self._tab.Pos)
from MobileGL.Protocol.Wire.DispatchComputeIndirect import DispatchComputeIndirect
obj = DispatchComputeIndirect()
obj.Init(self._tab.Bytes, x)
return obj
return None
# Command
def FenceSync(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(42))
if o != 0:
x = self._tab.Indirect(o + self._tab.Pos)
from MobileGL.Protocol.Wire.FenceSync import FenceSync
obj = FenceSync()
obj.Init(self._tab.Bytes, x)
return obj
return None
# Command
def DeleteSync(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(44))
if o != 0:
x = self._tab.Indirect(o + self._tab.Pos)
from MobileGL.Protocol.Wire.DeleteSync import DeleteSync
obj = DeleteSync()
obj.Init(self._tab.Bytes, x)
return obj
return None
# Command
def WaitSync(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(46))
if o != 0:
x = self._tab.Indirect(o + self._tab.Pos)
from MobileGL.Protocol.Wire.WaitSync import WaitSync
obj = WaitSync()
obj.Init(self._tab.Bytes, x)
return obj
return None
# Command
def DrawArraysInstanced(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(48))
if o != 0:
x = self._tab.Indirect(o + self._tab.Pos)
from MobileGL.Protocol.Wire.DrawArraysInstanced import DrawArraysInstanced
obj = DrawArraysInstanced()
obj.Init(self._tab.Bytes, x)
return obj
return None
# Command
def DrawElementsInstanced(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(50))
if o != 0:
x = self._tab.Indirect(o + self._tab.Pos)
from MobileGL.Protocol.Wire.DrawElementsInstanced import DrawElementsInstanced
obj = DrawElementsInstanced()
obj.Init(self._tab.Bytes, x)
return obj
return None
# Command
def DrawRangeElements(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(52))
if o != 0:
x = self._tab.Indirect(o + self._tab.Pos)
from MobileGL.Protocol.Wire.DrawRangeElements import DrawRangeElements
obj = DrawRangeElements()
obj.Init(self._tab.Bytes, x)
return obj
return None
# Command
def BufferRespecify(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(54))
if o != 0:
x = self._tab.Indirect(o + self._tab.Pos)
from MobileGL.Protocol.Wire.BufferRespecify import BufferRespecify
obj = BufferRespecify()
obj.Init(self._tab.Bytes, x)
return obj
return None
# Command
def DrawArraysIndirect(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(56))
if o != 0:
x = self._tab.Indirect(o + self._tab.Pos)
from MobileGL.Protocol.Wire.DrawArraysIndirect import DrawArraysIndirect
obj = DrawArraysIndirect()
obj.Init(self._tab.Bytes, x)
return obj
return None
# Command
def DrawElementsIndirect(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(58))
if o != 0:
x = self._tab.Indirect(o + self._tab.Pos)
from MobileGL.Protocol.Wire.DrawElementsIndirect import DrawElementsIndirect
obj = DrawElementsIndirect()
obj.Init(self._tab.Bytes, x)
return obj
return None
# Command
def GetString(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(60))
if o != 0:
x = self._tab.Indirect(o + self._tab.Pos)
from MobileGL.Protocol.Wire.GetString import GetString
obj = GetString()
obj.Init(self._tab.Bytes, x)
return obj
return None
# Command
def TextureRespecify(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(62))
if o != 0:
x = self._tab.Indirect(o + self._tab.Pos)
from MobileGL.Protocol.Wire.TextureRespecify import TextureRespecify
obj = TextureRespecify()
obj.Init(self._tab.Bytes, x)
return obj
return None
# Command
def TextureSubImage(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(64))
if o != 0:
x = self._tab.Indirect(o + self._tab.Pos)
from MobileGL.Protocol.Wire.TextureSubImage import TextureSubImage
obj = TextureSubImage()
obj.Init(self._tab.Bytes, x)
return obj
return None
# Command
def ReadPixels(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(66))
if o != 0:
x = self._tab.Indirect(o + self._tab.Pos)
from MobileGL.Protocol.Wire.ReadPixels import ReadPixels
obj = ReadPixels()
obj.Init(self._tab.Bytes, x)
return obj
return None
# Command
def BufferReadbackFromGpu(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(68))
if o != 0:
x = self._tab.Indirect(o + self._tab.Pos)
from MobileGL.Protocol.Wire.BufferReadbackFromGpu import BufferReadbackFromGpu
obj = BufferReadbackFromGpu()
obj.Init(self._tab.Bytes, x)
return obj
return None
# Command
def MapBufferRange(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(70))
if o != 0:
x = self._tab.Indirect(o + self._tab.Pos)
from MobileGL.Protocol.Wire.MapBufferRange import MapBufferRange
obj = MapBufferRange()
obj.Init(self._tab.Bytes, x)
return obj
return None
# Command
def UnmapBuffer(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(72))
if o != 0:
x = self._tab.Indirect(o + self._tab.Pos)
from MobileGL.Protocol.Wire.UnmapBuffer import UnmapBuffer
obj = UnmapBuffer()
obj.Init(self._tab.Bytes, x)
return obj
return None
# Command
def EglCreatePbufferSurface(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(74))
if o != 0:
x = self._tab.Indirect(o + self._tab.Pos)
from MobileGL.Protocol.Wire.EglCreatePbufferSurface import EglCreatePbufferSurface
obj = EglCreatePbufferSurface()
obj.Init(self._tab.Bytes, x)
return obj
return None
# Command
def EglDestroySurface(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(76))
if o != 0:
x = self._tab.Indirect(o + self._tab.Pos)
from MobileGL.Protocol.Wire.EglDestroySurface import EglDestroySurface
obj = EglDestroySurface()
obj.Init(self._tab.Bytes, x)
return obj
return None
# Command
def EglMakeCurrent(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(78))
if o != 0:
x = self._tab.Indirect(o + self._tab.Pos)
from MobileGL.Protocol.Wire.EglMakeCurrent import EglMakeCurrent
obj = EglMakeCurrent()
obj.Init(self._tab.Bytes, x)
return obj
return None
# Command
def EglSwapInterval(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(80))
if o != 0:
x = self._tab.Indirect(o + self._tab.Pos)
from MobileGL.Protocol.Wire.EglSwapInterval import EglSwapInterval
obj = EglSwapInterval()
obj.Init(self._tab.Bytes, x)
return obj
return None
# Command
def EglResizeSurface(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(82))
if o != 0:
x = self._tab.Indirect(o + self._tab.Pos)
from MobileGL.Protocol.Wire.EglResizeSurface import EglResizeSurface
obj = EglResizeSurface()
obj.Init(self._tab.Bytes, x)
return obj
return None
# Command
def ClientWaitSync(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(84))
if o != 0:
x = self._tab.Indirect(o + self._tab.Pos)
from MobileGL.Protocol.Wire.ClientWaitSync import ClientWaitSync
obj = ClientWaitSync()
obj.Init(self._tab.Bytes, x)
return obj
return None
# Command
def BeginTimeElapsedQuery(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(86))
if o != 0:
x = self._tab.Indirect(o + self._tab.Pos)
from MobileGL.Protocol.Wire.BeginTimeElapsedQuery import BeginTimeElapsedQuery
obj = BeginTimeElapsedQuery()
obj.Init(self._tab.Bytes, x)
return obj
return None
# Command
def EndTimeElapsedQuery(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(88))
if o != 0:
x = self._tab.Indirect(o + self._tab.Pos)
from MobileGL.Protocol.Wire.EndTimeElapsedQuery import EndTimeElapsedQuery
obj = EndTimeElapsedQuery()
obj.Init(self._tab.Bytes, x)
return obj
return None
# Command
def DeleteBackendQuery(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(90))
if o != 0:
x = self._tab.Indirect(o + self._tab.Pos)
from MobileGL.Protocol.Wire.DeleteBackendQuery import DeleteBackendQuery
obj = DeleteBackendQuery()
obj.Init(self._tab.Bytes, x)
return obj
return None
# Command
def IsQueryResultAvailable(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(92))
if o != 0:
x = self._tab.Indirect(o + self._tab.Pos)
from MobileGL.Protocol.Wire.IsQueryResultAvailable import IsQueryResultAvailable
obj = IsQueryResultAvailable()
obj.Init(self._tab.Bytes, x)
return obj
return None
# Command
def GetQueryResult64(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(94))
if o != 0:
x = self._tab.Indirect(o + self._tab.Pos)
from MobileGL.Protocol.Wire.GetQueryResult64 import GetQueryResult64
obj = GetQueryResult64()
obj.Init(self._tab.Bytes, x)
return obj
return None
# Command
def BeginOcclusionQuery(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(96))
if o != 0:
x = self._tab.Indirect(o + self._tab.Pos)
from MobileGL.Protocol.Wire.BeginOcclusionQuery import BeginOcclusionQuery
obj = BeginOcclusionQuery()
obj.Init(self._tab.Bytes, x)
return obj
return None
# Command
def EndOcclusionQuery(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(98))
if o != 0:
x = self._tab.Indirect(o + self._tab.Pos)
from MobileGL.Protocol.Wire.EndOcclusionQuery import EndOcclusionQuery
obj = EndOcclusionQuery()
obj.Init(self._tab.Bytes, x)
return obj
return None
# Command
def BeginXfbPrimitivesQuery(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(100))
if o != 0:
x = self._tab.Indirect(o + self._tab.Pos)
from MobileGL.Protocol.Wire.BeginXfbPrimitivesQuery import BeginXfbPrimitivesQuery
obj = BeginXfbPrimitivesQuery()
obj.Init(self._tab.Bytes, x)
return obj
return None
# Command
def EndXfbPrimitivesQuery(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(102))
if o != 0:
x = self._tab.Indirect(o + self._tab.Pos)
from MobileGL.Protocol.Wire.EndXfbPrimitivesQuery import EndXfbPrimitivesQuery
obj = EndXfbPrimitivesQuery()
obj.Init(self._tab.Bytes, x)
return obj
return None
def CommandStart(builder):
builder.StartObject(50)
def Start(builder):
CommandStart(builder)
def CommandAddOpcode(builder, opcode):
builder.PrependUint32Slot(0, opcode, 0)
def AddOpcode(builder, opcode):
CommandAddOpcode(builder, opcode)
def CommandAddSessionId(builder, sessionId):
builder.PrependUint64Slot(1, sessionId, 0)
def AddSessionId(builder, sessionId):
CommandAddSessionId(builder, sessionId)
def CommandAddToken(builder, token):
builder.PrependUint64Slot(2, token, 0)
def AddToken(builder, token):
CommandAddToken(builder, token)
def CommandAddClear(builder, clear):
builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(clear), 0)
def AddClear(builder, clear):
CommandAddClear(builder, clear)
def CommandAddClearColor(builder, clearColor):
builder.PrependUOffsetTRelativeSlot(4, flatbuffers.number_types.UOffsetTFlags.py_type(clearColor), 0)
def AddClearColor(builder, clearColor):
CommandAddClearColor(builder, clearColor)
def CommandAddDrawArrays(builder, drawArrays):
builder.PrependUOffsetTRelativeSlot(5, flatbuffers.number_types.UOffsetTFlags.py_type(drawArrays), 0)
def AddDrawArrays(builder, drawArrays):
CommandAddDrawArrays(builder, drawArrays)
def CommandAddDrawElements(builder, drawElements):
builder.PrependUOffsetTRelativeSlot(6, flatbuffers.number_types.UOffsetTFlags.py_type(drawElements), 0)
def AddDrawElements(builder, drawElements):
CommandAddDrawElements(builder, drawElements)
def CommandAddBufferSubData(builder, bufferSubData):
builder.PrependUOffsetTRelativeSlot(7, flatbuffers.number_types.UOffsetTFlags.py_type(bufferSubData), 0)
def AddBufferSubData(builder, bufferSubData):
CommandAddBufferSubData(builder, bufferSubData)
def CommandAddMemoryBarrier(builder, memoryBarrier):
builder.PrependUOffsetTRelativeSlot(8, flatbuffers.number_types.UOffsetTFlags.py_type(memoryBarrier), 0)
def AddMemoryBarrier(builder, memoryBarrier):
CommandAddMemoryBarrier(builder, memoryBarrier)
def CommandAddMemoryBarrierByRegion(builder, memoryBarrierByRegion):
builder.PrependUOffsetTRelativeSlot(9, flatbuffers.number_types.UOffsetTFlags.py_type(memoryBarrierByRegion), 0)
def AddMemoryBarrierByRegion(builder, memoryBarrierByRegion):
CommandAddMemoryBarrierByRegion(builder, memoryBarrierByRegion)
def CommandAddPatchParameteri(builder, patchParameteri):
builder.PrependUOffsetTRelativeSlot(10, flatbuffers.number_types.UOffsetTFlags.py_type(patchParameteri), 0)
def AddPatchParameteri(builder, patchParameteri):
CommandAddPatchParameteri(builder, patchParameteri)
def CommandAddGenerateMipmap(builder, generateMipmap):
builder.PrependUOffsetTRelativeSlot(11, flatbuffers.number_types.UOffsetTFlags.py_type(generateMipmap), 0)
def AddGenerateMipmap(builder, generateMipmap):
CommandAddGenerateMipmap(builder, generateMipmap)
def CommandAddDispatchCompute(builder, dispatchCompute):
builder.PrependUOffsetTRelativeSlot(12, flatbuffers.number_types.UOffsetTFlags.py_type(dispatchCompute), 0)
def AddDispatchCompute(builder, dispatchCompute):
CommandAddDispatchCompute(builder, dispatchCompute)
def CommandAddBeginTransformFeedback(builder, beginTransformFeedback):
builder.PrependUOffsetTRelativeSlot(13, flatbuffers.number_types.UOffsetTFlags.py_type(beginTransformFeedback), 0)
def AddBeginTransformFeedback(builder, beginTransformFeedback):
CommandAddBeginTransformFeedback(builder, beginTransformFeedback)
def CommandAddBindTransformFeedback(builder, bindTransformFeedback):
builder.PrependUOffsetTRelativeSlot(14, flatbuffers.number_types.UOffsetTFlags.py_type(bindTransformFeedback), 0)
def AddBindTransformFeedback(builder, bindTransformFeedback):
CommandAddBindTransformFeedback(builder, bindTransformFeedback)
def CommandAddBlitFramebuffer(builder, blitFramebuffer):
builder.PrependUOffsetTRelativeSlot(15, flatbuffers.number_types.UOffsetTFlags.py_type(blitFramebuffer), 0)
def AddBlitFramebuffer(builder, blitFramebuffer):
CommandAddBlitFramebuffer(builder, blitFramebuffer)
def CommandAddSwapBuffers(builder, swapBuffers):
builder.PrependUOffsetTRelativeSlot(16, flatbuffers.number_types.UOffsetTFlags.py_type(swapBuffers), 0)
def AddSwapBuffers(builder, swapBuffers):
CommandAddSwapBuffers(builder, swapBuffers)
def CommandAddData(builder, data):
builder.PrependUOffsetTRelativeSlot(17, flatbuffers.number_types.UOffsetTFlags.py_type(data), 0)
def AddData(builder, data):
CommandAddData(builder, data)
def CommandAddDispatchComputeIndirect(builder, dispatchComputeIndirect):
builder.PrependUOffsetTRelativeSlot(18, flatbuffers.number_types.UOffsetTFlags.py_type(dispatchComputeIndirect), 0)
def AddDispatchComputeIndirect(builder, dispatchComputeIndirect):
CommandAddDispatchComputeIndirect(builder, dispatchComputeIndirect)
def CommandAddFenceSync(builder, fenceSync):
builder.PrependUOffsetTRelativeSlot(19, flatbuffers.number_types.UOffsetTFlags.py_type(fenceSync), 0)
def AddFenceSync(builder, fenceSync):
CommandAddFenceSync(builder, fenceSync)
def CommandAddDeleteSync(builder, deleteSync):
builder.PrependUOffsetTRelativeSlot(20, flatbuffers.number_types.UOffsetTFlags.py_type(deleteSync), 0)
def AddDeleteSync(builder, deleteSync):
CommandAddDeleteSync(builder, deleteSync)
def CommandAddWaitSync(builder, waitSync):
builder.PrependUOffsetTRelativeSlot(21, flatbuffers.number_types.UOffsetTFlags.py_type(waitSync), 0)
def AddWaitSync(builder, waitSync):
CommandAddWaitSync(builder, waitSync)
def CommandAddDrawArraysInstanced(builder, drawArraysInstanced):
builder.PrependUOffsetTRelativeSlot(22, flatbuffers.number_types.UOffsetTFlags.py_type(drawArraysInstanced), 0)
def AddDrawArraysInstanced(builder, drawArraysInstanced):
CommandAddDrawArraysInstanced(builder, drawArraysInstanced)
def CommandAddDrawElementsInstanced(builder, drawElementsInstanced):
builder.PrependUOffsetTRelativeSlot(23, flatbuffers.number_types.UOffsetTFlags.py_type(drawElementsInstanced), 0)
def AddDrawElementsInstanced(builder, drawElementsInstanced):
CommandAddDrawElementsInstanced(builder, drawElementsInstanced)
def CommandAddDrawRangeElements(builder, drawRangeElements):
builder.PrependUOffsetTRelativeSlot(24, flatbuffers.number_types.UOffsetTFlags.py_type(drawRangeElements), 0)
def AddDrawRangeElements(builder, drawRangeElements):
CommandAddDrawRangeElements(builder, drawRangeElements)
def CommandAddBufferRespecify(builder, bufferRespecify):
builder.PrependUOffsetTRelativeSlot(25, flatbuffers.number_types.UOffsetTFlags.py_type(bufferRespecify), 0)
def AddBufferRespecify(builder, bufferRespecify):
CommandAddBufferRespecify(builder, bufferRespecify)
def CommandAddDrawArraysIndirect(builder, drawArraysIndirect):
builder.PrependUOffsetTRelativeSlot(26, flatbuffers.number_types.UOffsetTFlags.py_type(drawArraysIndirect), 0)
def AddDrawArraysIndirect(builder, drawArraysIndirect):
CommandAddDrawArraysIndirect(builder, drawArraysIndirect)
def CommandAddDrawElementsIndirect(builder, drawElementsIndirect):
builder.PrependUOffsetTRelativeSlot(27, flatbuffers.number_types.UOffsetTFlags.py_type(drawElementsIndirect), 0)
def AddDrawElementsIndirect(builder, drawElementsIndirect):
CommandAddDrawElementsIndirect(builder, drawElementsIndirect)
def CommandAddGetString(builder, getString):
builder.PrependUOffsetTRelativeSlot(28, flatbuffers.number_types.UOffsetTFlags.py_type(getString), 0)
def AddGetString(builder, getString):
CommandAddGetString(builder, getString)
def CommandAddTextureRespecify(builder, textureRespecify):
builder.PrependUOffsetTRelativeSlot(29, flatbuffers.number_types.UOffsetTFlags.py_type(textureRespecify), 0)
def AddTextureRespecify(builder, textureRespecify):
CommandAddTextureRespecify(builder, textureRespecify)
def CommandAddTextureSubImage(builder, textureSubImage):
builder.PrependUOffsetTRelativeSlot(30, flatbuffers.number_types.UOffsetTFlags.py_type(textureSubImage), 0)
def AddTextureSubImage(builder, textureSubImage):
CommandAddTextureSubImage(builder, textureSubImage)
def CommandAddReadPixels(builder, readPixels):
builder.PrependUOffsetTRelativeSlot(31, flatbuffers.number_types.UOffsetTFlags.py_type(readPixels), 0)
def AddReadPixels(builder, readPixels):
CommandAddReadPixels(builder, readPixels)
def CommandAddBufferReadbackFromGpu(builder, bufferReadbackFromGpu):
builder.PrependUOffsetTRelativeSlot(32, flatbuffers.number_types.UOffsetTFlags.py_type(bufferReadbackFromGpu), 0)
def AddBufferReadbackFromGpu(builder, bufferReadbackFromGpu):
CommandAddBufferReadbackFromGpu(builder, bufferReadbackFromGpu)
def CommandAddMapBufferRange(builder, mapBufferRange):
builder.PrependUOffsetTRelativeSlot(33, flatbuffers.number_types.UOffsetTFlags.py_type(mapBufferRange), 0)
def AddMapBufferRange(builder, mapBufferRange):
CommandAddMapBufferRange(builder, mapBufferRange)
def CommandAddUnmapBuffer(builder, unmapBuffer):
builder.PrependUOffsetTRelativeSlot(34, flatbuffers.number_types.UOffsetTFlags.py_type(unmapBuffer), 0)
def AddUnmapBuffer(builder, unmapBuffer):
CommandAddUnmapBuffer(builder, unmapBuffer)
def CommandAddEglCreatePbufferSurface(builder, eglCreatePbufferSurface):
builder.PrependUOffsetTRelativeSlot(35, flatbuffers.number_types.UOffsetTFlags.py_type(eglCreatePbufferSurface), 0)
def AddEglCreatePbufferSurface(builder, eglCreatePbufferSurface):
CommandAddEglCreatePbufferSurface(builder, eglCreatePbufferSurface)
def CommandAddEglDestroySurface(builder, eglDestroySurface):
builder.PrependUOffsetTRelativeSlot(36, flatbuffers.number_types.UOffsetTFlags.py_type(eglDestroySurface), 0)
def AddEglDestroySurface(builder, eglDestroySurface):
CommandAddEglDestroySurface(builder, eglDestroySurface)
def CommandAddEglMakeCurrent(builder, eglMakeCurrent):
builder.PrependUOffsetTRelativeSlot(37, flatbuffers.number_types.UOffsetTFlags.py_type(eglMakeCurrent), 0)
def AddEglMakeCurrent(builder, eglMakeCurrent):
CommandAddEglMakeCurrent(builder, eglMakeCurrent)
def CommandAddEglSwapInterval(builder, eglSwapInterval):
builder.PrependUOffsetTRelativeSlot(38, flatbuffers.number_types.UOffsetTFlags.py_type(eglSwapInterval), 0)
def AddEglSwapInterval(builder, eglSwapInterval):
CommandAddEglSwapInterval(builder, eglSwapInterval)
def CommandAddEglResizeSurface(builder, eglResizeSurface):
builder.PrependUOffsetTRelativeSlot(39, flatbuffers.number_types.UOffsetTFlags.py_type(eglResizeSurface), 0)
def AddEglResizeSurface(builder, eglResizeSurface):
CommandAddEglResizeSurface(builder, eglResizeSurface)
def CommandAddClientWaitSync(builder, clientWaitSync):
builder.PrependUOffsetTRelativeSlot(40, flatbuffers.number_types.UOffsetTFlags.py_type(clientWaitSync), 0)
def AddClientWaitSync(builder, clientWaitSync):
CommandAddClientWaitSync(builder, clientWaitSync)
def CommandAddBeginTimeElapsedQuery(builder, beginTimeElapsedQuery):
builder.PrependUOffsetTRelativeSlot(41, flatbuffers.number_types.UOffsetTFlags.py_type(beginTimeElapsedQuery), 0)
def AddBeginTimeElapsedQuery(builder, beginTimeElapsedQuery):
CommandAddBeginTimeElapsedQuery(builder, beginTimeElapsedQuery)
def CommandAddEndTimeElapsedQuery(builder, endTimeElapsedQuery):
builder.PrependUOffsetTRelativeSlot(42, flatbuffers.number_types.UOffsetTFlags.py_type(endTimeElapsedQuery), 0)
def AddEndTimeElapsedQuery(builder, endTimeElapsedQuery):
CommandAddEndTimeElapsedQuery(builder, endTimeElapsedQuery)
def CommandAddDeleteBackendQuery(builder, deleteBackendQuery):
builder.PrependUOffsetTRelativeSlot(43, flatbuffers.number_types.UOffsetTFlags.py_type(deleteBackendQuery), 0)
def AddDeleteBackendQuery(builder, deleteBackendQuery):
CommandAddDeleteBackendQuery(builder, deleteBackendQuery)
def CommandAddIsQueryResultAvailable(builder, isQueryResultAvailable):
builder.PrependUOffsetTRelativeSlot(44, flatbuffers.number_types.UOffsetTFlags.py_type(isQueryResultAvailable), 0)
def AddIsQueryResultAvailable(builder, isQueryResultAvailable):
CommandAddIsQueryResultAvailable(builder, isQueryResultAvailable)
def CommandAddGetQueryResult64(builder, getQueryResult64):
builder.PrependUOffsetTRelativeSlot(45, flatbuffers.number_types.UOffsetTFlags.py_type(getQueryResult64), 0)
def AddGetQueryResult64(builder, getQueryResult64):
CommandAddGetQueryResult64(builder, getQueryResult64)
def CommandAddBeginOcclusionQuery(builder, beginOcclusionQuery):
builder.PrependUOffsetTRelativeSlot(46, flatbuffers.number_types.UOffsetTFlags.py_type(beginOcclusionQuery), 0)
def AddBeginOcclusionQuery(builder, beginOcclusionQuery):
CommandAddBeginOcclusionQuery(builder, beginOcclusionQuery)
def CommandAddEndOcclusionQuery(builder, endOcclusionQuery):
builder.PrependUOffsetTRelativeSlot(47, flatbuffers.number_types.UOffsetTFlags.py_type(endOcclusionQuery), 0)
def AddEndOcclusionQuery(builder, endOcclusionQuery):
CommandAddEndOcclusionQuery(builder, endOcclusionQuery)
def CommandAddBeginXfbPrimitivesQuery(builder, beginXfbPrimitivesQuery):
builder.PrependUOffsetTRelativeSlot(48, flatbuffers.number_types.UOffsetTFlags.py_type(beginXfbPrimitivesQuery), 0)
def AddBeginXfbPrimitivesQuery(builder, beginXfbPrimitivesQuery):
CommandAddBeginXfbPrimitivesQuery(builder, beginXfbPrimitivesQuery)
def CommandAddEndXfbPrimitivesQuery(builder, endXfbPrimitivesQuery):
builder.PrependUOffsetTRelativeSlot(49, flatbuffers.number_types.UOffsetTFlags.py_type(endXfbPrimitivesQuery), 0)
def AddEndXfbPrimitivesQuery(builder, endXfbPrimitivesQuery):
CommandAddEndXfbPrimitivesQuery(builder, endXfbPrimitivesQuery)
def CommandEnd(builder):
return builder.EndObject()
def End(builder):
return CommandEnd(builder)
@@ -0,0 +1,63 @@
# automatically generated by the FlatBuffers compiler, do not modify
# namespace: Wire
import flatbuffers
from flatbuffers.compat import import_numpy
np = import_numpy()
class DataBlob(object):
__slots__ = ['_tab']
@classmethod
def GetRootAs(cls, buf, offset=0):
n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
x = DataBlob()
x.Init(buf, n + offset)
return x
@classmethod
def GetRootAsDataBlob(cls, buf, offset=0):
"""This method is deprecated. Please switch to GetRootAs."""
return cls.GetRootAs(buf, offset)
# DataBlob
def Init(self, buf, pos):
self._tab = flatbuffers.table.Table(buf, pos)
# DataBlob
def Offset(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
return 0
# DataBlob
def Size(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
return 0
def DataBlobStart(builder):
builder.StartObject(2)
def Start(builder):
DataBlobStart(builder)
def DataBlobAddOffset(builder, offset):
builder.PrependUint64Slot(0, offset, 0)
def AddOffset(builder, offset):
DataBlobAddOffset(builder, offset)
def DataBlobAddSize(builder, size):
builder.PrependUint64Slot(1, size, 0)
def AddSize(builder, size):
DataBlobAddSize(builder, size)
def DataBlobEnd(builder):
return builder.EndObject()
def End(builder):
return DataBlobEnd(builder)
@@ -0,0 +1,50 @@
# automatically generated by the FlatBuffers compiler, do not modify
# namespace: Wire
import flatbuffers
from flatbuffers.compat import import_numpy
np = import_numpy()
class DeleteBackendQuery(object):
__slots__ = ['_tab']
@classmethod
def GetRootAs(cls, buf, offset=0):
n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
x = DeleteBackendQuery()
x.Init(buf, n + offset)
return x
@classmethod
def GetRootAsDeleteBackendQuery(cls, buf, offset=0):
"""This method is deprecated. Please switch to GetRootAs."""
return cls.GetRootAs(buf, offset)
# DeleteBackendQuery
def Init(self, buf, pos):
self._tab = flatbuffers.table.Table(buf, pos)
# DeleteBackendQuery
def Query(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
return 0
def DeleteBackendQueryStart(builder):
builder.StartObject(1)
def Start(builder):
DeleteBackendQueryStart(builder)
def DeleteBackendQueryAddQuery(builder, query):
builder.PrependUint64Slot(0, query, 0)
def AddQuery(builder, query):
DeleteBackendQueryAddQuery(builder, query)
def DeleteBackendQueryEnd(builder):
return builder.EndObject()
def End(builder):
return DeleteBackendQueryEnd(builder)
@@ -0,0 +1,50 @@
# automatically generated by the FlatBuffers compiler, do not modify
# namespace: Wire
import flatbuffers
from flatbuffers.compat import import_numpy
np = import_numpy()
class DeleteSync(object):
__slots__ = ['_tab']
@classmethod
def GetRootAs(cls, buf, offset=0):
n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
x = DeleteSync()
x.Init(buf, n + offset)
return x
@classmethod
def GetRootAsDeleteSync(cls, buf, offset=0):
"""This method is deprecated. Please switch to GetRootAs."""
return cls.GetRootAs(buf, offset)
# DeleteSync
def Init(self, buf, pos):
self._tab = flatbuffers.table.Table(buf, pos)
# DeleteSync
def Sync(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
return 0
def DeleteSyncStart(builder):
builder.StartObject(1)
def Start(builder):
DeleteSyncStart(builder)
def DeleteSyncAddSync(builder, sync):
builder.PrependUint64Slot(0, sync, 0)
def AddSync(builder, sync):
DeleteSyncAddSync(builder, sync)
def DeleteSyncEnd(builder):
return builder.EndObject()
def End(builder):
return DeleteSyncEnd(builder)
@@ -0,0 +1,76 @@
# automatically generated by the FlatBuffers compiler, do not modify
# namespace: Wire
import flatbuffers
from flatbuffers.compat import import_numpy
np = import_numpy()
class DispatchCompute(object):
__slots__ = ['_tab']
@classmethod
def GetRootAs(cls, buf, offset=0):
n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
x = DispatchCompute()
x.Init(buf, n + offset)
return x
@classmethod
def GetRootAsDispatchCompute(cls, buf, offset=0):
"""This method is deprecated. Please switch to GetRootAs."""
return cls.GetRootAs(buf, offset)
# DispatchCompute
def Init(self, buf, pos):
self._tab = flatbuffers.table.Table(buf, pos)
# DispatchCompute
def NumGroupsX(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos)
return 0
# DispatchCompute
def NumGroupsY(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos)
return 0
# DispatchCompute
def NumGroupsZ(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos)
return 0
def DispatchComputeStart(builder):
builder.StartObject(3)
def Start(builder):
DispatchComputeStart(builder)
def DispatchComputeAddNumGroupsX(builder, numGroupsX):
builder.PrependUint32Slot(0, numGroupsX, 0)
def AddNumGroupsX(builder, numGroupsX):
DispatchComputeAddNumGroupsX(builder, numGroupsX)
def DispatchComputeAddNumGroupsY(builder, numGroupsY):
builder.PrependUint32Slot(1, numGroupsY, 0)
def AddNumGroupsY(builder, numGroupsY):
DispatchComputeAddNumGroupsY(builder, numGroupsY)
def DispatchComputeAddNumGroupsZ(builder, numGroupsZ):
builder.PrependUint32Slot(2, numGroupsZ, 0)
def AddNumGroupsZ(builder, numGroupsZ):
DispatchComputeAddNumGroupsZ(builder, numGroupsZ)
def DispatchComputeEnd(builder):
return builder.EndObject()
def End(builder):
return DispatchComputeEnd(builder)
@@ -0,0 +1,50 @@
# automatically generated by the FlatBuffers compiler, do not modify
# namespace: Wire
import flatbuffers
from flatbuffers.compat import import_numpy
np = import_numpy()
class DispatchComputeIndirect(object):
__slots__ = ['_tab']
@classmethod
def GetRootAs(cls, buf, offset=0):
n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
x = DispatchComputeIndirect()
x.Init(buf, n + offset)
return x
@classmethod
def GetRootAsDispatchComputeIndirect(cls, buf, offset=0):
"""This method is deprecated. Please switch to GetRootAs."""
return cls.GetRootAs(buf, offset)
# DispatchComputeIndirect
def Init(self, buf, pos):
self._tab = flatbuffers.table.Table(buf, pos)
# DispatchComputeIndirect
def IndirectOffset(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
return 0
def DispatchComputeIndirectStart(builder):
builder.StartObject(1)
def Start(builder):
DispatchComputeIndirectStart(builder)
def DispatchComputeIndirectAddIndirectOffset(builder, indirectOffset):
builder.PrependUint64Slot(0, indirectOffset, 0)
def AddIndirectOffset(builder, indirectOffset):
DispatchComputeIndirectAddIndirectOffset(builder, indirectOffset)
def DispatchComputeIndirectEnd(builder):
return builder.EndObject()
def End(builder):
return DispatchComputeIndirectEnd(builder)
@@ -0,0 +1,76 @@
# automatically generated by the FlatBuffers compiler, do not modify
# namespace: Wire
import flatbuffers
from flatbuffers.compat import import_numpy
np = import_numpy()
class DrawArrays(object):
__slots__ = ['_tab']
@classmethod
def GetRootAs(cls, buf, offset=0):
n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
x = DrawArrays()
x.Init(buf, n + offset)
return x
@classmethod
def GetRootAsDrawArrays(cls, buf, offset=0):
"""This method is deprecated. Please switch to GetRootAs."""
return cls.GetRootAs(buf, offset)
# DrawArrays
def Init(self, buf, pos):
self._tab = flatbuffers.table.Table(buf, pos)
# DrawArrays
def Mode(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos)
return 0
# DrawArrays
def First(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos)
return 0
# DrawArrays
def Count(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos)
return 0
def DrawArraysStart(builder):
builder.StartObject(3)
def Start(builder):
DrawArraysStart(builder)
def DrawArraysAddMode(builder, mode):
builder.PrependUint32Slot(0, mode, 0)
def AddMode(builder, mode):
DrawArraysAddMode(builder, mode)
def DrawArraysAddFirst(builder, first):
builder.PrependInt32Slot(1, first, 0)
def AddFirst(builder, first):
DrawArraysAddFirst(builder, first)
def DrawArraysAddCount(builder, count):
builder.PrependInt32Slot(2, count, 0)
def AddCount(builder, count):
DrawArraysAddCount(builder, count)
def DrawArraysEnd(builder):
return builder.EndObject()
def End(builder):
return DrawArraysEnd(builder)
@@ -0,0 +1,63 @@
# automatically generated by the FlatBuffers compiler, do not modify
# namespace: Wire
import flatbuffers
from flatbuffers.compat import import_numpy
np = import_numpy()
class DrawArraysIndirect(object):
__slots__ = ['_tab']
@classmethod
def GetRootAs(cls, buf, offset=0):
n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
x = DrawArraysIndirect()
x.Init(buf, n + offset)
return x
@classmethod
def GetRootAsDrawArraysIndirect(cls, buf, offset=0):
"""This method is deprecated. Please switch to GetRootAs."""
return cls.GetRootAs(buf, offset)
# DrawArraysIndirect
def Init(self, buf, pos):
self._tab = flatbuffers.table.Table(buf, pos)
# DrawArraysIndirect
def Mode(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos)
return 0
# DrawArraysIndirect
def ShmOffset(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
return 0
def DrawArraysIndirectStart(builder):
builder.StartObject(2)
def Start(builder):
DrawArraysIndirectStart(builder)
def DrawArraysIndirectAddMode(builder, mode):
builder.PrependUint32Slot(0, mode, 0)
def AddMode(builder, mode):
DrawArraysIndirectAddMode(builder, mode)
def DrawArraysIndirectAddShmOffset(builder, shmOffset):
builder.PrependUint64Slot(1, shmOffset, 0)
def AddShmOffset(builder, shmOffset):
DrawArraysIndirectAddShmOffset(builder, shmOffset)
def DrawArraysIndirectEnd(builder):
return builder.EndObject()
def End(builder):
return DrawArraysIndirectEnd(builder)
@@ -0,0 +1,89 @@
# automatically generated by the FlatBuffers compiler, do not modify
# namespace: Wire
import flatbuffers
from flatbuffers.compat import import_numpy
np = import_numpy()
class DrawArraysInstanced(object):
__slots__ = ['_tab']
@classmethod
def GetRootAs(cls, buf, offset=0):
n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
x = DrawArraysInstanced()
x.Init(buf, n + offset)
return x
@classmethod
def GetRootAsDrawArraysInstanced(cls, buf, offset=0):
"""This method is deprecated. Please switch to GetRootAs."""
return cls.GetRootAs(buf, offset)
# DrawArraysInstanced
def Init(self, buf, pos):
self._tab = flatbuffers.table.Table(buf, pos)
# DrawArraysInstanced
def Mode(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos)
return 0
# DrawArraysInstanced
def First(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos)
return 0
# DrawArraysInstanced
def Count(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos)
return 0
# DrawArraysInstanced
def Primcount(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos)
return 0
def DrawArraysInstancedStart(builder):
builder.StartObject(4)
def Start(builder):
DrawArraysInstancedStart(builder)
def DrawArraysInstancedAddMode(builder, mode):
builder.PrependUint32Slot(0, mode, 0)
def AddMode(builder, mode):
DrawArraysInstancedAddMode(builder, mode)
def DrawArraysInstancedAddFirst(builder, first):
builder.PrependInt32Slot(1, first, 0)
def AddFirst(builder, first):
DrawArraysInstancedAddFirst(builder, first)
def DrawArraysInstancedAddCount(builder, count):
builder.PrependInt32Slot(2, count, 0)
def AddCount(builder, count):
DrawArraysInstancedAddCount(builder, count)
def DrawArraysInstancedAddPrimcount(builder, primcount):
builder.PrependInt32Slot(3, primcount, 0)
def AddPrimcount(builder, primcount):
DrawArraysInstancedAddPrimcount(builder, primcount)
def DrawArraysInstancedEnd(builder):
return builder.EndObject()
def End(builder):
return DrawArraysInstancedEnd(builder)
@@ -0,0 +1,89 @@
# automatically generated by the FlatBuffers compiler, do not modify
# namespace: Wire
import flatbuffers
from flatbuffers.compat import import_numpy
np = import_numpy()
class DrawElements(object):
__slots__ = ['_tab']
@classmethod
def GetRootAs(cls, buf, offset=0):
n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
x = DrawElements()
x.Init(buf, n + offset)
return x
@classmethod
def GetRootAsDrawElements(cls, buf, offset=0):
"""This method is deprecated. Please switch to GetRootAs."""
return cls.GetRootAs(buf, offset)
# DrawElements
def Init(self, buf, pos):
self._tab = flatbuffers.table.Table(buf, pos)
# DrawElements
def Mode(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos)
return 0
# DrawElements
def Count(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos)
return 0
# DrawElements
def Type(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos)
return 0
# DrawElements
def IndicesOffset(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
return 0
def DrawElementsStart(builder):
builder.StartObject(4)
def Start(builder):
DrawElementsStart(builder)
def DrawElementsAddMode(builder, mode):
builder.PrependUint32Slot(0, mode, 0)
def AddMode(builder, mode):
DrawElementsAddMode(builder, mode)
def DrawElementsAddCount(builder, count):
builder.PrependInt32Slot(1, count, 0)
def AddCount(builder, count):
DrawElementsAddCount(builder, count)
def DrawElementsAddType(builder, type):
builder.PrependUint32Slot(2, type, 0)
def AddType(builder, type):
DrawElementsAddType(builder, type)
def DrawElementsAddIndicesOffset(builder, indicesOffset):
builder.PrependUint64Slot(3, indicesOffset, 0)
def AddIndicesOffset(builder, indicesOffset):
DrawElementsAddIndicesOffset(builder, indicesOffset)
def DrawElementsEnd(builder):
return builder.EndObject()
def End(builder):
return DrawElementsEnd(builder)
@@ -0,0 +1,76 @@
# automatically generated by the FlatBuffers compiler, do not modify
# namespace: Wire
import flatbuffers
from flatbuffers.compat import import_numpy
np = import_numpy()
class DrawElementsIndirect(object):
__slots__ = ['_tab']
@classmethod
def GetRootAs(cls, buf, offset=0):
n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
x = DrawElementsIndirect()
x.Init(buf, n + offset)
return x
@classmethod
def GetRootAsDrawElementsIndirect(cls, buf, offset=0):
"""This method is deprecated. Please switch to GetRootAs."""
return cls.GetRootAs(buf, offset)
# DrawElementsIndirect
def Init(self, buf, pos):
self._tab = flatbuffers.table.Table(buf, pos)
# DrawElementsIndirect
def Mode(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos)
return 0
# DrawElementsIndirect
def Type(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos)
return 0
# DrawElementsIndirect
def ShmOffset(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
return 0
def DrawElementsIndirectStart(builder):
builder.StartObject(3)
def Start(builder):
DrawElementsIndirectStart(builder)
def DrawElementsIndirectAddMode(builder, mode):
builder.PrependUint32Slot(0, mode, 0)
def AddMode(builder, mode):
DrawElementsIndirectAddMode(builder, mode)
def DrawElementsIndirectAddType(builder, type):
builder.PrependUint32Slot(1, type, 0)
def AddType(builder, type):
DrawElementsIndirectAddType(builder, type)
def DrawElementsIndirectAddShmOffset(builder, shmOffset):
builder.PrependUint64Slot(2, shmOffset, 0)
def AddShmOffset(builder, shmOffset):
DrawElementsIndirectAddShmOffset(builder, shmOffset)
def DrawElementsIndirectEnd(builder):
return builder.EndObject()
def End(builder):
return DrawElementsIndirectEnd(builder)
@@ -0,0 +1,102 @@
# automatically generated by the FlatBuffers compiler, do not modify
# namespace: Wire
import flatbuffers
from flatbuffers.compat import import_numpy
np = import_numpy()
class DrawElementsInstanced(object):
__slots__ = ['_tab']
@classmethod
def GetRootAs(cls, buf, offset=0):
n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
x = DrawElementsInstanced()
x.Init(buf, n + offset)
return x
@classmethod
def GetRootAsDrawElementsInstanced(cls, buf, offset=0):
"""This method is deprecated. Please switch to GetRootAs."""
return cls.GetRootAs(buf, offset)
# DrawElementsInstanced
def Init(self, buf, pos):
self._tab = flatbuffers.table.Table(buf, pos)
# DrawElementsInstanced
def Mode(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos)
return 0
# DrawElementsInstanced
def Count(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos)
return 0
# DrawElementsInstanced
def Type(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos)
return 0
# DrawElementsInstanced
def IndicesOffset(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
return 0
# DrawElementsInstanced
def InstanceCount(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos)
return 0
def DrawElementsInstancedStart(builder):
builder.StartObject(5)
def Start(builder):
DrawElementsInstancedStart(builder)
def DrawElementsInstancedAddMode(builder, mode):
builder.PrependUint32Slot(0, mode, 0)
def AddMode(builder, mode):
DrawElementsInstancedAddMode(builder, mode)
def DrawElementsInstancedAddCount(builder, count):
builder.PrependInt32Slot(1, count, 0)
def AddCount(builder, count):
DrawElementsInstancedAddCount(builder, count)
def DrawElementsInstancedAddType(builder, type):
builder.PrependUint32Slot(2, type, 0)
def AddType(builder, type):
DrawElementsInstancedAddType(builder, type)
def DrawElementsInstancedAddIndicesOffset(builder, indicesOffset):
builder.PrependUint64Slot(3, indicesOffset, 0)
def AddIndicesOffset(builder, indicesOffset):
DrawElementsInstancedAddIndicesOffset(builder, indicesOffset)
def DrawElementsInstancedAddInstanceCount(builder, instanceCount):
builder.PrependInt32Slot(4, instanceCount, 0)
def AddInstanceCount(builder, instanceCount):
DrawElementsInstancedAddInstanceCount(builder, instanceCount)
def DrawElementsInstancedEnd(builder):
return builder.EndObject()
def End(builder):
return DrawElementsInstancedEnd(builder)
@@ -0,0 +1,115 @@
# automatically generated by the FlatBuffers compiler, do not modify
# namespace: Wire
import flatbuffers
from flatbuffers.compat import import_numpy
np = import_numpy()
class DrawRangeElements(object):
__slots__ = ['_tab']
@classmethod
def GetRootAs(cls, buf, offset=0):
n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
x = DrawRangeElements()
x.Init(buf, n + offset)
return x
@classmethod
def GetRootAsDrawRangeElements(cls, buf, offset=0):
"""This method is deprecated. Please switch to GetRootAs."""
return cls.GetRootAs(buf, offset)
# DrawRangeElements
def Init(self, buf, pos):
self._tab = flatbuffers.table.Table(buf, pos)
# DrawRangeElements
def Mode(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos)
return 0
# DrawRangeElements
def Start(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos)
return 0
# DrawRangeElements
def End(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos)
return 0
# DrawRangeElements
def Count(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos)
return 0
# DrawRangeElements
def Type(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos)
return 0
# DrawRangeElements
def IndicesOffset(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
return 0
def DrawRangeElementsStart(builder):
builder.StartObject(6)
def Start(builder):
DrawRangeElementsStart(builder)
def DrawRangeElementsAddMode(builder, mode):
builder.PrependUint32Slot(0, mode, 0)
def AddMode(builder, mode):
DrawRangeElementsAddMode(builder, mode)
def DrawRangeElementsAddStart(builder, start):
builder.PrependUint32Slot(1, start, 0)
def AddStart(builder, start):
DrawRangeElementsAddStart(builder, start)
def DrawRangeElementsAddEnd(builder, end):
builder.PrependUint32Slot(2, end, 0)
def AddEnd(builder, end):
DrawRangeElementsAddEnd(builder, end)
def DrawRangeElementsAddCount(builder, count):
builder.PrependInt32Slot(3, count, 0)
def AddCount(builder, count):
DrawRangeElementsAddCount(builder, count)
def DrawRangeElementsAddType(builder, type):
builder.PrependUint32Slot(4, type, 0)
def AddType(builder, type):
DrawRangeElementsAddType(builder, type)
def DrawRangeElementsAddIndicesOffset(builder, indicesOffset):
builder.PrependUint64Slot(5, indicesOffset, 0)
def AddIndicesOffset(builder, indicesOffset):
DrawRangeElementsAddIndicesOffset(builder, indicesOffset)
def DrawRangeElementsEnd(builder):
return builder.EndObject()
def End(builder):
return DrawRangeElementsEnd(builder)
@@ -0,0 +1,89 @@
# automatically generated by the FlatBuffers compiler, do not modify
# namespace: Wire
import flatbuffers
from flatbuffers.compat import import_numpy
np = import_numpy()
class EglCreatePbufferSurface(object):
__slots__ = ['_tab']
@classmethod
def GetRootAs(cls, buf, offset=0):
n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
x = EglCreatePbufferSurface()
x.Init(buf, n + offset)
return x
@classmethod
def GetRootAsEglCreatePbufferSurface(cls, buf, offset=0):
"""This method is deprecated. Please switch to GetRootAs."""
return cls.GetRootAs(buf, offset)
# EglCreatePbufferSurface
def Init(self, buf, pos):
self._tab = flatbuffers.table.Table(buf, pos)
# EglCreatePbufferSurface
def Display(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
return 0
# EglCreatePbufferSurface
def Surface(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
return 0
# EglCreatePbufferSurface
def Width(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos)
return 0
# EglCreatePbufferSurface
def Height(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos)
return 0
def EglCreatePbufferSurfaceStart(builder):
builder.StartObject(4)
def Start(builder):
EglCreatePbufferSurfaceStart(builder)
def EglCreatePbufferSurfaceAddDisplay(builder, display):
builder.PrependUint64Slot(0, display, 0)
def AddDisplay(builder, display):
EglCreatePbufferSurfaceAddDisplay(builder, display)
def EglCreatePbufferSurfaceAddSurface(builder, surface):
builder.PrependUint64Slot(1, surface, 0)
def AddSurface(builder, surface):
EglCreatePbufferSurfaceAddSurface(builder, surface)
def EglCreatePbufferSurfaceAddWidth(builder, width):
builder.PrependInt32Slot(2, width, 0)
def AddWidth(builder, width):
EglCreatePbufferSurfaceAddWidth(builder, width)
def EglCreatePbufferSurfaceAddHeight(builder, height):
builder.PrependInt32Slot(3, height, 0)
def AddHeight(builder, height):
EglCreatePbufferSurfaceAddHeight(builder, height)
def EglCreatePbufferSurfaceEnd(builder):
return builder.EndObject()
def End(builder):
return EglCreatePbufferSurfaceEnd(builder)
@@ -0,0 +1,63 @@
# automatically generated by the FlatBuffers compiler, do not modify
# namespace: Wire
import flatbuffers
from flatbuffers.compat import import_numpy
np = import_numpy()
class EglDestroySurface(object):
__slots__ = ['_tab']
@classmethod
def GetRootAs(cls, buf, offset=0):
n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
x = EglDestroySurface()
x.Init(buf, n + offset)
return x
@classmethod
def GetRootAsEglDestroySurface(cls, buf, offset=0):
"""This method is deprecated. Please switch to GetRootAs."""
return cls.GetRootAs(buf, offset)
# EglDestroySurface
def Init(self, buf, pos):
self._tab = flatbuffers.table.Table(buf, pos)
# EglDestroySurface
def Display(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
return 0
# EglDestroySurface
def Surface(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
return 0
def EglDestroySurfaceStart(builder):
builder.StartObject(2)
def Start(builder):
EglDestroySurfaceStart(builder)
def EglDestroySurfaceAddDisplay(builder, display):
builder.PrependUint64Slot(0, display, 0)
def AddDisplay(builder, display):
EglDestroySurfaceAddDisplay(builder, display)
def EglDestroySurfaceAddSurface(builder, surface):
builder.PrependUint64Slot(1, surface, 0)
def AddSurface(builder, surface):
EglDestroySurfaceAddSurface(builder, surface)
def EglDestroySurfaceEnd(builder):
return builder.EndObject()
def End(builder):
return EglDestroySurfaceEnd(builder)
@@ -0,0 +1,76 @@
# automatically generated by the FlatBuffers compiler, do not modify
# namespace: Wire
import flatbuffers
from flatbuffers.compat import import_numpy
np = import_numpy()
class EglMakeCurrent(object):
__slots__ = ['_tab']
@classmethod
def GetRootAs(cls, buf, offset=0):
n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
x = EglMakeCurrent()
x.Init(buf, n + offset)
return x
@classmethod
def GetRootAsEglMakeCurrent(cls, buf, offset=0):
"""This method is deprecated. Please switch to GetRootAs."""
return cls.GetRootAs(buf, offset)
# EglMakeCurrent
def Init(self, buf, pos):
self._tab = flatbuffers.table.Table(buf, pos)
# EglMakeCurrent
def Session(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
return 0
# EglMakeCurrent
def Draw(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
return 0
# EglMakeCurrent
def Read(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
return 0
def EglMakeCurrentStart(builder):
builder.StartObject(3)
def Start(builder):
EglMakeCurrentStart(builder)
def EglMakeCurrentAddSession(builder, session):
builder.PrependUint64Slot(0, session, 0)
def AddSession(builder, session):
EglMakeCurrentAddSession(builder, session)
def EglMakeCurrentAddDraw(builder, draw):
builder.PrependUint64Slot(1, draw, 0)
def AddDraw(builder, draw):
EglMakeCurrentAddDraw(builder, draw)
def EglMakeCurrentAddRead(builder, read):
builder.PrependUint64Slot(2, read, 0)
def AddRead(builder, read):
EglMakeCurrentAddRead(builder, read)
def EglMakeCurrentEnd(builder):
return builder.EndObject()
def End(builder):
return EglMakeCurrentEnd(builder)
@@ -0,0 +1,89 @@
# automatically generated by the FlatBuffers compiler, do not modify
# namespace: Wire
import flatbuffers
from flatbuffers.compat import import_numpy
np = import_numpy()
class EglResizeSurface(object):
__slots__ = ['_tab']
@classmethod
def GetRootAs(cls, buf, offset=0):
n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
x = EglResizeSurface()
x.Init(buf, n + offset)
return x
@classmethod
def GetRootAsEglResizeSurface(cls, buf, offset=0):
"""This method is deprecated. Please switch to GetRootAs."""
return cls.GetRootAs(buf, offset)
# EglResizeSurface
def Init(self, buf, pos):
self._tab = flatbuffers.table.Table(buf, pos)
# EglResizeSurface
def Display(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
return 0
# EglResizeSurface
def Surface(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
return 0
# EglResizeSurface
def Width(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos)
return 0
# EglResizeSurface
def Height(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos)
return 0
def EglResizeSurfaceStart(builder):
builder.StartObject(4)
def Start(builder):
EglResizeSurfaceStart(builder)
def EglResizeSurfaceAddDisplay(builder, display):
builder.PrependUint64Slot(0, display, 0)
def AddDisplay(builder, display):
EglResizeSurfaceAddDisplay(builder, display)
def EglResizeSurfaceAddSurface(builder, surface):
builder.PrependUint64Slot(1, surface, 0)
def AddSurface(builder, surface):
EglResizeSurfaceAddSurface(builder, surface)
def EglResizeSurfaceAddWidth(builder, width):
builder.PrependUint32Slot(2, width, 0)
def AddWidth(builder, width):
EglResizeSurfaceAddWidth(builder, width)
def EglResizeSurfaceAddHeight(builder, height):
builder.PrependUint32Slot(3, height, 0)
def AddHeight(builder, height):
EglResizeSurfaceAddHeight(builder, height)
def EglResizeSurfaceEnd(builder):
return builder.EndObject()
def End(builder):
return EglResizeSurfaceEnd(builder)
@@ -0,0 +1,50 @@
# automatically generated by the FlatBuffers compiler, do not modify
# namespace: Wire
import flatbuffers
from flatbuffers.compat import import_numpy
np = import_numpy()
class EglSwapInterval(object):
__slots__ = ['_tab']
@classmethod
def GetRootAs(cls, buf, offset=0):
n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
x = EglSwapInterval()
x.Init(buf, n + offset)
return x
@classmethod
def GetRootAsEglSwapInterval(cls, buf, offset=0):
"""This method is deprecated. Please switch to GetRootAs."""
return cls.GetRootAs(buf, offset)
# EglSwapInterval
def Init(self, buf, pos):
self._tab = flatbuffers.table.Table(buf, pos)
# EglSwapInterval
def Interval(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos)
return 0
def EglSwapIntervalStart(builder):
builder.StartObject(1)
def Start(builder):
EglSwapIntervalStart(builder)
def EglSwapIntervalAddInterval(builder, interval):
builder.PrependInt32Slot(0, interval, 0)
def AddInterval(builder, interval):
EglSwapIntervalAddInterval(builder, interval)
def EglSwapIntervalEnd(builder):
return builder.EndObject()
def End(builder):
return EglSwapIntervalEnd(builder)
@@ -0,0 +1,50 @@
# automatically generated by the FlatBuffers compiler, do not modify
# namespace: Wire
import flatbuffers
from flatbuffers.compat import import_numpy
np = import_numpy()
class EndOcclusionQuery(object):
__slots__ = ['_tab']
@classmethod
def GetRootAs(cls, buf, offset=0):
n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
x = EndOcclusionQuery()
x.Init(buf, n + offset)
return x
@classmethod
def GetRootAsEndOcclusionQuery(cls, buf, offset=0):
"""This method is deprecated. Please switch to GetRootAs."""
return cls.GetRootAs(buf, offset)
# EndOcclusionQuery
def Init(self, buf, pos):
self._tab = flatbuffers.table.Table(buf, pos)
# EndOcclusionQuery
def Query(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
return 0
def EndOcclusionQueryStart(builder):
builder.StartObject(1)
def Start(builder):
EndOcclusionQueryStart(builder)
def EndOcclusionQueryAddQuery(builder, query):
builder.PrependUint64Slot(0, query, 0)
def AddQuery(builder, query):
EndOcclusionQueryAddQuery(builder, query)
def EndOcclusionQueryEnd(builder):
return builder.EndObject()
def End(builder):
return EndOcclusionQueryEnd(builder)
@@ -0,0 +1,50 @@
# automatically generated by the FlatBuffers compiler, do not modify
# namespace: Wire
import flatbuffers
from flatbuffers.compat import import_numpy
np = import_numpy()
class EndTimeElapsedQuery(object):
__slots__ = ['_tab']
@classmethod
def GetRootAs(cls, buf, offset=0):
n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
x = EndTimeElapsedQuery()
x.Init(buf, n + offset)
return x
@classmethod
def GetRootAsEndTimeElapsedQuery(cls, buf, offset=0):
"""This method is deprecated. Please switch to GetRootAs."""
return cls.GetRootAs(buf, offset)
# EndTimeElapsedQuery
def Init(self, buf, pos):
self._tab = flatbuffers.table.Table(buf, pos)
# EndTimeElapsedQuery
def Query(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
return 0
def EndTimeElapsedQueryStart(builder):
builder.StartObject(1)
def Start(builder):
EndTimeElapsedQueryStart(builder)
def EndTimeElapsedQueryAddQuery(builder, query):
builder.PrependUint64Slot(0, query, 0)
def AddQuery(builder, query):
EndTimeElapsedQueryAddQuery(builder, query)
def EndTimeElapsedQueryEnd(builder):
return builder.EndObject()
def End(builder):
return EndTimeElapsedQueryEnd(builder)
@@ -0,0 +1,50 @@
# automatically generated by the FlatBuffers compiler, do not modify
# namespace: Wire
import flatbuffers
from flatbuffers.compat import import_numpy
np = import_numpy()
class EndXfbPrimitivesQuery(object):
__slots__ = ['_tab']
@classmethod
def GetRootAs(cls, buf, offset=0):
n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
x = EndXfbPrimitivesQuery()
x.Init(buf, n + offset)
return x
@classmethod
def GetRootAsEndXfbPrimitivesQuery(cls, buf, offset=0):
"""This method is deprecated. Please switch to GetRootAs."""
return cls.GetRootAs(buf, offset)
# EndXfbPrimitivesQuery
def Init(self, buf, pos):
self._tab = flatbuffers.table.Table(buf, pos)
# EndXfbPrimitivesQuery
def Query(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
return 0
def EndXfbPrimitivesQueryStart(builder):
builder.StartObject(1)
def Start(builder):
EndXfbPrimitivesQueryStart(builder)
def EndXfbPrimitivesQueryAddQuery(builder, query):
builder.PrependUint64Slot(0, query, 0)
def AddQuery(builder, query):
EndXfbPrimitivesQueryAddQuery(builder, query)
def EndXfbPrimitivesQueryEnd(builder):
return builder.EndObject()
def End(builder):
return EndXfbPrimitivesQueryEnd(builder)
@@ -0,0 +1,63 @@
# automatically generated by the FlatBuffers compiler, do not modify
# namespace: Wire
import flatbuffers
from flatbuffers.compat import import_numpy
np = import_numpy()
class FenceSync(object):
__slots__ = ['_tab']
@classmethod
def GetRootAs(cls, buf, offset=0):
n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
x = FenceSync()
x.Init(buf, n + offset)
return x
@classmethod
def GetRootAsFenceSync(cls, buf, offset=0):
"""This method is deprecated. Please switch to GetRootAs."""
return cls.GetRootAs(buf, offset)
# FenceSync
def Init(self, buf, pos):
self._tab = flatbuffers.table.Table(buf, pos)
# FenceSync
def Condition(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos)
return 0
# FenceSync
def Flags(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos)
return 0
def FenceSyncStart(builder):
builder.StartObject(2)
def Start(builder):
FenceSyncStart(builder)
def FenceSyncAddCondition(builder, condition):
builder.PrependUint32Slot(0, condition, 0)
def AddCondition(builder, condition):
FenceSyncAddCondition(builder, condition)
def FenceSyncAddFlags(builder, flags):
builder.PrependUint32Slot(1, flags, 0)
def AddFlags(builder, flags):
FenceSyncAddFlags(builder, flags)
def FenceSyncEnd(builder):
return builder.EndObject()
def End(builder):
return FenceSyncEnd(builder)
@@ -0,0 +1,50 @@
# automatically generated by the FlatBuffers compiler, do not modify
# namespace: Wire
import flatbuffers
from flatbuffers.compat import import_numpy
np = import_numpy()
class GenerateMipmap(object):
__slots__ = ['_tab']
@classmethod
def GetRootAs(cls, buf, offset=0):
n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
x = GenerateMipmap()
x.Init(buf, n + offset)
return x
@classmethod
def GetRootAsGenerateMipmap(cls, buf, offset=0):
"""This method is deprecated. Please switch to GetRootAs."""
return cls.GetRootAs(buf, offset)
# GenerateMipmap
def Init(self, buf, pos):
self._tab = flatbuffers.table.Table(buf, pos)
# GenerateMipmap
def Target(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos)
return 0
def GenerateMipmapStart(builder):
builder.StartObject(1)
def Start(builder):
GenerateMipmapStart(builder)
def GenerateMipmapAddTarget(builder, target):
builder.PrependUint32Slot(0, target, 0)
def AddTarget(builder, target):
GenerateMipmapAddTarget(builder, target)
def GenerateMipmapEnd(builder):
return builder.EndObject()
def End(builder):
return GenerateMipmapEnd(builder)
@@ -0,0 +1,63 @@
# automatically generated by the FlatBuffers compiler, do not modify
# namespace: Wire
import flatbuffers
from flatbuffers.compat import import_numpy
np = import_numpy()
class GetQueryResult64(object):
__slots__ = ['_tab']
@classmethod
def GetRootAs(cls, buf, offset=0):
n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
x = GetQueryResult64()
x.Init(buf, n + offset)
return x
@classmethod
def GetRootAsGetQueryResult64(cls, buf, offset=0):
"""This method is deprecated. Please switch to GetRootAs."""
return cls.GetRootAs(buf, offset)
# GetQueryResult64
def Init(self, buf, pos):
self._tab = flatbuffers.table.Table(buf, pos)
# GetQueryResult64
def Query(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
return 0
# GetQueryResult64
def Wait(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos)
return 0
def GetQueryResult64Start(builder):
builder.StartObject(2)
def Start(builder):
GetQueryResult64Start(builder)
def GetQueryResult64AddQuery(builder, query):
builder.PrependUint64Slot(0, query, 0)
def AddQuery(builder, query):
GetQueryResult64AddQuery(builder, query)
def GetQueryResult64AddWait(builder, wait):
builder.PrependUint32Slot(1, wait, 0)
def AddWait(builder, wait):
GetQueryResult64AddWait(builder, wait)
def GetQueryResult64End(builder):
return builder.EndObject()
def End(builder):
return GetQueryResult64End(builder)
@@ -0,0 +1,50 @@
# automatically generated by the FlatBuffers compiler, do not modify
# namespace: Wire
import flatbuffers
from flatbuffers.compat import import_numpy
np = import_numpy()
class GetString(object):
__slots__ = ['_tab']
@classmethod
def GetRootAs(cls, buf, offset=0):
n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
x = GetString()
x.Init(buf, n + offset)
return x
@classmethod
def GetRootAsGetString(cls, buf, offset=0):
"""This method is deprecated. Please switch to GetRootAs."""
return cls.GetRootAs(buf, offset)
# GetString
def Init(self, buf, pos):
self._tab = flatbuffers.table.Table(buf, pos)
# GetString
def Pname(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos)
return 0
def GetStringStart(builder):
builder.StartObject(1)
def Start(builder):
GetStringStart(builder)
def GetStringAddPname(builder, pname):
builder.PrependUint32Slot(0, pname, 0)
def AddPname(builder, pname):
GetStringAddPname(builder, pname)
def GetStringEnd(builder):
return builder.EndObject()
def End(builder):
return GetStringEnd(builder)
@@ -0,0 +1,50 @@
# automatically generated by the FlatBuffers compiler, do not modify
# namespace: Wire
import flatbuffers
from flatbuffers.compat import import_numpy
np = import_numpy()
class GlClear(object):
__slots__ = ['_tab']
@classmethod
def GetRootAs(cls, buf, offset=0):
n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
x = GlClear()
x.Init(buf, n + offset)
return x
@classmethod
def GetRootAsGlClear(cls, buf, offset=0):
"""This method is deprecated. Please switch to GetRootAs."""
return cls.GetRootAs(buf, offset)
# GlClear
def Init(self, buf, pos):
self._tab = flatbuffers.table.Table(buf, pos)
# GlClear
def Mask(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos)
return 0
def GlClearStart(builder):
builder.StartObject(1)
def Start(builder):
GlClearStart(builder)
def GlClearAddMask(builder, mask):
builder.PrependUint32Slot(0, mask, 0)
def AddMask(builder, mask):
GlClearAddMask(builder, mask)
def GlClearEnd(builder):
return builder.EndObject()
def End(builder):
return GlClearEnd(builder)
@@ -0,0 +1,50 @@
# automatically generated by the FlatBuffers compiler, do not modify
# namespace: Wire
import flatbuffers
from flatbuffers.compat import import_numpy
np = import_numpy()
class IsQueryResultAvailable(object):
__slots__ = ['_tab']
@classmethod
def GetRootAs(cls, buf, offset=0):
n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
x = IsQueryResultAvailable()
x.Init(buf, n + offset)
return x
@classmethod
def GetRootAsIsQueryResultAvailable(cls, buf, offset=0):
"""This method is deprecated. Please switch to GetRootAs."""
return cls.GetRootAs(buf, offset)
# IsQueryResultAvailable
def Init(self, buf, pos):
self._tab = flatbuffers.table.Table(buf, pos)
# IsQueryResultAvailable
def Query(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
return 0
def IsQueryResultAvailableStart(builder):
builder.StartObject(1)
def Start(builder):
IsQueryResultAvailableStart(builder)
def IsQueryResultAvailableAddQuery(builder, query):
builder.PrependUint64Slot(0, query, 0)
def AddQuery(builder, query):
IsQueryResultAvailableAddQuery(builder, query)
def IsQueryResultAvailableEnd(builder):
return builder.EndObject()
def End(builder):
return IsQueryResultAvailableEnd(builder)
@@ -0,0 +1,89 @@
# automatically generated by the FlatBuffers compiler, do not modify
# namespace: Wire
import flatbuffers
from flatbuffers.compat import import_numpy
np = import_numpy()
class MapBufferRange(object):
__slots__ = ['_tab']
@classmethod
def GetRootAs(cls, buf, offset=0):
n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
x = MapBufferRange()
x.Init(buf, n + offset)
return x
@classmethod
def GetRootAsMapBufferRange(cls, buf, offset=0):
"""This method is deprecated. Please switch to GetRootAs."""
return cls.GetRootAs(buf, offset)
# MapBufferRange
def Init(self, buf, pos):
self._tab = flatbuffers.table.Table(buf, pos)
# MapBufferRange
def BufferHandle(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
return 0
# MapBufferRange
def Offset(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
return 0
# MapBufferRange
def Size(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
return 0
# MapBufferRange
def Access(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos)
return 0
def MapBufferRangeStart(builder):
builder.StartObject(4)
def Start(builder):
MapBufferRangeStart(builder)
def MapBufferRangeAddBufferHandle(builder, bufferHandle):
builder.PrependUint64Slot(0, bufferHandle, 0)
def AddBufferHandle(builder, bufferHandle):
MapBufferRangeAddBufferHandle(builder, bufferHandle)
def MapBufferRangeAddOffset(builder, offset):
builder.PrependUint64Slot(1, offset, 0)
def AddOffset(builder, offset):
MapBufferRangeAddOffset(builder, offset)
def MapBufferRangeAddSize(builder, size):
builder.PrependUint64Slot(2, size, 0)
def AddSize(builder, size):
MapBufferRangeAddSize(builder, size)
def MapBufferRangeAddAccess(builder, access):
builder.PrependUint32Slot(3, access, 0)
def AddAccess(builder, access):
MapBufferRangeAddAccess(builder, access)
def MapBufferRangeEnd(builder):
return builder.EndObject()
def End(builder):
return MapBufferRangeEnd(builder)
@@ -0,0 +1,50 @@
# automatically generated by the FlatBuffers compiler, do not modify
# namespace: Wire
import flatbuffers
from flatbuffers.compat import import_numpy
np = import_numpy()
class MemoryBarrier(object):
__slots__ = ['_tab']
@classmethod
def GetRootAs(cls, buf, offset=0):
n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
x = MemoryBarrier()
x.Init(buf, n + offset)
return x
@classmethod
def GetRootAsMemoryBarrier(cls, buf, offset=0):
"""This method is deprecated. Please switch to GetRootAs."""
return cls.GetRootAs(buf, offset)
# MemoryBarrier
def Init(self, buf, pos):
self._tab = flatbuffers.table.Table(buf, pos)
# MemoryBarrier
def Barriers(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos)
return 0
def MemoryBarrierStart(builder):
builder.StartObject(1)
def Start(builder):
MemoryBarrierStart(builder)
def MemoryBarrierAddBarriers(builder, barriers):
builder.PrependUint32Slot(0, barriers, 0)
def AddBarriers(builder, barriers):
MemoryBarrierAddBarriers(builder, barriers)
def MemoryBarrierEnd(builder):
return builder.EndObject()
def End(builder):
return MemoryBarrierEnd(builder)
@@ -0,0 +1,50 @@
# automatically generated by the FlatBuffers compiler, do not modify
# namespace: Wire
import flatbuffers
from flatbuffers.compat import import_numpy
np = import_numpy()
class MemoryBarrierByRegion(object):
__slots__ = ['_tab']
@classmethod
def GetRootAs(cls, buf, offset=0):
n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
x = MemoryBarrierByRegion()
x.Init(buf, n + offset)
return x
@classmethod
def GetRootAsMemoryBarrierByRegion(cls, buf, offset=0):
"""This method is deprecated. Please switch to GetRootAs."""
return cls.GetRootAs(buf, offset)
# MemoryBarrierByRegion
def Init(self, buf, pos):
self._tab = flatbuffers.table.Table(buf, pos)
# MemoryBarrierByRegion
def Barriers(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos)
return 0
def MemoryBarrierByRegionStart(builder):
builder.StartObject(1)
def Start(builder):
MemoryBarrierByRegionStart(builder)
def MemoryBarrierByRegionAddBarriers(builder, barriers):
builder.PrependUint32Slot(0, barriers, 0)
def AddBarriers(builder, barriers):
MemoryBarrierByRegionAddBarriers(builder, barriers)
def MemoryBarrierByRegionEnd(builder):
return builder.EndObject()
def End(builder):
return MemoryBarrierByRegionEnd(builder)
@@ -0,0 +1,67 @@
# automatically generated by the FlatBuffers compiler, do not modify
# namespace: Wire
import flatbuffers
from flatbuffers.compat import import_numpy
np = import_numpy()
class Message(object):
__slots__ = ['_tab']
@classmethod
def GetRootAs(cls, buf, offset=0):
n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
x = Message()
x.Init(buf, n + offset)
return x
@classmethod
def GetRootAsMessage(cls, buf, offset=0):
"""This method is deprecated. Please switch to GetRootAs."""
return cls.GetRootAs(buf, offset)
# Message
def Init(self, buf, pos):
self._tab = flatbuffers.table.Table(buf, pos)
# Message
def Command(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
if o != 0:
x = self._tab.Indirect(o + self._tab.Pos)
from MobileGL.Protocol.Wire.Command import Command
obj = Command()
obj.Init(self._tab.Bytes, x)
return obj
return None
# Message
def ShmCount(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos)
return 0
def MessageStart(builder):
builder.StartObject(2)
def Start(builder):
MessageStart(builder)
def MessageAddCommand(builder, command):
builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(command), 0)
def AddCommand(builder, command):
MessageAddCommand(builder, command)
def MessageAddShmCount(builder, shmCount):
builder.PrependUint32Slot(1, shmCount, 0)
def AddShmCount(builder, shmCount):
MessageAddShmCount(builder, shmCount)
def MessageEnd(builder):
return builder.EndObject()
def End(builder):
return MessageEnd(builder)
@@ -0,0 +1,63 @@
# automatically generated by the FlatBuffers compiler, do not modify
# namespace: Wire
import flatbuffers
from flatbuffers.compat import import_numpy
np = import_numpy()
class PatchParameteri(object):
__slots__ = ['_tab']
@classmethod
def GetRootAs(cls, buf, offset=0):
n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
x = PatchParameteri()
x.Init(buf, n + offset)
return x
@classmethod
def GetRootAsPatchParameteri(cls, buf, offset=0):
"""This method is deprecated. Please switch to GetRootAs."""
return cls.GetRootAs(buf, offset)
# PatchParameteri
def Init(self, buf, pos):
self._tab = flatbuffers.table.Table(buf, pos)
# PatchParameteri
def Pname(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos)
return 0
# PatchParameteri
def Value(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos)
return 0
def PatchParameteriStart(builder):
builder.StartObject(2)
def Start(builder):
PatchParameteriStart(builder)
def PatchParameteriAddPname(builder, pname):
builder.PrependUint32Slot(0, pname, 0)
def AddPname(builder, pname):
PatchParameteriAddPname(builder, pname)
def PatchParameteriAddValue(builder, value):
builder.PrependInt32Slot(1, value, 0)
def AddValue(builder, value):
PatchParameteriAddValue(builder, value)
def PatchParameteriEnd(builder):
return builder.EndObject()
def End(builder):
return PatchParameteriEnd(builder)
@@ -0,0 +1,115 @@
# automatically generated by the FlatBuffers compiler, do not modify
# namespace: Wire
import flatbuffers
from flatbuffers.compat import import_numpy
np = import_numpy()
class ReadPixels(object):
__slots__ = ['_tab']
@classmethod
def GetRootAs(cls, buf, offset=0):
n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
x = ReadPixels()
x.Init(buf, n + offset)
return x
@classmethod
def GetRootAsReadPixels(cls, buf, offset=0):
"""This method is deprecated. Please switch to GetRootAs."""
return cls.GetRootAs(buf, offset)
# ReadPixels
def Init(self, buf, pos):
self._tab = flatbuffers.table.Table(buf, pos)
# ReadPixels
def X(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos)
return 0
# ReadPixels
def Y(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos)
return 0
# ReadPixels
def Width(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos)
return 0
# ReadPixels
def Height(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos)
return 0
# ReadPixels
def Format(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos)
return 0
# ReadPixels
def Type(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos)
return 0
def ReadPixelsStart(builder):
builder.StartObject(6)
def Start(builder):
ReadPixelsStart(builder)
def ReadPixelsAddX(builder, x):
builder.PrependInt32Slot(0, x, 0)
def AddX(builder, x):
ReadPixelsAddX(builder, x)
def ReadPixelsAddY(builder, y):
builder.PrependInt32Slot(1, y, 0)
def AddY(builder, y):
ReadPixelsAddY(builder, y)
def ReadPixelsAddWidth(builder, width):
builder.PrependInt32Slot(2, width, 0)
def AddWidth(builder, width):
ReadPixelsAddWidth(builder, width)
def ReadPixelsAddHeight(builder, height):
builder.PrependInt32Slot(3, height, 0)
def AddHeight(builder, height):
ReadPixelsAddHeight(builder, height)
def ReadPixelsAddFormat(builder, format):
builder.PrependUint32Slot(4, format, 0)
def AddFormat(builder, format):
ReadPixelsAddFormat(builder, format)
def ReadPixelsAddType(builder, type):
builder.PrependUint32Slot(5, type, 0)
def AddType(builder, type):
ReadPixelsAddType(builder, type)
def ReadPixelsEnd(builder):
return builder.EndObject()
def End(builder):
return ReadPixelsEnd(builder)
@@ -0,0 +1,128 @@
# automatically generated by the FlatBuffers compiler, do not modify
# namespace: Wire
import flatbuffers
from flatbuffers.compat import import_numpy
np = import_numpy()
class Response(object):
__slots__ = ['_tab']
@classmethod
def GetRootAs(cls, buf, offset=0):
n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
x = Response()
x.Init(buf, n + offset)
return x
@classmethod
def GetRootAsResponse(cls, buf, offset=0):
"""This method is deprecated. Please switch to GetRootAs."""
return cls.GetRootAs(buf, offset)
# Response
def Init(self, buf, pos):
self._tab = flatbuffers.table.Table(buf, pos)
# Response
def Status(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos)
return 0
# Response
def Token(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
return 0
# Response
def DataByte(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos)
return 0
# Response
def Sync(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
return 0
# Response
def StringValue(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
if o != 0:
return self._tab.String(o + self._tab.Pos)
return None
# Response
def RetShmCount(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos)
return 0
# Response
def QueryNs(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
return 0
def ResponseStart(builder):
builder.StartObject(7)
def Start(builder):
ResponseStart(builder)
def ResponseAddStatus(builder, status):
builder.PrependUint32Slot(0, status, 0)
def AddStatus(builder, status):
ResponseAddStatus(builder, status)
def ResponseAddToken(builder, token):
builder.PrependUint64Slot(1, token, 0)
def AddToken(builder, token):
ResponseAddToken(builder, token)
def ResponseAddDataByte(builder, dataByte):
builder.PrependUint32Slot(2, dataByte, 0)
def AddDataByte(builder, dataByte):
ResponseAddDataByte(builder, dataByte)
def ResponseAddSync(builder, sync):
builder.PrependUint64Slot(3, sync, 0)
def AddSync(builder, sync):
ResponseAddSync(builder, sync)
def ResponseAddStringValue(builder, stringValue):
builder.PrependUOffsetTRelativeSlot(4, flatbuffers.number_types.UOffsetTFlags.py_type(stringValue), 0)
def AddStringValue(builder, stringValue):
ResponseAddStringValue(builder, stringValue)
def ResponseAddRetShmCount(builder, retShmCount):
builder.PrependUint32Slot(5, retShmCount, 0)
def AddRetShmCount(builder, retShmCount):
ResponseAddRetShmCount(builder, retShmCount)
def ResponseAddQueryNs(builder, queryNs):
builder.PrependUint64Slot(6, queryNs, 0)
def AddQueryNs(builder, queryNs):
ResponseAddQueryNs(builder, queryNs)
def ResponseEnd(builder):
return builder.EndObject()
def End(builder):
return ResponseEnd(builder)
@@ -0,0 +1,50 @@
# automatically generated by the FlatBuffers compiler, do not modify
# namespace: Wire
import flatbuffers
from flatbuffers.compat import import_numpy
np = import_numpy()
class SwapBuffers(object):
__slots__ = ['_tab']
@classmethod
def GetRootAs(cls, buf, offset=0):
n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
x = SwapBuffers()
x.Init(buf, n + offset)
return x
@classmethod
def GetRootAsSwapBuffers(cls, buf, offset=0):
"""This method is deprecated. Please switch to GetRootAs."""
return cls.GetRootAs(buf, offset)
# SwapBuffers
def Init(self, buf, pos):
self._tab = flatbuffers.table.Table(buf, pos)
# SwapBuffers
def Draw(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
return 0
def SwapBuffersStart(builder):
builder.StartObject(1)
def Start(builder):
SwapBuffersStart(builder)
def SwapBuffersAddDraw(builder, draw):
builder.PrependUint64Slot(0, draw, 0)
def AddDraw(builder, draw):
SwapBuffersAddDraw(builder, draw)
def SwapBuffersEnd(builder):
return builder.EndObject()
def End(builder):
return SwapBuffersEnd(builder)
@@ -0,0 +1,141 @@
# automatically generated by the FlatBuffers compiler, do not modify
# namespace: Wire
import flatbuffers
from flatbuffers.compat import import_numpy
np = import_numpy()
class TextureRespecify(object):
__slots__ = ['_tab']
@classmethod
def GetRootAs(cls, buf, offset=0):
n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
x = TextureRespecify()
x.Init(buf, n + offset)
return x
@classmethod
def GetRootAsTextureRespecify(cls, buf, offset=0):
"""This method is deprecated. Please switch to GetRootAs."""
return cls.GetRootAs(buf, offset)
# TextureRespecify
def Init(self, buf, pos):
self._tab = flatbuffers.table.Table(buf, pos)
# TextureRespecify
def Texture(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
return 0
# TextureRespecify
def Level(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos)
return 0
# TextureRespecify
def Format(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos)
return 0
# TextureRespecify
def Type(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos)
return 0
# TextureRespecify
def Width(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos)
return 0
# TextureRespecify
def Height(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos)
return 0
# TextureRespecify
def Depth(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos)
return 0
# TextureRespecify
def DataSize(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
return 0
def TextureRespecifyStart(builder):
builder.StartObject(8)
def Start(builder):
TextureRespecifyStart(builder)
def TextureRespecifyAddTexture(builder, texture):
builder.PrependUint64Slot(0, texture, 0)
def AddTexture(builder, texture):
TextureRespecifyAddTexture(builder, texture)
def TextureRespecifyAddLevel(builder, level):
builder.PrependUint32Slot(1, level, 0)
def AddLevel(builder, level):
TextureRespecifyAddLevel(builder, level)
def TextureRespecifyAddFormat(builder, format):
builder.PrependUint32Slot(2, format, 0)
def AddFormat(builder, format):
TextureRespecifyAddFormat(builder, format)
def TextureRespecifyAddType(builder, type):
builder.PrependUint32Slot(3, type, 0)
def AddType(builder, type):
TextureRespecifyAddType(builder, type)
def TextureRespecifyAddWidth(builder, width):
builder.PrependUint32Slot(4, width, 0)
def AddWidth(builder, width):
TextureRespecifyAddWidth(builder, width)
def TextureRespecifyAddHeight(builder, height):
builder.PrependUint32Slot(5, height, 0)
def AddHeight(builder, height):
TextureRespecifyAddHeight(builder, height)
def TextureRespecifyAddDepth(builder, depth):
builder.PrependUint32Slot(6, depth, 0)
def AddDepth(builder, depth):
TextureRespecifyAddDepth(builder, depth)
def TextureRespecifyAddDataSize(builder, dataSize):
builder.PrependUint64Slot(7, dataSize, 0)
def AddDataSize(builder, dataSize):
TextureRespecifyAddDataSize(builder, dataSize)
def TextureRespecifyEnd(builder):
return builder.EndObject()
def End(builder):
return TextureRespecifyEnd(builder)
@@ -0,0 +1,141 @@
# automatically generated by the FlatBuffers compiler, do not modify
# namespace: Wire
import flatbuffers
from flatbuffers.compat import import_numpy
np = import_numpy()
class TextureSubImage(object):
__slots__ = ['_tab']
@classmethod
def GetRootAs(cls, buf, offset=0):
n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
x = TextureSubImage()
x.Init(buf, n + offset)
return x
@classmethod
def GetRootAsTextureSubImage(cls, buf, offset=0):
"""This method is deprecated. Please switch to GetRootAs."""
return cls.GetRootAs(buf, offset)
# TextureSubImage
def Init(self, buf, pos):
self._tab = flatbuffers.table.Table(buf, pos)
# TextureSubImage
def Texture(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
return 0
# TextureSubImage
def Level(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos)
return 0
# TextureSubImage
def Format(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos)
return 0
# TextureSubImage
def Type(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos)
return 0
# TextureSubImage
def Width(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos)
return 0
# TextureSubImage
def Height(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos)
return 0
# TextureSubImage
def Depth(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos)
return 0
# TextureSubImage
def DataSize(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
return 0
def TextureSubImageStart(builder):
builder.StartObject(8)
def Start(builder):
TextureSubImageStart(builder)
def TextureSubImageAddTexture(builder, texture):
builder.PrependUint64Slot(0, texture, 0)
def AddTexture(builder, texture):
TextureSubImageAddTexture(builder, texture)
def TextureSubImageAddLevel(builder, level):
builder.PrependUint32Slot(1, level, 0)
def AddLevel(builder, level):
TextureSubImageAddLevel(builder, level)
def TextureSubImageAddFormat(builder, format):
builder.PrependUint32Slot(2, format, 0)
def AddFormat(builder, format):
TextureSubImageAddFormat(builder, format)
def TextureSubImageAddType(builder, type):
builder.PrependUint32Slot(3, type, 0)
def AddType(builder, type):
TextureSubImageAddType(builder, type)
def TextureSubImageAddWidth(builder, width):
builder.PrependUint32Slot(4, width, 0)
def AddWidth(builder, width):
TextureSubImageAddWidth(builder, width)
def TextureSubImageAddHeight(builder, height):
builder.PrependUint32Slot(5, height, 0)
def AddHeight(builder, height):
TextureSubImageAddHeight(builder, height)
def TextureSubImageAddDepth(builder, depth):
builder.PrependUint32Slot(6, depth, 0)
def AddDepth(builder, depth):
TextureSubImageAddDepth(builder, depth)
def TextureSubImageAddDataSize(builder, dataSize):
builder.PrependUint64Slot(7, dataSize, 0)
def AddDataSize(builder, dataSize):
TextureSubImageAddDataSize(builder, dataSize)
def TextureSubImageEnd(builder):
return builder.EndObject()
def End(builder):
return TextureSubImageEnd(builder)
@@ -0,0 +1,76 @@
# automatically generated by the FlatBuffers compiler, do not modify
# namespace: Wire
import flatbuffers
from flatbuffers.compat import import_numpy
np = import_numpy()
class UnmapBuffer(object):
__slots__ = ['_tab']
@classmethod
def GetRootAs(cls, buf, offset=0):
n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
x = UnmapBuffer()
x.Init(buf, n + offset)
return x
@classmethod
def GetRootAsUnmapBuffer(cls, buf, offset=0):
"""This method is deprecated. Please switch to GetRootAs."""
return cls.GetRootAs(buf, offset)
# UnmapBuffer
def Init(self, buf, pos):
self._tab = flatbuffers.table.Table(buf, pos)
# UnmapBuffer
def BufferHandle(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
return 0
# UnmapBuffer
def Offset(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
return 0
# UnmapBuffer
def Size(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
return 0
def UnmapBufferStart(builder):
builder.StartObject(3)
def Start(builder):
UnmapBufferStart(builder)
def UnmapBufferAddBufferHandle(builder, bufferHandle):
builder.PrependUint64Slot(0, bufferHandle, 0)
def AddBufferHandle(builder, bufferHandle):
UnmapBufferAddBufferHandle(builder, bufferHandle)
def UnmapBufferAddOffset(builder, offset):
builder.PrependUint64Slot(1, offset, 0)
def AddOffset(builder, offset):
UnmapBufferAddOffset(builder, offset)
def UnmapBufferAddSize(builder, size):
builder.PrependUint64Slot(2, size, 0)
def AddSize(builder, size):
UnmapBufferAddSize(builder, size)
def UnmapBufferEnd(builder):
return builder.EndObject()
def End(builder):
return UnmapBufferEnd(builder)
@@ -0,0 +1,76 @@
# automatically generated by the FlatBuffers compiler, do not modify
# namespace: Wire
import flatbuffers
from flatbuffers.compat import import_numpy
np = import_numpy()
class WaitSync(object):
__slots__ = ['_tab']
@classmethod
def GetRootAs(cls, buf, offset=0):
n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
x = WaitSync()
x.Init(buf, n + offset)
return x
@classmethod
def GetRootAsWaitSync(cls, buf, offset=0):
"""This method is deprecated. Please switch to GetRootAs."""
return cls.GetRootAs(buf, offset)
# WaitSync
def Init(self, buf, pos):
self._tab = flatbuffers.table.Table(buf, pos)
# WaitSync
def Sync(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
return 0
# WaitSync
def Flags(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos)
return 0
# WaitSync
def Timeout(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
return 0
def WaitSyncStart(builder):
builder.StartObject(3)
def Start(builder):
WaitSyncStart(builder)
def WaitSyncAddSync(builder, sync):
builder.PrependUint64Slot(0, sync, 0)
def AddSync(builder, sync):
WaitSyncAddSync(builder, sync)
def WaitSyncAddFlags(builder, flags):
builder.PrependUint32Slot(1, flags, 0)
def AddFlags(builder, flags):
WaitSyncAddFlags(builder, flags)
def WaitSyncAddTimeout(builder, timeout):
builder.PrependUint64Slot(2, timeout, 0)
def AddTimeout(builder, timeout):
WaitSyncAddTimeout(builder, timeout)
def WaitSyncEnd(builder):
return builder.EndObject()
def End(builder):
return WaitSyncEnd(builder)
File diff suppressed because it is too large Load Diff
File diff suppressed because it is too large Load Diff
File diff suppressed because it is too large Load Diff
File diff suppressed because it is too large Load Diff
@@ -0,0 +1,209 @@
# MobileGL wire dispatch unsupported report (generated)
21 eglGetCurrentContext unsupported payload signature
22 eglGetCurrentDisplay unsupported payload signature
28 eglGetProcAddress unsupported payload signature
32 eglQueryAPI unsupported payload signature
37 eglReleaseThread unsupported payload signature
42 eglWaitClient unsupported payload signature
43 eglWaitGL unsupported payload signature
49 glApplyFramebufferAttachmentCMAAINTEL unsupported payload signature
63 glBindBuffersRange unsupported payload signature
67 glBindFramebufferEXT no payload table
73 glBindRenderbufferEXT no payload table
83 glBindVertexBuffers unsupported payload signature
84 glBlendBarrierKHR unsupported payload signature
85 glBlendBarrierNV unsupported payload signature
111 glCheckFramebufferStatusEXT no payload table
146 glCompileShaderIncludeARB unsupported payload signature
202 glCreateProgram no payload table
209 glCreateShaderProgramv unsupported payload signature
211 glCreateSyncFromCLeventARB unsupported payload signature
216 glDebugMessageCallback unsupported payload signature
217 glDebugMessageCallbackARB no payload table
219 glDebugMessageControlARB no payload table
221 glDebugMessageInsertARB no payload table
225 glDeleteFramebuffersEXT no payload table
234 glDeleteRenderbuffersEXT no payload table
268 glDrawArraysInstancedARB no payload table
270 glDrawArraysInstancedEXT no payload table
274 glDrawCommandsNV unsupported payload signature
276 glDrawCommandsStatesNV unsupported payload signature
281 glDrawElementsInstancedARB no payload table
285 glDrawElementsInstancedEXT no payload table
286 glDrawMeshTasksEXT no payload table
287 glDrawMeshTasksIndirectEXT no payload table
297 glEGLImageTargetTexStorageEXT unsupported payload signature
298 glEGLImageTargetTextureStorageEXT unsupported payload signature
309 glEndConditionalRender no payload table
310 glEndConditionalRenderNV unsupported payload signature
315 glEndTransformFeedback no payload table
316 glEvaluateDepthValuesARB unsupported payload signature
318 glFinish no payload table
319 glFlush no payload table
327 glFramebufferFetchBarrierEXT unsupported payload signature
332 glFramebufferRenderbufferEXT no payload table
335 glFramebufferShadingRateEXT no payload table
340 glFramebufferTexture2DEXT no payload table
343 glFramebufferTextureARB no payload table
346 glFramebufferTextureLayerARB no payload table
351 glGenFramebuffersEXT no payload table
357 glGenRenderbuffersEXT no payload table
363 glGenerateMipmapEXT no payload table
368 glGetActiveAttrib unsupported payload signature
369 glGetActiveSubroutineName unsupported payload signature
370 glGetActiveSubroutineUniformName unsupported payload signature
372 glGetActiveUniform unsupported payload signature
373 glGetActiveUniformBlockName unsupported payload signature
375 glGetActiveUniformName unsupported payload signature
385 glGetBufferPointerv unsupported payload signature
394 glGetDebugMessageLog unsupported payload signature
395 glGetDebugMessageLogARB no payload table
400 glGetError no payload table
408 glGetFragmentShadingRatesEXT no payload table
410 glGetFramebufferAttachmentParameterivEXT no payload table
412 glGetFramebufferParameterivEXT no payload table
414 glGetGraphicsResetStatus no payload table
415 glGetGraphicsResetStatusARB no payload table
446 glGetNamedBufferPointerv unsupported payload signature
447 glGetNamedBufferPointervEXT unsupported payload signature
462 glGetNamedStringARB unsupported payload signature
465 glGetObjectLabel unsupported payload signature
466 glGetObjectLabelEXT no payload table
467 glGetObjectPtrLabel unsupported payload signature
477 glGetPerfCounterInfoINTEL unsupported payload signature
480 glGetPerfMonitorCounterStringAMD unsupported payload signature
482 glGetPerfMonitorGroupStringAMD unsupported payload signature
485 glGetPerfQueryIdByNameINTEL unsupported payload signature
486 glGetPerfQueryInfoINTEL unsupported payload signature
487 glGetPointerIndexedvEXT unsupported payload signature
488 glGetPointeri_vEXT unsupported payload signature
489 glGetPointerv unsupported payload signature
491 glGetProgramInfoLog unsupported payload signature
493 glGetProgramPipelineInfoLog unsupported payload signature
498 glGetProgramResourceName unsupported payload signature
514 glGetRenderbufferParameterivEXT no payload table
519 glGetShaderInfoLog unsupported payload signature
521 glGetShaderSource unsupported payload signature
557 glGetTransformFeedbackVarying unsupported payload signature
562 glGetUniformIndices unsupported payload signature
577 glGetVertexArrayPointeri_vEXT unsupported payload signature
578 glGetVertexArrayPointervEXT unsupported payload signature
586 glGetVertexAttribPointerv unsupported payload signature
598 glGetnUniformfvARB no payload table
601 glGetnUniformivARB no payload table
604 glGetnUniformuivARB no payload table
624 glIsFramebufferEXT no payload table
636 glIsRenderbufferEXT no payload table
645 glIsTransformFeedbackNV no payload table
650 glListDrawCommandsStatesClientNV unsupported payload signature
666 glMapNamedBuffer no payload table
667 glMapNamedBufferEXT no payload table
668 glMapNamedBufferRange no payload table
669 glMapNamedBufferRangeEXT no payload table
700 glMinSampleShadingARB no payload table
707 glMultiDrawElements unsupported payload signature
708 glMultiDrawElementsBaseVertex unsupported payload signature
714 glMultiDrawMeshTasksIndirectCountEXT no payload table
716 glMultiDrawMeshTasksIndirectEXT no payload table
771 glNamedFramebufferTextureMultiviewOVR no payload table
814 glPauseTransformFeedback no payload table
827 glPopDebugGroup no payload table
828 glPopGroupMarkerEXT unsupported payload signature
833 glProgramParameteriARB no payload table
840 glProgramUniform1fEXT no payload table
842 glProgramUniform1fvEXT no payload table
848 glProgramUniform1iEXT no payload table
850 glProgramUniform1ivEXT no payload table
856 glProgramUniform1uiEXT no payload table
858 glProgramUniform1uivEXT no payload table
864 glProgramUniform2fEXT no payload table
866 glProgramUniform2fvEXT no payload table
872 glProgramUniform2iEXT no payload table
874 glProgramUniform2ivEXT no payload table
880 glProgramUniform2uiEXT no payload table
882 glProgramUniform2uivEXT no payload table
888 glProgramUniform3fEXT no payload table
890 glProgramUniform3fvEXT no payload table
896 glProgramUniform3iEXT no payload table
898 glProgramUniform3ivEXT no payload table
904 glProgramUniform3uiEXT no payload table
906 glProgramUniform3uivEXT no payload table
912 glProgramUniform4fEXT no payload table
914 glProgramUniform4fvEXT no payload table
920 glProgramUniform4iEXT no payload table
922 glProgramUniform4ivEXT no payload table
928 glProgramUniform4uiEXT no payload table
930 glProgramUniform4uivEXT no payload table
938 glProgramUniformMatrix2fvEXT no payload table
942 glProgramUniformMatrix2x3fvEXT no payload table
946 glProgramUniformMatrix2x4fvEXT no payload table
950 glProgramUniformMatrix3fvEXT no payload table
954 glProgramUniformMatrix3x2fvEXT no payload table
958 glProgramUniformMatrix3x4fvEXT no payload table
962 glProgramUniformMatrix4fvEXT no payload table
966 glProgramUniformMatrix4x2fvEXT no payload table
970 glProgramUniformMatrix4x3fvEXT no payload table
982 glReadnPixelsARB no payload table
983 glReleaseShaderCompiler no payload table
985 glRenderbufferStorageEXT no payload table
990 glResolveDepthValuesNV unsupported payload signature
991 glResumeTransformFeedback no payload table
1009 glShaderSource unsupported payload signature
1011 glShadingRateCombinerOpsEXT no payload table
1012 glShadingRateEXT no payload table
1039 glTexBufferARB no payload table
1055 glTexStorage1D no payload table
1058 glTexStorage2DEXT no payload table
1061 glTexStorage3DEXT no payload table
1067 glTextureBarrier unsupported payload signature
1068 glTextureBarrierNV unsupported payload signature
1110 glTransformFeedbackVaryings unsupported payload signature
1235 glVertexArrayVertexBuffers unsupported payload signature
1275 glVertexAttribDivisorARB no payload table
1350 glWindowRectanglesEXT no payload table
1351 glXChooseFBConfig no payload table
1352 glXChooseVisual no payload table
1353 glXCopyContext no payload table
1354 glXCreateContext no payload table
1355 glXCreateContextAttribsARB no payload table
1356 glXCreateGLXPixmap no payload table
1357 glXCreateNewContext no payload table
1358 glXCreatePbuffer no payload table
1359 glXCreatePixmap no payload table
1360 glXCreateWindow no payload table
1361 glXDestroyContext no payload table
1362 glXDestroyGLXPixmap no payload table
1363 glXDestroyPbuffer no payload table
1364 glXDestroyPixmap no payload table
1365 glXDestroyWindow no payload table
1366 glXGetClientString no payload table
1367 glXGetConfig no payload table
1368 glXGetCurrentContext no payload table
1369 glXGetCurrentDisplay no payload table
1370 glXGetCurrentDrawable no payload table
1371 glXGetCurrentReadDrawable no payload table
1372 glXGetFBConfigAttrib no payload table
1373 glXGetFBConfigs no payload table
1374 glXGetProcAddress no payload table
1375 glXGetProcAddressARB no payload table
1376 glXGetSelectedEvent no payload table
1377 glXGetSwapIntervalMESA no payload table
1378 glXGetVisualFromFBConfig no payload table
1379 glXIsDirect no payload table
1380 glXMakeContextCurrent no payload table
1381 glXMakeCurrent no payload table
1382 glXQueryContext no payload table
1383 glXQueryDrawable no payload table
1384 glXQueryExtension no payload table
1385 glXQueryExtensionsString no payload table
1386 glXQueryServerString no payload table
1387 glXQueryVersion no payload table
1388 glXSelectEvent no payload table
1389 glXSwapBuffers no payload table
1390 glXSwapIntervalEXT no payload table
1391 glXSwapIntervalMESA no payload table
1392 glXSwapIntervalSGI no payload table
1393 glXUseXFont no payload table
1394 glXWaitGL no payload table
1395 glXWaitX no payload table
1396 glx no payload table
File diff suppressed because it is too large Load Diff