mirror of
https://github.com/MobileGL-Dev/MobileGL
synced 2026-11-13 13:03:22 +09:00
swung0x48
901d48a678
- S-1 PipeStats::OnPresent read each frame accumulator and then store(0)'d it; a Bump from a staging thread landing in between was lost from the Tracy plot and from every frame. Each accumulator is now exchange(0, relaxed) and the exchanged value is what is plotted, so every add lands in exactly one frame. - T-3 FdPassing without MSG_CMSG_CLOEXEC (macOS, BSD) handed back descriptors that survived exec; every received fd now gets FD_CLOEXEC by hand under !MSG_CMSG_CLOEXEC. MSG_NOSIGNAL is defined to 0 where the platform lacks it (FdPassing.cpp, Doorbell.cpp) and SO_NOSIGPIPE is set on the socketpair and on a SocketDoorbell's descriptor where it exists, so a write to a hung-up peer is EPIPE rather than a fatal signal. - T-4 the missing-flatbuffers fallback wrote OFF into the cache with FORCE, so a plain re-configure after `git submodule update` stayed OFF silently. It is a normal-variable set now, shadowing the cache for that configure only; verified by hiding flatbuffers.h, configuring with ON (warning, transport off, cache still ON) and re-configuring plainly with the header back (transport ON). - P-2 three LIVE GLFunctionsTable entries had no carrier: GetGpuTimestampNs (glGetInteger64v(GL_TIMESTAMP), a synchronous server answer), QueryCounterTimestamp (glQueryCounter, a one-shot stamp, not a begin/end pair) and WaitSync (the GPU-side wait FenceWait's client wait does not express). QueryTimestamp (MGPTimestampRequest, kCtxQuery, kReplySlot), QueryCounter (MGPQueryDesc with Kind = GL_TIMESTAMP, kCtxQuery) and FenceWaitServer (MGPFenceWait, kScreen) are APPENDED at the end of PipeCalls.def because the opcode is the position: SetSwapInterval stays 68, the three take 69-71, and PipeCatalogue.LateArrivalsAreAppendedWithoutRenumbering pins that. Header counts 71 (screen 11, query 8); the seven generators regenerated. - P-3 MGPBufferRange inlined a 32-byte MGHostSpan into every range of every class - dead space on every SSBO, atomic-counter and XFB range, and D-B8 says not to freeze the named-UBO payload before the stage-ubo-named numbers exist. The range is 24 bytes now; the host spans are an optional second var-tail behind the ranges, announced by MGPShaderBuffers::HostSpanCount (0 or Count), with set_shader_buffers keeping its kVarTail|kHostSpan flags. PipeCatalogue.BufferRangeCarriesNoInlineHostSpan pins the sizes, the flags and the comparator's view of the count. - P-4 QueryEnvUint64 parsed with base 0 (a leading zero meant octal: MOBILEGL_PIPE_PUSH=010 read as 8) and accepted -1 as every bit set; it is decimal or explicit 0x now and a '-' anywhere is refused with the warning (smoke through the integration binary: -1 and 12abc warn, 010 and 0x10 parse). The CI stdio gate's alternation now also catches fprintf(stdout, puts( and std::cout/cerr; it is green over MG_Backend and MG_State. MGPSubData states how the buffer half expresses [offset, size): UnionBox.X / UnionBox.W with Target == Buffer, Y = Z = 0, H = D = 1, one record bounded at a 2^31-1 offset and 2^32-1 size beyond which the emitter splits (the same rule the ring's half-capacity bound already imposes); MGPipeSetSubDataBufferRange / MGPipeSubDataBufferOffset / Size are the only spelling and PipeCatalogue.SubDataBufferRangeRidesInTheUnionBox pins the encoding and its bounds. gen_pipe.py now refuses, in both modes, a call payload named in PipeCalls.def with no field list in PipeFields.def (the four memcmp-fallback member types are the documented exception); shown by dropping P(MGPSwapInterval), which exits 1 naming the payload. - The MGPPixelPackState size assertion compared sizeof against itself; it asserts the literal 28 PixelStoreParameters measures. - Verified: ctest -L unit green in both the default and the split configuration, gen_pipe.py --check clean with the generated files committed, nm --defined-only of the default libMobileGL.so has no MG_Remote symbol, and the full integration-gpu suite passes (the *IsActuallyArmedWhenTheEnvironmentPinsItOn family trips under -j 8 as documented and passes serially).
932 lines
39 KiB
C++
932 lines
39 KiB
C++
// MobileGL - MobileGL/MG_Pipe/generated/PipeWire.inc
|
|
// Copyright (c) 2025-2026 MobileGL-Dev
|
|
// Licensed under the GNU Lesser General Public License v3.0:
|
|
// https://www.gnu.org/licenses/gpl-3.0.txt
|
|
// https://www.gnu.org/licenses/lgpl-3.0.txt
|
|
// SPDX-License-Identifier: LGPL-3.0-only
|
|
// End of Source File Header
|
|
|
|
// G3: wire records, size assertions and the applier's bounds gate.
|
|
//
|
|
// GENERATED by scripts/gen_pipe.py from PipeCalls.def - DO NOT EDIT.
|
|
// Regenerate with `python3 scripts/gen_pipe.py`; CI runs it and diffs the result.
|
|
// This file is included from MG_Pipe/MGPipe.h inside namespace MobileGL::MG_Pipe.
|
|
|
|
// Every record is a fixed header plus its payload, padded to the stream's 8-byte
|
|
// granularity. The size assertion is stated as a COMPOSITION so it fires on any padding
|
|
// the compiler inserts between the header and the payload while staying honest about the
|
|
// tail padding the alignment requires.
|
|
//
|
|
// The applier's precondition is checked BEFORE dispatch, on every record, in every build:
|
|
// a record that is shorter than its own type, longer than what is left in the buffer, or
|
|
// not a multiple of 8 is protocol corruption and is fatal. There is no recovery path -
|
|
// silently applying a truncated record is how a corrupt stream becomes a wrong picture.
|
|
//
|
|
// OVERSIZED PAYLOADS ARE CHUNKED, NEVER EMITTED WHOLE (plan section 8.2: G3 has to define
|
|
// the path for a record larger than the segment). The bound is the ring's,
|
|
// RingProducer::MaxRecordBytes() == Capacity()/2, and it is exact rather than
|
|
// conservative: a record has to be placeable at every head offset of an empty ring, the
|
|
// wrap pad in front of it costs up to total-8 bytes, and only a record of at most half the
|
|
// ring survives that at every offset. An emitter holding more than Capacity()/2 bytes of
|
|
// record (a large resource_subdata, a create_shader_state archive) splits it into several
|
|
// records of at most that size; the transport refuses a bigger one outright - nullptr plus
|
|
// an MGLOG_E - rather than let the producer wait on free bytes that can never suffice.
|
|
|
|
struct MGPWireRecHeader {
|
|
Uint16 Op; // MGPWireOp
|
|
Uint16 Flags; // MGPipeCallFlags of the call, for asserts and tracing
|
|
Uint32 Size; // bytes of this record including the header and the variable tail
|
|
};
|
|
static_assert(sizeof(MGPWireRecHeader) == 8, "the wire header is 8 bytes");
|
|
static_assert(std::is_trivially_copyable_v<MGPWireRecHeader>);
|
|
|
|
// The opcode is the call's position in PipeCalls.def. Reordering that file is a protocol
|
|
// break; appending to it is not.
|
|
enum class MGPWireOp : Uint16 {
|
|
kInvalid = 0,
|
|
GetCaps = 1,
|
|
ResourceCreate = 2,
|
|
ResourceRespecify = 3,
|
|
ResourceDestroy = 4,
|
|
MapPersistent = 5,
|
|
UnmapPersistent = 6,
|
|
FenceCreate = 7,
|
|
FenceStatus = 8,
|
|
FenceWait = 9,
|
|
FenceDestroy = 10,
|
|
QueryCreate = 11,
|
|
QueryBegin = 12,
|
|
QueryEnd = 13,
|
|
QueryAvailable = 14,
|
|
QueryResult = 15,
|
|
QueryDestroy = 16,
|
|
CreateRenderState = 17,
|
|
BindRenderState = 18,
|
|
DeleteRenderState = 19,
|
|
CreateVertexElements = 20,
|
|
BindVertexElements = 21,
|
|
DeleteVertexElements = 22,
|
|
CreateSamplerState = 23,
|
|
DeleteSamplerState = 24,
|
|
CreateSamplerView = 25,
|
|
DeleteSamplerView = 26,
|
|
CreateShaderState = 27,
|
|
BindShaderState = 28,
|
|
DeleteShaderState = 29,
|
|
SetDynamicState = 30,
|
|
SetFramebufferState = 31,
|
|
SetVertexBuffers = 32,
|
|
SetIndexBuffer = 33,
|
|
SetIndirectBuffers = 34,
|
|
SetSamplerViews = 35,
|
|
BindSamplerStates = 36,
|
|
SetShaderImages = 37,
|
|
SetShaderBuffers = 38,
|
|
SetStreamOutputTargets = 39,
|
|
SetGlobalConstants = 40,
|
|
SetVertexAttribDefaults = 41,
|
|
SetPixelPackState = 42,
|
|
SetPatchState = 43,
|
|
SetDrawProgram = 44,
|
|
SetDispatchProgram = 45,
|
|
SetResidualValueState = 46,
|
|
SetTextureParams = 47,
|
|
ResourceSubData = 48,
|
|
BufferSubDataResident = 49,
|
|
ResourceSubDataComplete = 50,
|
|
ResourceFlushRange = 51,
|
|
ResourceReadback = 52,
|
|
ResourceCopyRegion = 53,
|
|
GenerateMipmap = 54,
|
|
GetTextureImage = 55,
|
|
Blit = 56,
|
|
Clear = 57,
|
|
ReadPixels = 58,
|
|
DrawVbo = 59,
|
|
LaunchGrid = 60,
|
|
MemoryBarrier = 61,
|
|
BeginStreamOutput = 62,
|
|
EndStreamOutput = 63,
|
|
PauseStreamOutput = 64,
|
|
ResumeStreamOutput = 65,
|
|
Flush = 66,
|
|
Present = 67,
|
|
SetSwapInterval = 68,
|
|
QueryTimestamp = 69,
|
|
QueryCounter = 70,
|
|
FenceWaitServer = 71,
|
|
kOpCount = 72,
|
|
};
|
|
|
|
struct alignas(8) MGPWireRec_GetCaps {
|
|
MGPWireRecHeader Header;
|
|
MGPCaps Payload;
|
|
};
|
|
static_assert(sizeof(MGPWireRec_GetCaps) ==
|
|
((sizeof(MGPWireRecHeader) + sizeof(MGPCaps) + 7u) & ~SizeT(7u)),
|
|
"MGPWireRec_GetCaps gained padding; the wire format moved");
|
|
|
|
struct alignas(8) MGPWireRec_ResourceCreate {
|
|
MGPWireRecHeader Header;
|
|
MGPResourceDesc Payload;
|
|
};
|
|
static_assert(sizeof(MGPWireRec_ResourceCreate) ==
|
|
((sizeof(MGPWireRecHeader) + sizeof(MGPResourceDesc) + 7u) & ~SizeT(7u)),
|
|
"MGPWireRec_ResourceCreate gained padding; the wire format moved");
|
|
|
|
struct alignas(8) MGPWireRec_ResourceRespecify {
|
|
MGPWireRecHeader Header;
|
|
MGPResourceDesc Payload;
|
|
};
|
|
static_assert(sizeof(MGPWireRec_ResourceRespecify) ==
|
|
((sizeof(MGPWireRecHeader) + sizeof(MGPResourceDesc) + 7u) & ~SizeT(7u)),
|
|
"MGPWireRec_ResourceRespecify gained padding; the wire format moved");
|
|
|
|
struct alignas(8) MGPWireRec_ResourceDestroy {
|
|
MGPWireRecHeader Header;
|
|
MGPHandleOnly Payload;
|
|
};
|
|
static_assert(sizeof(MGPWireRec_ResourceDestroy) ==
|
|
((sizeof(MGPWireRecHeader) + sizeof(MGPHandleOnly) + 7u) & ~SizeT(7u)),
|
|
"MGPWireRec_ResourceDestroy gained padding; the wire format moved");
|
|
|
|
struct alignas(8) MGPWireRec_MapPersistent {
|
|
MGPWireRecHeader Header;
|
|
MGPHandleOnly Payload;
|
|
};
|
|
static_assert(sizeof(MGPWireRec_MapPersistent) ==
|
|
((sizeof(MGPWireRecHeader) + sizeof(MGPHandleOnly) + 7u) & ~SizeT(7u)),
|
|
"MGPWireRec_MapPersistent gained padding; the wire format moved");
|
|
|
|
struct alignas(8) MGPWireRec_UnmapPersistent {
|
|
MGPWireRecHeader Header;
|
|
MGPHandleOnly Payload;
|
|
};
|
|
static_assert(sizeof(MGPWireRec_UnmapPersistent) ==
|
|
((sizeof(MGPWireRecHeader) + sizeof(MGPHandleOnly) + 7u) & ~SizeT(7u)),
|
|
"MGPWireRec_UnmapPersistent gained padding; the wire format moved");
|
|
|
|
struct alignas(8) MGPWireRec_FenceCreate {
|
|
MGPWireRecHeader Header;
|
|
MGPHandleOnly Payload;
|
|
};
|
|
static_assert(sizeof(MGPWireRec_FenceCreate) ==
|
|
((sizeof(MGPWireRecHeader) + sizeof(MGPHandleOnly) + 7u) & ~SizeT(7u)),
|
|
"MGPWireRec_FenceCreate gained padding; the wire format moved");
|
|
|
|
struct alignas(8) MGPWireRec_FenceStatus {
|
|
MGPWireRecHeader Header;
|
|
MGPHandleOnly Payload;
|
|
};
|
|
static_assert(sizeof(MGPWireRec_FenceStatus) ==
|
|
((sizeof(MGPWireRecHeader) + sizeof(MGPHandleOnly) + 7u) & ~SizeT(7u)),
|
|
"MGPWireRec_FenceStatus gained padding; the wire format moved");
|
|
|
|
struct alignas(8) MGPWireRec_FenceWait {
|
|
MGPWireRecHeader Header;
|
|
MGPFenceWait Payload;
|
|
};
|
|
static_assert(sizeof(MGPWireRec_FenceWait) ==
|
|
((sizeof(MGPWireRecHeader) + sizeof(MGPFenceWait) + 7u) & ~SizeT(7u)),
|
|
"MGPWireRec_FenceWait gained padding; the wire format moved");
|
|
|
|
struct alignas(8) MGPWireRec_FenceDestroy {
|
|
MGPWireRecHeader Header;
|
|
MGPHandleOnly Payload;
|
|
};
|
|
static_assert(sizeof(MGPWireRec_FenceDestroy) ==
|
|
((sizeof(MGPWireRecHeader) + sizeof(MGPHandleOnly) + 7u) & ~SizeT(7u)),
|
|
"MGPWireRec_FenceDestroy gained padding; the wire format moved");
|
|
|
|
struct alignas(8) MGPWireRec_QueryCreate {
|
|
MGPWireRecHeader Header;
|
|
MGPQueryDesc Payload;
|
|
};
|
|
static_assert(sizeof(MGPWireRec_QueryCreate) ==
|
|
((sizeof(MGPWireRecHeader) + sizeof(MGPQueryDesc) + 7u) & ~SizeT(7u)),
|
|
"MGPWireRec_QueryCreate gained padding; the wire format moved");
|
|
|
|
struct alignas(8) MGPWireRec_QueryBegin {
|
|
MGPWireRecHeader Header;
|
|
MGPQueryDesc Payload;
|
|
};
|
|
static_assert(sizeof(MGPWireRec_QueryBegin) ==
|
|
((sizeof(MGPWireRecHeader) + sizeof(MGPQueryDesc) + 7u) & ~SizeT(7u)),
|
|
"MGPWireRec_QueryBegin gained padding; the wire format moved");
|
|
|
|
struct alignas(8) MGPWireRec_QueryEnd {
|
|
MGPWireRecHeader Header;
|
|
MGPQueryDesc Payload;
|
|
};
|
|
static_assert(sizeof(MGPWireRec_QueryEnd) ==
|
|
((sizeof(MGPWireRecHeader) + sizeof(MGPQueryDesc) + 7u) & ~SizeT(7u)),
|
|
"MGPWireRec_QueryEnd gained padding; the wire format moved");
|
|
|
|
struct alignas(8) MGPWireRec_QueryAvailable {
|
|
MGPWireRecHeader Header;
|
|
MGPHandleOnly Payload;
|
|
};
|
|
static_assert(sizeof(MGPWireRec_QueryAvailable) ==
|
|
((sizeof(MGPWireRecHeader) + sizeof(MGPHandleOnly) + 7u) & ~SizeT(7u)),
|
|
"MGPWireRec_QueryAvailable gained padding; the wire format moved");
|
|
|
|
struct alignas(8) MGPWireRec_QueryResult {
|
|
MGPWireRecHeader Header;
|
|
MGPQueryResultRequest Payload;
|
|
};
|
|
static_assert(sizeof(MGPWireRec_QueryResult) ==
|
|
((sizeof(MGPWireRecHeader) + sizeof(MGPQueryResultRequest) + 7u) & ~SizeT(7u)),
|
|
"MGPWireRec_QueryResult gained padding; the wire format moved");
|
|
|
|
struct alignas(8) MGPWireRec_QueryDestroy {
|
|
MGPWireRecHeader Header;
|
|
MGPHandleOnly Payload;
|
|
};
|
|
static_assert(sizeof(MGPWireRec_QueryDestroy) ==
|
|
((sizeof(MGPWireRecHeader) + sizeof(MGPHandleOnly) + 7u) & ~SizeT(7u)),
|
|
"MGPWireRec_QueryDestroy gained padding; the wire format moved");
|
|
|
|
struct alignas(8) MGPWireRec_CreateRenderState {
|
|
MGPWireRecHeader Header;
|
|
MGPRenderStateDesc Payload;
|
|
};
|
|
static_assert(sizeof(MGPWireRec_CreateRenderState) ==
|
|
((sizeof(MGPWireRecHeader) + sizeof(MGPRenderStateDesc) + 7u) & ~SizeT(7u)),
|
|
"MGPWireRec_CreateRenderState gained padding; the wire format moved");
|
|
|
|
struct alignas(8) MGPWireRec_BindRenderState {
|
|
MGPWireRecHeader Header;
|
|
MGPBindRenderState Payload;
|
|
};
|
|
static_assert(sizeof(MGPWireRec_BindRenderState) ==
|
|
((sizeof(MGPWireRecHeader) + sizeof(MGPBindRenderState) + 7u) & ~SizeT(7u)),
|
|
"MGPWireRec_BindRenderState gained padding; the wire format moved");
|
|
|
|
struct alignas(8) MGPWireRec_DeleteRenderState {
|
|
MGPWireRecHeader Header;
|
|
MGPHandleOnly Payload;
|
|
};
|
|
static_assert(sizeof(MGPWireRec_DeleteRenderState) ==
|
|
((sizeof(MGPWireRecHeader) + sizeof(MGPHandleOnly) + 7u) & ~SizeT(7u)),
|
|
"MGPWireRec_DeleteRenderState gained padding; the wire format moved");
|
|
|
|
struct alignas(8) MGPWireRec_CreateVertexElements {
|
|
MGPWireRecHeader Header;
|
|
MGPVertexElements Payload;
|
|
};
|
|
static_assert(sizeof(MGPWireRec_CreateVertexElements) ==
|
|
((sizeof(MGPWireRecHeader) + sizeof(MGPVertexElements) + 7u) & ~SizeT(7u)),
|
|
"MGPWireRec_CreateVertexElements gained padding; the wire format moved");
|
|
|
|
struct alignas(8) MGPWireRec_BindVertexElements {
|
|
MGPWireRecHeader Header;
|
|
MGPHandleOnly Payload;
|
|
};
|
|
static_assert(sizeof(MGPWireRec_BindVertexElements) ==
|
|
((sizeof(MGPWireRecHeader) + sizeof(MGPHandleOnly) + 7u) & ~SizeT(7u)),
|
|
"MGPWireRec_BindVertexElements gained padding; the wire format moved");
|
|
|
|
struct alignas(8) MGPWireRec_DeleteVertexElements {
|
|
MGPWireRecHeader Header;
|
|
MGPHandleOnly Payload;
|
|
};
|
|
static_assert(sizeof(MGPWireRec_DeleteVertexElements) ==
|
|
((sizeof(MGPWireRecHeader) + sizeof(MGPHandleOnly) + 7u) & ~SizeT(7u)),
|
|
"MGPWireRec_DeleteVertexElements gained padding; the wire format moved");
|
|
|
|
struct alignas(8) MGPWireRec_CreateSamplerState {
|
|
MGPWireRecHeader Header;
|
|
MGPSamplerDesc Payload;
|
|
};
|
|
static_assert(sizeof(MGPWireRec_CreateSamplerState) ==
|
|
((sizeof(MGPWireRecHeader) + sizeof(MGPSamplerDesc) + 7u) & ~SizeT(7u)),
|
|
"MGPWireRec_CreateSamplerState gained padding; the wire format moved");
|
|
|
|
struct alignas(8) MGPWireRec_DeleteSamplerState {
|
|
MGPWireRecHeader Header;
|
|
MGPHandleOnly Payload;
|
|
};
|
|
static_assert(sizeof(MGPWireRec_DeleteSamplerState) ==
|
|
((sizeof(MGPWireRecHeader) + sizeof(MGPHandleOnly) + 7u) & ~SizeT(7u)),
|
|
"MGPWireRec_DeleteSamplerState gained padding; the wire format moved");
|
|
|
|
struct alignas(8) MGPWireRec_CreateSamplerView {
|
|
MGPWireRecHeader Header;
|
|
MGPSamplerView Payload;
|
|
};
|
|
static_assert(sizeof(MGPWireRec_CreateSamplerView) ==
|
|
((sizeof(MGPWireRecHeader) + sizeof(MGPSamplerView) + 7u) & ~SizeT(7u)),
|
|
"MGPWireRec_CreateSamplerView gained padding; the wire format moved");
|
|
|
|
struct alignas(8) MGPWireRec_DeleteSamplerView {
|
|
MGPWireRecHeader Header;
|
|
MGPHandleOnly Payload;
|
|
};
|
|
static_assert(sizeof(MGPWireRec_DeleteSamplerView) ==
|
|
((sizeof(MGPWireRecHeader) + sizeof(MGPHandleOnly) + 7u) & ~SizeT(7u)),
|
|
"MGPWireRec_DeleteSamplerView gained padding; the wire format moved");
|
|
|
|
struct alignas(8) MGPWireRec_CreateShaderState {
|
|
MGPWireRecHeader Header;
|
|
MGPProgramDesc Payload;
|
|
};
|
|
static_assert(sizeof(MGPWireRec_CreateShaderState) ==
|
|
((sizeof(MGPWireRecHeader) + sizeof(MGPProgramDesc) + 7u) & ~SizeT(7u)),
|
|
"MGPWireRec_CreateShaderState gained padding; the wire format moved");
|
|
|
|
struct alignas(8) MGPWireRec_BindShaderState {
|
|
MGPWireRecHeader Header;
|
|
MGPHandleOnly Payload;
|
|
};
|
|
static_assert(sizeof(MGPWireRec_BindShaderState) ==
|
|
((sizeof(MGPWireRecHeader) + sizeof(MGPHandleOnly) + 7u) & ~SizeT(7u)),
|
|
"MGPWireRec_BindShaderState gained padding; the wire format moved");
|
|
|
|
struct alignas(8) MGPWireRec_DeleteShaderState {
|
|
MGPWireRecHeader Header;
|
|
MGPHandleOnly Payload;
|
|
};
|
|
static_assert(sizeof(MGPWireRec_DeleteShaderState) ==
|
|
((sizeof(MGPWireRecHeader) + sizeof(MGPHandleOnly) + 7u) & ~SizeT(7u)),
|
|
"MGPWireRec_DeleteShaderState gained padding; the wire format moved");
|
|
|
|
struct alignas(8) MGPWireRec_SetDynamicState {
|
|
MGPWireRecHeader Header;
|
|
MGPDynamicState Payload;
|
|
};
|
|
static_assert(sizeof(MGPWireRec_SetDynamicState) ==
|
|
((sizeof(MGPWireRecHeader) + sizeof(MGPDynamicState) + 7u) & ~SizeT(7u)),
|
|
"MGPWireRec_SetDynamicState gained padding; the wire format moved");
|
|
|
|
struct alignas(8) MGPWireRec_SetFramebufferState {
|
|
MGPWireRecHeader Header;
|
|
MGPFramebufferState Payload;
|
|
};
|
|
static_assert(sizeof(MGPWireRec_SetFramebufferState) ==
|
|
((sizeof(MGPWireRecHeader) + sizeof(MGPFramebufferState) + 7u) & ~SizeT(7u)),
|
|
"MGPWireRec_SetFramebufferState gained padding; the wire format moved");
|
|
|
|
struct alignas(8) MGPWireRec_SetVertexBuffers {
|
|
MGPWireRecHeader Header;
|
|
MGPVertexBuffers Payload;
|
|
};
|
|
static_assert(sizeof(MGPWireRec_SetVertexBuffers) ==
|
|
((sizeof(MGPWireRecHeader) + sizeof(MGPVertexBuffers) + 7u) & ~SizeT(7u)),
|
|
"MGPWireRec_SetVertexBuffers gained padding; the wire format moved");
|
|
|
|
struct alignas(8) MGPWireRec_SetIndexBuffer {
|
|
MGPWireRecHeader Header;
|
|
MGPIndexBuffer Payload;
|
|
};
|
|
static_assert(sizeof(MGPWireRec_SetIndexBuffer) ==
|
|
((sizeof(MGPWireRecHeader) + sizeof(MGPIndexBuffer) + 7u) & ~SizeT(7u)),
|
|
"MGPWireRec_SetIndexBuffer gained padding; the wire format moved");
|
|
|
|
struct alignas(8) MGPWireRec_SetIndirectBuffers {
|
|
MGPWireRecHeader Header;
|
|
MGPIndirectBuffers Payload;
|
|
};
|
|
static_assert(sizeof(MGPWireRec_SetIndirectBuffers) ==
|
|
((sizeof(MGPWireRecHeader) + sizeof(MGPIndirectBuffers) + 7u) & ~SizeT(7u)),
|
|
"MGPWireRec_SetIndirectBuffers gained padding; the wire format moved");
|
|
|
|
struct alignas(8) MGPWireRec_SetSamplerViews {
|
|
MGPWireRecHeader Header;
|
|
MGPSamplerViews Payload;
|
|
};
|
|
static_assert(sizeof(MGPWireRec_SetSamplerViews) ==
|
|
((sizeof(MGPWireRecHeader) + sizeof(MGPSamplerViews) + 7u) & ~SizeT(7u)),
|
|
"MGPWireRec_SetSamplerViews gained padding; the wire format moved");
|
|
|
|
struct alignas(8) MGPWireRec_BindSamplerStates {
|
|
MGPWireRecHeader Header;
|
|
MGPSamplerStates Payload;
|
|
};
|
|
static_assert(sizeof(MGPWireRec_BindSamplerStates) ==
|
|
((sizeof(MGPWireRecHeader) + sizeof(MGPSamplerStates) + 7u) & ~SizeT(7u)),
|
|
"MGPWireRec_BindSamplerStates gained padding; the wire format moved");
|
|
|
|
struct alignas(8) MGPWireRec_SetShaderImages {
|
|
MGPWireRecHeader Header;
|
|
MGPShaderImages Payload;
|
|
};
|
|
static_assert(sizeof(MGPWireRec_SetShaderImages) ==
|
|
((sizeof(MGPWireRecHeader) + sizeof(MGPShaderImages) + 7u) & ~SizeT(7u)),
|
|
"MGPWireRec_SetShaderImages gained padding; the wire format moved");
|
|
|
|
struct alignas(8) MGPWireRec_SetShaderBuffers {
|
|
MGPWireRecHeader Header;
|
|
MGPShaderBuffers Payload;
|
|
};
|
|
static_assert(sizeof(MGPWireRec_SetShaderBuffers) ==
|
|
((sizeof(MGPWireRecHeader) + sizeof(MGPShaderBuffers) + 7u) & ~SizeT(7u)),
|
|
"MGPWireRec_SetShaderBuffers gained padding; the wire format moved");
|
|
|
|
struct alignas(8) MGPWireRec_SetStreamOutputTargets {
|
|
MGPWireRecHeader Header;
|
|
MGPStreamOutputTargets Payload;
|
|
};
|
|
static_assert(sizeof(MGPWireRec_SetStreamOutputTargets) ==
|
|
((sizeof(MGPWireRecHeader) + sizeof(MGPStreamOutputTargets) + 7u) & ~SizeT(7u)),
|
|
"MGPWireRec_SetStreamOutputTargets gained padding; the wire format moved");
|
|
|
|
struct alignas(8) MGPWireRec_SetGlobalConstants {
|
|
MGPWireRecHeader Header;
|
|
MGPGlobalConstants Payload;
|
|
};
|
|
static_assert(sizeof(MGPWireRec_SetGlobalConstants) ==
|
|
((sizeof(MGPWireRecHeader) + sizeof(MGPGlobalConstants) + 7u) & ~SizeT(7u)),
|
|
"MGPWireRec_SetGlobalConstants gained padding; the wire format moved");
|
|
|
|
struct alignas(8) MGPWireRec_SetVertexAttribDefaults {
|
|
MGPWireRecHeader Header;
|
|
MGPVertexAttribDefaults Payload;
|
|
};
|
|
static_assert(sizeof(MGPWireRec_SetVertexAttribDefaults) ==
|
|
((sizeof(MGPWireRecHeader) + sizeof(MGPVertexAttribDefaults) + 7u) & ~SizeT(7u)),
|
|
"MGPWireRec_SetVertexAttribDefaults gained padding; the wire format moved");
|
|
|
|
struct alignas(8) MGPWireRec_SetPixelPackState {
|
|
MGPWireRecHeader Header;
|
|
MGPPixelPackState Payload;
|
|
};
|
|
static_assert(sizeof(MGPWireRec_SetPixelPackState) ==
|
|
((sizeof(MGPWireRecHeader) + sizeof(MGPPixelPackState) + 7u) & ~SizeT(7u)),
|
|
"MGPWireRec_SetPixelPackState gained padding; the wire format moved");
|
|
|
|
struct alignas(8) MGPWireRec_SetPatchState {
|
|
MGPWireRecHeader Header;
|
|
MGPPatchState Payload;
|
|
};
|
|
static_assert(sizeof(MGPWireRec_SetPatchState) ==
|
|
((sizeof(MGPWireRecHeader) + sizeof(MGPPatchState) + 7u) & ~SizeT(7u)),
|
|
"MGPWireRec_SetPatchState gained padding; the wire format moved");
|
|
|
|
struct alignas(8) MGPWireRec_SetDrawProgram {
|
|
MGPWireRecHeader Header;
|
|
MGPHandleOnly Payload;
|
|
};
|
|
static_assert(sizeof(MGPWireRec_SetDrawProgram) ==
|
|
((sizeof(MGPWireRecHeader) + sizeof(MGPHandleOnly) + 7u) & ~SizeT(7u)),
|
|
"MGPWireRec_SetDrawProgram gained padding; the wire format moved");
|
|
|
|
struct alignas(8) MGPWireRec_SetDispatchProgram {
|
|
MGPWireRecHeader Header;
|
|
MGPHandleOnly Payload;
|
|
};
|
|
static_assert(sizeof(MGPWireRec_SetDispatchProgram) ==
|
|
((sizeof(MGPWireRecHeader) + sizeof(MGPHandleOnly) + 7u) & ~SizeT(7u)),
|
|
"MGPWireRec_SetDispatchProgram gained padding; the wire format moved");
|
|
|
|
struct alignas(8) MGPWireRec_SetResidualValueState {
|
|
MGPWireRecHeader Header;
|
|
MGPResidualValueState Payload;
|
|
};
|
|
static_assert(sizeof(MGPWireRec_SetResidualValueState) ==
|
|
((sizeof(MGPWireRecHeader) + sizeof(MGPResidualValueState) + 7u) & ~SizeT(7u)),
|
|
"MGPWireRec_SetResidualValueState gained padding; the wire format moved");
|
|
|
|
struct alignas(8) MGPWireRec_SetTextureParams {
|
|
MGPWireRecHeader Header;
|
|
MGPTextureParams Payload;
|
|
};
|
|
static_assert(sizeof(MGPWireRec_SetTextureParams) ==
|
|
((sizeof(MGPWireRecHeader) + sizeof(MGPTextureParams) + 7u) & ~SizeT(7u)),
|
|
"MGPWireRec_SetTextureParams gained padding; the wire format moved");
|
|
|
|
struct alignas(8) MGPWireRec_ResourceSubData {
|
|
MGPWireRecHeader Header;
|
|
MGPSubData Payload;
|
|
};
|
|
static_assert(sizeof(MGPWireRec_ResourceSubData) ==
|
|
((sizeof(MGPWireRecHeader) + sizeof(MGPSubData) + 7u) & ~SizeT(7u)),
|
|
"MGPWireRec_ResourceSubData gained padding; the wire format moved");
|
|
|
|
struct alignas(8) MGPWireRec_BufferSubDataResident {
|
|
MGPWireRecHeader Header;
|
|
MGPSubData Payload;
|
|
};
|
|
static_assert(sizeof(MGPWireRec_BufferSubDataResident) ==
|
|
((sizeof(MGPWireRecHeader) + sizeof(MGPSubData) + 7u) & ~SizeT(7u)),
|
|
"MGPWireRec_BufferSubDataResident gained padding; the wire format moved");
|
|
|
|
struct alignas(8) MGPWireRec_ResourceSubDataComplete {
|
|
MGPWireRecHeader Header;
|
|
MGPSubDataComplete Payload;
|
|
};
|
|
static_assert(sizeof(MGPWireRec_ResourceSubDataComplete) ==
|
|
((sizeof(MGPWireRecHeader) + sizeof(MGPSubDataComplete) + 7u) & ~SizeT(7u)),
|
|
"MGPWireRec_ResourceSubDataComplete gained padding; the wire format moved");
|
|
|
|
struct alignas(8) MGPWireRec_ResourceFlushRange {
|
|
MGPWireRecHeader Header;
|
|
MGPFlushRange Payload;
|
|
};
|
|
static_assert(sizeof(MGPWireRec_ResourceFlushRange) ==
|
|
((sizeof(MGPWireRecHeader) + sizeof(MGPFlushRange) + 7u) & ~SizeT(7u)),
|
|
"MGPWireRec_ResourceFlushRange gained padding; the wire format moved");
|
|
|
|
struct alignas(8) MGPWireRec_ResourceReadback {
|
|
MGPWireRecHeader Header;
|
|
MGPReadback Payload;
|
|
};
|
|
static_assert(sizeof(MGPWireRec_ResourceReadback) ==
|
|
((sizeof(MGPWireRecHeader) + sizeof(MGPReadback) + 7u) & ~SizeT(7u)),
|
|
"MGPWireRec_ResourceReadback gained padding; the wire format moved");
|
|
|
|
struct alignas(8) MGPWireRec_ResourceCopyRegion {
|
|
MGPWireRecHeader Header;
|
|
MGPCopyRegion Payload;
|
|
};
|
|
static_assert(sizeof(MGPWireRec_ResourceCopyRegion) ==
|
|
((sizeof(MGPWireRecHeader) + sizeof(MGPCopyRegion) + 7u) & ~SizeT(7u)),
|
|
"MGPWireRec_ResourceCopyRegion gained padding; the wire format moved");
|
|
|
|
struct alignas(8) MGPWireRec_GenerateMipmap {
|
|
MGPWireRecHeader Header;
|
|
MGPMipPlan Payload;
|
|
};
|
|
static_assert(sizeof(MGPWireRec_GenerateMipmap) ==
|
|
((sizeof(MGPWireRecHeader) + sizeof(MGPMipPlan) + 7u) & ~SizeT(7u)),
|
|
"MGPWireRec_GenerateMipmap gained padding; the wire format moved");
|
|
|
|
struct alignas(8) MGPWireRec_GetTextureImage {
|
|
MGPWireRecHeader Header;
|
|
MGPReadbackInfo Payload;
|
|
};
|
|
static_assert(sizeof(MGPWireRec_GetTextureImage) ==
|
|
((sizeof(MGPWireRecHeader) + sizeof(MGPReadbackInfo) + 7u) & ~SizeT(7u)),
|
|
"MGPWireRec_GetTextureImage gained padding; the wire format moved");
|
|
|
|
struct alignas(8) MGPWireRec_Blit {
|
|
MGPWireRecHeader Header;
|
|
MGPBlit Payload;
|
|
};
|
|
static_assert(sizeof(MGPWireRec_Blit) ==
|
|
((sizeof(MGPWireRecHeader) + sizeof(MGPBlit) + 7u) & ~SizeT(7u)),
|
|
"MGPWireRec_Blit gained padding; the wire format moved");
|
|
|
|
struct alignas(8) MGPWireRec_Clear {
|
|
MGPWireRecHeader Header;
|
|
MGPClear Payload;
|
|
};
|
|
static_assert(sizeof(MGPWireRec_Clear) ==
|
|
((sizeof(MGPWireRecHeader) + sizeof(MGPClear) + 7u) & ~SizeT(7u)),
|
|
"MGPWireRec_Clear gained padding; the wire format moved");
|
|
|
|
struct alignas(8) MGPWireRec_ReadPixels {
|
|
MGPWireRecHeader Header;
|
|
MGPReadbackInfo Payload;
|
|
};
|
|
static_assert(sizeof(MGPWireRec_ReadPixels) ==
|
|
((sizeof(MGPWireRecHeader) + sizeof(MGPReadbackInfo) + 7u) & ~SizeT(7u)),
|
|
"MGPWireRec_ReadPixels gained padding; the wire format moved");
|
|
|
|
struct alignas(8) MGPWireRec_DrawVbo {
|
|
MGPWireRecHeader Header;
|
|
MGPDrawInfo Payload;
|
|
};
|
|
static_assert(sizeof(MGPWireRec_DrawVbo) ==
|
|
((sizeof(MGPWireRecHeader) + sizeof(MGPDrawInfo) + 7u) & ~SizeT(7u)),
|
|
"MGPWireRec_DrawVbo gained padding; the wire format moved");
|
|
|
|
struct alignas(8) MGPWireRec_LaunchGrid {
|
|
MGPWireRecHeader Header;
|
|
MGPGridInfo Payload;
|
|
};
|
|
static_assert(sizeof(MGPWireRec_LaunchGrid) ==
|
|
((sizeof(MGPWireRecHeader) + sizeof(MGPGridInfo) + 7u) & ~SizeT(7u)),
|
|
"MGPWireRec_LaunchGrid gained padding; the wire format moved");
|
|
|
|
struct alignas(8) MGPWireRec_MemoryBarrier {
|
|
MGPWireRecHeader Header;
|
|
MGPMemoryBarrier Payload;
|
|
};
|
|
static_assert(sizeof(MGPWireRec_MemoryBarrier) ==
|
|
((sizeof(MGPWireRecHeader) + sizeof(MGPMemoryBarrier) + 7u) & ~SizeT(7u)),
|
|
"MGPWireRec_MemoryBarrier gained padding; the wire format moved");
|
|
|
|
struct alignas(8) MGPWireRec_BeginStreamOutput {
|
|
MGPWireRecHeader Header;
|
|
MGPStreamOutputBegin Payload;
|
|
};
|
|
static_assert(sizeof(MGPWireRec_BeginStreamOutput) ==
|
|
((sizeof(MGPWireRecHeader) + sizeof(MGPStreamOutputBegin) + 7u) & ~SizeT(7u)),
|
|
"MGPWireRec_BeginStreamOutput gained padding; the wire format moved");
|
|
|
|
struct alignas(8) MGPWireRec_EndStreamOutput {
|
|
MGPWireRecHeader Header;
|
|
MGPXfbAccounting Payload;
|
|
};
|
|
static_assert(sizeof(MGPWireRec_EndStreamOutput) ==
|
|
((sizeof(MGPWireRecHeader) + sizeof(MGPXfbAccounting) + 7u) & ~SizeT(7u)),
|
|
"MGPWireRec_EndStreamOutput gained padding; the wire format moved");
|
|
|
|
struct alignas(8) MGPWireRec_PauseStreamOutput {
|
|
MGPWireRecHeader Header;
|
|
MGPStreamOutputControl Payload;
|
|
};
|
|
static_assert(sizeof(MGPWireRec_PauseStreamOutput) ==
|
|
((sizeof(MGPWireRecHeader) + sizeof(MGPStreamOutputControl) + 7u) & ~SizeT(7u)),
|
|
"MGPWireRec_PauseStreamOutput gained padding; the wire format moved");
|
|
|
|
struct alignas(8) MGPWireRec_ResumeStreamOutput {
|
|
MGPWireRecHeader Header;
|
|
MGPStreamOutputControl Payload;
|
|
};
|
|
static_assert(sizeof(MGPWireRec_ResumeStreamOutput) ==
|
|
((sizeof(MGPWireRecHeader) + sizeof(MGPStreamOutputControl) + 7u) & ~SizeT(7u)),
|
|
"MGPWireRec_ResumeStreamOutput gained padding; the wire format moved");
|
|
|
|
struct alignas(8) MGPWireRec_Flush {
|
|
MGPWireRecHeader Header;
|
|
MGPFlush Payload;
|
|
};
|
|
static_assert(sizeof(MGPWireRec_Flush) ==
|
|
((sizeof(MGPWireRecHeader) + sizeof(MGPFlush) + 7u) & ~SizeT(7u)),
|
|
"MGPWireRec_Flush gained padding; the wire format moved");
|
|
|
|
struct alignas(8) MGPWireRec_Present {
|
|
MGPWireRecHeader Header;
|
|
MGPPresent Payload;
|
|
};
|
|
static_assert(sizeof(MGPWireRec_Present) ==
|
|
((sizeof(MGPWireRecHeader) + sizeof(MGPPresent) + 7u) & ~SizeT(7u)),
|
|
"MGPWireRec_Present gained padding; the wire format moved");
|
|
|
|
struct alignas(8) MGPWireRec_SetSwapInterval {
|
|
MGPWireRecHeader Header;
|
|
MGPSwapInterval Payload;
|
|
};
|
|
static_assert(sizeof(MGPWireRec_SetSwapInterval) ==
|
|
((sizeof(MGPWireRecHeader) + sizeof(MGPSwapInterval) + 7u) & ~SizeT(7u)),
|
|
"MGPWireRec_SetSwapInterval gained padding; the wire format moved");
|
|
|
|
struct alignas(8) MGPWireRec_QueryTimestamp {
|
|
MGPWireRecHeader Header;
|
|
MGPTimestampRequest Payload;
|
|
};
|
|
static_assert(sizeof(MGPWireRec_QueryTimestamp) ==
|
|
((sizeof(MGPWireRecHeader) + sizeof(MGPTimestampRequest) + 7u) & ~SizeT(7u)),
|
|
"MGPWireRec_QueryTimestamp gained padding; the wire format moved");
|
|
|
|
struct alignas(8) MGPWireRec_QueryCounter {
|
|
MGPWireRecHeader Header;
|
|
MGPQueryDesc Payload;
|
|
};
|
|
static_assert(sizeof(MGPWireRec_QueryCounter) ==
|
|
((sizeof(MGPWireRecHeader) + sizeof(MGPQueryDesc) + 7u) & ~SizeT(7u)),
|
|
"MGPWireRec_QueryCounter gained padding; the wire format moved");
|
|
|
|
struct alignas(8) MGPWireRec_FenceWaitServer {
|
|
MGPWireRecHeader Header;
|
|
MGPFenceWait Payload;
|
|
};
|
|
static_assert(sizeof(MGPWireRec_FenceWaitServer) ==
|
|
((sizeof(MGPWireRecHeader) + sizeof(MGPFenceWait) + 7u) & ~SizeT(7u)),
|
|
"MGPWireRec_FenceWaitServer gained padding; the wire format moved");
|
|
|
|
[[noreturn]] inline void MGPipeWireProtocolFatal(const char* call, Uint64 size, Uint64 remaining) {
|
|
MGLOG_F("MGPipe: protocol corruption applying %s: size=%llu remaining=%llu", call,
|
|
static_cast<unsigned long long>(size), static_cast<unsigned long long>(remaining));
|
|
std::abort();
|
|
}
|
|
|
|
#define MGP_WIRE_CHECK_BOUNDS(RecType, CallName) \
|
|
do { \
|
|
if (!(size >= sizeof(RecType) && size <= remaining && (size % 8) == 0)) { \
|
|
MGPipeWireProtocolFatal(CallName, size, remaining); \
|
|
} \
|
|
} while (0)
|
|
|
|
// Returns whether the record was applied. P0 is a SKELETON: every case validates its
|
|
// bounds and then reports "not applied", because no applier exists until P5 wires
|
|
// MG_Remote/Server/PipeApplier.cpp to the real backend tables. The switch and the opcode
|
|
// enum come from the same list, so a call added to the catalogue cannot be forgotten here;
|
|
// the default arm is for the opcode that never came from this catalogue at all - a byte
|
|
// off a corrupt stream - and it is fatal for the same reason the bounds check is.
|
|
inline Bool MGPipeApplyWireRecord(MGPWireOp op, const void* record, Uint64 size, Uint64 remaining) {
|
|
(void)record;
|
|
switch (op) {
|
|
case MGPWireOp::GetCaps:
|
|
MGP_WIRE_CHECK_BOUNDS(MGPWireRec_GetCaps, "GetCaps");
|
|
return false;
|
|
case MGPWireOp::ResourceCreate:
|
|
MGP_WIRE_CHECK_BOUNDS(MGPWireRec_ResourceCreate, "ResourceCreate");
|
|
return false;
|
|
case MGPWireOp::ResourceRespecify:
|
|
MGP_WIRE_CHECK_BOUNDS(MGPWireRec_ResourceRespecify, "ResourceRespecify");
|
|
return false;
|
|
case MGPWireOp::ResourceDestroy:
|
|
MGP_WIRE_CHECK_BOUNDS(MGPWireRec_ResourceDestroy, "ResourceDestroy");
|
|
return false;
|
|
case MGPWireOp::MapPersistent:
|
|
MGP_WIRE_CHECK_BOUNDS(MGPWireRec_MapPersistent, "MapPersistent");
|
|
return false;
|
|
case MGPWireOp::UnmapPersistent:
|
|
MGP_WIRE_CHECK_BOUNDS(MGPWireRec_UnmapPersistent, "UnmapPersistent");
|
|
return false;
|
|
case MGPWireOp::FenceCreate:
|
|
MGP_WIRE_CHECK_BOUNDS(MGPWireRec_FenceCreate, "FenceCreate");
|
|
return false;
|
|
case MGPWireOp::FenceStatus:
|
|
MGP_WIRE_CHECK_BOUNDS(MGPWireRec_FenceStatus, "FenceStatus");
|
|
return false;
|
|
case MGPWireOp::FenceWait:
|
|
MGP_WIRE_CHECK_BOUNDS(MGPWireRec_FenceWait, "FenceWait");
|
|
return false;
|
|
case MGPWireOp::FenceDestroy:
|
|
MGP_WIRE_CHECK_BOUNDS(MGPWireRec_FenceDestroy, "FenceDestroy");
|
|
return false;
|
|
case MGPWireOp::QueryCreate:
|
|
MGP_WIRE_CHECK_BOUNDS(MGPWireRec_QueryCreate, "QueryCreate");
|
|
return false;
|
|
case MGPWireOp::QueryBegin:
|
|
MGP_WIRE_CHECK_BOUNDS(MGPWireRec_QueryBegin, "QueryBegin");
|
|
return false;
|
|
case MGPWireOp::QueryEnd:
|
|
MGP_WIRE_CHECK_BOUNDS(MGPWireRec_QueryEnd, "QueryEnd");
|
|
return false;
|
|
case MGPWireOp::QueryAvailable:
|
|
MGP_WIRE_CHECK_BOUNDS(MGPWireRec_QueryAvailable, "QueryAvailable");
|
|
return false;
|
|
case MGPWireOp::QueryResult:
|
|
MGP_WIRE_CHECK_BOUNDS(MGPWireRec_QueryResult, "QueryResult");
|
|
return false;
|
|
case MGPWireOp::QueryDestroy:
|
|
MGP_WIRE_CHECK_BOUNDS(MGPWireRec_QueryDestroy, "QueryDestroy");
|
|
return false;
|
|
case MGPWireOp::CreateRenderState:
|
|
MGP_WIRE_CHECK_BOUNDS(MGPWireRec_CreateRenderState, "CreateRenderState");
|
|
return false;
|
|
case MGPWireOp::BindRenderState:
|
|
MGP_WIRE_CHECK_BOUNDS(MGPWireRec_BindRenderState, "BindRenderState");
|
|
return false;
|
|
case MGPWireOp::DeleteRenderState:
|
|
MGP_WIRE_CHECK_BOUNDS(MGPWireRec_DeleteRenderState, "DeleteRenderState");
|
|
return false;
|
|
case MGPWireOp::CreateVertexElements:
|
|
MGP_WIRE_CHECK_BOUNDS(MGPWireRec_CreateVertexElements, "CreateVertexElements");
|
|
return false;
|
|
case MGPWireOp::BindVertexElements:
|
|
MGP_WIRE_CHECK_BOUNDS(MGPWireRec_BindVertexElements, "BindVertexElements");
|
|
return false;
|
|
case MGPWireOp::DeleteVertexElements:
|
|
MGP_WIRE_CHECK_BOUNDS(MGPWireRec_DeleteVertexElements, "DeleteVertexElements");
|
|
return false;
|
|
case MGPWireOp::CreateSamplerState:
|
|
MGP_WIRE_CHECK_BOUNDS(MGPWireRec_CreateSamplerState, "CreateSamplerState");
|
|
return false;
|
|
case MGPWireOp::DeleteSamplerState:
|
|
MGP_WIRE_CHECK_BOUNDS(MGPWireRec_DeleteSamplerState, "DeleteSamplerState");
|
|
return false;
|
|
case MGPWireOp::CreateSamplerView:
|
|
MGP_WIRE_CHECK_BOUNDS(MGPWireRec_CreateSamplerView, "CreateSamplerView");
|
|
return false;
|
|
case MGPWireOp::DeleteSamplerView:
|
|
MGP_WIRE_CHECK_BOUNDS(MGPWireRec_DeleteSamplerView, "DeleteSamplerView");
|
|
return false;
|
|
case MGPWireOp::CreateShaderState:
|
|
MGP_WIRE_CHECK_BOUNDS(MGPWireRec_CreateShaderState, "CreateShaderState");
|
|
return false;
|
|
case MGPWireOp::BindShaderState:
|
|
MGP_WIRE_CHECK_BOUNDS(MGPWireRec_BindShaderState, "BindShaderState");
|
|
return false;
|
|
case MGPWireOp::DeleteShaderState:
|
|
MGP_WIRE_CHECK_BOUNDS(MGPWireRec_DeleteShaderState, "DeleteShaderState");
|
|
return false;
|
|
case MGPWireOp::SetDynamicState:
|
|
MGP_WIRE_CHECK_BOUNDS(MGPWireRec_SetDynamicState, "SetDynamicState");
|
|
return false;
|
|
case MGPWireOp::SetFramebufferState:
|
|
MGP_WIRE_CHECK_BOUNDS(MGPWireRec_SetFramebufferState, "SetFramebufferState");
|
|
return false;
|
|
case MGPWireOp::SetVertexBuffers:
|
|
MGP_WIRE_CHECK_BOUNDS(MGPWireRec_SetVertexBuffers, "SetVertexBuffers");
|
|
return false;
|
|
case MGPWireOp::SetIndexBuffer:
|
|
MGP_WIRE_CHECK_BOUNDS(MGPWireRec_SetIndexBuffer, "SetIndexBuffer");
|
|
return false;
|
|
case MGPWireOp::SetIndirectBuffers:
|
|
MGP_WIRE_CHECK_BOUNDS(MGPWireRec_SetIndirectBuffers, "SetIndirectBuffers");
|
|
return false;
|
|
case MGPWireOp::SetSamplerViews:
|
|
MGP_WIRE_CHECK_BOUNDS(MGPWireRec_SetSamplerViews, "SetSamplerViews");
|
|
return false;
|
|
case MGPWireOp::BindSamplerStates:
|
|
MGP_WIRE_CHECK_BOUNDS(MGPWireRec_BindSamplerStates, "BindSamplerStates");
|
|
return false;
|
|
case MGPWireOp::SetShaderImages:
|
|
MGP_WIRE_CHECK_BOUNDS(MGPWireRec_SetShaderImages, "SetShaderImages");
|
|
return false;
|
|
case MGPWireOp::SetShaderBuffers:
|
|
MGP_WIRE_CHECK_BOUNDS(MGPWireRec_SetShaderBuffers, "SetShaderBuffers");
|
|
return false;
|
|
case MGPWireOp::SetStreamOutputTargets:
|
|
MGP_WIRE_CHECK_BOUNDS(MGPWireRec_SetStreamOutputTargets, "SetStreamOutputTargets");
|
|
return false;
|
|
case MGPWireOp::SetGlobalConstants:
|
|
MGP_WIRE_CHECK_BOUNDS(MGPWireRec_SetGlobalConstants, "SetGlobalConstants");
|
|
return false;
|
|
case MGPWireOp::SetVertexAttribDefaults:
|
|
MGP_WIRE_CHECK_BOUNDS(MGPWireRec_SetVertexAttribDefaults, "SetVertexAttribDefaults");
|
|
return false;
|
|
case MGPWireOp::SetPixelPackState:
|
|
MGP_WIRE_CHECK_BOUNDS(MGPWireRec_SetPixelPackState, "SetPixelPackState");
|
|
return false;
|
|
case MGPWireOp::SetPatchState:
|
|
MGP_WIRE_CHECK_BOUNDS(MGPWireRec_SetPatchState, "SetPatchState");
|
|
return false;
|
|
case MGPWireOp::SetDrawProgram:
|
|
MGP_WIRE_CHECK_BOUNDS(MGPWireRec_SetDrawProgram, "SetDrawProgram");
|
|
return false;
|
|
case MGPWireOp::SetDispatchProgram:
|
|
MGP_WIRE_CHECK_BOUNDS(MGPWireRec_SetDispatchProgram, "SetDispatchProgram");
|
|
return false;
|
|
case MGPWireOp::SetResidualValueState:
|
|
MGP_WIRE_CHECK_BOUNDS(MGPWireRec_SetResidualValueState, "SetResidualValueState");
|
|
return false;
|
|
case MGPWireOp::SetTextureParams:
|
|
MGP_WIRE_CHECK_BOUNDS(MGPWireRec_SetTextureParams, "SetTextureParams");
|
|
return false;
|
|
case MGPWireOp::ResourceSubData:
|
|
MGP_WIRE_CHECK_BOUNDS(MGPWireRec_ResourceSubData, "ResourceSubData");
|
|
return false;
|
|
case MGPWireOp::BufferSubDataResident:
|
|
MGP_WIRE_CHECK_BOUNDS(MGPWireRec_BufferSubDataResident, "BufferSubDataResident");
|
|
return false;
|
|
case MGPWireOp::ResourceSubDataComplete:
|
|
MGP_WIRE_CHECK_BOUNDS(MGPWireRec_ResourceSubDataComplete, "ResourceSubDataComplete");
|
|
return false;
|
|
case MGPWireOp::ResourceFlushRange:
|
|
MGP_WIRE_CHECK_BOUNDS(MGPWireRec_ResourceFlushRange, "ResourceFlushRange");
|
|
return false;
|
|
case MGPWireOp::ResourceReadback:
|
|
MGP_WIRE_CHECK_BOUNDS(MGPWireRec_ResourceReadback, "ResourceReadback");
|
|
return false;
|
|
case MGPWireOp::ResourceCopyRegion:
|
|
MGP_WIRE_CHECK_BOUNDS(MGPWireRec_ResourceCopyRegion, "ResourceCopyRegion");
|
|
return false;
|
|
case MGPWireOp::GenerateMipmap:
|
|
MGP_WIRE_CHECK_BOUNDS(MGPWireRec_GenerateMipmap, "GenerateMipmap");
|
|
return false;
|
|
case MGPWireOp::GetTextureImage:
|
|
MGP_WIRE_CHECK_BOUNDS(MGPWireRec_GetTextureImage, "GetTextureImage");
|
|
return false;
|
|
case MGPWireOp::Blit:
|
|
MGP_WIRE_CHECK_BOUNDS(MGPWireRec_Blit, "Blit");
|
|
return false;
|
|
case MGPWireOp::Clear:
|
|
MGP_WIRE_CHECK_BOUNDS(MGPWireRec_Clear, "Clear");
|
|
return false;
|
|
case MGPWireOp::ReadPixels:
|
|
MGP_WIRE_CHECK_BOUNDS(MGPWireRec_ReadPixels, "ReadPixels");
|
|
return false;
|
|
case MGPWireOp::DrawVbo:
|
|
MGP_WIRE_CHECK_BOUNDS(MGPWireRec_DrawVbo, "DrawVbo");
|
|
return false;
|
|
case MGPWireOp::LaunchGrid:
|
|
MGP_WIRE_CHECK_BOUNDS(MGPWireRec_LaunchGrid, "LaunchGrid");
|
|
return false;
|
|
case MGPWireOp::MemoryBarrier:
|
|
MGP_WIRE_CHECK_BOUNDS(MGPWireRec_MemoryBarrier, "MemoryBarrier");
|
|
return false;
|
|
case MGPWireOp::BeginStreamOutput:
|
|
MGP_WIRE_CHECK_BOUNDS(MGPWireRec_BeginStreamOutput, "BeginStreamOutput");
|
|
return false;
|
|
case MGPWireOp::EndStreamOutput:
|
|
MGP_WIRE_CHECK_BOUNDS(MGPWireRec_EndStreamOutput, "EndStreamOutput");
|
|
return false;
|
|
case MGPWireOp::PauseStreamOutput:
|
|
MGP_WIRE_CHECK_BOUNDS(MGPWireRec_PauseStreamOutput, "PauseStreamOutput");
|
|
return false;
|
|
case MGPWireOp::ResumeStreamOutput:
|
|
MGP_WIRE_CHECK_BOUNDS(MGPWireRec_ResumeStreamOutput, "ResumeStreamOutput");
|
|
return false;
|
|
case MGPWireOp::Flush:
|
|
MGP_WIRE_CHECK_BOUNDS(MGPWireRec_Flush, "Flush");
|
|
return false;
|
|
case MGPWireOp::Present:
|
|
MGP_WIRE_CHECK_BOUNDS(MGPWireRec_Present, "Present");
|
|
return false;
|
|
case MGPWireOp::SetSwapInterval:
|
|
MGP_WIRE_CHECK_BOUNDS(MGPWireRec_SetSwapInterval, "SetSwapInterval");
|
|
return false;
|
|
case MGPWireOp::QueryTimestamp:
|
|
MGP_WIRE_CHECK_BOUNDS(MGPWireRec_QueryTimestamp, "QueryTimestamp");
|
|
return false;
|
|
case MGPWireOp::QueryCounter:
|
|
MGP_WIRE_CHECK_BOUNDS(MGPWireRec_QueryCounter, "QueryCounter");
|
|
return false;
|
|
case MGPWireOp::FenceWaitServer:
|
|
MGP_WIRE_CHECK_BOUNDS(MGPWireRec_FenceWaitServer, "FenceWaitServer");
|
|
return false;
|
|
case MGPWireOp::kInvalid:
|
|
case MGPWireOp::kOpCount:
|
|
default:
|
|
MGPipeWireProtocolFatal("<unknown opcode>", size, remaining);
|
|
}
|
|
}
|
|
|
|
#undef MGP_WIRE_CHECK_BOUNDS
|