From 46b40365e53a293c5348febe1091fc0e90e437a3 Mon Sep 17 00:00:00 2001 From: Panos Stergiotis Date: Wed, 24 Jul 2024 21:47:46 +0200 Subject: [PATCH] wip: video --- skia/build_cpp.sh | 2 +- skia/skia/video/app.cpp | 114 +- skia/skia/video/app.h | 2 +- skia/skia/video/userInteraction_generated.h | 1080 ++++++++++++++++++ skia/video_userinput.sh | 24 + skia/video_userinput2.sh | 32 + video_player/build_cpp.sh | 2 +- video_player/common.dhall | 6 +- video_player/sdl3_mpv/app.cpp | 51 +- video_player/sdl3_mpv/app.h | 8 +- video_player/spec/userInteraction.fbs | 6 + video_player/src/userInteraction_generated.h | 355 +++++- 12 files changed, 1624 insertions(+), 58 deletions(-) create mode 100644 skia/skia/video/userInteraction_generated.h create mode 100755 skia/video_userinput.sh create mode 100755 skia/video_userinput2.sh diff --git a/skia/build_cpp.sh b/skia/build_cpp.sh index a48723c..1534c09 100755 --- a/skia/build_cpp.sh +++ b/skia/build_cpp.sh @@ -4,7 +4,7 @@ here=$(dirname "$(readlink -f "$BASH_SOURCE")") cd "$here" flatc="../../contrib/flatbuffers/flatc" "$flatc" -o imgui --cpp imgui/vectorCmd.fbs -"$flatc" -o skia/video --cpp ../video_player/spec/userInteraction.fbs +"$flatc" -o skia/video --cpp ../video_player/spec/userInteraction.fbs --reflect-types --reflect-names ./cmakelists.dhall diff --git a/skia/skia/video/app.cpp b/skia/skia/video/app.cpp index dcf1a7f..11a62dc 100644 --- a/skia/skia/video/app.cpp +++ b/skia/skia/video/app.cpp @@ -25,6 +25,8 @@ #include "marshalling/receive.h" #include "marshalling/send.h" +#include "flatbuffers/minireflect.h" + #define QOI_IMPLEMENTATION #define QOI_NO_STDIO #define QOI_FREE static_assert(false && "free should never be called") @@ -275,6 +277,29 @@ int App::run(CliOptions &opts) { } fBackgroundColor = SkColorSetARGB(clearColorImVec4.w * 255.0f, clearColorImVec4.x * 255.0f, clearColorImVec4.y * 255.0f, clearColorImVec4.z * 255.0f); + if(opts.videoUserInteractionEventsInFile != nullptr && opts.videoUserInteractionEventsInFile[0] != '\0') { + fUserInteractionFH = fopen(opts.videoUserInteractionEventsInFile, "rb"); + if(fUserInteractionFH == nullptr) { + fprintf(stderr, "unable to open user interaction events in file %s: %s\n", opts.videoUserInteractionEventsInFile, strerror(errno)); + return 1; + } + + auto const fd = fileno(fUserInteractionFH); + auto const flags = fcntl(fd, F_GETFL); + if(flags < 0) { + fprintf(stderr, "unable to get file status flags for file %s: %s\n", opts.videoUserInteractionEventsInFile, strerror(errno)); + return 1; + } + if(fcntl(fd, F_SETFL, flags | O_NONBLOCK) < 0) { + fprintf(stderr, "unable to set file status flag O_NONBLOCK file %s: %s\n", opts.videoUserInteractionEventsInFile, strerror(errno)); + return 1; + } + //if(setvbuf(fUserInteractionFH,nullptr,_IONBF,0) != 0) { + // fprintf(stderr, "unable to set buffering for file %s: %s\n", opts.videoUserInteractionEventsInFile, strerror(errno)); + // return 1; + //} + } + switch(fOutputFormat) { case kRawFrameOutputFormat_None: loopEmpty(opts); @@ -306,28 +331,6 @@ int App::run(CliOptions &opts) { loopSkp(opts); break; } - if(opts.videoUserInteractionEventsInFile != nullptr && opts.videoUserInteractionEventsInFile[0] != '\0') { - fUserInteractionFH = fopen(opts.videoUserInteractionEventsInFile, "rb"); - if(fUserInteractionFH == nullptr) { - fprintf(stderr, "unable to open user interaction events in file %s: %s\n", opts.videoUserInteractionEventsInFile, strerror(errno)); - return 1; - } - - auto const fd = fileno(fUserInteractionFH); - auto const flags = fcntl(fd, F_GETFL); - if(flags < 0) { - fprintf(stderr, "unable to get file status flags for file %s: %s\n", opts.videoUserInteractionEventsInFile, strerror(errno)); - return 1; - } - if(fcntl(fd, F_SETFL, flags | O_NONBLOCK) < 0) { - fprintf(stderr, "unable to set file status flag O_NONBLOCK file %s: %s\n", opts.videoUserInteractionEventsInFile, strerror(errno)); - return 1; - } - if(setvbuf(fUserInteractionFH,nullptr,_IONBF,0) != 0) { - fprintf(stderr, "unable to set buffering for file %s: %s\n", opts.videoUserInteractionEventsInFile, strerror(errno)); - return 1; - } - } if(opts.fffiInterpreter) { render_cleanup(); @@ -342,6 +345,7 @@ void App::postPaint() { io.DeltaTime = static_cast(currentTime - fPreviousTime); fPreviousTime = currentTime; fFrame++; + dispatchUserInteractionEvents(); } App::App() { @@ -649,11 +653,16 @@ App::~App() { } void App::dispatchUserInteractionEvents() { - size_t memorySize = 1024 * 1024; + static size_t memorySize = 1024 * 1024; static uint8_t state = 0; static uint8_t* mem = nullptr; static uint8_t* p = nullptr; static uint32_t bytesToRead = 0; + constexpr const int sizeOfLengthPrefix = 4; + + if(fUserInteractionFH == nullptr) { + return; + } while(true) { switch(state) { @@ -664,12 +673,15 @@ void App::dispatchUserInteractionEvents() { exit(2); } state = 1; - bytesToRead = 4; + bytesToRead = sizeOfLengthPrefix; p = mem; break; case 1: // read flatbuffers message length { auto r = fread(p,1,bytesToRead,fUserInteractionFH); + if(r <= 0) { + return; + } bytesToRead -= r; p += r; if(bytesToRead == 0) { @@ -678,7 +690,7 @@ void App::dispatchUserInteractionEvents() { if(bytesToRead > memorySize) { memorySize = (bytesToRead/4096+1)*4096; mem = static_cast(realloc(mem, memorySize)); - p = mem+4; + p = mem+sizeOfLengthPrefix; } state = 2; } @@ -686,15 +698,25 @@ void App::dispatchUserInteractionEvents() { break; case 2: // read flatbuffers message { + //fprintf(stderr, "reading message of size %d\n", (int)bytesToRead); auto r = fread(p,1,bytesToRead,fUserInteractionFH); bytesToRead -= r; p += r; if(bytesToRead == 0) { - auto const e = UserInteractionFB::GetSizePrefixedEvent(mem); - handleUserInteractionEvent(*e); - state = 1; - p = mem; - bytesToRead = 4; + auto verifier = flatbuffers::Verifier(mem+sizeOfLengthPrefix,bytesToRead); + if(!UserInteractionFB::VerifyEventBuffer(verifier)) { + auto txt = flatbuffers::FlatBufferToString(mem+sizeOfLengthPrefix,UserInteractionFB::EventTypeTable()); + fprintf(stderr, "userInteractionEvent=%s\n", txt.c_str()); + + auto const e = UserInteractionFB::GetSizePrefixedEvent(mem); + handleUserInteractionEvent(*e); + state = 1; + p = mem; + bytesToRead = sizeOfLengthPrefix; + } else { + fprintf(stderr, "received corrupt user interaction event!\n"); + exit(1); + } } } break; @@ -703,22 +725,54 @@ void App::dispatchUserInteractionEvents() { } void App::handleUserInteractionEvent(UserInteractionFB::Event const &ev) { + ImGuiIO& io = ImGui::GetIO(); + fprintf(stderr, "handling user interaction event %s\n",EnumNameUserInteraction(ev.event_type())); switch(ev.event_type()) { case UserInteractionFB::UserInteraction_NONE: break; case UserInteractionFB::UserInteraction_EventMouseMotion: { auto const e = ev.event_as_EventMouseMotion(); + io.AddMouseSourceEvent(e->is_touch() ? ImGuiMouseSource_TouchScreen : ImGuiMouseSource_Mouse); + auto const p = e->pos(); + io.AddMousePosEvent(p->x(), p->y()); } break; case UserInteractionFB::UserInteraction_EventMouseWheel: { auto const e = ev.event_as_EventMouseMotion(); + io.AddMouseSourceEvent(e->is_touch() ? ImGuiMouseSource_TouchScreen : ImGuiMouseSource_Mouse); + auto const p = e->pos(); + io.AddMouseWheelEvent(-p->x(), p->y()); } break; case UserInteractionFB::UserInteraction_EventMouseButton: { auto const e = ev.event_as_EventMouseButton(); + int mb = -1; + auto const b = e->button(); + switch(b) { + case UserInteractionFB::MouseButton_None: break; + case UserInteractionFB::MouseButton_Left: mb = 0; break; + case UserInteractionFB::MouseButton_Right: mb = 1; break; + case UserInteractionFB::MouseButton_Middle: mb = 2; break; + case UserInteractionFB::MouseButton_X1: mb = 3; break; + case UserInteractionFB::MouseButton_X2: mb = 4; break; + } + if (mb >= 0) { + auto const d = e->type() == UserInteractionFB::MouseButtonEventType_Down; + io.AddMouseSourceEvent(e->is_touch() ? ImGuiMouseSource_TouchScreen : ImGuiMouseSource_Mouse); + io.AddMouseButtonEvent(mb, d); + //bd->MouseButtonsDown = d ? (bd->MouseButtonsDown | (1 << mb)) : (bd->MouseButtonsDown & ~(1 << mb)); + } + } + break; + case UserInteractionFB::UserInteraction_EventTextInput: + { + auto const e = ev.event_as_EventTextInput(); + auto const t = e->text(); + + io.AddInputCharactersUTF8(e->text()->c_str()); } break; } diff --git a/skia/skia/video/app.h b/skia/skia/video/app.h index 3d56e7f..2e57e1c 100644 --- a/skia/skia/video/app.h +++ b/skia/skia/video/app.h @@ -41,7 +41,7 @@ class App { void loopSvg(CliOptions const &opts); void loopSkp(CliOptions const &opts); void dispatchUserInteractionEvents(); - void handleUserInteractionEvent(UserInteractionFB::Event const &ev); + static void handleUserInteractionEvent(UserInteractionFB::Event const &ev); SkPaint fFontPaint; VectorCmdSkiaRenderer fVectorCmdSkiaRenderer; diff --git a/skia/skia/video/userInteraction_generated.h b/skia/skia/video/userInteraction_generated.h new file mode 100644 index 0000000..b6d3c78 --- /dev/null +++ b/skia/skia/video/userInteraction_generated.h @@ -0,0 +1,1080 @@ +// automatically generated by the FlatBuffers compiler, do not modify + + +#ifndef FLATBUFFERS_GENERATED_USERINTERACTION_USERINTERACTIONFB_H_ +#define FLATBUFFERS_GENERATED_USERINTERACTION_USERINTERACTIONFB_H_ + +#include "flatbuffers/flatbuffers.h" + +// Ensure the included flatbuffers.h is the same version as when this file was +// generated, otherwise it may not be compatible. +static_assert(FLATBUFFERS_VERSION_MAJOR == 23 && + FLATBUFFERS_VERSION_MINOR == 5 && + FLATBUFFERS_VERSION_REVISION == 26, + "Non-compatible flatbuffers version included"); + +namespace UserInteractionFB { + +struct SingleVec2; + +struct SingleVec4; + +struct ArrayOfVec2; +struct ArrayOfVec2Builder; + +struct ArrayOfVec4; +struct ArrayOfVec4Builder; + +struct EventMouseMotion; +struct EventMouseMotionBuilder; + +struct EventMouseWheel; +struct EventMouseWheelBuilder; + +struct EventMouseButton; +struct EventMouseButtonBuilder; + +struct EventTextInput; +struct EventTextInputBuilder; + +struct Event; +struct EventBuilder; + +inline const ::flatbuffers::TypeTable *SingleVec2TypeTable(); + +inline const ::flatbuffers::TypeTable *SingleVec4TypeTable(); + +inline const ::flatbuffers::TypeTable *ArrayOfVec2TypeTable(); + +inline const ::flatbuffers::TypeTable *ArrayOfVec4TypeTable(); + +inline const ::flatbuffers::TypeTable *EventMouseMotionTypeTable(); + +inline const ::flatbuffers::TypeTable *EventMouseWheelTypeTable(); + +inline const ::flatbuffers::TypeTable *EventMouseButtonTypeTable(); + +inline const ::flatbuffers::TypeTable *EventTextInputTypeTable(); + +inline const ::flatbuffers::TypeTable *EventTypeTable(); + +enum MouseButton : uint8_t { + MouseButton_None = 0, + MouseButton_Left = 1, + MouseButton_Right = 2, + MouseButton_Middle = 3, + MouseButton_X1 = 4, + MouseButton_X2 = 5, + MouseButton_MIN = MouseButton_None, + MouseButton_MAX = MouseButton_X2 +}; + +inline const MouseButton (&EnumValuesMouseButton())[6] { + static const MouseButton values[] = { + MouseButton_None, + MouseButton_Left, + MouseButton_Right, + MouseButton_Middle, + MouseButton_X1, + MouseButton_X2 + }; + return values; +} + +inline const char * const *EnumNamesMouseButton() { + static const char * const names[7] = { + "None", + "Left", + "Right", + "Middle", + "X1", + "X2", + nullptr + }; + return names; +} + +inline const char *EnumNameMouseButton(MouseButton e) { + if (::flatbuffers::IsOutRange(e, MouseButton_None, MouseButton_X2)) return ""; + const size_t index = static_cast(e); + return EnumNamesMouseButton()[index]; +} + +enum MouseButtonEventType : uint8_t { + MouseButtonEventType_Up = 0, + MouseButtonEventType_Down = 1, + MouseButtonEventType_MIN = MouseButtonEventType_Up, + MouseButtonEventType_MAX = MouseButtonEventType_Down +}; + +inline const MouseButtonEventType (&EnumValuesMouseButtonEventType())[2] { + static const MouseButtonEventType values[] = { + MouseButtonEventType_Up, + MouseButtonEventType_Down + }; + return values; +} + +inline const char * const *EnumNamesMouseButtonEventType() { + static const char * const names[3] = { + "Up", + "Down", + nullptr + }; + return names; +} + +inline const char *EnumNameMouseButtonEventType(MouseButtonEventType e) { + if (::flatbuffers::IsOutRange(e, MouseButtonEventType_Up, MouseButtonEventType_Down)) return ""; + const size_t index = static_cast(e); + return EnumNamesMouseButtonEventType()[index]; +} + +enum UserInteraction : uint8_t { + UserInteraction_NONE = 0, + UserInteraction_EventMouseMotion = 1, + UserInteraction_EventMouseWheel = 2, + UserInteraction_EventMouseButton = 3, + UserInteraction_EventTextInput = 4, + UserInteraction_MIN = UserInteraction_NONE, + UserInteraction_MAX = UserInteraction_EventTextInput +}; + +inline const UserInteraction (&EnumValuesUserInteraction())[5] { + static const UserInteraction values[] = { + UserInteraction_NONE, + UserInteraction_EventMouseMotion, + UserInteraction_EventMouseWheel, + UserInteraction_EventMouseButton, + UserInteraction_EventTextInput + }; + return values; +} + +inline const char * const *EnumNamesUserInteraction() { + static const char * const names[6] = { + "NONE", + "EventMouseMotion", + "EventMouseWheel", + "EventMouseButton", + "EventTextInput", + nullptr + }; + return names; +} + +inline const char *EnumNameUserInteraction(UserInteraction e) { + if (::flatbuffers::IsOutRange(e, UserInteraction_NONE, UserInteraction_EventTextInput)) return ""; + const size_t index = static_cast(e); + return EnumNamesUserInteraction()[index]; +} + +template struct UserInteractionTraits { + static const UserInteraction enum_value = UserInteraction_NONE; +}; + +template<> struct UserInteractionTraits { + static const UserInteraction enum_value = UserInteraction_EventMouseMotion; +}; + +template<> struct UserInteractionTraits { + static const UserInteraction enum_value = UserInteraction_EventMouseWheel; +}; + +template<> struct UserInteractionTraits { + static const UserInteraction enum_value = UserInteraction_EventMouseButton; +}; + +template<> struct UserInteractionTraits { + static const UserInteraction enum_value = UserInteraction_EventTextInput; +}; + +bool VerifyUserInteraction(::flatbuffers::Verifier &verifier, const void *obj, UserInteraction type); +bool VerifyUserInteractionVector(::flatbuffers::Verifier &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset> *values, const ::flatbuffers::Vector *types); + +FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(4) SingleVec2 FLATBUFFERS_FINAL_CLASS { + private: + float x_; + float y_; + + public: + static const ::flatbuffers::TypeTable *MiniReflectTypeTable() { + return SingleVec2TypeTable(); + } + SingleVec2() + : x_(0), + y_(0) { + } + SingleVec2(float _x, float _y) + : x_(::flatbuffers::EndianScalar(_x)), + y_(::flatbuffers::EndianScalar(_y)) { + } + float x() const { + return ::flatbuffers::EndianScalar(x_); + } + float y() const { + return ::flatbuffers::EndianScalar(y_); + } +}; +FLATBUFFERS_STRUCT_END(SingleVec2, 8); + +FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(4) SingleVec4 FLATBUFFERS_FINAL_CLASS { + private: + float x_; + float y_; + float z_; + float w_; + + public: + static const ::flatbuffers::TypeTable *MiniReflectTypeTable() { + return SingleVec4TypeTable(); + } + SingleVec4() + : x_(0), + y_(0), + z_(0), + w_(0) { + } + SingleVec4(float _x, float _y, float _z, float _w) + : x_(::flatbuffers::EndianScalar(_x)), + y_(::flatbuffers::EndianScalar(_y)), + z_(::flatbuffers::EndianScalar(_z)), + w_(::flatbuffers::EndianScalar(_w)) { + } + float x() const { + return ::flatbuffers::EndianScalar(x_); + } + float y() const { + return ::flatbuffers::EndianScalar(y_); + } + float z() const { + return ::flatbuffers::EndianScalar(z_); + } + float w() const { + return ::flatbuffers::EndianScalar(w_); + } +}; +FLATBUFFERS_STRUCT_END(SingleVec4, 16); + +struct ArrayOfVec2 FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { + typedef ArrayOfVec2Builder Builder; + static const ::flatbuffers::TypeTable *MiniReflectTypeTable() { + return ArrayOfVec2TypeTable(); + } + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_XS = 4, + VT_YS = 6 + }; + const ::flatbuffers::Vector *xs() const { + return GetPointer *>(VT_XS); + } + const ::flatbuffers::Vector *ys() const { + return GetPointer *>(VT_YS); + } + bool Verify(::flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyOffset(verifier, VT_XS) && + verifier.VerifyVector(xs()) && + VerifyOffset(verifier, VT_YS) && + verifier.VerifyVector(ys()) && + verifier.EndTable(); + } +}; + +struct ArrayOfVec2Builder { + typedef ArrayOfVec2 Table; + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; + void add_xs(::flatbuffers::Offset<::flatbuffers::Vector> xs) { + fbb_.AddOffset(ArrayOfVec2::VT_XS, xs); + } + void add_ys(::flatbuffers::Offset<::flatbuffers::Vector> ys) { + fbb_.AddOffset(ArrayOfVec2::VT_YS, ys); + } + explicit ArrayOfVec2Builder(::flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + ::flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = ::flatbuffers::Offset(end); + return o; + } +}; + +inline ::flatbuffers::Offset CreateArrayOfVec2( + ::flatbuffers::FlatBufferBuilder &_fbb, + ::flatbuffers::Offset<::flatbuffers::Vector> xs = 0, + ::flatbuffers::Offset<::flatbuffers::Vector> ys = 0) { + ArrayOfVec2Builder builder_(_fbb); + builder_.add_ys(ys); + builder_.add_xs(xs); + return builder_.Finish(); +} + +inline ::flatbuffers::Offset CreateArrayOfVec2Direct( + ::flatbuffers::FlatBufferBuilder &_fbb, + const std::vector *xs = nullptr, + const std::vector *ys = nullptr) { + auto xs__ = xs ? _fbb.CreateVector(*xs) : 0; + auto ys__ = ys ? _fbb.CreateVector(*ys) : 0; + return UserInteractionFB::CreateArrayOfVec2( + _fbb, + xs__, + ys__); +} + +struct ArrayOfVec4 FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { + typedef ArrayOfVec4Builder Builder; + static const ::flatbuffers::TypeTable *MiniReflectTypeTable() { + return ArrayOfVec4TypeTable(); + } + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_XS = 4, + VT_YS = 6, + VT_ZS = 8, + VT_WS = 10 + }; + const ::flatbuffers::Vector *xs() const { + return GetPointer *>(VT_XS); + } + const ::flatbuffers::Vector *ys() const { + return GetPointer *>(VT_YS); + } + const ::flatbuffers::Vector *zs() const { + return GetPointer *>(VT_ZS); + } + const ::flatbuffers::Vector *ws() const { + return GetPointer *>(VT_WS); + } + bool Verify(::flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyOffset(verifier, VT_XS) && + verifier.VerifyVector(xs()) && + VerifyOffset(verifier, VT_YS) && + verifier.VerifyVector(ys()) && + VerifyOffset(verifier, VT_ZS) && + verifier.VerifyVector(zs()) && + VerifyOffset(verifier, VT_WS) && + verifier.VerifyVector(ws()) && + verifier.EndTable(); + } +}; + +struct ArrayOfVec4Builder { + typedef ArrayOfVec4 Table; + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; + void add_xs(::flatbuffers::Offset<::flatbuffers::Vector> xs) { + fbb_.AddOffset(ArrayOfVec4::VT_XS, xs); + } + void add_ys(::flatbuffers::Offset<::flatbuffers::Vector> ys) { + fbb_.AddOffset(ArrayOfVec4::VT_YS, ys); + } + void add_zs(::flatbuffers::Offset<::flatbuffers::Vector> zs) { + fbb_.AddOffset(ArrayOfVec4::VT_ZS, zs); + } + void add_ws(::flatbuffers::Offset<::flatbuffers::Vector> ws) { + fbb_.AddOffset(ArrayOfVec4::VT_WS, ws); + } + explicit ArrayOfVec4Builder(::flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + ::flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = ::flatbuffers::Offset(end); + return o; + } +}; + +inline ::flatbuffers::Offset CreateArrayOfVec4( + ::flatbuffers::FlatBufferBuilder &_fbb, + ::flatbuffers::Offset<::flatbuffers::Vector> xs = 0, + ::flatbuffers::Offset<::flatbuffers::Vector> ys = 0, + ::flatbuffers::Offset<::flatbuffers::Vector> zs = 0, + ::flatbuffers::Offset<::flatbuffers::Vector> ws = 0) { + ArrayOfVec4Builder builder_(_fbb); + builder_.add_ws(ws); + builder_.add_zs(zs); + builder_.add_ys(ys); + builder_.add_xs(xs); + return builder_.Finish(); +} + +inline ::flatbuffers::Offset CreateArrayOfVec4Direct( + ::flatbuffers::FlatBufferBuilder &_fbb, + const std::vector *xs = nullptr, + const std::vector *ys = nullptr, + const std::vector *zs = nullptr, + const std::vector *ws = nullptr) { + auto xs__ = xs ? _fbb.CreateVector(*xs) : 0; + auto ys__ = ys ? _fbb.CreateVector(*ys) : 0; + auto zs__ = zs ? _fbb.CreateVector(*zs) : 0; + auto ws__ = ws ? _fbb.CreateVector(*ws) : 0; + return UserInteractionFB::CreateArrayOfVec4( + _fbb, + xs__, + ys__, + zs__, + ws__); +} + +struct EventMouseMotion FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { + typedef EventMouseMotionBuilder Builder; + static const ::flatbuffers::TypeTable *MiniReflectTypeTable() { + return EventMouseMotionTypeTable(); + } + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_POS = 4, + VT_MOUSE_ID = 6, + VT_IS_TOUCH = 8 + }; + const UserInteractionFB::SingleVec2 *pos() const { + return GetStruct(VT_POS); + } + uint32_t mouse_id() const { + return GetField(VT_MOUSE_ID, 0); + } + bool is_touch() const { + return GetField(VT_IS_TOUCH, 0) != 0; + } + bool Verify(::flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyField(verifier, VT_POS, 4) && + VerifyField(verifier, VT_MOUSE_ID, 4) && + VerifyField(verifier, VT_IS_TOUCH, 1) && + verifier.EndTable(); + } +}; + +struct EventMouseMotionBuilder { + typedef EventMouseMotion Table; + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; + void add_pos(const UserInteractionFB::SingleVec2 *pos) { + fbb_.AddStruct(EventMouseMotion::VT_POS, pos); + } + void add_mouse_id(uint32_t mouse_id) { + fbb_.AddElement(EventMouseMotion::VT_MOUSE_ID, mouse_id, 0); + } + void add_is_touch(bool is_touch) { + fbb_.AddElement(EventMouseMotion::VT_IS_TOUCH, static_cast(is_touch), 0); + } + explicit EventMouseMotionBuilder(::flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + ::flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = ::flatbuffers::Offset(end); + return o; + } +}; + +inline ::flatbuffers::Offset CreateEventMouseMotion( + ::flatbuffers::FlatBufferBuilder &_fbb, + const UserInteractionFB::SingleVec2 *pos = nullptr, + uint32_t mouse_id = 0, + bool is_touch = false) { + EventMouseMotionBuilder builder_(_fbb); + builder_.add_mouse_id(mouse_id); + builder_.add_pos(pos); + builder_.add_is_touch(is_touch); + return builder_.Finish(); +} + +struct EventMouseWheel FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { + typedef EventMouseWheelBuilder Builder; + static const ::flatbuffers::TypeTable *MiniReflectTypeTable() { + return EventMouseWheelTypeTable(); + } + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_POS = 4, + VT_MOUSE_ID = 6, + VT_IS_TOUCH = 8 + }; + const UserInteractionFB::SingleVec2 *pos() const { + return GetStruct(VT_POS); + } + uint32_t mouse_id() const { + return GetField(VT_MOUSE_ID, 0); + } + bool is_touch() const { + return GetField(VT_IS_TOUCH, 0) != 0; + } + bool Verify(::flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyField(verifier, VT_POS, 4) && + VerifyField(verifier, VT_MOUSE_ID, 4) && + VerifyField(verifier, VT_IS_TOUCH, 1) && + verifier.EndTable(); + } +}; + +struct EventMouseWheelBuilder { + typedef EventMouseWheel Table; + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; + void add_pos(const UserInteractionFB::SingleVec2 *pos) { + fbb_.AddStruct(EventMouseWheel::VT_POS, pos); + } + void add_mouse_id(uint32_t mouse_id) { + fbb_.AddElement(EventMouseWheel::VT_MOUSE_ID, mouse_id, 0); + } + void add_is_touch(bool is_touch) { + fbb_.AddElement(EventMouseWheel::VT_IS_TOUCH, static_cast(is_touch), 0); + } + explicit EventMouseWheelBuilder(::flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + ::flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = ::flatbuffers::Offset(end); + return o; + } +}; + +inline ::flatbuffers::Offset CreateEventMouseWheel( + ::flatbuffers::FlatBufferBuilder &_fbb, + const UserInteractionFB::SingleVec2 *pos = nullptr, + uint32_t mouse_id = 0, + bool is_touch = false) { + EventMouseWheelBuilder builder_(_fbb); + builder_.add_mouse_id(mouse_id); + builder_.add_pos(pos); + builder_.add_is_touch(is_touch); + return builder_.Finish(); +} + +struct EventMouseButton FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { + typedef EventMouseButtonBuilder Builder; + static const ::flatbuffers::TypeTable *MiniReflectTypeTable() { + return EventMouseButtonTypeTable(); + } + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_POS = 4, + VT_MOUSE_ID = 6, + VT_IS_TOUCH = 8, + VT_BUTTON = 10, + VT_TYPE = 12 + }; + const UserInteractionFB::SingleVec2 *pos() const { + return GetStruct(VT_POS); + } + uint32_t mouse_id() const { + return GetField(VT_MOUSE_ID, 0); + } + bool is_touch() const { + return GetField(VT_IS_TOUCH, 0) != 0; + } + UserInteractionFB::MouseButton button() const { + return static_cast(GetField(VT_BUTTON, 0)); + } + UserInteractionFB::MouseButtonEventType type() const { + return static_cast(GetField(VT_TYPE, 0)); + } + bool Verify(::flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyField(verifier, VT_POS, 4) && + VerifyField(verifier, VT_MOUSE_ID, 4) && + VerifyField(verifier, VT_IS_TOUCH, 1) && + VerifyField(verifier, VT_BUTTON, 1) && + VerifyField(verifier, VT_TYPE, 1) && + verifier.EndTable(); + } +}; + +struct EventMouseButtonBuilder { + typedef EventMouseButton Table; + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; + void add_pos(const UserInteractionFB::SingleVec2 *pos) { + fbb_.AddStruct(EventMouseButton::VT_POS, pos); + } + void add_mouse_id(uint32_t mouse_id) { + fbb_.AddElement(EventMouseButton::VT_MOUSE_ID, mouse_id, 0); + } + void add_is_touch(bool is_touch) { + fbb_.AddElement(EventMouseButton::VT_IS_TOUCH, static_cast(is_touch), 0); + } + void add_button(UserInteractionFB::MouseButton button) { + fbb_.AddElement(EventMouseButton::VT_BUTTON, static_cast(button), 0); + } + void add_type(UserInteractionFB::MouseButtonEventType type) { + fbb_.AddElement(EventMouseButton::VT_TYPE, static_cast(type), 0); + } + explicit EventMouseButtonBuilder(::flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + ::flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = ::flatbuffers::Offset(end); + return o; + } +}; + +inline ::flatbuffers::Offset CreateEventMouseButton( + ::flatbuffers::FlatBufferBuilder &_fbb, + const UserInteractionFB::SingleVec2 *pos = nullptr, + uint32_t mouse_id = 0, + bool is_touch = false, + UserInteractionFB::MouseButton button = UserInteractionFB::MouseButton_None, + UserInteractionFB::MouseButtonEventType type = UserInteractionFB::MouseButtonEventType_Up) { + EventMouseButtonBuilder builder_(_fbb); + builder_.add_mouse_id(mouse_id); + builder_.add_pos(pos); + builder_.add_type(type); + builder_.add_button(button); + builder_.add_is_touch(is_touch); + return builder_.Finish(); +} + +struct EventTextInput FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { + typedef EventTextInputBuilder Builder; + static const ::flatbuffers::TypeTable *MiniReflectTypeTable() { + return EventTextInputTypeTable(); + } + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_TEXT = 4 + }; + const ::flatbuffers::String *text() const { + return GetPointer(VT_TEXT); + } + bool Verify(::flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyOffset(verifier, VT_TEXT) && + verifier.VerifyString(text()) && + verifier.EndTable(); + } +}; + +struct EventTextInputBuilder { + typedef EventTextInput Table; + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; + void add_text(::flatbuffers::Offset<::flatbuffers::String> text) { + fbb_.AddOffset(EventTextInput::VT_TEXT, text); + } + explicit EventTextInputBuilder(::flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + ::flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = ::flatbuffers::Offset(end); + return o; + } +}; + +inline ::flatbuffers::Offset CreateEventTextInput( + ::flatbuffers::FlatBufferBuilder &_fbb, + ::flatbuffers::Offset<::flatbuffers::String> text = 0) { + EventTextInputBuilder builder_(_fbb); + builder_.add_text(text); + return builder_.Finish(); +} + +inline ::flatbuffers::Offset CreateEventTextInputDirect( + ::flatbuffers::FlatBufferBuilder &_fbb, + const char *text = nullptr) { + auto text__ = text ? _fbb.CreateString(text) : 0; + return UserInteractionFB::CreateEventTextInput( + _fbb, + text__); +} + +struct Event FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { + typedef EventBuilder Builder; + static const ::flatbuffers::TypeTable *MiniReflectTypeTable() { + return EventTypeTable(); + } + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_EVENT_TYPE = 4, + VT_EVENT = 6 + }; + UserInteractionFB::UserInteraction event_type() const { + return static_cast(GetField(VT_EVENT_TYPE, 0)); + } + const void *event() const { + return GetPointer(VT_EVENT); + } + template const T *event_as() const; + const UserInteractionFB::EventMouseMotion *event_as_EventMouseMotion() const { + return event_type() == UserInteractionFB::UserInteraction_EventMouseMotion ? static_cast(event()) : nullptr; + } + const UserInteractionFB::EventMouseWheel *event_as_EventMouseWheel() const { + return event_type() == UserInteractionFB::UserInteraction_EventMouseWheel ? static_cast(event()) : nullptr; + } + const UserInteractionFB::EventMouseButton *event_as_EventMouseButton() const { + return event_type() == UserInteractionFB::UserInteraction_EventMouseButton ? static_cast(event()) : nullptr; + } + const UserInteractionFB::EventTextInput *event_as_EventTextInput() const { + return event_type() == UserInteractionFB::UserInteraction_EventTextInput ? static_cast(event()) : nullptr; + } + bool Verify(::flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyField(verifier, VT_EVENT_TYPE, 1) && + VerifyOffset(verifier, VT_EVENT) && + VerifyUserInteraction(verifier, event(), event_type()) && + verifier.EndTable(); + } +}; + +template<> inline const UserInteractionFB::EventMouseMotion *Event::event_as() const { + return event_as_EventMouseMotion(); +} + +template<> inline const UserInteractionFB::EventMouseWheel *Event::event_as() const { + return event_as_EventMouseWheel(); +} + +template<> inline const UserInteractionFB::EventMouseButton *Event::event_as() const { + return event_as_EventMouseButton(); +} + +template<> inline const UserInteractionFB::EventTextInput *Event::event_as() const { + return event_as_EventTextInput(); +} + +struct EventBuilder { + typedef Event Table; + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; + void add_event_type(UserInteractionFB::UserInteraction event_type) { + fbb_.AddElement(Event::VT_EVENT_TYPE, static_cast(event_type), 0); + } + void add_event(::flatbuffers::Offset event) { + fbb_.AddOffset(Event::VT_EVENT, event); + } + explicit EventBuilder(::flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + ::flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = ::flatbuffers::Offset(end); + return o; + } +}; + +inline ::flatbuffers::Offset CreateEvent( + ::flatbuffers::FlatBufferBuilder &_fbb, + UserInteractionFB::UserInteraction event_type = UserInteractionFB::UserInteraction_NONE, + ::flatbuffers::Offset event = 0) { + EventBuilder builder_(_fbb); + builder_.add_event(event); + builder_.add_event_type(event_type); + return builder_.Finish(); +} + +inline bool VerifyUserInteraction(::flatbuffers::Verifier &verifier, const void *obj, UserInteraction type) { + switch (type) { + case UserInteraction_NONE: { + return true; + } + case UserInteraction_EventMouseMotion: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case UserInteraction_EventMouseWheel: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case UserInteraction_EventMouseButton: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case UserInteraction_EventTextInput: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + default: return true; + } +} + +inline bool VerifyUserInteractionVector(::flatbuffers::Verifier &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset> *values, const ::flatbuffers::Vector *types) { + if (!values || !types) return !values && !types; + if (values->size() != types->size()) return false; + for (::flatbuffers::uoffset_t i = 0; i < values->size(); ++i) { + if (!VerifyUserInteraction( + verifier, values->Get(i), types->GetEnum(i))) { + return false; + } + } + return true; +} + +inline const ::flatbuffers::TypeTable *MouseButtonTypeTable() { + static const ::flatbuffers::TypeCode type_codes[] = { + { ::flatbuffers::ET_UCHAR, 0, 0 }, + { ::flatbuffers::ET_UCHAR, 0, 0 }, + { ::flatbuffers::ET_UCHAR, 0, 0 }, + { ::flatbuffers::ET_UCHAR, 0, 0 }, + { ::flatbuffers::ET_UCHAR, 0, 0 }, + { ::flatbuffers::ET_UCHAR, 0, 0 } + }; + static const ::flatbuffers::TypeFunction type_refs[] = { + UserInteractionFB::MouseButtonTypeTable + }; + static const char * const names[] = { + "None", + "Left", + "Right", + "Middle", + "X1", + "X2" + }; + static const ::flatbuffers::TypeTable tt = { + ::flatbuffers::ST_ENUM, 6, type_codes, type_refs, nullptr, nullptr, names + }; + return &tt; +} + +inline const ::flatbuffers::TypeTable *MouseButtonEventTypeTypeTable() { + static const ::flatbuffers::TypeCode type_codes[] = { + { ::flatbuffers::ET_UCHAR, 0, 0 }, + { ::flatbuffers::ET_UCHAR, 0, 0 } + }; + static const ::flatbuffers::TypeFunction type_refs[] = { + UserInteractionFB::MouseButtonEventTypeTypeTable + }; + static const char * const names[] = { + "Up", + "Down" + }; + static const ::flatbuffers::TypeTable tt = { + ::flatbuffers::ST_ENUM, 2, type_codes, type_refs, nullptr, nullptr, names + }; + return &tt; +} + +inline const ::flatbuffers::TypeTable *UserInteractionTypeTable() { + static const ::flatbuffers::TypeCode type_codes[] = { + { ::flatbuffers::ET_SEQUENCE, 0, -1 }, + { ::flatbuffers::ET_SEQUENCE, 0, 0 }, + { ::flatbuffers::ET_SEQUENCE, 0, 1 }, + { ::flatbuffers::ET_SEQUENCE, 0, 2 }, + { ::flatbuffers::ET_SEQUENCE, 0, 3 } + }; + static const ::flatbuffers::TypeFunction type_refs[] = { + UserInteractionFB::EventMouseMotionTypeTable, + UserInteractionFB::EventMouseWheelTypeTable, + UserInteractionFB::EventMouseButtonTypeTable, + UserInteractionFB::EventTextInputTypeTable + }; + static const char * const names[] = { + "NONE", + "EventMouseMotion", + "EventMouseWheel", + "EventMouseButton", + "EventTextInput" + }; + static const ::flatbuffers::TypeTable tt = { + ::flatbuffers::ST_UNION, 5, type_codes, type_refs, nullptr, nullptr, names + }; + return &tt; +} + +inline const ::flatbuffers::TypeTable *SingleVec2TypeTable() { + static const ::flatbuffers::TypeCode type_codes[] = { + { ::flatbuffers::ET_FLOAT, 0, -1 }, + { ::flatbuffers::ET_FLOAT, 0, -1 } + }; + static const int64_t values[] = { 0, 4, 8 }; + static const char * const names[] = { + "x", + "y" + }; + static const ::flatbuffers::TypeTable tt = { + ::flatbuffers::ST_STRUCT, 2, type_codes, nullptr, nullptr, values, names + }; + return &tt; +} + +inline const ::flatbuffers::TypeTable *SingleVec4TypeTable() { + static const ::flatbuffers::TypeCode type_codes[] = { + { ::flatbuffers::ET_FLOAT, 0, -1 }, + { ::flatbuffers::ET_FLOAT, 0, -1 }, + { ::flatbuffers::ET_FLOAT, 0, -1 }, + { ::flatbuffers::ET_FLOAT, 0, -1 } + }; + static const int64_t values[] = { 0, 4, 8, 12, 16 }; + static const char * const names[] = { + "x", + "y", + "z", + "w" + }; + static const ::flatbuffers::TypeTable tt = { + ::flatbuffers::ST_STRUCT, 4, type_codes, nullptr, nullptr, values, names + }; + return &tt; +} + +inline const ::flatbuffers::TypeTable *ArrayOfVec2TypeTable() { + static const ::flatbuffers::TypeCode type_codes[] = { + { ::flatbuffers::ET_FLOAT, 1, -1 }, + { ::flatbuffers::ET_FLOAT, 1, -1 } + }; + static const char * const names[] = { + "xs", + "ys" + }; + static const ::flatbuffers::TypeTable tt = { + ::flatbuffers::ST_TABLE, 2, type_codes, nullptr, nullptr, nullptr, names + }; + return &tt; +} + +inline const ::flatbuffers::TypeTable *ArrayOfVec4TypeTable() { + static const ::flatbuffers::TypeCode type_codes[] = { + { ::flatbuffers::ET_FLOAT, 1, -1 }, + { ::flatbuffers::ET_FLOAT, 1, -1 }, + { ::flatbuffers::ET_FLOAT, 1, -1 }, + { ::flatbuffers::ET_FLOAT, 1, -1 } + }; + static const char * const names[] = { + "xs", + "ys", + "zs", + "ws" + }; + static const ::flatbuffers::TypeTable tt = { + ::flatbuffers::ST_TABLE, 4, type_codes, nullptr, nullptr, nullptr, names + }; + return &tt; +} + +inline const ::flatbuffers::TypeTable *EventMouseMotionTypeTable() { + static const ::flatbuffers::TypeCode type_codes[] = { + { ::flatbuffers::ET_SEQUENCE, 0, 0 }, + { ::flatbuffers::ET_UINT, 0, -1 }, + { ::flatbuffers::ET_BOOL, 0, -1 } + }; + static const ::flatbuffers::TypeFunction type_refs[] = { + UserInteractionFB::SingleVec2TypeTable + }; + static const char * const names[] = { + "pos", + "mouse_id", + "is_touch" + }; + static const ::flatbuffers::TypeTable tt = { + ::flatbuffers::ST_TABLE, 3, type_codes, type_refs, nullptr, nullptr, names + }; + return &tt; +} + +inline const ::flatbuffers::TypeTable *EventMouseWheelTypeTable() { + static const ::flatbuffers::TypeCode type_codes[] = { + { ::flatbuffers::ET_SEQUENCE, 0, 0 }, + { ::flatbuffers::ET_UINT, 0, -1 }, + { ::flatbuffers::ET_BOOL, 0, -1 } + }; + static const ::flatbuffers::TypeFunction type_refs[] = { + UserInteractionFB::SingleVec2TypeTable + }; + static const char * const names[] = { + "pos", + "mouse_id", + "is_touch" + }; + static const ::flatbuffers::TypeTable tt = { + ::flatbuffers::ST_TABLE, 3, type_codes, type_refs, nullptr, nullptr, names + }; + return &tt; +} + +inline const ::flatbuffers::TypeTable *EventMouseButtonTypeTable() { + static const ::flatbuffers::TypeCode type_codes[] = { + { ::flatbuffers::ET_SEQUENCE, 0, 0 }, + { ::flatbuffers::ET_UINT, 0, -1 }, + { ::flatbuffers::ET_BOOL, 0, -1 }, + { ::flatbuffers::ET_UCHAR, 0, 1 }, + { ::flatbuffers::ET_UCHAR, 0, 2 } + }; + static const ::flatbuffers::TypeFunction type_refs[] = { + UserInteractionFB::SingleVec2TypeTable, + UserInteractionFB::MouseButtonTypeTable, + UserInteractionFB::MouseButtonEventTypeTypeTable + }; + static const char * const names[] = { + "pos", + "mouse_id", + "is_touch", + "button", + "type" + }; + static const ::flatbuffers::TypeTable tt = { + ::flatbuffers::ST_TABLE, 5, type_codes, type_refs, nullptr, nullptr, names + }; + return &tt; +} + +inline const ::flatbuffers::TypeTable *EventTextInputTypeTable() { + static const ::flatbuffers::TypeCode type_codes[] = { + { ::flatbuffers::ET_STRING, 0, -1 } + }; + static const char * const names[] = { + "text" + }; + static const ::flatbuffers::TypeTable tt = { + ::flatbuffers::ST_TABLE, 1, type_codes, nullptr, nullptr, nullptr, names + }; + return &tt; +} + +inline const ::flatbuffers::TypeTable *EventTypeTable() { + static const ::flatbuffers::TypeCode type_codes[] = { + { ::flatbuffers::ET_UTYPE, 0, 0 }, + { ::flatbuffers::ET_SEQUENCE, 0, 0 } + }; + static const ::flatbuffers::TypeFunction type_refs[] = { + UserInteractionFB::UserInteractionTypeTable + }; + static const char * const names[] = { + "event_type", + "event" + }; + static const ::flatbuffers::TypeTable tt = { + ::flatbuffers::ST_TABLE, 2, type_codes, type_refs, nullptr, nullptr, names + }; + return &tt; +} + +inline const UserInteractionFB::Event *GetEvent(const void *buf) { + return ::flatbuffers::GetRoot(buf); +} + +inline const UserInteractionFB::Event *GetSizePrefixedEvent(const void *buf) { + return ::flatbuffers::GetSizePrefixedRoot(buf); +} + +inline bool VerifyEventBuffer( + ::flatbuffers::Verifier &verifier) { + return verifier.VerifyBuffer(nullptr); +} + +inline bool VerifySizePrefixedEventBuffer( + ::flatbuffers::Verifier &verifier) { + return verifier.VerifySizePrefixedBuffer(nullptr); +} + +inline void FinishEventBuffer( + ::flatbuffers::FlatBufferBuilder &fbb, + ::flatbuffers::Offset root) { + fbb.Finish(root); +} + +inline void FinishSizePrefixedEventBuffer( + ::flatbuffers::FlatBufferBuilder &fbb, + ::flatbuffers::Offset root) { + fbb.FinishSizePrefixed(root); +} + +} // namespace UserInteractionFB + +#endif // FLATBUFFERS_GENERATED_USERINTERACTION_USERINTERACTIONFB_H_ diff --git a/skia/video_userinput.sh b/skia/video_userinput.sh new file mode 100755 index 0000000..1b5add0 --- /dev/null +++ b/skia/video_userinput.sh @@ -0,0 +1,24 @@ +#!/bin/bash +set -ev +rm -f transferRawFrames +rm -f transferUserInteractionEvents +mkfifo transferRawFrames +mkfifo transferUserInteractionEvents + +resW=1920 +resH=1080 + +./imgui_skia_exe -fffiInterpreter off \ + -ttfFilePath ./SauceCodeProNerdFontPropo-Regular.ttf \ + -backdropFilter off \ + -videoRawFramesFile transferRawFrames \ + -videoResolutionWidth $resW \ + -videoResolutionHeight $resH \ + -videoRawOutputFormat bmp_bgra8888 \ + -videoUserInteractionEventsInFile transferUserInteractionEvents \ + -videoExitAfterNFrames 0 & +pid=$! +cat transferRawFrames | ../video_player/imzero_video_play - > transferUserInteractionEvents +# ../video_player/imzero_video_play transferRawFrames > transferUserInteractionEvents +#cat transferRawFrames | tee out.raw | mpv - +kill $pid diff --git a/skia/video_userinput2.sh b/skia/video_userinput2.sh new file mode 100755 index 0000000..a0618ac --- /dev/null +++ b/skia/video_userinput2.sh @@ -0,0 +1,32 @@ +#!/bin/bash +set -ev +rm -f transferRawFrames +rm -f transferUserInteractionEvents +mkfifo transferRawFrames +mkfifo transferUserInteractionEvents + +resW=1920 +resH=1080 + +./imgui_exe -fffiInterpreter off \ + -ttfFilePath ./SauceCodeProNerdFontPropo-Regular.ttf \ + -backdropFilter off \ + -videoRawFramesFile transferRawFrames \ + -videoResolutionWidth $resW \ + -videoResolutionHeight $resH \ + -videoRawOutputFormat bmp_bgra8888 \ + -videoUserInteractionEventsInFile transferUserInteractionEvents \ + -videoExitAfterNFrames 0 + +#cat transferRawFrames | ../video_player/imzero_video_play - > transferUserInteractionEvents #& +#pid=$! +#./imgui_skia_exe -fffiInterpreter off \ +# -ttfFilePath ./SauceCodeProNerdFontPropo-Regular.ttf \ +# -backdropFilter off \ +# -videoRawFramesFile transferRawFrames \ +# -videoResolutionWidth $resW \ +# -videoResolutionHeight $resH \ +# -videoRawOutputFormat bmp_bgra8888 \ +# -videoUserInteractionEventsInFile transferUserInteractionEvents \ +# -videoExitAfterNFrames 0 +#kill $pid diff --git a/video_player/build_cpp.sh b/video_player/build_cpp.sh index f3eb071..b25eb99 100755 --- a/video_player/build_cpp.sh +++ b/video_player/build_cpp.sh @@ -6,7 +6,7 @@ cd "$here" source env.sh flatc="../../contrib/flatbuffers/flatc" -"$flatc" -o src --cpp spec/userInteraction.fbs +"$flatc" -o src --cpp spec/userInteraction.fbs --reflect-types --reflect-names ./cmakelists.dhall diff --git a/video_player/common.dhall b/video_player/common.dhall index 753d9b5..bc96629 100644 --- a/video_player/common.dhall +++ b/video_player/common.dhall @@ -1,6 +1,6 @@ let lib = ../dhall/lib.dhall -let debug = False -let asan = False +let debug = True +let asan = True --let clangdir = env:CLANGDIR as Text -- FIXME sync with ./build_skia_asan.sh let sourceTreePartsRepo = ../dhall/sourceTreeParts.dhall let sourceTreeParts = [ @@ -31,7 +31,7 @@ let cxxflagsRelease = [ let ldflagsDebug = if asan then [ , "-fsanitize=address" , "-fsanitize=undefined" - , "-fuse-ld=lld" +-- , "-fuse-ld=lld" , "-v" -- , "-Wl,-rpath,${clangdir}/lib/x86_64-unknown-linux-gnu" ] else [] : List Text diff --git a/video_player/sdl3_mpv/app.cpp b/video_player/sdl3_mpv/app.cpp index b7d5ef6..7341368 100644 --- a/video_player/sdl3_mpv/app.cpp +++ b/video_player/sdl3_mpv/app.cpp @@ -1,5 +1,6 @@ #include #include "app.h" +#include "flatbuffers/minireflect.h" #define HANDLE_MPV_RETURN(errorCode) handleMpvRetr((errorCode),__func__,__FILE__,__LINE__) #define HANDLE_SDL_RETURN(errorCode) handleSdlRetr((errorCode),__func__,__FILE__,__LINE__) @@ -21,16 +22,20 @@ static void onMpvRenderUpdate(void *ctx) { App::~App() { teardown(); } -void App::serializeUserInteractionEventFB(const uint8_t *&out,size_t &size, flatbuffers::Offset e) { +void App::serializeUserInteractionEventFB(const uint8_t *&out,size_t &size, flatbuffers::Offset e) { fFlatBufferBuilder.FinishSizePrefixed(e); size = fFlatBufferBuilder.GetSize(); out = fFlatBufferBuilder.GetBufferPointer(); + + { + auto txt = flatbuffers::FlatBufferToString(out+4,UserInteractionFB::EventTypeTable()); + fprintf(stderr, "userInteractionEvent=%s\n", txt.c_str()); + } } -void App::sendUserInteractionEvent(flatbuffers::Offset e) { +void App::sendUserInteractionEvent(UserInteractionFB::UserInteraction eventType, flatbuffers::Offset e) { const uint8_t *ptr = nullptr; size_t sz = 0; - serializeUserInteractionEventFB(ptr,sz,e); - fprintf(stderr,"sz=%d,%.*s\n",(int)sz,(int)sz,ptr); + serializeUserInteractionEventFB(ptr,sz,UserInteractionFB::CreateEvent(fFlatBufferBuilder, eventType, e)); fwrite(ptr,1,sz,fUserInteractionOutput); fflush(fUserInteractionOutput); } @@ -42,19 +47,19 @@ void App::handleSdlEvent(SDL_Event &event) { { auto const ev = event.motion; auto const pos = UserInteractionFB::SingleVec2(ev.x,ev.y); - auto const e = UserInteractionFB::CreateEventMouseMotion(fFlatBufferBuilder,&pos,ev.which,ev.which == SDL_TOUCH_MOUSEID).Union(); - sendUserInteractionEvent(e); + auto const e = UserInteractionFB::CreateEventMouseMotion(fFlatBufferBuilder,&pos,ev.which,ev.which == SDL_TOUCH_MOUSEID); + sendUserInteractionEvent(UserInteractionFB::UserInteraction_EventMouseMotion, e.Union()); } break; case SDL_EVENT_MOUSE_WHEEL: { auto const ev = event.wheel; auto const pos = UserInteractionFB::SingleVec2(ev.x,ev.y); - auto const e = UserInteractionFB::CreateEventMouseWheel(fFlatBufferBuilder, &pos, ev.which, ev.which == SDL_TOUCH_MOUSEID).Union(); - sendUserInteractionEvent(e); + auto const e = UserInteractionFB::CreateEventMouseWheel(fFlatBufferBuilder, &pos, ev.which, ev.which == SDL_TOUCH_MOUSEID); + sendUserInteractionEvent(UserInteractionFB::UserInteraction_EventMouseWheel, e.Union()); } break; - case SDL_EVENT_MOUSE_BUTTON_DOWN: + case SDL_EVENT_MOUSE_BUTTON_DOWN: // fallthrough case SDL_EVENT_MOUSE_BUTTON_UP: { auto const ev = event.button; @@ -77,16 +82,16 @@ void App::handleSdlEvent(SDL_Event &event) { break; } auto const pos = UserInteractionFB::SingleVec2(ev.x,ev.y); - auto const e = UserInteractionFB::CreateEventMouseButton(fFlatBufferBuilder,&pos,ev.which,ev.which == SDL_TOUCH_MOUSEID,b).Union(); - sendUserInteractionEvent(e); + auto const e = UserInteractionFB::CreateEventMouseButton(fFlatBufferBuilder,&pos,ev.which,ev.which == SDL_TOUCH_MOUSEID,b); + sendUserInteractionEvent(UserInteractionFB::UserInteraction_EventMouseButton, e.Union()); } break; case SDL_EVENT_TEXT_INPUT: { auto const ev = event.text; auto const t = fFlatBufferBuilder.CreateString(ev.text); - auto const e = UserInteractionFB::CreateEventTextInput(fFlatBufferBuilder,t).Union(); - sendUserInteractionEvent(e); + auto const e = UserInteractionFB::CreateEventTextInput(fFlatBufferBuilder,t); + sendUserInteractionEvent(UserInteractionFB::UserInteraction_EventTextInput, e.Union()); } break; //case SDL_EVENT_KEY_DOWN: @@ -157,6 +162,14 @@ bool App::scheduleMpvCommandAsync2(const char *command, const char *arg1) { const char *cmd[] = {command, arg1, nullptr}; return !HANDLE_MPV_RETURN(mpv_command_async(fMpvHandle, 0, cmd)); } +bool App::scheduleMpvCommand2(const char *command, const char *arg1) { + const char *cmd[] = {command, arg1, nullptr}; + return !HANDLE_MPV_RETURN(mpv_command(fMpvHandle, cmd)); +} +bool App::scheduleMpvCommandAsync1(const char *command) { + const char *cmd[] = {command, nullptr}; + return !HANDLE_MPV_RETURN(mpv_command_async(fMpvHandle, 0, cmd)); +} bool App::handleMpvRetr(int errorCode, const char *func, const char *filename, int line) { if(errorCode >= 0) { @@ -262,6 +275,18 @@ const char *App::setup(const char *inputFile, FILE *userInteractionOutput) { // users which run OpenGL on a different thread.) mpv_render_context_set_update_callback(fMpvRenderContext, onMpvRenderUpdate, this); + /* + if(!scheduleMpvCommandAsync1("keep-open")) { + return "unable to schedule command"; + } + if(!scheduleMpvCommandAsync1("cursor-autohide-fs-only")) { + return "unable to schedule command"; + } + if(!scheduleMpvCommand2("profile","low-latency")) { + return "unable to schedule profile command"; + } + */ + if(!scheduleMpvCommandAsync2("loadfile", inputFile)) { return "unable to schedule loadfile command"; } diff --git a/video_player/sdl3_mpv/app.h b/video_player/sdl3_mpv/app.h index 6f0c99d..f4c6efb 100644 --- a/video_player/sdl3_mpv/app.h +++ b/video_player/sdl3_mpv/app.h @@ -21,14 +21,18 @@ class App { Uint32 fWakeupOnMpvEvents = 0; private: - void serializeUserInteractionEventFB(const uint8_t *&out,size_t &size, flatbuffers::Offset e); - void sendUserInteractionEvent(flatbuffers::Offset e); + void serializeUserInteractionEventFB(const uint8_t *&out,size_t &size, flatbuffers::Offset e); + void sendUserInteractionEvent(UserInteractionFB::UserInteraction eventType, flatbuffers::Offset e); void redraw(); void teardown(); void handleSdlEvent(SDL_Event &event); void processMpvEvents(); // @return true on success bool scheduleMpvCommandAsync2(const char *command, const char *arg1); + // @return true on success + bool scheduleMpvCommand2(const char *command, const char *arg1); + // @return true on success + bool scheduleMpvCommandAsync1(const char *command); // @return true on failure static bool handleMpvRetr(int errorCode, const char *func, const char *filename, int line); // @return true on failure diff --git a/video_player/spec/userInteraction.fbs b/video_player/spec/userInteraction.fbs index 258166f..1796fcf 100644 --- a/video_player/spec/userInteraction.fbs +++ b/video_player/spec/userInteraction.fbs @@ -38,11 +38,16 @@ enum MouseButton:uint8 { X1 = 4, X2 = 5, } +enum MouseButtonEventType:uint8 { + Up = 0, + Down = 1, +} table EventMouseButton { pos: SingleVec2; mouse_id: uint32; is_touch: bool; button: MouseButton; + type: MouseButtonEventType; } table EventTextInput { text: string; @@ -51,6 +56,7 @@ union UserInteraction { EventMouseMotion, EventMouseWheel, EventMouseButton, + EventTextInput, } table Event { event: UserInteraction; diff --git a/video_player/src/userInteraction_generated.h b/video_player/src/userInteraction_generated.h index 3b6c766..b6d3c78 100644 --- a/video_player/src/userInteraction_generated.h +++ b/video_player/src/userInteraction_generated.h @@ -40,6 +40,24 @@ struct EventTextInputBuilder; struct Event; struct EventBuilder; +inline const ::flatbuffers::TypeTable *SingleVec2TypeTable(); + +inline const ::flatbuffers::TypeTable *SingleVec4TypeTable(); + +inline const ::flatbuffers::TypeTable *ArrayOfVec2TypeTable(); + +inline const ::flatbuffers::TypeTable *ArrayOfVec4TypeTable(); + +inline const ::flatbuffers::TypeTable *EventMouseMotionTypeTable(); + +inline const ::flatbuffers::TypeTable *EventMouseWheelTypeTable(); + +inline const ::flatbuffers::TypeTable *EventMouseButtonTypeTable(); + +inline const ::flatbuffers::TypeTable *EventTextInputTypeTable(); + +inline const ::flatbuffers::TypeTable *EventTypeTable(); + enum MouseButton : uint8_t { MouseButton_None = 0, MouseButton_Left = 1, @@ -82,38 +100,71 @@ inline const char *EnumNameMouseButton(MouseButton e) { return EnumNamesMouseButton()[index]; } +enum MouseButtonEventType : uint8_t { + MouseButtonEventType_Up = 0, + MouseButtonEventType_Down = 1, + MouseButtonEventType_MIN = MouseButtonEventType_Up, + MouseButtonEventType_MAX = MouseButtonEventType_Down +}; + +inline const MouseButtonEventType (&EnumValuesMouseButtonEventType())[2] { + static const MouseButtonEventType values[] = { + MouseButtonEventType_Up, + MouseButtonEventType_Down + }; + return values; +} + +inline const char * const *EnumNamesMouseButtonEventType() { + static const char * const names[3] = { + "Up", + "Down", + nullptr + }; + return names; +} + +inline const char *EnumNameMouseButtonEventType(MouseButtonEventType e) { + if (::flatbuffers::IsOutRange(e, MouseButtonEventType_Up, MouseButtonEventType_Down)) return ""; + const size_t index = static_cast(e); + return EnumNamesMouseButtonEventType()[index]; +} + enum UserInteraction : uint8_t { UserInteraction_NONE = 0, UserInteraction_EventMouseMotion = 1, UserInteraction_EventMouseWheel = 2, UserInteraction_EventMouseButton = 3, + UserInteraction_EventTextInput = 4, UserInteraction_MIN = UserInteraction_NONE, - UserInteraction_MAX = UserInteraction_EventMouseButton + UserInteraction_MAX = UserInteraction_EventTextInput }; -inline const UserInteraction (&EnumValuesUserInteraction())[4] { +inline const UserInteraction (&EnumValuesUserInteraction())[5] { static const UserInteraction values[] = { UserInteraction_NONE, UserInteraction_EventMouseMotion, UserInteraction_EventMouseWheel, - UserInteraction_EventMouseButton + UserInteraction_EventMouseButton, + UserInteraction_EventTextInput }; return values; } inline const char * const *EnumNamesUserInteraction() { - static const char * const names[5] = { + static const char * const names[6] = { "NONE", "EventMouseMotion", "EventMouseWheel", "EventMouseButton", + "EventTextInput", nullptr }; return names; } inline const char *EnumNameUserInteraction(UserInteraction e) { - if (::flatbuffers::IsOutRange(e, UserInteraction_NONE, UserInteraction_EventMouseButton)) return ""; + if (::flatbuffers::IsOutRange(e, UserInteraction_NONE, UserInteraction_EventTextInput)) return ""; const size_t index = static_cast(e); return EnumNamesUserInteraction()[index]; } @@ -134,6 +185,10 @@ template<> struct UserInteractionTraits { static const UserInteraction enum_value = UserInteraction_EventMouseButton; }; +template<> struct UserInteractionTraits { + static const UserInteraction enum_value = UserInteraction_EventTextInput; +}; + bool VerifyUserInteraction(::flatbuffers::Verifier &verifier, const void *obj, UserInteraction type); bool VerifyUserInteractionVector(::flatbuffers::Verifier &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset> *values, const ::flatbuffers::Vector *types); @@ -143,6 +198,9 @@ FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(4) SingleVec2 FLATBUFFERS_FINAL_CLASS { float y_; public: + static const ::flatbuffers::TypeTable *MiniReflectTypeTable() { + return SingleVec2TypeTable(); + } SingleVec2() : x_(0), y_(0) { @@ -168,6 +226,9 @@ FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(4) SingleVec4 FLATBUFFERS_FINAL_CLASS { float w_; public: + static const ::flatbuffers::TypeTable *MiniReflectTypeTable() { + return SingleVec4TypeTable(); + } SingleVec4() : x_(0), y_(0), @@ -197,6 +258,9 @@ FLATBUFFERS_STRUCT_END(SingleVec4, 16); struct ArrayOfVec2 FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { typedef ArrayOfVec2Builder Builder; + static const ::flatbuffers::TypeTable *MiniReflectTypeTable() { + return ArrayOfVec2TypeTable(); + } enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { VT_XS = 4, VT_YS = 6 @@ -262,6 +326,9 @@ inline ::flatbuffers::Offset CreateArrayOfVec2Direct( struct ArrayOfVec4 FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { typedef ArrayOfVec4Builder Builder; + static const ::flatbuffers::TypeTable *MiniReflectTypeTable() { + return ArrayOfVec4TypeTable(); + } enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { VT_XS = 4, VT_YS = 6, @@ -355,6 +422,9 @@ inline ::flatbuffers::Offset CreateArrayOfVec4Direct( struct EventMouseMotion FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { typedef EventMouseMotionBuilder Builder; + static const ::flatbuffers::TypeTable *MiniReflectTypeTable() { + return EventMouseMotionTypeTable(); + } enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { VT_POS = 4, VT_MOUSE_ID = 6, @@ -416,6 +486,9 @@ inline ::flatbuffers::Offset CreateEventMouseMotion( struct EventMouseWheel FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { typedef EventMouseWheelBuilder Builder; + static const ::flatbuffers::TypeTable *MiniReflectTypeTable() { + return EventMouseWheelTypeTable(); + } enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { VT_POS = 4, VT_MOUSE_ID = 6, @@ -477,11 +550,15 @@ inline ::flatbuffers::Offset CreateEventMouseWheel( struct EventMouseButton FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { typedef EventMouseButtonBuilder Builder; + static const ::flatbuffers::TypeTable *MiniReflectTypeTable() { + return EventMouseButtonTypeTable(); + } enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { VT_POS = 4, VT_MOUSE_ID = 6, VT_IS_TOUCH = 8, - VT_BUTTON = 10 + VT_BUTTON = 10, + VT_TYPE = 12 }; const UserInteractionFB::SingleVec2 *pos() const { return GetStruct(VT_POS); @@ -495,12 +572,16 @@ struct EventMouseButton FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { UserInteractionFB::MouseButton button() const { return static_cast(GetField(VT_BUTTON, 0)); } + UserInteractionFB::MouseButtonEventType type() const { + return static_cast(GetField(VT_TYPE, 0)); + } bool Verify(::flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && VerifyField(verifier, VT_POS, 4) && VerifyField(verifier, VT_MOUSE_ID, 4) && VerifyField(verifier, VT_IS_TOUCH, 1) && VerifyField(verifier, VT_BUTTON, 1) && + VerifyField(verifier, VT_TYPE, 1) && verifier.EndTable(); } }; @@ -521,6 +602,9 @@ struct EventMouseButtonBuilder { void add_button(UserInteractionFB::MouseButton button) { fbb_.AddElement(EventMouseButton::VT_BUTTON, static_cast(button), 0); } + void add_type(UserInteractionFB::MouseButtonEventType type) { + fbb_.AddElement(EventMouseButton::VT_TYPE, static_cast(type), 0); + } explicit EventMouseButtonBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); @@ -537,10 +621,12 @@ inline ::flatbuffers::Offset CreateEventMouseButton( const UserInteractionFB::SingleVec2 *pos = nullptr, uint32_t mouse_id = 0, bool is_touch = false, - UserInteractionFB::MouseButton button = UserInteractionFB::MouseButton_None) { + UserInteractionFB::MouseButton button = UserInteractionFB::MouseButton_None, + UserInteractionFB::MouseButtonEventType type = UserInteractionFB::MouseButtonEventType_Up) { EventMouseButtonBuilder builder_(_fbb); builder_.add_mouse_id(mouse_id); builder_.add_pos(pos); + builder_.add_type(type); builder_.add_button(button); builder_.add_is_touch(is_touch); return builder_.Finish(); @@ -548,6 +634,9 @@ inline ::flatbuffers::Offset CreateEventMouseButton( struct EventTextInput FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { typedef EventTextInputBuilder Builder; + static const ::flatbuffers::TypeTable *MiniReflectTypeTable() { + return EventTextInputTypeTable(); + } enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { VT_TEXT = 4 }; @@ -599,6 +688,9 @@ inline ::flatbuffers::Offset CreateEventTextInputDirect( struct Event FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { typedef EventBuilder Builder; + static const ::flatbuffers::TypeTable *MiniReflectTypeTable() { + return EventTypeTable(); + } enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { VT_EVENT_TYPE = 4, VT_EVENT = 6 @@ -619,6 +711,9 @@ struct Event FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { const UserInteractionFB::EventMouseButton *event_as_EventMouseButton() const { return event_type() == UserInteractionFB::UserInteraction_EventMouseButton ? static_cast(event()) : nullptr; } + const UserInteractionFB::EventTextInput *event_as_EventTextInput() const { + return event_type() == UserInteractionFB::UserInteraction_EventTextInput ? static_cast(event()) : nullptr; + } bool Verify(::flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && VerifyField(verifier, VT_EVENT_TYPE, 1) && @@ -640,6 +735,10 @@ template<> inline const UserInteractionFB::EventMouseButton *Event::event_as inline const UserInteractionFB::EventTextInput *Event::event_as() const { + return event_as_EventTextInput(); +} + struct EventBuilder { typedef Event Table; ::flatbuffers::FlatBufferBuilder &fbb_; @@ -688,6 +787,10 @@ inline bool VerifyUserInteraction(::flatbuffers::Verifier &verifier, const void auto ptr = reinterpret_cast(obj); return verifier.VerifyTable(ptr); } + case UserInteraction_EventTextInput: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } default: return true; } } @@ -704,6 +807,244 @@ inline bool VerifyUserInteractionVector(::flatbuffers::Verifier &verifier, const return true; } +inline const ::flatbuffers::TypeTable *MouseButtonTypeTable() { + static const ::flatbuffers::TypeCode type_codes[] = { + { ::flatbuffers::ET_UCHAR, 0, 0 }, + { ::flatbuffers::ET_UCHAR, 0, 0 }, + { ::flatbuffers::ET_UCHAR, 0, 0 }, + { ::flatbuffers::ET_UCHAR, 0, 0 }, + { ::flatbuffers::ET_UCHAR, 0, 0 }, + { ::flatbuffers::ET_UCHAR, 0, 0 } + }; + static const ::flatbuffers::TypeFunction type_refs[] = { + UserInteractionFB::MouseButtonTypeTable + }; + static const char * const names[] = { + "None", + "Left", + "Right", + "Middle", + "X1", + "X2" + }; + static const ::flatbuffers::TypeTable tt = { + ::flatbuffers::ST_ENUM, 6, type_codes, type_refs, nullptr, nullptr, names + }; + return &tt; +} + +inline const ::flatbuffers::TypeTable *MouseButtonEventTypeTypeTable() { + static const ::flatbuffers::TypeCode type_codes[] = { + { ::flatbuffers::ET_UCHAR, 0, 0 }, + { ::flatbuffers::ET_UCHAR, 0, 0 } + }; + static const ::flatbuffers::TypeFunction type_refs[] = { + UserInteractionFB::MouseButtonEventTypeTypeTable + }; + static const char * const names[] = { + "Up", + "Down" + }; + static const ::flatbuffers::TypeTable tt = { + ::flatbuffers::ST_ENUM, 2, type_codes, type_refs, nullptr, nullptr, names + }; + return &tt; +} + +inline const ::flatbuffers::TypeTable *UserInteractionTypeTable() { + static const ::flatbuffers::TypeCode type_codes[] = { + { ::flatbuffers::ET_SEQUENCE, 0, -1 }, + { ::flatbuffers::ET_SEQUENCE, 0, 0 }, + { ::flatbuffers::ET_SEQUENCE, 0, 1 }, + { ::flatbuffers::ET_SEQUENCE, 0, 2 }, + { ::flatbuffers::ET_SEQUENCE, 0, 3 } + }; + static const ::flatbuffers::TypeFunction type_refs[] = { + UserInteractionFB::EventMouseMotionTypeTable, + UserInteractionFB::EventMouseWheelTypeTable, + UserInteractionFB::EventMouseButtonTypeTable, + UserInteractionFB::EventTextInputTypeTable + }; + static const char * const names[] = { + "NONE", + "EventMouseMotion", + "EventMouseWheel", + "EventMouseButton", + "EventTextInput" + }; + static const ::flatbuffers::TypeTable tt = { + ::flatbuffers::ST_UNION, 5, type_codes, type_refs, nullptr, nullptr, names + }; + return &tt; +} + +inline const ::flatbuffers::TypeTable *SingleVec2TypeTable() { + static const ::flatbuffers::TypeCode type_codes[] = { + { ::flatbuffers::ET_FLOAT, 0, -1 }, + { ::flatbuffers::ET_FLOAT, 0, -1 } + }; + static const int64_t values[] = { 0, 4, 8 }; + static const char * const names[] = { + "x", + "y" + }; + static const ::flatbuffers::TypeTable tt = { + ::flatbuffers::ST_STRUCT, 2, type_codes, nullptr, nullptr, values, names + }; + return &tt; +} + +inline const ::flatbuffers::TypeTable *SingleVec4TypeTable() { + static const ::flatbuffers::TypeCode type_codes[] = { + { ::flatbuffers::ET_FLOAT, 0, -1 }, + { ::flatbuffers::ET_FLOAT, 0, -1 }, + { ::flatbuffers::ET_FLOAT, 0, -1 }, + { ::flatbuffers::ET_FLOAT, 0, -1 } + }; + static const int64_t values[] = { 0, 4, 8, 12, 16 }; + static const char * const names[] = { + "x", + "y", + "z", + "w" + }; + static const ::flatbuffers::TypeTable tt = { + ::flatbuffers::ST_STRUCT, 4, type_codes, nullptr, nullptr, values, names + }; + return &tt; +} + +inline const ::flatbuffers::TypeTable *ArrayOfVec2TypeTable() { + static const ::flatbuffers::TypeCode type_codes[] = { + { ::flatbuffers::ET_FLOAT, 1, -1 }, + { ::flatbuffers::ET_FLOAT, 1, -1 } + }; + static const char * const names[] = { + "xs", + "ys" + }; + static const ::flatbuffers::TypeTable tt = { + ::flatbuffers::ST_TABLE, 2, type_codes, nullptr, nullptr, nullptr, names + }; + return &tt; +} + +inline const ::flatbuffers::TypeTable *ArrayOfVec4TypeTable() { + static const ::flatbuffers::TypeCode type_codes[] = { + { ::flatbuffers::ET_FLOAT, 1, -1 }, + { ::flatbuffers::ET_FLOAT, 1, -1 }, + { ::flatbuffers::ET_FLOAT, 1, -1 }, + { ::flatbuffers::ET_FLOAT, 1, -1 } + }; + static const char * const names[] = { + "xs", + "ys", + "zs", + "ws" + }; + static const ::flatbuffers::TypeTable tt = { + ::flatbuffers::ST_TABLE, 4, type_codes, nullptr, nullptr, nullptr, names + }; + return &tt; +} + +inline const ::flatbuffers::TypeTable *EventMouseMotionTypeTable() { + static const ::flatbuffers::TypeCode type_codes[] = { + { ::flatbuffers::ET_SEQUENCE, 0, 0 }, + { ::flatbuffers::ET_UINT, 0, -1 }, + { ::flatbuffers::ET_BOOL, 0, -1 } + }; + static const ::flatbuffers::TypeFunction type_refs[] = { + UserInteractionFB::SingleVec2TypeTable + }; + static const char * const names[] = { + "pos", + "mouse_id", + "is_touch" + }; + static const ::flatbuffers::TypeTable tt = { + ::flatbuffers::ST_TABLE, 3, type_codes, type_refs, nullptr, nullptr, names + }; + return &tt; +} + +inline const ::flatbuffers::TypeTable *EventMouseWheelTypeTable() { + static const ::flatbuffers::TypeCode type_codes[] = { + { ::flatbuffers::ET_SEQUENCE, 0, 0 }, + { ::flatbuffers::ET_UINT, 0, -1 }, + { ::flatbuffers::ET_BOOL, 0, -1 } + }; + static const ::flatbuffers::TypeFunction type_refs[] = { + UserInteractionFB::SingleVec2TypeTable + }; + static const char * const names[] = { + "pos", + "mouse_id", + "is_touch" + }; + static const ::flatbuffers::TypeTable tt = { + ::flatbuffers::ST_TABLE, 3, type_codes, type_refs, nullptr, nullptr, names + }; + return &tt; +} + +inline const ::flatbuffers::TypeTable *EventMouseButtonTypeTable() { + static const ::flatbuffers::TypeCode type_codes[] = { + { ::flatbuffers::ET_SEQUENCE, 0, 0 }, + { ::flatbuffers::ET_UINT, 0, -1 }, + { ::flatbuffers::ET_BOOL, 0, -1 }, + { ::flatbuffers::ET_UCHAR, 0, 1 }, + { ::flatbuffers::ET_UCHAR, 0, 2 } + }; + static const ::flatbuffers::TypeFunction type_refs[] = { + UserInteractionFB::SingleVec2TypeTable, + UserInteractionFB::MouseButtonTypeTable, + UserInteractionFB::MouseButtonEventTypeTypeTable + }; + static const char * const names[] = { + "pos", + "mouse_id", + "is_touch", + "button", + "type" + }; + static const ::flatbuffers::TypeTable tt = { + ::flatbuffers::ST_TABLE, 5, type_codes, type_refs, nullptr, nullptr, names + }; + return &tt; +} + +inline const ::flatbuffers::TypeTable *EventTextInputTypeTable() { + static const ::flatbuffers::TypeCode type_codes[] = { + { ::flatbuffers::ET_STRING, 0, -1 } + }; + static const char * const names[] = { + "text" + }; + static const ::flatbuffers::TypeTable tt = { + ::flatbuffers::ST_TABLE, 1, type_codes, nullptr, nullptr, nullptr, names + }; + return &tt; +} + +inline const ::flatbuffers::TypeTable *EventTypeTable() { + static const ::flatbuffers::TypeCode type_codes[] = { + { ::flatbuffers::ET_UTYPE, 0, 0 }, + { ::flatbuffers::ET_SEQUENCE, 0, 0 } + }; + static const ::flatbuffers::TypeFunction type_refs[] = { + UserInteractionFB::UserInteractionTypeTable + }; + static const char * const names[] = { + "event_type", + "event" + }; + static const ::flatbuffers::TypeTable tt = { + ::flatbuffers::ST_TABLE, 2, type_codes, type_refs, nullptr, nullptr, names + }; + return &tt; +} + inline const UserInteractionFB::Event *GetEvent(const void *buf) { return ::flatbuffers::GetRoot(buf); }