From 9c9eda84bc60b1ca5222823d490c59c79a34ea4c Mon Sep 17 00:00:00 2001 From: bernatx Date: Wed, 8 Jun 2022 23:22:30 +0200 Subject: [PATCH] Multi GPU first version --- LibCarla/cmake/client/CMakeLists.txt | 6 + LibCarla/cmake/server/CMakeLists.txt | 6 +- LibCarla/source/carla/Buffer.h | 2 + .../source/carla/client/ServerSideSensor.cpp | 4 + .../source/carla/client/detail/Client.cpp | 4 +- LibCarla/source/carla/geom/BoundingBox.h | 4 +- LibCarla/source/carla/geom/Location.h | 4 +- LibCarla/source/carla/geom/Mesh.h | 2 + LibCarla/source/carla/geom/Rotation.h | 4 +- LibCarla/source/carla/geom/Transform.h | 2 + LibCarla/source/carla/multigpu/commands.h | 27 + .../source/carla/multigpu/incomingMessage.h | 53 + LibCarla/source/carla/multigpu/listener.cpp | 55 + LibCarla/source/carla/multigpu/listener.h | 79 + LibCarla/source/carla/multigpu/primary.cpp | 219 + LibCarla/source/carla/multigpu/primary.h | 110 + .../source/carla/multigpu/primaryCommands.cpp | 66 + .../source/carla/multigpu/primaryCommands.h | 52 + LibCarla/source/carla/multigpu/router.cpp | 147 + LibCarla/source/carla/multigpu/router.h | 75 + LibCarla/source/carla/multigpu/secondary.cpp | 284 + LibCarla/source/carla/multigpu/secondary.h | 86 + .../carla/multigpu/secondaryCommands.cpp | 36 + .../source/carla/multigpu/secondaryCommands.h | 34 + LibCarla/source/carla/rpc/ActorAttribute.h | 4 +- LibCarla/source/carla/rpc/ActorDescription.h | 4 +- LibCarla/source/carla/rpc/Color.h | 4 +- LibCarla/source/carla/rpc/EpisodeSettings.h | 4 +- LibCarla/source/carla/rpc/FloatColor.h | 4 +- LibCarla/source/carla/rpc/Server.h | 2 + LibCarla/source/carla/rpc/String.h | 4 +- LibCarla/source/carla/rpc/VehicleControl.h | 4 +- LibCarla/source/carla/rpc/VehicleLightState.h | 4 +- .../source/carla/rpc/WalkerBoneControlIn.h | 4 +- .../source/carla/rpc/WalkerBoneControlOut.h | 4 +- LibCarla/source/carla/rpc/WalkerControl.h | 4 +- LibCarla/source/carla/rpc/WeatherParameters.h | 4 +- LibCarla/source/carla/streaming/Server.h | 5 + .../carla/streaming/detail/Dispatcher.cpp | 81 +- .../carla/streaming/detail/Dispatcher.h | 12 +- .../carla/streaming/detail/MultiStreamState.h | 11 +- .../source/carla/streaming/detail/Stream.h | 5 + .../source/carla/streaming/detail/Token.h | 11 +- .../streaming/detail/tcp/ServerSession.cpp | 7 +- .../source/carla/streaming/low_level/Client.h | 1 + .../source/carla/streaming/low_level/Server.h | 5 + LibCarla/source/compiler/disable-ue4-macros.h | 6704 ++++++++++++++++- LibCarla/source/compiler/enable-ue4-macros.h | 2236 +++++- .../test/server/test_benchmark_streaming.cpp | 2 +- .../Carla/Source/Carla/Game/CarlaEngine.cpp | 151 +- .../Carla/Source/Carla/Game/CarlaEngine.h | 19 + .../Carla/Source/Carla/Game/CarlaEpisode.cpp | 16 + .../Carla/Source/Carla/Game/CarlaEpisode.h | 17 + .../Carla/Source/Carla/Game/FrameData.cpp | 1032 +++ .../Carla/Source/Carla/Game/FrameData.h | 158 + .../Carla/Source/Carla/Lights/CarlaLight.cpp | 1 + .../Source/Carla/OpenDrive/OpenDrive.cpp | 3 +- .../Source/Carla/OpenDrive/OpenDriveActor.cpp | 3 + .../Source/Carla/Recorder/CarlaRecorder.h | 3 +- .../Recorder/CarlaRecorderAnimVehicle.cpp | 25 +- .../Carla/Recorder/CarlaRecorderAnimVehicle.h | 11 +- .../Recorder/CarlaRecorderAnimWalker.cpp | 25 +- .../Carla/Recorder/CarlaRecorderAnimWalker.h | 12 +- .../Recorder/CarlaRecorderBoundingBox.cpp | 12 +- .../Carla/Recorder/CarlaRecorderBoundingBox.h | 14 +- .../Carla/Recorder/CarlaRecorderCollision.cpp | 8 +- .../Carla/Recorder/CarlaRecorderCollision.h | 8 +- .../Carla/Recorder/CarlaRecorderEventAdd.cpp | 23 +- .../Carla/Recorder/CarlaRecorderEventAdd.h | 10 +- .../Carla/Recorder/CarlaRecorderEventDel.cpp | 27 +- .../Carla/Recorder/CarlaRecorderEventDel.h | 10 +- .../Recorder/CarlaRecorderEventParent.cpp | 28 +- .../Carla/Recorder/CarlaRecorderEventParent.h | 12 +- .../Recorder/CarlaRecorderFrameCounter.cpp | 26 + .../Recorder/CarlaRecorderFrameCounter.h | 22 + .../Carla/Recorder/CarlaRecorderFrames.cpp | 8 +- .../Carla/Recorder/CarlaRecorderFrames.h | 10 +- .../Carla/Recorder/CarlaRecorderHelpers.cpp | 12 +- .../Carla/Recorder/CarlaRecorderHelpers.h | 26 +- .../Source/Carla/Recorder/CarlaRecorderInfo.h | 6 +- .../Recorder/CarlaRecorderKinematics.cpp | 6 +- .../Carla/Recorder/CarlaRecorderKinematics.h | 8 +- .../Recorder/CarlaRecorderLightScene.cpp | 25 +- .../Carla/Recorder/CarlaRecorderLightScene.h | 12 +- .../Recorder/CarlaRecorderLightVehicle.cpp | 25 +- .../Recorder/CarlaRecorderLightVehicle.h | 12 +- .../Recorder/CarlaRecorderPhysicsControl.cpp | 6 +- .../Recorder/CarlaRecorderPhysicsControl.h | 8 +- .../Recorder/CarlaRecorderPlatformTime.cpp | 4 +- .../Recorder/CarlaRecorderPlatformTime.h | 6 +- .../Carla/Recorder/CarlaRecorderPosition.cpp | 25 +- .../Carla/Recorder/CarlaRecorderPosition.h | 12 +- .../Carla/Recorder/CarlaRecorderState.cpp | 25 +- .../Carla/Recorder/CarlaRecorderState.h | 12 +- .../Recorder/CarlaRecorderTraficLightTime.cpp | 6 +- .../Recorder/CarlaRecorderTraficLightTime.h | 8 +- .../Source/Carla/Sensor/AsyncDataStream.h | 10 + .../Carla/Source/Carla/Sensor/DVSCamera.cpp | 2 +- .../Carla/Source/Carla/Sensor/DataStream.h | 5 + .../Carla/Source/Carla/Sensor/PixelReader.cpp | 4 +- .../Carla/Source/Carla/Sensor/PixelReader.h | 2 +- .../Source/Carla/Sensor/PixelReader2.cpp | 208 + .../Carla/Source/Carla/Sensor/PixelReader2.h | 150 + .../Carla/Sensor/SceneCaptureCamera.cpp | 35 +- .../Source/Carla/Sensor/SceneCaptureCamera.h | 10 +- .../Carla/Sensor/SceneCaptureSensor.cpp | 2 +- .../Source/Carla/Sensor/SceneCaptureSensor.h | 11 +- .../Carla/Source/Carla/Sensor/Sensor.cpp | 33 +- .../Carla/Source/Carla/Sensor/Sensor.h | 15 +- .../Source/Carla/Sensor/SensorManager.cpp | 26 + .../Carla/Source/Carla/Sensor/SensorManager.h | 26 + .../Carla/Source/Carla/Server/CarlaServer.cpp | 96 +- .../Carla/Source/Carla/Server/CarlaServer.h | 13 +- .../Source/Carla/Settings/CarlaSettings.cpp | 30 +- .../Source/Carla/Settings/CarlaSettings.h | 11 +- .../Carla/Traffic/SpeedLimitComponent.cpp | 12 +- .../Carla/Traffic/StopSignComponent.cpp | 3 + .../Carla/Traffic/TrafficLightComponent.cpp | 1 + .../Carla/Traffic/TrafficLightManager.cpp | 3 + .../Carla/Vehicle/CarlaWheeledVehicle.cpp | 1 + Util/BuildTools/BuildCarlaUE4.bat | 9 +- Util/BuildTools/BuildCarlaUE4.sh | 8 +- Util/BuildTools/Package.bat | 35 +- Util/BuildTools/Windows.mk | 2 +- 124 files changed, 12911 insertions(+), 281 deletions(-) create mode 100644 LibCarla/source/carla/multigpu/commands.h create mode 100644 LibCarla/source/carla/multigpu/incomingMessage.h create mode 100644 LibCarla/source/carla/multigpu/listener.cpp create mode 100644 LibCarla/source/carla/multigpu/listener.h create mode 100644 LibCarla/source/carla/multigpu/primary.cpp create mode 100644 LibCarla/source/carla/multigpu/primary.h create mode 100644 LibCarla/source/carla/multigpu/primaryCommands.cpp create mode 100644 LibCarla/source/carla/multigpu/primaryCommands.h create mode 100644 LibCarla/source/carla/multigpu/router.cpp create mode 100644 LibCarla/source/carla/multigpu/router.h create mode 100644 LibCarla/source/carla/multigpu/secondary.cpp create mode 100644 LibCarla/source/carla/multigpu/secondary.h create mode 100644 LibCarla/source/carla/multigpu/secondaryCommands.cpp create mode 100644 LibCarla/source/carla/multigpu/secondaryCommands.h create mode 100644 Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Game/FrameData.cpp create mode 100644 Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Game/FrameData.h create mode 100644 Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Recorder/CarlaRecorderFrameCounter.cpp create mode 100644 Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Recorder/CarlaRecorderFrameCounter.h create mode 100644 Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Sensor/PixelReader2.cpp create mode 100644 Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Sensor/PixelReader2.h create mode 100644 Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Sensor/SensorManager.cpp create mode 100644 Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Sensor/SensorManager.h diff --git a/LibCarla/cmake/client/CMakeLists.txt b/LibCarla/cmake/client/CMakeLists.txt index d1570e3a7..f0ebfeeb9 100644 --- a/LibCarla/cmake/client/CMakeLists.txt +++ b/LibCarla/cmake/client/CMakeLists.txt @@ -224,6 +224,12 @@ file(GLOB libcarla_carla_streaming_low_level_sources set(libcarla_sources "${libcarla_sources};${libcarla_carla_streaming_low_level_sources}") install(FILES ${libcarla_carla_streaming_low_level_sources} DESTINATION include/carla/streaming/low_level) +file(GLOB libcarla_carla_multigpu_sources + "${libcarla_source_path}/carla/multigpu/*.cpp" + "${libcarla_source_path}/carla/multigpu/*.h") +set(libcarla_sources "${libcarla_sources};${libcarla_carla_multigpu_sources}") +install(FILES ${libcarla_carla_multigpu_sources} DESTINATION include/carla/multigpu) + file(GLOB libcarla_odr_spiral_sources "${libcarla_source_thirdparty_path}/odrSpiral/*.cpp" "${libcarla_source_thirdparty_path}/odrSpiral/*.h") diff --git a/LibCarla/cmake/server/CMakeLists.txt b/LibCarla/cmake/server/CMakeLists.txt index 60fe079e1..070fb5062 100644 --- a/LibCarla/cmake/server/CMakeLists.txt +++ b/LibCarla/cmake/server/CMakeLists.txt @@ -68,6 +68,9 @@ install(FILES ${libcarla_carla_streaming_detail_tcp_headers} DESTINATION include file(GLOB libcarla_carla_streaming_low_level_headers "${libcarla_source_path}/carla/streaming/low_level/*.h") install(FILES ${libcarla_carla_streaming_low_level_headers} DESTINATION include/carla/streaming/low_level) +file(GLOB libcarla_carla_multigpu_headers "${libcarla_source_path}/carla/multigpu/*.h") +install(FILES ${libcarla_carla_multigpu_headers} DESTINATION include/carla/multigpu) + install(DIRECTORY "${BOOST_INCLUDE_PATH}/boost" DESTINATION include) if(WIN32) @@ -109,8 +112,9 @@ file(GLOB libcarla_server_sources "${libcarla_source_path}/carla/streaming/detail/*.cpp" "${libcarla_source_path}/carla/streaming/detail/*.h" "${libcarla_source_path}/carla/streaming/detail/tcp/*.cpp" - "${libcarla_source_path}/carla/streaming/detail/tcp/*.h" "${libcarla_source_path}/carla/streaming/low_level/*.h" + "${libcarla_source_path}/carla/multigpu/*.h" + "${libcarla_source_path}/carla/multigpu/*.cpp" "${libcarla_source_thirdparty_path}/odrSpiral/*.cpp" "${libcarla_source_thirdparty_path}/odrSpiral/*.h" "${libcarla_source_thirdparty_path}/moodycamel/*.cpp" diff --git a/LibCarla/source/carla/Buffer.h b/LibCarla/source/carla/Buffer.h index 27b9ca4c3..1d8d9c583 100644 --- a/LibCarla/source/carla/Buffer.h +++ b/LibCarla/source/carla/Buffer.h @@ -18,7 +18,9 @@ #include #ifdef LIBCARLA_INCLUDED_FROM_UE4 +#include #include "Containers/Array.h" +#include #endif // LIBCARLA_INCLUDED_FROM_UE4 namespace carla { diff --git a/LibCarla/source/carla/client/ServerSideSensor.cpp b/LibCarla/source/carla/client/ServerSideSensor.cpp index 52ede6457..e5029d884 100644 --- a/LibCarla/source/carla/client/ServerSideSensor.cpp +++ b/LibCarla/source/carla/client/ServerSideSensor.cpp @@ -15,6 +15,7 @@ namespace carla { namespace client { ServerSideSensor::~ServerSideSensor() { + log_warning("calling sensor destructor ", GetDisplayId()); if (IsAlive() && IsListening()) { log_warning( "sensor object went out of the scope but the sensor is still alive", @@ -31,12 +32,14 @@ namespace client { } void ServerSideSensor::Listen(CallbackFunctionType callback) { + log_warning("calling sensor Listen() ", GetDisplayId()); log_debug(GetDisplayId(), ": subscribing to stream"); GetEpisode().Lock()->SubscribeToSensor(*this, std::move(callback)); _is_listening = true; } void ServerSideSensor::Stop() { + log_warning("calling sensor Stop() ", GetDisplayId()); if (!_is_listening) { log_warning( "attempting to unsubscribe from stream but sensor wasn't listening:", @@ -48,6 +51,7 @@ namespace client { } bool ServerSideSensor::Destroy() { + log_warning("calling sensor Destroy() ", GetDisplayId()); if (IsListening()) { Stop(); } diff --git a/LibCarla/source/carla/client/detail/Client.cpp b/LibCarla/source/carla/client/detail/Client.cpp index 56c9cb8b3..e3f48fd47 100644 --- a/LibCarla/source/carla/client/detail/Client.cpp +++ b/LibCarla/source/carla/client/detail/Client.cpp @@ -575,7 +575,9 @@ namespace detail { void Client::SubscribeToStream( const streaming::Token &token, std::function callback) { - _pimpl->streaming_client.Subscribe(token, std::move(callback)); + carla::streaming::detail::token_type thisToken(token); + streaming::Token receivedToken = _pimpl->CallAndWait("get_sensor_token", thisToken.get_stream_id()); + _pimpl->streaming_client.Subscribe(receivedToken, std::move(callback)); } void Client::UnSubscribeFromStream(const streaming::Token &token) { diff --git a/LibCarla/source/carla/geom/BoundingBox.h b/LibCarla/source/carla/geom/BoundingBox.h index 8790d78dc..f8f566317 100644 --- a/LibCarla/source/carla/geom/BoundingBox.h +++ b/LibCarla/source/carla/geom/BoundingBox.h @@ -15,7 +15,9 @@ #include #ifdef LIBCARLA_INCLUDED_FROM_UE4 -# include "Carla/Util/BoundingBox.h" +#include +#include "Carla/Util/BoundingBox.h" +#include #endif // LIBCARLA_INCLUDED_FROM_UE4 namespace carla { diff --git a/LibCarla/source/carla/geom/Location.h b/LibCarla/source/carla/geom/Location.h index 60baf0072..162243ab5 100644 --- a/LibCarla/source/carla/geom/Location.h +++ b/LibCarla/source/carla/geom/Location.h @@ -11,7 +11,9 @@ #include "carla/geom/Math.h" #ifdef LIBCARLA_INCLUDED_FROM_UE4 -# include "Math/Vector.h" +#include +#include "Math/Vector.h" +#include #endif // LIBCARLA_INCLUDED_FROM_UE4 namespace carla { diff --git a/LibCarla/source/carla/geom/Mesh.h b/LibCarla/source/carla/geom/Mesh.h index 307a7e1df..e5882c760 100644 --- a/LibCarla/source/carla/geom/Mesh.h +++ b/LibCarla/source/carla/geom/Mesh.h @@ -12,7 +12,9 @@ #include #ifdef LIBCARLA_INCLUDED_FROM_UE4 +#include #include "Util/ProceduralCustomMesh.h" +#include #endif // LIBCARLA_INCLUDED_FROM_UE4 namespace carla { diff --git a/LibCarla/source/carla/geom/Rotation.h b/LibCarla/source/carla/geom/Rotation.h index 3096dc2de..aec5637d8 100644 --- a/LibCarla/source/carla/geom/Rotation.h +++ b/LibCarla/source/carla/geom/Rotation.h @@ -11,7 +11,9 @@ #include "carla/geom/Vector3D.h" #ifdef LIBCARLA_INCLUDED_FROM_UE4 -# include "Math/Rotator.h" +#include +#include "Math/Rotator.h" +#include #endif // LIBCARLA_INCLUDED_FROM_UE4 namespace carla { diff --git a/LibCarla/source/carla/geom/Transform.h b/LibCarla/source/carla/geom/Transform.h index 41d4da319..198c59d7a 100644 --- a/LibCarla/source/carla/geom/Transform.h +++ b/LibCarla/source/carla/geom/Transform.h @@ -12,7 +12,9 @@ #include "carla/geom/Rotation.h" #ifdef LIBCARLA_INCLUDED_FROM_UE4 +#include #include "Math/Transform.h" +#include #endif // LIBCARLA_INCLUDED_FROM_UE4 namespace carla { diff --git a/LibCarla/source/carla/multigpu/commands.h b/LibCarla/source/carla/multigpu/commands.h new file mode 100644 index 000000000..f64aa538a --- /dev/null +++ b/LibCarla/source/carla/multigpu/commands.h @@ -0,0 +1,27 @@ +// Copyright (c) 2022 Computer Vision Center (CVC) at the Universitat Autonoma +// de Barcelona (UAB). +// +// This work is licensed under the terms of the MIT license. +// For a copy, see . + +#pragma once + +#include + +namespace carla { +namespace multigpu { + +enum MultiGPUCommand : uint32_t { + SEND_FRAME = 0, + LOAD_MAP, + GET_TOKEN, + YOU_ALIVE +}; + +struct CommandHeader { + MultiGPUCommand id; + uint32_t size; +}; + +} // namespace multigpu +} // namespace carla diff --git a/LibCarla/source/carla/multigpu/incomingMessage.h b/LibCarla/source/carla/multigpu/incomingMessage.h new file mode 100644 index 000000000..7660325b2 --- /dev/null +++ b/LibCarla/source/carla/multigpu/incomingMessage.h @@ -0,0 +1,53 @@ +// Copyright (c) 2022 Computer Vision Center (CVC) at the Universitat Autonoma +// de Barcelona (UAB). +// +// This work is licensed under the terms of the MIT license. +// For a copy, see . + +#include "carla/BufferPool.h" +#include "carla/Debug.h" +#include "carla/Exception.h" +#include "carla/Logging.h" +#include "carla/streaming/detail/Types.h" +#include "carla/Time.h" + +#include + +namespace carla { +namespace multigpu { + + /// Helper for reading incoming TCP messages. Allocates the whole message in + /// a single buffer. + class IncomingMessage { + public: + + explicit IncomingMessage(Buffer &&buffer) : _buffer(std::move(buffer)) {} + + boost::asio::mutable_buffer size_as_buffer() { + return boost::asio::buffer(&_size, sizeof(_size)); + } + + boost::asio::mutable_buffer buffer() { + DEBUG_ASSERT(_size > 0u); + _buffer.reset(_size); + return _buffer.buffer(); + } + + auto size() const { + return _size; + } + + auto pop() { + return std::move(_buffer); + } + + private: + + carla::streaming::detail::message_size_type _size = 0u; + + Buffer _buffer; + }; + + +} // namespace multigpu +} // namespace carla diff --git a/LibCarla/source/carla/multigpu/listener.cpp b/LibCarla/source/carla/multigpu/listener.cpp new file mode 100644 index 000000000..a2e709668 --- /dev/null +++ b/LibCarla/source/carla/multigpu/listener.cpp @@ -0,0 +1,55 @@ +// Copyright (c) 2022 Computer Vision Center (CVC) at the Universitat Autonoma +// de Barcelona (UAB). +// +// This work is licensed under the terms of the MIT license. +// For a copy, see . + +#include "carla/multigpu/listener.h" +#include "carla/multigpu/primary.h" + +#include + +#include "carla/Logging.h" + +#include + +namespace carla { +namespace multigpu { + + Listener::Listener(boost::asio::io_context &io_context, endpoint ep) + : _io_context(io_context), + _acceptor(_io_context, std::move(ep)), + _timeout(time_duration::seconds(1u)) { + _acceptor.listen(); + } + + Listener::~Listener() { + } + + void Listener::Stop() { + _acceptor.cancel(); + } + + void Listener::OpenSession( + time_duration timeout, + callback_function_type on_opened, + callback_function_type on_closed, + callback_function_type_response on_response) { + + using boost::system::error_code; + + auto session = std::make_shared(_io_context, timeout, *this); + auto self = shared_from_this(); + _acceptor.async_accept(session->_socket, [=](error_code ec) { + if (!ec) { + session->Open(on_opened, on_closed, on_response); + } else { + log_error("tcp accept error:", ec.message()); + } + + self->OpenSession(timeout, on_opened, on_closed, on_response); + }); + } + +} // namespace multigpu +} // namespace carla diff --git a/LibCarla/source/carla/multigpu/listener.h b/LibCarla/source/carla/multigpu/listener.h new file mode 100644 index 000000000..b1ff7a6a5 --- /dev/null +++ b/LibCarla/source/carla/multigpu/listener.h @@ -0,0 +1,79 @@ +// Copyright (c) 2022 Computer Vision Center (CVC) at the Universitat Autonoma +// de Barcelona (UAB). +// +// This work is licensed under the terms of the MIT license. +// For a copy, see . + +#pragma once + +#include "carla/NonCopyable.h" +#include "carla/Time.h" +#include "carla/Buffer.h" + +#include +#include +#include + +#include + +namespace carla { +namespace multigpu { + + class Primary; + + /// @warning This server cannot be destructed before its @a io_context is + /// stopped. + class Listener : public std::enable_shared_from_this, private NonCopyable { + public: + + using endpoint = boost::asio::ip::tcp::endpoint; + using protocol_type = endpoint::protocol_type; + using Session = std::shared_ptr; + using callback_function_type = std::function)>; + using callback_function_type_response = std::function, carla::Buffer)>; + + explicit Listener(boost::asio::io_context &io_context, endpoint ep); + ~Listener(); + + endpoint GetLocalEndpoint() const { + return _acceptor.local_endpoint(); + } + + /// Set session time-out. Applies only to newly created sessions. By default + /// the time-out is set to 10 seconds. + void SetTimeout(time_duration timeout) { + _timeout = timeout; + } + + /// Start listening for connections. On each new connection, @a + /// on_session_opened is called, and @a on_session_closed when the session + /// is closed, also @a on_response is called when an answer is received. + void Listen(callback_function_type on_session_opened, + callback_function_type on_session_closed, + callback_function_type_response on_response) { + boost::asio::post(_io_context, [=]() { + OpenSession( + _timeout, + std::move(on_session_opened), + std::move(on_session_closed), + std::move(on_response)); + }); + } + + void Stop(); + + private: + + void OpenSession( + time_duration timeout, + callback_function_type on_session_opened, + callback_function_type on_session_closed, + callback_function_type_response on_response); + + boost::asio::io_context &_io_context; + boost::asio::ip::tcp::acceptor _acceptor; + std::atomic _timeout; + }; + +} // namespace multigpu +} // namespace carla diff --git a/LibCarla/source/carla/multigpu/primary.cpp b/LibCarla/source/carla/multigpu/primary.cpp new file mode 100644 index 000000000..87988878e --- /dev/null +++ b/LibCarla/source/carla/multigpu/primary.cpp @@ -0,0 +1,219 @@ +// Copyright (c) 2022 Computer Vision Center (CVC) at the Universitat Autonoma +// de Barcelona (UAB). +// +// This work is licensed under the terms of the MIT license. +// For a copy, see . + +#include "carla/multigpu/primary.h" + +#include "carla/Debug.h" +#include "carla/Logging.h" +#include "carla/multigpu/incomingMessage.h" +#include "carla/multigpu/listener.h" + +#include +#include +#include +#include + +#include +#include + +namespace carla { +namespace multigpu { + + static std::atomic_size_t SESSION_COUNTER{0u}; + + Primary::Primary( + boost::asio::io_context &io_context, + const time_duration timeout, + Listener &server) + : LIBCARLA_INITIALIZE_LIFETIME_PROFILER( + std::string("tcp multigpu server session ") + std::to_string(SESSION_COUNTER)), + _server(server), + _session_id(SESSION_COUNTER++), + _socket(io_context), + _timeout(timeout), + _deadline(io_context), + _strand(io_context), + _buffer_pool(std::make_shared()) {} + + Primary::~Primary() { + if (_socket.is_open()) { + boost::system::error_code ec; + _socket.shutdown(boost::asio::socket_base::shutdown_both, ec); + _socket.close(); + } + } + + void Primary::Open( + Listener::callback_function_type on_opened, + Listener::callback_function_type on_closed, + Listener::callback_function_type_response on_response) { + DEBUG_ASSERT(on_opened && on_closed); + + // This forces not using Nagle's algorithm. + // Improves the sync mode velocity on Linux by a factor of ~3. + const boost::asio::ip::tcp::no_delay option(true); + _socket.set_option(option); + + // callbacks + _on_closed = std::move(on_closed); + _on_response = std::move(on_response); + on_opened(shared_from_this()); + + ReadData(); + } + + void Primary::Write(std::shared_ptr message) { + DEBUG_ASSERT(message != nullptr); + DEBUG_ASSERT(!message->empty()); + std::weak_ptr weak = shared_from_this(); + boost::asio::post(_strand, [=]() { + auto self = weak.lock(); + if (!self) return; + if (!self->_socket.is_open()) { + return; + } + + auto handle_sent = [weak, message](const boost::system::error_code &ec, size_t DEBUG_ONLY(bytes)) { + auto self = weak.lock(); + if (!self) return; + if (ec) { + log_error("session ", self->_session_id, ": error sending data: ", ec.message()); + self->CloseNow(); + } else { + // DEBUG_ASSERT_EQ(bytes, sizeof(message_size_type) + message->size()); + } + }; + + self->_deadline.expires_from_now(self->_timeout); + boost::asio::async_write( + self->_socket, + message->GetBufferSequence(), + boost::asio::bind_executor(self->_strand, handle_sent)); + }); + } + + void Primary::Write(std::string text) { + std::weak_ptr weak = shared_from_this(); + boost::asio::post(_strand, [=]() { + auto self = weak.lock(); + if (!self) return; + if (!self->_socket.is_open()) { + return; + } + + auto handle_sent = [weak](const boost::system::error_code &ec, size_t DEBUG_ONLY(bytes)) { + // auto self = weak.lock(); + // if (!self) return; + }; + + // sent first size buffer + self->_deadline.expires_from_now(self->_timeout); + int this_size = text.size(); + boost::asio::async_write( + self->_socket, + boost::asio::buffer(&this_size, sizeof(this_size)), + boost::asio::bind_executor(self->_strand, [](const boost::system::error_code &ec, size_t bytes){ })); + // send characters + boost::asio::async_write( + self->_socket, + boost::asio::buffer(text.c_str(), text.size()), + boost::asio::bind_executor(self->_strand, handle_sent)); + }); + } + + void Primary::ReadData() { + std::weak_ptr weak = shared_from_this(); + boost::asio::post(_strand, [weak]() { + auto self = weak.lock(); + if (!self) return; + + auto message = std::make_shared(self->_buffer_pool->Pop()); + + auto handle_read_data = [weak, message](boost::system::error_code ec, size_t DEBUG_ONLY(bytes)) { + auto self = weak.lock(); + if (!self) return; + if (!ec) { + DEBUG_ASSERT_EQ(bytes, message->size()); + DEBUG_ASSERT_NE(bytes, 0u); + // Move the buffer to the callback function and start reading the next + // piece of data. + self->_on_response(self, message->pop()); + std::cout << "Getting data on listener\n"; + self->ReadData(); + } else { + // As usual, if anything fails start over from the very top. + log_error("primary server: failed to read data: ", ec.message()); + } + }; + + auto handle_read_header = [weak, message, handle_read_data]( + boost::system::error_code ec, + size_t DEBUG_ONLY(bytes)) { + auto self = weak.lock(); + if (!self) return; + if (!ec && (message->size() > 0u)) { + // Now that we know the size of the coming buffer, we can allocate our + // buffer and start putting data into it. + boost::asio::async_read( + self->_socket, + message->buffer(), + boost::asio::bind_executor(self->_strand, handle_read_data)); + } else { + if (ec) { + log_error("Primary server: failed to read header: ", ec.message()); + } + // Connect(); + self->Close(); + } + }; + + // Read the size of the buffer that is coming. + boost::asio::async_read( + self->_socket, + message->size_as_buffer(), + boost::asio::bind_executor(self->_strand, handle_read_header)); + }); + } + + void Primary::Close() { + std::weak_ptr weak = shared_from_this(); + boost::asio::post(_strand, [weak]() { + auto self = weak.lock(); + if (!self) return; + self->CloseNow(); + }); + } + + void Primary::StartTimer() { + if (_deadline.expires_at() <= boost::asio::deadline_timer::traits_type::now()) { + log_debug("session ", _session_id, " time out"); + Close(); + } else { + std::weak_ptr weak = shared_from_this(); + _deadline.async_wait([weak](boost::system::error_code ec) { + auto self = weak.lock(); + if (!self) return; + if (!ec) { + self->StartTimer(); + } else { + log_error("session ", self->_session_id, " timed out error: ", ec.message()); + } + }); + } + } + + void Primary::CloseNow() { + _deadline.cancel(); + if (_socket.is_open()) { + boost::system::error_code ec; + _socket.shutdown(boost::asio::socket_base::shutdown_both, ec); + _socket.close(); + _on_closed(shared_from_this()); + } + } + +} // namespace multigpu +} // namespace carla diff --git a/LibCarla/source/carla/multigpu/primary.h b/LibCarla/source/carla/multigpu/primary.h new file mode 100644 index 000000000..fb27deb63 --- /dev/null +++ b/LibCarla/source/carla/multigpu/primary.h @@ -0,0 +1,110 @@ +// Copyright (c) 2022 Computer Vision Center (CVC) at the Universitat Autonoma +// de Barcelona (UAB). +// +// This work is licensed under the terms of the MIT license. +// For a copy, see . + +#pragma once + +#include "carla/NonCopyable.h" +#include "carla/Time.h" +#include "carla/TypeTraits.h" +#include "carla/profiler/LifetimeProfiled.h" +#include "carla/streaming/detail/Types.h" +#include "carla/streaming/detail/tcp/Message.h" +#include "carla/multigpu/listener.h" + +#include +#include +#include +#include + +#include +#include + +namespace carla { +namespace multigpu { + + /// A TCP server session. When a session opens, it reads from the socket a + /// stream id object and passes itself to the callback functor. The session + /// closes itself after @a timeout of inactivity is met. + class Primary + : public std::enable_shared_from_this, + private profiler::LifetimeProfiled, + private NonCopyable { + public: + + using socket_type = boost::asio::ip::tcp::socket; + + explicit Primary( + boost::asio::io_context &io_context, + time_duration timeout, + Listener &server); + + ~Primary(); + + /// Starts the session and calls @a on_opened after successfully reading the + /// stream id, and @a on_closed once the session is closed. + void Open( + Listener::callback_function_type on_opened, + Listener::callback_function_type on_closed, + Listener::callback_function_type_response on_response); + + template + static auto MakeMessage(Buffers &&... buffers) { + static_assert( + are_same::value, + "This function only accepts arguments of type Buffer."); + return std::make_shared(std::move(buffers)...); + } + + /// Writes some data to the socket. + void Write(std::shared_ptr message); + + /// Writes a string + void Write(std::string text); + + /// read data + void ReadData(); + + /// Writes some data to the socket. + template + void Write(Buffers &&... buffers) { + Write(MakeMessage(std::move(buffers)...)); + } + + /// Post a job to close the session. + void Close(); + + private: + + void StartTimer(); + + void CloseNow(); + + friend class Listener; + + Listener &_server; + + const size_t _session_id; + + socket_type _socket; + + time_duration _timeout; + + boost::asio::deadline_timer _deadline; + + boost::asio::io_context::strand _strand; + + Listener::callback_function_type _on_closed; + + Listener::callback_function_type_response _on_response; + + std::shared_ptr _buffer_pool; + + bool _is_writing = false; + + }; + +} // namespace multigpu +} // namespace carla diff --git a/LibCarla/source/carla/multigpu/primaryCommands.cpp b/LibCarla/source/carla/multigpu/primaryCommands.cpp new file mode 100644 index 000000000..71f5b5498 --- /dev/null +++ b/LibCarla/source/carla/multigpu/primaryCommands.cpp @@ -0,0 +1,66 @@ +// Copyright (c) 2022 Computer Vision Center (CVC) at the Universitat Autonoma +// de Barcelona (UAB). +// +// This work is licensed under the terms of the MIT license. +// For a copy, see . + +#include "carla/multigpu/primaryCommands.h" + +// #include "carla/Logging.h" +#include "carla/multigpu/commands.h" +#include "carla/multigpu/primary.h" +#include "carla/multigpu/router.h" +#include "carla/streaming/detail/tcp/Message.h" +#include "carla/streaming/detail/Token.h" +#include "carla/streaming/detail/Types.h" + +namespace carla { +namespace multigpu { + +PrimaryCommands::PrimaryCommands() { +} + +PrimaryCommands::PrimaryCommands(std::shared_ptr router) : + _router(router) { +} + +// broadcast to all secondary servers the frame data +void PrimaryCommands::SendFrameData(carla::Buffer buffer) { + _router->Write(MultiGPUCommand::SEND_FRAME, std::move(buffer)); + // log_info("sending frame command"); +} + +// broadcast to all secondary servers the map to load +void PrimaryCommands::SendLoadMap(std::string map) { + // carla::Buffer buf((unsigned char *) map.c_str(), (size_t) map.size()); + log_info("sending load map command"); +} + +// send to who the router wants the request for a token +token_type PrimaryCommands::SendGetToken(carla::streaming::detail::stream_id_type sensor_id) { + log_info("asking for a token"); + carla::Buffer buf((carla::Buffer::value_type *) &sensor_id, (size_t) sizeof(carla::streaming::detail::stream_id_type)); + auto fut = _router->WriteToNext(MultiGPUCommand::GET_TOKEN, std::move(buf)); + + auto response = fut.get(); + token_type new_token(*reinterpret_cast(response.buffer.data())); + log_info("got a token: ", new_token.get_stream_id(), ", ", new_token.get_port()); + return new_token; +} + +// send to know if a connection is alive +void PrimaryCommands::SendIsAlive() { + std::string msg("Are you alive?"); + carla::Buffer buf((unsigned char *) msg.c_str(), (size_t) msg.size()); + log_info("sending is alive command"); + auto fut = _router->WriteToNext(MultiGPUCommand::YOU_ALIVE, std::move(buf)); + auto response = fut.get(); + log_info("response from alive command: ", response.buffer.data()); +} + +void PrimaryCommands::set_router(std::shared_ptr router) { + _router = router; +} + +} // namespace multigpu +} // namespace carla diff --git a/LibCarla/source/carla/multigpu/primaryCommands.h b/LibCarla/source/carla/multigpu/primaryCommands.h new file mode 100644 index 000000000..be03ef081 --- /dev/null +++ b/LibCarla/source/carla/multigpu/primaryCommands.h @@ -0,0 +1,52 @@ +// Copyright (c) 2022 Computer Vision Center (CVC) at the Universitat Autonoma +// de Barcelona (UAB). +// +// This work is licensed under the terms of the MIT license. +// For a copy, see . + +#pragma once + +// #include "carla/Logging.h" +#include "carla/multigpu/commands.h" +#include "carla/multigpu/primary.h" +#include "carla/streaming/detail/tcp/Message.h" +#include "carla/streaming/detail/Token.h" +#include "carla/streaming/detail/Types.h" + +namespace carla { +namespace multigpu { + +// using session = std::shared_ptr; +// using callback_response = std::function, carla::Buffer)>; +using token_type = carla::streaming::detail::token_type; + +class Router; + +class PrimaryCommands { + public: + + + PrimaryCommands(); + PrimaryCommands(std::shared_ptr router); + + // broadcast to all secondary servers the frame data + void SendFrameData(carla::Buffer buffer); + + // broadcast to all secondary servers the map to load + void SendLoadMap(std::string map); + + // send to one secondary to get the token of a sensor + token_type SendGetToken(carla::streaming::detail::stream_id_type sensor_id); + + // send to know if a connection is alive + void SendIsAlive(); + + void set_router(std::shared_ptr router); + + private: + + std::shared_ptr _router; +}; + +} // namespace multigpu +} // namespace carla diff --git a/LibCarla/source/carla/multigpu/router.cpp b/LibCarla/source/carla/multigpu/router.cpp new file mode 100644 index 000000000..a7db4759c --- /dev/null +++ b/LibCarla/source/carla/multigpu/router.cpp @@ -0,0 +1,147 @@ +// Copyright (c) 2022 Computer Vision Center (CVC) at the Universitat Autonoma +// de Barcelona (UAB). +// +// This work is licensed under the terms of the MIT license. +// For a copy, see . + +#include "carla/multigpu/router.h" + +#include "carla/multigpu/listener.h" +#include "carla/streaming/EndPoint.h" + +namespace carla { +namespace multigpu { + +Router::Router(void) : + _next(0) { } + +Router::~Router() { + ClearSessions(); + _listener->Stop(); + _pool.Stop(); +} + +Router::Router(uint16_t port) : + _next(0) { + + _endpoint = boost::asio::ip::tcp::endpoint(boost::asio::ip::address::from_string("0.0.0.0"), port); + _listener = std::make_shared(_pool.io_context(), _endpoint); +} + +void Router::SetCallbacks() { + // prepare server + std::weak_ptr weak = shared_from_this(); + + carla::multigpu::Listener::callback_function_type on_open = [=](std::shared_ptr session) { + auto self = weak.lock(); + if (!self) return; + self->ConnectSession(session); + }; + + carla::multigpu::Listener::callback_function_type on_close = [=](std::shared_ptr session) { + auto self = weak.lock(); + if (!self) return; + self->DisconnectSession(session); + }; + + carla::multigpu::Listener::callback_function_type_response on_response = [=](std::shared_ptr session, carla::Buffer buffer) { + auto self = weak.lock(); + if (!self) return; + std::lock_guard lock(self->_mutex); + auto prom =self-> _promises.find(session.get()); + if (prom != self->_promises.end()) { + log_info("Got data from secondary (with promise): ", buffer.size()); + prom->second->set_value({session, std::move(buffer)}); + self->_promises.erase(prom); + } else { + log_info("Got data from secondary (without promise): ", buffer.size()); + } + }; + + _commander.set_router(shared_from_this()); + + _listener->Listen(on_open, on_close, on_response); + log_info("Listening at ", _endpoint); +} + +void Router::AsyncRun(size_t worker_threads) { + _pool.AsyncRun(worker_threads); +} + +boost::asio::ip::tcp::endpoint Router::GetLocalEndpoint() const { + return _endpoint; +} + +void Router::ConnectSession(std::shared_ptr session) { + DEBUG_ASSERT(session != nullptr); + std::lock_guard lock(_mutex); + _sessions.emplace_back(std::move(session)); + log_info("Connected secondary servers:", _sessions.size()); +} + +void Router::DisconnectSession(std::shared_ptr session) { + DEBUG_ASSERT(session != nullptr); + std::lock_guard lock(_mutex); + if (_sessions.size() == 0) return; + _sessions.erase( + std::remove(_sessions.begin(), _sessions.end(), session), + _sessions.end()); + log_info("Connected secondary servers:", _sessions.size()); +} + +void Router::ClearSessions() { + std::lock_guard lock(_mutex); + _sessions.clear(); + log_info("Disconnecting all secondary servers"); +} + +void Router::Write(MultiGPUCommand id, Buffer &&buffer) { + // define the command header + CommandHeader header; + header.id = id; + header.size = buffer.size(); + Buffer buf_header((uint8_t *) &header, sizeof(header)); + + auto message = Primary::MakeMessage(std::move(buf_header), std::move(buffer)); + + // write to multiple servers + std::lock_guard lock(_mutex); + for (auto &s : _sessions) { + if (s != nullptr) { + s->Write(message); + } + } +} + +std::future Router::WriteToNext(MultiGPUCommand id, Buffer &&buffer) { + // define the command header + CommandHeader header; + header.id = id; + header.size = buffer.size(); + Buffer buf_header((uint8_t *) &header, sizeof(header)); + + auto message = Primary::MakeMessage(std::move(buf_header), std::move(buffer)); + + // create the promise for the posible answer + auto response = std::make_shared>(); + + // write to the next server only + std::lock_guard lock(_mutex); + if (_next >= _sessions.size()) { + _next = 0; + } + if (_next < _sessions.size()) { + // std::cout << "Sending to session " << _next << std::endl; + auto s = _sessions[_next]; + if (s != nullptr) { + _promises[s.get()] = response; + std::cout << "Updated promise into map: " << _promises.size() << std::endl; + s->Write(message); + } + } + ++_next; + return response->get_future(); +} + +} // namespace multigpu +} // namespace carla diff --git a/LibCarla/source/carla/multigpu/router.h b/LibCarla/source/carla/multigpu/router.h new file mode 100644 index 000000000..acf6ccda9 --- /dev/null +++ b/LibCarla/source/carla/multigpu/router.h @@ -0,0 +1,75 @@ +// Copyright (c) 2022 Computer Vision Center (CVC) at the Universitat Autonoma +// de Barcelona (UAB). +// +// This work is licensed under the terms of the MIT license. +// For a copy, see . + +#pragma once + +// #include "carla/Logging.h" +#include "carla/streaming/detail/tcp/Message.h" +#include "carla/ThreadPool.h" +#include "carla/multigpu/primary.h" +#include "carla/multigpu/primaryCommands.h" +#include "carla/multigpu/commands.h" + +#include +#include + +#include +#include +#include +#include + +namespace carla { +namespace multigpu { + + // class Primary; + class Listener; + + struct SessionInfo { + std::shared_ptr session; + carla::Buffer buffer; + }; + + class Router : public std::enable_shared_from_this { + public: + + Router(void); + explicit Router(uint16_t port); + ~Router(); + + void Write(MultiGPUCommand id, Buffer &&buffer); + std::future WriteToNext(MultiGPUCommand id, Buffer &&buffer); + + void SetCallbacks(); + void AsyncRun(size_t worker_threads); + + boost::asio::ip::tcp::endpoint GetLocalEndpoint() const; + + bool HasClientsConnected() { + return (!_sessions.empty()); + } + + PrimaryCommands &GetCommander() { + return _commander; + } + + private: + void ConnectSession(std::shared_ptr session); + void DisconnectSession(std::shared_ptr session); + void ClearSessions(); + + // mutex and thread pool must be at the beginning to be destroyed last + std::mutex _mutex; + ThreadPool _pool; + boost::asio::ip::tcp::endpoint _endpoint; + std::vector> _sessions; + std::shared_ptr _listener; + int _next; + std::unordered_map>> _promises; + PrimaryCommands _commander; + }; + +} // namespace multigpu +} // namespace carla diff --git a/LibCarla/source/carla/multigpu/secondary.cpp b/LibCarla/source/carla/multigpu/secondary.cpp new file mode 100644 index 000000000..a414cbaf4 --- /dev/null +++ b/LibCarla/source/carla/multigpu/secondary.cpp @@ -0,0 +1,284 @@ +// Copyright (c) 2022 Computer Vision Center (CVC) at the Universitat Autonoma +// de Barcelona (UAB). +// +// This work is licensed under the terms of the MIT license. +// For a copy, see . + +#include "carla/multigpu/incomingMessage.h" +#include "carla/multigpu/secondary.h" + +#include "carla/BufferPool.h" +#include "carla/Debug.h" +#include "carla/Exception.h" +#include "carla/Logging.h" +#include "carla/Time.h" + +#include +#include +#include +#include +#include + +#include + +namespace carla { +namespace multigpu { + + Secondary::Secondary( + boost::asio::ip::tcp::endpoint ep, + SecondaryCommands::callback_type callback) : + _pool(), + _endpoint(ep), + _buffer_pool(std::make_shared()), + _socket(_pool.io_context()), + _strand(_pool.io_context()), + _connection_timer(_pool.io_context()) { + + _commander.set_callback(callback); + } + + + Secondary::Secondary( + std::string ip, + uint16_t port, + SecondaryCommands::callback_type callback) : + _pool(), + _buffer_pool(std::make_shared()), + _socket(_pool.io_context()), + _strand(_pool.io_context()), + _connection_timer(_pool.io_context()) { + + boost::asio::ip::address ip_address = boost::asio::ip::address::from_string(ip); + _endpoint = boost::asio::ip::tcp::endpoint(ip_address, port); + _commander.set_callback(callback); + } + + Secondary::~Secondary() { + _pool.Stop(); + } + + void Secondary::Connect() { + AsyncRun(2u); + + _commander.set_secondary(shared_from_this()); + + std::weak_ptr weak = shared_from_this(); + boost::asio::post(_strand, [weak]() { + auto self = weak.lock(); + if (!self) return; + + if (self->_done) { + return; + } + + if (self->_socket.is_open()) { + self->_socket.close(); + } + + auto handle_connect = [weak](boost::system::error_code ec) { + auto self = weak.lock(); + if (!self) return; + if (ec) { + log_error("secondary server: connection failed:", ec.message()); + if (!self->_done) + self->Reconnect(); + return; + } + + if (self->_done) { + return; + } + + // This forces not using Nagle's algorithm. + // Improves the sync mode velocity on Linux by a factor of ~3. + self->_socket.set_option(boost::asio::ip::tcp::no_delay(true)); + + log_info("secondary server: connected to ", self->_endpoint); + + self->ReadData(); + }; + + self->_socket.async_connect(self->_endpoint, boost::asio::bind_executor(self->_strand, handle_connect)); + }); + } + + void Secondary::Stop() { + _connection_timer.cancel(); + std::weak_ptr weak = shared_from_this(); + boost::asio::post(_strand, [weak]() { + auto self = weak.lock(); + if (!self) return; + self->_done = true; + if (self->_socket.is_open()) { + self->_socket.close(); + } + }); + } + + void Secondary::Reconnect() { + std::weak_ptr weak = shared_from_this(); + _connection_timer.expires_from_now(time_duration::seconds(1u)); + _connection_timer.async_wait([weak](boost::system::error_code ec) { + auto self = weak.lock(); + if (!self) return; + if (!ec) { + self->Connect(); + } + }); + } + + void Secondary::AsyncRun(size_t worker_threads) { + _pool.AsyncRun(worker_threads); + } + + void Secondary::Write(std::shared_ptr message) { + DEBUG_ASSERT(message != nullptr); + DEBUG_ASSERT(!message->empty()); + std::weak_ptr weak = shared_from_this(); + boost::asio::post(_strand, [=]() { + auto self = weak.lock(); + if (!self) return; + if (!self->_socket.is_open()) { + return; + } + + auto handle_sent = [weak, message](const boost::system::error_code &ec, size_t DEBUG_ONLY(bytes)) { + auto self = weak.lock(); + if (!self) return; + if (ec) { + log_error("error sending data: ", ec.message()); + } + }; + + // _deadline.expires_from_now(_timeout); + boost::asio::async_write( + self->_socket, + message->GetBufferSequence(), + boost::asio::bind_executor(self->_strand, handle_sent)); + }); + } + + void Secondary::Write(Buffer buffer) { + auto message = Secondary::MakeMessage(std::move(buffer)); + + DEBUG_ASSERT(message != nullptr); + DEBUG_ASSERT(!message->empty()); + std::weak_ptr weak = shared_from_this(); + boost::asio::post(_strand, [=]() { + auto self = weak.lock(); + if (!self) return; + if (!self->_socket.is_open()) { + return; + } + + auto handle_sent = [weak, message](const boost::system::error_code &ec, size_t DEBUG_ONLY(bytes)) { + auto self = weak.lock(); + if (!self) return; + if (ec) { + log_error("error sending data: ", ec.message()); + } + }; + + // _deadline.expires_from_now(_timeout); + boost::asio::async_write( + self->_socket, + message->GetBufferSequence(), + boost::asio::bind_executor(self->_strand, handle_sent)); + }); + } + + void Secondary::Write(std::string text) { + std::weak_ptr weak = shared_from_this(); + boost::asio::post(_strand, [=]() { + auto self = weak.lock(); + if (!self) return; + if (!self->_socket.is_open()) { + return; + } + + auto handle_sent = [weak](const boost::system::error_code &ec, size_t DEBUG_ONLY(bytes)) { + auto self = weak.lock(); + if (!self) return; + if (ec) { + log_error("error sending data: ", ec.message()); + } + }; + + // _deadline.expires_from_now(_timeout); + // sent first size buffer + int this_size = text.size(); + boost::asio::async_write( + self->_socket, + boost::asio::buffer(&this_size, sizeof(this_size)), + boost::asio::bind_executor(self->_strand, handle_sent)); + + // send characters + boost::asio::async_write( + self->_socket, + boost::asio::buffer(text.c_str(), text.size()), + boost::asio::bind_executor(self->_strand, handle_sent)); + }); + } + + void Secondary::ReadData() { + std::weak_ptr weak = shared_from_this(); + boost::asio::post(_strand, [weak]() { + auto self = weak.lock(); + if (!self) return; + if (self->_done) { + return; + } + + auto message = std::make_shared(self->_buffer_pool->Pop()); + + auto handle_read_data = [weak, message](boost::system::error_code ec, size_t DEBUG_ONLY(bytes)) { + auto self = weak.lock(); + if (!self) return; + if (!ec) { + DEBUG_ASSERT_EQ(bytes, message->size()); + DEBUG_ASSERT_NE(bytes, 0u); + // Move the buffer to the callback function and start reading the next + // piece of data. + self->GetCommander().process_command(message->pop()); + self->ReadData(); + } else { + // As usual, if anything fails start over from the very top. + log_error("secondary server: failed to read data: ", ec.message()); + // Connect(); + } + }; + + auto handle_read_header = [weak, message, handle_read_data]( + boost::system::error_code ec, + size_t DEBUG_ONLY(bytes)) { + auto self = weak.lock(); + if (!self) return; + if (!ec && (message->size() > 0u)) { + DEBUG_ASSERT_EQ(bytes, sizeof(carla::streaming::detail::message_size_type)); + if (self->_done) { + return; + } + // Now that we know the size of the coming buffer, we can allocate our + // buffer and start putting data into it. + boost::asio::async_read( + self->_socket, + message->buffer(), + boost::asio::bind_executor(self->_strand, handle_read_data)); + } else if (!self->_done) { + log_error("secondary server: failed to read header: ", ec.message()); + // DEBUG_ONLY(printf("size = ", message->size())); + // DEBUG_ONLY(printf("bytes = ", bytes)); + // Connect(); + } + }; + + // Read the size of the buffer that is coming. + boost::asio::async_read( + self->_socket, + message->size_as_buffer(), + boost::asio::bind_executor(self->_strand, handle_read_header)); + }); + } + +} // namespace multigpu +} // namespace carla diff --git a/LibCarla/source/carla/multigpu/secondary.h b/LibCarla/source/carla/multigpu/secondary.h new file mode 100644 index 000000000..4d360acd2 --- /dev/null +++ b/LibCarla/source/carla/multigpu/secondary.h @@ -0,0 +1,86 @@ +// Copyright (c) 2022 Computer Vision Center (CVC) at the Universitat Autonoma +// de Barcelona (UAB). +// +// This work is licensed under the terms of the MIT license. +// For a copy, see . + +#pragma once + +#include "carla/Buffer.h" +#include "carla/NonCopyable.h" +#include "carla/TypeTraits.h" +#include "carla/profiler/LifetimeProfiled.h" +#include "carla/multigpu/secondaryCommands.h" +#include "carla/streaming/detail/tcp/Message.h" +#include "carla/streaming/detail/Token.h" +#include "carla/streaming/detail/Types.h" +#include "carla/ThreadPool.h" + +#include +#include +#include +#include + +#include +#include +#include + +namespace carla { + + class BufferPool; + +namespace multigpu { + + class Secondary + : public std::enable_shared_from_this, + private profiler::LifetimeProfiled, + private NonCopyable { + public: + + using endpoint = boost::asio::ip::tcp::endpoint; + using protocol_type = endpoint::protocol_type; + + Secondary(boost::asio::ip::tcp::endpoint ep, SecondaryCommands::callback_type callback); + Secondary(std::string ip, uint16_t port, SecondaryCommands::callback_type callback); + ~Secondary(); + + void Connect(); + + void Stop(); + + void AsyncRun(size_t worker_threads); + + void Write(std::shared_ptr message); + void Write(Buffer buffer); + void Write(std::string text); + + SecondaryCommands &GetCommander() { + return _commander; + } + + template + static auto MakeMessage(Buffers &&... buffers) { + static_assert( + are_same::value, + "This function only accepts arguments of type Buffer."); + return std::make_shared(std::move(buffers)...); + } + + private: + + void Reconnect(); + + void ReadData(); + + ThreadPool _pool; + boost::asio::ip::tcp::socket _socket; + boost::asio::ip::tcp::endpoint _endpoint; + boost::asio::io_context::strand _strand; + boost::asio::deadline_timer _connection_timer; + std::shared_ptr _buffer_pool; + std::atomic_bool _done {false}; + SecondaryCommands _commander; + }; + +} // namespace multigpu +} // namespace carla diff --git a/LibCarla/source/carla/multigpu/secondaryCommands.cpp b/LibCarla/source/carla/multigpu/secondaryCommands.cpp new file mode 100644 index 000000000..1758d4ebd --- /dev/null +++ b/LibCarla/source/carla/multigpu/secondaryCommands.cpp @@ -0,0 +1,36 @@ +// Copyright (c) 2022 Computer Vision Center (CVC) at the Universitat Autonoma +// de Barcelona (UAB). +// +// This work is licensed under the terms of the MIT license. +// For a copy, see . + +// #include "carla/Logging.h" +#include "carla/multigpu/secondaryCommands.h" +// #include "carla/streaming/detail/tcp/Message.h" + +namespace carla { +namespace multigpu { + +void SecondaryCommands::set_secondary(std::shared_ptr secondary) { + _secondary = secondary; +} + +void SecondaryCommands::set_callback(callback_type callback) { + _callback = callback; +} + +void SecondaryCommands::process_command(Buffer buffer) { + // get the header + CommandHeader *header; + header = reinterpret_cast(buffer.data()); + + // send only data to the callback + Buffer data(buffer.data() + sizeof(CommandHeader), header->size); + _callback(header->id, std::move(data)); + + // log_info("Secondary got a command to process"); +} + + +} // namespace multigpu +} // namespace carla diff --git a/LibCarla/source/carla/multigpu/secondaryCommands.h b/LibCarla/source/carla/multigpu/secondaryCommands.h new file mode 100644 index 000000000..3f28ed2ae --- /dev/null +++ b/LibCarla/source/carla/multigpu/secondaryCommands.h @@ -0,0 +1,34 @@ +// Copyright (c) 2022 Computer Vision Center (CVC) at the Universitat Autonoma +// de Barcelona (UAB). +// +// This work is licensed under the terms of the MIT license. +// For a copy, see . + +#pragma once + +// #include "carla/Logging.h" +#include "carla/Buffer.h" +#include "carla/multigpu/commands.h" +#include + +namespace carla { +namespace multigpu { + +class Secondary; + +class SecondaryCommands { + public: + + using callback_type = std::function; + + void set_secondary(std::shared_ptr secondary); + void set_callback(callback_type callback); + void process_command(Buffer buffer); + + private: + std::shared_ptr _secondary; + callback_type _callback; +}; + +} // namespace multigpu +} // namespace carla diff --git a/LibCarla/source/carla/rpc/ActorAttribute.h b/LibCarla/source/carla/rpc/ActorAttribute.h index 79912cca6..5eb119eb3 100644 --- a/LibCarla/source/carla/rpc/ActorAttribute.h +++ b/LibCarla/source/carla/rpc/ActorAttribute.h @@ -15,7 +15,9 @@ MSGPACK_ADD_ENUM(carla::rpc::ActorAttributeType); #ifdef LIBCARLA_INCLUDED_FROM_UE4 -# include "Carla/Actor/ActorAttribute.h" +#include +#include "Carla/Actor/ActorAttribute.h" +#include #endif // LIBCARLA_INCLUDED_FROM_UE4 namespace carla { diff --git a/LibCarla/source/carla/rpc/ActorDescription.h b/LibCarla/source/carla/rpc/ActorDescription.h index 03b944b3a..c49455183 100644 --- a/LibCarla/source/carla/rpc/ActorDescription.h +++ b/LibCarla/source/carla/rpc/ActorDescription.h @@ -14,7 +14,9 @@ #include #ifdef LIBCARLA_INCLUDED_FROM_UE4 -# include "Carla/Actor/ActorDescription.h" +#include +#include "Carla/Actor/ActorDescription.h" +#include #endif // LIBCARLA_INCLUDED_FROM_UE4 namespace carla { diff --git a/LibCarla/source/carla/rpc/Color.h b/LibCarla/source/carla/rpc/Color.h index d777b08af..c34dde880 100644 --- a/LibCarla/source/carla/rpc/Color.h +++ b/LibCarla/source/carla/rpc/Color.h @@ -11,7 +11,9 @@ #include #ifdef LIBCARLA_INCLUDED_FROM_UE4 -# include "Math/Color.h" +#include +#include "Math/Color.h" +#include #endif // LIBCARLA_INCLUDED_FROM_UE4 namespace carla { diff --git a/LibCarla/source/carla/rpc/EpisodeSettings.h b/LibCarla/source/carla/rpc/EpisodeSettings.h index 57cbf0fa4..bdc6e37cb 100644 --- a/LibCarla/source/carla/rpc/EpisodeSettings.h +++ b/LibCarla/source/carla/rpc/EpisodeSettings.h @@ -10,7 +10,9 @@ #include "carla/MsgPackAdaptors.h" #ifdef LIBCARLA_INCLUDED_FROM_UE4 -# include "Carla/Settings/EpisodeSettings.h" +#include +#include "Carla/Settings/EpisodeSettings.h" +#include #endif // LIBCARLA_INCLUDED_FROM_UE4 #include diff --git a/LibCarla/source/carla/rpc/FloatColor.h b/LibCarla/source/carla/rpc/FloatColor.h index 09329454b..242be0164 100644 --- a/LibCarla/source/carla/rpc/FloatColor.h +++ b/LibCarla/source/carla/rpc/FloatColor.h @@ -11,7 +11,9 @@ #include #ifdef LIBCARLA_INCLUDED_FROM_UE4 -# include "Math/Color.h" +#include +#include "Math/Color.h" +#include #endif // LIBCARLA_INCLUDED_FROM_UE4 namespace carla { diff --git a/LibCarla/source/carla/rpc/Server.h b/LibCarla/source/carla/rpc/Server.h index 13a849e07..69dc6f8c8 100644 --- a/LibCarla/source/carla/rpc/Server.h +++ b/LibCarla/source/carla/rpc/Server.h @@ -52,7 +52,9 @@ namespace rpc { void SyncRunFor(time_duration duration) { #ifdef LIBCARLA_INCLUDED_FROM_UE4 + #include TRACE_CPUPROFILER_EVENT_SCOPE_STR(__FUNCTION__); + #include #endif // LIBCARLA_INCLUDED_FROM_UE4 _sync_io_context.reset(); _sync_io_context.run_for(duration.to_chrono()); diff --git a/LibCarla/source/carla/rpc/String.h b/LibCarla/source/carla/rpc/String.h index 92effa85e..a4a892a4d 100644 --- a/LibCarla/source/carla/rpc/String.h +++ b/LibCarla/source/carla/rpc/String.h @@ -9,7 +9,9 @@ #include #ifdef LIBCARLA_INCLUDED_FROM_UE4 -# include "UnrealString.h" +#include +#include "UnrealString.h" +#include #endif // LIBCARLA_INCLUDED_FROM_UE4 namespace carla { diff --git a/LibCarla/source/carla/rpc/VehicleControl.h b/LibCarla/source/carla/rpc/VehicleControl.h index 59928768f..47dd92c96 100644 --- a/LibCarla/source/carla/rpc/VehicleControl.h +++ b/LibCarla/source/carla/rpc/VehicleControl.h @@ -9,7 +9,9 @@ #include "carla/MsgPack.h" #ifdef LIBCARLA_INCLUDED_FROM_UE4 -# include "Carla/Vehicle/VehicleControl.h" +#include +#include "Carla/Vehicle/VehicleControl.h" +#include #endif // LIBCARLA_INCLUDED_FROM_UE4 namespace carla { diff --git a/LibCarla/source/carla/rpc/VehicleLightState.h b/LibCarla/source/carla/rpc/VehicleLightState.h index 817a01efe..d35901565 100644 --- a/LibCarla/source/carla/rpc/VehicleLightState.h +++ b/LibCarla/source/carla/rpc/VehicleLightState.h @@ -9,7 +9,9 @@ #include "carla/MsgPack.h" #ifdef LIBCARLA_INCLUDED_FROM_UE4 -# include "Carla/Vehicle/VehicleLightState.h" +#include +#include "Carla/Vehicle/VehicleLightState.h" +#include #endif // LIBCARLA_INCLUDED_FROM_UE4 namespace carla { diff --git a/LibCarla/source/carla/rpc/WalkerBoneControlIn.h b/LibCarla/source/carla/rpc/WalkerBoneControlIn.h index cf2644945..e1c7dc3a1 100644 --- a/LibCarla/source/carla/rpc/WalkerBoneControlIn.h +++ b/LibCarla/source/carla/rpc/WalkerBoneControlIn.h @@ -12,7 +12,9 @@ #include "carla/rpc/Transform.h" #ifdef LIBCARLA_INCLUDED_FROM_UE4 -# include "Carla/Walker/WalkerBoneControlIn.h" +#include +#include "Carla/Walker/WalkerBoneControlIn.h" +#include #endif // LIBCARLA_INCLUDED_FROM_UE4 #include diff --git a/LibCarla/source/carla/rpc/WalkerBoneControlOut.h b/LibCarla/source/carla/rpc/WalkerBoneControlOut.h index d5e51c396..ecdc6b597 100644 --- a/LibCarla/source/carla/rpc/WalkerBoneControlOut.h +++ b/LibCarla/source/carla/rpc/WalkerBoneControlOut.h @@ -12,7 +12,9 @@ #include "carla/rpc/Transform.h" #ifdef LIBCARLA_INCLUDED_FROM_UE4 -# include "Carla/Walker/WalkerBoneControlOut.h" +#include +#include "Carla/Walker/WalkerBoneControlOut.h" +#include #endif // LIBCARLA_INCLUDED_FROM_UE4 #include diff --git a/LibCarla/source/carla/rpc/WalkerControl.h b/LibCarla/source/carla/rpc/WalkerControl.h index 165febc21..ada295714 100644 --- a/LibCarla/source/carla/rpc/WalkerControl.h +++ b/LibCarla/source/carla/rpc/WalkerControl.h @@ -9,7 +9,9 @@ #include "carla/MsgPack.h" #ifdef LIBCARLA_INCLUDED_FROM_UE4 -# include "Carla/Walker/WalkerControl.h" + #include + #include "Carla/Walker/WalkerControl.h" + #include #endif // LIBCARLA_INCLUDED_FROM_UE4 namespace carla { diff --git a/LibCarla/source/carla/rpc/WeatherParameters.h b/LibCarla/source/carla/rpc/WeatherParameters.h index 45a75bf1f..5dccb625b 100644 --- a/LibCarla/source/carla/rpc/WeatherParameters.h +++ b/LibCarla/source/carla/rpc/WeatherParameters.h @@ -9,7 +9,9 @@ #include "carla/MsgPack.h" #ifdef LIBCARLA_INCLUDED_FROM_UE4 -# include "Carla/Weather/WeatherParameters.h" +#include +#include "Carla/Weather/WeatherParameters.h" +#include #endif // LIBCARLA_INCLUDED_FROM_UE4 namespace carla { diff --git a/LibCarla/source/carla/streaming/Server.h b/LibCarla/source/carla/streaming/Server.h index d9535821a..b99bbe666 100644 --- a/LibCarla/source/carla/streaming/Server.h +++ b/LibCarla/source/carla/streaming/Server.h @@ -8,6 +8,7 @@ #include "carla/ThreadPool.h" #include "carla/streaming/detail/tcp/Server.h" +#include "carla/streaming/detail/Types.h" #include "carla/streaming/low_level/Server.h" #include @@ -64,6 +65,10 @@ namespace streaming { _server.SetSynchronousMode(is_synchro); } + carla::streaming::detail::token_type GetToken(carla::streaming::detail::stream_id_type sensor_id) { + return _server.GetToken(sensor_id); + } + private: // The order of these two arguments is very important. diff --git a/LibCarla/source/carla/streaming/detail/Dispatcher.cpp b/LibCarla/source/carla/streaming/detail/Dispatcher.cpp index b1f55ff2e..f10e0de6b 100644 --- a/LibCarla/source/carla/streaming/detail/Dispatcher.cpp +++ b/LibCarla/source/carla/streaming/detail/Dispatcher.cpp @@ -16,16 +16,6 @@ namespace carla { namespace streaming { namespace detail { - template - static auto MakeStreamState(const token_type &cached_token, StreamMapT &stream_map) { - auto ptr = std::make_shared(cached_token); - auto result = stream_map.emplace(std::make_pair(cached_token.get_stream_id(), ptr)); - if (!result.second) { - throw_exception(std::runtime_error("failed to create stream!")); - } - return ptr; - } - Dispatcher::~Dispatcher() { // Disconnect all the sessions from their streams, this should kill any // session remaining since at this point the io_context should be already @@ -34,10 +24,8 @@ namespace detail { #ifndef LIBCARLA_NO_EXCEPTIONS try { #endif // LIBCARLA_NO_EXCEPTIONS - auto stream_state = pair.second.lock(); - if (stream_state != nullptr) { - stream_state->ClearSessions(); - } + auto stream_state = pair.second; + stream_state->ClearSessions(); #ifndef LIBCARLA_NO_EXCEPTIONS } catch (const std::exception &e) { log_error("failed to clear sessions:", e.what()); @@ -49,8 +37,24 @@ namespace detail { carla::streaming::Stream Dispatcher::MakeStream() { std::lock_guard lock(_mutex); ++_cached_token._token.stream_id; // id zero only happens in overflow. - log_info("Created new stream:", _cached_token._token.stream_id); - return MakeStreamState(_cached_token, _stream_map); + log_info("New stream:", _cached_token._token.stream_id); + std::shared_ptr ptr; + auto search = _stream_map.find(_cached_token.get_stream_id()); + if (search == _stream_map.end()) { + // creating new stream + ptr = std::make_shared(_cached_token); + auto result = _stream_map.emplace(std::make_pair(_cached_token.get_stream_id(), ptr)); + if (!result.second) { + throw_exception(std::runtime_error("failed to create stream!")); + } + log_info("Stream created"); + return carla::streaming::Stream(ptr); + } else { + // reusing existing stream + log_info("Stream reused"); + ptr = search->second; + return carla::streaming::Stream(ptr); + } } bool Dispatcher::RegisterSession(std::shared_ptr session) { @@ -58,12 +62,10 @@ namespace detail { std::lock_guard lock(_mutex); auto search = _stream_map.find(session->get_stream_id()); if (search != _stream_map.end()) { - auto stream_state = search->second.lock(); - if (stream_state != nullptr) { - log_info("Connecting session (stream ", session->get_stream_id(), ")"); - stream_state->ConnectSession(std::move(session)); - return true; - } + auto stream_state = search->second; + log_info("Connecting session (stream ", session->get_stream_id(), ")"); + stream_state->ConnectSession(std::move(session)); + return true; } log_error("Invalid session: no stream available with id", session->get_stream_id()); return false; @@ -72,25 +74,36 @@ namespace detail { void Dispatcher::DeregisterSession(std::shared_ptr session) { DEBUG_ASSERT(session != nullptr); std::lock_guard lock(_mutex); - ClearExpiredStreams(); auto search = _stream_map.find(session->get_stream_id()); if (search != _stream_map.end()) { - auto stream_state = search->second.lock(); - if (stream_state != nullptr) { - log_info("Disconnecting session (stream ", session->get_stream_id(), ")"); - stream_state->DisconnectSession(session); - } + auto stream_state = search->second; + log_info("Disconnecting session (stream ", session->get_stream_id(), ")"); + stream_state->DisconnectSession(session); } } - void Dispatcher::ClearExpiredStreams() { - for (auto it = _stream_map.begin(); it != _stream_map.end(); ) { - if (it->second.expired()) { - it = _stream_map.erase(it); - } else { - ++it; + token_type Dispatcher::GetToken(stream_id_type sensor_id) { + std::lock_guard lock(_mutex); + log_info("Searching sensor id: ", sensor_id); + auto search = _stream_map.find(sensor_id); + if (search != _stream_map.end()) { + log_info("Found sensor id: ", sensor_id); + auto stream_state = search->second; + log_info("Getting token from stream ", sensor_id, " on port ", stream_state->token().get_port()); + return stream_state->token(); + } else { + log_info("Not Found sensor id, creating sensor stream: ", sensor_id); + token_type temp_token(_cached_token); + temp_token.set_stream_id(sensor_id); + auto ptr = std::make_shared(temp_token); + auto result = _stream_map.emplace(std::make_pair(temp_token.get_stream_id(), ptr)); + if (!result.second) { + log_info("Failed to create multistream for stream ", sensor_id, " on port ", temp_token.get_port()); } + log_info("Created token from stream ", sensor_id, " on port ", temp_token.get_port()); + return temp_token; } + return token_type(); } } // namespace detail diff --git a/LibCarla/source/carla/streaming/detail/Dispatcher.h b/LibCarla/source/carla/streaming/detail/Dispatcher.h index 19a2aafee..491ea2f8d 100644 --- a/LibCarla/source/carla/streaming/detail/Dispatcher.h +++ b/LibCarla/source/carla/streaming/detail/Dispatcher.h @@ -9,6 +9,7 @@ #include "carla/streaming/EndPoint.h" #include "carla/streaming/Stream.h" #include "carla/streaming/detail/Session.h" +#include "carla/streaming/detail/Stream.h" #include "carla/streaming/detail/Token.h" #include @@ -19,7 +20,8 @@ namespace carla { namespace streaming { namespace detail { - class StreamStateBase; + class MultiStreamState; + using StreamMap = std::unordered_map>; /// Keeps the mapping between streams and sessions. class Dispatcher { @@ -36,20 +38,18 @@ namespace detail { bool RegisterSession(std::shared_ptr session); void DeregisterSession(std::shared_ptr session); + + token_type GetToken(stream_id_type sensor_id); private: - void ClearExpiredStreams(); - // We use a mutex here, but we assume that sessions and streams won't be // created too often. std::mutex _mutex; token_type _cached_token; - std::unordered_map< - stream_id_type, - std::weak_ptr> _stream_map; + StreamMap _stream_map; }; } // namespace detail diff --git a/LibCarla/source/carla/streaming/detail/MultiStreamState.h b/LibCarla/source/carla/streaming/detail/MultiStreamState.h index b5cfeead7..0f1800aee 100644 --- a/LibCarla/source/carla/streaming/detail/MultiStreamState.h +++ b/LibCarla/source/carla/streaming/detail/MultiStreamState.h @@ -34,11 +34,10 @@ namespace detail { template void Write(Buffers &&... buffers) { - auto message = Session::MakeMessage(std::move(buffers)...); - // try write single stream auto session = _session.load(); if (session != nullptr) { + auto message = Session::MakeMessage(std::move(buffers)...); session->Write(std::move(message)); // Return here, _session is only valid if we have a // single session. @@ -47,6 +46,7 @@ namespace detail { // try write multiple stream std::lock_guard lock(_mutex); + auto message = Session::MakeMessage(std::move(buffers)...); for (auto &s : _sessions) { if (s != nullptr) { s->Write(message); @@ -54,7 +54,9 @@ namespace detail { } } - private: + bool AreClientsListening() { + return (_sessions.size() > 0); + } void ConnectSession(std::shared_ptr session) final { DEBUG_ASSERT(session != nullptr); @@ -77,6 +79,7 @@ namespace detail { DEBUG_ASSERT(session == _session.load()); _session.store(nullptr); _sessions.clear(); + log_warning("Last session disconnected"); } else { _sessions.erase( std::remove(_sessions.begin(), _sessions.end(), session), @@ -98,6 +101,8 @@ namespace detail { log_debug("Disconnecting all multistream sessions"); } + private: + std::mutex _mutex; // if there is only one session, then we use atomic diff --git a/LibCarla/source/carla/streaming/detail/Stream.h b/LibCarla/source/carla/streaming/detail/Stream.h index fc32e4a9f..2e006367a 100644 --- a/LibCarla/source/carla/streaming/detail/Stream.h +++ b/LibCarla/source/carla/streaming/detail/Stream.h @@ -61,6 +61,11 @@ namespace detail { return *this; } + bool AreClientsListening() + { + return _shared_state ? _shared_state->AreClientsListening() : false; + } + private: friend class detail::Dispatcher; diff --git a/LibCarla/source/carla/streaming/detail/Token.h b/LibCarla/source/carla/streaming/detail/Token.h index 8cc174e19..eecdb8089 100644 --- a/LibCarla/source/carla/streaming/detail/Token.h +++ b/LibCarla/source/carla/streaming/detail/Token.h @@ -78,6 +78,8 @@ namespace detail { return {get_address(), _token.port}; } + public: + template explicit token_type( stream_id_type stream_id, @@ -97,13 +99,16 @@ namespace detail { _token.protocol = get_protocol(); } - public: token_type() = default; token_type(const token_type &) = default; token_type(const Token &rhs); + explicit token_type(token_data data) { + _token = data; + } + operator Token() const; // We need to return a reference here so we can use the address of the @@ -112,6 +117,10 @@ namespace detail { return _token.stream_id; } + void set_stream_id(stream_id_type id) { + _token.stream_id = id; + } + bool has_address() const { return _token.address_type != token_data::address::not_set; } diff --git a/LibCarla/source/carla/streaming/detail/tcp/ServerSession.cpp b/LibCarla/source/carla/streaming/detail/tcp/ServerSession.cpp index b8f7ff6be..e6e2783ed 100644 --- a/LibCarla/source/carla/streaming/detail/tcp/ServerSession.cpp +++ b/LibCarla/source/carla/streaming/detail/tcp/ServerSession.cpp @@ -140,12 +140,11 @@ namespace tcp { void ServerSession::CloseNow() { _deadline.cancel(); if (_socket.is_open()) { + boost::system::error_code ec; + _socket.shutdown(boost::asio::socket_base::shutdown_both, ec); _socket.close(); } - boost::asio::post(_strand.context(), [self=shared_from_this()]() { - DEBUG_ASSERT(self->_on_closed); - self->_on_closed(self); - }); + _on_closed(shared_from_this()); log_debug("session", _session_id, "closed"); } diff --git a/LibCarla/source/carla/streaming/low_level/Client.h b/LibCarla/source/carla/streaming/low_level/Client.h index aacc4ceba..4d8e25e42 100644 --- a/LibCarla/source/carla/streaming/low_level/Client.h +++ b/LibCarla/source/carla/streaming/low_level/Client.h @@ -66,6 +66,7 @@ namespace low_level { } void UnSubscribe(token_type token) { + log_warning("calling sensor UnSubscribe()"); auto it = _clients.find(token.get_stream_id()); if (it != _clients.end()) { it->second->Stop(); diff --git a/LibCarla/source/carla/streaming/low_level/Server.h b/LibCarla/source/carla/streaming/low_level/Server.h index 5f5a89c46..f859bc425 100644 --- a/LibCarla/source/carla/streaming/low_level/Server.h +++ b/LibCarla/source/carla/streaming/low_level/Server.h @@ -7,6 +7,7 @@ #pragma once #include "carla/streaming/detail/Dispatcher.h" +#include "carla/streaming/detail/Types.h" #include "carla/streaming/Stream.h" #include @@ -68,6 +69,10 @@ namespace low_level { _server.SetSynchronousMode(is_synchro); } + carla::streaming::detail::token_type GetToken(carla::streaming::detail::stream_id_type sensor_id) { + return _dispatcher.GetToken(sensor_id); + } + private: void StartServer() { diff --git a/LibCarla/source/compiler/disable-ue4-macros.h b/LibCarla/source/compiler/disable-ue4-macros.h index 766c0cb3f..eddc2ddc3 100644 --- a/LibCarla/source/compiler/disable-ue4-macros.h +++ b/LibCarla/source/compiler/disable-ue4-macros.h @@ -52,11 +52,6707 @@ # pragma clang diagnostic ignored "-Wshadow" #endif -#pragma push_macro("TEXT") -#undef TEXT +#pragma push_macro("GET_AI_CONFIG_VAR") +#undef GET_AI_CONFIG_VAR + +#pragma push_macro("BT_VLOG") +#undef BT_VLOG + +#pragma push_macro("BT_SEARCHLOG") +#undef BT_SEARCHLOG + +#pragma push_macro("EQSHEADERLOG") +#undef EQSHEADERLOG + +#pragma push_macro("MEM_STAT_UPDATE_WRAPPER") +#undef MEM_STAT_UPDATE_WRAPPER + +#pragma push_macro("GET_STRUCT_NAME_CHECKED") +#undef GET_STRUCT_NAME_CHECKED + +#pragma push_macro("PRINT_TABLE_ROW") +#undef PRINT_TABLE_ROW + +#pragma push_macro("SIGHT_LOG_SEGMENT") +#undef SIGHT_LOG_SEGMENT + +#pragma push_macro("SIGHT_LOG_LOCATION") +#undef SIGHT_LOG_LOCATION + +#pragma push_macro("ANALYTICS_FLUSH_TRACKING_BEGIN") +#undef ANALYTICS_FLUSH_TRACKING_BEGIN + +#pragma push_macro("ANALYTICS_FLUSH_TRACKING_END") +#undef ANALYTICS_FLUSH_TRACKING_END + +#pragma push_macro("OCULUS_DEVICE_LOOP") +#undef OCULUS_DEVICE_LOOP + +#pragma push_macro("OPENSLES_RETURN_ON_FAIL") +#undef OPENSLES_RETURN_ON_FAIL + +#pragma push_macro("OPENSLES_CHECK_ON_FAIL") +#undef OPENSLES_CHECK_ON_FAIL + +#pragma push_macro("OPENSLES_LOG_ON_FAIL") +#undef OPENSLES_LOG_ON_FAIL + +#pragma push_macro("CASE_ENUM_TO_TEXT") +#undef CASE_ENUM_TO_TEXT + +#pragma push_macro("TRACE_BLENDSPACE_PLAYER") +#undef TRACE_BLENDSPACE_PLAYER + +#pragma push_macro("SEQUENCER_INSTANCE_PLAYER_TYPE") +#undef SEQUENCER_INSTANCE_PLAYER_TYPE + +#pragma push_macro("IMAGE_BRUSH") +#undef IMAGE_BRUSH + +#pragma push_macro("BOX_BRUSH") +#undef BOX_BRUSH + +#pragma push_macro("BORDER_BRUSH") +#undef BORDER_BRUSH + +#pragma push_macro("DEFAULT_FONT") +#undef DEFAULT_FONT + +#pragma push_macro("INTERNAL_DECORATOR") +#undef INTERNAL_DECORATOR + +#pragma push_macro("LLM_SCOPE_METAL") +#undef LLM_SCOPE_METAL + +#pragma push_macro("LLM_PLATFORM_SCOPE_METAL") +#undef LLM_PLATFORM_SCOPE_METAL + +#pragma push_macro("METAL_DEBUG_OPTION") +#undef METAL_DEBUG_OPTION + +#pragma push_macro("METAL_DEBUG_ONLY") +#undef METAL_DEBUG_ONLY + +#pragma push_macro("METAL_DEBUG_LAYER") +#undef METAL_DEBUG_LAYER + +#pragma push_macro("METAL_GPUPROFILE") +#undef METAL_GPUPROFILE + +#pragma push_macro("UNREAL_TO_METAL_BUFFER_INDEX") +#undef UNREAL_TO_METAL_BUFFER_INDEX + +#pragma push_macro("METAL_TO_UNREAL_BUFFER_INDEX") +#undef METAL_TO_UNREAL_BUFFER_INDEX + +#pragma push_macro("METAL_FATAL_ERROR") +#undef METAL_FATAL_ERROR + +#pragma push_macro("METAL_FATAL_ASSERT") +#undef METAL_FATAL_ASSERT + +#pragma push_macro("METAL_IGNORED") +#undef METAL_IGNORED + +#pragma push_macro("NOT_SUPPORTED") +#undef NOT_SUPPORTED + +#pragma push_macro("METAL_INC_DWORD_STAT_BY") +#undef METAL_INC_DWORD_STAT_BY + +#pragma push_macro("CHECK_JNI_RESULT") +#undef CHECK_JNI_RESULT + +#pragma push_macro("SET_PRESSED") +#undef SET_PRESSED + +#pragma push_macro("ADD_WINDOWS_MESSAGE_STRING") +#undef ADD_WINDOWS_MESSAGE_STRING + +#pragma push_macro("ADD_IMN_STRING") +#undef ADD_IMN_STRING + +#pragma push_macro("ADD_IMR_STRING") +#undef ADD_IMR_STRING + +#pragma push_macro("IsTouchEvent") +#undef IsTouchEvent + +#pragma push_macro("ADDTOMAP") +#undef ADDTOMAP + +#pragma push_macro("UE_PACKAGEREADER_CORRUPTPACKAGE_WARNING") +#undef UE_PACKAGEREADER_CORRUPTPACKAGE_WARNING + +#pragma push_macro("MUTEX_INITIALIZE") +#undef MUTEX_INITIALIZE + +#pragma push_macro("MUTEX_DESTROY") +#undef MUTEX_DESTROY + +#pragma push_macro("MUTEX_LOCK") +#undef MUTEX_LOCK + +#pragma push_macro("MUTEX_UNLOCK") +#undef MUTEX_UNLOCK + +#pragma push_macro("SAFE_RELEASE") +#undef SAFE_RELEASE + +#pragma push_macro("AUDIO_MIXER_DEBUG_LOG") +#undef AUDIO_MIXER_DEBUG_LOG + +#pragma push_macro("AUDIO_PLATFORM_ERROR") +#undef AUDIO_PLATFORM_ERROR + +#pragma push_macro("AUDIO_MIXER_CHECK") +#undef AUDIO_MIXER_CHECK + +#pragma push_macro("AUDIO_MIXER_CHECK_GAME_THREAD") +#undef AUDIO_MIXER_CHECK_GAME_THREAD + +#pragma push_macro("AUDIO_MIXER_CHECK_AUDIO_PLAT_THREAD") +#undef AUDIO_MIXER_CHECK_AUDIO_PLAT_THREAD + +#pragma push_macro("DEFINE_AR_COMPONENT_DEBUG_MODE") +#undef DEFINE_AR_COMPONENT_DEBUG_MODE + +#pragma push_macro("DEFINE_AR_COMPONENT_VIRTUALS") +#undef DEFINE_AR_COMPONENT_VIRTUALS + +#pragma push_macro("DEFINE_AR_SI_DELEGATE_FUNCS") +#undef DEFINE_AR_SI_DELEGATE_FUNCS + +#pragma push_macro("DEFINE_AR_BPLIB_DELEGATE_FUNCS") +#undef DEFINE_AR_BPLIB_DELEGATE_FUNCS + +#pragma push_macro("DECLARE_AR_SI_DELEGATE_FUNCS") +#undef DECLARE_AR_SI_DELEGATE_FUNCS + +#pragma push_macro("DEFINE_AR_DELEGATE_BASE") +#undef DEFINE_AR_DELEGATE_BASE + +#pragma push_macro("DEFINE_AR_DELEGATE_ONE_PARAM") +#undef DEFINE_AR_DELEGATE_ONE_PARAM + +#pragma push_macro("CHECK_HR") +#undef CHECK_HR + +#pragma push_macro("CHECK_HR_DEFAULT") +#undef CHECK_HR_DEFAULT + +#pragma push_macro("CHECK_HR_COM") +#undef CHECK_HR_COM + +#pragma push_macro("CHECK_HR_VOID") +#undef CHECK_HR_VOID + +#pragma push_macro("CHECK_AMF_RET") +#undef CHECK_AMF_RET + +#pragma push_macro("CHECK_AMF_NORET") +#undef CHECK_AMF_NORET + +#pragma push_macro("CHECK_NV_RES") +#undef CHECK_NV_RES + +#pragma push_macro("NV_RESULT") +#undef NV_RESULT + +#pragma push_macro("B") +#undef B + +#pragma push_macro("AMF_DECLARE_IID") +#undef AMF_DECLARE_IID + +#pragma push_macro("AMF_MACRO_STRING2") +#undef AMF_MACRO_STRING2 + +#pragma push_macro("AMF_MACRO_STRING") +#undef AMF_MACRO_STRING + +#pragma push_macro("AMF_TODO") +#undef AMF_TODO + +#pragma push_macro("AMF_ALIGN") +#undef AMF_ALIGN + +#pragma push_macro("amf_countof") +#undef amf_countof + +#pragma push_macro("AMF_MIN") +#undef AMF_MIN + +#pragma push_macro("AMF_MAX") +#undef AMF_MAX + +#pragma push_macro("AMF_ASSIGN_PROPERTY_DATA") +#undef AMF_ASSIGN_PROPERTY_DATA + +#pragma push_macro("AMF_QUERY_INTERFACE") +#undef AMF_QUERY_INTERFACE + +#pragma push_macro("AMF_ASSIGN_PROPERTY_INTERFACE") +#undef AMF_ASSIGN_PROPERTY_INTERFACE + +#pragma push_macro("AMF_GET_PROPERTY_INTERFACE") +#undef AMF_GET_PROPERTY_INTERFACE + +#pragma push_macro("AMF_ASSIGN_PROPERTY_TYPE") +#undef AMF_ASSIGN_PROPERTY_TYPE + +#pragma push_macro("AMF_ASSIGN_PROPERTY_INT64") +#undef AMF_ASSIGN_PROPERTY_INT64 + +#pragma push_macro("AMF_ASSIGN_PROPERTY_DOUBLE") +#undef AMF_ASSIGN_PROPERTY_DOUBLE + +#pragma push_macro("AMF_ASSIGN_PROPERTY_BOOL") +#undef AMF_ASSIGN_PROPERTY_BOOL + +#pragma push_macro("AMF_ASSIGN_PROPERTY_RECT") +#undef AMF_ASSIGN_PROPERTY_RECT + +#pragma push_macro("AMF_ASSIGN_PROPERTY_SIZE") +#undef AMF_ASSIGN_PROPERTY_SIZE + +#pragma push_macro("AMF_ASSIGN_PROPERTY_POINT") +#undef AMF_ASSIGN_PROPERTY_POINT + +#pragma push_macro("AMF_ASSIGN_PROPERTY_RATE") +#undef AMF_ASSIGN_PROPERTY_RATE + +#pragma push_macro("AMF_ASSIGN_PROPERTY_RATIO") +#undef AMF_ASSIGN_PROPERTY_RATIO + +#pragma push_macro("AMF_ASSIGN_PROPERTY_COLOR") +#undef AMF_ASSIGN_PROPERTY_COLOR + +#pragma push_macro("AMFVariantEmpty") +#undef AMFVariantEmpty + +#pragma push_macro("AMFVariantBool") +#undef AMFVariantBool + +#pragma push_macro("AMFVariantInt64") +#undef AMFVariantInt64 + +#pragma push_macro("AMFVariantDouble") +#undef AMFVariantDouble + +#pragma push_macro("AMFVariantRect") +#undef AMFVariantRect + +#pragma push_macro("AMFVariantSize") +#undef AMFVariantSize + +#pragma push_macro("AMFVariantPoint") +#undef AMFVariantPoint + +#pragma push_macro("AMFVariantRate") +#undef AMFVariantRate + +#pragma push_macro("AMFVariantRatio") +#undef AMFVariantRatio + +#pragma push_macro("AMFVariantColor") +#undef AMFVariantColor + +#pragma push_macro("AMFVariantString") +#undef AMFVariantString + +#pragma push_macro("AMFVariantWString") +#undef AMFVariantWString + +#pragma push_macro("AMFVariantInterface") +#undef AMFVariantInterface + +#pragma push_macro("AMF_VARIANT_RETURN_IF_INVALID_POINTER") +#undef AMF_VARIANT_RETURN_IF_INVALID_POINTER + +#pragma push_macro("AMFConvertTool") +#undef AMFConvertTool + +#pragma push_macro("AMF_MAKE_FULL_VERSION") +#undef AMF_MAKE_FULL_VERSION + +#pragma push_macro("AMF_GET_MAJOR_VERSION") +#undef AMF_GET_MAJOR_VERSION + +#pragma push_macro("AMF_GET_MINOR_VERSION") +#undef AMF_GET_MINOR_VERSION + +#pragma push_macro("AMF_GET_SUBMINOR_VERSION") +#undef AMF_GET_SUBMINOR_VERSION + +#pragma push_macro("AMF_GET_BUILD_VERSION") +#undef AMF_GET_BUILD_VERSION + +#pragma push_macro("NVENCAPI_STRUCT_VERSION") +#undef NVENCAPI_STRUCT_VERSION + +#pragma push_macro("__lseek") +#undef __lseek + +#pragma push_macro("__pread") +#undef __pread + +#pragma push_macro("__pwrite") +#undef __pwrite + +#pragma push_macro("__ftruncate") +#undef __ftruncate + +#pragma push_macro("VK_MAKE_VERSION") +#undef VK_MAKE_VERSION + +#pragma push_macro("VK_VERSION_MAJOR") +#undef VK_VERSION_MAJOR + +#pragma push_macro("VK_VERSION_MINOR") +#undef VK_VERSION_MINOR + +#pragma push_macro("VK_VERSION_PATCH") +#undef VK_VERSION_PATCH + +#pragma push_macro("VK_DEFINE_HANDLE") +#undef VK_DEFINE_HANDLE + +#pragma push_macro("SET_DWORD_STAT_BY_FNAME") +#undef SET_DWORD_STAT_BY_FNAME + +#pragma push_macro("SET_FLOAT_STAT_BY_FNAME") +#undef SET_FLOAT_STAT_BY_FNAME + +#pragma push_macro("CSV_STAT_PTR") +#undef CSV_STAT_PTR + +#pragma push_macro("CSV_CUSTOM_STAT_DEFINED_BY_PTR") +#undef CSV_CUSTOM_STAT_DEFINED_BY_PTR + +#pragma push_macro("HANDLE_CASE") +#undef HANDLE_CASE + +#pragma push_macro("KDBG_CODE") +#undef KDBG_CODE + +#pragma push_macro("APPSDBG_CODE") +#undef APPSDBG_CODE + +#pragma push_macro("TASKGRAPH_SCOPE_CYCLE_COUNTER") +#undef TASKGRAPH_SCOPE_CYCLE_COUNTER + +#pragma push_macro("likely") +#undef likely + +#pragma push_macro("unlikely") +#undef unlikely + +#pragma push_macro("ALLOC") +#undef ALLOC + +#pragma push_macro("ALLOC_AND_ZERO") +#undef ALLOC_AND_ZERO + +#pragma push_macro("FREEMEM") +#undef FREEMEM + +#pragma push_macro("MEM_INIT") +#undef MEM_INIT + +#pragma push_macro("LZ4_STATIC_ASSERT") +#undef LZ4_STATIC_ASSERT + +#pragma push_macro("MIN") +#undef MIN + +#pragma push_macro("HASH_FUNCTION") +#undef HASH_FUNCTION + +#pragma push_macro("DELTANEXTMAXD") +#undef DELTANEXTMAXD + +#pragma push_macro("DELTANEXTU16") +#undef DELTANEXTU16 + +#pragma push_macro("UPDATABLE") +#undef UPDATABLE + +#pragma push_macro("SUBSTRINGTEST") +#undef SUBSTRINGTEST + +#pragma push_macro("FP_TEXT_PASTE") +#undef FP_TEXT_PASTE + +// #pragma push_macro("WTEXT") +// #undef WTEXT + +#pragma push_macro("CASE") +#undef CASE + +#pragma push_macro("LLM_TAG_NAME_ARRAY") +#undef LLM_TAG_NAME_ARRAY + +#pragma push_macro("LLM_TAG_STAT_ARRAY") +#undef LLM_TAG_STAT_ARRAY + +#pragma push_macro("LLM_TAG_STATGROUP_ARRAY") +#undef LLM_TAG_STATGROUP_ARRAY + +#pragma push_macro("bswap_32") +#undef bswap_32 + +#pragma push_macro("bswap_64") +#undef bswap_64 + +#pragma push_macro("uint32_in_expected_order") +#undef uint32_in_expected_order + +#pragma push_macro("uint64_in_expected_order") +#undef uint64_in_expected_order + +#pragma push_macro("LIKELY") +#undef LIKELY + +#pragma push_macro("PERMUTE3") +#undef PERMUTE3 + +#pragma push_macro("DEF_GETPLURALFORM_CAST") +#undef DEF_GETPLURALFORM_CAST + +#pragma push_macro("DEF_ASNUMBER_CAST") +#undef DEF_ASNUMBER_CAST + +#pragma push_macro("DEF_ASNUMBER") +#undef DEF_ASNUMBER + +#pragma push_macro("DEF_ASCURRENCY_CAST") +#undef DEF_ASCURRENCY_CAST + +#pragma push_macro("DEF_ASCURRENCY") +#undef DEF_ASCURRENCY + +#pragma push_macro("DEF_ASPERCENT_CAST") +#undef DEF_ASPERCENT_CAST + +#pragma push_macro("DEF_ASPERCENT") +#undef DEF_ASPERCENT + +#pragma push_macro("CONDITIONAL_CREATE_TEXT_HISTORY") +#undef CONDITIONAL_CREATE_TEXT_HISTORY + +#pragma push_macro("ENUM_CASE_FROM_STRING") +#undef ENUM_CASE_FROM_STRING + +#pragma push_macro("ENUM_CASE_TO_STRING") +#undef ENUM_CASE_TO_STRING + +#pragma push_macro("WRITE_CUSTOM_OPTION") +#undef WRITE_CUSTOM_OPTION + +#pragma push_macro("READ_BOOL_OPTION") +#undef READ_BOOL_OPTION + +#pragma push_macro("READ_CUSTOM_OPTION") +#undef READ_CUSTOM_OPTION + +#pragma push_macro("TEXT_STRINGIFICATION_FUNC_MODIFY_BUFFER_AND_VALIDATE") +#undef TEXT_STRINGIFICATION_FUNC_MODIFY_BUFFER_AND_VALIDATE + +#pragma push_macro("TEXT_STRINGIFICATION_PEEK_MARKER") +#undef TEXT_STRINGIFICATION_PEEK_MARKER + +#pragma push_macro("TEXT_STRINGIFICATION_PEEK_INSENSITIVE_MARKER") +#undef TEXT_STRINGIFICATION_PEEK_INSENSITIVE_MARKER + +#pragma push_macro("TEXT_STRINGIFICATION_SKIP_MARKER") +#undef TEXT_STRINGIFICATION_SKIP_MARKER + +#pragma push_macro("TEXT_STRINGIFICATION_SKIP_INSENSITIVE_MARKER") +#undef TEXT_STRINGIFICATION_SKIP_INSENSITIVE_MARKER + +#pragma push_macro("TEXT_STRINGIFICATION_SKIP_MARKER_LEN") +#undef TEXT_STRINGIFICATION_SKIP_MARKER_LEN + +#pragma push_macro("TEXT_STRINGIFICATION_SKIP_WHITESPACE") +#undef TEXT_STRINGIFICATION_SKIP_WHITESPACE + +#pragma push_macro("TEXT_STRINGIFICATION_SKIP_WHITESPACE_TO_CHAR") +#undef TEXT_STRINGIFICATION_SKIP_WHITESPACE_TO_CHAR + +#pragma push_macro("TEXT_STRINGIFICATION_SKIP_WHITESPACE_AND_CHAR") +#undef TEXT_STRINGIFICATION_SKIP_WHITESPACE_AND_CHAR + +#pragma push_macro("TEXT_STRINGIFICATION_READ_NUMBER") +#undef TEXT_STRINGIFICATION_READ_NUMBER + +#pragma push_macro("TEXT_STRINGIFICATION_READ_ALNUM") +#undef TEXT_STRINGIFICATION_READ_ALNUM + +#pragma push_macro("TEXT_STRINGIFICATION_READ_QUOTED_STRING") +#undef TEXT_STRINGIFICATION_READ_QUOTED_STRING + +#pragma push_macro("TEXT_STRINGIFICATION_READ_SCOPED_ENUM") +#undef TEXT_STRINGIFICATION_READ_SCOPED_ENUM + +#pragma push_macro("PLATFORM_MAC_MAKE_FOURCC") +#undef PLATFORM_MAC_MAKE_FOURCC + +#pragma push_macro("MEMPRO_STATIC_ASSERT") +#undef MEMPRO_STATIC_ASSERT + +#pragma push_macro("ENDIAN_TEST") +#undef ENDIAN_TEST + +#pragma push_macro("_T") +#undef _T + +#pragma push_macro("KEYLENGTH") +#undef KEYLENGTH + +#pragma push_macro("RKLENGTH") +#undef RKLENGTH + +#pragma push_macro("NROUNDS") +#undef NROUNDS + +#pragma push_macro("GETU32") +#undef GETU32 + +#pragma push_macro("PUTU32") +#undef PUTU32 + +#pragma push_macro("DEFINE_LOG_CATEGORY_HELPER") +#undef DEFINE_LOG_CATEGORY_HELPER + +#pragma push_macro("ADD_64b_2_64b") +#undef ADD_64b_2_64b + +#pragma push_macro("ADD_16b_2_64b") +#undef ADD_16b_2_64b + +#pragma push_macro("MD5_F") +#undef MD5_F + +#pragma push_macro("MD5_G") +#undef MD5_G + +#pragma push_macro("MD5_H") +#undef MD5_H + +#pragma push_macro("MD5_I") +#undef MD5_I + +#pragma push_macro("ROTLEFT") +#undef ROTLEFT + +#pragma push_macro("MD5_FF") +#undef MD5_FF + +#pragma push_macro("MD5_GG") +#undef MD5_GG + +#pragma push_macro("MD5_HH") +#undef MD5_HH + +#pragma push_macro("MD5_II") +#undef MD5_II + +#pragma push_macro("ROL32") +#undef ROL32 + +#pragma push_macro("SHABLK0") +#undef SHABLK0 + +#pragma push_macro("SHABLK") +#undef SHABLK + +#pragma push_macro("_R0") +#undef _R0 + +#pragma push_macro("_R1") +#undef _R1 + +#pragma push_macro("_R2") +#undef _R2 + +#pragma push_macro("_R3") +#undef _R3 + +#pragma push_macro("_R4") +#undef _R4 + +#pragma push_macro("GROWABLE_LOGF") +#undef GROWABLE_LOGF + +#pragma push_macro("ABTEST_LOG") +#undef ABTEST_LOG + +#pragma push_macro("CPUPROFILERTRACE_OUTPUTBEGINEVENT_PROLOGUE") +#undef CPUPROFILERTRACE_OUTPUTBEGINEVENT_PROLOGUE + +#pragma push_macro("CPUPROFILERTRACE_OUTPUTBEGINEVENT_EPILOGUE") +#undef CPUPROFILERTRACE_OUTPUTBEGINEVENT_EPILOGUE + +#pragma push_macro("STATS_HIERARCHICAL_TIMER_FUNC") +#undef STATS_HIERARCHICAL_TIMER_FUNC + +#pragma push_macro("BENCHMARK") +#undef BENCHMARK + +#pragma push_macro("TEST") +#undef TEST + +#pragma push_macro("TEST_EX") +#undef TEST_EX + +#pragma push_macro("TEST_QUAT_ROTATE") +#undef TEST_QUAT_ROTATE + +#pragma push_macro("INTERP_WITH_RANGE") +#undef INTERP_WITH_RANGE + +#pragma push_macro("TestUnixEquivalent") +#undef TestUnixEquivalent + +#pragma push_macro("TestYear") +#undef TestYear + +#pragma push_macro("TestMonth") +#undef TestMonth + +#pragma push_macro("TestMonthOfYear") +#undef TestMonthOfYear + +#pragma push_macro("TestDay") +#undef TestDay + +#pragma push_macro("TestHour") +#undef TestHour + +#pragma push_macro("TestMinute") +#undef TestMinute + +#pragma push_macro("TestSecond") +#undef TestSecond + +#pragma push_macro("TestMillisecond") +#undef TestMillisecond + +#pragma push_macro("UE_LOG_UNIX_FILE") +#undef UE_LOG_UNIX_FILE + +#pragma push_macro("REGISTER_NAME") +#undef REGISTER_NAME + +#pragma push_macro("DECLARE_LOG_CATEGORY_EXTERN_HELPER") +#undef DECLARE_LOG_CATEGORY_EXTERN_HELPER + +#pragma push_macro("SCOPED_BOOT_TIMING") +#undef SCOPED_BOOT_TIMING + +#pragma push_macro("FOREACH_ENUM_EPIXELFORMAT") +#undef FOREACH_ENUM_EPIXELFORMAT + +#pragma push_macro("PLATFORM_CODE_SECTION") +#undef PLATFORM_CODE_SECTION + +#pragma push_macro("GCC_PACK") +#undef GCC_PACK + +#pragma push_macro("GCC_ALIGN") +#undef GCC_ALIGN + +#pragma push_macro("PLATFORM_BREAK") +#undef PLATFORM_BREAK + +#pragma push_macro("UE_DEBUG_BREAK_IMPL") +#undef UE_DEBUG_BREAK_IMPL + +#pragma push_macro("_aligned_malloc") +#undef _aligned_malloc + +#pragma push_macro("_aligned_realloc") +#undef _aligned_realloc + +#pragma push_macro("_aligned_free") +#undef _aligned_free + +// #pragma push_macro("TEXT") +// #undef TEXT + +#pragma push_macro("LLM_SCOPE_APPLE") +#undef LLM_SCOPE_APPLE + +#pragma push_macro("LLM_PLATFORM_SCOPE_APPLE") +#undef LLM_PLATFORM_SCOPE_APPLE + +#pragma push_macro("APPLE_PLATFORM_OBJECT_ALLOC_OVERRIDES") +#undef APPLE_PLATFORM_OBJECT_ALLOC_OVERRIDES + +#pragma push_macro("checkThreadGraph") +#undef checkThreadGraph + +#pragma push_macro("CA_SUPPRESS") +#undef CA_SUPPRESS + +#pragma push_macro("CA_ASSUME") +#undef CA_ASSUME + +#pragma push_macro("CA_CONSTANT_IF") +#undef CA_CONSTANT_IF + +#pragma push_macro("TSAN_BEFORE") +#undef TSAN_BEFORE + +#pragma push_macro("TSAN_AFTER") +#undef TSAN_AFTER + +#pragma push_macro("TSAN_ATOMIC") +#undef TSAN_ATOMIC + +#pragma push_macro("DEPRECATED") +#undef DEPRECATED + +#pragma push_macro("EMIT_CUSTOM_WARNING_AT_LINE") +#undef EMIT_CUSTOM_WARNING_AT_LINE + +#pragma push_macro("LZ4_QUOTE") +#undef LZ4_QUOTE + +#pragma push_macro("LZ4_EXPAND_AND_QUOTE") +#undef LZ4_EXPAND_AND_QUOTE + +#pragma push_macro("LZ4_COMPRESSBOUND") +#undef LZ4_COMPRESSBOUND + +#pragma push_macro("LZ4_DECODER_RING_BUFFER_SIZE") +#undef LZ4_DECODER_RING_BUFFER_SIZE + +#pragma push_macro("LZ4_DECOMPRESS_INPLACE_MARGIN") +#undef LZ4_DECOMPRESS_INPLACE_MARGIN + +#pragma push_macro("LZ4_DECOMPRESS_INPLACE_BUFFER_SIZE") +#undef LZ4_DECOMPRESS_INPLACE_BUFFER_SIZE + +#pragma push_macro("LZ4_COMPRESS_INPLACE_BUFFER_SIZE") +#undef LZ4_COMPRESS_INPLACE_BUFFER_SIZE + +#pragma push_macro("checkLockFreePointerList") +#undef checkLockFreePointerList + +#pragma push_macro("ExchangeB") +#undef ExchangeB + +// #pragma push_macro("TCHAR_TO_ANSI") +// #undef TCHAR_TO_ANSI + +// #pragma push_macro("ANSI_TO_TCHAR") +// #undef ANSI_TO_TCHAR + +// #pragma push_macro("TCHAR_TO_UTF8") +// #undef TCHAR_TO_UTF8 + +// #pragma push_macro("UTF8_TO_TCHAR") +// #undef UTF8_TO_TCHAR + +// #pragma push_macro("TCHAR_TO_UTF16") +// #undef TCHAR_TO_UTF16 + +// #pragma push_macro("UTF16_TO_TCHAR") +// #undef UTF16_TO_TCHAR + +// #pragma push_macro("TCHAR_TO_UTF32") +// #undef TCHAR_TO_UTF32 + +// #pragma push_macro("UTF32_TO_TCHAR") +// #undef UTF32_TO_TCHAR + +// #pragma push_macro("TCHAR_TO_WCHAR") +// #undef TCHAR_TO_WCHAR + +// #pragma push_macro("WCHAR_TO_TCHAR") +// #undef WCHAR_TO_TCHAR + +#pragma push_macro("FUNC_CONCAT") +#undef FUNC_CONCAT + +#pragma push_macro("FUNC_DECLARE_DELEGATE") +#undef FUNC_DECLARE_DELEGATE + +#pragma push_macro("FUNC_DECLARE_MULTICAST_DELEGATE") +#undef FUNC_DECLARE_MULTICAST_DELEGATE + +#pragma push_macro("FUNC_DECLARE_EVENT") +#undef FUNC_DECLARE_EVENT + +#pragma push_macro("DECLARE_DERIVED_EVENT") +#undef DECLARE_DERIVED_EVENT + +#pragma push_macro("FUNC_DECLARE_DYNAMIC_DELEGATE") +#undef FUNC_DECLARE_DYNAMIC_DELEGATE + +#pragma push_macro("FUNC_DECLARE_DYNAMIC_DELEGATE_RETVAL") +#undef FUNC_DECLARE_DYNAMIC_DELEGATE_RETVAL + +#pragma push_macro("FUNC_DECLARE_DYNAMIC_MULTICAST_DELEGATE") +#undef FUNC_DECLARE_DYNAMIC_MULTICAST_DELEGATE + +#pragma push_macro("STATIC_FUNCTION_FNAME") +#undef STATIC_FUNCTION_FNAME + +#pragma push_macro("BindDynamic") +#undef BindDynamic + +#pragma push_macro("AddDynamic") +#undef AddDynamic + +#pragma push_macro("AddUniqueDynamic") +#undef AddUniqueDynamic + +#pragma push_macro("RemoveDynamic") +#undef RemoveDynamic + +#pragma push_macro("IsAlreadyBound") +#undef IsAlreadyBound + +#pragma push_macro("DECLARE_DELEGATE") +#undef DECLARE_DELEGATE + +#pragma push_macro("DECLARE_MULTICAST_DELEGATE") +#undef DECLARE_MULTICAST_DELEGATE + +#pragma push_macro("DECLARE_EVENT") +#undef DECLARE_EVENT + +#pragma push_macro("DECLARE_DYNAMIC_DELEGATE") +#undef DECLARE_DYNAMIC_DELEGATE + +#pragma push_macro("DECLARE_DYNAMIC_MULTICAST_DELEGATE") +#undef DECLARE_DYNAMIC_MULTICAST_DELEGATE + +#pragma push_macro("DECLARE_DELEGATE_RetVal") +#undef DECLARE_DELEGATE_RetVal + +#pragma push_macro("DECLARE_DYNAMIC_DELEGATE_RetVal") +#undef DECLARE_DYNAMIC_DELEGATE_RetVal + +#pragma push_macro("DECLARE_DELEGATE_OneParam") +#undef DECLARE_DELEGATE_OneParam + +#pragma push_macro("DECLARE_MULTICAST_DELEGATE_OneParam") +#undef DECLARE_MULTICAST_DELEGATE_OneParam + +#pragma push_macro("DECLARE_EVENT_OneParam") +#undef DECLARE_EVENT_OneParam + +#pragma push_macro("DECLARE_DYNAMIC_DELEGATE_OneParam") +#undef DECLARE_DYNAMIC_DELEGATE_OneParam + +#pragma push_macro("DECLARE_DYNAMIC_MULTICAST_DELEGATE_OneParam") +#undef DECLARE_DYNAMIC_MULTICAST_DELEGATE_OneParam + +#pragma push_macro("DECLARE_DELEGATE_RetVal_OneParam") +#undef DECLARE_DELEGATE_RetVal_OneParam + +#pragma push_macro("DECLARE_DYNAMIC_DELEGATE_RetVal_OneParam") +#undef DECLARE_DYNAMIC_DELEGATE_RetVal_OneParam + +#pragma push_macro("DECLARE_DELEGATE_TwoParams") +#undef DECLARE_DELEGATE_TwoParams + +#pragma push_macro("DECLARE_MULTICAST_DELEGATE_TwoParams") +#undef DECLARE_MULTICAST_DELEGATE_TwoParams + +#pragma push_macro("DECLARE_EVENT_TwoParams") +#undef DECLARE_EVENT_TwoParams + +#pragma push_macro("DECLARE_DYNAMIC_DELEGATE_TwoParams") +#undef DECLARE_DYNAMIC_DELEGATE_TwoParams + +#pragma push_macro("DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams") +#undef DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams + +#pragma push_macro("DECLARE_DELEGATE_RetVal_TwoParams") +#undef DECLARE_DELEGATE_RetVal_TwoParams + +#pragma push_macro("DECLARE_DYNAMIC_DELEGATE_RetVal_TwoParams") +#undef DECLARE_DYNAMIC_DELEGATE_RetVal_TwoParams + +#pragma push_macro("DECLARE_DELEGATE_ThreeParams") +#undef DECLARE_DELEGATE_ThreeParams + +#pragma push_macro("DECLARE_MULTICAST_DELEGATE_ThreeParams") +#undef DECLARE_MULTICAST_DELEGATE_ThreeParams + +#pragma push_macro("DECLARE_EVENT_ThreeParams") +#undef DECLARE_EVENT_ThreeParams + +#pragma push_macro("DECLARE_DYNAMIC_DELEGATE_ThreeParams") +#undef DECLARE_DYNAMIC_DELEGATE_ThreeParams + +#pragma push_macro("DECLARE_DYNAMIC_MULTICAST_DELEGATE_ThreeParams") +#undef DECLARE_DYNAMIC_MULTICAST_DELEGATE_ThreeParams + +#pragma push_macro("DECLARE_DELEGATE_RetVal_ThreeParams") +#undef DECLARE_DELEGATE_RetVal_ThreeParams + +#pragma push_macro("DECLARE_DYNAMIC_DELEGATE_RetVal_ThreeParams") +#undef DECLARE_DYNAMIC_DELEGATE_RetVal_ThreeParams + +#pragma push_macro("DECLARE_DELEGATE_FourParams") +#undef DECLARE_DELEGATE_FourParams + +#pragma push_macro("DECLARE_MULTICAST_DELEGATE_FourParams") +#undef DECLARE_MULTICAST_DELEGATE_FourParams + +#pragma push_macro("DECLARE_EVENT_FourParams") +#undef DECLARE_EVENT_FourParams + +#pragma push_macro("DECLARE_DYNAMIC_DELEGATE_FourParams") +#undef DECLARE_DYNAMIC_DELEGATE_FourParams + +#pragma push_macro("DECLARE_DYNAMIC_MULTICAST_DELEGATE_FourParams") +#undef DECLARE_DYNAMIC_MULTICAST_DELEGATE_FourParams + +#pragma push_macro("DECLARE_DELEGATE_RetVal_FourParams") +#undef DECLARE_DELEGATE_RetVal_FourParams + +#pragma push_macro("DECLARE_DYNAMIC_DELEGATE_RetVal_FourParams") +#undef DECLARE_DYNAMIC_DELEGATE_RetVal_FourParams + +#pragma push_macro("DECLARE_DELEGATE_FiveParams") +#undef DECLARE_DELEGATE_FiveParams + +#pragma push_macro("DECLARE_MULTICAST_DELEGATE_FiveParams") +#undef DECLARE_MULTICAST_DELEGATE_FiveParams + +#pragma push_macro("DECLARE_EVENT_FiveParams") +#undef DECLARE_EVENT_FiveParams + +#pragma push_macro("DECLARE_DYNAMIC_DELEGATE_FiveParams") +#undef DECLARE_DYNAMIC_DELEGATE_FiveParams + +#pragma push_macro("DECLARE_DYNAMIC_MULTICAST_DELEGATE_FiveParams") +#undef DECLARE_DYNAMIC_MULTICAST_DELEGATE_FiveParams + +#pragma push_macro("DECLARE_DELEGATE_RetVal_FiveParams") +#undef DECLARE_DELEGATE_RetVal_FiveParams + +#pragma push_macro("DECLARE_DYNAMIC_DELEGATE_RetVal_FiveParams") +#undef DECLARE_DYNAMIC_DELEGATE_RetVal_FiveParams + +#pragma push_macro("DECLARE_DELEGATE_SixParams") +#undef DECLARE_DELEGATE_SixParams + +#pragma push_macro("DECLARE_MULTICAST_DELEGATE_SixParams") +#undef DECLARE_MULTICAST_DELEGATE_SixParams + +#pragma push_macro("DECLARE_EVENT_SixParams") +#undef DECLARE_EVENT_SixParams + +#pragma push_macro("DECLARE_DYNAMIC_DELEGATE_SixParams") +#undef DECLARE_DYNAMIC_DELEGATE_SixParams + +#pragma push_macro("DECLARE_DYNAMIC_MULTICAST_DELEGATE_SixParams") +#undef DECLARE_DYNAMIC_MULTICAST_DELEGATE_SixParams + +#pragma push_macro("DECLARE_DELEGATE_RetVal_SixParams") +#undef DECLARE_DELEGATE_RetVal_SixParams + +#pragma push_macro("DECLARE_DYNAMIC_DELEGATE_RetVal_SixParams") +#undef DECLARE_DYNAMIC_DELEGATE_RetVal_SixParams + +#pragma push_macro("DECLARE_DELEGATE_SevenParams") +#undef DECLARE_DELEGATE_SevenParams + +#pragma push_macro("DECLARE_MULTICAST_DELEGATE_SevenParams") +#undef DECLARE_MULTICAST_DELEGATE_SevenParams + +#pragma push_macro("DECLARE_EVENT_SevenParams") +#undef DECLARE_EVENT_SevenParams + +#pragma push_macro("DECLARE_DYNAMIC_DELEGATE_SevenParams") +#undef DECLARE_DYNAMIC_DELEGATE_SevenParams + +#pragma push_macro("DECLARE_DYNAMIC_MULTICAST_DELEGATE_SevenParams") +#undef DECLARE_DYNAMIC_MULTICAST_DELEGATE_SevenParams + +#pragma push_macro("DECLARE_DELEGATE_RetVal_SevenParams") +#undef DECLARE_DELEGATE_RetVal_SevenParams + +#pragma push_macro("DECLARE_DYNAMIC_DELEGATE_RetVal_SevenParams") +#undef DECLARE_DYNAMIC_DELEGATE_RetVal_SevenParams + +#pragma push_macro("DECLARE_DELEGATE_EightParams") +#undef DECLARE_DELEGATE_EightParams + +#pragma push_macro("DECLARE_MULTICAST_DELEGATE_EightParams") +#undef DECLARE_MULTICAST_DELEGATE_EightParams + +#pragma push_macro("DECLARE_EVENT_EightParams") +#undef DECLARE_EVENT_EightParams + +#pragma push_macro("DECLARE_DYNAMIC_DELEGATE_EightParams") +#undef DECLARE_DYNAMIC_DELEGATE_EightParams + +#pragma push_macro("DECLARE_DYNAMIC_MULTICAST_DELEGATE_EightParams") +#undef DECLARE_DYNAMIC_MULTICAST_DELEGATE_EightParams + +#pragma push_macro("DECLARE_DELEGATE_RetVal_EightParams") +#undef DECLARE_DELEGATE_RetVal_EightParams + +#pragma push_macro("DECLARE_DYNAMIC_DELEGATE_RetVal_EightParams") +#undef DECLARE_DYNAMIC_DELEGATE_RetVal_EightParams + +#pragma push_macro("DECLARE_DELEGATE_NineParams") +#undef DECLARE_DELEGATE_NineParams + +#pragma push_macro("DECLARE_MULTICAST_DELEGATE_NineParams") +#undef DECLARE_MULTICAST_DELEGATE_NineParams + +#pragma push_macro("DECLARE_EVENT_NineParams") +#undef DECLARE_EVENT_NineParams + +#pragma push_macro("DECLARE_DYNAMIC_DELEGATE_NineParams") +#undef DECLARE_DYNAMIC_DELEGATE_NineParams + +#pragma push_macro("DECLARE_DYNAMIC_MULTICAST_DELEGATE_NineParams") +#undef DECLARE_DYNAMIC_MULTICAST_DELEGATE_NineParams + +#pragma push_macro("DECLARE_DELEGATE_RetVal_NineParams") +#undef DECLARE_DELEGATE_RetVal_NineParams + +#pragma push_macro("DECLARE_DYNAMIC_DELEGATE_RetVal_NineParams") +#undef DECLARE_DYNAMIC_DELEGATE_RetVal_NineParams + +#pragma push_macro("CHECK_CONCURRENT_ACCESS") +#undef CHECK_CONCURRENT_ACCESS + +#pragma push_macro("FRAMEPRO_FRAME_START") +#undef FRAMEPRO_FRAME_START + +#pragma push_macro("FRAMEPRO_SHUTDOWN") +#undef FRAMEPRO_SHUTDOWN + +#pragma push_macro("FRAMEPRO_SET_PORT") +#undef FRAMEPRO_SET_PORT + +#pragma push_macro("FRAMEPRO_SET_SESSION_INFO") +#undef FRAMEPRO_SET_SESSION_INFO + +#pragma push_macro("FRAMEPRO_SET_ALLOCATOR") +#undef FRAMEPRO_SET_ALLOCATOR + +#pragma push_macro("FRAMEPRO_SET_THREAD_NAME") +#undef FRAMEPRO_SET_THREAD_NAME + +#pragma push_macro("FRAMEPRO_THREAD_ORDER") +#undef FRAMEPRO_THREAD_ORDER + +#pragma push_macro("FRAMEPRO_REGISTER_STRING") +#undef FRAMEPRO_REGISTER_STRING + +#pragma push_macro("FRAMEPRO_START_RECORDING") +#undef FRAMEPRO_START_RECORDING + +#pragma push_macro("FRAMEPRO_STOP_RECORDING") +#undef FRAMEPRO_STOP_RECORDING + +#pragma push_macro("FRAMEPRO_REGISTER_CONNECTION_CHANGED_CALLBACK") +#undef FRAMEPRO_REGISTER_CONNECTION_CHANGED_CALLBACK + +#pragma push_macro("FRAMEPRO_UNREGISTER_CONNECTION_CHANGED_CALLBACK") +#undef FRAMEPRO_UNREGISTER_CONNECTION_CHANGED_CALLBACK + +#pragma push_macro("FRAMEPRO_SET_THREAD_PRIORITY") +#undef FRAMEPRO_SET_THREAD_PRIORITY + +#pragma push_macro("FRAMEPRO_SET_THREAD_AFFINITY") +#undef FRAMEPRO_SET_THREAD_AFFINITY + +#pragma push_macro("FRAMEPRO_BLOCK_SOCKETS") +#undef FRAMEPRO_BLOCK_SOCKETS + +#pragma push_macro("FRAMEPRO_UNBLOCK_SOCKETS") +#undef FRAMEPRO_UNBLOCK_SOCKETS + +#pragma push_macro("FRAMEPRO_CLEANUP_THREAD") +#undef FRAMEPRO_CLEANUP_THREAD + +#pragma push_macro("FRAMEPRO_THREAD_SCOPE") +#undef FRAMEPRO_THREAD_SCOPE + +#pragma push_macro("FRAMEPRO_LOG") +#undef FRAMEPRO_LOG + +#pragma push_macro("FRAMEPRO_COLOUR") +#undef FRAMEPRO_COLOUR + +#pragma push_macro("FRAMEPRO_SET_CONDITIONAL_SCOPE_MIN_TIME") +#undef FRAMEPRO_SET_CONDITIONAL_SCOPE_MIN_TIME + +#pragma push_macro("FRAMEPRO_SCOPE") +#undef FRAMEPRO_SCOPE + +#pragma push_macro("FRAMEPRO_NAMED_SCOPE") +#undef FRAMEPRO_NAMED_SCOPE + +#pragma push_macro("FRAMEPRO_NAMED_SCOPE_W") +#undef FRAMEPRO_NAMED_SCOPE_W + +#pragma push_macro("FRAMEPRO_ID_SCOPE") +#undef FRAMEPRO_ID_SCOPE + +#pragma push_macro("FRAMEPRO_DYNAMIC_SCOPE") +#undef FRAMEPRO_DYNAMIC_SCOPE + +#pragma push_macro("FRAMEPRO_CONDITIONAL_SCOPE") +#undef FRAMEPRO_CONDITIONAL_SCOPE + +#pragma push_macro("FRAMEPRO_CONDITIONAL_ID_SCOPE") +#undef FRAMEPRO_CONDITIONAL_ID_SCOPE + +#pragma push_macro("FRAMEPRO_CONDITIONAL_NAMED_SCOPE") +#undef FRAMEPRO_CONDITIONAL_NAMED_SCOPE + +#pragma push_macro("FRAMEPRO_CONDITIONAL_NAMED_SCOPE_W") +#undef FRAMEPRO_CONDITIONAL_NAMED_SCOPE_W + +#pragma push_macro("FRAMEPRO_CONDITIONAL_BOOL_SCOPE") +#undef FRAMEPRO_CONDITIONAL_BOOL_SCOPE + +#pragma push_macro("FRAMEPRO_CONDITIONAL_BOOL_ID_SCOPE") +#undef FRAMEPRO_CONDITIONAL_BOOL_ID_SCOPE + +#pragma push_macro("FRAMEPRO_CONDITIONAL_BOOL_NAMED_SCOPE") +#undef FRAMEPRO_CONDITIONAL_BOOL_NAMED_SCOPE + +#pragma push_macro("FRAMEPRO_CONDITIONAL_BOOL_NAMED_SCOPE_W") +#undef FRAMEPRO_CONDITIONAL_BOOL_NAMED_SCOPE_W + +#pragma push_macro("FRAMEPRO_START_NAMED_SCOPE") +#undef FRAMEPRO_START_NAMED_SCOPE + +#pragma push_macro("FRAMEPRO_STOP_NAMED_SCOPE") +#undef FRAMEPRO_STOP_NAMED_SCOPE + +#pragma push_macro("FRAMEPRO_CONDITIONAL_START_SCOPE") +#undef FRAMEPRO_CONDITIONAL_START_SCOPE + +#pragma push_macro("FRAMEPRO_CONDITIONAL_STOP_NAMED_SCOPE") +#undef FRAMEPRO_CONDITIONAL_STOP_NAMED_SCOPE + +#pragma push_macro("FRAMEPRO_CONDITIONAL_STOP_DYNAMIC_SCOPE") +#undef FRAMEPRO_CONDITIONAL_STOP_DYNAMIC_SCOPE + +#pragma push_macro("FRAMEPRO_CONDITIONAL_PARENT_SCOPE") +#undef FRAMEPRO_CONDITIONAL_PARENT_SCOPE + +#pragma push_macro("FRAMEPRO_SET_SCOPE_COLOUR") +#undef FRAMEPRO_SET_SCOPE_COLOUR + +#pragma push_macro("FRAMEPRO_IDLE_SCOPE") +#undef FRAMEPRO_IDLE_SCOPE + +#pragma push_macro("FRAMEPRO_IDLE_NAMED_SCOPE") +#undef FRAMEPRO_IDLE_NAMED_SCOPE + +#pragma push_macro("FRAMEPRO_IDLE_NAMED_SCOPE_W") +#undef FRAMEPRO_IDLE_NAMED_SCOPE_W + +#pragma push_macro("FRAMEPRO_IDLE_ID_SCOPE") +#undef FRAMEPRO_IDLE_ID_SCOPE + +#pragma push_macro("FRAMEPRO_IDLE_DYNAMIC_SCOPE") +#undef FRAMEPRO_IDLE_DYNAMIC_SCOPE + +#pragma push_macro("FRAMEPRO_IDLE_CONDITIONAL_SCOPE") +#undef FRAMEPRO_IDLE_CONDITIONAL_SCOPE + +#pragma push_macro("FRAMEPRO_IDLE_CONDITIONAL_ID_SCOPE") +#undef FRAMEPRO_IDLE_CONDITIONAL_ID_SCOPE + +#pragma push_macro("FRAMEPRO_IDLE_CONDITIONAL_NAMED_SCOPE") +#undef FRAMEPRO_IDLE_CONDITIONAL_NAMED_SCOPE + +#pragma push_macro("FRAMEPRO_IDLE_CONDITIONAL_NAMED_SCOPE_W") +#undef FRAMEPRO_IDLE_CONDITIONAL_NAMED_SCOPE_W + +#pragma push_macro("FRAMEPRO_IDLE_START_NAMED_SCOPE") +#undef FRAMEPRO_IDLE_START_NAMED_SCOPE + +#pragma push_macro("FRAMEPRO_IDLE_STOP_NAMED_SCOPE") +#undef FRAMEPRO_IDLE_STOP_NAMED_SCOPE + +#pragma push_macro("FRAMEPRO_IDLE_CONDITIONAL_START_SCOPE") +#undef FRAMEPRO_IDLE_CONDITIONAL_START_SCOPE + +#pragma push_macro("FRAMEPRO_IDLE_CONDITIONAL_STOP_NAMED_SCOPE") +#undef FRAMEPRO_IDLE_CONDITIONAL_STOP_NAMED_SCOPE + +#pragma push_macro("FRAMEPRO_IDLE_CONDITIONAL_STOP_DYNAMIC_SCOPE") +#undef FRAMEPRO_IDLE_CONDITIONAL_STOP_DYNAMIC_SCOPE + +#pragma push_macro("FRAMEPRO_CUSTOM_STAT") +#undef FRAMEPRO_CUSTOM_STAT + +#pragma push_macro("FRAMEPRO_DYNAMIC_CUSTOM_STAT") +#undef FRAMEPRO_DYNAMIC_CUSTOM_STAT + +#pragma push_macro("FRAMEPRO_SCOPE_CUSTOM_STAT") +#undef FRAMEPRO_SCOPE_CUSTOM_STAT + +#pragma push_macro("FRAMEPRO_SET_CUSTOM_STAT_GRAPH") +#undef FRAMEPRO_SET_CUSTOM_STAT_GRAPH + +#pragma push_macro("FRAMEPRO_SET_CUSTOM_STAT_UNIT") +#undef FRAMEPRO_SET_CUSTOM_STAT_UNIT + +#pragma push_macro("FRAMEPRO_SET_CUSTOM_STAT_COLOUR") +#undef FRAMEPRO_SET_CUSTOM_STAT_COLOUR + +#pragma push_macro("FRAMEPRO_HIRES_SCOPE") +#undef FRAMEPRO_HIRES_SCOPE + +#pragma push_macro("FRAMEPRO_DECL_GLOBAL_HIRES_TIMER") +#undef FRAMEPRO_DECL_GLOBAL_HIRES_TIMER + +#pragma push_macro("FRAMEPRO_GLOBAL_HIRES_SCOPE") +#undef FRAMEPRO_GLOBAL_HIRES_SCOPE + +#pragma push_macro("FRAMEPRO_EVENT") +#undef FRAMEPRO_EVENT + +#pragma push_macro("FRAMEPRO_WAIT_EVENT_SCOPE") +#undef FRAMEPRO_WAIT_EVENT_SCOPE + +#pragma push_macro("FRAMEPRO_TRIGGER_WAIT_EVENT") +#undef FRAMEPRO_TRIGGER_WAIT_EVENT + +#pragma push_macro("FRAMEPRO_STRINGIZE") +#undef FRAMEPRO_STRINGIZE + +#pragma push_macro("FRAMEPRO_STRINGIZE2") +#undef FRAMEPRO_STRINGIZE2 + +#pragma push_macro("FRAMEPRO_JOIN") +#undef FRAMEPRO_JOIN + +#pragma push_macro("FRAMEPRO_JOIN2") +#undef FRAMEPRO_JOIN2 + +#pragma push_macro("FRAMEPRO_UNIQUE") +#undef FRAMEPRO_UNIQUE + +#pragma push_macro("FRAMEPRO_WIDESTR") +#undef FRAMEPRO_WIDESTR + +#pragma push_macro("FRAMEPRO_WIDESTR2") +#undef FRAMEPRO_WIDESTR2 + +#pragma push_macro("FRAMEPRO_ASSERT") +#undef FRAMEPRO_ASSERT + +#pragma push_macro("FRAMEPRO_UNREFERENCED") +#undef FRAMEPRO_UNREFERENCED + +#pragma push_macro("FRAMEPRO_GET_CLOCK_COUNT") +#undef FRAMEPRO_GET_CLOCK_COUNT + +#pragma push_macro("MULTI_STATEMENT") +#undef MULTI_STATEMENT + +#pragma push_macro("FRAMEPRO_ALIGN_STRUCT") +#undef FRAMEPRO_ALIGN_STRUCT + +#pragma push_macro("EMIT_CUSTOM_WARNING") +#undef EMIT_CUSTOM_WARNING + +#pragma push_macro("DEPRECATED_MACRO") +#undef DEPRECATED_MACRO + +#pragma push_macro("PLATFORM_MEMORY_SIZE_BUCKET_LIST") +#undef PLATFORM_MEMORY_SIZE_BUCKET_LIST + +#pragma push_macro("PLATFORM_MEMORY_SIZE_BUCKET_ENUM") +#undef PLATFORM_MEMORY_SIZE_BUCKET_ENUM + +#pragma push_macro("PLATFORM_MEMORY_SIZE_BUCKET_LEXTOSTRING") +#undef PLATFORM_MEMORY_SIZE_BUCKET_LEXTOSTRING + +#pragma push_macro("FMemory_Alloca") +#undef FMemory_Alloca + +#pragma push_macro("UE_DEBUG_BREAK") +#undef UE_DEBUG_BREAK + +#pragma push_macro("cvarCheckCode") +#undef cvarCheckCode + +#pragma push_macro("FILE_LOG") +#undef FILE_LOG + +#pragma push_macro("DECLARE_LLM_MEMORY_STAT") +#undef DECLARE_LLM_MEMORY_STAT + +#pragma push_macro("DECLARE_LLM_MEMORY_STAT_EXTERN") +#undef DECLARE_LLM_MEMORY_STAT_EXTERN + +#pragma push_macro("LLMCheckMessage") +#undef LLMCheckMessage + +#pragma push_macro("LLMCheckfMessage") +#undef LLMCheckfMessage + +#pragma push_macro("LLMEnsureMessage") +#undef LLMEnsureMessage + +#pragma push_macro("LLMCheck") +#undef LLMCheck + +#pragma push_macro("LLMCheckf") +#undef LLMCheckf + +#pragma push_macro("LLMEnsure") +#undef LLMEnsure + +#pragma push_macro("LLM_ENUM_GENERIC_TAGS") +#undef LLM_ENUM_GENERIC_TAGS + +#pragma push_macro("LLM_ENUM") +#undef LLM_ENUM + +#pragma push_macro("LLM") +#undef LLM + +#pragma push_macro("LLM_IF_ENABLED") +#undef LLM_IF_ENABLED + +#pragma push_macro("LLM_SCOPE") +#undef LLM_SCOPE + +#pragma push_macro("LLM_PLATFORM_SCOPE") +#undef LLM_PLATFORM_SCOPE + +#pragma push_macro("LLM_SCOPED_PAUSE_TRACKING") +#undef LLM_SCOPED_PAUSE_TRACKING + +#pragma push_macro("LLM_SCOPED_PAUSE_TRACKING_FOR_TRACKER") +#undef LLM_SCOPED_PAUSE_TRACKING_FOR_TRACKER + +#pragma push_macro("LLM_SCOPED_PAUSE_TRACKING_WITH_ENUM_AND_AMOUNT") +#undef LLM_SCOPED_PAUSE_TRACKING_WITH_ENUM_AND_AMOUNT + +#pragma push_macro("LLM_REALLOC_SCOPE") +#undef LLM_REALLOC_SCOPE + +#pragma push_macro("LLM_REALLOC_PLATFORM_SCOPE") +#undef LLM_REALLOC_PLATFORM_SCOPE + +#pragma push_macro("LLM_SCOPED_TAG_WITH_STAT") +#undef LLM_SCOPED_TAG_WITH_STAT + +#pragma push_macro("LLM_SCOPED_TAG_WITH_STAT_IN_SET") +#undef LLM_SCOPED_TAG_WITH_STAT_IN_SET + +#pragma push_macro("LLM_SCOPED_TAG_WITH_STAT_NAME") +#undef LLM_SCOPED_TAG_WITH_STAT_NAME + +#pragma push_macro("LLM_SCOPED_TAG_WITH_STAT_NAME_IN_SET") +#undef LLM_SCOPED_TAG_WITH_STAT_NAME_IN_SET + +#pragma push_macro("LLM_SCOPED_SINGLE_PLATFORM_STAT_TAG") +#undef LLM_SCOPED_SINGLE_PLATFORM_STAT_TAG + +#pragma push_macro("LLM_SCOPED_SINGLE_PLATFORM_STAT_TAG_IN_SET") +#undef LLM_SCOPED_SINGLE_PLATFORM_STAT_TAG_IN_SET + +#pragma push_macro("LLM_SCOPED_SINGLE_STAT_TAG") +#undef LLM_SCOPED_SINGLE_STAT_TAG + +#pragma push_macro("LLM_SCOPED_SINGLE_STAT_TAG_IN_SET") +#undef LLM_SCOPED_SINGLE_STAT_TAG_IN_SET + +#pragma push_macro("LLM_SCOPED_PAUSE_TRACKING_WITH_STAT_AND_AMOUNT") +#undef LLM_SCOPED_PAUSE_TRACKING_WITH_STAT_AND_AMOUNT + +#pragma push_macro("LLM_SCOPED_TAG_WITH_OBJECT_IN_SET") +#undef LLM_SCOPED_TAG_WITH_OBJECT_IN_SET + +#pragma push_macro("LLM_PUSH_STATS_FOR_ASSET_TAGS") +#undef LLM_PUSH_STATS_FOR_ASSET_TAGS + +#pragma push_macro("LLM_DUMP_TAG") +#undef LLM_DUMP_TAG + +#pragma push_macro("LLM_DUMP_PLATFORM_TAG") +#undef LLM_DUMP_PLATFORM_TAG + +#pragma push_macro("LLM_SCOPED_SINGLE_RHI_STAT_TAG") +#undef LLM_SCOPED_SINGLE_RHI_STAT_TAG + +#pragma push_macro("LLM_SCOPED_SINGLE_RHI_STAT_TAG_IN_SET") +#undef LLM_SCOPED_SINGLE_RHI_STAT_TAG_IN_SET + +#pragma push_macro("MEM_TIME") +#undef MEM_TIME + +#pragma push_macro("MBA_STAT") +#undef MBA_STAT + +#pragma push_macro("MBG_STAT") +#undef MBG_STAT + +#pragma push_macro("MALLOCLEAK_WHITELIST_SCOPE") +#undef MALLOCLEAK_WHITELIST_SCOPE + +#pragma push_macro("MALLOCLEAK_SCOPED_CONTEXT") +#undef MALLOCLEAK_SCOPED_CONTEXT + +#pragma push_macro("FUNCTION_CHECK_RETURN") +#undef FUNCTION_CHECK_RETURN + +#pragma push_macro("UE_ASSUME") +#undef UE_ASSUME + +#pragma push_macro("ASSUME") +#undef ASSUME + +#pragma push_macro("UNLIKELY") +#undef UNLIKELY + +#pragma push_macro("DECLARE_UINT64") +#undef DECLARE_UINT64 + +#pragma push_macro("MS_ALIGN") +#undef MS_ALIGN + +#pragma push_macro("MSVC_PRAGMA") +#undef MSVC_PRAGMA + +#pragma push_macro("FLUSH_CACHE_LINE") +#undef FLUSH_CACHE_LINE + +#pragma push_macro("MSC_FORMAT_DIAGNOSTIC_HELPER_2") +#undef MSC_FORMAT_DIAGNOSTIC_HELPER_2 + +#pragma push_macro("MSC_FORMAT_DIAGNOSTIC_HELPER") +#undef MSC_FORMAT_DIAGNOSTIC_HELPER + +#pragma push_macro("COMPILE_WARNING") +#undef COMPILE_WARNING + +#pragma push_macro("COMPILE_ERROR") +#undef COMPILE_ERROR + +#pragma push_macro("GCC_DIAGNOSTIC_HELPER") +#undef GCC_DIAGNOSTIC_HELPER + +#pragma push_macro("checkAtCompileTime") +#undef checkAtCompileTime + +#pragma push_macro("DEPRECATED_FORGAME") +#undef DEPRECATED_FORGAME + +#pragma push_macro("INT32_MAIN_INT32_ARGC_TCHAR_ARGV") +#undef INT32_MAIN_INT32_ARGC_TCHAR_ARGV + +#pragma push_macro("TEXT_PASTE") +#undef TEXT_PASTE + +#pragma push_macro("NAMED_EVENT_STR") +#undef NAMED_EVENT_STR + +#pragma push_macro("SCOPED_NAMED_EVENT") +#undef SCOPED_NAMED_EVENT + +#pragma push_macro("SCOPED_NAMED_EVENT_FSTRING") +#undef SCOPED_NAMED_EVENT_FSTRING + +#pragma push_macro("SCOPED_NAMED_EVENT_TCHAR") +#undef SCOPED_NAMED_EVENT_TCHAR + +#pragma push_macro("SCOPED_NAMED_EVENT_TEXT") +#undef SCOPED_NAMED_EVENT_TEXT + +#pragma push_macro("SCOPED_NAMED_EVENT_F") +#undef SCOPED_NAMED_EVENT_F + +#pragma push_macro("SCOPED_PROFILER_COLOR") +#undef SCOPED_PROFILER_COLOR + +#pragma push_macro("PREPROCESSOR_TO_STRING") +#undef PREPROCESSOR_TO_STRING + +#pragma push_macro("PREPROCESSOR_TO_STRING_INNER") +#undef PREPROCESSOR_TO_STRING_INNER + +#pragma push_macro("PREPROCESSOR_JOIN") +#undef PREPROCESSOR_JOIN + +#pragma push_macro("PREPROCESSOR_JOIN_INNER") +#undef PREPROCESSOR_JOIN_INNER + +#pragma push_macro("PREPROCESSOR_JOIN_FIRST") +#undef PREPROCESSOR_JOIN_FIRST + +#pragma push_macro("PREPROCESSOR_JOIN_FIRST_INNER") +#undef PREPROCESSOR_JOIN_FIRST_INNER + +#pragma push_macro("PREPROCESSOR_IF") +#undef PREPROCESSOR_IF + +#pragma push_macro("PREPROCESSOR_IF_INNER_1") +#undef PREPROCESSOR_IF_INNER_1 + +#pragma push_macro("PREPROCESSOR_IF_INNER_0") +#undef PREPROCESSOR_IF_INNER_0 + +#pragma push_macro("PREPROCESSOR_COMMA_SEPARATED") +#undef PREPROCESSOR_COMMA_SEPARATED + +#pragma push_macro("DEFINE_VARIABLE") +#undef DEFINE_VARIABLE + +#pragma push_macro("PREPROCESSOR_REMOVE_OPTIONAL_PARENS") +#undef PREPROCESSOR_REMOVE_OPTIONAL_PARENS + +#pragma push_macro("PREPROCESSOR_REMOVE_OPTIONAL_PARENS_IMPL") +#undef PREPROCESSOR_REMOVE_OPTIONAL_PARENS_IMPL + +#pragma push_macro("COMPILED_PLATFORM_HEADER") +#undef COMPILED_PLATFORM_HEADER + +#pragma push_macro("COMPILED_PLATFORM_HEADER_WITH_PREFIX") +#undef COMPILED_PLATFORM_HEADER_WITH_PREFIX + +#pragma push_macro("FAST_DECIMAL_FORMAT_SIGNED_IMPL") +#undef FAST_DECIMAL_FORMAT_SIGNED_IMPL + +#pragma push_macro("FAST_DECIMAL_FORMAT_UNSIGNED_IMPL") +#undef FAST_DECIMAL_FORMAT_UNSIGNED_IMPL + +#pragma push_macro("FAST_DECIMAL_FORMAT_FRACTIONAL_IMPL") +#undef FAST_DECIMAL_FORMAT_FRACTIONAL_IMPL + +#pragma push_macro("FAST_DECIMAL_PARSE_INTEGER_IMPL") +#undef FAST_DECIMAL_PARSE_INTEGER_IMPL + +#pragma push_macro("FAST_DECIMAL_PARSE_FRACTIONAL_IMPL") +#undef FAST_DECIMAL_PARSE_FRACTIONAL_IMPL + +#pragma push_macro("LOCTEXT") +#undef LOCTEXT + +#pragma push_macro("NSLOCTEXT") +#undef NSLOCTEXT + +#pragma push_macro("INVTEXT") +#undef INVTEXT + +#pragma push_macro("LOCGEN_NUMBER") +#undef LOCGEN_NUMBER + +#pragma push_macro("LOCGEN_NUMBER_GROUPED") +#undef LOCGEN_NUMBER_GROUPED + +#pragma push_macro("LOCGEN_NUMBER_UNGROUPED") +#undef LOCGEN_NUMBER_UNGROUPED + +#pragma push_macro("LOCGEN_NUMBER_CUSTOM") +#undef LOCGEN_NUMBER_CUSTOM + +#pragma push_macro("LOCGEN_PERCENT") +#undef LOCGEN_PERCENT + +#pragma push_macro("LOCGEN_PERCENT_GROUPED") +#undef LOCGEN_PERCENT_GROUPED + +#pragma push_macro("LOCGEN_PERCENT_UNGROUPED") +#undef LOCGEN_PERCENT_UNGROUPED + +#pragma push_macro("LOCGEN_PERCENT_CUSTOM") +#undef LOCGEN_PERCENT_CUSTOM + +#pragma push_macro("LOCGEN_CURRENCY") +#undef LOCGEN_CURRENCY + +#pragma push_macro("LOCGEN_DATE_UTC") +#undef LOCGEN_DATE_UTC + +#pragma push_macro("LOCGEN_DATE_LOCAL") +#undef LOCGEN_DATE_LOCAL + +#pragma push_macro("LOCGEN_TIME_UTC") +#undef LOCGEN_TIME_UTC + +#pragma push_macro("LOCGEN_TIME_LOCAL") +#undef LOCGEN_TIME_LOCAL + +#pragma push_macro("LOCGEN_DATETIME_UTC") +#undef LOCGEN_DATETIME_UTC + +#pragma push_macro("LOCGEN_DATETIME_LOCAL") +#undef LOCGEN_DATETIME_LOCAL + +#pragma push_macro("LOCGEN_TOUPPER") +#undef LOCGEN_TOUPPER + +#pragma push_macro("LOCGEN_TOLOWER") +#undef LOCGEN_TOLOWER + +#pragma push_macro("LOCGEN_FORMAT_ORDERED") +#undef LOCGEN_FORMAT_ORDERED + +#pragma push_macro("LOCGEN_FORMAT_NAMED") +#undef LOCGEN_FORMAT_NAMED + +#pragma push_macro("LOCTABLE_NEW") +#undef LOCTABLE_NEW + +#pragma push_macro("LOCTABLE_FROMFILE_ENGINE") +#undef LOCTABLE_FROMFILE_ENGINE + +#pragma push_macro("LOCTABLE_FROMFILE_GAME") +#undef LOCTABLE_FROMFILE_GAME + +#pragma push_macro("LOCTABLE_SETSTRING") +#undef LOCTABLE_SETSTRING + +#pragma push_macro("LOCTABLE_SETMETA") +#undef LOCTABLE_SETMETA + +#pragma push_macro("LOCTABLE") +#undef LOCTABLE + +#pragma push_macro("_aligned_msize") +#undef _aligned_msize + +#pragma push_macro("UE_LOG_EXPAND_IS_FATAL") +#undef UE_LOG_EXPAND_IS_FATAL + +#pragma push_macro("UE_LOG_EXPAND_IS_FATAL_Fatal") +#undef UE_LOG_EXPAND_IS_FATAL_Fatal + +#pragma push_macro("UE_LOG_EXPAND_IS_FATAL_Error") +#undef UE_LOG_EXPAND_IS_FATAL_Error + +#pragma push_macro("UE_LOG_EXPAND_IS_FATAL_Warning") +#undef UE_LOG_EXPAND_IS_FATAL_Warning + +#pragma push_macro("UE_LOG_EXPAND_IS_FATAL_Display") +#undef UE_LOG_EXPAND_IS_FATAL_Display + +#pragma push_macro("UE_LOG_EXPAND_IS_FATAL_Log") +#undef UE_LOG_EXPAND_IS_FATAL_Log + +#pragma push_macro("UE_LOG_EXPAND_IS_FATAL_Verbose") +#undef UE_LOG_EXPAND_IS_FATAL_Verbose + +#pragma push_macro("UE_LOG_EXPAND_IS_FATAL_VeryVerbose") +#undef UE_LOG_EXPAND_IS_FATAL_VeryVerbose + +#pragma push_macro("UE_LOG_EXPAND_IS_FATAL_All") +#undef UE_LOG_EXPAND_IS_FATAL_All + +#pragma push_macro("UE_LOG_EXPAND_IS_FATAL_SetColor") +#undef UE_LOG_EXPAND_IS_FATAL_SetColor + +#pragma push_macro("UE_LOG_SOURCE_FILE") +#undef UE_LOG_SOURCE_FILE + +#pragma push_macro("UE_LOG") +#undef UE_LOG + +#pragma push_macro("UE_LOG_CLINKAGE") +#undef UE_LOG_CLINKAGE + +#pragma push_macro("UE_CLOG") +#undef UE_CLOG + +#pragma push_macro("UE_LOG_ACTIVE") +#undef UE_LOG_ACTIVE + +#pragma push_macro("UE_LOG_ANY_ACTIVE") +#undef UE_LOG_ANY_ACTIVE + +#pragma push_macro("UE_SUPPRESS") +#undef UE_SUPPRESS + +#pragma push_macro("UE_GET_LOG_VERBOSITY") +#undef UE_GET_LOG_VERBOSITY + +#pragma push_macro("UE_SET_LOG_VERBOSITY") +#undef UE_SET_LOG_VERBOSITY + +#pragma push_macro("DECLARE_LOG_CATEGORY_EXTERN") +#undef DECLARE_LOG_CATEGORY_EXTERN + +#pragma push_macro("DEFINE_LOG_CATEGORY") +#undef DEFINE_LOG_CATEGORY + +#pragma push_macro("DEFINE_LOG_CATEGORY_STATIC") +#undef DEFINE_LOG_CATEGORY_STATIC + +#pragma push_macro("DECLARE_LOG_CATEGORY_CLASS") +#undef DECLARE_LOG_CATEGORY_CLASS + +#pragma push_macro("DEFINE_LOG_CATEGORY_CLASS") +#undef DEFINE_LOG_CATEGORY_CLASS + +#pragma push_macro("UE_SECURITY_LOG") +#undef UE_SECURITY_LOG + +#pragma push_macro("NOTIFY_CLIENT_OF_SECURITY_EVENT_IF_NOT_SHIPPING") +#undef NOTIFY_CLIENT_OF_SECURITY_EVENT_IF_NOT_SHIPPING + +#pragma push_macro("CLOSE_CONNECTION_DUE_TO_SECURITY_VIOLATION_INNER") +#undef CLOSE_CONNECTION_DUE_TO_SECURITY_VIOLATION_INNER + +#pragma push_macro("CLOSE_CONNECTION_DUE_TO_SECURITY_VIOLATION") +#undef CLOSE_CONNECTION_DUE_TO_SECURITY_VIOLATION + +#pragma push_macro("logOrEnsureNanError") +#undef logOrEnsureNanError + +#pragma push_macro("LOG_SCOPE_VERBOSITY_OVERRIDE") +#undef LOG_SCOPE_VERBOSITY_OVERRIDE + +#pragma push_macro("TRACE_LOG_CATEGORY") +#undef TRACE_LOG_CATEGORY + +#pragma push_macro("TRACE_LOG_MESSAGE") +#undef TRACE_LOG_MESSAGE + +#pragma push_macro("CREATE_FUNCTION_SHIM") +#undef CREATE_FUNCTION_SHIM + +#pragma push_macro("CREATE_GLOBAL_SHIM") +#undef CREATE_GLOBAL_SHIM + +#pragma push_macro("CREATE_DEPRECATED_SHIM") +#undef CREATE_DEPRECATED_SHIM + +#pragma push_macro("CREATE_DEPRECATED_MSG_SHIM") +#undef CREATE_DEPRECATED_MSG_SHIM + +#pragma push_macro("LUMIN_MLSDK_API_DEPRECATED_MSG") +#undef LUMIN_MLSDK_API_DEPRECATED_MSG + +#pragma push_macro("AOS_TO_SOA2_ISPC") +#undef AOS_TO_SOA2_ISPC + +#pragma push_macro("AOS_TO_SOA3_ISPC") +#undef AOS_TO_SOA3_ISPC + +#pragma push_macro("AOS_TO_SOA4_ISPC") +#undef AOS_TO_SOA4_ISPC + +#pragma push_macro("AOS_TO_SOA6_ISPC") +#undef AOS_TO_SOA6_ISPC + +#pragma push_macro("DEFINE_EXPRESSION_OPERATOR_NODE") +#undef DEFINE_EXPRESSION_OPERATOR_NODE + +#pragma push_macro("FOREACH_OCTREE_CHILD_NODE") +#undef FOREACH_OCTREE_CHILD_NODE + +#pragma push_macro("DEFINE_INTERPCURVE_WRAPPER_STRUCT") +#undef DEFINE_INTERPCURVE_WRAPPER_STRUCT + +#pragma push_macro("DEFINE_INTERVAL_WRAPPER_STRUCT") +#undef DEFINE_INTERVAL_WRAPPER_STRUCT + +#pragma push_macro("DEFINE_RANGE_WRAPPER_STRUCT") +#undef DEFINE_RANGE_WRAPPER_STRUCT + +#pragma push_macro("DEFINE_RANGEBOUND_WRAPPER_STRUCT") +#undef DEFINE_RANGEBOUND_WRAPPER_STRUCT + +#pragma push_macro("NonZeroAnimWeight") +#undef NonZeroAnimWeight + +#pragma push_macro("NonOneAnimWeight") +#undef NonOneAnimWeight + +#pragma push_macro("ScalarReciprocal") +#undef ScalarReciprocal + +#pragma push_macro("SOA_TO_AOS2_ISPC") +#undef SOA_TO_AOS2_ISPC + +#pragma push_macro("SOA_TO_AOS3_ISPC") +#undef SOA_TO_AOS3_ISPC + +#pragma push_macro("SOA_TO_AOS4_ISPC") +#undef SOA_TO_AOS4_ISPC + +#pragma push_macro("SOA_TO_AOS6_ISPC") +#undef SOA_TO_AOS6_ISPC + +#pragma push_macro("_PS_CONST") +#undef _PS_CONST + +#pragma push_macro("_PI32_CONST") +#undef _PI32_CONST + +#pragma push_macro("_PS_CONST_TYPE") +#undef _PS_CONST_TYPE + +#pragma push_macro("COPY_XMM_TO_MM") +#undef COPY_XMM_TO_MM + +#pragma push_macro("COPY_MM_TO_XMM") +#undef COPY_MM_TO_XMM + +#pragma push_macro("DECLARE_VECTOR_REGISTER") +#undef DECLARE_VECTOR_REGISTER + +#pragma push_macro("VectorZero") +#undef VectorZero + +#pragma push_macro("VectorOne") +#undef VectorOne + +#pragma push_macro("VectorLoad") +#undef VectorLoad + +#pragma push_macro("VectorLoadFloat3") +#undef VectorLoadFloat3 + +#pragma push_macro("VectorLoadFloat3_W0") +#undef VectorLoadFloat3_W0 + +#pragma push_macro("VectorLoadFloat3_W1") +#undef VectorLoadFloat3_W1 + +#pragma push_macro("VectorLoadAligned") +#undef VectorLoadAligned + +#pragma push_macro("VectorLoadFloat1") +#undef VectorLoadFloat1 + +#pragma push_macro("VectorLoadFloat2") +#undef VectorLoadFloat2 + +#pragma push_macro("VectorSetFloat3") +#undef VectorSetFloat3 + +#pragma push_macro("VectorSetFloat1") +#undef VectorSetFloat1 + +#pragma push_macro("VectorSet") +#undef VectorSet + +#pragma push_macro("VectorStoreAligned") +#undef VectorStoreAligned + +#pragma push_macro("VectorStoreAlignedStreamed") +#undef VectorStoreAlignedStreamed + +#pragma push_macro("VectorStore") +#undef VectorStore + +#pragma push_macro("VectorStoreFloat3") +#undef VectorStoreFloat3 + +#pragma push_macro("VectorStoreFloat1") +#undef VectorStoreFloat1 + +#pragma push_macro("VectorReplicate") +#undef VectorReplicate + +#pragma push_macro("VectorAbs") +#undef VectorAbs + +#pragma push_macro("VectorNegate") +#undef VectorNegate + +#pragma push_macro("VectorAdd") +#undef VectorAdd + +#pragma push_macro("VectorSubtract") +#undef VectorSubtract + +#pragma push_macro("VectorMultiply") +#undef VectorMultiply + +#pragma push_macro("VectorDivide") +#undef VectorDivide + +#pragma push_macro("VectorMultiplyAdd") +#undef VectorMultiplyAdd + +#pragma push_macro("VectorDot3") +#undef VectorDot3 + +#pragma push_macro("VectorDot4") +#undef VectorDot4 + +#pragma push_macro("VectorCompareEQ") +#undef VectorCompareEQ + +#pragma push_macro("VectorCompareNE") +#undef VectorCompareNE + +#pragma push_macro("VectorCompareGT") +#undef VectorCompareGT + +#pragma push_macro("VectorCompareGE") +#undef VectorCompareGE + +#pragma push_macro("VectorCompareLT") +#undef VectorCompareLT + +#pragma push_macro("VectorCompareLE") +#undef VectorCompareLE + +#pragma push_macro("VectorSelect") +#undef VectorSelect + +#pragma push_macro("VectorBitwiseOr") +#undef VectorBitwiseOr + +#pragma push_macro("VectorBitwiseAnd") +#undef VectorBitwiseAnd + +#pragma push_macro("VectorBitwiseXor") +#undef VectorBitwiseXor + +#pragma push_macro("VectorMaskBits") +#undef VectorMaskBits + +#pragma push_macro("VectorCross") +#undef VectorCross + +#pragma push_macro("VectorPow") +#undef VectorPow + +#pragma push_macro("VectorReciprocalSqrt") +#undef VectorReciprocalSqrt + +#pragma push_macro("VectorReciprocal") +#undef VectorReciprocal + +#pragma push_macro("VectorReciprocalLen") +#undef VectorReciprocalLen + +#pragma push_macro("VectorReciprocalSqrtAccurate") +#undef VectorReciprocalSqrtAccurate + +#pragma push_macro("VectorReciprocalAccurate") +#undef VectorReciprocalAccurate + +#pragma push_macro("VectorNormalize") +#undef VectorNormalize + +#pragma push_macro("VectorSet_W0") +#undef VectorSet_W0 + +#pragma push_macro("VectorSet_W1") +#undef VectorSet_W1 + +#pragma push_macro("VectorMin") +#undef VectorMin + +#pragma push_macro("VectorMax") +#undef VectorMax + +#pragma push_macro("VectorSwizzle") +#undef VectorSwizzle + +#pragma push_macro("VectorShuffle") +#undef VectorShuffle + +#pragma push_macro("VectorMask_LT") +#undef VectorMask_LT + +#pragma push_macro("VectorMask_LE") +#undef VectorMask_LE + +#pragma push_macro("VectorMask_GT") +#undef VectorMask_GT + +#pragma push_macro("VectorMask_GE") +#undef VectorMask_GE + +#pragma push_macro("VectorMask_EQ") +#undef VectorMask_EQ + +#pragma push_macro("VectorMask_NE") +#undef VectorMask_NE + +#pragma push_macro("VectorLoadByte4") +#undef VectorLoadByte4 + +#pragma push_macro("VectorLoadSignedByte4") +#undef VectorLoadSignedByte4 + +#pragma push_macro("VectorStoreByte4") +#undef VectorStoreByte4 + +#pragma push_macro("VectorStoreSignedByte4") +#undef VectorStoreSignedByte4 + +#pragma push_macro("VectorLoadURGB10A2N") +#undef VectorLoadURGB10A2N + +#pragma push_macro("VectorStoreURGB10A2N") +#undef VectorStoreURGB10A2N + +#pragma push_macro("VectorLoadURGBA16N") +#undef VectorLoadURGBA16N + +#pragma push_macro("VectorLoadSRGBA16N") +#undef VectorLoadSRGBA16N + +#pragma push_macro("VectorStoreURGBA16N") +#undef VectorStoreURGBA16N + +#pragma push_macro("VectorResetFloatRegisters") +#undef VectorResetFloatRegisters + +#pragma push_macro("VectorGetControlRegister") +#undef VectorGetControlRegister + +#pragma push_macro("VectorIntAnd") +#undef VectorIntAnd + +#pragma push_macro("VectorIntOr") +#undef VectorIntOr + +#pragma push_macro("VectorIntXor") +#undef VectorIntXor + +#pragma push_macro("VectorIntAndNot") +#undef VectorIntAndNot + +#pragma push_macro("VectorIntNot") +#undef VectorIntNot + +#pragma push_macro("VectorIntCompareEQ") +#undef VectorIntCompareEQ + +#pragma push_macro("VectorIntCompareNEQ") +#undef VectorIntCompareNEQ + +#pragma push_macro("VectorIntCompareGT") +#undef VectorIntCompareGT + +#pragma push_macro("VectorIntCompareLT") +#undef VectorIntCompareLT + +#pragma push_macro("VectorIntCompareGE") +#undef VectorIntCompareGE + +#pragma push_macro("VectorIntCompareLE") +#undef VectorIntCompareLE + +#pragma push_macro("VectorIntAdd") +#undef VectorIntAdd + +#pragma push_macro("VectorIntSubtract") +#undef VectorIntSubtract + +#pragma push_macro("VectorIntNegate") +#undef VectorIntNegate + +#pragma push_macro("VectorIntSign") +#undef VectorIntSign + +#pragma push_macro("VectorIntToFloat") +#undef VectorIntToFloat + +#pragma push_macro("VectorFloatToInt") +#undef VectorFloatToInt + +#pragma push_macro("VectorIntStore") +#undef VectorIntStore + +#pragma push_macro("VectorIntLoad") +#undef VectorIntLoad + +#pragma push_macro("VectorIntStoreAligned") +#undef VectorIntStoreAligned + +#pragma push_macro("VectorIntLoadAligned") +#undef VectorIntLoadAligned + +#pragma push_macro("VectorIntLoad1") +#undef VectorIntLoad1 + +#pragma push_macro("VectorLoadByte4Reverse") +#undef VectorLoadByte4Reverse + +#pragma push_macro("VectorPermute") +#undef VectorPermute + +#pragma push_macro("VectorSetComponent") +#undef VectorSetComponent + +#pragma push_macro("VectorIntMultiply") +#undef VectorIntMultiply + +#pragma push_macro("VectorIntMin") +#undef VectorIntMin + +#pragma push_macro("VectorIntMax") +#undef VectorIntMax + +#pragma push_macro("VectorIntAbs") +#undef VectorIntAbs + +#pragma push_macro("SHUFFLEMASK") +#undef SHUFFLEMASK + +#pragma push_macro("VectorMergeVecXYZ_VecW") +#undef VectorMergeVecXYZ_VecW + +#pragma push_macro("VectorAnyGreaterThan") +#undef VectorAnyGreaterThan + +#pragma push_macro("INTEL_ORDER_VECTOR") +#undef INTEL_ORDER_VECTOR + +#pragma push_macro("MEMPRO_TRACK_ALLOC") +#undef MEMPRO_TRACK_ALLOC + +#pragma push_macro("MEMPRO_TRACK_FREE") +#undef MEMPRO_TRACK_FREE + +#pragma push_macro("MEMPRO_ASSERT") +#undef MEMPRO_ASSERT + +#pragma push_macro("MEMPRO_DISABLE_WARNING") +#undef MEMPRO_DISABLE_WARNING + +#pragma push_macro("MEMPRO_ALIGN_SUFFIX") +#undef MEMPRO_ALIGN_SUFFIX + +#pragma push_macro("_DebugBreakAndPromptForRemote") +#undef _DebugBreakAndPromptForRemote + +#pragma push_macro("checkCode") +#undef checkCode + +#pragma push_macro("verify") +#undef verify #pragma push_macro("check") #undef check -#pragma push_macro("PI") -#undef PI +#pragma push_macro("UE_CHECK_IMPL") +#undef UE_CHECK_IMPL + +#pragma push_macro("verifyf") +#undef verifyf + +#pragma push_macro("checkf") +#undef checkf + +#pragma push_macro("UE_CHECK_F_IMPL") +#undef UE_CHECK_F_IMPL + +#pragma push_macro("checkNoEntry") +#undef checkNoEntry + +#pragma push_macro("checkNoReentry") +#undef checkNoReentry + +#pragma push_macro("checkNoRecursion") +#undef checkNoRecursion + +#pragma push_macro("unimplemented") +#undef unimplemented + +#pragma push_macro("checkSlow") +#undef checkSlow + +#pragma push_macro("checkfSlow") +#undef checkfSlow + +#pragma push_macro("verifySlow") +#undef verifySlow + +#pragma push_macro("UE_ENSURE_IMPL") +#undef UE_ENSURE_IMPL + +#pragma push_macro("ensure") +#undef ensure + +#pragma push_macro("ensureMsgf") +#undef ensureMsgf + +#pragma push_macro("ensureAlways") +#undef ensureAlways + +#pragma push_macro("ensureAlwaysMsgf") +#undef ensureAlwaysMsgf + +#pragma push_macro("GET_ENUMERATOR_NAME_CHECKED") +#undef GET_ENUMERATOR_NAME_CHECKED + +#pragma push_macro("GET_MEMBER_NAME_CHECKED") +#undef GET_MEMBER_NAME_CHECKED + +#pragma push_macro("GET_MEMBER_NAME_STRING_CHECKED") +#undef GET_MEMBER_NAME_STRING_CHECKED + +#pragma push_macro("GET_FUNCTION_NAME_CHECKED") +#undef GET_FUNCTION_NAME_CHECKED + +#pragma push_macro("GET_FUNCTION_NAME_STRING_CHECKED") +#undef GET_FUNCTION_NAME_STRING_CHECKED + +#pragma push_macro("LowLevelFatalError") +#undef LowLevelFatalError + +#pragma push_macro("TestTrueExpr") +#undef TestTrueExpr + +#pragma push_macro("DEFINE_LATENT_AUTOMATION_COMMAND") +#undef DEFINE_LATENT_AUTOMATION_COMMAND + +#pragma push_macro("DEFINE_LATENT_AUTOMATION_COMMAND_ONE_PARAMETER") +#undef DEFINE_LATENT_AUTOMATION_COMMAND_ONE_PARAMETER + +#pragma push_macro("DEFINE_LATENT_AUTOMATION_COMMAND_TWO_PARAMETER") +#undef DEFINE_LATENT_AUTOMATION_COMMAND_TWO_PARAMETER + +#pragma push_macro("DEFINE_LATENT_AUTOMATION_COMMAND_THREE_PARAMETER") +#undef DEFINE_LATENT_AUTOMATION_COMMAND_THREE_PARAMETER + +#pragma push_macro("DEFINE_LATENT_AUTOMATION_COMMAND_FOUR_PARAMETER") +#undef DEFINE_LATENT_AUTOMATION_COMMAND_FOUR_PARAMETER + +#pragma push_macro("DEFINE_LATENT_AUTOMATION_COMMAND_FIVE_PARAMETER") +#undef DEFINE_LATENT_AUTOMATION_COMMAND_FIVE_PARAMETER + +#pragma push_macro("DEFINE_EXPORTED_LATENT_AUTOMATION_COMMAND") +#undef DEFINE_EXPORTED_LATENT_AUTOMATION_COMMAND + +#pragma push_macro("DEFINE_EXPORTED_LATENT_AUTOMATION_COMMAND_ONE_PARAMETER") +#undef DEFINE_EXPORTED_LATENT_AUTOMATION_COMMAND_ONE_PARAMETER + +#pragma push_macro("DEFINE_ENGINE_LATENT_AUTOMATION_COMMAND") +#undef DEFINE_ENGINE_LATENT_AUTOMATION_COMMAND + +#pragma push_macro("DEFINE_ENGINE_LATENT_AUTOMATION_COMMAND_ONE_PARAMETER") +#undef DEFINE_ENGINE_LATENT_AUTOMATION_COMMAND_ONE_PARAMETER + +#pragma push_macro("ADD_LATENT_AUTOMATION_COMMAND") +#undef ADD_LATENT_AUTOMATION_COMMAND + +#pragma push_macro("START_NETWORK_AUTOMATION_COMMAND") +#undef START_NETWORK_AUTOMATION_COMMAND + +#pragma push_macro("END_NETWORK_AUTOMATION_COMMAND") +#undef END_NETWORK_AUTOMATION_COMMAND + +#pragma push_macro("IMPLEMENT_SIMPLE_AUTOMATION_TEST_PRIVATE") +#undef IMPLEMENT_SIMPLE_AUTOMATION_TEST_PRIVATE + +#pragma push_macro("IMPLEMENT_COMPLEX_AUTOMATION_TEST_PRIVATE") +#undef IMPLEMENT_COMPLEX_AUTOMATION_TEST_PRIVATE + +#pragma push_macro("IMPLEMENT_NETWORKED_AUTOMATION_TEST_PRIVATE") +#undef IMPLEMENT_NETWORKED_AUTOMATION_TEST_PRIVATE + +#pragma push_macro("IMPLEMENT_BDD_AUTOMATION_TEST_PRIVATE") +#undef IMPLEMENT_BDD_AUTOMATION_TEST_PRIVATE + +#pragma push_macro("DEFINE_SPEC_PRIVATE") +#undef DEFINE_SPEC_PRIVATE + +#pragma push_macro("BEGIN_DEFINE_SPEC_PRIVATE") +#undef BEGIN_DEFINE_SPEC_PRIVATE + +#pragma push_macro("IMPLEMENT_SIMPLE_AUTOMATION_TEST") +#undef IMPLEMENT_SIMPLE_AUTOMATION_TEST + +#pragma push_macro("IMPLEMENT_COMPLEX_AUTOMATION_TEST") +#undef IMPLEMENT_COMPLEX_AUTOMATION_TEST + +#pragma push_macro("IMPLEMENT_COMPLEX_AUTOMATION_CLASS") +#undef IMPLEMENT_COMPLEX_AUTOMATION_CLASS + +#pragma push_macro("IMPLEMENT_NETWORKED_AUTOMATION_TEST") +#undef IMPLEMENT_NETWORKED_AUTOMATION_TEST + +#pragma push_macro("IMPLEMENT_CUSTOM_SIMPLE_AUTOMATION_TEST") +#undef IMPLEMENT_CUSTOM_SIMPLE_AUTOMATION_TEST + +#pragma push_macro("IMPLEMENT_CUSTOM_COMPLEX_AUTOMATION_TEST") +#undef IMPLEMENT_CUSTOM_COMPLEX_AUTOMATION_TEST + +#pragma push_macro("IMPLEMENT_BDD_AUTOMATION_TEST") +#undef IMPLEMENT_BDD_AUTOMATION_TEST + +#pragma push_macro("DEFINE_SPEC") +#undef DEFINE_SPEC + +#pragma push_macro("BEGIN_DEFINE_SPEC") +#undef BEGIN_DEFINE_SPEC + +#pragma push_macro("END_DEFINE_SPEC") +#undef END_DEFINE_SPEC + +#pragma push_macro("BEGIN_CUSTOM_COMPLEX_AUTOMATION_TEST") +#undef BEGIN_CUSTOM_COMPLEX_AUTOMATION_TEST + +#pragma push_macro("END_CUSTOM_COMPLEX_AUTOMATION_TEST") +#undef END_CUSTOM_COMPLEX_AUTOMATION_TEST + +#pragma push_macro("UTEST_EQUAL") +#undef UTEST_EQUAL + +#pragma push_macro("UTEST_EQUAL_TOLERANCE") +#undef UTEST_EQUAL_TOLERANCE + +#pragma push_macro("UTEST_EQUAL_INSENSITIVE") +#undef UTEST_EQUAL_INSENSITIVE + +#pragma push_macro("UTEST_NOT_EQUAL") +#undef UTEST_NOT_EQUAL + +#pragma push_macro("UTEST_SAME") +#undef UTEST_SAME + +#pragma push_macro("UTEST_NOT_SAME") +#undef UTEST_NOT_SAME + +#pragma push_macro("UTEST_TRUE") +#undef UTEST_TRUE + +#pragma push_macro("UTEST_FALSE") +#undef UTEST_FALSE + +#pragma push_macro("UTEST_VALID") +#undef UTEST_VALID + +#pragma push_macro("UTEST_INVALID") +#undef UTEST_INVALID + +#pragma push_macro("UTEST_NULL") +#undef UTEST_NULL + +#pragma push_macro("UTEST_NOT_NULL") +#undef UTEST_NOT_NULL + +#pragma push_macro("BYTESWAP_ORDER16_unsigned") +#undef BYTESWAP_ORDER16_unsigned + +#pragma push_macro("BYTESWAP_ORDER32_unsigned") +#undef BYTESWAP_ORDER32_unsigned + +#pragma push_macro("UE_BYTESWAP_INTRINSIC_PRIVATE_16") +#undef UE_BYTESWAP_INTRINSIC_PRIVATE_16 + +#pragma push_macro("UE_BYTESWAP_INTRINSIC_PRIVATE_32") +#undef UE_BYTESWAP_INTRINSIC_PRIVATE_32 + +#pragma push_macro("UE_BYTESWAP_INTRINSIC_PRIVATE_64") +#undef UE_BYTESWAP_INTRINSIC_PRIVATE_64 + +#pragma push_macro("INTEL_ORDER16") +#undef INTEL_ORDER16 + +#pragma push_macro("INTEL_ORDER32") +#undef INTEL_ORDER32 + +#pragma push_macro("INTEL_ORDERF") +#undef INTEL_ORDERF + +#pragma push_macro("INTEL_ORDER64") +#undef INTEL_ORDER64 + +#pragma push_macro("INTEL_ORDER_TCHARARRAY") +#undef INTEL_ORDER_TCHARARRAY + +#pragma push_macro("NETWORK_ORDER16") +#undef NETWORK_ORDER16 + +#pragma push_macro("NETWORK_ORDER32") +#undef NETWORK_ORDER32 + +#pragma push_macro("NETWORK_ORDERF") +#undef NETWORK_ORDERF + +#pragma push_macro("NETWORK_ORDER64") +#undef NETWORK_ORDER64 + +#pragma push_macro("NETWORK_ORDER_TCHARARRAY") +#undef NETWORK_ORDER_TCHARARRAY + +#pragma push_macro("LITERAL") +#undef LITERAL + +#pragma push_macro("WhitelistCommandLines") +#undef WhitelistCommandLines + +#pragma push_macro("STUBBED") +#undef STUBBED + +#pragma push_macro("CLOCK_CYCLES") +#undef CLOCK_CYCLES + +#pragma push_macro("UNCLOCK_CYCLES") +#undef UNCLOCK_CYCLES + +#pragma push_macro("RETURN_VAL_IF_EXIT_REQUESTED") +#undef RETURN_VAL_IF_EXIT_REQUESTED + +#pragma push_macro("PURE_VIRTUAL") +#undef PURE_VIRTUAL + +#pragma push_macro("WARNING_LOCATION") +#undef WARNING_LOCATION + +#pragma push_macro("PUSH_MACRO") +#undef PUSH_MACRO + +#pragma push_macro("POP_MACRO") +#undef POP_MACRO + +#pragma push_macro("ANONYMOUS_VARIABLE") +#undef ANONYMOUS_VARIABLE + +#pragma push_macro("UE_DEPRECATED") +#undef UE_DEPRECATED + +#pragma push_macro("UE_DEPRECATED_FORGAME") +#undef UE_DEPRECATED_FORGAME + +#pragma push_macro("UE_STATIC_DEPRECATE") +#undef UE_STATIC_DEPRECATE + +#pragma push_macro("UE_PTRDIFF_TO_INT32") +#undef UE_PTRDIFF_TO_INT32 + +#pragma push_macro("UE_PTRDIFF_TO_UINT32") +#undef UE_PTRDIFF_TO_UINT32 + +#pragma push_macro("UE_NONCOPYABLE") +#undef UE_NONCOPYABLE + +#pragma push_macro("UE_GREATER_SORT") +#undef UE_GREATER_SORT + +#pragma push_macro("UE_VERSION_NEWER_THAN") +#undef UE_VERSION_NEWER_THAN + +#pragma push_macro("UE_VERSION_OLDER_THAN") +#undef UE_VERSION_OLDER_THAN + +#pragma push_macro("ENUM_CLASS_FLAGS") +#undef ENUM_CLASS_FLAGS + +#pragma push_macro("FRIEND_ENUM_CLASS_FLAGS") +#undef FRIEND_ENUM_CLASS_FLAGS + +#pragma push_macro("ENUM_RANGE_BY_COUNT") +#undef ENUM_RANGE_BY_COUNT + +#pragma push_macro("ENUM_RANGE_BY_FIRST_AND_LAST") +#undef ENUM_RANGE_BY_FIRST_AND_LAST + +#pragma push_macro("ENUM_RANGE_BY_VALUES") +#undef ENUM_RANGE_BY_VALUES + +#pragma push_macro("DEFINE_EXPRESSION_NODE_TYPE") +#undef DEFINE_EXPRESSION_NODE_TYPE + +#pragma push_macro("MONOLITHIC_HEADER_BOILERPLATE") +#undef MONOLITHIC_HEADER_BOILERPLATE + +#pragma push_macro("SET_WARN_COLOR") +#undef SET_WARN_COLOR + +#pragma push_macro("SET_WARN_COLOR_AND_BACKGROUND") +#undef SET_WARN_COLOR_AND_BACKGROUND + +#pragma push_macro("CLEAR_WARN_COLOR") +#undef CLEAR_WARN_COLOR + +#pragma push_macro("LogRuntimeError") +#undef LogRuntimeError + +#pragma push_macro("LogRuntimeWarning") +#undef LogRuntimeWarning + +#pragma push_macro("ensureAsRuntimeWarning") +#undef ensureAsRuntimeWarning + +#pragma push_macro("UE_STATIC_ASSERT_COMPLETE_TYPE") +#undef UE_STATIC_ASSERT_COMPLETE_TYPE + +#pragma push_macro("DEFINE_TEXT_EXPRESSION_OPERATOR_NODE") +#undef DEFINE_TEXT_EXPRESSION_OPERATOR_NODE + +#pragma push_macro("SCOPE_TIME_GUARD") +#undef SCOPE_TIME_GUARD + +#pragma push_macro("SCOPE_TIME_GUARD_MS") +#undef SCOPE_TIME_GUARD_MS + +#pragma push_macro("SCOPE_TIME_GUARD_NAMED") +#undef SCOPE_TIME_GUARD_NAMED + +#pragma push_macro("SCOPE_TIME_GUARD_NAMED_MS") +#undef SCOPE_TIME_GUARD_NAMED_MS + +#pragma push_macro("SCOPE_TIME_GUARD_DELEGATE") +#undef SCOPE_TIME_GUARD_DELEGATE + +#pragma push_macro("SCOPE_TIME_GUARD_DELEGATE_MS") +#undef SCOPE_TIME_GUARD_DELEGATE_MS + +#pragma push_macro("ENABLE_TIME_GUARDS") +#undef ENABLE_TIME_GUARDS + +#pragma push_macro("CLEAR_TIME_GUARDS") +#undef CLEAR_TIME_GUARDS + +#pragma push_macro("LIGHTWEIGHT_TIME_GUARD_BEGIN") +#undef LIGHTWEIGHT_TIME_GUARD_BEGIN + +#pragma push_macro("LIGHTWEIGHT_TIME_GUARD_END") +#undef LIGHTWEIGHT_TIME_GUARD_END + +#pragma push_macro("VARARG_DECL") +#undef VARARG_DECL + +#pragma push_macro("VARARG_BODY") +#undef VARARG_BODY + +#pragma push_macro("GET_VARARGS") +#undef GET_VARARGS + +#pragma push_macro("GET_VARARGS_WIDE") +#undef GET_VARARGS_WIDE + +#pragma push_macro("GET_VARARGS_ANSI") +#undef GET_VARARGS_ANSI + +#pragma push_macro("GET_VARARGS_RESULT") +#undef GET_VARARGS_RESULT + +#pragma push_macro("GET_VARARGS_RESULT_WIDE") +#undef GET_VARARGS_RESULT_WIDE + +#pragma push_macro("GET_VARARGS_RESULT_ANSI") +#undef GET_VARARGS_RESULT_ANSI + +#pragma push_macro("VARARG_EXTRA") +#undef VARARG_EXTRA + +#pragma push_macro("IMPLEMENT_MODULE") +#undef IMPLEMENT_MODULE + +#pragma push_macro("IMPLEMENT_GAME_MODULE") +#undef IMPLEMENT_GAME_MODULE + +#pragma push_macro("IMPLEMENT_FOREIGN_ENGINE_DIR") +#undef IMPLEMENT_FOREIGN_ENGINE_DIR + +#pragma push_macro("IMPLEMENT_LIVE_CODING_ENGINE_DIR") +#undef IMPLEMENT_LIVE_CODING_ENGINE_DIR + +#pragma push_macro("IMPLEMENT_LIVE_CODING_PROJECT") +#undef IMPLEMENT_LIVE_CODING_PROJECT + +#pragma push_macro("UE_LIST_ARGUMENT") +#undef UE_LIST_ARGUMENT + +#pragma push_macro("UE_REGISTER_SIGNING_KEY") +#undef UE_REGISTER_SIGNING_KEY + +#pragma push_macro("UE_REGISTER_ENCRYPTION_KEY") +#undef UE_REGISTER_ENCRYPTION_KEY + +#pragma push_macro("IMPLEMENT_TARGET_NAME_REGISTRATION") +#undef IMPLEMENT_TARGET_NAME_REGISTRATION + +#pragma push_macro("IMPLEMENT_APPLICATION") +#undef IMPLEMENT_APPLICATION + +#pragma push_macro("IMPLEMENT_PRIMARY_GAME_MODULE") +#undef IMPLEMENT_PRIMARY_GAME_MODULE + +#pragma push_macro("PER_MODULE_BOILERPLATE_ANYLINK") +#undef PER_MODULE_BOILERPLATE_ANYLINK + +#pragma push_macro("SCOPED_ABTEST") +#undef SCOPED_ABTEST + +#pragma push_macro("SCOPED_ABTEST_DOFIRSTTEST") +#undef SCOPED_ABTEST_DOFIRSTTEST + +#pragma push_macro("COOK_STAT") +#undef COOK_STAT + +#pragma push_macro("__TRACE_DECLARE_INLINE_COUNTER") +#undef __TRACE_DECLARE_INLINE_COUNTER + +#pragma push_macro("TRACE_INT_VALUE") +#undef TRACE_INT_VALUE + +#pragma push_macro("TRACE_FLOAT_VALUE") +#undef TRACE_FLOAT_VALUE + +#pragma push_macro("TRACE_MEMORY_VALUE") +#undef TRACE_MEMORY_VALUE + +#pragma push_macro("TRACE_DECLARE_INT_COUNTER") +#undef TRACE_DECLARE_INT_COUNTER + +#pragma push_macro("TRACE_DECLARE_INT_COUNTER_EXTERN") +#undef TRACE_DECLARE_INT_COUNTER_EXTERN + +#pragma push_macro("TRACE_DECLARE_FLOAT_COUNTER") +#undef TRACE_DECLARE_FLOAT_COUNTER + +#pragma push_macro("TRACE_DECLARE_FLOAT_COUNTER_EXTERN") +#undef TRACE_DECLARE_FLOAT_COUNTER_EXTERN + +#pragma push_macro("TRACE_DECLARE_MEMORY_COUNTER") +#undef TRACE_DECLARE_MEMORY_COUNTER + +#pragma push_macro("TRACE_DECLARE_MEMORY_COUNTER_EXTERN") +#undef TRACE_DECLARE_MEMORY_COUNTER_EXTERN + +#pragma push_macro("TRACE_COUNTER_SET") +#undef TRACE_COUNTER_SET + +#pragma push_macro("TRACE_COUNTER_ADD") +#undef TRACE_COUNTER_ADD + +#pragma push_macro("TRACE_COUNTER_SUBTRACT") +#undef TRACE_COUNTER_SUBTRACT + +#pragma push_macro("TRACE_COUNTER_INCREMENT") +#undef TRACE_COUNTER_INCREMENT + +#pragma push_macro("TRACE_COUNTER_DECREMENT") +#undef TRACE_COUNTER_DECREMENT + +#pragma push_macro("TRACE_CPUPROFILER_SHUTDOWN") +#undef TRACE_CPUPROFILER_SHUTDOWN + +#pragma push_macro("TRACE_CPUPROFILER_EVENT_SCOPE_ON_CHANNEL_STR") +#undef TRACE_CPUPROFILER_EVENT_SCOPE_ON_CHANNEL_STR + +#pragma push_macro("TRACE_CPUPROFILER_EVENT_SCOPE_ON_CHANNEL") +#undef TRACE_CPUPROFILER_EVENT_SCOPE_ON_CHANNEL + +#pragma push_macro("TRACE_CPUPROFILER_EVENT_SCOPE_STR") +#undef TRACE_CPUPROFILER_EVENT_SCOPE_STR + +#pragma push_macro("TRACE_CPUPROFILER_EVENT_SCOPE") +#undef TRACE_CPUPROFILER_EVENT_SCOPE + +#pragma push_macro("TRACE_CPUPROFILER_EVENT_SCOPE_TEXT_ON_CHANNEL") +#undef TRACE_CPUPROFILER_EVENT_SCOPE_TEXT_ON_CHANNEL + +#pragma push_macro("TRACE_CPUPROFILER_EVENT_SCOPE_TEXT") +#undef TRACE_CPUPROFILER_EVENT_SCOPE_TEXT + +#pragma push_macro("CSV_CATEGORY_INDEX") +#undef CSV_CATEGORY_INDEX + +#pragma push_macro("CSV_STAT_FNAME") +#undef CSV_STAT_FNAME + +#pragma push_macro("CSV_SCOPED_TIMING_STAT") +#undef CSV_SCOPED_TIMING_STAT + +#pragma push_macro("CSV_SCOPED_TIMING_STAT_GLOBAL") +#undef CSV_SCOPED_TIMING_STAT_GLOBAL + +#pragma push_macro("CSV_SCOPED_TIMING_STAT_EXCLUSIVE") +#undef CSV_SCOPED_TIMING_STAT_EXCLUSIVE + +#pragma push_macro("CSV_SCOPED_TIMING_STAT_EXCLUSIVE_CONDITIONAL") +#undef CSV_SCOPED_TIMING_STAT_EXCLUSIVE_CONDITIONAL + +#pragma push_macro("CSV_SCOPED_WAIT_CONDITIONAL") +#undef CSV_SCOPED_WAIT_CONDITIONAL + +#pragma push_macro("CSV_SCOPED_SET_WAIT_STAT") +#undef CSV_SCOPED_SET_WAIT_STAT + +#pragma push_macro("CSV_SCOPED_SET_WAIT_STAT_IGNORE") +#undef CSV_SCOPED_SET_WAIT_STAT_IGNORE + +#pragma push_macro("CSV_CUSTOM_STAT") +#undef CSV_CUSTOM_STAT + +#pragma push_macro("CSV_CUSTOM_STAT_GLOBAL") +#undef CSV_CUSTOM_STAT_GLOBAL + +#pragma push_macro("CSV_DEFINE_STAT") +#undef CSV_DEFINE_STAT + +#pragma push_macro("CSV_DEFINE_STAT_GLOBAL") +#undef CSV_DEFINE_STAT_GLOBAL + +#pragma push_macro("CSV_DECLARE_STAT_EXTERN") +#undef CSV_DECLARE_STAT_EXTERN + +#pragma push_macro("CSV_CUSTOM_STAT_DEFINED") +#undef CSV_CUSTOM_STAT_DEFINED + +#pragma push_macro("CSV_DEFINE_CATEGORY") +#undef CSV_DEFINE_CATEGORY + +#pragma push_macro("CSV_DECLARE_CATEGORY_EXTERN") +#undef CSV_DECLARE_CATEGORY_EXTERN + +#pragma push_macro("CSV_DEFINE_CATEGORY_MODULE") +#undef CSV_DEFINE_CATEGORY_MODULE + +#pragma push_macro("CSV_DECLARE_CATEGORY_MODULE_EXTERN") +#undef CSV_DECLARE_CATEGORY_MODULE_EXTERN + +#pragma push_macro("CSV_EVENT") +#undef CSV_EVENT + +#pragma push_macro("CSV_EVENT_GLOBAL") +#undef CSV_EVENT_GLOBAL + +#pragma push_macro("CSV_METADATA") +#undef CSV_METADATA + +#pragma push_macro("TRACE_CSV_PROFILER_REGISTER_CATEGORY") +#undef TRACE_CSV_PROFILER_REGISTER_CATEGORY + +#pragma push_macro("TRACE_CSV_PROFILER_INLINE_STAT") +#undef TRACE_CSV_PROFILER_INLINE_STAT + +#pragma push_macro("TRACE_CSV_PROFILER_INLINE_STAT_EXCLUSIVE") +#undef TRACE_CSV_PROFILER_INLINE_STAT_EXCLUSIVE + +#pragma push_macro("TRACE_CSV_PROFILER_DECLARED_STAT") +#undef TRACE_CSV_PROFILER_DECLARED_STAT + +#pragma push_macro("TRACE_CSV_PROFILER_BEGIN_STAT") +#undef TRACE_CSV_PROFILER_BEGIN_STAT + +#pragma push_macro("TRACE_CSV_PROFILER_END_STAT") +#undef TRACE_CSV_PROFILER_END_STAT + +#pragma push_macro("TRACE_CSV_PROFILER_BEGIN_EXCLUSIVE_STAT") +#undef TRACE_CSV_PROFILER_BEGIN_EXCLUSIVE_STAT + +#pragma push_macro("TRACE_CSV_PROFILER_END_EXCLUSIVE_STAT") +#undef TRACE_CSV_PROFILER_END_EXCLUSIVE_STAT + +#pragma push_macro("TRACE_CSV_PROFILER_CUSTOM_STAT") +#undef TRACE_CSV_PROFILER_CUSTOM_STAT + +#pragma push_macro("TRACE_CSV_PROFILER_EVENT") +#undef TRACE_CSV_PROFILER_EVENT + +#pragma push_macro("TRACE_CSV_PROFILER_BEGIN_CAPTURE") +#undef TRACE_CSV_PROFILER_BEGIN_CAPTURE + +#pragma push_macro("TRACE_CSV_PROFILER_END_CAPTURE") +#undef TRACE_CSV_PROFILER_END_CAPTURE + +#pragma push_macro("TRACE_CSV_PROFILER_METADATA") +#undef TRACE_CSV_PROFILER_METADATA + +#pragma push_macro("SCOPE_PROFILER_INCLUDER") +#undef SCOPE_PROFILER_INCLUDER + +#pragma push_macro("SCOPE_PROFILER_EXCLUDER") +#undef SCOPE_PROFILER_EXCLUDER + +#pragma push_macro("COUNT_INSTANCES") +#undef COUNT_INSTANCES + +#pragma push_macro("COUNT_INSTANCES_AND_LOG") +#undef COUNT_INSTANCES_AND_LOG + +#pragma push_macro("ACCUM_LOADTIME") +#undef ACCUM_LOADTIME + +#pragma push_macro("SCOPED_ACCUM_LOADTIME") +#undef SCOPED_ACCUM_LOADTIME + +#pragma push_macro("SCOPED_LOADTIMER_TEXT") +#undef SCOPED_LOADTIMER_TEXT + +#pragma push_macro("SCOPED_LOADTIMER") +#undef SCOPED_LOADTIMER + +#pragma push_macro("SCOPED_LOADTIMER_CNT") +#undef SCOPED_LOADTIMER_CNT + +#pragma push_macro("ADD_CUSTOM_LOADTIMER_META") +#undef ADD_CUSTOM_LOADTIMER_META + +#pragma push_macro("SCOPED_CUSTOM_LOADTIMER") +#undef SCOPED_CUSTOM_LOADTIMER + +#pragma push_macro("SCOPED_ACCUM_LOADTIME_STAT") +#undef SCOPED_ACCUM_LOADTIME_STAT + +#pragma push_macro("ACCUM_LOADTIMECOUNT_STAT") +#undef ACCUM_LOADTIMECOUNT_STAT + +#pragma push_macro("TRACE_BOOKMARK") +#undef TRACE_BOOKMARK + +#pragma push_macro("TRACE_BEGIN_FRAME") +#undef TRACE_BEGIN_FRAME + +#pragma push_macro("TRACE_END_FRAME") +#undef TRACE_END_FRAME + +#pragma push_macro("TRACE_PLATFORMFILE_BEGIN_OPEN") +#undef TRACE_PLATFORMFILE_BEGIN_OPEN + +#pragma push_macro("TRACE_PLATFORMFILE_END_OPEN") +#undef TRACE_PLATFORMFILE_END_OPEN + +#pragma push_macro("TRACE_PLATFORMFILE_FAIL_OPEN") +#undef TRACE_PLATFORMFILE_FAIL_OPEN + +#pragma push_macro("TRACE_PLATFORMFILE_BEGIN_CLOSE") +#undef TRACE_PLATFORMFILE_BEGIN_CLOSE + +#pragma push_macro("TRACE_PLATFORMFILE_END_CLOSE") +#undef TRACE_PLATFORMFILE_END_CLOSE + +#pragma push_macro("TRACE_PLATFORMFILE_FAIL_CLOSE") +#undef TRACE_PLATFORMFILE_FAIL_CLOSE + +#pragma push_macro("TRACE_PLATFORMFILE_BEGIN_READ") +#undef TRACE_PLATFORMFILE_BEGIN_READ + +#pragma push_macro("TRACE_PLATFORMFILE_END_READ") +#undef TRACE_PLATFORMFILE_END_READ + +#pragma push_macro("TRACE_PLATFORMFILE_BEGIN_WRITE") +#undef TRACE_PLATFORMFILE_BEGIN_WRITE + +#pragma push_macro("TRACE_PLATFORMFILE_END_WRITE") +#undef TRACE_PLATFORMFILE_END_WRITE + +#pragma push_macro("MALLOC_PROFILER") +#undef MALLOC_PROFILER + +#pragma push_macro("FArchive_Serialize_BitfieldBool") +#undef FArchive_Serialize_BitfieldBool + +#pragma push_macro("TRACE_LOADTIME_REQUEST_GROUP_SCOPE") +#undef TRACE_LOADTIME_REQUEST_GROUP_SCOPE + +#pragma push_macro("UE_STATIC_ONLY") +#undef UE_STATIC_ONLY + +#pragma push_macro("UE_DECLARE_INTERNAL_LINK_BASE") +#undef UE_DECLARE_INTERNAL_LINK_BASE + +#pragma push_macro("UE_DECLARE_INTERNAL_LINK_SPECIALIZATION") +#undef UE_DECLARE_INTERNAL_LINK_SPECIALIZATION + +#pragma push_macro("INTERNAL_LAYOUT_FIELD") +#undef INTERNAL_LAYOUT_FIELD + +#pragma push_macro("INTERNAL_LAYOUT_FIELD_WITH_WRITER") +#undef INTERNAL_LAYOUT_FIELD_WITH_WRITER + +#pragma push_macro("INTERNAL_LAYOUT_WRITE_MEMORY_IMAGE") +#undef INTERNAL_LAYOUT_WRITE_MEMORY_IMAGE + +#pragma push_macro("INTERNAL_LAYOUT_TOSTRING") +#undef INTERNAL_LAYOUT_TOSTRING + +#pragma push_macro("LAYOUT_FIELD") +#undef LAYOUT_FIELD + +#pragma push_macro("LAYOUT_MUTABLE_FIELD") +#undef LAYOUT_MUTABLE_FIELD + +#pragma push_macro("LAYOUT_FIELD_INITIALIZED") +#undef LAYOUT_FIELD_INITIALIZED + +#pragma push_macro("LAYOUT_MUTABLE_FIELD_INITIALIZED") +#undef LAYOUT_MUTABLE_FIELD_INITIALIZED + +#pragma push_macro("LAYOUT_ARRAY") +#undef LAYOUT_ARRAY + +#pragma push_macro("LAYOUT_MUTABLE_BITFIELD") +#undef LAYOUT_MUTABLE_BITFIELD + +#pragma push_macro("LAYOUT_BITFIELD") +#undef LAYOUT_BITFIELD + +#pragma push_macro("LAYOUT_FIELD_WITH_WRITER") +#undef LAYOUT_FIELD_WITH_WRITER + +#pragma push_macro("LAYOUT_MUTABLE_FIELD_WITH_WRITER") +#undef LAYOUT_MUTABLE_FIELD_WITH_WRITER + +#pragma push_macro("LAYOUT_WRITE_MEMORY_IMAGE") +#undef LAYOUT_WRITE_MEMORY_IMAGE + +#pragma push_macro("LAYOUT_TOSTRING") +#undef LAYOUT_TOSTRING + +#pragma push_macro("LAYOUT_FIELD_EDITORONLY") +#undef LAYOUT_FIELD_EDITORONLY + +#pragma push_macro("LAYOUT_ARRAY_EDITORONLY") +#undef LAYOUT_ARRAY_EDITORONLY + +#pragma push_macro("LAYOUT_BITFIELD_EDITORONLY") +#undef LAYOUT_BITFIELD_EDITORONLY + +#pragma push_macro("LAYOUT_FIELD_RAYTRACING") +#undef LAYOUT_FIELD_RAYTRACING + +#pragma push_macro("LAYOUT_FIELD_INITIALIZED_RAYTRACING") +#undef LAYOUT_FIELD_INITIALIZED_RAYTRACING + +#pragma push_macro("LAYOUT_ARRAY_RAYTRACING") +#undef LAYOUT_ARRAY_RAYTRACING + +#pragma push_macro("INTERNAL_LAYOUT_INTERFACE_PREFIX_NonVirtual") +#undef INTERNAL_LAYOUT_INTERFACE_PREFIX_NonVirtual + +#pragma push_macro("INTERNAL_LAYOUT_INTERFACE_PREFIX_Virtual") +#undef INTERNAL_LAYOUT_INTERFACE_PREFIX_Virtual + +#pragma push_macro("INTERNAL_LAYOUT_INTERFACE_PREFIX_Abstract") +#undef INTERNAL_LAYOUT_INTERFACE_PREFIX_Abstract + +#pragma push_macro("INTERNAL_LAYOUT_INTERFACE_PREFIX") +#undef INTERNAL_LAYOUT_INTERFACE_PREFIX + +#pragma push_macro("INTERNAL_LAYOUT_INTERFACE_SUFFIX") +#undef INTERNAL_LAYOUT_INTERFACE_SUFFIX + +#pragma push_macro("INTERNAL_LAYOUT_INTERFACE_INLINE_IMPL") +#undef INTERNAL_LAYOUT_INTERFACE_INLINE_IMPL + +#pragma push_macro("INTERNAL_DECLARE_TYPE_LAYOUT_COMMON") +#undef INTERNAL_DECLARE_TYPE_LAYOUT_COMMON + +#pragma push_macro("INTERNAL_DECLARE_INLINE_TYPE_LAYOUT") +#undef INTERNAL_DECLARE_INLINE_TYPE_LAYOUT + +#pragma push_macro("INTERNAL_DECLARE_TYPE_LAYOUT") +#undef INTERNAL_DECLARE_TYPE_LAYOUT + +#pragma push_macro("INTERNAL_DECLARE_LAYOUT_BASE") +#undef INTERNAL_DECLARE_LAYOUT_BASE + +#pragma push_macro("INTERNAL_DECLARE_LAYOUT_EXPLICIT_BASES") +#undef INTERNAL_DECLARE_LAYOUT_EXPLICIT_BASES + +#pragma push_macro("DECLARE_TYPE_LAYOUT") +#undef DECLARE_TYPE_LAYOUT + +#pragma push_macro("DECLARE_INLINE_TYPE_LAYOUT") +#undef DECLARE_INLINE_TYPE_LAYOUT + +#pragma push_macro("DECLARE_EXPORTED_TYPE_LAYOUT") +#undef DECLARE_EXPORTED_TYPE_LAYOUT + +#pragma push_macro("DECLARE_TYPE_LAYOUT_EXPLICIT_BASES") +#undef DECLARE_TYPE_LAYOUT_EXPLICIT_BASES + +#pragma push_macro("DECLARE_INLINE_TYPE_LAYOUT_EXPLICIT_BASES") +#undef DECLARE_INLINE_TYPE_LAYOUT_EXPLICIT_BASES + +#pragma push_macro("DECLARE_EXPORTED_TYPE_LAYOUT_EXPLICIT_BASES") +#undef DECLARE_EXPORTED_TYPE_LAYOUT_EXPLICIT_BASES + +#pragma push_macro("INTERNAL_IMPLEMENT_TYPE_LAYOUT_COMMON") +#undef INTERNAL_IMPLEMENT_TYPE_LAYOUT_COMMON + +#pragma push_macro("INTERNAL_REGISTER_TYPE_LAYOUT") +#undef INTERNAL_REGISTER_TYPE_LAYOUT + +#pragma push_macro("IMPLEMENT_UNREGISTERED_TEMPLATE_TYPE_LAYOUT") +#undef IMPLEMENT_UNREGISTERED_TEMPLATE_TYPE_LAYOUT + +#pragma push_macro("IMPLEMENT_TEMPLATE_TYPE_LAYOUT") +#undef IMPLEMENT_TEMPLATE_TYPE_LAYOUT + +#pragma push_macro("IMPLEMENT_TYPE_LAYOUT") +#undef IMPLEMENT_TYPE_LAYOUT + +#pragma push_macro("IMPLEMENT_ABSTRACT_TYPE_LAYOUT") +#undef IMPLEMENT_ABSTRACT_TYPE_LAYOUT + +#pragma push_macro("REGISTER_INLINE_TYPE_LAYOUT") +#undef REGISTER_INLINE_TYPE_LAYOUT + +#pragma push_macro("DECLARE_TEMPLATE_INTRINSIC_TYPE_LAYOUT") +#undef DECLARE_TEMPLATE_INTRINSIC_TYPE_LAYOUT + +#pragma push_macro("DECLARE_EXPORTED_TEMPLATE_INTRINSIC_TYPE_LAYOUT") +#undef DECLARE_EXPORTED_TEMPLATE_INTRINSIC_TYPE_LAYOUT + +#pragma push_macro("IMPLEMENT_EXPORTED_INTRINSIC_TYPE_LAYOUT") +#undef IMPLEMENT_EXPORTED_INTRINSIC_TYPE_LAYOUT + +#pragma push_macro("DECLARE_INTRINSIC_TYPE_LAYOUT") +#undef DECLARE_INTRINSIC_TYPE_LAYOUT + +#pragma push_macro("ALIAS_TEMPLATE_TYPE_LAYOUT") +#undef ALIAS_TEMPLATE_TYPE_LAYOUT + +#pragma push_macro("ALIAS_TYPE_LAYOUT") +#undef ALIAS_TYPE_LAYOUT + +#pragma push_macro("SA_VALUE") +#undef SA_VALUE + +#pragma push_macro("SA_ATTRIBUTE") +#undef SA_ATTRIBUTE + +#pragma push_macro("SA_OPTIONAL_ATTRIBUTE") +#undef SA_OPTIONAL_ATTRIBUTE + +#pragma push_macro("SA_FIELD_NAME") +#undef SA_FIELD_NAME + +#pragma push_macro("STAT") +#undef STAT + +#pragma push_macro("ANSI_TO_PROFILING") +#undef ANSI_TO_PROFILING + +#pragma push_macro("DECLARE_SCOPE_CYCLE_COUNTER") +#undef DECLARE_SCOPE_CYCLE_COUNTER + +#pragma push_macro("QUICK_SCOPE_CYCLE_COUNTER") +#undef QUICK_SCOPE_CYCLE_COUNTER + +#pragma push_macro("SCOPE_CYCLE_COUNTER") +#undef SCOPE_CYCLE_COUNTER + +#pragma push_macro("CONDITIONAL_SCOPE_CYCLE_COUNTER") +#undef CONDITIONAL_SCOPE_CYCLE_COUNTER + +#pragma push_macro("RETURN_QUICK_DECLARE_CYCLE_STAT") +#undef RETURN_QUICK_DECLARE_CYCLE_STAT + +#pragma push_macro("GET_STATID") +#undef GET_STATID + +#pragma push_macro("SCOPE_SECONDS_ACCUMULATOR") +#undef SCOPE_SECONDS_ACCUMULATOR + +#pragma push_macro("SCOPE_MS_ACCUMULATOR") +#undef SCOPE_MS_ACCUMULATOR + +#pragma push_macro("DEFINE_STAT") +#undef DEFINE_STAT + +#pragma push_macro("QUICK_USE_CYCLE_STAT") +#undef QUICK_USE_CYCLE_STAT + +#pragma push_macro("DECLARE_CYCLE_STAT") +#undef DECLARE_CYCLE_STAT + +#pragma push_macro("DECLARE_FLOAT_COUNTER_STAT") +#undef DECLARE_FLOAT_COUNTER_STAT + +#pragma push_macro("DECLARE_DWORD_COUNTER_STAT") +#undef DECLARE_DWORD_COUNTER_STAT + +#pragma push_macro("DECLARE_FLOAT_ACCUMULATOR_STAT") +#undef DECLARE_FLOAT_ACCUMULATOR_STAT + +#pragma push_macro("DECLARE_DWORD_ACCUMULATOR_STAT") +#undef DECLARE_DWORD_ACCUMULATOR_STAT + +#pragma push_macro("DECLARE_FNAME_STAT") +#undef DECLARE_FNAME_STAT + +#pragma push_macro("DECLARE_PTR_STAT") +#undef DECLARE_PTR_STAT + +#pragma push_macro("DECLARE_MEMORY_STAT") +#undef DECLARE_MEMORY_STAT + +#pragma push_macro("DECLARE_MEMORY_STAT_POOL") +#undef DECLARE_MEMORY_STAT_POOL + +#pragma push_macro("DECLARE_CYCLE_STAT_EXTERN") +#undef DECLARE_CYCLE_STAT_EXTERN + +#pragma push_macro("DECLARE_FLOAT_COUNTER_STAT_EXTERN") +#undef DECLARE_FLOAT_COUNTER_STAT_EXTERN + +#pragma push_macro("DECLARE_DWORD_COUNTER_STAT_EXTERN") +#undef DECLARE_DWORD_COUNTER_STAT_EXTERN + +#pragma push_macro("DECLARE_FLOAT_ACCUMULATOR_STAT_EXTERN") +#undef DECLARE_FLOAT_ACCUMULATOR_STAT_EXTERN + +#pragma push_macro("DECLARE_DWORD_ACCUMULATOR_STAT_EXTERN") +#undef DECLARE_DWORD_ACCUMULATOR_STAT_EXTERN + +#pragma push_macro("DECLARE_FNAME_STAT_EXTERN") +#undef DECLARE_FNAME_STAT_EXTERN + +#pragma push_macro("DECLARE_PTR_STAT_EXTERN") +#undef DECLARE_PTR_STAT_EXTERN + +#pragma push_macro("DECLARE_MEMORY_STAT_EXTERN") +#undef DECLARE_MEMORY_STAT_EXTERN + +#pragma push_macro("DECLARE_MEMORY_STAT_POOL_EXTERN") +#undef DECLARE_MEMORY_STAT_POOL_EXTERN + +#pragma push_macro("DECLARE_STATS_GROUP") +#undef DECLARE_STATS_GROUP + +#pragma push_macro("DECLARE_STATS_GROUP_VERBOSE") +#undef DECLARE_STATS_GROUP_VERBOSE + +#pragma push_macro("DECLARE_STATS_GROUP_MAYBE_COMPILED_OUT") +#undef DECLARE_STATS_GROUP_MAYBE_COMPILED_OUT + +#pragma push_macro("SET_CYCLE_COUNTER") +#undef SET_CYCLE_COUNTER + +#pragma push_macro("INC_DWORD_STAT") +#undef INC_DWORD_STAT + +#pragma push_macro("INC_FLOAT_STAT_BY") +#undef INC_FLOAT_STAT_BY + +#pragma push_macro("INC_DWORD_STAT_BY") +#undef INC_DWORD_STAT_BY + +#pragma push_macro("INC_DWORD_STAT_FNAME_BY") +#undef INC_DWORD_STAT_FNAME_BY + +#pragma push_macro("INC_MEMORY_STAT_BY") +#undef INC_MEMORY_STAT_BY + +#pragma push_macro("DEC_DWORD_STAT") +#undef DEC_DWORD_STAT + +#pragma push_macro("DEC_FLOAT_STAT_BY") +#undef DEC_FLOAT_STAT_BY + +#pragma push_macro("DEC_DWORD_STAT_BY") +#undef DEC_DWORD_STAT_BY + +#pragma push_macro("DEC_DWORD_STAT_FNAME_BY") +#undef DEC_DWORD_STAT_FNAME_BY + +#pragma push_macro("DEC_MEMORY_STAT_BY") +#undef DEC_MEMORY_STAT_BY + +#pragma push_macro("SET_MEMORY_STAT") +#undef SET_MEMORY_STAT + +#pragma push_macro("SET_DWORD_STAT") +#undef SET_DWORD_STAT + +#pragma push_macro("SET_FLOAT_STAT") +#undef SET_FLOAT_STAT + +#pragma push_macro("STAT_ADD_CUSTOMMESSAGE_NAME") +#undef STAT_ADD_CUSTOMMESSAGE_NAME + +#pragma push_macro("STAT_ADD_CUSTOMMESSAGE_PTR") +#undef STAT_ADD_CUSTOMMESSAGE_PTR + +#pragma push_macro("SET_CYCLE_COUNTER_FName") +#undef SET_CYCLE_COUNTER_FName + +#pragma push_macro("INC_DWORD_STAT_FName") +#undef INC_DWORD_STAT_FName + +#pragma push_macro("INC_FLOAT_STAT_BY_FName") +#undef INC_FLOAT_STAT_BY_FName + +#pragma push_macro("INC_DWORD_STAT_BY_FName") +#undef INC_DWORD_STAT_BY_FName + +#pragma push_macro("INC_MEMORY_STAT_BY_FName") +#undef INC_MEMORY_STAT_BY_FName + +#pragma push_macro("DEC_DWORD_STAT_FName") +#undef DEC_DWORD_STAT_FName + +#pragma push_macro("DEC_FLOAT_STAT_BY_FName") +#undef DEC_FLOAT_STAT_BY_FName + +#pragma push_macro("DEC_DWORD_STAT_BY_FName") +#undef DEC_DWORD_STAT_BY_FName + +#pragma push_macro("DEC_MEMORY_STAT_BY_FName") +#undef DEC_MEMORY_STAT_BY_FName + +#pragma push_macro("SET_MEMORY_STAT_FName") +#undef SET_MEMORY_STAT_FName + +#pragma push_macro("SET_DWORD_STAT_FName") +#undef SET_DWORD_STAT_FName + +#pragma push_macro("SET_FLOAT_STAT_FName") +#undef SET_FLOAT_STAT_FName + +#pragma push_macro("GET_STATFNAME") +#undef GET_STATFNAME + +#pragma push_macro("GET_STATDESCRIPTION") +#undef GET_STATDESCRIPTION + +#pragma push_macro("DECLARE_STAT_GROUP") +#undef DECLARE_STAT_GROUP + +#pragma push_macro("DECLARE_STAT") +#undef DECLARE_STAT + +#pragma push_macro("GET_STATISEVERYFRAME") +#undef GET_STATISEVERYFRAME + +#pragma push_macro("STAT_GROUP_TO_FStatGroup") +#undef STAT_GROUP_TO_FStatGroup + +#pragma push_macro("DECLARE_STATS_GROUP_SORTBYNAME") +#undef DECLARE_STATS_GROUP_SORTBYNAME + +#pragma push_macro("checkStats") +#undef checkStats + +#pragma push_macro("DECLARE_SCOPE_HIERARCHICAL_COUNTER") +#undef DECLARE_SCOPE_HIERARCHICAL_COUNTER + +#pragma push_macro("DECLARE_SCOPE_HIERARCHICAL_COUNTER_FUNC") +#undef DECLARE_SCOPE_HIERARCHICAL_COUNTER_FUNC + +#pragma push_macro("SCOPE_SECONDS_COUNTER_BASE") +#undef SCOPE_SECONDS_COUNTER_BASE + +#pragma push_macro("SCOPE_SECONDS_COUNTER_RECURSION_SAFE_BASE") +#undef SCOPE_SECONDS_COUNTER_RECURSION_SAFE_BASE + +#pragma push_macro("SCOPE_SECONDS_COUNTER") +#undef SCOPE_SECONDS_COUNTER + +#pragma push_macro("SCOPE_SECONDS_COUNTER_RECURSION_SAFE") +#undef SCOPE_SECONDS_COUNTER_RECURSION_SAFE + +#pragma push_macro("SCOPE_LOG_TIME") +#undef SCOPE_LOG_TIME + +#pragma push_macro("SCOPE_LOG_TIME_IN_SECONDS") +#undef SCOPE_LOG_TIME_IN_SECONDS + +#pragma push_macro("SCOPE_LOG_TIME_FUNC") +#undef SCOPE_LOG_TIME_FUNC + +#pragma push_macro("SCOPE_LOG_TIME_FUNC_WITH_GLOBAL") +#undef SCOPE_LOG_TIME_FUNC_WITH_GLOBAL + +#pragma push_macro("CONDITIONAL_SCOPE_LOG_TIME") +#undef CONDITIONAL_SCOPE_LOG_TIME + +#pragma push_macro("CONDITIONAL_SCOPE_LOG_TIME_IN_SECONDS") +#undef CONDITIONAL_SCOPE_LOG_TIME_IN_SECONDS + +#pragma push_macro("CONDITIONAL_SCOPE_LOG_TIME_FUNC") +#undef CONDITIONAL_SCOPE_LOG_TIME_FUNC + +#pragma push_macro("CONDITIONAL_SCOPE_LOG_TIME_FUNC_WITH_GLOBAL") +#undef CONDITIONAL_SCOPE_LOG_TIME_FUNC_WITH_GLOBAL + +#pragma push_macro("TRACE_STAT_INCREMENT") +#undef TRACE_STAT_INCREMENT + +#pragma push_macro("TRACE_STAT_DECREMENT") +#undef TRACE_STAT_DECREMENT + +#pragma push_macro("TRACE_STAT_ADD") +#undef TRACE_STAT_ADD + +#pragma push_macro("TRACE_STAT_SET") +#undef TRACE_STAT_SET + +#pragma push_macro("ALIGNOF") +#undef ALIGNOF + +#pragma push_macro("ARE_TYPES_EQUAL") +#undef ARE_TYPES_EQUAL + +#pragma push_macro("UE_PROJECTION") +#undef UE_PROJECTION + +#pragma push_macro("UE_PROJECTION_MEMBER") +#undef UE_PROJECTION_MEMBER + +#pragma push_macro("PROJECTION") +#undef PROJECTION + +#pragma push_macro("PROJECTION_MEMBER") +#undef PROJECTION_MEMBER + +#pragma push_macro("UE_TSHAREDPTR_STATIC_ASSERT_VALID_MODE") +#undef UE_TSHAREDPTR_STATIC_ASSERT_VALID_MODE + +#pragma push_macro("IMPLEMENT_ALIGNED_STORAGE") +#undef IMPLEMENT_ALIGNED_STORAGE + +#pragma push_macro("UE_ARRAY_COUNT") +#undef UE_ARRAY_COUNT + +#pragma push_macro("ARRAY_COUNT") +#undef ARRAY_COUNT + +#pragma push_macro("STRUCT_OFFSET") +#undef STRUCT_OFFSET + +#pragma push_macro("VTABLE_OFFSET") +#undef VTABLE_OFFSET + +#pragma push_macro("FGuardValue_Bitfield") +#undef FGuardValue_Bitfield + +#pragma push_macro("TEMPLATE_PARAMETERS2") +#undef TEMPLATE_PARAMETERS2 + +#pragma push_macro("HAS_TRIVIAL_CONSTRUCTOR") +#undef HAS_TRIVIAL_CONSTRUCTOR + +#pragma push_macro("IS_POD") +#undef IS_POD + +#pragma push_macro("IS_EMPTY") +#undef IS_EMPTY + +#pragma push_macro("Expose_TFormatSpecifier") +#undef Expose_TFormatSpecifier + +#pragma push_macro("Expose_TNameOf") +#undef Expose_TNameOf + +#pragma push_macro("GENERATE_MEMBER_FUNCTION_CHECK") +#undef GENERATE_MEMBER_FUNCTION_CHECK + +#pragma push_macro("NAME_INTERNAL_TO_EXTERNAL") +#undef NAME_INTERNAL_TO_EXTERNAL + +#pragma push_macro("NAME_EXTERNAL_TO_INTERNAL") +#undef NAME_EXTERNAL_TO_INTERNAL + +#pragma push_macro("PREPROCESSOR_ENUM_PROTECT") +#undef PREPROCESSOR_ENUM_PROTECT + +#pragma push_macro("DEFERRED_DEPENDENCY_CHECK") +#undef DEFERRED_DEPENDENCY_CHECK + +#pragma push_macro("UE_ASYNC_PACKAGE_DEBUG") +#undef UE_ASYNC_PACKAGE_DEBUG + +#pragma push_macro("UE_ASYNC_UPACKAGE_DEBUG") +#undef UE_ASYNC_UPACKAGE_DEBUG + +#pragma push_macro("UE_ASYNC_PACKAGE_LOG") +#undef UE_ASYNC_PACKAGE_LOG + +#pragma push_macro("UE_ASYNC_PACKAGE_CLOG") +#undef UE_ASYNC_PACKAGE_CLOG + +#pragma push_macro("UE_ASYNC_PACKAGE_LOG_VERBOSE") +#undef UE_ASYNC_PACKAGE_LOG_VERBOSE + +#pragma push_macro("UE_ASYNC_PACKAGE_CLOG_VERBOSE") +#undef UE_ASYNC_PACKAGE_CLOG_VERBOSE + +#pragma push_macro("CHECK_IOSTATUS") +#undef CHECK_IOSTATUS + +#pragma push_macro("TRACE_LOADTIME_START_ASYNC_LOADING") +#undef TRACE_LOADTIME_START_ASYNC_LOADING + +#pragma push_macro("TRACE_LOADTIME_SUSPEND_ASYNC_LOADING") +#undef TRACE_LOADTIME_SUSPEND_ASYNC_LOADING + +#pragma push_macro("TRACE_LOADTIME_RESUME_ASYNC_LOADING") +#undef TRACE_LOADTIME_RESUME_ASYNC_LOADING + +#pragma push_macro("TRACE_LOADTIME_BEGIN_REQUEST") +#undef TRACE_LOADTIME_BEGIN_REQUEST + +#pragma push_macro("TRACE_LOADTIME_END_REQUEST") +#undef TRACE_LOADTIME_END_REQUEST + +#pragma push_macro("TRACE_LOADTIME_NEW_ASYNC_PACKAGE") +#undef TRACE_LOADTIME_NEW_ASYNC_PACKAGE + +#pragma push_macro("TRACE_LOADTIME_BEGIN_LOAD_ASYNC_PACKAGE") +#undef TRACE_LOADTIME_BEGIN_LOAD_ASYNC_PACKAGE + +#pragma push_macro("TRACE_LOADTIME_END_LOAD_ASYNC_PACKAGE") +#undef TRACE_LOADTIME_END_LOAD_ASYNC_PACKAGE + +#pragma push_macro("TRACE_LOADTIME_DESTROY_ASYNC_PACKAGE") +#undef TRACE_LOADTIME_DESTROY_ASYNC_PACKAGE + +#pragma push_macro("TRACE_LOADTIME_PACKAGE_SUMMARY") +#undef TRACE_LOADTIME_PACKAGE_SUMMARY + +#pragma push_macro("TRACE_LOADTIME_ASYNC_PACKAGE_REQUEST_ASSOCIATION") +#undef TRACE_LOADTIME_ASYNC_PACKAGE_REQUEST_ASSOCIATION + +#pragma push_macro("TRACE_LOADTIME_ASYNC_PACKAGE_LINKER_ASSOCIATION") +#undef TRACE_LOADTIME_ASYNC_PACKAGE_LINKER_ASSOCIATION + +#pragma push_macro("TRACE_LOADTIME_ASYNC_PACKAGE_IMPORT_DEPENDENCY") +#undef TRACE_LOADTIME_ASYNC_PACKAGE_IMPORT_DEPENDENCY + +#pragma push_macro("TRACE_LOADTIME_CREATE_EXPORT_SCOPE") +#undef TRACE_LOADTIME_CREATE_EXPORT_SCOPE + +#pragma push_macro("TRACE_LOADTIME_SERIALIZE_EXPORT_SCOPE") +#undef TRACE_LOADTIME_SERIALIZE_EXPORT_SCOPE + +#pragma push_macro("TRACE_LOADTIME_POSTLOAD_EXPORT_SCOPE") +#undef TRACE_LOADTIME_POSTLOAD_EXPORT_SCOPE + +#pragma push_macro("TRACE_LOADTIME_CLASS_INFO") +#undef TRACE_LOADTIME_CLASS_INFO + +#pragma push_macro("XFERSTRING") +#undef XFERSTRING + +#pragma push_macro("XFERUNICODESTRING") +#undef XFERUNICODESTRING + +#pragma push_macro("XFERTEXT") +#undef XFERTEXT + +#pragma push_macro("DECLARE_CAST_BY_FLAG") +#undef DECLARE_CAST_BY_FLAG + +#pragma push_macro("FIXUP_EXPR_OBJECT_POINTER") +#undef FIXUP_EXPR_OBJECT_POINTER + +#pragma push_macro("CLASS_REDIRECT") +#undef CLASS_REDIRECT + +#pragma push_macro("CLASS_REDIRECT_INSTANCES") +#undef CLASS_REDIRECT_INSTANCES + +#pragma push_macro("STRUCT_REDIRECT") +#undef STRUCT_REDIRECT + +#pragma push_macro("ENUM_REDIRECT") +#undef ENUM_REDIRECT + +#pragma push_macro("PROPERTY_REDIRECT") +#undef PROPERTY_REDIRECT + +#pragma push_macro("FUNCTION_REDIRECT") +#undef FUNCTION_REDIRECT + +#pragma push_macro("PACKAGE_REDIRECT") +#undef PACKAGE_REDIRECT + +#pragma push_macro("COMPARE_MEMBER") +#undef COMPARE_MEMBER + +#pragma push_macro("DEFERRED_DEPENDENCY_ENSURE") +#undef DEFERRED_DEPENDENCY_ENSURE + +#pragma push_macro("CompCheck") +#undef CompCheck + +#pragma push_macro("DECLARE_OBJECT_FLAG") +#undef DECLARE_OBJECT_FLAG + +#pragma push_macro("SCOPED_SAVETIMER") +#undef SCOPED_SAVETIMER + +#pragma push_macro("STORE_INSTRUCTION_NAME") +#undef STORE_INSTRUCTION_NAME + +#pragma push_macro("IMPLEMENT_FUNCTION") +#undef IMPLEMENT_FUNCTION + +#pragma push_macro("IMPLEMENT_CAST_FUNCTION") +#undef IMPLEMENT_CAST_FUNCTION + +#pragma push_macro("IMPLEMENT_VM_FUNCTION") +#undef IMPLEMENT_VM_FUNCTION + +#pragma push_macro("ADD_COOK_STAT") +#undef ADD_COOK_STAT + +#pragma push_macro("STREAMINGTOKEN_PARAM") +#undef STREAMINGTOKEN_PARAM + +#pragma push_macro("DECLARE_CAST_BY_FLAG_FWD") +#undef DECLARE_CAST_BY_FLAG_FWD + +#pragma push_macro("DECLARE_CAST_BY_FLAG_CAST") +#undef DECLARE_CAST_BY_FLAG_CAST + +#pragma push_macro("IMPLEMENT_STRUCT") +#undef IMPLEMENT_STRUCT + +#pragma push_macro("NET_CHECKSUM_OR_END") +#undef NET_CHECKSUM_OR_END + +#pragma push_macro("NET_CHECKSUM") +#undef NET_CHECKSUM + +#pragma push_macro("NET_CHECKSUM_CUSTOM") +#undef NET_CHECKSUM_CUSTOM + +#pragma push_macro("NET_CHECKSUM_IGNORE") +#undef NET_CHECKSUM_IGNORE + +#pragma push_macro("DECLARE_FIELD") +#undef DECLARE_FIELD + +#pragma push_macro("IMPLEMENT_FIELD") +#undef IMPLEMENT_FIELD + +#pragma push_macro("UPROPERTY") +#undef UPROPERTY + +#pragma push_macro("UFUNCTION") +#undef UFUNCTION + +#pragma push_macro("USTRUCT") +#undef USTRUCT + +#pragma push_macro("UMETA") +#undef UMETA + +#pragma push_macro("UPARAM") +#undef UPARAM + +#pragma push_macro("UENUM") +#undef UENUM + +#pragma push_macro("UDELEGATE") +#undef UDELEGATE + +#pragma push_macro("RIGVM_METHOD") +#undef RIGVM_METHOD + +#pragma push_macro("BODY_MACRO_COMBINE_INNER") +#undef BODY_MACRO_COMBINE_INNER + +#pragma push_macro("BODY_MACRO_COMBINE") +#undef BODY_MACRO_COMBINE + +#pragma push_macro("GENERATED_BODY_LEGACY") +#undef GENERATED_BODY_LEGACY + +#pragma push_macro("GENERATED_BODY") +#undef GENERATED_BODY + +#pragma push_macro("GENERATED_USTRUCT_BODY") +#undef GENERATED_USTRUCT_BODY + +#pragma push_macro("GENERATED_UCLASS_BODY") +#undef GENERATED_UCLASS_BODY + +#pragma push_macro("GENERATED_UINTERFACE_BODY") +#undef GENERATED_UINTERFACE_BODY + +#pragma push_macro("GENERATED_IINTERFACE_BODY") +#undef GENERATED_IINTERFACE_BODY + +#pragma push_macro("UCLASS") +#undef UCLASS + +#pragma push_macro("UINTERFACE") +#undef UINTERFACE + +#pragma push_macro("DECLARE_FUNCTION") +#undef DECLARE_FUNCTION + +#pragma push_macro("DEFINE_FUNCTION") +#undef DEFINE_FUNCTION + +#pragma push_macro("RELAY_CONSTRUCTOR") +#undef RELAY_CONSTRUCTOR + +#pragma push_macro("COMPILED_IN_FLAGS") +#undef COMPILED_IN_FLAGS + +#pragma push_macro("DECLARE_SERIALIZER") +#undef DECLARE_SERIALIZER + +#pragma push_macro("IMPLEMENT_FARCHIVE_SERIALIZER") +#undef IMPLEMENT_FARCHIVE_SERIALIZER + +#pragma push_macro("IMPLEMENT_FSTRUCTUREDARCHIVE_SERIALIZER") +#undef IMPLEMENT_FSTRUCTUREDARCHIVE_SERIALIZER + +#pragma push_macro("DECLARE_FARCHIVE_SERIALIZER") +#undef DECLARE_FARCHIVE_SERIALIZER + +#pragma push_macro("DECLARE_FSTRUCTUREDARCHIVE_SERIALIZER") +#undef DECLARE_FSTRUCTUREDARCHIVE_SERIALIZER + +#pragma push_macro("DECLARE_CLASS") +#undef DECLARE_CLASS + +#pragma push_macro("DEFINE_FORBIDDEN_DEFAULT_CONSTRUCTOR_CALL") +#undef DEFINE_FORBIDDEN_DEFAULT_CONSTRUCTOR_CALL + +#pragma push_macro("DEFINE_DEFAULT_CONSTRUCTOR_CALL") +#undef DEFINE_DEFAULT_CONSTRUCTOR_CALL + +#pragma push_macro("DEFINE_DEFAULT_OBJECT_INITIALIZER_CONSTRUCTOR_CALL") +#undef DEFINE_DEFAULT_OBJECT_INITIALIZER_CONSTRUCTOR_CALL + +#pragma push_macro("DECLARE_VTABLE_PTR_HELPER_CTOR") +#undef DECLARE_VTABLE_PTR_HELPER_CTOR + +#pragma push_macro("DEFINE_VTABLE_PTR_HELPER_CTOR") +#undef DEFINE_VTABLE_PTR_HELPER_CTOR + +#pragma push_macro("DEFINE_VTABLE_PTR_HELPER_CTOR_CALLER_DUMMY") +#undef DEFINE_VTABLE_PTR_HELPER_CTOR_CALLER_DUMMY + +#pragma push_macro("DEFINE_VTABLE_PTR_HELPER_CTOR_CALLER") +#undef DEFINE_VTABLE_PTR_HELPER_CTOR_CALLER + +#pragma push_macro("DECLARE_CLASS_INTRINSIC_NO_CTOR") +#undef DECLARE_CLASS_INTRINSIC_NO_CTOR + +#pragma push_macro("DECLARE_CLASS_INTRINSIC") +#undef DECLARE_CLASS_INTRINSIC + +#pragma push_macro("DECLARE_CASTED_CLASS_INTRINSIC_WITH_API_NO_CTOR") +#undef DECLARE_CASTED_CLASS_INTRINSIC_WITH_API_NO_CTOR + +#pragma push_macro("DECLARE_CASTED_CLASS_INTRINSIC_WITH_API") +#undef DECLARE_CASTED_CLASS_INTRINSIC_WITH_API + +#pragma push_macro("DECLARE_CASTED_CLASS_INTRINSIC_NO_CTOR_NO_VTABLE_CTOR") +#undef DECLARE_CASTED_CLASS_INTRINSIC_NO_CTOR_NO_VTABLE_CTOR + +#pragma push_macro("DECLARE_CASTED_CLASS_INTRINSIC_NO_CTOR") +#undef DECLARE_CASTED_CLASS_INTRINSIC_NO_CTOR + +#pragma push_macro("DECLARE_CASTED_CLASS_INTRINSIC") +#undef DECLARE_CASTED_CLASS_INTRINSIC + +#pragma push_macro("DECLARE_WITHIN_INTERNAL") +#undef DECLARE_WITHIN_INTERNAL + +#pragma push_macro("DECLARE_WITHIN") +#undef DECLARE_WITHIN + +#pragma push_macro("DECLARE_WITHIN_UPACKAGE") +#undef DECLARE_WITHIN_UPACKAGE + +#pragma push_macro("IMPLEMENT_CLASS") +#undef IMPLEMENT_CLASS + +#pragma push_macro("IMPLEMENT_INTRINSIC_CLASS") +#undef IMPLEMENT_INTRINSIC_CLASS + +#pragma push_macro("IMPLEMENT_CORE_INTRINSIC_CLASS") +#undef IMPLEMENT_CORE_INTRINSIC_CLASS + +#pragma push_macro("IMPLEMENT_DYNAMIC_CLASS") +#undef IMPLEMENT_DYNAMIC_CLASS + +#pragma push_macro("SCOPED_SCRIPT_NATIVE_TIMER") +#undef SCOPED_SCRIPT_NATIVE_TIMER + +#pragma push_macro("ZERO_INIT") +#undef ZERO_INIT + +#pragma push_macro("PARAM_PASSED_BY_VAL") +#undef PARAM_PASSED_BY_VAL + +#pragma push_macro("PARAM_PASSED_BY_VAL_ZEROED") +#undef PARAM_PASSED_BY_VAL_ZEROED + +#pragma push_macro("PARAM_PASSED_BY_REF") +#undef PARAM_PASSED_BY_REF + +#pragma push_macro("PARAM_PASSED_BY_REF_ZEROED") +#undef PARAM_PASSED_BY_REF_ZEROED + +#pragma push_macro("P_GET_PROPERTY") +#undef P_GET_PROPERTY + +#pragma push_macro("P_GET_PROPERTY_REF") +#undef P_GET_PROPERTY_REF + +#pragma push_macro("P_GET_UBOOL") +#undef P_GET_UBOOL + +#pragma push_macro("P_GET_UBOOL8") +#undef P_GET_UBOOL8 + +#pragma push_macro("P_GET_UBOOL16") +#undef P_GET_UBOOL16 + +#pragma push_macro("P_GET_UBOOL32") +#undef P_GET_UBOOL32 + +#pragma push_macro("P_GET_UBOOL64") +#undef P_GET_UBOOL64 + +#pragma push_macro("P_GET_UBOOL_REF") +#undef P_GET_UBOOL_REF + +#pragma push_macro("P_GET_STRUCT") +#undef P_GET_STRUCT + +#pragma push_macro("P_GET_STRUCT_REF") +#undef P_GET_STRUCT_REF + +#pragma push_macro("P_GET_OBJECT") +#undef P_GET_OBJECT + +#pragma push_macro("P_GET_OBJECT_REF") +#undef P_GET_OBJECT_REF + +#pragma push_macro("P_GET_OBJECT_NO_PTR") +#undef P_GET_OBJECT_NO_PTR + +#pragma push_macro("P_GET_OBJECT_REF_NO_PTR") +#undef P_GET_OBJECT_REF_NO_PTR + +#pragma push_macro("P_GET_TARRAY") +#undef P_GET_TARRAY + +#pragma push_macro("P_GET_TARRAY_REF") +#undef P_GET_TARRAY_REF + +#pragma push_macro("P_GET_TMAP") +#undef P_GET_TMAP + +#pragma push_macro("P_GET_TMAP_REF") +#undef P_GET_TMAP_REF + +#pragma push_macro("P_GET_TSET") +#undef P_GET_TSET + +#pragma push_macro("P_GET_TSET_REF") +#undef P_GET_TSET_REF + +#pragma push_macro("P_GET_TINTERFACE") +#undef P_GET_TINTERFACE + +#pragma push_macro("P_GET_TINTERFACE_REF") +#undef P_GET_TINTERFACE_REF + +#pragma push_macro("P_GET_SOFTOBJECT") +#undef P_GET_SOFTOBJECT + +#pragma push_macro("P_GET_SOFTOBJECT_REF") +#undef P_GET_SOFTOBJECT_REF + +#pragma push_macro("P_GET_SOFTCLASS") +#undef P_GET_SOFTCLASS + +#pragma push_macro("P_GET_SOFTCLASS_REF") +#undef P_GET_SOFTCLASS_REF + +#pragma push_macro("P_GET_ARRAY") +#undef P_GET_ARRAY + +#pragma push_macro("P_GET_ARRAY_REF") +#undef P_GET_ARRAY_REF + +#pragma push_macro("P_GET_ENUM") +#undef P_GET_ENUM + +#pragma push_macro("P_GET_ENUM_REF") +#undef P_GET_ENUM_REF + +#pragma push_macro("P_THIS_CAST") +#undef P_THIS_CAST + +#pragma push_macro("XFER") +#undef XFER + +#pragma push_macro("XFERNAME") +#undef XFERNAME + +#pragma push_macro("XFERPTR") +#undef XFERPTR + +#pragma push_macro("XFER_OBJECT_POINTER") +#undef XFER_OBJECT_POINTER + +#pragma push_macro("FUNC_DECLARE_DYNAMIC_MULTICAST_SPARSE_DELEGATE") +#undef FUNC_DECLARE_DYNAMIC_MULTICAST_SPARSE_DELEGATE + +#pragma push_macro("DECLARE_DYNAMIC_MULTICAST_SPARSE_DELEGATE") +#undef DECLARE_DYNAMIC_MULTICAST_SPARSE_DELEGATE + +#pragma push_macro("DECLARE_DYNAMIC_MULTICAST_SPARSE_DELEGATE_OneParam") +#undef DECLARE_DYNAMIC_MULTICAST_SPARSE_DELEGATE_OneParam + +#pragma push_macro("DECLARE_DYNAMIC_MULTICAST_SPARSE_DELEGATE_TwoParams") +#undef DECLARE_DYNAMIC_MULTICAST_SPARSE_DELEGATE_TwoParams + +#pragma push_macro("DECLARE_DYNAMIC_MULTICAST_SPARSE_DELEGATE_ThreeParams") +#undef DECLARE_DYNAMIC_MULTICAST_SPARSE_DELEGATE_ThreeParams + +#pragma push_macro("DECLARE_DYNAMIC_MULTICAST_SPARSE_DELEGATE_FourParams") +#undef DECLARE_DYNAMIC_MULTICAST_SPARSE_DELEGATE_FourParams + +#pragma push_macro("DECLARE_DYNAMIC_MULTICAST_SPARSE_DELEGATE_FiveParams") +#undef DECLARE_DYNAMIC_MULTICAST_SPARSE_DELEGATE_FiveParams + +#pragma push_macro("DECLARE_DYNAMIC_MULTICAST_SPARSE_DELEGATE_SixParams") +#undef DECLARE_DYNAMIC_MULTICAST_SPARSE_DELEGATE_SixParams + +#pragma push_macro("DECLARE_DYNAMIC_MULTICAST_SPARSE_DELEGATE_SevenParams") +#undef DECLARE_DYNAMIC_MULTICAST_SPARSE_DELEGATE_SevenParams + +#pragma push_macro("DECLARE_DYNAMIC_MULTICAST_SPARSE_DELEGATE_EightParams") +#undef DECLARE_DYNAMIC_MULTICAST_SPARSE_DELEGATE_EightParams + +#pragma push_macro("DECLARE_DYNAMIC_MULTICAST_SPARSE_DELEGATE_NineParams") +#undef DECLARE_DYNAMIC_MULTICAST_SPARSE_DELEGATE_NineParams + +#pragma push_macro("CPP_ARRAY_DIM") +#undef CPP_ARRAY_DIM + +#pragma push_macro("SCOPE_CYCLE_UOBJECT") +#undef SCOPE_CYCLE_UOBJECT + +#pragma push_macro("UE_ASSET_LOG") +#undef UE_ASSET_LOG + +#pragma push_macro("METADATA_PARAMS") +#undef METADATA_PARAMS + +#pragma push_macro("IF_WITH_EDITOR") +#undef IF_WITH_EDITOR + +#pragma push_macro("IF_WITH_EDITORONLY_DATA") +#undef IF_WITH_EDITORONLY_DATA + +#pragma push_macro("INCREASE_ALLOC_COUNTER") +#undef INCREASE_ALLOC_COUNTER + +#pragma push_macro("DECREASE_ALLOC_COUNTER") +#undef DECREASE_ALLOC_COUNTER + +#pragma push_macro("ContextRedirect") +#undef ContextRedirect + +#pragma push_macro("ContextGPU0") +#undef ContextGPU0 + +#pragma push_macro("DECLARE_ISBOUNDSHADER") +#undef DECLARE_ISBOUNDSHADER + +#pragma push_macro("VALIDATE_BOUND_SHADER") +#undef VALIDATE_BOUND_SHADER + +#pragma push_macro("COPY_SHADER") +#undef COPY_SHADER + +#pragma push_macro("EXT_SHADER") +#undef EXT_SHADER + +#pragma push_macro("PSO_IF_NOT_EQUAL_RETURN_FALSE") +#undef PSO_IF_NOT_EQUAL_RETURN_FALSE + +#pragma push_macro("PSO_IF_MEMCMP_FAILS_RETURN_FALSE") +#undef PSO_IF_MEMCMP_FAILS_RETURN_FALSE + +#pragma push_macro("PSO_IF_STRING_COMPARE_FAILS_RETURN_FALSE") +#undef PSO_IF_STRING_COMPARE_FAILS_RETURN_FALSE + +#pragma push_macro("DEBUG_EXECUTE_COMMAND_LIST") +#undef DEBUG_EXECUTE_COMMAND_LIST + +#pragma push_macro("DEBUG_EXECUTE_COMMAND_CONTEXT") +#undef DEBUG_EXECUTE_COMMAND_CONTEXT + +#pragma push_macro("DEBUG_RHI_EXECUTE_COMMAND_LIST") +#undef DEBUG_RHI_EXECUTE_COMMAND_LIST + +#pragma push_macro("EMBED_DXGI_ERROR_LIST") +#undef EMBED_DXGI_ERROR_LIST + +#pragma push_macro("CONDITIONAL_SET_SRVS") +#undef CONDITIONAL_SET_SRVS + +#pragma push_macro("CONDITIONAL_SET_CBVS") +#undef CONDITIONAL_SET_CBVS + +#pragma push_macro("CONDITIONAL_SET_SAMPLERS") +#undef CONDITIONAL_SET_SAMPLERS + +#pragma push_macro("DECLARE_SHADER_TRAITS") +#undef DECLARE_SHADER_TRAITS + +#pragma push_macro("D3DERR") +#undef D3DERR + +#pragma push_macro("MAKE_D3DHRESULT") +#undef MAKE_D3DHRESULT + +#pragma push_macro("D3DFORMATCASE") +#undef D3DFORMATCASE + +#pragma push_macro("MERGE_EXT") +#undef MERGE_EXT + +#pragma push_macro("CASE_ERROR_NAME") +#undef CASE_ERROR_NAME + +#pragma push_macro("VERIFYD3D12RESULT_LAMBDA") +#undef VERIFYD3D12RESULT_LAMBDA + +#pragma push_macro("VERIFYD3D12RESULT_EX") +#undef VERIFYD3D12RESULT_EX + +#pragma push_macro("VERIFYD3D12RESULT") +#undef VERIFYD3D12RESULT + +#pragma push_macro("VERIFYD3D12CREATETEXTURERESULT") +#undef VERIFYD3D12CREATETEXTURERESULT + +#pragma push_macro("checkComRefCount") +#undef checkComRefCount + +#pragma push_macro("UPDATE_BITFLAGS") +#undef UPDATE_BITFLAGS + +#pragma push_macro("DS_ELEMENT_TYPE") +#undef DS_ELEMENT_TYPE + +#pragma push_macro("SerialAny_Case") +#undef SerialAny_Case + +#pragma push_macro("DECLARE_SCOPE_HIERARCHICAL_COUNTER_ANIMNODE") +#undef DECLARE_SCOPE_HIERARCHICAL_COUNTER_ANIMNODE + +#pragma push_macro("GETCURVE_REPORTERROR") +#undef GETCURVE_REPORTERROR + +#pragma push_macro("GETCURVE_REPORTERROR_WITHPATHNAME") +#undef GETCURVE_REPORTERROR_WITHPATHNAME + +#pragma push_macro("GETROW_REPORTERROR") +#undef GETROW_REPORTERROR + +#pragma push_macro("GETROWOBJECT_REPORTERROR") +#undef GETROWOBJECT_REPORTERROR + +#pragma push_macro("DECLARE_SCOPED_DELEGATE") +#undef DECLARE_SCOPED_DELEGATE + +#pragma push_macro("STREAMABLERENDERASSET_NODEFAULT") +#undef STREAMABLERENDERASSET_NODEFAULT + +#pragma push_macro("HIDE_ACTOR_TRANSFORM_FUNCTIONS") +#undef HIDE_ACTOR_TRANSFORM_FUNCTIONS + +#pragma push_macro("DEPRECATED_CHARACTER_MOVEMENT_RPC") +#undef DEPRECATED_CHARACTER_MOVEMENT_RPC + +#pragma push_macro("PARTICLE_PERF_STAT_INSTANCE_COUNT") +#undef PARTICLE_PERF_STAT_INSTANCE_COUNT + +#pragma push_macro("PARTICLE_PERF_STAT_CYCLES") +#undef PARTICLE_PERF_STAT_CYCLES + +#pragma push_macro("EFFECT_SETTINGS_NAME2") +#undef EFFECT_SETTINGS_NAME2 + +#pragma push_macro("EFFECT_SETTINGS_NAME1") +#undef EFFECT_SETTINGS_NAME1 + +#pragma push_macro("EFFECT_SETTINGS_NAME") +#undef EFFECT_SETTINGS_NAME + +#pragma push_macro("EFFECT_PRESET_NAME2") +#undef EFFECT_PRESET_NAME2 + +#pragma push_macro("EFFECT_PRESET_NAME1") +#undef EFFECT_PRESET_NAME1 + +#pragma push_macro("EFFECT_PRESET_NAME") +#undef EFFECT_PRESET_NAME + +#pragma push_macro("GET_EFFECT_SETTINGS") +#undef GET_EFFECT_SETTINGS + +#pragma push_macro("EFFECT_PRESET_METHODS") +#undef EFFECT_PRESET_METHODS + +#pragma push_macro("DECLARE_SOUNDNODE_ELEMENT") +#undef DECLARE_SOUNDNODE_ELEMENT + +#pragma push_macro("DECLARE_SOUNDNODE_ELEMENT_PTR") +#undef DECLARE_SOUNDNODE_ELEMENT_PTR + +#pragma push_macro("DEBUG_CALLSPACE") +#undef DEBUG_CALLSPACE + +#pragma push_macro("UE_MAKEFOURCC") +#undef UE_MAKEFOURCC + +#pragma push_macro("UE_mmioFOURCC") +#undef UE_mmioFOURCC + +#pragma push_macro("SAFE_TRACEINDEX_DECREASE") +#undef SAFE_TRACEINDEX_DECREASE + +#pragma push_macro("DATATABLE_CHANGE_SCOPE") +#undef DATATABLE_CHANGE_SCOPE + +#pragma push_macro("CURVETABLE_CHANGE_SCOPE") +#undef CURVETABLE_CHANGE_SCOPE + +#pragma push_macro("UE_DRAW_SERVER_DEBUG_ON_EACH_CLIENT") +#undef UE_DRAW_SERVER_DEBUG_ON_EACH_CLIENT + +#pragma push_macro("IMPLEMENT_GPUSKINNING_VERTEX_FACTORY_TYPE_INTERNAL") +#undef IMPLEMENT_GPUSKINNING_VERTEX_FACTORY_TYPE_INTERNAL + +#pragma push_macro("IMPLEMENT_GPUSKINNING_VERTEX_FACTORY_TYPE") +#undef IMPLEMENT_GPUSKINNING_VERTEX_FACTORY_TYPE + +#pragma push_macro("IMPLEMENT_GPUSKINNING_VERTEX_FACTORY_PARAMETER_TYPE") +#undef IMPLEMENT_GPUSKINNING_VERTEX_FACTORY_PARAMETER_TYPE + +#pragma push_macro("STRUCTTRACK_GETNUMKEYFRAMES") +#undef STRUCTTRACK_GETNUMKEYFRAMES + +#pragma push_macro("STRUCTTRACK_GETTIMERANGE") +#undef STRUCTTRACK_GETTIMERANGE + +#pragma push_macro("STRUCTTRACK_GETTRACKENDTIME") +#undef STRUCTTRACK_GETTRACKENDTIME + +#pragma push_macro("STRUCTTRACK_GETKEYFRAMETIME") +#undef STRUCTTRACK_GETKEYFRAMETIME + +#pragma push_macro("STRUCTTRACK_GETKEYFRAMEINDEX") +#undef STRUCTTRACK_GETKEYFRAMEINDEX + +#pragma push_macro("STRUCTTRACK_SETKEYFRAMETIME") +#undef STRUCTTRACK_SETKEYFRAMETIME + +#pragma push_macro("STRUCTTRACK_REMOVEKEYFRAME") +#undef STRUCTTRACK_REMOVEKEYFRAME + +#pragma push_macro("STRUCTTRACK_DUPLICATEKEYFRAME") +#undef STRUCTTRACK_DUPLICATEKEYFRAME + +#pragma push_macro("STRUCTTRACK_GETCLOSESTSNAPPOSITION") +#undef STRUCTTRACK_GETCLOSESTSNAPPOSITION + +#pragma push_macro("DEBUG_REMOTEFUNCTION") +#undef DEBUG_REMOTEFUNCTION + +#pragma push_macro("UpdatePerClientMinMaxAvg") +#undef UpdatePerClientMinMaxAvg + +#pragma push_macro("BUILD_NETEMULATION_CONSOLE_COMMAND") +#undef BUILD_NETEMULATION_CONSOLE_COMMAND + +#pragma push_macro("SCOPE_LOCK_REF") +#undef SCOPE_LOCK_REF + +#pragma push_macro("CHECK_REPL_EQUALITY") +#undef CHECK_REPL_EQUALITY + +#pragma push_macro("CHECK_REPL_VALIDITY") +#undef CHECK_REPL_VALIDITY + +#pragma push_macro("COMPOSE_NET_GUID") +#undef COMPOSE_NET_GUID + +#pragma push_macro("ALLOC_NEW_NET_GUID") +#undef ALLOC_NEW_NET_GUID + +#pragma push_macro("PolyCheck") +#undef PolyCheck + +#pragma push_macro("CHECK_VIRTUALTEXTURE_USAGE") +#undef CHECK_VIRTUALTEXTURE_USAGE + +#pragma push_macro("WarnInvalidPhysicsOperations") +#undef WarnInvalidPhysicsOperations + +#pragma push_macro("REPDATATYPE_SPECIALIZATION") +#undef REPDATATYPE_SPECIALIZATION + +#pragma push_macro("LERP_PP") +#undef LERP_PP + +#pragma push_macro("IF_PP") +#undef IF_PP + +#pragma push_macro("IMPLEMENT_PLATFORM_INTERFACE_SINGLETON") +#undef IMPLEMENT_PLATFORM_INTERFACE_SINGLETON + +#pragma push_macro("SHOWFLAG_ALWAYS_ACCESSIBLE") +#undef SHOWFLAG_ALWAYS_ACCESSIBLE + +#pragma push_macro("SHOWFLAG_FIXED_IN_SHIPPING") +#undef SHOWFLAG_FIXED_IN_SHIPPING + +#pragma push_macro("DISABLE_ENGINE_SHOWFLAG") +#undef DISABLE_ENGINE_SHOWFLAG + +#pragma push_macro("DEBUGBROKENCONSTRAINTUPDATE") +#undef DEBUGBROKENCONSTRAINTUPDATE + +#pragma push_macro("GENERATE_LOD_MODEL") +#undef GENERATE_LOD_MODEL + +#pragma push_macro("SERIALIZE_CURVE") +#undef SERIALIZE_CURVE + +#pragma push_macro("SERIALIZE_OPTION") +#undef SERIALIZE_OPTION + +#pragma push_macro("SKIP_OLD_OPTION") +#undef SKIP_OLD_OPTION + +#pragma push_macro("DECLARETEXTUREGROUPSTAT") +#undef DECLARETEXTUREGROUPSTAT + +#pragma push_macro("ASSIGNTEXTUREGROUPSTATNAME") +#undef ASSIGNTEXTUREGROUPSTATNAME + +#pragma push_macro("TEXT_TO_ENUM") +#undef TEXT_TO_ENUM + +#pragma push_macro("TEXT_TO_MIPGENSETTINGS") +#undef TEXT_TO_MIPGENSETTINGS + +#pragma push_macro("GROUPNAMES") +#undef GROUPNAMES + +#pragma push_macro("TIMER_TEST_TEXT") +#undef TIMER_TEST_TEXT + +#pragma push_macro("SCOPE_TIME_TO_VAR") +#undef SCOPE_TIME_TO_VAR + +#pragma push_macro("CALCULATE_WEIGHTING") +#undef CALCULATE_WEIGHTING + +#pragma push_macro("DO_ANIMSTAT_PROCESSING") +#undef DO_ANIMSTAT_PROCESSING + +#pragma push_macro("IS_VALID_COLLISIONCHANNEL") +#undef IS_VALID_COLLISIONCHANNEL + +#pragma push_macro("devCode") +#undef devCode + +#pragma push_macro("SKY_DECLARE_BLUEPRINT_SETFUNCTION") +#undef SKY_DECLARE_BLUEPRINT_SETFUNCTION + +#pragma push_macro("SKY_DECLARE_BLUEPRINT_SETFUNCTION_LINEARCOEFFICIENT") +#undef SKY_DECLARE_BLUEPRINT_SETFUNCTION_LINEARCOEFFICIENT + +#pragma push_macro("CLOUD_DECLARE_BLUEPRINT_SETFUNCTION") +#undef CLOUD_DECLARE_BLUEPRINT_SETFUNCTION + +#pragma push_macro("SETUPLODGROUP") +#undef SETUPLODGROUP + +#pragma push_macro("TEXT_TO_SHADINGMODEL") +#undef TEXT_TO_SHADINGMODEL + +#pragma push_macro("TEXT_TO_BLENDMODE") +#undef TEXT_TO_BLENDMODE + +#pragma push_macro("SWAP_REFERENCE_TO") +#undef SWAP_REFERENCE_TO + +#pragma push_macro("IF_INPUT_RETURN") +#undef IF_INPUT_RETURN + +#pragma push_macro("COMPILER_OR_LOG_ERROR") +#undef COMPILER_OR_LOG_ERROR + +#pragma push_macro("DECLARE_MATERIALUNIFORMEXPRESSION_TYPE") +#undef DECLARE_MATERIALUNIFORMEXPRESSION_TYPE + +#pragma push_macro("IMPLEMENT_MATERIALUNIFORMEXPRESSION_TYPE") +#undef IMPLEMENT_MATERIALUNIFORMEXPRESSION_TYPE + +#pragma push_macro("WORLD_TYPE_CASE") +#undef WORLD_TYPE_CASE + +#pragma push_macro("STARTQUERYTIMER") +#undef STARTQUERYTIMER + +#pragma push_macro("CAPTUREGEOMSWEEP") +#undef CAPTUREGEOMSWEEP + +#pragma push_macro("CAPTURERAYCAST") +#undef CAPTURERAYCAST + +#pragma push_macro("CAPTUREGEOMOVERLAP") +#undef CAPTUREGEOMOVERLAP + +#pragma push_macro("SET_DRIVE_PARAM") +#undef SET_DRIVE_PARAM + +#pragma push_macro("SUBSTEPPING_WARNING") +#undef SUBSTEPPING_WARNING + +#pragma push_macro("ALLOCATE_VERTEX_DATA_TEMPLATE") +#undef ALLOCATE_VERTEX_DATA_TEMPLATE + +#pragma push_macro("CHECK_SUCCESS") +#undef CHECK_SUCCESS + +#pragma push_macro("CHECK_FAIL") +#undef CHECK_FAIL + +#pragma push_macro("CHECK_NOT_NULL") +#undef CHECK_NOT_NULL + +#pragma push_macro("MAKE_565") +#undef MAKE_565 + +#pragma push_macro("MAKE_8888") +#undef MAKE_8888 + +#pragma push_macro("UNORM16") +#undef UNORM16 + +#pragma push_macro("UNORM16_SRGB") +#undef UNORM16_SRGB + +#pragma push_macro("AC_UnalignedSwap") +#undef AC_UnalignedSwap + +#pragma push_macro("ECC_TO_BITFIELD") +#undef ECC_TO_BITFIELD + +#pragma push_macro("CRC_TO_BITFIELD") +#undef CRC_TO_BITFIELD + +#pragma push_macro("SCENE_QUERY_STAT_ONLY") +#undef SCENE_QUERY_STAT_ONLY + +#pragma push_macro("SCENE_QUERY_STAT_NAME_ONLY") +#undef SCENE_QUERY_STAT_NAME_ONLY + +#pragma push_macro("SCENE_QUERY_STAT") +#undef SCENE_QUERY_STAT + +#pragma push_macro("MAKEFOURCC") +#undef MAKEFOURCC + +#pragma push_macro("DIST_GET_RANDOM_VALUE") +#undef DIST_GET_RANDOM_VALUE + +#pragma push_macro("DEFINE_GAME_DELEGATE") +#undef DEFINE_GAME_DELEGATE + +#pragma push_macro("DEFINE_GAME_DELEGATE_TYPED") +#undef DEFINE_GAME_DELEGATE_TYPED + +#pragma push_macro("SET_BONE_DATA") +#undef SET_BONE_DATA + +#pragma push_macro("DECLARE_HIT_PROXY_STATIC") +#undef DECLARE_HIT_PROXY_STATIC + +#pragma push_macro("DECLARE_HIT_PROXY") +#undef DECLARE_HIT_PROXY + +#pragma push_macro("IMPLEMENT_HIT_PROXY_BASE") +#undef IMPLEMENT_HIT_PROXY_BASE + +#pragma push_macro("IMPLEMENT_HIT_PROXY") +#undef IMPLEMENT_HIT_PROXY + +#pragma push_macro("EVAL_CURVE") +#undef EVAL_CURVE + +#pragma push_macro("FIND_POINT") +#undef FIND_POINT + +#pragma push_macro("IMPLEMENT_MATERIAL_SHADER_TYPE") +#undef IMPLEMENT_MATERIAL_SHADER_TYPE + +#pragma push_macro("TRACE_CLASS") +#undef TRACE_CLASS + +#pragma push_macro("TRACE_OBJECT") +#undef TRACE_OBJECT + +#pragma push_macro("TRACE_OBJECT_EVENT") +#undef TRACE_OBJECT_EVENT + +#pragma push_macro("UNCONDITIONAL_TRACE_OBJECT_EVENT") +#undef UNCONDITIONAL_TRACE_OBJECT_EVENT + +#pragma push_macro("TRACE_WORLD") +#undef TRACE_WORLD + +#pragma push_macro("PARTICLE_INSTANCE_PREFETCH") +#undef PARTICLE_INSTANCE_PREFETCH + +#pragma push_macro("DECLARE_PARTICLE") +#undef DECLARE_PARTICLE + +#pragma push_macro("DECLARE_PARTICLE_CONST") +#undef DECLARE_PARTICLE_CONST + +#pragma push_macro("DECLARE_PARTICLE_PTR") +#undef DECLARE_PARTICLE_PTR + +#pragma push_macro("PARTICLE_ELEMENT") +#undef PARTICLE_ELEMENT + +#pragma push_macro("TRAIL_EMITTER_CHECK_FLAG") +#undef TRAIL_EMITTER_CHECK_FLAG + +#pragma push_macro("TRAIL_EMITTER_SET_FLAG") +#undef TRAIL_EMITTER_SET_FLAG + +#pragma push_macro("TRAIL_EMITTER_GET_PREVNEXT") +#undef TRAIL_EMITTER_GET_PREVNEXT + +#pragma push_macro("TRAIL_EMITTER_SET_PREVNEXT") +#undef TRAIL_EMITTER_SET_PREVNEXT + +#pragma push_macro("TRAIL_EMITTER_IS_START") +#undef TRAIL_EMITTER_IS_START + +#pragma push_macro("TRAIL_EMITTER_SET_START") +#undef TRAIL_EMITTER_SET_START + +#pragma push_macro("TRAIL_EMITTER_IS_END") +#undef TRAIL_EMITTER_IS_END + +#pragma push_macro("TRAIL_EMITTER_SET_END") +#undef TRAIL_EMITTER_SET_END + +#pragma push_macro("TRAIL_EMITTER_IS_MIDDLE") +#undef TRAIL_EMITTER_IS_MIDDLE + +#pragma push_macro("TRAIL_EMITTER_SET_MIDDLE") +#undef TRAIL_EMITTER_SET_MIDDLE + +#pragma push_macro("TRAIL_EMITTER_IS_ONLY") +#undef TRAIL_EMITTER_IS_ONLY + +#pragma push_macro("TRAIL_EMITTER_SET_ONLY") +#undef TRAIL_EMITTER_SET_ONLY + +#pragma push_macro("TRAIL_EMITTER_IS_FORCEKILL") +#undef TRAIL_EMITTER_IS_FORCEKILL + +#pragma push_macro("TRAIL_EMITTER_SET_FORCEKILL") +#undef TRAIL_EMITTER_SET_FORCEKILL + +#pragma push_macro("TRAIL_EMITTER_IS_DEADTRAIL") +#undef TRAIL_EMITTER_IS_DEADTRAIL + +#pragma push_macro("TRAIL_EMITTER_SET_DEADTRAIL") +#undef TRAIL_EMITTER_SET_DEADTRAIL + +#pragma push_macro("TRAIL_EMITTER_IS_HEAD") +#undef TRAIL_EMITTER_IS_HEAD + +#pragma push_macro("TRAIL_EMITTER_IS_HEADONLY") +#undef TRAIL_EMITTER_IS_HEADONLY + +#pragma push_macro("TRAIL_EMITTER_GET_PREV") +#undef TRAIL_EMITTER_GET_PREV + +#pragma push_macro("TRAIL_EMITTER_SET_PREV") +#undef TRAIL_EMITTER_SET_PREV + +#pragma push_macro("TRAIL_EMITTER_GET_NEXT") +#undef TRAIL_EMITTER_GET_NEXT + +#pragma push_macro("TRAIL_EMITTER_SET_NEXT") +#undef TRAIL_EMITTER_SET_NEXT + +#pragma push_macro("BEAM2_TYPEDATA_SETFREQUENCY") +#undef BEAM2_TYPEDATA_SETFREQUENCY + +#pragma push_macro("SRA_UPDATE_CALLBACK") +#undef SRA_UPDATE_CALLBACK + +#pragma push_macro("VIEW_UNIFORM_BUFFER_MEMBER") +#undef VIEW_UNIFORM_BUFFER_MEMBER + +#pragma push_macro("VIEW_UNIFORM_BUFFER_MEMBER_EX") +#undef VIEW_UNIFORM_BUFFER_MEMBER_EX + +#pragma push_macro("VIEW_UNIFORM_BUFFER_MEMBER_ARRAY") +#undef VIEW_UNIFORM_BUFFER_MEMBER_ARRAY + +#pragma push_macro("STEREO_LAYER_SHAPE_BOILERPLATE") +#undef STEREO_LAYER_SHAPE_BOILERPLATE + +#pragma push_macro("CAN_TRACE_OBJECT") +#undef CAN_TRACE_OBJECT + +#pragma push_macro("CANNOT_TRACE_OBJECT") +#undef CANNOT_TRACE_OBJECT + +#pragma push_macro("MARK_OBJECT_TRACEABLE") +#undef MARK_OBJECT_TRACEABLE + +#pragma push_macro("SET_OBJECT_TRACEABLE") +#undef SET_OBJECT_TRACEABLE + +#pragma push_macro("GET_TRACE_OBJECT_VALUE") +#undef GET_TRACE_OBJECT_VALUE + +#pragma push_macro("DISABLE_ENGINE_ACTOR_TRACE_FILTERING") +#undef DISABLE_ENGINE_ACTOR_TRACE_FILTERING + +#pragma push_macro("DISABLE_ENGINE_WORLD_TRACE_FILTERING") +#undef DISABLE_ENGINE_WORLD_TRACE_FILTERING + +#pragma push_macro("ANIM_MT_SCOPE_CYCLE_COUNTER") +#undef ANIM_MT_SCOPE_CYCLE_COUNTER + +#pragma push_macro("TRACE_ANIM_TICK_RECORD") +#undef TRACE_ANIM_TICK_RECORD + +#pragma push_macro("TRACE_SKELETAL_MESH") +#undef TRACE_SKELETAL_MESH + +#pragma push_macro("TRACE_SKELETAL_MESH_COMPONENT") +#undef TRACE_SKELETAL_MESH_COMPONENT + +#pragma push_macro("TRACE_SKELETALMESH_FRAME") +#undef TRACE_SKELETALMESH_FRAME + +#pragma push_macro("TRACE_SCOPED_ANIM_GRAPH") +#undef TRACE_SCOPED_ANIM_GRAPH + +#pragma push_macro("TRACE_SCOPED_ANIM_NODE") +#undef TRACE_SCOPED_ANIM_NODE + +#pragma push_macro("TRACE_ANIM_NODE_VALUE") +#undef TRACE_ANIM_NODE_VALUE + +#pragma push_macro("TRACE_ANIM_SEQUENCE_PLAYER") +#undef TRACE_ANIM_SEQUENCE_PLAYER + +#pragma push_macro("TRACE_ANIM_STATE_MACHINE_STATE") +#undef TRACE_ANIM_STATE_MACHINE_STATE + +#pragma push_macro("TRACE_ANIM_NOTIFY") +#undef TRACE_ANIM_NOTIFY + +#pragma push_macro("TRACE_ANIM_SYNC_MARKER") +#undef TRACE_ANIM_SYNC_MARKER + +#pragma push_macro("TRACE_ANIM_MONTAGE") +#undef TRACE_ANIM_MONTAGE + +#pragma push_macro("DEFINE_CONTROL_CHANNEL_MESSAGE") +#undef DEFINE_CONTROL_CHANNEL_MESSAGE + +#pragma push_macro("DEFINE_CONTROL_CHANNEL_MESSAGE_ZEROPARAM") +#undef DEFINE_CONTROL_CHANNEL_MESSAGE_ZEROPARAM + +#pragma push_macro("DEFINE_CONTROL_CHANNEL_MESSAGE_ONEPARAM") +#undef DEFINE_CONTROL_CHANNEL_MESSAGE_ONEPARAM + +#pragma push_macro("DEFINE_CONTROL_CHANNEL_MESSAGE_TWOPARAM") +#undef DEFINE_CONTROL_CHANNEL_MESSAGE_TWOPARAM + +#pragma push_macro("DEFINE_CONTROL_CHANNEL_MESSAGE_THREEPARAM") +#undef DEFINE_CONTROL_CHANNEL_MESSAGE_THREEPARAM + +#pragma push_macro("DEFINE_CONTROL_CHANNEL_MESSAGE_FOURPARAM") +#undef DEFINE_CONTROL_CHANNEL_MESSAGE_FOURPARAM + +#pragma push_macro("DEFINE_CONTROL_CHANNEL_MESSAGE_FIVEPARAM") +#undef DEFINE_CONTROL_CHANNEL_MESSAGE_FIVEPARAM + +#pragma push_macro("DEFINE_CONTROL_CHANNEL_MESSAGE_SIXPARAM") +#undef DEFINE_CONTROL_CHANNEL_MESSAGE_SIXPARAM + +#pragma push_macro("DEFINE_CONTROL_CHANNEL_MESSAGE_SEVENPARAM") +#undef DEFINE_CONTROL_CHANNEL_MESSAGE_SEVENPARAM + +#pragma push_macro("DEFINE_CONTROL_CHANNEL_MESSAGE_EIGHTPARAM") +#undef DEFINE_CONTROL_CHANNEL_MESSAGE_EIGHTPARAM + +#pragma push_macro("IMPLEMENT_CONTROL_CHANNEL_MESSAGE") +#undef IMPLEMENT_CONTROL_CHANNEL_MESSAGE + +#pragma push_macro("UE_LOG_PACKET_NOTIFY_WARNING") +#undef UE_LOG_PACKET_NOTIFY_WARNING + +#pragma push_macro("GRANULAR_NETWORK_MEMORY_TRACKING_INIT") +#undef GRANULAR_NETWORK_MEMORY_TRACKING_INIT + +#pragma push_macro("GRANULAR_NETWORK_MEMORY_TRACKING_TRACK") +#undef GRANULAR_NETWORK_MEMORY_TRACKING_TRACK + +#pragma push_macro("GRANULAR_NETWORK_MEMORY_TRACKING_CUSTOM_WORK") +#undef GRANULAR_NETWORK_MEMORY_TRACKING_CUSTOM_WORK + +#pragma push_macro("NETWORK_PROFILER") +#undef NETWORK_PROFILER + +#pragma push_macro("DOREPLIFETIME_WITH_PARAMS_FAST") +#undef DOREPLIFETIME_WITH_PARAMS_FAST + +#pragma push_macro("DOREPLIFETIME_WITH_PARAMS_FAST_STATIC_ARRAY") +#undef DOREPLIFETIME_WITH_PARAMS_FAST_STATIC_ARRAY + +#pragma push_macro("DOREPLIFETIME_WITH_PARAMS") +#undef DOREPLIFETIME_WITH_PARAMS + +#pragma push_macro("DOREPLIFETIME") +#undef DOREPLIFETIME + +#pragma push_macro("DOREPLIFETIME_DIFFNAMES") +#undef DOREPLIFETIME_DIFFNAMES + +#pragma push_macro("DOREPLIFETIME_CONDITION") +#undef DOREPLIFETIME_CONDITION + +#pragma push_macro("DOREPLIFETIME_CONDITION_NOTIFY") +#undef DOREPLIFETIME_CONDITION_NOTIFY + +#pragma push_macro("DOREPLIFETIME_ACTIVE_OVERRIDE_FAST") +#undef DOREPLIFETIME_ACTIVE_OVERRIDE_FAST + +#pragma push_macro("DOREPLIFETIME_ACTIVE_OVERRIDE_FAST_STATIC_ARRAY") +#undef DOREPLIFETIME_ACTIVE_OVERRIDE_FAST_STATIC_ARRAY + +#pragma push_macro("DOREPLIFETIME_ACTIVE_OVERRIDE") +#undef DOREPLIFETIME_ACTIVE_OVERRIDE + +#pragma push_macro("DOREPLIFETIME_CHANGE_CONDITION") +#undef DOREPLIFETIME_CHANGE_CONDITION + +#pragma push_macro("DISABLE_REPLICATED_PROPERTY") +#undef DISABLE_REPLICATED_PROPERTY + +#pragma push_macro("DISABLE_REPLICATED_PRIVATE_PROPERTY") +#undef DISABLE_REPLICATED_PRIVATE_PROPERTY + +#pragma push_macro("DISABLE_REPLICATED_PROPERTY_FAST") +#undef DISABLE_REPLICATED_PROPERTY_FAST + +#pragma push_macro("DISABLE_REPLICATED_PROPERTY_FAST_STATIC_ARRAY") +#undef DISABLE_REPLICATED_PROPERTY_FAST_STATIC_ARRAY + +#pragma push_macro("DISABLE_ALL_CLASS_REPLICATED_PROPERTIES") +#undef DISABLE_ALL_CLASS_REPLICATED_PROPERTIES + +#pragma push_macro("DISABLE_ALL_CLASS_REPLICATED_PROPERTIES_FAST") +#undef DISABLE_ALL_CLASS_REPLICATED_PROPERTIES_FAST + +#pragma push_macro("RESET_REPLIFETIME_CONDITION") +#undef RESET_REPLIFETIME_CONDITION + +#pragma push_macro("RESET_REPLIFETIME") +#undef RESET_REPLIFETIME + +#pragma push_macro("RESET_REPLIFETIME_CONDITION_FAST") +#undef RESET_REPLIFETIME_CONDITION_FAST + +#pragma push_macro("RESET_REPLIFETIME_CONDITION_FAST_STATIC_ARRAY") +#undef RESET_REPLIFETIME_CONDITION_FAST_STATIC_ARRAY + +#pragma push_macro("RESET_REPLIFETIME_FAST") +#undef RESET_REPLIFETIME_FAST + +#pragma push_macro("RESET_REPLIFETIME_FAST_STATIC_ARRAY") +#undef RESET_REPLIFETIME_FAST_STATIC_ARRAY + +#pragma push_macro("RPC_VALIDATE") +#undef RPC_VALIDATE + +#pragma push_macro("REDIRECT_TO_VLOG") +#undef REDIRECT_TO_VLOG + +#pragma push_macro("REDIRECT_OBJECT_TO_VLOG") +#undef REDIRECT_OBJECT_TO_VLOG + +#pragma push_macro("CONNECT_WITH_VLOG") +#undef CONNECT_WITH_VLOG + +#pragma push_macro("CONNECT_OBJECT_WITH_VLOG") +#undef CONNECT_OBJECT_WITH_VLOG + +#pragma push_macro("UE_VLOG") +#undef UE_VLOG + +#pragma push_macro("UE_CVLOG") +#undef UE_CVLOG + +#pragma push_macro("UE_VLOG_UELOG") +#undef UE_VLOG_UELOG + +#pragma push_macro("UE_CVLOG_UELOG") +#undef UE_CVLOG_UELOG + +#pragma push_macro("UE_VLOG_SEGMENT") +#undef UE_VLOG_SEGMENT + +#pragma push_macro("UE_CVLOG_SEGMENT") +#undef UE_CVLOG_SEGMENT + +#pragma push_macro("UE_VLOG_SEGMENT_THICK") +#undef UE_VLOG_SEGMENT_THICK + +#pragma push_macro("UE_CVLOG_SEGMENT_THICK") +#undef UE_CVLOG_SEGMENT_THICK + +#pragma push_macro("UE_VLOG_LOCATION") +#undef UE_VLOG_LOCATION + +#pragma push_macro("UE_CVLOG_LOCATION") +#undef UE_CVLOG_LOCATION + +#pragma push_macro("UE_VLOG_BOX") +#undef UE_VLOG_BOX + +#pragma push_macro("UE_CVLOG_BOX") +#undef UE_CVLOG_BOX + +#pragma push_macro("UE_VLOG_OBOX") +#undef UE_VLOG_OBOX + +#pragma push_macro("UE_CVLOG_OBOX") +#undef UE_CVLOG_OBOX + +#pragma push_macro("UE_VLOG_CONE") +#undef UE_VLOG_CONE + +#pragma push_macro("UE_CVLOG_CONE") +#undef UE_CVLOG_CONE + +#pragma push_macro("UE_VLOG_CYLINDER") +#undef UE_VLOG_CYLINDER + +#pragma push_macro("UE_CVLOG_CYLINDER") +#undef UE_CVLOG_CYLINDER + +#pragma push_macro("UE_VLOG_CAPSULE") +#undef UE_VLOG_CAPSULE + +#pragma push_macro("UE_CVLOG_CAPSULE") +#undef UE_CVLOG_CAPSULE + +#pragma push_macro("UE_VLOG_HISTOGRAM") +#undef UE_VLOG_HISTOGRAM + +#pragma push_macro("UE_CVLOG_HISTOGRAM") +#undef UE_CVLOG_HISTOGRAM + +#pragma push_macro("UE_VLOG_PULLEDCONVEX") +#undef UE_VLOG_PULLEDCONVEX + +#pragma push_macro("UE_CVLOG_PULLEDCONVEX") +#undef UE_CVLOG_PULLEDCONVEX + +#pragma push_macro("UE_VLOG_MESH") +#undef UE_VLOG_MESH + +#pragma push_macro("UE_CVLOG_MESH") +#undef UE_CVLOG_MESH + +#pragma push_macro("UE_VLOG_CONVEXPOLY") +#undef UE_VLOG_CONVEXPOLY + +#pragma push_macro("UE_CVLOG_CONVEXPOLY") +#undef UE_CVLOG_CONVEXPOLY + +#pragma push_macro("UE_VLOG_ARROW") +#undef UE_VLOG_ARROW + +#pragma push_macro("UE_CVLOG_ARROW") +#undef UE_CVLOG_ARROW + +#pragma push_macro("DECLARE_VLOG_EVENT") +#undef DECLARE_VLOG_EVENT + +#pragma push_macro("DEFINE_VLOG_EVENT") +#undef DEFINE_VLOG_EVENT + +#pragma push_macro("UE_VLOG_EVENTS") +#undef UE_VLOG_EVENTS + +#pragma push_macro("UE_CVLOG_EVENTS") +#undef UE_CVLOG_EVENTS + +#pragma push_macro("UE_VLOG_EVENT_WITH_DATA") +#undef UE_VLOG_EVENT_WITH_DATA + +#pragma push_macro("UE_CVLOG_EVENT_WITH_DATA") +#undef UE_CVLOG_EVENT_WITH_DATA + +#pragma push_macro("UE_IFVLOG") +#undef UE_IFVLOG + +#pragma push_macro("TEXT_CONDITION") +#undef TEXT_CONDITION + +#pragma push_macro("COLLAPSED_LOGF") +#undef COLLAPSED_LOGF + +#pragma push_macro("DEFINE_ENUM_TO_STRING") +#undef DEFINE_ENUM_TO_STRING + +#pragma push_macro("DECLARE_ENUM_TO_STRING") +#undef DECLARE_ENUM_TO_STRING + +#pragma push_macro("EVOLUTION_TRAIT") +#undef EVOLUTION_TRAIT + +#pragma push_macro("SCOPE_CYCLE_COUNTER_GJK") +#undef SCOPE_CYCLE_COUNTER_GJK + +#pragma push_macro("MAX_CLAMP") +#undef MAX_CLAMP + +#pragma push_macro("MIN_CLAMP") +#undef MIN_CLAMP + +#pragma push_macro("RANGE_CLAMP") +#undef RANGE_CLAMP + +#pragma push_macro("CHAOS_CHECK") +#undef CHAOS_CHECK + +#pragma push_macro("CHAOS_ENSURE") +#undef CHAOS_ENSURE + +#pragma push_macro("CHAOS_ENSURE_MSG") +#undef CHAOS_ENSURE_MSG + +#pragma push_macro("CHAOS_LOG") +#undef CHAOS_LOG + +#pragma push_macro("CHAOS_CLOG") +#undef CHAOS_CLOG + +#pragma push_macro("CHAOS_PERF_TEST") +#undef CHAOS_PERF_TEST + +#pragma push_macro("CHAOS_SCOPED_TIMER") +#undef CHAOS_SCOPED_TIMER + +#pragma push_macro("PARTICLE_PROPERTY") +#undef PARTICLE_PROPERTY + +#pragma push_macro("PROPERTY_TYPE") +#undef PROPERTY_TYPE + +#pragma push_macro("SHAPE_PROPERTY") +#undef SHAPE_PROPERTY + +#pragma push_macro("PARTICLE_PROPERTY_CHECKED") +#undef PARTICLE_PROPERTY_CHECKED + +#pragma push_macro("CONSTRAINT_JOINT_PROPERPETY_IMPL") +#undef CONSTRAINT_JOINT_PROPERPETY_IMPL + +#pragma push_macro("SCOPE_CYCLE_COUNTER_NAROWPHASE") +#undef SCOPE_CYCLE_COUNTER_NAROWPHASE + +#pragma push_macro("CHAOS_COLLISION_STAT") +#undef CHAOS_COLLISION_STAT + +#pragma push_macro("CHAOS_COLLISION_STAT_DISABLED") +#undef CHAOS_COLLISION_STAT_DISABLED + +#pragma push_macro("MANAGED_ARRAY_TYPE") +#undef MANAGED_ARRAY_TYPE + +#pragma push_macro("COPY_ON_WRITE_ATTRIBUTE") +#undef COPY_ON_WRITE_ATTRIBUTE + +#pragma push_macro("SCOPE_LOG_GAMEPLAYTAGS") +#undef SCOPE_LOG_GAMEPLAYTAGS + +#pragma push_macro("PARSE_FLOAT") +#undef PARSE_FLOAT + +#pragma push_macro("PARSE_INT") +#undef PARSE_INT + +#pragma push_macro("ADDKEYMAP") +#undef ADDKEYMAP + +#pragma push_macro("MAP_OEM_VK_TO_SCAN") +#undef MAP_OEM_VK_TO_SCAN + +#pragma push_macro("JSON_SERIALIZE") +#undef JSON_SERIALIZE + +#pragma push_macro("JSON_SERIALIZE_ARRAY") +#undef JSON_SERIALIZE_ARRAY + +#pragma push_macro("JSON_SERIALIZE_MAP") +#undef JSON_SERIALIZE_MAP + +#pragma push_macro("JSON_SERIALIZE_SIMPLECOPY") +#undef JSON_SERIALIZE_SIMPLECOPY + +#pragma push_macro("JSON_SERIALIZE_MAP_SAFE") +#undef JSON_SERIALIZE_MAP_SAFE + +#pragma push_macro("JSON_SERIALIZE_SERIALIZABLE") +#undef JSON_SERIALIZE_SERIALIZABLE + +#pragma push_macro("JSON_SERIALIZE_RAW_JSON_STRING") +#undef JSON_SERIALIZE_RAW_JSON_STRING + +#pragma push_macro("JSON_SERIALIZE_ARRAY_SERIALIZABLE") +#undef JSON_SERIALIZE_ARRAY_SERIALIZABLE + +#pragma push_macro("JSON_SERIALIZE_MAP_SERIALIZABLE") +#undef JSON_SERIALIZE_MAP_SERIALIZABLE + +#pragma push_macro("JSON_SERIALIZE_OBJECT_SERIALIZABLE") +#undef JSON_SERIALIZE_OBJECT_SERIALIZABLE + +#pragma push_macro("JSON_SERIALIZE_DATETIME_UNIX_TIMESTAMP") +#undef JSON_SERIALIZE_DATETIME_UNIX_TIMESTAMP + +#pragma push_macro("JSON_SERIALIZE_DATETIME_UNIX_TIMESTAMP_MILLISECONDS") +#undef JSON_SERIALIZE_DATETIME_UNIX_TIMESTAMP_MILLISECONDS + +#pragma push_macro("JSON_SERIALIZE_ENUM") +#undef JSON_SERIALIZE_ENUM + +#pragma push_macro("HEIGHTDATA") +#undef HEIGHTDATA + +#pragma push_macro("CHECK_JNI_METHOD") +#undef CHECK_JNI_METHOD + +#pragma push_macro("VERSION_TEXT") +#undef VERSION_TEXT + +#pragma push_macro("VERSION_STRINGIFY_2") +#undef VERSION_STRINGIFY_2 + +#pragma push_macro("VERSION_STRINGIFY") +#undef VERSION_STRINGIFY + +#pragma push_macro("SAFE_CA_CALL") +#undef SAFE_CA_CALL + +#pragma push_macro("CORE_AUDIO_ERR") +#undef CORE_AUDIO_ERR + +#pragma push_macro("NEW_GLOBAL_PROPERTY") +#undef NEW_GLOBAL_PROPERTY + +#pragma push_macro("NEW_OUTPUT_PROPERTY") +#undef NEW_OUTPUT_PROPERTY + +#pragma push_macro("DECLARE_RPC") +#undef DECLARE_RPC + +#pragma push_macro("MOVIESCENE_DETAILED_SCOPE_CYCLE_COUNTER") +#undef MOVIESCENE_DETAILED_SCOPE_CYCLE_COUNTER + +#pragma push_macro("UE_MOVIESCENE_TODO_IMPL") +#undef UE_MOVIESCENE_TODO_IMPL + +#pragma push_macro("UE_MOVIESCENE_TODO") +#undef UE_MOVIESCENE_TODO + +#pragma push_macro("INITIALIZE_NAVQUERY_SIMPLE") +#undef INITIALIZE_NAVQUERY_SIMPLE + +#pragma push_macro("INITIALIZE_NAVQUERY") +#undef INITIALIZE_NAVQUERY + +#pragma push_macro("INITIALIZE_NAVQUERY_WLINKFILTER") +#undef INITIALIZE_NAVQUERY_WLINKFILTER + +#pragma push_macro("TEXT_WEAKOBJ_NAME") +#undef TEXT_WEAKOBJ_NAME + +#pragma push_macro("REGISTER_NET_ANALYTICS") +#undef REGISTER_NET_ANALYTICS + +#pragma push_macro("CONDITIONAL_ON_PUSH_MODEL") +#undef CONDITIONAL_ON_PUSH_MODEL + +#pragma push_macro("IS_PUSH_MODEL_ENABLED") +#undef IS_PUSH_MODEL_ENABLED + +#pragma push_macro("PUSH_MAKE_BP_PROPERTIES_PUSH_MODEL") +#undef PUSH_MAKE_BP_PROPERTIES_PUSH_MODEL + +#pragma push_macro("GET_PROPERTY_REP_INDEX") +#undef GET_PROPERTY_REP_INDEX + +#pragma push_macro("GET_PROPERTY_REP_INDEX_STATIC_ARRAY_START") +#undef GET_PROPERTY_REP_INDEX_STATIC_ARRAY_START + +#pragma push_macro("GET_PROPERTY_REP_INDEX_STATIC_ARRAY_END") +#undef GET_PROPERTY_REP_INDEX_STATIC_ARRAY_END + +#pragma push_macro("GET_PROPERTY_REP_INDEX_STATIC_ARRAY_INDEX") +#undef GET_PROPERTY_REP_INDEX_STATIC_ARRAY_INDEX + +#pragma push_macro("IS_PROPERTY_REPLICATED") +#undef IS_PROPERTY_REPLICATED + +#pragma push_macro("CONDITIONAL_ON_OBJECT_NET_ID") +#undef CONDITIONAL_ON_OBJECT_NET_ID + +#pragma push_macro("CONDITIONAL_ON_OBJECT_NET_ID_DYNAMIC") +#undef CONDITIONAL_ON_OBJECT_NET_ID_DYNAMIC + +#pragma push_macro("CONDITIONAL_ON_REP_INDEX_AND_OBJECT_NET_ID") +#undef CONDITIONAL_ON_REP_INDEX_AND_OBJECT_NET_ID + +#pragma push_macro("MARK_PROPERTY_DIRTY_UNSAFE") +#undef MARK_PROPERTY_DIRTY_UNSAFE + +#pragma push_macro("MARK_PROPERTY_DIRTY") +#undef MARK_PROPERTY_DIRTY + +#pragma push_macro("MARK_PROPERTY_DIRTY_STATIC_ARRAY_INDEX") +#undef MARK_PROPERTY_DIRTY_STATIC_ARRAY_INDEX + +#pragma push_macro("MARK_PROPERTY_DIRTY_STATIC_ARRAY") +#undef MARK_PROPERTY_DIRTY_STATIC_ARRAY + +#pragma push_macro("MARK_PROPERTY_DIRTY_FROM_NAME") +#undef MARK_PROPERTY_DIRTY_FROM_NAME + +#pragma push_macro("MARK_PROPERTY_DIRTY_FROM_NAME_STATIC_ARRAY_INDEX") +#undef MARK_PROPERTY_DIRTY_FROM_NAME_STATIC_ARRAY_INDEX + +#pragma push_macro("MARK_PROPERTY_DIRTY_FROM_NAME_STATIC_ARRAY") +#undef MARK_PROPERTY_DIRTY_FROM_NAME_STATIC_ARRAY + +#pragma push_macro("GET_PROPERTY_REP_INDEX_STATIC_ARRAY") +#undef GET_PROPERTY_REP_INDEX_STATIC_ARRAY + +#pragma push_macro("REPLICATED_BASE_CLASS") +#undef REPLICATED_BASE_CLASS + +#pragma push_macro("UE_NET_TRACE_CREATE_COLLECTOR") +#undef UE_NET_TRACE_CREATE_COLLECTOR + +#pragma push_macro("UE_NET_TRACE_DESTROY_COLLECTOR") +#undef UE_NET_TRACE_DESTROY_COLLECTOR + +#pragma push_macro("UE_NET_TRACE_SCOPE") +#undef UE_NET_TRACE_SCOPE + +#pragma push_macro("UE_NET_TRACE_OBJECT_SCOPE") +#undef UE_NET_TRACE_OBJECT_SCOPE + +#pragma push_macro("UE_NET_TRACE_DYNAMIC_NAME_SCOPE") +#undef UE_NET_TRACE_DYNAMIC_NAME_SCOPE + +#pragma push_macro("UE_NET_TRACE_NAMED_SCOPE") +#undef UE_NET_TRACE_NAMED_SCOPE + +#pragma push_macro("UE_NET_TRACE_NAMED_OBJECT_SCOPE") +#undef UE_NET_TRACE_NAMED_OBJECT_SCOPE + +#pragma push_macro("UE_NET_TRACE_NAMED_DYNAMIC_NAME_SCOPE") +#undef UE_NET_TRACE_NAMED_DYNAMIC_NAME_SCOPE + +#pragma push_macro("UE_NET_TRACE_SET_SCOPE_NAME") +#undef UE_NET_TRACE_SET_SCOPE_NAME + +#pragma push_macro("UE_NET_TRACE_SET_SCOPE_OBJECTID") +#undef UE_NET_TRACE_SET_SCOPE_OBJECTID + +#pragma push_macro("UE_NET_TRACE_EXIT_NAMED_SCOPE") +#undef UE_NET_TRACE_EXIT_NAMED_SCOPE + +#pragma push_macro("UE_NET_TRACE_OFFSET_SCOPE") +#undef UE_NET_TRACE_OFFSET_SCOPE + +#pragma push_macro("UE_NET_TRACE") +#undef UE_NET_TRACE + +#pragma push_macro("UE_NET_TRACE_DYNAMIC_NAME") +#undef UE_NET_TRACE_DYNAMIC_NAME + +#pragma push_macro("UE_NET_TRACE_FLUSH_COLLECTOR") +#undef UE_NET_TRACE_FLUSH_COLLECTOR + +#pragma push_macro("UE_NET_TRACE_BEGIN_BUNCH") +#undef UE_NET_TRACE_BEGIN_BUNCH + +#pragma push_macro("UE_NET_TRACE_DISCARD_BUNCH") +#undef UE_NET_TRACE_DISCARD_BUNCH + +#pragma push_macro("UE_NET_TRACE_POP_SEND_BUNCH") +#undef UE_NET_TRACE_POP_SEND_BUNCH + +#pragma push_macro("UE_NET_TRACE_EVENTS") +#undef UE_NET_TRACE_EVENTS + +#pragma push_macro("UE_NET_TRACE_END_BUNCH") +#undef UE_NET_TRACE_END_BUNCH + +#pragma push_macro("UE_NET_TRACE_BUNCH_SCOPE") +#undef UE_NET_TRACE_BUNCH_SCOPE + +#pragma push_macro("UE_NET_TRACE_ASSIGNED_GUID") +#undef UE_NET_TRACE_ASSIGNED_GUID + +#pragma push_macro("UE_NET_TRACE_NETHANDLE_CREATED") +#undef UE_NET_TRACE_NETHANDLE_CREATED + +#pragma push_macro("UE_NET_TRACE_NETHANDLE_DESTROYED") +#undef UE_NET_TRACE_NETHANDLE_DESTROYED + +#pragma push_macro("UE_NET_TRACE_CONNECTION_CREATED") +#undef UE_NET_TRACE_CONNECTION_CREATED + +#pragma push_macro("UE_NET_TRACE_CONNECTION_CLOSED") +#undef UE_NET_TRACE_CONNECTION_CLOSED + +#pragma push_macro("UE_NET_TRACE_PACKET_DROPPED") +#undef UE_NET_TRACE_PACKET_DROPPED + +#pragma push_macro("UE_NET_TRACE_PACKET_SEND") +#undef UE_NET_TRACE_PACKET_SEND + +#pragma push_macro("UE_NET_TRACE_PACKET_RECV") +#undef UE_NET_TRACE_PACKET_RECV + +#pragma push_macro("UE_NET_TRACE_END_SESSION") +#undef UE_NET_TRACE_END_SESSION + +#pragma push_macro("UE_NET_TRACE_DO_IF") +#undef UE_NET_TRACE_DO_IF + +#pragma push_macro("UE_NET_TRACE_INTERNAL_CREATE_COLLECTOR") +#undef UE_NET_TRACE_INTERNAL_CREATE_COLLECTOR + +#pragma push_macro("UE_NET_TRACE_INTERNAL_DESTROY_COLLECTOR") +#undef UE_NET_TRACE_INTERNAL_DESTROY_COLLECTOR + +#pragma push_macro("UE_NET_TRACE_INTERNAL_FLUSH_COLLECTOR") +#undef UE_NET_TRACE_INTERNAL_FLUSH_COLLECTOR + +#pragma push_macro("UE_NET_TRACE_INTERNAL_BEGIN_BUNCH") +#undef UE_NET_TRACE_INTERNAL_BEGIN_BUNCH + +#pragma push_macro("UE_NET_TRACE_INTERNAL_DISCARD_BUNCH") +#undef UE_NET_TRACE_INTERNAL_DISCARD_BUNCH + +#pragma push_macro("UE_NET_TRACE_INTERNAL_POP_SEND_BUNCH") +#undef UE_NET_TRACE_INTERNAL_POP_SEND_BUNCH + +#pragma push_macro("UE_NET_TRACE_INTERNAL_EVENTS") +#undef UE_NET_TRACE_INTERNAL_EVENTS + +#pragma push_macro("UE_NET_TRACE_INTERNAL_END_BUNCH") +#undef UE_NET_TRACE_INTERNAL_END_BUNCH + +#pragma push_macro("UE_NET_TRACE_INTERNAL_BUNCH_SCOPE") +#undef UE_NET_TRACE_INTERNAL_BUNCH_SCOPE + +#pragma push_macro("UE_NET_TRACE_INTERNAL_SCOPE") +#undef UE_NET_TRACE_INTERNAL_SCOPE + +#pragma push_macro("UE_NET_TRACE_INTERNAL_OBJECT_SCOPE") +#undef UE_NET_TRACE_INTERNAL_OBJECT_SCOPE + +#pragma push_macro("UE_NET_TRACE_INTERNAL_DYNAMIC_NAME_SCOPE") +#undef UE_NET_TRACE_INTERNAL_DYNAMIC_NAME_SCOPE + +#pragma push_macro("UE_NET_TRACE_INTERNAL_NAMED_SCOPE") +#undef UE_NET_TRACE_INTERNAL_NAMED_SCOPE + +#pragma push_macro("UE_NET_TRACE_INTERNAL_NAMED_OBJECT_SCOPE") +#undef UE_NET_TRACE_INTERNAL_NAMED_OBJECT_SCOPE + +#pragma push_macro("UE_NET_TRACE_INTERNAL_NAMED_DYNAMIC_NAME_SCOPE") +#undef UE_NET_TRACE_INTERNAL_NAMED_DYNAMIC_NAME_SCOPE + +#pragma push_macro("UE_NET_TRACE_INTERNAL_SET_SCOPE_NAME") +#undef UE_NET_TRACE_INTERNAL_SET_SCOPE_NAME + +#pragma push_macro("UE_NET_TRACE_INTERNAL_SET_SCOPE_OBJECTID") +#undef UE_NET_TRACE_INTERNAL_SET_SCOPE_OBJECTID + +#pragma push_macro("UE_NET_TRACE_INTERNAL_EXIT_NAMED_SCOPE") +#undef UE_NET_TRACE_INTERNAL_EXIT_NAMED_SCOPE + +#pragma push_macro("UE_NET_TRACE_INTERNAL_OFFSET_SCOPE") +#undef UE_NET_TRACE_INTERNAL_OFFSET_SCOPE + +#pragma push_macro("UE_NET_TRACE_INTERNAL") +#undef UE_NET_TRACE_INTERNAL + +#pragma push_macro("UE_NET_TRACE_INTERNAL_DYNAMIC_NAME") +#undef UE_NET_TRACE_INTERNAL_DYNAMIC_NAME + +#pragma push_macro("UE_NET_TRACE_INTERNAL_ASSIGNED_GUID") +#undef UE_NET_TRACE_INTERNAL_ASSIGNED_GUID + +#pragma push_macro("UE_NET_TRACE_INTERNAL_NETHANDLE_CREATED") +#undef UE_NET_TRACE_INTERNAL_NETHANDLE_CREATED + +#pragma push_macro("UE_NET_TRACE_INTERNAL_NETHANDLE_DESTROYED") +#undef UE_NET_TRACE_INTERNAL_NETHANDLE_DESTROYED + +#pragma push_macro("UE_NET_TRACE_INTERNAL_CONNECTION_CREATED") +#undef UE_NET_TRACE_INTERNAL_CONNECTION_CREATED + +#pragma push_macro("UE_NET_TRACE_INTERNAL_CONNECTION_CLOSED") +#undef UE_NET_TRACE_INTERNAL_CONNECTION_CLOSED + +#pragma push_macro("UE_NET_TRACE_INTERNAL_PACKET_DROPPED") +#undef UE_NET_TRACE_INTERNAL_PACKET_DROPPED + +#pragma push_macro("UE_NET_TRACE_INTERNAL_PACKET_SEND") +#undef UE_NET_TRACE_INTERNAL_PACKET_SEND + +#pragma push_macro("UE_NET_TRACE_INTERNAL_PACKET_RECV") +#undef UE_NET_TRACE_INTERNAL_PACKET_RECV + +#pragma push_macro("UE_NET_TRACE_INTERNAL_END_SESSION") +#undef UE_NET_TRACE_INTERNAL_END_SESSION + +#pragma push_macro("CASE_ENUM_TO_STR") +#undef CASE_ENUM_TO_STR + +#pragma push_macro("RETURN_IF_EQUAL") +#undef RETURN_IF_EQUAL + +#pragma push_macro("ROTLEFT_64B") +#undef ROTLEFT_64B + +#pragma push_macro("_TEST_EQUAL") +#undef _TEST_EQUAL + +#pragma push_macro("_TEST_NOT_EQUAL") +#undef _TEST_NOT_EQUAL + +#pragma push_macro("_TEST_NULL") +#undef _TEST_NULL + +#pragma push_macro("_TEST_NOT_NULL") +#undef _TEST_NOT_NULL + +#pragma push_macro("TEST_EQUAL") +#undef TEST_EQUAL + +#pragma push_macro("TEST_NOT_EQUAL") +#undef TEST_NOT_EQUAL + +#pragma push_macro("TEST_TRUE") +#undef TEST_TRUE + +#pragma push_macro("TEST_FALSE") +#undef TEST_FALSE + +#pragma push_macro("TEST_NULL") +#undef TEST_NULL + +#pragma push_macro("TEST_NOT_NULL") +#undef TEST_NOT_NULL + +#pragma push_macro("TEST_BECOMES_TRUE") +#undef TEST_BECOMES_TRUE + +#pragma push_macro("MOCK_FUNC_NOT_IMPLEMENTED") +#undef MOCK_FUNC_NOT_IMPLEMENTED + +#pragma push_macro("ARRAY") +#undef ARRAY + +#pragma push_macro("ARRAYU64") +#undef ARRAYU64 + +#pragma push_macro("CASE_ENUM_SET") +#undef CASE_ENUM_SET + +#pragma push_macro("MAP_TO_RESULTSTRING") +#undef MAP_TO_RESULTSTRING + +#pragma push_macro("PrintCurlFeature") +#undef PrintCurlFeature + +#pragma push_macro("EnumCase") +#undef EnumCase + +#pragma push_macro("RESTRICT_SSL_TLS_PROTOCOL") +#undef RESTRICT_SSL_TLS_PROTOCOL + +#pragma push_macro("DEFINE_COMMAND") +#undef DEFINE_COMMAND + +#pragma push_macro("DECLARE_COMMAND") +#undef DECLARE_COMMAND + +#pragma push_macro("IMPL_HEADER_FIELD_GETTER") +#undef IMPL_HEADER_FIELD_GETTER + +#pragma push_macro("OPUS_CHECK_CTL") +#undef OPUS_CHECK_CTL + +#pragma push_macro("LWSWEBSOCKET_ESTATE_TOSTRING") +#undef LWSWEBSOCKET_ESTATE_TOSTRING + +#pragma push_macro("LOG_AND_GET_GL_QUERY_INT") +#undef LOG_AND_GET_GL_QUERY_INT + +#pragma push_macro("INDEX_TO_VOID") +#undef INDEX_TO_VOID + +#pragma push_macro("ASSERT_NO_GL_ERROR") +#undef ASSERT_NO_GL_ERROR + +#pragma push_macro("LOG_GL_STRING") +#undef LOG_GL_STRING + +#pragma push_macro("LOG_AND_GET_GL_INT_TEMP") +#undef LOG_AND_GET_GL_INT_TEMP + +#pragma push_macro("CHECK_COMPRESSED_FORMAT") +#undef CHECK_COMPRESSED_FORMAT + +#pragma push_macro("LOG_GL_DEBUG_FLAG") +#undef LOG_GL_DEBUG_FLAG + +#pragma push_macro("GL_CHECK") +#undef GL_CHECK + +#pragma push_macro("LOG_AND_GET_GL_INT") +#undef LOG_AND_GET_GL_INT + +#pragma push_macro("GET_GL_INT") +#undef GET_GL_INT + +#pragma push_macro("INTERFACE_BLOCK") +#undef INTERFACE_BLOCK + +#pragma push_macro("VERIFY_EGL") +#undef VERIFY_EGL + +#pragma push_macro("MACRO_TOKENIZER") +#undef MACRO_TOKENIZER + +#pragma push_macro("MACRO_TOKENIZER2") +#undef MACRO_TOKENIZER2 + +#pragma push_macro("VERIFY_EGL_SCOPE_WITH_MSG_STR") +#undef VERIFY_EGL_SCOPE_WITH_MSG_STR + +#pragma push_macro("VERIFY_EGL_SCOPE") +#undef VERIFY_EGL_SCOPE + +#pragma push_macro("VERIFY_EGL_FUNC") +#undef VERIFY_EGL_FUNC + +#pragma push_macro("QUERY_CHECK") +#undef QUERY_CHECK + +#pragma push_macro("DEFINE_GL_ENTRYPOINTS") +#undef DEFINE_GL_ENTRYPOINTS + +#pragma push_macro("GET_GL_ENTRYPOINTS") +#undef GET_GL_ENTRYPOINTS + +#pragma push_macro("CHECK_GL_ENTRYPOINTS") +#undef CHECK_GL_ENTRYPOINTS + +#pragma push_macro("ENUM_GL_ENTRYPOINTS") +#undef ENUM_GL_ENTRYPOINTS + +#pragma push_macro("ENUM_GL_ENTRYPOINTS_OPTIONAL") +#undef ENUM_GL_ENTRYPOINTS_OPTIONAL + +#pragma push_macro("ENUM_GL_ENTRYPOINTS_ALL") +#undef ENUM_GL_ENTRYPOINTS_ALL + +#pragma push_macro("DECLARE_GL_ENTRYPOINTS") +#undef DECLARE_GL_ENTRYPOINTS + +#pragma push_macro("CHECK_GL_ENTRYPOINTS_NULL") +#undef CHECK_GL_ENTRYPOINTS_NULL + +#pragma push_macro("CHECK_GL_ENTRYPOINTS_OK") +#undef CHECK_GL_ENTRYPOINTS_OK + +#pragma push_macro("ENUM_GL_ENTRYPOINTS_1_0") +#undef ENUM_GL_ENTRYPOINTS_1_0 + +#pragma push_macro("ENUM_GL_ENTRYPOINTS_1_1") +#undef ENUM_GL_ENTRYPOINTS_1_1 + +#pragma push_macro("ENUM_GL_ENTRYPOINTS_1_3") +#undef ENUM_GL_ENTRYPOINTS_1_3 + +#pragma push_macro("ENUM_GL_ENTRYPOINTS_1_4") +#undef ENUM_GL_ENTRYPOINTS_1_4 + +#pragma push_macro("ENUM_GL_ENTRYPOINTS_1_5") +#undef ENUM_GL_ENTRYPOINTS_1_5 + +#pragma push_macro("ENUM_GL_ENTRYPOINTS_2_0") +#undef ENUM_GL_ENTRYPOINTS_2_0 + +#pragma push_macro("ENUM_GL_ENTRYPOINTS_2_1") +#undef ENUM_GL_ENTRYPOINTS_2_1 + +#pragma push_macro("ENUM_GL_ENTRYPOINTS_3_0") +#undef ENUM_GL_ENTRYPOINTS_3_0 + +#pragma push_macro("ENUM_GL_ENTRYPOINTS_3_1") +#undef ENUM_GL_ENTRYPOINTS_3_1 + +#pragma push_macro("ENUM_GL_ENTRYPOINTS_3_2") +#undef ENUM_GL_ENTRYPOINTS_3_2 + +#pragma push_macro("ENUM_GL_ENTRYPOINTS_3_3") +#undef ENUM_GL_ENTRYPOINTS_3_3 + +#pragma push_macro("ENUM_GL_ENTRYPOINTS_4_0") +#undef ENUM_GL_ENTRYPOINTS_4_0 + +#pragma push_macro("ENUM_GL_ENTRYPOINTS_4_1") +#undef ENUM_GL_ENTRYPOINTS_4_1 + +#pragma push_macro("ENUM_GL_ENTRYPOINTS_4_2") +#undef ENUM_GL_ENTRYPOINTS_4_2 + +#pragma push_macro("ENUM_GL_ENTRYPOINTS_4_3") +#undef ENUM_GL_ENTRYPOINTS_4_3 + +#pragma push_macro("ENUM_GL_ENTRYPOINTS_4_4") +#undef ENUM_GL_ENTRYPOINTS_4_4 + +#pragma push_macro("ENUM_GL_ENTRYPOINTS_4_5") +#undef ENUM_GL_ENTRYPOINTS_4_5 + +#pragma push_macro("GET_GL_ENTRYPOINTS_DLL") +#undef GET_GL_ENTRYPOINTS_DLL + +#pragma push_macro("ENUM_GL_ENTRYPOINTS_DLL") +#undef ENUM_GL_ENTRYPOINTS_DLL + +#pragma push_macro("UGL_REQUIRED") +#undef UGL_REQUIRED + +#pragma push_macro("UGL_OPTIONAL") +#undef UGL_OPTIONAL + +#pragma push_macro("RHITHREAD_GLCOMMAND_PROLOGUE") +#undef RHITHREAD_GLCOMMAND_PROLOGUE + +#pragma push_macro("RHITHREAD_GLCOMMAND_EPILOGUE_RETURN") +#undef RHITHREAD_GLCOMMAND_EPILOGUE_RETURN + +#pragma push_macro("RHITHREAD_GLCOMMAND_EPILOGUE_GET_RETURN") +#undef RHITHREAD_GLCOMMAND_EPILOGUE_GET_RETURN + +#pragma push_macro("RHITHREAD_GLCOMMAND_EPILOGUE") +#undef RHITHREAD_GLCOMMAND_EPILOGUE + +#pragma push_macro("RHITHREAD_GLCOMMAND_EPILOGUE_NORETURN") +#undef RHITHREAD_GLCOMMAND_EPILOGUE_NORETURN + +#pragma push_macro("SCOPE_CYCLE_COUNTER_DETAILED") +#undef SCOPE_CYCLE_COUNTER_DETAILED + +#pragma push_macro("DETAILED_QUICK_SCOPE_CYCLE_COUNTER") +#undef DETAILED_QUICK_SCOPE_CYCLE_COUNTER + +#pragma push_macro("GLAF_CHECK") +#undef GLAF_CHECK + +#pragma push_macro("CHECK_EXPECTED_GL_THREAD") +#undef CHECK_EXPECTED_GL_THREAD + +#pragma push_macro("VERIFY_GL") +#undef VERIFY_GL + +#pragma push_macro("VERIFY_GL_SCOPE_WITH_MSG_STR") +#undef VERIFY_GL_SCOPE_WITH_MSG_STR + +#pragma push_macro("VERIFY_GL_SCOPE") +#undef VERIFY_GL_SCOPE + +#pragma push_macro("VERIFY_GL_FUNC") +#undef VERIFY_GL_FUNC + +#pragma push_macro("glBlitFramebuffer") +#undef glBlitFramebuffer + +#pragma push_macro("glTexImage2D") +#undef glTexImage2D + +#pragma push_macro("glTexSubImage2D") +#undef glTexSubImage2D + +#pragma push_macro("glCompressedTexImage2D") +#undef glCompressedTexImage2D + +#pragma push_macro("REPORT_GL_DRAW_ARRAYS_EVENT_FOR_FRAME_DUMP") +#undef REPORT_GL_DRAW_ARRAYS_EVENT_FOR_FRAME_DUMP + +#pragma push_macro("REPORT_GL_DRAW_ARRAYS_INSTANCED_EVENT_FOR_FRAME_DUMP") +#undef REPORT_GL_DRAW_ARRAYS_INSTANCED_EVENT_FOR_FRAME_DUMP + +#pragma push_macro("REPORT_GL_DRAW_RANGE_ELEMENTS_EVENT_FOR_FRAME_DUMP") +#undef REPORT_GL_DRAW_RANGE_ELEMENTS_EVENT_FOR_FRAME_DUMP + +#pragma push_macro("REPORT_GL_DRAW_ELEMENTS_INSTANCED_EVENT_FOR_FRAME_DUMP") +#undef REPORT_GL_DRAW_ELEMENTS_INSTANCED_EVENT_FOR_FRAME_DUMP + +#pragma push_macro("REPORT_GL_CLEAR_EVENT_FOR_FRAME_DUMP") +#undef REPORT_GL_CLEAR_EVENT_FOR_FRAME_DUMP + +#pragma push_macro("REPORT_GL_FRAMEBUFFER_BLIT_EVENT") +#undef REPORT_GL_FRAMEBUFFER_BLIT_EVENT + +#pragma push_macro("REPORT_GL_END_BUFFER_EVENT_FOR_FRAME_DUMP") +#undef REPORT_GL_END_BUFFER_EVENT_FOR_FRAME_DUMP + +#pragma push_macro("INITIATE_GL_FRAME_DUMP") +#undef INITIATE_GL_FRAME_DUMP + +#pragma push_macro("INITIATE_GL_FRAME_DUMP_EVERY_X_CALLS") +#undef INITIATE_GL_FRAME_DUMP_EVERY_X_CALLS + +#pragma push_macro("SCOPED_SCENE_READ_LOCK") +#undef SCOPED_SCENE_READ_LOCK + +#pragma push_macro("SCOPED_SCENE_WRITE_LOCK") +#undef SCOPED_SCENE_WRITE_LOCK + +#pragma push_macro("SCOPED_APEX_SCENE_READ_LOCK") +#undef SCOPED_APEX_SCENE_READ_LOCK + +#pragma push_macro("SCOPED_APEX_SCENE_WRITE_LOCK") +#undef SCOPED_APEX_SCENE_WRITE_LOCK + +#pragma push_macro("SCENE_LOCK_READ") +#undef SCENE_LOCK_READ + +#pragma push_macro("SCENE_UNLOCK_READ") +#undef SCENE_UNLOCK_READ + +#pragma push_macro("SCENE_LOCK_WRITE") +#undef SCENE_LOCK_WRITE + +#pragma push_macro("SCENE_UNLOCK_WRITE") +#undef SCENE_UNLOCK_WRITE + +#pragma push_macro("SCOPED_SCENE_READ_LOCK_INDEXED") +#undef SCOPED_SCENE_READ_LOCK_INDEXED + +#pragma push_macro("SCOPED_SCENE_WRITE_LOCK_INDEXED") +#undef SCOPED_SCENE_WRITE_LOCK_INDEXED + +#pragma push_macro("SQ_REPLAY_TEST") +#undef SQ_REPLAY_TEST + +#pragma push_macro("BROADCAST_PROPERTY_CHANGED") +#undef BROADCAST_PROPERTY_CHANGED + +#pragma push_macro("IMPLEMENT_COPY_RESOURCE_SHADER") +#undef IMPLEMENT_COPY_RESOURCE_SHADER + +#pragma push_macro("IMPLEMENT_COPY_RESOURCE_SHADER_ALL_TYPES") +#undef IMPLEMENT_COPY_RESOURCE_SHADER_ALL_TYPES + +#pragma push_macro("IMPLEMENT_ONECOLORVS") +#undef IMPLEMENT_ONECOLORVS + +#pragma push_macro("EmitRDGWarningf") +#undef EmitRDGWarningf + +#pragma push_macro("TEXT_TO_PIXELFORMAT") +#undef TEXT_TO_PIXELFORMAT + +#pragma push_macro("DECLARE_GLOBAL_SHADER") +#undef DECLARE_GLOBAL_SHADER + +#pragma push_macro("IMPLEMENT_GLOBAL_SHADER") +#undef IMPLEMENT_GLOBAL_SHADER + +#pragma push_macro("RDG_ASYNC_COMPUTE_BUDGET_SCOPE") +#undef RDG_ASYNC_COMPUTE_BUDGET_SCOPE + +#pragma push_macro("RDG_GPU_MASK_SCOPE") +#undef RDG_GPU_MASK_SCOPE + +#pragma push_macro("IF_RDG_ENABLE_DEBUG") +#undef IF_RDG_ENABLE_DEBUG + +#pragma push_macro("IF_RDG_GPU_SCOPES") +#undef IF_RDG_GPU_SCOPES + +#pragma push_macro("IF_RDG_CPU_SCOPES") +#undef IF_RDG_CPU_SCOPES + +#pragma push_macro("RDG_EVENT_NAME") +#undef RDG_EVENT_NAME + +#pragma push_macro("RDG_EVENT_SCOPE") +#undef RDG_EVENT_SCOPE + +#pragma push_macro("RDG_EVENT_SCOPE_CONDITIONAL") +#undef RDG_EVENT_SCOPE_CONDITIONAL + +#pragma push_macro("RDG_GPU_STAT_SCOPE") +#undef RDG_GPU_STAT_SCOPE + +#pragma push_macro("RDG_CSV_STAT_EXCLUSIVE_SCOPE") +#undef RDG_CSV_STAT_EXCLUSIVE_SCOPE + +#pragma push_macro("RDG_CSV_STAT_EXCLUSIVE_SCOPE_CONDITIONAL") +#undef RDG_CSV_STAT_EXCLUSIVE_SCOPE_CONDITIONAL + +#pragma push_macro("RDG_WAIT_FOR_TASKS_CONDITIONAL") +#undef RDG_WAIT_FOR_TASKS_CONDITIONAL + +#pragma push_macro("RDG_WAIT_FOR_TASKS") +#undef RDG_WAIT_FOR_TASKS + +#pragma push_macro("SCOPED_SUSPEND_RENDERING_THREAD") +#undef SCOPED_SUSPEND_RENDERING_THREAD + +#pragma push_macro("LogRenderCommand") +#undef LogRenderCommand + +#pragma push_macro("TASK_FUNCTION") +#undef TASK_FUNCTION + +#pragma push_macro("TASKNAME_FUNCTION") +#undef TASKNAME_FUNCTION + +#pragma push_macro("ENQUEUE_RENDER_COMMAND") +#undef ENQUEUE_RENDER_COMMAND + +#pragma push_macro("SHADER_DECLARE_VTABLE") +#undef SHADER_DECLARE_VTABLE + +#pragma push_macro("INTERNAL_DECLARE_SHADER_TYPE_COMMON") +#undef INTERNAL_DECLARE_SHADER_TYPE_COMMON + +#pragma push_macro("DECLARE_EXPORTED_SHADER_TYPE") +#undef DECLARE_EXPORTED_SHADER_TYPE + +#pragma push_macro("DECLARE_SHADER_TYPE") +#undef DECLARE_SHADER_TYPE + +#pragma push_macro("DECLARE_SHADER_TYPE_EXPLICIT_BASES") +#undef DECLARE_SHADER_TYPE_EXPLICIT_BASES + +#pragma push_macro("SHADER_TYPE_VTABLE") +#undef SHADER_TYPE_VTABLE + +#pragma push_macro("IMPLEMENT_SHADER_TYPE") +#undef IMPLEMENT_SHADER_TYPE + +#pragma push_macro("IMPLEMENT_SHADER_TYPE_WITH_DEBUG_NAME") +#undef IMPLEMENT_SHADER_TYPE_WITH_DEBUG_NAME + +#pragma push_macro("IMPLEMENT_SHADER_TYPE2_WITH_TEMPLATE_PREFIX") +#undef IMPLEMENT_SHADER_TYPE2_WITH_TEMPLATE_PREFIX + +#pragma push_macro("IMPLEMENT_SHADER_TYPE2") +#undef IMPLEMENT_SHADER_TYPE2 + +#pragma push_macro("IMPLEMENT_SHADER_TYPE3") +#undef IMPLEMENT_SHADER_TYPE3 + +#pragma push_macro("IMPLEMENT_SHADER_TYPE4_WITH_TEMPLATE_PREFIX") +#undef IMPLEMENT_SHADER_TYPE4_WITH_TEMPLATE_PREFIX + +#pragma push_macro("IMPLEMENT_SHADERPIPELINE_TYPE_VSPS") +#undef IMPLEMENT_SHADERPIPELINE_TYPE_VSPS + +#pragma push_macro("IMPLEMENT_SHADERPIPELINE_TYPE_VS") +#undef IMPLEMENT_SHADERPIPELINE_TYPE_VS + +#pragma push_macro("IMPLEMENT_SHADERPIPELINE_TYPE_VSGSPS") +#undef IMPLEMENT_SHADERPIPELINE_TYPE_VSGSPS + +#pragma push_macro("IMPLEMENT_SHADERPIPELINE_TYPE_VSGS") +#undef IMPLEMENT_SHADERPIPELINE_TYPE_VSGS + +#pragma push_macro("IMPLEMENT_SHADERPIPELINE_TYPE_VSHSDSPS") +#undef IMPLEMENT_SHADERPIPELINE_TYPE_VSHSDSPS + +#pragma push_macro("IMPLEMENT_SHADERPIPELINE_TYPE_VSHSDSGSPS") +#undef IMPLEMENT_SHADERPIPELINE_TYPE_VSHSDSGSPS + +#pragma push_macro("IMPLEMENT_SHADERPIPELINE_TYPE_VSHSDS") +#undef IMPLEMENT_SHADERPIPELINE_TYPE_VSHSDS + +#pragma push_macro("IMPLEMENT_SHADERPIPELINE_TYPE_VSHSDSGS") +#undef IMPLEMENT_SHADERPIPELINE_TYPE_VSHSDSGS + +#pragma push_macro("IMPLEMENT_ALIGNED_TYPE") +#undef IMPLEMENT_ALIGNED_TYPE + +#pragma push_macro("INTERNAL_UNIFORM_BUFFER_STRUCT_GET_STRUCT_METADATA") +#undef INTERNAL_UNIFORM_BUFFER_STRUCT_GET_STRUCT_METADATA + +#pragma push_macro("INTERNAL_SHADER_PARAMETER_GET_STRUCT_METADATA") +#undef INTERNAL_SHADER_PARAMETER_GET_STRUCT_METADATA + +#pragma push_macro("INTERNAL_SHADER_PARAMETER_STRUCT_BEGIN") +#undef INTERNAL_SHADER_PARAMETER_STRUCT_BEGIN + +#pragma push_macro("INTERNAL_SHADER_PARAMETER_EXPLICIT") +#undef INTERNAL_SHADER_PARAMETER_EXPLICIT + +#pragma push_macro("BEGIN_SHADER_PARAMETER_STRUCT") +#undef BEGIN_SHADER_PARAMETER_STRUCT + +#pragma push_macro("END_SHADER_PARAMETER_STRUCT") +#undef END_SHADER_PARAMETER_STRUCT + +#pragma push_macro("BEGIN_UNIFORM_BUFFER_STRUCT") +#undef BEGIN_UNIFORM_BUFFER_STRUCT + +#pragma push_macro("BEGIN_UNIFORM_BUFFER_STRUCT_WITH_CONSTRUCTOR") +#undef BEGIN_UNIFORM_BUFFER_STRUCT_WITH_CONSTRUCTOR + +#pragma push_macro("END_UNIFORM_BUFFER_STRUCT") +#undef END_UNIFORM_BUFFER_STRUCT + +#pragma push_macro("IMPLEMENT_UNIFORM_BUFFER_STRUCT") +#undef IMPLEMENT_UNIFORM_BUFFER_STRUCT + +#pragma push_macro("IMPLEMENT_UNIFORM_BUFFER_ALIAS_STRUCT") +#undef IMPLEMENT_UNIFORM_BUFFER_ALIAS_STRUCT + +#pragma push_macro("IMPLEMENT_STATIC_UNIFORM_BUFFER_STRUCT") +#undef IMPLEMENT_STATIC_UNIFORM_BUFFER_STRUCT + +#pragma push_macro("IMPLEMENT_STATIC_UNIFORM_BUFFER_SLOT") +#undef IMPLEMENT_STATIC_UNIFORM_BUFFER_SLOT + +#pragma push_macro("SHADER_PARAMETER") +#undef SHADER_PARAMETER + +#pragma push_macro("SHADER_PARAMETER_EX") +#undef SHADER_PARAMETER_EX + +#pragma push_macro("SHADER_PARAMETER_ARRAY") +#undef SHADER_PARAMETER_ARRAY + +#pragma push_macro("SHADER_PARAMETER_ARRAY_EX") +#undef SHADER_PARAMETER_ARRAY_EX + +#pragma push_macro("SHADER_PARAMETER_TEXTURE") +#undef SHADER_PARAMETER_TEXTURE + +#pragma push_macro("SHADER_PARAMETER_TEXTURE_ARRAY") +#undef SHADER_PARAMETER_TEXTURE_ARRAY + +#pragma push_macro("SHADER_PARAMETER_SRV") +#undef SHADER_PARAMETER_SRV + +#pragma push_macro("SHADER_PARAMETER_SRV_ARRAY") +#undef SHADER_PARAMETER_SRV_ARRAY + +#pragma push_macro("SHADER_PARAMETER_UAV") +#undef SHADER_PARAMETER_UAV + +#pragma push_macro("SHADER_PARAMETER_SAMPLER") +#undef SHADER_PARAMETER_SAMPLER + +#pragma push_macro("SHADER_PARAMETER_SAMPLER_ARRAY") +#undef SHADER_PARAMETER_SAMPLER_ARRAY + +#pragma push_macro("SHADER_PARAMETER_RDG_TEXTURE") +#undef SHADER_PARAMETER_RDG_TEXTURE + +#pragma push_macro("SHADER_PARAMETER_RDG_TEXTURE_ARRAY") +#undef SHADER_PARAMETER_RDG_TEXTURE_ARRAY + +#pragma push_macro("SHADER_PARAMETER_RDG_TEXTURE_SRV") +#undef SHADER_PARAMETER_RDG_TEXTURE_SRV + +#pragma push_macro("SHADER_PARAMETER_RDG_TEXTURE_SRV_ARRAY") +#undef SHADER_PARAMETER_RDG_TEXTURE_SRV_ARRAY + +#pragma push_macro("SHADER_PARAMETER_RDG_TEXTURE_UAV") +#undef SHADER_PARAMETER_RDG_TEXTURE_UAV + +#pragma push_macro("SHADER_PARAMETER_RDG_TEXTURE_UAV_ARRAY") +#undef SHADER_PARAMETER_RDG_TEXTURE_UAV_ARRAY + +#pragma push_macro("SHADER_PARAMETER_RDG_BUFFER") +#undef SHADER_PARAMETER_RDG_BUFFER + +#pragma push_macro("SHADER_PARAMETER_RDG_BUFFER_ARRAY") +#undef SHADER_PARAMETER_RDG_BUFFER_ARRAY + +#pragma push_macro("SHADER_PARAMETER_RDG_BUFFER_SRV") +#undef SHADER_PARAMETER_RDG_BUFFER_SRV + +#pragma push_macro("SHADER_PARAMETER_RDG_BUFFER_SRV_ARRAY") +#undef SHADER_PARAMETER_RDG_BUFFER_SRV_ARRAY + +#pragma push_macro("SHADER_PARAMETER_RDG_BUFFER_UAV") +#undef SHADER_PARAMETER_RDG_BUFFER_UAV + +#pragma push_macro("SHADER_PARAMETER_RDG_BUFFER_UAV_ARRAY") +#undef SHADER_PARAMETER_RDG_BUFFER_UAV_ARRAY + +#pragma push_macro("SHADER_PARAMETER_RDG_UNIFORM_BUFFER") +#undef SHADER_PARAMETER_RDG_UNIFORM_BUFFER + +#pragma push_macro("SHADER_PARAMETER_STRUCT") +#undef SHADER_PARAMETER_STRUCT + +#pragma push_macro("SHADER_PARAMETER_STRUCT_ARRAY") +#undef SHADER_PARAMETER_STRUCT_ARRAY + +#pragma push_macro("SHADER_PARAMETER_STRUCT_INCLUDE") +#undef SHADER_PARAMETER_STRUCT_INCLUDE + +#pragma push_macro("SHADER_PARAMETER_STRUCT_REF") +#undef SHADER_PARAMETER_STRUCT_REF + +#pragma push_macro("RDG_BUFFER_ACCESS") +#undef RDG_BUFFER_ACCESS + +#pragma push_macro("RDG_BUFFER_ACCESS_DYNAMIC") +#undef RDG_BUFFER_ACCESS_DYNAMIC + +#pragma push_macro("RDG_TEXTURE_ACCESS") +#undef RDG_TEXTURE_ACCESS + +#pragma push_macro("RDG_TEXTURE_ACCESS_DYNAMIC") +#undef RDG_TEXTURE_ACCESS_DYNAMIC + +#pragma push_macro("SHADER_PARAMETER_RDG_BUFFER_UPLOAD") +#undef SHADER_PARAMETER_RDG_BUFFER_UPLOAD + +#pragma push_macro("RENDER_TARGET_BINDING_SLOTS") +#undef RENDER_TARGET_BINDING_SLOTS + +#pragma push_macro("SHADER_USE_PARAMETER_STRUCT_INTERNAL") +#undef SHADER_USE_PARAMETER_STRUCT_INTERNAL + +#pragma push_macro("SHADER_USE_PARAMETER_STRUCT") +#undef SHADER_USE_PARAMETER_STRUCT + +#pragma push_macro("SHADER_USE_PARAMETER_STRUCT_WITH_LEGACY_BASE") +#undef SHADER_USE_PARAMETER_STRUCT_WITH_LEGACY_BASE + +#pragma push_macro("SHADER_USE_ROOT_PARAMETER_STRUCT") +#undef SHADER_USE_ROOT_PARAMETER_STRUCT + +#pragma push_macro("DECLARE_SHADER_PERMUTATION_IMPL") +#undef DECLARE_SHADER_PERMUTATION_IMPL + +#pragma push_macro("SHADER_PERMUTATION_BOOL") +#undef SHADER_PERMUTATION_BOOL + +#pragma push_macro("SHADER_PERMUTATION_INT") +#undef SHADER_PERMUTATION_INT + +#pragma push_macro("SHADER_PERMUTATION_RANGE_INT") +#undef SHADER_PERMUTATION_RANGE_INT + +#pragma push_macro("SHADER_PERMUTATION_SPARSE_INT") +#undef SHADER_PERMUTATION_SPARSE_INT + +#pragma push_macro("SHADER_PERMUTATION_ENUM_CLASS") +#undef SHADER_PERMUTATION_ENUM_CLASS + +#pragma push_macro("STRUCTMEMBER_VERTEXSTREAMCOMPONENT") +#undef STRUCTMEMBER_VERTEXSTREAMCOMPONENT + +#pragma push_macro("IMPLEMENT_VERTEX_FACTORY_PARAMETER_TYPE") +#undef IMPLEMENT_VERTEX_FACTORY_PARAMETER_TYPE + +#pragma push_macro("DECLARE_VERTEX_FACTORY_TYPE") +#undef DECLARE_VERTEX_FACTORY_TYPE + +#pragma push_macro("IMPLEMENT_VERTEX_FACTORY_VTABLE") +#undef IMPLEMENT_VERTEX_FACTORY_VTABLE + +#pragma push_macro("IMPLEMENT_VERTEX_FACTORY_TYPE") +#undef IMPLEMENT_VERTEX_FACTORY_TYPE + +#pragma push_macro("IMPLEMENT_TEMPLATE_VERTEX_FACTORY_TYPE_EX") +#undef IMPLEMENT_TEMPLATE_VERTEX_FACTORY_TYPE_EX + +#pragma push_macro("IMPLEMENT_VERTEX_FACTORY_TYPE_EX") +#undef IMPLEMENT_VERTEX_FACTORY_TYPE_EX + +#pragma push_macro("SCOPED_GPU_EVENT") +#undef SCOPED_GPU_EVENT + +#pragma push_macro("SCOPED_GPU_EVENT_COLOR") +#undef SCOPED_GPU_EVENT_COLOR + +#pragma push_macro("SCOPED_GPU_EVENTF") +#undef SCOPED_GPU_EVENTF + +#pragma push_macro("SCOPED_GPU_EVENTF_COLOR") +#undef SCOPED_GPU_EVENTF_COLOR + +#pragma push_macro("SCOPED_CONDITIONAL_GPU_EVENT") +#undef SCOPED_CONDITIONAL_GPU_EVENT + +#pragma push_macro("SCOPED_CONDITIONAL_GPU_EVENT_COLOR") +#undef SCOPED_CONDITIONAL_GPU_EVENT_COLOR + +#pragma push_macro("SCOPED_CONDITIONAL_GPU_EVENTF") +#undef SCOPED_CONDITIONAL_GPU_EVENTF + +#pragma push_macro("SCOPED_CONDITIONAL_GPU_EVENTF_COLOR") +#undef SCOPED_CONDITIONAL_GPU_EVENTF_COLOR + +#pragma push_macro("BEGIN_GPU_EVENTF") +#undef BEGIN_GPU_EVENTF + +#pragma push_macro("BEGIN_GPU_EVENTF_COLOR") +#undef BEGIN_GPU_EVENTF_COLOR + +#pragma push_macro("STOP_GPU_EVENT") +#undef STOP_GPU_EVENT + +#pragma push_macro("SCOPED_DRAW_EVENT") +#undef SCOPED_DRAW_EVENT + +#pragma push_macro("SCOPED_DRAW_EVENT_COLOR") +#undef SCOPED_DRAW_EVENT_COLOR + +#pragma push_macro("SCOPED_DRAW_EVENTF") +#undef SCOPED_DRAW_EVENTF + +#pragma push_macro("SCOPED_DRAW_EVENTF_COLOR") +#undef SCOPED_DRAW_EVENTF_COLOR + +#pragma push_macro("SCOPED_CONDITIONAL_DRAW_EVENT") +#undef SCOPED_CONDITIONAL_DRAW_EVENT + +#pragma push_macro("SCOPED_CONDITIONAL_DRAW_EVENT_COLOR") +#undef SCOPED_CONDITIONAL_DRAW_EVENT_COLOR + +#pragma push_macro("SCOPED_CONDITIONAL_DRAW_EVENTF") +#undef SCOPED_CONDITIONAL_DRAW_EVENTF + +#pragma push_macro("SCOPED_CONDITIONAL_DRAW_EVENTF_COLOR") +#undef SCOPED_CONDITIONAL_DRAW_EVENTF_COLOR + +#pragma push_macro("BEGIN_DRAW_EVENTF") +#undef BEGIN_DRAW_EVENTF + +#pragma push_macro("BEGIN_DRAW_EVENTF_COLOR") +#undef BEGIN_DRAW_EVENTF_COLOR + +#pragma push_macro("STOP_DRAW_EVENT") +#undef STOP_DRAW_EVENT + +#pragma push_macro("SCOPED_RHI_DRAW_EVENT") +#undef SCOPED_RHI_DRAW_EVENT + +#pragma push_macro("SCOPED_RHI_DRAW_EVENT_COLOR") +#undef SCOPED_RHI_DRAW_EVENT_COLOR + +#pragma push_macro("SCOPED_RHI_DRAW_EVENTF") +#undef SCOPED_RHI_DRAW_EVENTF + +#pragma push_macro("SCOPED_RHI_DRAW_EVENTF_COLOR") +#undef SCOPED_RHI_DRAW_EVENTF_COLOR + +#pragma push_macro("SCOPED_RHI_CONDITIONAL_DRAW_EVENT") +#undef SCOPED_RHI_CONDITIONAL_DRAW_EVENT + +#pragma push_macro("SCOPED_RHI_CONDITIONAL_DRAW_EVENT_COLOR") +#undef SCOPED_RHI_CONDITIONAL_DRAW_EVENT_COLOR + +#pragma push_macro("SCOPED_RHI_CONDITIONAL_DRAW_EVENTF") +#undef SCOPED_RHI_CONDITIONAL_DRAW_EVENTF + +#pragma push_macro("SCOPED_RHI_CONDITIONAL_DRAW_EVENTF_COLOR") +#undef SCOPED_RHI_CONDITIONAL_DRAW_EVENTF_COLOR + +#pragma push_macro("SCOPED_COMPUTE_EVENT") +#undef SCOPED_COMPUTE_EVENT + +#pragma push_macro("SCOPED_COMPUTE_EVENT_COLOR") +#undef SCOPED_COMPUTE_EVENT_COLOR + +#pragma push_macro("SCOPED_COMPUTE_EVENTF") +#undef SCOPED_COMPUTE_EVENTF + +#pragma push_macro("SCOPED_COMPUTE_EVENTF_COLOR") +#undef SCOPED_COMPUTE_EVENTF_COLOR + +#pragma push_macro("SCOPED_CONDITIONAL_COMPUTE_EVENT") +#undef SCOPED_CONDITIONAL_COMPUTE_EVENT + +#pragma push_macro("SCOPED_CONDITIONAL_COMPUTE_EVENT_COLOR") +#undef SCOPED_CONDITIONAL_COMPUTE_EVENT_COLOR + +#pragma push_macro("SCOPED_CONDITIONAL_COMPUTE_EVENTF") +#undef SCOPED_CONDITIONAL_COMPUTE_EVENTF + +#pragma push_macro("SCOPED_CONDITIONAL_COMPUTE_EVENTF_COLOR") +#undef SCOPED_CONDITIONAL_COMPUTE_EVENTF_COLOR + +#pragma push_macro("DECLARE_GPU_STAT") +#undef DECLARE_GPU_STAT + +#pragma push_macro("DECLARE_GPU_DRAWCALL_STAT") +#undef DECLARE_GPU_DRAWCALL_STAT + +#pragma push_macro("DECLARE_GPU_DRAWCALL_STAT_EXTERN") +#undef DECLARE_GPU_DRAWCALL_STAT_EXTERN + +#pragma push_macro("DECLARE_GPU_STAT_NAMED") +#undef DECLARE_GPU_STAT_NAMED + +#pragma push_macro("DECLARE_GPU_DRAWCALL_STAT_NAMED") +#undef DECLARE_GPU_DRAWCALL_STAT_NAMED + +#pragma push_macro("DECLARE_GPU_STAT_NAMED_EXTERN") +#undef DECLARE_GPU_STAT_NAMED_EXTERN + +#pragma push_macro("DEFINE_GPU_STAT") +#undef DEFINE_GPU_STAT + +#pragma push_macro("DEFINE_GPU_DRAWCALL_STAT") +#undef DEFINE_GPU_DRAWCALL_STAT + +#pragma push_macro("SCOPED_GPU_STAT") +#undef SCOPED_GPU_STAT + +#pragma push_macro("GPU_STATS_BEGINFRAME") +#undef GPU_STATS_BEGINFRAME + +#pragma push_macro("GPU_STATS_ENDFRAME") +#undef GPU_STATS_ENDFRAME + +#pragma push_macro("IMPLEMENT_ATMOSPHERE_TEXTURE_PARAM_SET") +#undef IMPLEMENT_ATMOSPHERE_TEXTURE_PARAM_SET + +#pragma push_macro("SHADER_VARIATION") +#undef SHADER_VARIATION + +#pragma push_macro("IMPLEMENT_BASEPASS_VERTEXSHADER_TYPE") +#undef IMPLEMENT_BASEPASS_VERTEXSHADER_TYPE + +#pragma push_macro("IMPLEMENT_BASEPASS_VERTEXSHADER_ONLY_TYPE") +#undef IMPLEMENT_BASEPASS_VERTEXSHADER_ONLY_TYPE + +#pragma push_macro("IMPLEMENT_BASEPASS_PIXELSHADER_TYPE") +#undef IMPLEMENT_BASEPASS_PIXELSHADER_TYPE + +#pragma push_macro("IMPLEMENT_BASEPASS_LIGHTMAPPED_SHADER_TYPE") +#undef IMPLEMENT_BASEPASS_LIGHTMAPPED_SHADER_TYPE + +#pragma push_macro("IMPLEMENT_CAPSULE_SHADOW_TYPE") +#undef IMPLEMENT_CAPSULE_SHADOW_TYPE + +#pragma push_macro("IMPLEMENT_CAPSULE_APPLY_SHADER_TYPE") +#undef IMPLEMENT_CAPSULE_APPLY_SHADER_TYPE + +#pragma push_macro("IMPLEMENT_GetDepthPassShaders") +#undef IMPLEMENT_GetDepthPassShaders + +#pragma push_macro("VARIATION1") +#undef VARIATION1 + +#pragma push_macro("IMPLEMENT_REMOVE_OBJECTS_FROM_BUFFER_SHADER_TYPE") +#undef IMPLEMENT_REMOVE_OBJECTS_FROM_BUFFER_SHADER_TYPE + +#pragma push_macro("IMPLEMENT_CONETRACE_CS_TYPE") +#undef IMPLEMENT_CONETRACE_CS_TYPE + +#pragma push_macro("IMPLEMENT_CONETRACE_GLOBAL_CS_TYPE") +#undef IMPLEMENT_CONETRACE_GLOBAL_CS_TYPE + +#pragma push_macro("VARIATION") +#undef VARIATION + +#pragma push_macro("IMPLEMENT_GLOBALDF_COMPOSITE_CS_TYPE") +#undef IMPLEMENT_GLOBALDF_COMPOSITE_CS_TYPE + +#pragma push_macro("GROUPSHARED_COMPLEX_TRANSFORM") +#undef GROUPSHARED_COMPLEX_TRANSFORM + +#pragma push_macro("GROUPSHARED_TWO_FOR_ONE_TRANSFORM") +#undef GROUPSHARED_TWO_FOR_ONE_TRANSFORM + +#pragma push_macro("GROUPSHARED_CONVOLUTION_WTEXTURE") +#undef GROUPSHARED_CONVOLUTION_WTEXTURE + +#pragma push_macro("GET_COMPLEX_SHADER") +#undef GET_COMPLEX_SHADER + +#pragma push_macro("GET_TWOFORONE_SHADER") +#undef GET_TWOFORONE_SHADER + +#pragma push_macro("GET_GROUP_SHARED_TEXTURE_FILTER") +#undef GET_GROUP_SHARED_TEXTURE_FILTER + +#pragma push_macro("IMPLEMENT_DENSITY_VERTEXSHADER_TYPE") +#undef IMPLEMENT_DENSITY_VERTEXSHADER_TYPE + +#pragma push_macro("IMPLEMENT_DENSITY_PIXELSHADER_TYPE") +#undef IMPLEMENT_DENSITY_PIXELSHADER_TYPE + +#pragma push_macro("IMPLEMENT_DENSITY_LIGHTMAPPED_SHADER_TYPE") +#undef IMPLEMENT_DENSITY_LIGHTMAPPED_SHADER_TYPE + +#pragma push_macro("IMPLEMENT_MOBILE_SHADING_BASEPASS_LIGHTMAPPED_VERTEX_SHADER_TYPE") +#undef IMPLEMENT_MOBILE_SHADING_BASEPASS_LIGHTMAPPED_VERTEX_SHADER_TYPE + +#pragma push_macro("IMPLEMENT_MOBILE_SHADING_BASEPASS_LIGHTMAPPED_PIXEL_SHADER_TYPE") +#undef IMPLEMENT_MOBILE_SHADING_BASEPASS_LIGHTMAPPED_PIXEL_SHADER_TYPE + +#pragma push_macro("IMPLEMENT_MOBILE_SHADING_BASEPASS_LIGHTMAPPED_SHADER_TYPE") +#undef IMPLEMENT_MOBILE_SHADING_BASEPASS_LIGHTMAPPED_SHADER_TYPE + +#pragma push_macro("IMPLEMENT_MOBILE_SCENE_CAPTURECOPY") +#undef IMPLEMENT_MOBILE_SCENE_CAPTURECOPY + +#pragma push_macro("SET_SPEEDTREE_TABLE_FLOAT4V") +#undef SET_SPEEDTREE_TABLE_FLOAT4V + +#pragma push_macro("FASTVRAM_CVAR") +#undef FASTVRAM_CVAR + +#pragma push_macro("CANVAS_HEADER") +#undef CANVAS_HEADER + +#pragma push_macro("CANVAS_LINE") +#undef CANVAS_LINE + +#pragma push_macro("IMPLEMENT_MATERIAL_SHADER_SetParameters") +#undef IMPLEMENT_MATERIAL_SHADER_SetParameters + +#pragma push_macro("IMPLEMENT_SHADOW_DEPTH_SHADERMODE_SHADERS") +#undef IMPLEMENT_SHADOW_DEPTH_SHADERMODE_SHADERS + +#pragma push_macro("IMPLEMENT_SHADOWDEPTHPASS_PIXELSHADER_TYPE") +#undef IMPLEMENT_SHADOWDEPTHPASS_PIXELSHADER_TYPE + +#pragma push_macro("IMPLEMENT_SHADOW_PROJECTION_PIXEL_SHADER") +#undef IMPLEMENT_SHADOW_PROJECTION_PIXEL_SHADER + +#pragma push_macro("IMPLEMENT_MODULATED_SHADOW_PROJECTION_PIXEL_SHADER") +#undef IMPLEMENT_MODULATED_SHADOW_PROJECTION_PIXEL_SHADER + +#pragma push_macro("IMPLEMENT_ONEPASS_POINT_SHADOW_PROJECTION_PIXEL_SHADER") +#undef IMPLEMENT_ONEPASS_POINT_SHADOW_PROJECTION_PIXEL_SHADER + +#pragma push_macro("COPYMACRO") +#undef COPYMACRO + +#pragma push_macro("IMPLEMENT_INJECTION_PIXELSHADER_TYPE") +#undef IMPLEMENT_INJECTION_PIXELSHADER_TYPE + +#pragma push_macro("IMPLEMENT_RESOLVE_SHADER") +#undef IMPLEMENT_RESOLVE_SHADER + +#pragma push_macro("ENTRY") +#undef ENTRY + +#pragma push_macro("IMPLEMENT_POST_PROCESS_PARAM_SET") +#undef IMPLEMENT_POST_PROCESS_PARAM_SET + +#pragma push_macro("UPDATE_HISTORY_FLAGS") +#undef UPDATE_HISTORY_FLAGS + +#pragma push_macro("ANY_CAPTURE_RENDERED_RECENTLY") +#undef ANY_CAPTURE_RENDERED_RECENTLY + +#pragma push_macro("ANY_HIGHRES_CAPTURE_RENDERED_RECENTLY") +#undef ANY_HIGHRES_CAPTURE_RENDERED_RECENTLY + +#pragma push_macro("GET_STENCIL_BIT_MASK") +#undef GET_STENCIL_BIT_MASK + +#pragma push_macro("STENCIL_LIGHTING_CHANNELS_MASK") +#undef STENCIL_LIGHTING_CHANNELS_MASK + +#pragma push_macro("GET_STENCIL_MOBILE_SM_MASK") +#undef GET_STENCIL_MOBILE_SM_MASK + +#pragma push_macro("SCOPED_DRAW_OR_COMPUTE_EVENT") +#undef SCOPED_DRAW_OR_COMPUTE_EVENT + +#pragma push_macro("IMPLEMENT_MATERIALCHS_TYPE") +#undef IMPLEMENT_MATERIALCHS_TYPE + +#pragma push_macro("IMPLEMENT_VIRTUALTEXTURE_SHADER_TYPE") +#undef IMPLEMENT_VIRTUALTEXTURE_SHADER_TYPE + +#pragma push_macro("COMPARE_FIELD_BEGIN") +#undef COMPARE_FIELD_BEGIN + +#pragma push_macro("COMPARE_FIELD") +#undef COMPARE_FIELD + +#pragma push_macro("A") +#undef A + +#pragma push_macro("TRACE_GPUPROFILER_DEFINE_EVENT_TYPE") +#undef TRACE_GPUPROFILER_DEFINE_EVENT_TYPE + +#pragma push_macro("TRACE_GPUPROFILER_DECLARE_EVENT_TYPE_EXTERN") +#undef TRACE_GPUPROFILER_DECLARE_EVENT_TYPE_EXTERN + +#pragma push_macro("TRACE_GPUPROFILER_EVENT_TYPE") +#undef TRACE_GPUPROFILER_EVENT_TYPE + +#pragma push_macro("TRACE_GPUPROFILER_BEGIN_FRAME") +#undef TRACE_GPUPROFILER_BEGIN_FRAME + +#pragma push_macro("TRACE_GPUPROFILER_BEGIN_EVENT") +#undef TRACE_GPUPROFILER_BEGIN_EVENT + +#pragma push_macro("TRACE_GPUPROFILER_END_EVENT") +#undef TRACE_GPUPROFILER_END_EVENT + +#pragma push_macro("TRACE_GPUPROFILER_END_FRAME") +#undef TRACE_GPUPROFILER_END_FRAME + +#pragma push_macro("RHI_DRAW_CALL_INC") +#undef RHI_DRAW_CALL_INC + +#pragma push_macro("RHI_DRAW_CALL_STATS") +#undef RHI_DRAW_CALL_STATS + +#pragma push_macro("RHISTAT") +#undef RHISTAT + +#pragma push_macro("FRHICOMMAND_MACRO") +#undef FRHICOMMAND_MACRO + +#pragma push_macro("ALLOC_COMMAND") +#undef ALLOC_COMMAND + +#pragma push_macro("ALLOC_COMMAND_CL") +#undef ALLOC_COMMAND_CL + +#pragma push_macro("SCOPED_GPU_MASK") +#undef SCOPED_GPU_MASK + +#pragma push_macro("SCOPED_UNIFORM_BUFFER_GLOBAL_BINDINGS") +#undef SCOPED_UNIFORM_BUFFER_GLOBAL_BINDINGS + +#pragma push_macro("INTERNAL_DECORATOR_COMPUTE") +#undef INTERNAL_DECORATOR_COMPUTE + +#pragma push_macro("IMPLEMENT_DDPSPI_SETTING_WITH_RETURN_TYPE") +#undef IMPLEMENT_DDPSPI_SETTING_WITH_RETURN_TYPE + +#pragma push_macro("IMPLEMENT_DDPSPI_SETTING") +#undef IMPLEMENT_DDPSPI_SETTING + +#pragma push_macro("GEOMETRY_SHADER") +#undef GEOMETRY_SHADER + +#pragma push_macro("TESSELLATION_SHADER") +#undef TESSELLATION_SHADER + +#pragma push_macro("RTACTION_MAKE_MASK") +#undef RTACTION_MAKE_MASK + +#pragma push_macro("DUMP_TRANSITION") +#undef DUMP_TRANSITION + +#pragma push_macro("UE_LOG_RIGVMMEMORY") +#undef UE_LOG_RIGVMMEMORY + +#pragma push_macro("BREAK_WHEN_AUDIBLE") +#undef BREAK_WHEN_AUDIBLE + +#pragma push_macro("BREAK_WHEN_TOO_LOUD") +#undef BREAK_WHEN_TOO_LOUD + +#pragma push_macro("CHECK_SAMPLE") +#undef CHECK_SAMPLE + +#pragma push_macro("CHECK_SAMPLE2") +#undef CHECK_SAMPLE2 + +#pragma push_macro("UI_COMMAND_EXT") +#undef UI_COMMAND_EXT + +#pragma push_macro("UI_COMMAND") +#undef UI_COMMAND + +#pragma push_macro("APPEND_FONT") +#undef APPEND_FONT + +#pragma push_macro("APPEND_EDITOR_FONT") +#undef APPEND_EDITOR_FONT + +#pragma push_macro("APPEND_RANGE") +#undef APPEND_RANGE + +#pragma push_macro("RETURN_TRUE_IF_CHAR_WITHIN_RANGE") +#undef RETURN_TRUE_IF_CHAR_WITHIN_RANGE + +#pragma push_macro("REGISTER_UNICODE_BLOCK_RANGE") +#undef REGISTER_UNICODE_BLOCK_RANGE + +#pragma push_macro("AddToNextFocusableWidgetCondidateDebugResults") +#undef AddToNextFocusableWidgetCondidateDebugResults + +#pragma push_macro("SLATE_CROSS_THREAD_CHECK") +#undef SLATE_CROSS_THREAD_CHECK + +#pragma push_macro("DRAG_DROP_OPERATOR_TYPE") +#undef DRAG_DROP_OPERATOR_TYPE + +#pragma push_macro("UE_TRACE_SLATE_APPLICATION_TICK_AND_DRAW_WIDGETS") +#undef UE_TRACE_SLATE_APPLICATION_TICK_AND_DRAW_WIDGETS + +#pragma push_macro("UE_TRACE_SLATE_WIDGET_ADDED") +#undef UE_TRACE_SLATE_WIDGET_ADDED + +#pragma push_macro("UE_TRACE_SLATE_WIDGET_DEBUG_INFO") +#undef UE_TRACE_SLATE_WIDGET_DEBUG_INFO + +#pragma push_macro("UE_TRACE_SLATE_WIDGET_REMOVED") +#undef UE_TRACE_SLATE_WIDGET_REMOVED + +#pragma push_macro("UE_TRACE_SCOPED_SLATE_WIDGET_PAINT") +#undef UE_TRACE_SCOPED_SLATE_WIDGET_PAINT + +#pragma push_macro("UE_TRACE_SLATE_WIDGET_UPDATED") +#undef UE_TRACE_SLATE_WIDGET_UPDATED + +#pragma push_macro("UE_TRACE_SLATE_WIDGET_INVALIDATED") +#undef UE_TRACE_SLATE_WIDGET_INVALIDATED + +#pragma push_macro("UE_TRACE_SLATE_ROOT_INVALIDATED") +#undef UE_TRACE_SLATE_ROOT_INVALIDATED + +#pragma push_macro("UE_TRACE_SLATE_ROOT_CHILDORDER_INVALIDATED") +#undef UE_TRACE_SLATE_ROOT_CHILDORDER_INVALIDATED + +#pragma push_macro("SLATE_METADATA_TYPE") +#undef SLATE_METADATA_TYPE + +#pragma push_macro("SNew") +#undef SNew + +#pragma push_macro("SAssignNew") +#undef SAssignNew + +#pragma push_macro("SLATE_BEGIN_ARGS") +#undef SLATE_BEGIN_ARGS + +#pragma push_macro("SLATE_USER_ARGS") +#undef SLATE_USER_ARGS + +#pragma push_macro("HACK_SLATE_SLOT_ARGS") +#undef HACK_SLATE_SLOT_ARGS + +#pragma push_macro("SLATE_END_ARGS") +#undef SLATE_END_ARGS + +#pragma push_macro("SLATE_ATTRIBUTE") +#undef SLATE_ATTRIBUTE + +#pragma push_macro("SLATE_ARGUMENT") +#undef SLATE_ARGUMENT + +#pragma push_macro("SLATE_ARGUMENT_DEFAULT") +#undef SLATE_ARGUMENT_DEFAULT + +#pragma push_macro("SLATE_STYLE_ARGUMENT") +#undef SLATE_STYLE_ARGUMENT + +#pragma push_macro("SLATE_SUPPORTS_SLOT") +#undef SLATE_SUPPORTS_SLOT + +#pragma push_macro("SLATE_SUPPORTS_SLOT_WITH_ARGS") +#undef SLATE_SUPPORTS_SLOT_WITH_ARGS + +#pragma push_macro("SLATE_NAMED_SLOT") +#undef SLATE_NAMED_SLOT + +#pragma push_macro("SLATE_DEFAULT_SLOT") +#undef SLATE_DEFAULT_SLOT + +#pragma push_macro("SLATE_EVENT") +#undef SLATE_EVENT + +#pragma push_macro("SCOPE_CYCLE_SWIDGET") +#undef SCOPE_CYCLE_SWIDGET + +#pragma push_macro("IMPLEMENT_SLATE_VERTEXMATERIALSHADER_TYPE") +#undef IMPLEMENT_SLATE_VERTEXMATERIALSHADER_TYPE + +#pragma push_macro("IMPLEMENT_SLATE_MATERIALSHADER_TYPE") +#undef IMPLEMENT_SLATE_MATERIALSHADER_TYPE + +#pragma push_macro("SLATE_DRAW_EVENT") +#undef SLATE_DRAW_EVENT + +#pragma push_macro("IMPLEMENT_SLATE_PIXELSHADER_TYPE") +#undef IMPLEMENT_SLATE_PIXELSHADER_TYPE + +#pragma push_macro("UE_TRACE_EVENT_DEFINE") +#undef UE_TRACE_EVENT_DEFINE + +#pragma push_macro("UE_TRACE_EVENT_BEGIN") +#undef UE_TRACE_EVENT_BEGIN + +#pragma push_macro("UE_TRACE_EVENT_BEGIN_EXTERN") +#undef UE_TRACE_EVENT_BEGIN_EXTERN + +#pragma push_macro("UE_TRACE_EVENT_FIELD") +#undef UE_TRACE_EVENT_FIELD + +#pragma push_macro("UE_TRACE_EVENT_END") +#undef UE_TRACE_EVENT_END + +#pragma push_macro("UE_TRACE_LOG") +#undef UE_TRACE_LOG + +#pragma push_macro("UE_TRACE_LOG_SCOPED") +#undef UE_TRACE_LOG_SCOPED + +#pragma push_macro("UE_TRACE_LOG_SCOPED_T") +#undef UE_TRACE_LOG_SCOPED_T + +#pragma push_macro("UE_TRACE_CHANNEL") +#undef UE_TRACE_CHANNEL + +#pragma push_macro("UE_TRACE_CHANNEL_EXTERN") +#undef UE_TRACE_CHANNEL_EXTERN + +#pragma push_macro("UE_TRACE_CHANNEL_MODULE_EXTERN") +#undef UE_TRACE_CHANNEL_MODULE_EXTERN + +#pragma push_macro("UE_TRACE_CHANNEL_DEFINE") +#undef UE_TRACE_CHANNEL_DEFINE + +#pragma push_macro("UE_TRACE_CHANNELEXPR_IS_ENABLED") +#undef UE_TRACE_CHANNELEXPR_IS_ENABLED + +#pragma push_macro("TRACE_PRIVATE_FIELD") +#undef TRACE_PRIVATE_FIELD + +#pragma push_macro("TRACE_PRIVATE_CHANNEL_DECLARE") +#undef TRACE_PRIVATE_CHANNEL_DECLARE + +#pragma push_macro("TRACE_PRIVATE_CHANNEL_IMPL") +#undef TRACE_PRIVATE_CHANNEL_IMPL + +#pragma push_macro("TRACE_PRIVATE_CHANNEL") +#undef TRACE_PRIVATE_CHANNEL + +#pragma push_macro("TRACE_PRIVATE_CHANNEL_MODULE_EXTERN") +#undef TRACE_PRIVATE_CHANNEL_MODULE_EXTERN + +#pragma push_macro("TRACE_PRIVATE_CHANNEL_DEFINE") +#undef TRACE_PRIVATE_CHANNEL_DEFINE + +#pragma push_macro("TRACE_PRIVATE_CHANNEL_EXTERN") +#undef TRACE_PRIVATE_CHANNEL_EXTERN + +#pragma push_macro("TRACE_PRIVATE_CHANNELEXPR_IS_ENABLED") +#undef TRACE_PRIVATE_CHANNELEXPR_IS_ENABLED + +#pragma push_macro("TRACE_PRIVATE_EVENT_DEFINE") +#undef TRACE_PRIVATE_EVENT_DEFINE + +#pragma push_macro("TRACE_PRIVATE_EVENT_BEGIN") +#undef TRACE_PRIVATE_EVENT_BEGIN + +#pragma push_macro("TRACE_PRIVATE_EVENT_BEGIN_EXTERN") +#undef TRACE_PRIVATE_EVENT_BEGIN_EXTERN + +#pragma push_macro("TRACE_PRIVATE_EVENT_BEGIN_IMPL") +#undef TRACE_PRIVATE_EVENT_BEGIN_IMPL + +#pragma push_macro("TRACE_PRIVATE_EVENT_FIELD") +#undef TRACE_PRIVATE_EVENT_FIELD + +#pragma push_macro("TRACE_PRIVATE_EVENT_END") +#undef TRACE_PRIVATE_EVENT_END + +#pragma push_macro("TRACE_PRIVATE_LOG_PRELUDE") +#undef TRACE_PRIVATE_LOG_PRELUDE + +#pragma push_macro("TRACE_PRIVATE_LOG_EPILOG") +#undef TRACE_PRIVATE_LOG_EPILOG + +#pragma push_macro("TRACE_PRIVATE_LOG") +#undef TRACE_PRIVATE_LOG + +#pragma push_macro("TRACE_PRIVATE_LOG_SCOPED") +#undef TRACE_PRIVATE_LOG_SCOPED + +#pragma push_macro("TRACE_PRIVATE_LOG_SCOPED_T") +#undef TRACE_PRIVATE_LOG_SCOPED_T + +#pragma push_macro("IMPLEMENT_TYPED_UMG_LIST") +#undef IMPLEMENT_TYPED_UMG_LIST + +#pragma push_macro("BIND_UOBJECT_ATTRIBUTE") +#undef BIND_UOBJECT_ATTRIBUTE + +#pragma push_macro("BIND_UOBJECT_DELEGATE") +#undef BIND_UOBJECT_DELEGATE + +#pragma push_macro("OPTIONAL_BINDING") +#undef OPTIONAL_BINDING + +#pragma push_macro("PROPERTY_BINDING") +#undef PROPERTY_BINDING + +#pragma push_macro("BITFIELD_PROPERTY_BINDING") +#undef BITFIELD_PROPERTY_BINDING + +#pragma push_macro("PROPERTY_BINDING_IMPLEMENTATION") +#undef PROPERTY_BINDING_IMPLEMENTATION + +#pragma push_macro("GAME_SAFE_OPTIONAL_BINDING") +#undef GAME_SAFE_OPTIONAL_BINDING + +#pragma push_macro("GAME_SAFE_BINDING_IMPLEMENTATION") +#undef GAME_SAFE_BINDING_IMPLEMENTATION + +#pragma push_macro("OPTIONAL_BINDING_CONVERT") +#undef OPTIONAL_BINDING_CONVERT + +#pragma push_macro("UA_SYSTEM_ERROR") +#undef UA_SYSTEM_ERROR + +#pragma push_macro("SOUND_CONVERT_CHECK") +#undef SOUND_CONVERT_CHECK + +#pragma push_macro("DEBUG_AUDIO_CHECK_AUDIO_THREAD") +#undef DEBUG_AUDIO_CHECK_AUDIO_THREAD + +#pragma push_macro("DEBUG_AUDIO_CHECK_MAIN_THREAD") +#undef DEBUG_AUDIO_CHECK_MAIN_THREAD + +#pragma push_macro("DEBUG_AUDIO_CHECK") +#undef DEBUG_AUDIO_CHECK + +#pragma push_macro("DEBUG_AUDIO_CHECK_MSG") +#undef DEBUG_AUDIO_CHECK_MSG + +#pragma push_macro("AUDIO_VOICE_CHECK_ERROR") +#undef AUDIO_VOICE_CHECK_ERROR + +#pragma push_macro("AUDIO_VOICE_CHECK_SUSPEND") +#undef AUDIO_VOICE_CHECK_SUSPEND + +#pragma push_macro("VOICE_CHECK_INITIALIZATION") +#undef VOICE_CHECK_INITIALIZATION + +#pragma push_macro("UA_DEVICE_PLATFORM_ERROR") +#undef UA_DEVICE_PLATFORM_ERROR + +#pragma push_macro("AU_DEVICE_PARAM_ERROR") +#undef AU_DEVICE_PARAM_ERROR + +#pragma push_macro("AU_DEVICE_WARNING") +#undef AU_DEVICE_WARNING + +#pragma push_macro("VectorIntShuffle") +#undef VectorIntShuffle + +#pragma push_macro("VK_DYNAMICAPI_TO_VULKANRHI") +#undef VK_DYNAMICAPI_TO_VULKANRHI + +#pragma push_macro("VULKAN_REPORT_LOG") +#undef VULKAN_REPORT_LOG + +#pragma push_macro("VKSWITCHCASE") +#undef VKSWITCHCASE + +#pragma push_macro("AppendBitFieldName") +#undef AppendBitFieldName + +#pragma push_macro("VULKAN_SET_DEBUG_NAME") +#undef VULKAN_SET_DEBUG_NAME + +#pragma push_macro("VERIFYVULKANRESULT_INIT") +#undef VERIFYVULKANRESULT_INIT + +#pragma push_macro("LLM_SCOPE_VULKAN") +#undef LLM_SCOPE_VULKAN + +#pragma push_macro("LLM_PLATFORM_SCOPE_VULKAN") +#undef LLM_PLATFORM_SCOPE_VULKAN + +#pragma push_macro("LLM_TRACK_VULKAN_HIGH_LEVEL_ALLOC") +#undef LLM_TRACK_VULKAN_HIGH_LEVEL_ALLOC + +#pragma push_macro("LLM_TRACK_VULKAN_HIGH_LEVEL_FREE") +#undef LLM_TRACK_VULKAN_HIGH_LEVEL_FREE + +#pragma push_macro("LLM_TRACK_VULKAN_SPARE_MEMORY_GPU") +#undef LLM_TRACK_VULKAN_SPARE_MEMORY_GPU + +#pragma push_macro("ENUM_VK_ENTRYPOINTS_INSTANCE") +#undef ENUM_VK_ENTRYPOINTS_INSTANCE + +#pragma push_macro("ENUM_VK_ENTRYPOINTS_SURFACE_INSTANCE") +#undef ENUM_VK_ENTRYPOINTS_SURFACE_INSTANCE + +#pragma push_macro("ENUM_VK_ENTRYPOINTS_BASE") +#undef ENUM_VK_ENTRYPOINTS_BASE + +#pragma push_macro("ENUM_VK_ENTRYPOINTS_OPTIONAL_BASE") +#undef ENUM_VK_ENTRYPOINTS_OPTIONAL_BASE + +#pragma push_macro("ENUM_VK_ENTRYPOINTS_OPTIONAL_INSTANCE") +#undef ENUM_VK_ENTRYPOINTS_OPTIONAL_INSTANCE + +#pragma push_macro("ENUM_VK_ENTRYPOINTS_ALL") +#undef ENUM_VK_ENTRYPOINTS_ALL + +#pragma push_macro("DECLARE_VK_ENTRYPOINTS") +#undef DECLARE_VK_ENTRYPOINTS + +#pragma push_macro("VULKAN_LOGMEMORY") +#undef VULKAN_LOGMEMORY + +#pragma push_macro("VULKAN_FILL_TRACK_INFO") +#undef VULKAN_FILL_TRACK_INFO + +#pragma push_macro("VULKAN_FREE_TRACK_INFO") +#undef VULKAN_FREE_TRACK_INFO + +#pragma push_macro("VULKAN_TRACK_STRING") +#undef VULKAN_TRACK_STRING + +#pragma push_macro("VKSWITCH") +#undef VKSWITCH + +#pragma push_macro("LRUPRINT") +#undef LRUPRINT + +#pragma push_macro("LRUPRINT_DEBUG") +#undef LRUPRINT_DEBUG + +#pragma push_macro("VKERRORCASE") +#undef VKERRORCASE + +#pragma push_macro("DEFINE_VK_ENTRYPOINTS") +#undef DEFINE_VK_ENTRYPOINTS + +#pragma push_macro("CHECK_VK_ENTRYPOINTS") +#undef CHECK_VK_ENTRYPOINTS + +#pragma push_macro("GET_VK_ENTRYPOINTS") +#undef GET_VK_ENTRYPOINTS + +#pragma push_macro("GETINSTANCE_VK_ENTRYPOINTS") +#undef GETINSTANCE_VK_ENTRYPOINTS + +#pragma push_macro("CLEAR_VK_ENTRYPOINTS") +#undef CLEAR_VK_ENTRYPOINTS + +#pragma push_macro("ENUM_VK_ENTRYPOINTS_PLATFORM_BASE") +#undef ENUM_VK_ENTRYPOINTS_PLATFORM_BASE + +#pragma push_macro("ENUM_VK_ENTRYPOINTS_PLATFORM_INSTANCE") +#undef ENUM_VK_ENTRYPOINTS_PLATFORM_INSTANCE + +#pragma push_macro("ENUM_VK_ENTRYPOINTS_OPTIONAL_PLATFORM_INSTANCE") +#undef ENUM_VK_ENTRYPOINTS_OPTIONAL_PLATFORM_INSTANCE + +#pragma push_macro("VULKAN_SIGNAL_UNIMPLEMENTED") +#undef VULKAN_SIGNAL_UNIMPLEMENTED + +#pragma push_macro("VULKAN_TRACK_OBJECT_CREATE") +#undef VULKAN_TRACK_OBJECT_CREATE + +#pragma push_macro("VULKAN_TRACK_OBJECT_DELETE") +#undef VULKAN_TRACK_OBJECT_DELETE + +#pragma push_macro("VERIFYVULKANRESULT") +#undef VERIFYVULKANRESULT + +#pragma push_macro("VERIFYVULKANRESULT_EXPANDED") +#undef VERIFYVULKANRESULT_EXPANDED + +#pragma push_macro("XAUDIO2_GOTO_CLEANUP_ON_FAIL") +#undef XAUDIO2_GOTO_CLEANUP_ON_FAIL + +#pragma push_macro("XAUDIO2_RETURN_ON_FAIL") +#undef XAUDIO2_RETURN_ON_FAIL + +#pragma push_macro("NVAFTERMATH_ON_ERROR") +#undef NVAFTERMATH_ON_ERROR + +#pragma push_macro("D3D11_STATE_CACHE_VERIFY") +#undef D3D11_STATE_CACHE_VERIFY + +#pragma push_macro("D3D11_STATE_CACHE_VERIFY_PRE") +#undef D3D11_STATE_CACHE_VERIFY_PRE + +#pragma push_macro("D3D11_STATE_CACHE_VERIFY_POST") +#undef D3D11_STATE_CACHE_VERIFY_POST + +#pragma push_macro("CACHE_NV_AFTERMATH_ENABLED") +#undef CACHE_NV_AFTERMATH_ENABLED + +#pragma push_macro("START_NV_AFTERMATH") +#undef START_NV_AFTERMATH + +#pragma push_macro("STOP_NV_AFTERMATH") +#undef STOP_NV_AFTERMATH + +#pragma push_macro("VERIFYD3D11RESULT_EX") +#undef VERIFYD3D11RESULT_EX + +#pragma push_macro("VERIFYD3D11RESULT") +#undef VERIFYD3D11RESULT + +#pragma push_macro("VERIFYD3D11RESULT_NOEXIT") +#undef VERIFYD3D11RESULT_NOEXIT + +#pragma push_macro("VERIFYD3D11SHADERRESULT") +#undef VERIFYD3D11SHADERRESULT + +#pragma push_macro("VERIFYD3D11CREATETEXTURERESULT") +#undef VERIFYD3D11CREATETEXTURERESULT + +#pragma push_macro("VERIFYD3D11RESIZEVIEWPORTRESULT") +#undef VERIFYD3D11RESIZEVIEWPORTRESULT + +#pragma push_macro("CLEANUP_ON_FAIL") +#undef CLEANUP_ON_FAIL + +#pragma push_macro("RETURN_FALSE_ON_FAIL") +#undef RETURN_FALSE_ON_FAIL diff --git a/LibCarla/source/compiler/enable-ue4-macros.h b/LibCarla/source/compiler/enable-ue4-macros.h index 4d6a958f5..43bd1dbf9 100644 --- a/LibCarla/source/compiler/enable-ue4-macros.h +++ b/LibCarla/source/compiler/enable-ue4-macros.h @@ -15,8 +15,2240 @@ # pragma clang diagnostic pop #endif +#pragma pop_macro("GET_AI_CONFIG_VAR") +#pragma pop_macro("BT_VLOG") +#pragma pop_macro("BT_SEARCHLOG") +#pragma pop_macro("EQSHEADERLOG") +#pragma pop_macro("MEM_STAT_UPDATE_WRAPPER") +#pragma pop_macro("GET_STRUCT_NAME_CHECKED") +#pragma pop_macro("PRINT_TABLE_ROW") +#pragma pop_macro("SIGHT_LOG_SEGMENT") +#pragma pop_macro("SIGHT_LOG_LOCATION") +#pragma pop_macro("ANALYTICS_FLUSH_TRACKING_BEGIN") +#pragma pop_macro("ANALYTICS_FLUSH_TRACKING_END") +#pragma pop_macro("OCULUS_DEVICE_LOOP") +#pragma pop_macro("OPENSLES_RETURN_ON_FAIL") +#pragma pop_macro("OPENSLES_CHECK_ON_FAIL") +#pragma pop_macro("OPENSLES_LOG_ON_FAIL") +#pragma pop_macro("CASE_ENUM_TO_TEXT") +#pragma pop_macro("TRACE_BLENDSPACE_PLAYER") +#pragma pop_macro("SEQUENCER_INSTANCE_PLAYER_TYPE") +#pragma pop_macro("IMAGE_BRUSH") +#pragma pop_macro("BOX_BRUSH") +#pragma pop_macro("BORDER_BRUSH") +#pragma pop_macro("DEFAULT_FONT") +#pragma pop_macro("INTERNAL_DECORATOR") +#pragma pop_macro("LLM_SCOPE_METAL") +#pragma pop_macro("LLM_PLATFORM_SCOPE_METAL") +#pragma pop_macro("METAL_DEBUG_OPTION") +#pragma pop_macro("METAL_DEBUG_ONLY") +#pragma pop_macro("METAL_DEBUG_LAYER") +#pragma pop_macro("METAL_GPUPROFILE") +#pragma pop_macro("UNREAL_TO_METAL_BUFFER_INDEX") +#pragma pop_macro("METAL_TO_UNREAL_BUFFER_INDEX") +#pragma pop_macro("METAL_FATAL_ERROR") +#pragma pop_macro("METAL_FATAL_ASSERT") +#pragma pop_macro("METAL_IGNORED") +#pragma pop_macro("NOT_SUPPORTED") +#pragma pop_macro("METAL_INC_DWORD_STAT_BY") +#pragma pop_macro("CHECK_JNI_RESULT") +#pragma pop_macro("SET_PRESSED") +#pragma pop_macro("ADD_WINDOWS_MESSAGE_STRING") +#pragma pop_macro("ADD_IMN_STRING") +#pragma pop_macro("ADD_IMR_STRING") +#pragma pop_macro("IsTouchEvent") +#pragma pop_macro("ADDTOMAP") +#pragma pop_macro("UE_PACKAGEREADER_CORRUPTPACKAGE_WARNING") +#pragma pop_macro("MUTEX_INITIALIZE") +#pragma pop_macro("MUTEX_DESTROY") +#pragma pop_macro("MUTEX_LOCK") +#pragma pop_macro("MUTEX_UNLOCK") +#pragma pop_macro("SAFE_RELEASE") +#pragma pop_macro("AUDIO_MIXER_DEBUG_LOG") +#pragma pop_macro("AUDIO_PLATFORM_ERROR") +#pragma pop_macro("AUDIO_MIXER_CHECK") +#pragma pop_macro("AUDIO_MIXER_CHECK_GAME_THREAD") +#pragma pop_macro("AUDIO_MIXER_CHECK_AUDIO_PLAT_THREAD") +#pragma pop_macro("DEFINE_AR_COMPONENT_DEBUG_MODE") +#pragma pop_macro("DEFINE_AR_COMPONENT_VIRTUALS") +#pragma pop_macro("DEFINE_AR_SI_DELEGATE_FUNCS") +#pragma pop_macro("DEFINE_AR_BPLIB_DELEGATE_FUNCS") +#pragma pop_macro("DECLARE_AR_SI_DELEGATE_FUNCS") +#pragma pop_macro("DEFINE_AR_DELEGATE_BASE") +#pragma pop_macro("DEFINE_AR_DELEGATE_ONE_PARAM") +#pragma pop_macro("CHECK_HR") +#pragma pop_macro("CHECK_HR_DEFAULT") +#pragma pop_macro("CHECK_HR_COM") +#pragma pop_macro("CHECK_HR_VOID") +#pragma pop_macro("CHECK_AMF_RET") +#pragma pop_macro("CHECK_AMF_NORET") +#pragma pop_macro("CHECK_NV_RES") +#pragma pop_macro("NV_RESULT") +#pragma pop_macro("B") +#pragma pop_macro("AMF_DECLARE_IID") +#pragma pop_macro("AMF_MACRO_STRING2") +#pragma pop_macro("AMF_MACRO_STRING") +#pragma pop_macro("AMF_TODO") +#pragma pop_macro("AMF_ALIGN") +#pragma pop_macro("amf_countof") +#pragma pop_macro("AMF_MIN") +#pragma pop_macro("AMF_MAX") +#pragma pop_macro("AMF_ASSIGN_PROPERTY_DATA") +#pragma pop_macro("AMF_QUERY_INTERFACE") +#pragma pop_macro("AMF_ASSIGN_PROPERTY_INTERFACE") +#pragma pop_macro("AMF_GET_PROPERTY_INTERFACE") +#pragma pop_macro("AMF_ASSIGN_PROPERTY_TYPE") +#pragma pop_macro("AMF_ASSIGN_PROPERTY_INT64") +#pragma pop_macro("AMF_ASSIGN_PROPERTY_DOUBLE") +#pragma pop_macro("AMF_ASSIGN_PROPERTY_BOOL") +#pragma pop_macro("AMF_ASSIGN_PROPERTY_RECT") +#pragma pop_macro("AMF_ASSIGN_PROPERTY_SIZE") +#pragma pop_macro("AMF_ASSIGN_PROPERTY_POINT") +#pragma pop_macro("AMF_ASSIGN_PROPERTY_RATE") +#pragma pop_macro("AMF_ASSIGN_PROPERTY_RATIO") +#pragma pop_macro("AMF_ASSIGN_PROPERTY_COLOR") +#pragma pop_macro("AMFVariantEmpty") +#pragma pop_macro("AMFVariantBool") +#pragma pop_macro("AMFVariantInt64") +#pragma pop_macro("AMFVariantDouble") +#pragma pop_macro("AMFVariantRect") +#pragma pop_macro("AMFVariantSize") +#pragma pop_macro("AMFVariantPoint") +#pragma pop_macro("AMFVariantRate") +#pragma pop_macro("AMFVariantRatio") +#pragma pop_macro("AMFVariantColor") +#pragma pop_macro("AMFVariantString") +#pragma pop_macro("AMFVariantWString") +#pragma pop_macro("AMFVariantInterface") +#pragma pop_macro("AMF_VARIANT_RETURN_IF_INVALID_POINTER") +#pragma pop_macro("AMFConvertTool") +#pragma pop_macro("AMF_MAKE_FULL_VERSION") +#pragma pop_macro("AMF_GET_MAJOR_VERSION") +#pragma pop_macro("AMF_GET_MINOR_VERSION") +#pragma pop_macro("AMF_GET_SUBMINOR_VERSION") +#pragma pop_macro("AMF_GET_BUILD_VERSION") +#pragma pop_macro("NVENCAPI_STRUCT_VERSION") +#pragma pop_macro("__lseek") +#pragma pop_macro("__pread") +#pragma pop_macro("__pwrite") +#pragma pop_macro("__ftruncate") +#pragma pop_macro("VK_MAKE_VERSION") +#pragma pop_macro("VK_VERSION_MAJOR") +#pragma pop_macro("VK_VERSION_MINOR") +#pragma pop_macro("VK_VERSION_PATCH") +#pragma pop_macro("VK_DEFINE_HANDLE") +#pragma pop_macro("SET_DWORD_STAT_BY_FNAME") +#pragma pop_macro("SET_FLOAT_STAT_BY_FNAME") +#pragma pop_macro("CSV_STAT_PTR") +#pragma pop_macro("CSV_CUSTOM_STAT_DEFINED_BY_PTR") +#pragma pop_macro("HANDLE_CASE") +#pragma pop_macro("KDBG_CODE") +#pragma pop_macro("APPSDBG_CODE") +#pragma pop_macro("TASKGRAPH_SCOPE_CYCLE_COUNTER") +#pragma pop_macro("likely") +#pragma pop_macro("unlikely") +#pragma pop_macro("ALLOC") +#pragma pop_macro("ALLOC_AND_ZERO") +#pragma pop_macro("FREEMEM") +#pragma pop_macro("MEM_INIT") +#pragma pop_macro("LZ4_STATIC_ASSERT") +#pragma pop_macro("MIN") +#pragma pop_macro("HASH_FUNCTION") +#pragma pop_macro("DELTANEXTMAXD") +#pragma pop_macro("DELTANEXTU16") +#pragma pop_macro("UPDATABLE") +#pragma pop_macro("SUBSTRINGTEST") +#pragma pop_macro("FP_TEXT_PASTE") +// #pragma pop_macro("WTEXT") +#pragma pop_macro("CASE") +#pragma pop_macro("LLM_TAG_NAME_ARRAY") +#pragma pop_macro("LLM_TAG_STAT_ARRAY") +#pragma pop_macro("LLM_TAG_STATGROUP_ARRAY") +#pragma pop_macro("bswap_32") +#pragma pop_macro("bswap_64") +#pragma pop_macro("uint32_in_expected_order") +#pragma pop_macro("uint64_in_expected_order") +#pragma pop_macro("LIKELY") +#pragma pop_macro("PERMUTE3") +#pragma pop_macro("DEF_GETPLURALFORM_CAST") +#pragma pop_macro("DEF_ASNUMBER_CAST") +#pragma pop_macro("DEF_ASNUMBER") +#pragma pop_macro("DEF_ASCURRENCY_CAST") +#pragma pop_macro("DEF_ASCURRENCY") +#pragma pop_macro("DEF_ASPERCENT_CAST") +#pragma pop_macro("DEF_ASPERCENT") +#pragma pop_macro("CONDITIONAL_CREATE_TEXT_HISTORY") +#pragma pop_macro("ENUM_CASE_FROM_STRING") +#pragma pop_macro("ENUM_CASE_TO_STRING") +#pragma pop_macro("WRITE_CUSTOM_OPTION") +#pragma pop_macro("READ_BOOL_OPTION") +#pragma pop_macro("READ_CUSTOM_OPTION") +#pragma pop_macro("TEXT_STRINGIFICATION_FUNC_MODIFY_BUFFER_AND_VALIDATE") +#pragma pop_macro("TEXT_STRINGIFICATION_PEEK_MARKER") +#pragma pop_macro("TEXT_STRINGIFICATION_PEEK_INSENSITIVE_MARKER") +#pragma pop_macro("TEXT_STRINGIFICATION_SKIP_MARKER") +#pragma pop_macro("TEXT_STRINGIFICATION_SKIP_INSENSITIVE_MARKER") +#pragma pop_macro("TEXT_STRINGIFICATION_SKIP_MARKER_LEN") +#pragma pop_macro("TEXT_STRINGIFICATION_SKIP_WHITESPACE") +#pragma pop_macro("TEXT_STRINGIFICATION_SKIP_WHITESPACE_TO_CHAR") +#pragma pop_macro("TEXT_STRINGIFICATION_SKIP_WHITESPACE_AND_CHAR") +#pragma pop_macro("TEXT_STRINGIFICATION_READ_NUMBER") +#pragma pop_macro("TEXT_STRINGIFICATION_READ_ALNUM") +#pragma pop_macro("TEXT_STRINGIFICATION_READ_QUOTED_STRING") +#pragma pop_macro("TEXT_STRINGIFICATION_READ_SCOPED_ENUM") +#pragma pop_macro("PLATFORM_MAC_MAKE_FOURCC") +#pragma pop_macro("MEMPRO_STATIC_ASSERT") +#pragma pop_macro("ENDIAN_TEST") +#pragma pop_macro("_T") +#pragma pop_macro("KEYLENGTH") +#pragma pop_macro("RKLENGTH") +#pragma pop_macro("NROUNDS") +#pragma pop_macro("GETU32") +#pragma pop_macro("PUTU32") +#pragma pop_macro("DEFINE_LOG_CATEGORY_HELPER") +#pragma pop_macro("ADD_64b_2_64b") +#pragma pop_macro("ADD_16b_2_64b") +#pragma pop_macro("MD5_F") +#pragma pop_macro("MD5_G") +#pragma pop_macro("MD5_H") +#pragma pop_macro("MD5_I") +#pragma pop_macro("ROTLEFT") +#pragma pop_macro("MD5_FF") +#pragma pop_macro("MD5_GG") +#pragma pop_macro("MD5_HH") +#pragma pop_macro("MD5_II") +#pragma pop_macro("ROL32") +#pragma pop_macro("SHABLK0") +#pragma pop_macro("SHABLK") +#pragma pop_macro("_R0") +#pragma pop_macro("_R1") +#pragma pop_macro("_R2") +#pragma pop_macro("_R3") +#pragma pop_macro("_R4") +#pragma pop_macro("GROWABLE_LOGF") +#pragma pop_macro("ABTEST_LOG") +#pragma pop_macro("CPUPROFILERTRACE_OUTPUTBEGINEVENT_PROLOGUE") +#pragma pop_macro("CPUPROFILERTRACE_OUTPUTBEGINEVENT_EPILOGUE") +#pragma pop_macro("STATS_HIERARCHICAL_TIMER_FUNC") +#pragma pop_macro("BENCHMARK") +#pragma pop_macro("TEST") +#pragma pop_macro("TEST_EX") +#pragma pop_macro("TEST_QUAT_ROTATE") +#pragma pop_macro("INTERP_WITH_RANGE") +#pragma pop_macro("TestUnixEquivalent") +#pragma pop_macro("TestYear") +#pragma pop_macro("TestMonth") +#pragma pop_macro("TestMonthOfYear") +#pragma pop_macro("TestDay") +#pragma pop_macro("TestHour") +#pragma pop_macro("TestMinute") +#pragma pop_macro("TestSecond") +#pragma pop_macro("TestMillisecond") +#pragma pop_macro("UE_LOG_UNIX_FILE") +#pragma pop_macro("REGISTER_NAME") +#pragma pop_macro("DECLARE_LOG_CATEGORY_EXTERN_HELPER") +#pragma pop_macro("SCOPED_BOOT_TIMING") +#pragma pop_macro("FOREACH_ENUM_EPIXELFORMAT") +#pragma pop_macro("PLATFORM_CODE_SECTION") +#pragma pop_macro("GCC_PACK") +#pragma pop_macro("GCC_ALIGN") +#pragma pop_macro("PLATFORM_BREAK") +#pragma pop_macro("UE_DEBUG_BREAK_IMPL") +#pragma pop_macro("_aligned_malloc") +#pragma pop_macro("_aligned_realloc") +#pragma pop_macro("_aligned_free") +// #pragma pop_macro("TEXT") +#pragma pop_macro("LLM_SCOPE_APPLE") +#pragma pop_macro("LLM_PLATFORM_SCOPE_APPLE") +#pragma pop_macro("APPLE_PLATFORM_OBJECT_ALLOC_OVERRIDES") +#pragma pop_macro("checkThreadGraph") +#pragma pop_macro("CA_SUPPRESS") +#pragma pop_macro("CA_ASSUME") +#pragma pop_macro("CA_CONSTANT_IF") +#pragma pop_macro("TSAN_BEFORE") +#pragma pop_macro("TSAN_AFTER") +#pragma pop_macro("TSAN_ATOMIC") +#pragma pop_macro("DEPRECATED") +#pragma pop_macro("EMIT_CUSTOM_WARNING_AT_LINE") +#pragma pop_macro("LZ4_QUOTE") +#pragma pop_macro("LZ4_EXPAND_AND_QUOTE") +#pragma pop_macro("LZ4_COMPRESSBOUND") +#pragma pop_macro("LZ4_DECODER_RING_BUFFER_SIZE") +#pragma pop_macro("LZ4_DECOMPRESS_INPLACE_MARGIN") +#pragma pop_macro("LZ4_DECOMPRESS_INPLACE_BUFFER_SIZE") +#pragma pop_macro("LZ4_COMPRESS_INPLACE_BUFFER_SIZE") +#pragma pop_macro("checkLockFreePointerList") +#pragma pop_macro("ExchangeB") +// #pragma pop_macro("TCHAR_TO_ANSI") +// #pragma pop_macro("ANSI_TO_TCHAR") +// #pragma pop_macro("TCHAR_TO_UTF8") +// #pragma pop_macro("UTF8_TO_TCHAR") +// #pragma pop_macro("TCHAR_TO_UTF16") +// #pragma pop_macro("UTF16_TO_TCHAR") +// #pragma pop_macro("TCHAR_TO_UTF32") +// #pragma pop_macro("UTF32_TO_TCHAR") +// #pragma pop_macro("TCHAR_TO_WCHAR") +// #pragma pop_macro("WCHAR_TO_TCHAR") +#pragma pop_macro("FUNC_CONCAT") +#pragma pop_macro("FUNC_DECLARE_DELEGATE") +#pragma pop_macro("FUNC_DECLARE_MULTICAST_DELEGATE") +#pragma pop_macro("FUNC_DECLARE_EVENT") +#pragma pop_macro("DECLARE_DERIVED_EVENT") +#pragma pop_macro("FUNC_DECLARE_DYNAMIC_DELEGATE") +#pragma pop_macro("FUNC_DECLARE_DYNAMIC_DELEGATE_RETVAL") +#pragma pop_macro("FUNC_DECLARE_DYNAMIC_MULTICAST_DELEGATE") +#pragma pop_macro("STATIC_FUNCTION_FNAME") +#pragma pop_macro("BindDynamic") +#pragma pop_macro("AddDynamic") +#pragma pop_macro("AddUniqueDynamic") +#pragma pop_macro("RemoveDynamic") +#pragma pop_macro("IsAlreadyBound") +#pragma pop_macro("DECLARE_DELEGATE") +#pragma pop_macro("DECLARE_MULTICAST_DELEGATE") +#pragma pop_macro("DECLARE_EVENT") +#pragma pop_macro("DECLARE_DYNAMIC_DELEGATE") +#pragma pop_macro("DECLARE_DYNAMIC_MULTICAST_DELEGATE") +#pragma pop_macro("DECLARE_DELEGATE_RetVal") +#pragma pop_macro("DECLARE_DYNAMIC_DELEGATE_RetVal") +#pragma pop_macro("DECLARE_DELEGATE_OneParam") +#pragma pop_macro("DECLARE_MULTICAST_DELEGATE_OneParam") +#pragma pop_macro("DECLARE_EVENT_OneParam") +#pragma pop_macro("DECLARE_DYNAMIC_DELEGATE_OneParam") +#pragma pop_macro("DECLARE_DYNAMIC_MULTICAST_DELEGATE_OneParam") +#pragma pop_macro("DECLARE_DELEGATE_RetVal_OneParam") +#pragma pop_macro("DECLARE_DYNAMIC_DELEGATE_RetVal_OneParam") +#pragma pop_macro("DECLARE_DELEGATE_TwoParams") +#pragma pop_macro("DECLARE_MULTICAST_DELEGATE_TwoParams") +#pragma pop_macro("DECLARE_EVENT_TwoParams") +#pragma pop_macro("DECLARE_DYNAMIC_DELEGATE_TwoParams") +#pragma pop_macro("DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams") +#pragma pop_macro("DECLARE_DELEGATE_RetVal_TwoParams") +#pragma pop_macro("DECLARE_DYNAMIC_DELEGATE_RetVal_TwoParams") +#pragma pop_macro("DECLARE_DELEGATE_ThreeParams") +#pragma pop_macro("DECLARE_MULTICAST_DELEGATE_ThreeParams") +#pragma pop_macro("DECLARE_EVENT_ThreeParams") +#pragma pop_macro("DECLARE_DYNAMIC_DELEGATE_ThreeParams") +#pragma pop_macro("DECLARE_DYNAMIC_MULTICAST_DELEGATE_ThreeParams") +#pragma pop_macro("DECLARE_DELEGATE_RetVal_ThreeParams") +#pragma pop_macro("DECLARE_DYNAMIC_DELEGATE_RetVal_ThreeParams") +#pragma pop_macro("DECLARE_DELEGATE_FourParams") +#pragma pop_macro("DECLARE_MULTICAST_DELEGATE_FourParams") +#pragma pop_macro("DECLARE_EVENT_FourParams") +#pragma pop_macro("DECLARE_DYNAMIC_DELEGATE_FourParams") +#pragma pop_macro("DECLARE_DYNAMIC_MULTICAST_DELEGATE_FourParams") +#pragma pop_macro("DECLARE_DELEGATE_RetVal_FourParams") +#pragma pop_macro("DECLARE_DYNAMIC_DELEGATE_RetVal_FourParams") +#pragma pop_macro("DECLARE_DELEGATE_FiveParams") +#pragma pop_macro("DECLARE_MULTICAST_DELEGATE_FiveParams") +#pragma pop_macro("DECLARE_EVENT_FiveParams") +#pragma pop_macro("DECLARE_DYNAMIC_DELEGATE_FiveParams") +#pragma pop_macro("DECLARE_DYNAMIC_MULTICAST_DELEGATE_FiveParams") +#pragma pop_macro("DECLARE_DELEGATE_RetVal_FiveParams") +#pragma pop_macro("DECLARE_DYNAMIC_DELEGATE_RetVal_FiveParams") +#pragma pop_macro("DECLARE_DELEGATE_SixParams") +#pragma pop_macro("DECLARE_MULTICAST_DELEGATE_SixParams") +#pragma pop_macro("DECLARE_EVENT_SixParams") +#pragma pop_macro("DECLARE_DYNAMIC_DELEGATE_SixParams") +#pragma pop_macro("DECLARE_DYNAMIC_MULTICAST_DELEGATE_SixParams") +#pragma pop_macro("DECLARE_DELEGATE_RetVal_SixParams") +#pragma pop_macro("DECLARE_DYNAMIC_DELEGATE_RetVal_SixParams") +#pragma pop_macro("DECLARE_DELEGATE_SevenParams") +#pragma pop_macro("DECLARE_MULTICAST_DELEGATE_SevenParams") +#pragma pop_macro("DECLARE_EVENT_SevenParams") +#pragma pop_macro("DECLARE_DYNAMIC_DELEGATE_SevenParams") +#pragma pop_macro("DECLARE_DYNAMIC_MULTICAST_DELEGATE_SevenParams") +#pragma pop_macro("DECLARE_DELEGATE_RetVal_SevenParams") +#pragma pop_macro("DECLARE_DYNAMIC_DELEGATE_RetVal_SevenParams") +#pragma pop_macro("DECLARE_DELEGATE_EightParams") +#pragma pop_macro("DECLARE_MULTICAST_DELEGATE_EightParams") +#pragma pop_macro("DECLARE_EVENT_EightParams") +#pragma pop_macro("DECLARE_DYNAMIC_DELEGATE_EightParams") +#pragma pop_macro("DECLARE_DYNAMIC_MULTICAST_DELEGATE_EightParams") +#pragma pop_macro("DECLARE_DELEGATE_RetVal_EightParams") +#pragma pop_macro("DECLARE_DYNAMIC_DELEGATE_RetVal_EightParams") +#pragma pop_macro("DECLARE_DELEGATE_NineParams") +#pragma pop_macro("DECLARE_MULTICAST_DELEGATE_NineParams") +#pragma pop_macro("DECLARE_EVENT_NineParams") +#pragma pop_macro("DECLARE_DYNAMIC_DELEGATE_NineParams") +#pragma pop_macro("DECLARE_DYNAMIC_MULTICAST_DELEGATE_NineParams") +#pragma pop_macro("DECLARE_DELEGATE_RetVal_NineParams") +#pragma pop_macro("DECLARE_DYNAMIC_DELEGATE_RetVal_NineParams") +#pragma pop_macro("CHECK_CONCURRENT_ACCESS") +#pragma pop_macro("FRAMEPRO_FRAME_START") +#pragma pop_macro("FRAMEPRO_SHUTDOWN") +#pragma pop_macro("FRAMEPRO_SET_PORT") +#pragma pop_macro("FRAMEPRO_SET_SESSION_INFO") +#pragma pop_macro("FRAMEPRO_SET_ALLOCATOR") +#pragma pop_macro("FRAMEPRO_SET_THREAD_NAME") +#pragma pop_macro("FRAMEPRO_THREAD_ORDER") +#pragma pop_macro("FRAMEPRO_REGISTER_STRING") +#pragma pop_macro("FRAMEPRO_START_RECORDING") +#pragma pop_macro("FRAMEPRO_STOP_RECORDING") +#pragma pop_macro("FRAMEPRO_REGISTER_CONNECTION_CHANGED_CALLBACK") +#pragma pop_macro("FRAMEPRO_UNREGISTER_CONNECTION_CHANGED_CALLBACK") +#pragma pop_macro("FRAMEPRO_SET_THREAD_PRIORITY") +#pragma pop_macro("FRAMEPRO_SET_THREAD_AFFINITY") +#pragma pop_macro("FRAMEPRO_BLOCK_SOCKETS") +#pragma pop_macro("FRAMEPRO_UNBLOCK_SOCKETS") +#pragma pop_macro("FRAMEPRO_CLEANUP_THREAD") +#pragma pop_macro("FRAMEPRO_THREAD_SCOPE") +#pragma pop_macro("FRAMEPRO_LOG") +#pragma pop_macro("FRAMEPRO_COLOUR") +#pragma pop_macro("FRAMEPRO_SET_CONDITIONAL_SCOPE_MIN_TIME") +#pragma pop_macro("FRAMEPRO_SCOPE") +#pragma pop_macro("FRAMEPRO_NAMED_SCOPE") +#pragma pop_macro("FRAMEPRO_NAMED_SCOPE_W") +#pragma pop_macro("FRAMEPRO_ID_SCOPE") +#pragma pop_macro("FRAMEPRO_DYNAMIC_SCOPE") +#pragma pop_macro("FRAMEPRO_CONDITIONAL_SCOPE") +#pragma pop_macro("FRAMEPRO_CONDITIONAL_ID_SCOPE") +#pragma pop_macro("FRAMEPRO_CONDITIONAL_NAMED_SCOPE") +#pragma pop_macro("FRAMEPRO_CONDITIONAL_NAMED_SCOPE_W") +#pragma pop_macro("FRAMEPRO_CONDITIONAL_BOOL_SCOPE") +#pragma pop_macro("FRAMEPRO_CONDITIONAL_BOOL_ID_SCOPE") +#pragma pop_macro("FRAMEPRO_CONDITIONAL_BOOL_NAMED_SCOPE") +#pragma pop_macro("FRAMEPRO_CONDITIONAL_BOOL_NAMED_SCOPE_W") +#pragma pop_macro("FRAMEPRO_START_NAMED_SCOPE") +#pragma pop_macro("FRAMEPRO_STOP_NAMED_SCOPE") +#pragma pop_macro("FRAMEPRO_CONDITIONAL_START_SCOPE") +#pragma pop_macro("FRAMEPRO_CONDITIONAL_STOP_NAMED_SCOPE") +#pragma pop_macro("FRAMEPRO_CONDITIONAL_STOP_DYNAMIC_SCOPE") +#pragma pop_macro("FRAMEPRO_CONDITIONAL_PARENT_SCOPE") +#pragma pop_macro("FRAMEPRO_SET_SCOPE_COLOUR") +#pragma pop_macro("FRAMEPRO_IDLE_SCOPE") +#pragma pop_macro("FRAMEPRO_IDLE_NAMED_SCOPE") +#pragma pop_macro("FRAMEPRO_IDLE_NAMED_SCOPE_W") +#pragma pop_macro("FRAMEPRO_IDLE_ID_SCOPE") +#pragma pop_macro("FRAMEPRO_IDLE_DYNAMIC_SCOPE") +#pragma pop_macro("FRAMEPRO_IDLE_CONDITIONAL_SCOPE") +#pragma pop_macro("FRAMEPRO_IDLE_CONDITIONAL_ID_SCOPE") +#pragma pop_macro("FRAMEPRO_IDLE_CONDITIONAL_NAMED_SCOPE") +#pragma pop_macro("FRAMEPRO_IDLE_CONDITIONAL_NAMED_SCOPE_W") +#pragma pop_macro("FRAMEPRO_IDLE_START_NAMED_SCOPE") +#pragma pop_macro("FRAMEPRO_IDLE_STOP_NAMED_SCOPE") +#pragma pop_macro("FRAMEPRO_IDLE_CONDITIONAL_START_SCOPE") +#pragma pop_macro("FRAMEPRO_IDLE_CONDITIONAL_STOP_NAMED_SCOPE") +#pragma pop_macro("FRAMEPRO_IDLE_CONDITIONAL_STOP_DYNAMIC_SCOPE") +#pragma pop_macro("FRAMEPRO_CUSTOM_STAT") +#pragma pop_macro("FRAMEPRO_DYNAMIC_CUSTOM_STAT") +#pragma pop_macro("FRAMEPRO_SCOPE_CUSTOM_STAT") +#pragma pop_macro("FRAMEPRO_SET_CUSTOM_STAT_GRAPH") +#pragma pop_macro("FRAMEPRO_SET_CUSTOM_STAT_UNIT") +#pragma pop_macro("FRAMEPRO_SET_CUSTOM_STAT_COLOUR") +#pragma pop_macro("FRAMEPRO_HIRES_SCOPE") +#pragma pop_macro("FRAMEPRO_DECL_GLOBAL_HIRES_TIMER") +#pragma pop_macro("FRAMEPRO_GLOBAL_HIRES_SCOPE") +#pragma pop_macro("FRAMEPRO_EVENT") +#pragma pop_macro("FRAMEPRO_WAIT_EVENT_SCOPE") +#pragma pop_macro("FRAMEPRO_TRIGGER_WAIT_EVENT") +#pragma pop_macro("FRAMEPRO_STRINGIZE") +#pragma pop_macro("FRAMEPRO_STRINGIZE2") +#pragma pop_macro("FRAMEPRO_JOIN") +#pragma pop_macro("FRAMEPRO_JOIN2") +#pragma pop_macro("FRAMEPRO_UNIQUE") +#pragma pop_macro("FRAMEPRO_WIDESTR") +#pragma pop_macro("FRAMEPRO_WIDESTR2") +#pragma pop_macro("FRAMEPRO_ASSERT") +#pragma pop_macro("FRAMEPRO_UNREFERENCED") +#pragma pop_macro("FRAMEPRO_GET_CLOCK_COUNT") +#pragma pop_macro("MULTI_STATEMENT") +#pragma pop_macro("FRAMEPRO_ALIGN_STRUCT") +#pragma pop_macro("EMIT_CUSTOM_WARNING") +#pragma pop_macro("DEPRECATED_MACRO") +#pragma pop_macro("PLATFORM_MEMORY_SIZE_BUCKET_LIST") +#pragma pop_macro("PLATFORM_MEMORY_SIZE_BUCKET_ENUM") +#pragma pop_macro("PLATFORM_MEMORY_SIZE_BUCKET_LEXTOSTRING") +#pragma pop_macro("FMemory_Alloca") +#pragma pop_macro("UE_DEBUG_BREAK") +#pragma pop_macro("cvarCheckCode") +#pragma pop_macro("FILE_LOG") +#pragma pop_macro("DECLARE_LLM_MEMORY_STAT") +#pragma pop_macro("DECLARE_LLM_MEMORY_STAT_EXTERN") +#pragma pop_macro("LLMCheckMessage") +#pragma pop_macro("LLMCheckfMessage") +#pragma pop_macro("LLMEnsureMessage") +#pragma pop_macro("LLMCheck") +#pragma pop_macro("LLMCheckf") +#pragma pop_macro("LLMEnsure") +#pragma pop_macro("LLM_ENUM_GENERIC_TAGS") +#pragma pop_macro("LLM_ENUM") +#pragma pop_macro("LLM") +#pragma pop_macro("LLM_IF_ENABLED") +#pragma pop_macro("LLM_SCOPE") +#pragma pop_macro("LLM_PLATFORM_SCOPE") +#pragma pop_macro("LLM_SCOPED_PAUSE_TRACKING") +#pragma pop_macro("LLM_SCOPED_PAUSE_TRACKING_FOR_TRACKER") +#pragma pop_macro("LLM_SCOPED_PAUSE_TRACKING_WITH_ENUM_AND_AMOUNT") +#pragma pop_macro("LLM_REALLOC_SCOPE") +#pragma pop_macro("LLM_REALLOC_PLATFORM_SCOPE") +#pragma pop_macro("LLM_SCOPED_TAG_WITH_STAT") +#pragma pop_macro("LLM_SCOPED_TAG_WITH_STAT_IN_SET") +#pragma pop_macro("LLM_SCOPED_TAG_WITH_STAT_NAME") +#pragma pop_macro("LLM_SCOPED_TAG_WITH_STAT_NAME_IN_SET") +#pragma pop_macro("LLM_SCOPED_SINGLE_PLATFORM_STAT_TAG") +#pragma pop_macro("LLM_SCOPED_SINGLE_PLATFORM_STAT_TAG_IN_SET") +#pragma pop_macro("LLM_SCOPED_SINGLE_STAT_TAG") +#pragma pop_macro("LLM_SCOPED_SINGLE_STAT_TAG_IN_SET") +#pragma pop_macro("LLM_SCOPED_PAUSE_TRACKING_WITH_STAT_AND_AMOUNT") +#pragma pop_macro("LLM_SCOPED_TAG_WITH_OBJECT_IN_SET") +#pragma pop_macro("LLM_PUSH_STATS_FOR_ASSET_TAGS") +#pragma pop_macro("LLM_DUMP_TAG") +#pragma pop_macro("LLM_DUMP_PLATFORM_TAG") +#pragma pop_macro("LLM_SCOPED_SINGLE_RHI_STAT_TAG") +#pragma pop_macro("LLM_SCOPED_SINGLE_RHI_STAT_TAG_IN_SET") +#pragma pop_macro("MEM_TIME") +#pragma pop_macro("MBA_STAT") +#pragma pop_macro("MBG_STAT") +#pragma pop_macro("MALLOCLEAK_WHITELIST_SCOPE") +#pragma pop_macro("MALLOCLEAK_SCOPED_CONTEXT") +#pragma pop_macro("FUNCTION_CHECK_RETURN") +#pragma pop_macro("UE_ASSUME") +#pragma pop_macro("ASSUME") +#pragma pop_macro("UNLIKELY") +#pragma pop_macro("DECLARE_UINT64") +#pragma pop_macro("MS_ALIGN") +#pragma pop_macro("MSVC_PRAGMA") +#pragma pop_macro("FLUSH_CACHE_LINE") +#pragma pop_macro("MSC_FORMAT_DIAGNOSTIC_HELPER_2") +#pragma pop_macro("MSC_FORMAT_DIAGNOSTIC_HELPER") +#pragma pop_macro("COMPILE_WARNING") +#pragma pop_macro("COMPILE_ERROR") +#pragma pop_macro("GCC_DIAGNOSTIC_HELPER") +#pragma pop_macro("checkAtCompileTime") +#pragma pop_macro("DEPRECATED_FORGAME") +#pragma pop_macro("INT32_MAIN_INT32_ARGC_TCHAR_ARGV") +#pragma pop_macro("TEXT_PASTE") +#pragma pop_macro("NAMED_EVENT_STR") +#pragma pop_macro("SCOPED_NAMED_EVENT") +#pragma pop_macro("SCOPED_NAMED_EVENT_FSTRING") +#pragma pop_macro("SCOPED_NAMED_EVENT_TCHAR") +#pragma pop_macro("SCOPED_NAMED_EVENT_TEXT") +#pragma pop_macro("SCOPED_NAMED_EVENT_F") +#pragma pop_macro("SCOPED_PROFILER_COLOR") +#pragma pop_macro("PREPROCESSOR_TO_STRING") +#pragma pop_macro("PREPROCESSOR_TO_STRING_INNER") +#pragma pop_macro("PREPROCESSOR_JOIN") +#pragma pop_macro("PREPROCESSOR_JOIN_INNER") +#pragma pop_macro("PREPROCESSOR_JOIN_FIRST") +#pragma pop_macro("PREPROCESSOR_JOIN_FIRST_INNER") +#pragma pop_macro("PREPROCESSOR_IF") +#pragma pop_macro("PREPROCESSOR_IF_INNER_1") +#pragma pop_macro("PREPROCESSOR_IF_INNER_0") +#pragma pop_macro("PREPROCESSOR_COMMA_SEPARATED") +#pragma pop_macro("DEFINE_VARIABLE") +#pragma pop_macro("PREPROCESSOR_REMOVE_OPTIONAL_PARENS") +#pragma pop_macro("PREPROCESSOR_REMOVE_OPTIONAL_PARENS_IMPL") +#pragma pop_macro("COMPILED_PLATFORM_HEADER") +#pragma pop_macro("COMPILED_PLATFORM_HEADER_WITH_PREFIX") +#pragma pop_macro("FAST_DECIMAL_FORMAT_SIGNED_IMPL") +#pragma pop_macro("FAST_DECIMAL_FORMAT_UNSIGNED_IMPL") +#pragma pop_macro("FAST_DECIMAL_FORMAT_FRACTIONAL_IMPL") +#pragma pop_macro("FAST_DECIMAL_PARSE_INTEGER_IMPL") +#pragma pop_macro("FAST_DECIMAL_PARSE_FRACTIONAL_IMPL") +#pragma pop_macro("LOCTEXT") +#pragma pop_macro("NSLOCTEXT") +#pragma pop_macro("INVTEXT") +#pragma pop_macro("LOCGEN_NUMBER") +#pragma pop_macro("LOCGEN_NUMBER_GROUPED") +#pragma pop_macro("LOCGEN_NUMBER_UNGROUPED") +#pragma pop_macro("LOCGEN_NUMBER_CUSTOM") +#pragma pop_macro("LOCGEN_PERCENT") +#pragma pop_macro("LOCGEN_PERCENT_GROUPED") +#pragma pop_macro("LOCGEN_PERCENT_UNGROUPED") +#pragma pop_macro("LOCGEN_PERCENT_CUSTOM") +#pragma pop_macro("LOCGEN_CURRENCY") +#pragma pop_macro("LOCGEN_DATE_UTC") +#pragma pop_macro("LOCGEN_DATE_LOCAL") +#pragma pop_macro("LOCGEN_TIME_UTC") +#pragma pop_macro("LOCGEN_TIME_LOCAL") +#pragma pop_macro("LOCGEN_DATETIME_UTC") +#pragma pop_macro("LOCGEN_DATETIME_LOCAL") +#pragma pop_macro("LOCGEN_TOUPPER") +#pragma pop_macro("LOCGEN_TOLOWER") +#pragma pop_macro("LOCGEN_FORMAT_ORDERED") +#pragma pop_macro("LOCGEN_FORMAT_NAMED") +#pragma pop_macro("LOCTABLE_NEW") +#pragma pop_macro("LOCTABLE_FROMFILE_ENGINE") +#pragma pop_macro("LOCTABLE_FROMFILE_GAME") +#pragma pop_macro("LOCTABLE_SETSTRING") +#pragma pop_macro("LOCTABLE_SETMETA") +#pragma pop_macro("LOCTABLE") +#pragma pop_macro("_aligned_msize") +#pragma pop_macro("UE_LOG_EXPAND_IS_FATAL") +#pragma pop_macro("UE_LOG_EXPAND_IS_FATAL_Fatal") +#pragma pop_macro("UE_LOG_EXPAND_IS_FATAL_Error") +#pragma pop_macro("UE_LOG_EXPAND_IS_FATAL_Warning") +#pragma pop_macro("UE_LOG_EXPAND_IS_FATAL_Display") +#pragma pop_macro("UE_LOG_EXPAND_IS_FATAL_Log") +#pragma pop_macro("UE_LOG_EXPAND_IS_FATAL_Verbose") +#pragma pop_macro("UE_LOG_EXPAND_IS_FATAL_VeryVerbose") +#pragma pop_macro("UE_LOG_EXPAND_IS_FATAL_All") +#pragma pop_macro("UE_LOG_EXPAND_IS_FATAL_SetColor") +#pragma pop_macro("UE_LOG_SOURCE_FILE") +#pragma pop_macro("UE_LOG") +#pragma pop_macro("UE_LOG_CLINKAGE") +#pragma pop_macro("UE_CLOG") +#pragma pop_macro("UE_LOG_ACTIVE") +#pragma pop_macro("UE_LOG_ANY_ACTIVE") +#pragma pop_macro("UE_SUPPRESS") +#pragma pop_macro("UE_GET_LOG_VERBOSITY") +#pragma pop_macro("UE_SET_LOG_VERBOSITY") +#pragma pop_macro("DECLARE_LOG_CATEGORY_EXTERN") +#pragma pop_macro("DEFINE_LOG_CATEGORY") +#pragma pop_macro("DEFINE_LOG_CATEGORY_STATIC") +#pragma pop_macro("DECLARE_LOG_CATEGORY_CLASS") +#pragma pop_macro("DEFINE_LOG_CATEGORY_CLASS") +#pragma pop_macro("UE_SECURITY_LOG") +#pragma pop_macro("NOTIFY_CLIENT_OF_SECURITY_EVENT_IF_NOT_SHIPPING") +#pragma pop_macro("CLOSE_CONNECTION_DUE_TO_SECURITY_VIOLATION_INNER") +#pragma pop_macro("CLOSE_CONNECTION_DUE_TO_SECURITY_VIOLATION") +#pragma pop_macro("logOrEnsureNanError") +#pragma pop_macro("LOG_SCOPE_VERBOSITY_OVERRIDE") +#pragma pop_macro("TRACE_LOG_CATEGORY") +#pragma pop_macro("TRACE_LOG_MESSAGE") +#pragma pop_macro("CREATE_FUNCTION_SHIM") +#pragma pop_macro("CREATE_GLOBAL_SHIM") +#pragma pop_macro("CREATE_DEPRECATED_SHIM") +#pragma pop_macro("CREATE_DEPRECATED_MSG_SHIM") +#pragma pop_macro("LUMIN_MLSDK_API_DEPRECATED_MSG") +#pragma pop_macro("AOS_TO_SOA2_ISPC") +#pragma pop_macro("AOS_TO_SOA3_ISPC") +#pragma pop_macro("AOS_TO_SOA4_ISPC") +#pragma pop_macro("AOS_TO_SOA6_ISPC") +#pragma pop_macro("DEFINE_EXPRESSION_OPERATOR_NODE") +#pragma pop_macro("FOREACH_OCTREE_CHILD_NODE") +#pragma pop_macro("DEFINE_INTERPCURVE_WRAPPER_STRUCT") +#pragma pop_macro("DEFINE_INTERVAL_WRAPPER_STRUCT") +#pragma pop_macro("DEFINE_RANGE_WRAPPER_STRUCT") +#pragma pop_macro("DEFINE_RANGEBOUND_WRAPPER_STRUCT") +#pragma pop_macro("NonZeroAnimWeight") +#pragma pop_macro("NonOneAnimWeight") +#pragma pop_macro("ScalarReciprocal") +#pragma pop_macro("SOA_TO_AOS2_ISPC") +#pragma pop_macro("SOA_TO_AOS3_ISPC") +#pragma pop_macro("SOA_TO_AOS4_ISPC") +#pragma pop_macro("SOA_TO_AOS6_ISPC") +#pragma pop_macro("_PS_CONST") +#pragma pop_macro("_PI32_CONST") +#pragma pop_macro("_PS_CONST_TYPE") +#pragma pop_macro("COPY_XMM_TO_MM") +#pragma pop_macro("COPY_MM_TO_XMM") +#pragma pop_macro("DECLARE_VECTOR_REGISTER") +#pragma pop_macro("VectorZero") +#pragma pop_macro("VectorOne") +#pragma pop_macro("VectorLoad") +#pragma pop_macro("VectorLoadFloat3") +#pragma pop_macro("VectorLoadFloat3_W0") +#pragma pop_macro("VectorLoadFloat3_W1") +#pragma pop_macro("VectorLoadAligned") +#pragma pop_macro("VectorLoadFloat1") +#pragma pop_macro("VectorLoadFloat2") +#pragma pop_macro("VectorSetFloat3") +#pragma pop_macro("VectorSetFloat1") +#pragma pop_macro("VectorSet") +#pragma pop_macro("VectorStoreAligned") +#pragma pop_macro("VectorStoreAlignedStreamed") +#pragma pop_macro("VectorStore") +#pragma pop_macro("VectorStoreFloat3") +#pragma pop_macro("VectorStoreFloat1") +#pragma pop_macro("VectorReplicate") +#pragma pop_macro("VectorAbs") +#pragma pop_macro("VectorNegate") +#pragma pop_macro("VectorAdd") +#pragma pop_macro("VectorSubtract") +#pragma pop_macro("VectorMultiply") +#pragma pop_macro("VectorDivide") +#pragma pop_macro("VectorMultiplyAdd") +#pragma pop_macro("VectorDot3") +#pragma pop_macro("VectorDot4") +#pragma pop_macro("VectorCompareEQ") +#pragma pop_macro("VectorCompareNE") +#pragma pop_macro("VectorCompareGT") +#pragma pop_macro("VectorCompareGE") +#pragma pop_macro("VectorCompareLT") +#pragma pop_macro("VectorCompareLE") +#pragma pop_macro("VectorSelect") +#pragma pop_macro("VectorBitwiseOr") +#pragma pop_macro("VectorBitwiseAnd") +#pragma pop_macro("VectorBitwiseXor") +#pragma pop_macro("VectorMaskBits") +#pragma pop_macro("VectorCross") +#pragma pop_macro("VectorPow") +#pragma pop_macro("VectorReciprocalSqrt") +#pragma pop_macro("VectorReciprocal") +#pragma pop_macro("VectorReciprocalLen") +#pragma pop_macro("VectorReciprocalSqrtAccurate") +#pragma pop_macro("VectorReciprocalAccurate") +#pragma pop_macro("VectorNormalize") +#pragma pop_macro("VectorSet_W0") +#pragma pop_macro("VectorSet_W1") +#pragma pop_macro("VectorMin") +#pragma pop_macro("VectorMax") +#pragma pop_macro("VectorSwizzle") +#pragma pop_macro("VectorShuffle") +#pragma pop_macro("VectorMask_LT") +#pragma pop_macro("VectorMask_LE") +#pragma pop_macro("VectorMask_GT") +#pragma pop_macro("VectorMask_GE") +#pragma pop_macro("VectorMask_EQ") +#pragma pop_macro("VectorMask_NE") +#pragma pop_macro("VectorLoadByte4") +#pragma pop_macro("VectorLoadSignedByte4") +#pragma pop_macro("VectorStoreByte4") +#pragma pop_macro("VectorStoreSignedByte4") +#pragma pop_macro("VectorLoadURGB10A2N") +#pragma pop_macro("VectorStoreURGB10A2N") +#pragma pop_macro("VectorLoadURGBA16N") +#pragma pop_macro("VectorLoadSRGBA16N") +#pragma pop_macro("VectorStoreURGBA16N") +#pragma pop_macro("VectorResetFloatRegisters") +#pragma pop_macro("VectorGetControlRegister") +#pragma pop_macro("VectorIntAnd") +#pragma pop_macro("VectorIntOr") +#pragma pop_macro("VectorIntXor") +#pragma pop_macro("VectorIntAndNot") +#pragma pop_macro("VectorIntNot") +#pragma pop_macro("VectorIntCompareEQ") +#pragma pop_macro("VectorIntCompareNEQ") +#pragma pop_macro("VectorIntCompareGT") +#pragma pop_macro("VectorIntCompareLT") +#pragma pop_macro("VectorIntCompareGE") +#pragma pop_macro("VectorIntCompareLE") +#pragma pop_macro("VectorIntAdd") +#pragma pop_macro("VectorIntSubtract") +#pragma pop_macro("VectorIntNegate") +#pragma pop_macro("VectorIntSign") +#pragma pop_macro("VectorIntToFloat") +#pragma pop_macro("VectorFloatToInt") +#pragma pop_macro("VectorIntStore") +#pragma pop_macro("VectorIntLoad") +#pragma pop_macro("VectorIntStoreAligned") +#pragma pop_macro("VectorIntLoadAligned") +#pragma pop_macro("VectorIntLoad1") +#pragma pop_macro("VectorLoadByte4Reverse") +#pragma pop_macro("VectorPermute") +#pragma pop_macro("VectorSetComponent") +#pragma pop_macro("VectorIntMultiply") +#pragma pop_macro("VectorIntMin") +#pragma pop_macro("VectorIntMax") +#pragma pop_macro("VectorIntAbs") +#pragma pop_macro("SHUFFLEMASK") +#pragma pop_macro("VectorMergeVecXYZ_VecW") +#pragma pop_macro("VectorAnyGreaterThan") +#pragma pop_macro("INTEL_ORDER_VECTOR") +#pragma pop_macro("MEMPRO_TRACK_ALLOC") +#pragma pop_macro("MEMPRO_TRACK_FREE") +#pragma pop_macro("MEMPRO_ASSERT") +#pragma pop_macro("MEMPRO_DISABLE_WARNING") +#pragma pop_macro("MEMPRO_ALIGN_SUFFIX") +#pragma pop_macro("_DebugBreakAndPromptForRemote") +#pragma pop_macro("checkCode") +#pragma pop_macro("verify") #pragma pop_macro("check") -#pragma pop_macro("TEXT") -#pragma pop_macro("PI") +#pragma pop_macro("UE_CHECK_IMPL") +#pragma pop_macro("verifyf") +#pragma pop_macro("checkf") +#pragma pop_macro("UE_CHECK_F_IMPL") +#pragma pop_macro("checkNoEntry") +#pragma pop_macro("checkNoReentry") +#pragma pop_macro("checkNoRecursion") +#pragma pop_macro("unimplemented") +#pragma pop_macro("checkSlow") +#pragma pop_macro("checkfSlow") +#pragma pop_macro("verifySlow") +#pragma pop_macro("UE_ENSURE_IMPL") +#pragma pop_macro("ensure") +#pragma pop_macro("ensureMsgf") +#pragma pop_macro("ensureAlways") +#pragma pop_macro("ensureAlwaysMsgf") +#pragma pop_macro("GET_ENUMERATOR_NAME_CHECKED") +#pragma pop_macro("GET_MEMBER_NAME_CHECKED") +#pragma pop_macro("GET_MEMBER_NAME_STRING_CHECKED") +#pragma pop_macro("GET_FUNCTION_NAME_CHECKED") +#pragma pop_macro("GET_FUNCTION_NAME_STRING_CHECKED") +#pragma pop_macro("LowLevelFatalError") +#pragma pop_macro("TestTrueExpr") +#pragma pop_macro("DEFINE_LATENT_AUTOMATION_COMMAND") +#pragma pop_macro("DEFINE_LATENT_AUTOMATION_COMMAND_ONE_PARAMETER") +#pragma pop_macro("DEFINE_LATENT_AUTOMATION_COMMAND_TWO_PARAMETER") +#pragma pop_macro("DEFINE_LATENT_AUTOMATION_COMMAND_THREE_PARAMETER") +#pragma pop_macro("DEFINE_LATENT_AUTOMATION_COMMAND_FOUR_PARAMETER") +#pragma pop_macro("DEFINE_LATENT_AUTOMATION_COMMAND_FIVE_PARAMETER") +#pragma pop_macro("DEFINE_EXPORTED_LATENT_AUTOMATION_COMMAND") +#pragma pop_macro("DEFINE_EXPORTED_LATENT_AUTOMATION_COMMAND_ONE_PARAMETER") +#pragma pop_macro("DEFINE_ENGINE_LATENT_AUTOMATION_COMMAND") +#pragma pop_macro("DEFINE_ENGINE_LATENT_AUTOMATION_COMMAND_ONE_PARAMETER") +#pragma pop_macro("ADD_LATENT_AUTOMATION_COMMAND") +#pragma pop_macro("START_NETWORK_AUTOMATION_COMMAND") +#pragma pop_macro("END_NETWORK_AUTOMATION_COMMAND") +#pragma pop_macro("IMPLEMENT_SIMPLE_AUTOMATION_TEST_PRIVATE") +#pragma pop_macro("IMPLEMENT_COMPLEX_AUTOMATION_TEST_PRIVATE") +#pragma pop_macro("IMPLEMENT_NETWORKED_AUTOMATION_TEST_PRIVATE") +#pragma pop_macro("IMPLEMENT_BDD_AUTOMATION_TEST_PRIVATE") +#pragma pop_macro("DEFINE_SPEC_PRIVATE") +#pragma pop_macro("BEGIN_DEFINE_SPEC_PRIVATE") +#pragma pop_macro("IMPLEMENT_SIMPLE_AUTOMATION_TEST") +#pragma pop_macro("IMPLEMENT_COMPLEX_AUTOMATION_TEST") +#pragma pop_macro("IMPLEMENT_COMPLEX_AUTOMATION_CLASS") +#pragma pop_macro("IMPLEMENT_NETWORKED_AUTOMATION_TEST") +#pragma pop_macro("IMPLEMENT_CUSTOM_SIMPLE_AUTOMATION_TEST") +#pragma pop_macro("IMPLEMENT_CUSTOM_COMPLEX_AUTOMATION_TEST") +#pragma pop_macro("IMPLEMENT_BDD_AUTOMATION_TEST") +#pragma pop_macro("DEFINE_SPEC") +#pragma pop_macro("BEGIN_DEFINE_SPEC") +#pragma pop_macro("END_DEFINE_SPEC") +#pragma pop_macro("BEGIN_CUSTOM_COMPLEX_AUTOMATION_TEST") +#pragma pop_macro("END_CUSTOM_COMPLEX_AUTOMATION_TEST") +#pragma pop_macro("UTEST_EQUAL") +#pragma pop_macro("UTEST_EQUAL_TOLERANCE") +#pragma pop_macro("UTEST_EQUAL_INSENSITIVE") +#pragma pop_macro("UTEST_NOT_EQUAL") +#pragma pop_macro("UTEST_SAME") +#pragma pop_macro("UTEST_NOT_SAME") +#pragma pop_macro("UTEST_TRUE") +#pragma pop_macro("UTEST_FALSE") +#pragma pop_macro("UTEST_VALID") +#pragma pop_macro("UTEST_INVALID") +#pragma pop_macro("UTEST_NULL") +#pragma pop_macro("UTEST_NOT_NULL") +#pragma pop_macro("BYTESWAP_ORDER16_unsigned") +#pragma pop_macro("BYTESWAP_ORDER32_unsigned") +#pragma pop_macro("UE_BYTESWAP_INTRINSIC_PRIVATE_16") +#pragma pop_macro("UE_BYTESWAP_INTRINSIC_PRIVATE_32") +#pragma pop_macro("UE_BYTESWAP_INTRINSIC_PRIVATE_64") +#pragma pop_macro("INTEL_ORDER16") +#pragma pop_macro("INTEL_ORDER32") +#pragma pop_macro("INTEL_ORDERF") +#pragma pop_macro("INTEL_ORDER64") +#pragma pop_macro("INTEL_ORDER_TCHARARRAY") +#pragma pop_macro("NETWORK_ORDER16") +#pragma pop_macro("NETWORK_ORDER32") +#pragma pop_macro("NETWORK_ORDERF") +#pragma pop_macro("NETWORK_ORDER64") +#pragma pop_macro("NETWORK_ORDER_TCHARARRAY") +#pragma pop_macro("LITERAL") +#pragma pop_macro("WhitelistCommandLines") +#pragma pop_macro("STUBBED") +#pragma pop_macro("CLOCK_CYCLES") +#pragma pop_macro("UNCLOCK_CYCLES") +#pragma pop_macro("RETURN_VAL_IF_EXIT_REQUESTED") +#pragma pop_macro("PURE_VIRTUAL") +#pragma pop_macro("WARNING_LOCATION") +#pragma pop_macro("PUSH_MACRO") +#pragma pop_macro("POP_MACRO") +#pragma pop_macro("ANONYMOUS_VARIABLE") +#pragma pop_macro("UE_DEPRECATED") +#pragma pop_macro("UE_DEPRECATED_FORGAME") +#pragma pop_macro("UE_STATIC_DEPRECATE") +#pragma pop_macro("UE_PTRDIFF_TO_INT32") +#pragma pop_macro("UE_PTRDIFF_TO_UINT32") +#pragma pop_macro("UE_NONCOPYABLE") +#pragma pop_macro("UE_GREATER_SORT") +#pragma pop_macro("UE_VERSION_NEWER_THAN") +#pragma pop_macro("UE_VERSION_OLDER_THAN") +#pragma pop_macro("ENUM_CLASS_FLAGS") +#pragma pop_macro("FRIEND_ENUM_CLASS_FLAGS") +#pragma pop_macro("ENUM_RANGE_BY_COUNT") +#pragma pop_macro("ENUM_RANGE_BY_FIRST_AND_LAST") +#pragma pop_macro("ENUM_RANGE_BY_VALUES") +#pragma pop_macro("DEFINE_EXPRESSION_NODE_TYPE") +#pragma pop_macro("MONOLITHIC_HEADER_BOILERPLATE") +#pragma pop_macro("SET_WARN_COLOR") +#pragma pop_macro("SET_WARN_COLOR_AND_BACKGROUND") +#pragma pop_macro("CLEAR_WARN_COLOR") +#pragma pop_macro("LogRuntimeError") +#pragma pop_macro("LogRuntimeWarning") +#pragma pop_macro("ensureAsRuntimeWarning") +#pragma pop_macro("UE_STATIC_ASSERT_COMPLETE_TYPE") +#pragma pop_macro("DEFINE_TEXT_EXPRESSION_OPERATOR_NODE") +#pragma pop_macro("SCOPE_TIME_GUARD") +#pragma pop_macro("SCOPE_TIME_GUARD_MS") +#pragma pop_macro("SCOPE_TIME_GUARD_NAMED") +#pragma pop_macro("SCOPE_TIME_GUARD_NAMED_MS") +#pragma pop_macro("SCOPE_TIME_GUARD_DELEGATE") +#pragma pop_macro("SCOPE_TIME_GUARD_DELEGATE_MS") +#pragma pop_macro("ENABLE_TIME_GUARDS") +#pragma pop_macro("CLEAR_TIME_GUARDS") +#pragma pop_macro("LIGHTWEIGHT_TIME_GUARD_BEGIN") +#pragma pop_macro("LIGHTWEIGHT_TIME_GUARD_END") +#pragma pop_macro("VARARG_DECL") +#pragma pop_macro("VARARG_BODY") +#pragma pop_macro("GET_VARARGS") +#pragma pop_macro("GET_VARARGS_WIDE") +#pragma pop_macro("GET_VARARGS_ANSI") +#pragma pop_macro("GET_VARARGS_RESULT") +#pragma pop_macro("GET_VARARGS_RESULT_WIDE") +#pragma pop_macro("GET_VARARGS_RESULT_ANSI") +#pragma pop_macro("VARARG_EXTRA") +#pragma pop_macro("IMPLEMENT_MODULE") +#pragma pop_macro("IMPLEMENT_GAME_MODULE") +#pragma pop_macro("IMPLEMENT_FOREIGN_ENGINE_DIR") +#pragma pop_macro("IMPLEMENT_LIVE_CODING_ENGINE_DIR") +#pragma pop_macro("IMPLEMENT_LIVE_CODING_PROJECT") +#pragma pop_macro("UE_LIST_ARGUMENT") +#pragma pop_macro("UE_REGISTER_SIGNING_KEY") +#pragma pop_macro("UE_REGISTER_ENCRYPTION_KEY") +#pragma pop_macro("IMPLEMENT_TARGET_NAME_REGISTRATION") +#pragma pop_macro("IMPLEMENT_APPLICATION") +#pragma pop_macro("IMPLEMENT_PRIMARY_GAME_MODULE") +#pragma pop_macro("PER_MODULE_BOILERPLATE_ANYLINK") +#pragma pop_macro("SCOPED_ABTEST") +#pragma pop_macro("SCOPED_ABTEST_DOFIRSTTEST") +#pragma pop_macro("COOK_STAT") +#pragma pop_macro("__TRACE_DECLARE_INLINE_COUNTER") +#pragma pop_macro("TRACE_INT_VALUE") +#pragma pop_macro("TRACE_FLOAT_VALUE") +#pragma pop_macro("TRACE_MEMORY_VALUE") +#pragma pop_macro("TRACE_DECLARE_INT_COUNTER") +#pragma pop_macro("TRACE_DECLARE_INT_COUNTER_EXTERN") +#pragma pop_macro("TRACE_DECLARE_FLOAT_COUNTER") +#pragma pop_macro("TRACE_DECLARE_FLOAT_COUNTER_EXTERN") +#pragma pop_macro("TRACE_DECLARE_MEMORY_COUNTER") +#pragma pop_macro("TRACE_DECLARE_MEMORY_COUNTER_EXTERN") +#pragma pop_macro("TRACE_COUNTER_SET") +#pragma pop_macro("TRACE_COUNTER_ADD") +#pragma pop_macro("TRACE_COUNTER_SUBTRACT") +#pragma pop_macro("TRACE_COUNTER_INCREMENT") +#pragma pop_macro("TRACE_COUNTER_DECREMENT") +#pragma pop_macro("TRACE_CPUPROFILER_SHUTDOWN") +#pragma pop_macro("TRACE_CPUPROFILER_EVENT_SCOPE_ON_CHANNEL_STR") +#pragma pop_macro("TRACE_CPUPROFILER_EVENT_SCOPE_ON_CHANNEL") +#pragma pop_macro("TRACE_CPUPROFILER_EVENT_SCOPE_STR") +#pragma pop_macro("TRACE_CPUPROFILER_EVENT_SCOPE") +#pragma pop_macro("TRACE_CPUPROFILER_EVENT_SCOPE_TEXT_ON_CHANNEL") +#pragma pop_macro("TRACE_CPUPROFILER_EVENT_SCOPE_TEXT") +#pragma pop_macro("CSV_CATEGORY_INDEX") +#pragma pop_macro("CSV_STAT_FNAME") +#pragma pop_macro("CSV_SCOPED_TIMING_STAT") +#pragma pop_macro("CSV_SCOPED_TIMING_STAT_GLOBAL") +#pragma pop_macro("CSV_SCOPED_TIMING_STAT_EXCLUSIVE") +#pragma pop_macro("CSV_SCOPED_TIMING_STAT_EXCLUSIVE_CONDITIONAL") +#pragma pop_macro("CSV_SCOPED_WAIT_CONDITIONAL") +#pragma pop_macro("CSV_SCOPED_SET_WAIT_STAT") +#pragma pop_macro("CSV_SCOPED_SET_WAIT_STAT_IGNORE") +#pragma pop_macro("CSV_CUSTOM_STAT") +#pragma pop_macro("CSV_CUSTOM_STAT_GLOBAL") +#pragma pop_macro("CSV_DEFINE_STAT") +#pragma pop_macro("CSV_DEFINE_STAT_GLOBAL") +#pragma pop_macro("CSV_DECLARE_STAT_EXTERN") +#pragma pop_macro("CSV_CUSTOM_STAT_DEFINED") +#pragma pop_macro("CSV_DEFINE_CATEGORY") +#pragma pop_macro("CSV_DECLARE_CATEGORY_EXTERN") +#pragma pop_macro("CSV_DEFINE_CATEGORY_MODULE") +#pragma pop_macro("CSV_DECLARE_CATEGORY_MODULE_EXTERN") +#pragma pop_macro("CSV_EVENT") +#pragma pop_macro("CSV_EVENT_GLOBAL") +#pragma pop_macro("CSV_METADATA") +#pragma pop_macro("TRACE_CSV_PROFILER_REGISTER_CATEGORY") +#pragma pop_macro("TRACE_CSV_PROFILER_INLINE_STAT") +#pragma pop_macro("TRACE_CSV_PROFILER_INLINE_STAT_EXCLUSIVE") +#pragma pop_macro("TRACE_CSV_PROFILER_DECLARED_STAT") +#pragma pop_macro("TRACE_CSV_PROFILER_BEGIN_STAT") +#pragma pop_macro("TRACE_CSV_PROFILER_END_STAT") +#pragma pop_macro("TRACE_CSV_PROFILER_BEGIN_EXCLUSIVE_STAT") +#pragma pop_macro("TRACE_CSV_PROFILER_END_EXCLUSIVE_STAT") +#pragma pop_macro("TRACE_CSV_PROFILER_CUSTOM_STAT") +#pragma pop_macro("TRACE_CSV_PROFILER_EVENT") +#pragma pop_macro("TRACE_CSV_PROFILER_BEGIN_CAPTURE") +#pragma pop_macro("TRACE_CSV_PROFILER_END_CAPTURE") +#pragma pop_macro("TRACE_CSV_PROFILER_METADATA") +#pragma pop_macro("SCOPE_PROFILER_INCLUDER") +#pragma pop_macro("SCOPE_PROFILER_EXCLUDER") +#pragma pop_macro("COUNT_INSTANCES") +#pragma pop_macro("COUNT_INSTANCES_AND_LOG") +#pragma pop_macro("ACCUM_LOADTIME") +#pragma pop_macro("SCOPED_ACCUM_LOADTIME") +#pragma pop_macro("SCOPED_LOADTIMER_TEXT") +#pragma pop_macro("SCOPED_LOADTIMER") +#pragma pop_macro("SCOPED_LOADTIMER_CNT") +#pragma pop_macro("ADD_CUSTOM_LOADTIMER_META") +#pragma pop_macro("SCOPED_CUSTOM_LOADTIMER") +#pragma pop_macro("SCOPED_ACCUM_LOADTIME_STAT") +#pragma pop_macro("ACCUM_LOADTIMECOUNT_STAT") +#pragma pop_macro("TRACE_BOOKMARK") +#pragma pop_macro("TRACE_BEGIN_FRAME") +#pragma pop_macro("TRACE_END_FRAME") +#pragma pop_macro("TRACE_PLATFORMFILE_BEGIN_OPEN") +#pragma pop_macro("TRACE_PLATFORMFILE_END_OPEN") +#pragma pop_macro("TRACE_PLATFORMFILE_FAIL_OPEN") +#pragma pop_macro("TRACE_PLATFORMFILE_BEGIN_CLOSE") +#pragma pop_macro("TRACE_PLATFORMFILE_END_CLOSE") +#pragma pop_macro("TRACE_PLATFORMFILE_FAIL_CLOSE") +#pragma pop_macro("TRACE_PLATFORMFILE_BEGIN_READ") +#pragma pop_macro("TRACE_PLATFORMFILE_END_READ") +#pragma pop_macro("TRACE_PLATFORMFILE_BEGIN_WRITE") +#pragma pop_macro("TRACE_PLATFORMFILE_END_WRITE") +#pragma pop_macro("MALLOC_PROFILER") +#pragma pop_macro("FArchive_Serialize_BitfieldBool") +#pragma pop_macro("TRACE_LOADTIME_REQUEST_GROUP_SCOPE") +#pragma pop_macro("UE_STATIC_ONLY") +#pragma pop_macro("UE_DECLARE_INTERNAL_LINK_BASE") +#pragma pop_macro("UE_DECLARE_INTERNAL_LINK_SPECIALIZATION") +#pragma pop_macro("INTERNAL_LAYOUT_FIELD") +#pragma pop_macro("INTERNAL_LAYOUT_FIELD_WITH_WRITER") +#pragma pop_macro("INTERNAL_LAYOUT_WRITE_MEMORY_IMAGE") +#pragma pop_macro("INTERNAL_LAYOUT_TOSTRING") +#pragma pop_macro("LAYOUT_FIELD") +#pragma pop_macro("LAYOUT_MUTABLE_FIELD") +#pragma pop_macro("LAYOUT_FIELD_INITIALIZED") +#pragma pop_macro("LAYOUT_MUTABLE_FIELD_INITIALIZED") +#pragma pop_macro("LAYOUT_ARRAY") +#pragma pop_macro("LAYOUT_MUTABLE_BITFIELD") +#pragma pop_macro("LAYOUT_BITFIELD") +#pragma pop_macro("LAYOUT_FIELD_WITH_WRITER") +#pragma pop_macro("LAYOUT_MUTABLE_FIELD_WITH_WRITER") +#pragma pop_macro("LAYOUT_WRITE_MEMORY_IMAGE") +#pragma pop_macro("LAYOUT_TOSTRING") +#pragma pop_macro("LAYOUT_FIELD_EDITORONLY") +#pragma pop_macro("LAYOUT_ARRAY_EDITORONLY") +#pragma pop_macro("LAYOUT_BITFIELD_EDITORONLY") +#pragma pop_macro("LAYOUT_FIELD_RAYTRACING") +#pragma pop_macro("LAYOUT_FIELD_INITIALIZED_RAYTRACING") +#pragma pop_macro("LAYOUT_ARRAY_RAYTRACING") +#pragma pop_macro("INTERNAL_LAYOUT_INTERFACE_PREFIX_NonVirtual") +#pragma pop_macro("INTERNAL_LAYOUT_INTERFACE_PREFIX_Virtual") +#pragma pop_macro("INTERNAL_LAYOUT_INTERFACE_PREFIX_Abstract") +#pragma pop_macro("INTERNAL_LAYOUT_INTERFACE_PREFIX") +#pragma pop_macro("INTERNAL_LAYOUT_INTERFACE_SUFFIX") +#pragma pop_macro("INTERNAL_LAYOUT_INTERFACE_INLINE_IMPL") +#pragma pop_macro("INTERNAL_DECLARE_TYPE_LAYOUT_COMMON") +#pragma pop_macro("INTERNAL_DECLARE_INLINE_TYPE_LAYOUT") +#pragma pop_macro("INTERNAL_DECLARE_TYPE_LAYOUT") +#pragma pop_macro("INTERNAL_DECLARE_LAYOUT_BASE") +#pragma pop_macro("INTERNAL_DECLARE_LAYOUT_EXPLICIT_BASES") +#pragma pop_macro("DECLARE_TYPE_LAYOUT") +#pragma pop_macro("DECLARE_INLINE_TYPE_LAYOUT") +#pragma pop_macro("DECLARE_EXPORTED_TYPE_LAYOUT") +#pragma pop_macro("DECLARE_TYPE_LAYOUT_EXPLICIT_BASES") +#pragma pop_macro("DECLARE_INLINE_TYPE_LAYOUT_EXPLICIT_BASES") +#pragma pop_macro("DECLARE_EXPORTED_TYPE_LAYOUT_EXPLICIT_BASES") +#pragma pop_macro("INTERNAL_IMPLEMENT_TYPE_LAYOUT_COMMON") +#pragma pop_macro("INTERNAL_REGISTER_TYPE_LAYOUT") +#pragma pop_macro("IMPLEMENT_UNREGISTERED_TEMPLATE_TYPE_LAYOUT") +#pragma pop_macro("IMPLEMENT_TEMPLATE_TYPE_LAYOUT") +#pragma pop_macro("IMPLEMENT_TYPE_LAYOUT") +#pragma pop_macro("IMPLEMENT_ABSTRACT_TYPE_LAYOUT") +#pragma pop_macro("REGISTER_INLINE_TYPE_LAYOUT") +#pragma pop_macro("DECLARE_TEMPLATE_INTRINSIC_TYPE_LAYOUT") +#pragma pop_macro("DECLARE_EXPORTED_TEMPLATE_INTRINSIC_TYPE_LAYOUT") +#pragma pop_macro("IMPLEMENT_EXPORTED_INTRINSIC_TYPE_LAYOUT") +#pragma pop_macro("DECLARE_INTRINSIC_TYPE_LAYOUT") +#pragma pop_macro("ALIAS_TEMPLATE_TYPE_LAYOUT") +#pragma pop_macro("ALIAS_TYPE_LAYOUT") +#pragma pop_macro("SA_VALUE") +#pragma pop_macro("SA_ATTRIBUTE") +#pragma pop_macro("SA_OPTIONAL_ATTRIBUTE") +#pragma pop_macro("SA_FIELD_NAME") +#pragma pop_macro("STAT") +#pragma pop_macro("ANSI_TO_PROFILING") +#pragma pop_macro("DECLARE_SCOPE_CYCLE_COUNTER") +#pragma pop_macro("QUICK_SCOPE_CYCLE_COUNTER") +#pragma pop_macro("SCOPE_CYCLE_COUNTER") +#pragma pop_macro("CONDITIONAL_SCOPE_CYCLE_COUNTER") +#pragma pop_macro("RETURN_QUICK_DECLARE_CYCLE_STAT") +#pragma pop_macro("GET_STATID") +#pragma pop_macro("SCOPE_SECONDS_ACCUMULATOR") +#pragma pop_macro("SCOPE_MS_ACCUMULATOR") +#pragma pop_macro("DEFINE_STAT") +#pragma pop_macro("QUICK_USE_CYCLE_STAT") +#pragma pop_macro("DECLARE_CYCLE_STAT") +#pragma pop_macro("DECLARE_FLOAT_COUNTER_STAT") +#pragma pop_macro("DECLARE_DWORD_COUNTER_STAT") +#pragma pop_macro("DECLARE_FLOAT_ACCUMULATOR_STAT") +#pragma pop_macro("DECLARE_DWORD_ACCUMULATOR_STAT") +#pragma pop_macro("DECLARE_FNAME_STAT") +#pragma pop_macro("DECLARE_PTR_STAT") +#pragma pop_macro("DECLARE_MEMORY_STAT") +#pragma pop_macro("DECLARE_MEMORY_STAT_POOL") +#pragma pop_macro("DECLARE_CYCLE_STAT_EXTERN") +#pragma pop_macro("DECLARE_FLOAT_COUNTER_STAT_EXTERN") +#pragma pop_macro("DECLARE_DWORD_COUNTER_STAT_EXTERN") +#pragma pop_macro("DECLARE_FLOAT_ACCUMULATOR_STAT_EXTERN") +#pragma pop_macro("DECLARE_DWORD_ACCUMULATOR_STAT_EXTERN") +#pragma pop_macro("DECLARE_FNAME_STAT_EXTERN") +#pragma pop_macro("DECLARE_PTR_STAT_EXTERN") +#pragma pop_macro("DECLARE_MEMORY_STAT_EXTERN") +#pragma pop_macro("DECLARE_MEMORY_STAT_POOL_EXTERN") +#pragma pop_macro("DECLARE_STATS_GROUP") +#pragma pop_macro("DECLARE_STATS_GROUP_VERBOSE") +#pragma pop_macro("DECLARE_STATS_GROUP_MAYBE_COMPILED_OUT") +#pragma pop_macro("SET_CYCLE_COUNTER") +#pragma pop_macro("INC_DWORD_STAT") +#pragma pop_macro("INC_FLOAT_STAT_BY") +#pragma pop_macro("INC_DWORD_STAT_BY") +#pragma pop_macro("INC_DWORD_STAT_FNAME_BY") +#pragma pop_macro("INC_MEMORY_STAT_BY") +#pragma pop_macro("DEC_DWORD_STAT") +#pragma pop_macro("DEC_FLOAT_STAT_BY") +#pragma pop_macro("DEC_DWORD_STAT_BY") +#pragma pop_macro("DEC_DWORD_STAT_FNAME_BY") +#pragma pop_macro("DEC_MEMORY_STAT_BY") +#pragma pop_macro("SET_MEMORY_STAT") +#pragma pop_macro("SET_DWORD_STAT") +#pragma pop_macro("SET_FLOAT_STAT") +#pragma pop_macro("STAT_ADD_CUSTOMMESSAGE_NAME") +#pragma pop_macro("STAT_ADD_CUSTOMMESSAGE_PTR") +#pragma pop_macro("SET_CYCLE_COUNTER_FName") +#pragma pop_macro("INC_DWORD_STAT_FName") +#pragma pop_macro("INC_FLOAT_STAT_BY_FName") +#pragma pop_macro("INC_DWORD_STAT_BY_FName") +#pragma pop_macro("INC_MEMORY_STAT_BY_FName") +#pragma pop_macro("DEC_DWORD_STAT_FName") +#pragma pop_macro("DEC_FLOAT_STAT_BY_FName") +#pragma pop_macro("DEC_DWORD_STAT_BY_FName") +#pragma pop_macro("DEC_MEMORY_STAT_BY_FName") +#pragma pop_macro("SET_MEMORY_STAT_FName") +#pragma pop_macro("SET_DWORD_STAT_FName") +#pragma pop_macro("SET_FLOAT_STAT_FName") +#pragma pop_macro("GET_STATFNAME") +#pragma pop_macro("GET_STATDESCRIPTION") +#pragma pop_macro("DECLARE_STAT_GROUP") +#pragma pop_macro("DECLARE_STAT") +#pragma pop_macro("GET_STATISEVERYFRAME") +#pragma pop_macro("STAT_GROUP_TO_FStatGroup") +#pragma pop_macro("DECLARE_STATS_GROUP_SORTBYNAME") +#pragma pop_macro("checkStats") +#pragma pop_macro("DECLARE_SCOPE_HIERARCHICAL_COUNTER") +#pragma pop_macro("DECLARE_SCOPE_HIERARCHICAL_COUNTER_FUNC") +#pragma pop_macro("SCOPE_SECONDS_COUNTER_BASE") +#pragma pop_macro("SCOPE_SECONDS_COUNTER_RECURSION_SAFE_BASE") +#pragma pop_macro("SCOPE_SECONDS_COUNTER") +#pragma pop_macro("SCOPE_SECONDS_COUNTER_RECURSION_SAFE") +#pragma pop_macro("SCOPE_LOG_TIME") +#pragma pop_macro("SCOPE_LOG_TIME_IN_SECONDS") +#pragma pop_macro("SCOPE_LOG_TIME_FUNC") +#pragma pop_macro("SCOPE_LOG_TIME_FUNC_WITH_GLOBAL") +#pragma pop_macro("CONDITIONAL_SCOPE_LOG_TIME") +#pragma pop_macro("CONDITIONAL_SCOPE_LOG_TIME_IN_SECONDS") +#pragma pop_macro("CONDITIONAL_SCOPE_LOG_TIME_FUNC") +#pragma pop_macro("CONDITIONAL_SCOPE_LOG_TIME_FUNC_WITH_GLOBAL") +#pragma pop_macro("TRACE_STAT_INCREMENT") +#pragma pop_macro("TRACE_STAT_DECREMENT") +#pragma pop_macro("TRACE_STAT_ADD") +#pragma pop_macro("TRACE_STAT_SET") +#pragma pop_macro("ALIGNOF") +#pragma pop_macro("ARE_TYPES_EQUAL") +#pragma pop_macro("UE_PROJECTION") +#pragma pop_macro("UE_PROJECTION_MEMBER") +#pragma pop_macro("PROJECTION") +#pragma pop_macro("PROJECTION_MEMBER") +#pragma pop_macro("UE_TSHAREDPTR_STATIC_ASSERT_VALID_MODE") +#pragma pop_macro("IMPLEMENT_ALIGNED_STORAGE") +#pragma pop_macro("UE_ARRAY_COUNT") +#pragma pop_macro("ARRAY_COUNT") +#pragma pop_macro("STRUCT_OFFSET") +#pragma pop_macro("VTABLE_OFFSET") +#pragma pop_macro("FGuardValue_Bitfield") +#pragma pop_macro("TEMPLATE_PARAMETERS2") +#pragma pop_macro("HAS_TRIVIAL_CONSTRUCTOR") +#pragma pop_macro("IS_POD") +#pragma pop_macro("IS_EMPTY") +#pragma pop_macro("Expose_TFormatSpecifier") +#pragma pop_macro("Expose_TNameOf") +#pragma pop_macro("GENERATE_MEMBER_FUNCTION_CHECK") +#pragma pop_macro("NAME_INTERNAL_TO_EXTERNAL") +#pragma pop_macro("NAME_EXTERNAL_TO_INTERNAL") +#pragma pop_macro("PREPROCESSOR_ENUM_PROTECT") +#pragma pop_macro("DEFERRED_DEPENDENCY_CHECK") +#pragma pop_macro("UE_ASYNC_PACKAGE_DEBUG") +#pragma pop_macro("UE_ASYNC_UPACKAGE_DEBUG") +#pragma pop_macro("UE_ASYNC_PACKAGE_LOG") +#pragma pop_macro("UE_ASYNC_PACKAGE_CLOG") +#pragma pop_macro("UE_ASYNC_PACKAGE_LOG_VERBOSE") +#pragma pop_macro("UE_ASYNC_PACKAGE_CLOG_VERBOSE") +#pragma pop_macro("CHECK_IOSTATUS") +#pragma pop_macro("TRACE_LOADTIME_START_ASYNC_LOADING") +#pragma pop_macro("TRACE_LOADTIME_SUSPEND_ASYNC_LOADING") +#pragma pop_macro("TRACE_LOADTIME_RESUME_ASYNC_LOADING") +#pragma pop_macro("TRACE_LOADTIME_BEGIN_REQUEST") +#pragma pop_macro("TRACE_LOADTIME_END_REQUEST") +#pragma pop_macro("TRACE_LOADTIME_NEW_ASYNC_PACKAGE") +#pragma pop_macro("TRACE_LOADTIME_BEGIN_LOAD_ASYNC_PACKAGE") +#pragma pop_macro("TRACE_LOADTIME_END_LOAD_ASYNC_PACKAGE") +#pragma pop_macro("TRACE_LOADTIME_DESTROY_ASYNC_PACKAGE") +#pragma pop_macro("TRACE_LOADTIME_PACKAGE_SUMMARY") +#pragma pop_macro("TRACE_LOADTIME_ASYNC_PACKAGE_REQUEST_ASSOCIATION") +#pragma pop_macro("TRACE_LOADTIME_ASYNC_PACKAGE_LINKER_ASSOCIATION") +#pragma pop_macro("TRACE_LOADTIME_ASYNC_PACKAGE_IMPORT_DEPENDENCY") +#pragma pop_macro("TRACE_LOADTIME_CREATE_EXPORT_SCOPE") +#pragma pop_macro("TRACE_LOADTIME_SERIALIZE_EXPORT_SCOPE") +#pragma pop_macro("TRACE_LOADTIME_POSTLOAD_EXPORT_SCOPE") +#pragma pop_macro("TRACE_LOADTIME_CLASS_INFO") +#pragma pop_macro("XFERSTRING") +#pragma pop_macro("XFERUNICODESTRING") +#pragma pop_macro("XFERTEXT") +#pragma pop_macro("DECLARE_CAST_BY_FLAG") +#pragma pop_macro("FIXUP_EXPR_OBJECT_POINTER") +#pragma pop_macro("CLASS_REDIRECT") +#pragma pop_macro("CLASS_REDIRECT_INSTANCES") +#pragma pop_macro("STRUCT_REDIRECT") +#pragma pop_macro("ENUM_REDIRECT") +#pragma pop_macro("PROPERTY_REDIRECT") +#pragma pop_macro("FUNCTION_REDIRECT") +#pragma pop_macro("PACKAGE_REDIRECT") +#pragma pop_macro("COMPARE_MEMBER") +#pragma pop_macro("DEFERRED_DEPENDENCY_ENSURE") +#pragma pop_macro("CompCheck") +#pragma pop_macro("DECLARE_OBJECT_FLAG") +#pragma pop_macro("SCOPED_SAVETIMER") +#pragma pop_macro("STORE_INSTRUCTION_NAME") +#pragma pop_macro("IMPLEMENT_FUNCTION") +#pragma pop_macro("IMPLEMENT_CAST_FUNCTION") +#pragma pop_macro("IMPLEMENT_VM_FUNCTION") +#pragma pop_macro("ADD_COOK_STAT") +#pragma pop_macro("STREAMINGTOKEN_PARAM") +#pragma pop_macro("DECLARE_CAST_BY_FLAG_FWD") +#pragma pop_macro("DECLARE_CAST_BY_FLAG_CAST") +#pragma pop_macro("IMPLEMENT_STRUCT") +#pragma pop_macro("NET_CHECKSUM_OR_END") +#pragma pop_macro("NET_CHECKSUM") +#pragma pop_macro("NET_CHECKSUM_CUSTOM") +#pragma pop_macro("NET_CHECKSUM_IGNORE") +#pragma pop_macro("DECLARE_FIELD") +#pragma pop_macro("IMPLEMENT_FIELD") +#pragma pop_macro("UPROPERTY") +#pragma pop_macro("UFUNCTION") +#pragma pop_macro("USTRUCT") +#pragma pop_macro("UMETA") +#pragma pop_macro("UPARAM") +#pragma pop_macro("UENUM") +#pragma pop_macro("UDELEGATE") +#pragma pop_macro("RIGVM_METHOD") +#pragma pop_macro("BODY_MACRO_COMBINE_INNER") +#pragma pop_macro("BODY_MACRO_COMBINE") +#pragma pop_macro("GENERATED_BODY_LEGACY") +#pragma pop_macro("GENERATED_BODY") +#pragma pop_macro("GENERATED_USTRUCT_BODY") +#pragma pop_macro("GENERATED_UCLASS_BODY") +#pragma pop_macro("GENERATED_UINTERFACE_BODY") +#pragma pop_macro("GENERATED_IINTERFACE_BODY") +#pragma pop_macro("UCLASS") +#pragma pop_macro("UINTERFACE") +#pragma pop_macro("DECLARE_FUNCTION") +#pragma pop_macro("DEFINE_FUNCTION") +#pragma pop_macro("RELAY_CONSTRUCTOR") +#pragma pop_macro("COMPILED_IN_FLAGS") +#pragma pop_macro("DECLARE_SERIALIZER") +#pragma pop_macro("IMPLEMENT_FARCHIVE_SERIALIZER") +#pragma pop_macro("IMPLEMENT_FSTRUCTUREDARCHIVE_SERIALIZER") +#pragma pop_macro("DECLARE_FARCHIVE_SERIALIZER") +#pragma pop_macro("DECLARE_FSTRUCTUREDARCHIVE_SERIALIZER") +#pragma pop_macro("DECLARE_CLASS") +#pragma pop_macro("DEFINE_FORBIDDEN_DEFAULT_CONSTRUCTOR_CALL") +#pragma pop_macro("DEFINE_DEFAULT_CONSTRUCTOR_CALL") +#pragma pop_macro("DEFINE_DEFAULT_OBJECT_INITIALIZER_CONSTRUCTOR_CALL") +#pragma pop_macro("DECLARE_VTABLE_PTR_HELPER_CTOR") +#pragma pop_macro("DEFINE_VTABLE_PTR_HELPER_CTOR") +#pragma pop_macro("DEFINE_VTABLE_PTR_HELPER_CTOR_CALLER_DUMMY") +#pragma pop_macro("DEFINE_VTABLE_PTR_HELPER_CTOR_CALLER") +#pragma pop_macro("DECLARE_CLASS_INTRINSIC_NO_CTOR") +#pragma pop_macro("DECLARE_CLASS_INTRINSIC") +#pragma pop_macro("DECLARE_CASTED_CLASS_INTRINSIC_WITH_API_NO_CTOR") +#pragma pop_macro("DECLARE_CASTED_CLASS_INTRINSIC_WITH_API") +#pragma pop_macro("DECLARE_CASTED_CLASS_INTRINSIC_NO_CTOR_NO_VTABLE_CTOR") +#pragma pop_macro("DECLARE_CASTED_CLASS_INTRINSIC_NO_CTOR") +#pragma pop_macro("DECLARE_CASTED_CLASS_INTRINSIC") +#pragma pop_macro("DECLARE_WITHIN_INTERNAL") +#pragma pop_macro("DECLARE_WITHIN") +#pragma pop_macro("DECLARE_WITHIN_UPACKAGE") +#pragma pop_macro("IMPLEMENT_CLASS") +#pragma pop_macro("IMPLEMENT_INTRINSIC_CLASS") +#pragma pop_macro("IMPLEMENT_CORE_INTRINSIC_CLASS") +#pragma pop_macro("IMPLEMENT_DYNAMIC_CLASS") +#pragma pop_macro("SCOPED_SCRIPT_NATIVE_TIMER") +#pragma pop_macro("ZERO_INIT") +#pragma pop_macro("PARAM_PASSED_BY_VAL") +#pragma pop_macro("PARAM_PASSED_BY_VAL_ZEROED") +#pragma pop_macro("PARAM_PASSED_BY_REF") +#pragma pop_macro("PARAM_PASSED_BY_REF_ZEROED") +#pragma pop_macro("P_GET_PROPERTY") +#pragma pop_macro("P_GET_PROPERTY_REF") +#pragma pop_macro("P_GET_UBOOL") +#pragma pop_macro("P_GET_UBOOL8") +#pragma pop_macro("P_GET_UBOOL16") +#pragma pop_macro("P_GET_UBOOL32") +#pragma pop_macro("P_GET_UBOOL64") +#pragma pop_macro("P_GET_UBOOL_REF") +#pragma pop_macro("P_GET_STRUCT") +#pragma pop_macro("P_GET_STRUCT_REF") +#pragma pop_macro("P_GET_OBJECT") +#pragma pop_macro("P_GET_OBJECT_REF") +#pragma pop_macro("P_GET_OBJECT_NO_PTR") +#pragma pop_macro("P_GET_OBJECT_REF_NO_PTR") +#pragma pop_macro("P_GET_TARRAY") +#pragma pop_macro("P_GET_TARRAY_REF") +#pragma pop_macro("P_GET_TMAP") +#pragma pop_macro("P_GET_TMAP_REF") +#pragma pop_macro("P_GET_TSET") +#pragma pop_macro("P_GET_TSET_REF") +#pragma pop_macro("P_GET_TINTERFACE") +#pragma pop_macro("P_GET_TINTERFACE_REF") +#pragma pop_macro("P_GET_SOFTOBJECT") +#pragma pop_macro("P_GET_SOFTOBJECT_REF") +#pragma pop_macro("P_GET_SOFTCLASS") +#pragma pop_macro("P_GET_SOFTCLASS_REF") +#pragma pop_macro("P_GET_ARRAY") +#pragma pop_macro("P_GET_ARRAY_REF") +#pragma pop_macro("P_GET_ENUM") +#pragma pop_macro("P_GET_ENUM_REF") +#pragma pop_macro("P_THIS_CAST") +#pragma pop_macro("XFER") +#pragma pop_macro("XFERNAME") +#pragma pop_macro("XFERPTR") +#pragma pop_macro("XFER_OBJECT_POINTER") +#pragma pop_macro("FUNC_DECLARE_DYNAMIC_MULTICAST_SPARSE_DELEGATE") +#pragma pop_macro("DECLARE_DYNAMIC_MULTICAST_SPARSE_DELEGATE") +#pragma pop_macro("DECLARE_DYNAMIC_MULTICAST_SPARSE_DELEGATE_OneParam") +#pragma pop_macro("DECLARE_DYNAMIC_MULTICAST_SPARSE_DELEGATE_TwoParams") +#pragma pop_macro("DECLARE_DYNAMIC_MULTICAST_SPARSE_DELEGATE_ThreeParams") +#pragma pop_macro("DECLARE_DYNAMIC_MULTICAST_SPARSE_DELEGATE_FourParams") +#pragma pop_macro("DECLARE_DYNAMIC_MULTICAST_SPARSE_DELEGATE_FiveParams") +#pragma pop_macro("DECLARE_DYNAMIC_MULTICAST_SPARSE_DELEGATE_SixParams") +#pragma pop_macro("DECLARE_DYNAMIC_MULTICAST_SPARSE_DELEGATE_SevenParams") +#pragma pop_macro("DECLARE_DYNAMIC_MULTICAST_SPARSE_DELEGATE_EightParams") +#pragma pop_macro("DECLARE_DYNAMIC_MULTICAST_SPARSE_DELEGATE_NineParams") +#pragma pop_macro("CPP_ARRAY_DIM") +#pragma pop_macro("SCOPE_CYCLE_UOBJECT") +#pragma pop_macro("UE_ASSET_LOG") +#pragma pop_macro("METADATA_PARAMS") +#pragma pop_macro("IF_WITH_EDITOR") +#pragma pop_macro("IF_WITH_EDITORONLY_DATA") +#pragma pop_macro("INCREASE_ALLOC_COUNTER") +#pragma pop_macro("DECREASE_ALLOC_COUNTER") +#pragma pop_macro("ContextRedirect") +#pragma pop_macro("ContextGPU0") +#pragma pop_macro("DECLARE_ISBOUNDSHADER") +#pragma pop_macro("VALIDATE_BOUND_SHADER") +#pragma pop_macro("COPY_SHADER") +#pragma pop_macro("EXT_SHADER") +#pragma pop_macro("PSO_IF_NOT_EQUAL_RETURN_FALSE") +#pragma pop_macro("PSO_IF_MEMCMP_FAILS_RETURN_FALSE") +#pragma pop_macro("PSO_IF_STRING_COMPARE_FAILS_RETURN_FALSE") +#pragma pop_macro("DEBUG_EXECUTE_COMMAND_LIST") +#pragma pop_macro("DEBUG_EXECUTE_COMMAND_CONTEXT") +#pragma pop_macro("DEBUG_RHI_EXECUTE_COMMAND_LIST") +#pragma pop_macro("EMBED_DXGI_ERROR_LIST") +#pragma pop_macro("CONDITIONAL_SET_SRVS") +#pragma pop_macro("CONDITIONAL_SET_CBVS") +#pragma pop_macro("CONDITIONAL_SET_SAMPLERS") +#pragma pop_macro("DECLARE_SHADER_TRAITS") +#pragma pop_macro("D3DERR") +#pragma pop_macro("MAKE_D3DHRESULT") +#pragma pop_macro("D3DFORMATCASE") +#pragma pop_macro("MERGE_EXT") +#pragma pop_macro("CASE_ERROR_NAME") +#pragma pop_macro("VERIFYD3D12RESULT_LAMBDA") +#pragma pop_macro("VERIFYD3D12RESULT_EX") +#pragma pop_macro("VERIFYD3D12RESULT") +#pragma pop_macro("VERIFYD3D12CREATETEXTURERESULT") +#pragma pop_macro("checkComRefCount") +#pragma pop_macro("UPDATE_BITFLAGS") +#pragma pop_macro("DS_ELEMENT_TYPE") +#pragma pop_macro("SerialAny_Case") +#pragma pop_macro("DECLARE_SCOPE_HIERARCHICAL_COUNTER_ANIMNODE") +#pragma pop_macro("GETCURVE_REPORTERROR") +#pragma pop_macro("GETCURVE_REPORTERROR_WITHPATHNAME") +#pragma pop_macro("GETROW_REPORTERROR") +#pragma pop_macro("GETROWOBJECT_REPORTERROR") +#pragma pop_macro("DECLARE_SCOPED_DELEGATE") +#pragma pop_macro("STREAMABLERENDERASSET_NODEFAULT") +#pragma pop_macro("HIDE_ACTOR_TRANSFORM_FUNCTIONS") +#pragma pop_macro("DEPRECATED_CHARACTER_MOVEMENT_RPC") +#pragma pop_macro("PARTICLE_PERF_STAT_INSTANCE_COUNT") +#pragma pop_macro("PARTICLE_PERF_STAT_CYCLES") +#pragma pop_macro("EFFECT_SETTINGS_NAME2") +#pragma pop_macro("EFFECT_SETTINGS_NAME1") +#pragma pop_macro("EFFECT_SETTINGS_NAME") +#pragma pop_macro("EFFECT_PRESET_NAME2") +#pragma pop_macro("EFFECT_PRESET_NAME1") +#pragma pop_macro("EFFECT_PRESET_NAME") +#pragma pop_macro("GET_EFFECT_SETTINGS") +#pragma pop_macro("EFFECT_PRESET_METHODS") +#pragma pop_macro("DECLARE_SOUNDNODE_ELEMENT") +#pragma pop_macro("DECLARE_SOUNDNODE_ELEMENT_PTR") +#pragma pop_macro("DEBUG_CALLSPACE") +#pragma pop_macro("UE_MAKEFOURCC") +#pragma pop_macro("UE_mmioFOURCC") +#pragma pop_macro("SAFE_TRACEINDEX_DECREASE") +#pragma pop_macro("DATATABLE_CHANGE_SCOPE") +#pragma pop_macro("CURVETABLE_CHANGE_SCOPE") +#pragma pop_macro("UE_DRAW_SERVER_DEBUG_ON_EACH_CLIENT") +#pragma pop_macro("IMPLEMENT_GPUSKINNING_VERTEX_FACTORY_TYPE_INTERNAL") +#pragma pop_macro("IMPLEMENT_GPUSKINNING_VERTEX_FACTORY_TYPE") +#pragma pop_macro("IMPLEMENT_GPUSKINNING_VERTEX_FACTORY_PARAMETER_TYPE") +#pragma pop_macro("STRUCTTRACK_GETNUMKEYFRAMES") +#pragma pop_macro("STRUCTTRACK_GETTIMERANGE") +#pragma pop_macro("STRUCTTRACK_GETTRACKENDTIME") +#pragma pop_macro("STRUCTTRACK_GETKEYFRAMETIME") +#pragma pop_macro("STRUCTTRACK_GETKEYFRAMEINDEX") +#pragma pop_macro("STRUCTTRACK_SETKEYFRAMETIME") +#pragma pop_macro("STRUCTTRACK_REMOVEKEYFRAME") +#pragma pop_macro("STRUCTTRACK_DUPLICATEKEYFRAME") +#pragma pop_macro("STRUCTTRACK_GETCLOSESTSNAPPOSITION") +#pragma pop_macro("DEBUG_REMOTEFUNCTION") +#pragma pop_macro("UpdatePerClientMinMaxAvg") +#pragma pop_macro("BUILD_NETEMULATION_CONSOLE_COMMAND") +#pragma pop_macro("SCOPE_LOCK_REF") +#pragma pop_macro("CHECK_REPL_EQUALITY") +#pragma pop_macro("CHECK_REPL_VALIDITY") +#pragma pop_macro("COMPOSE_NET_GUID") +#pragma pop_macro("ALLOC_NEW_NET_GUID") +#pragma pop_macro("PolyCheck") +#pragma pop_macro("CHECK_VIRTUALTEXTURE_USAGE") +#pragma pop_macro("WarnInvalidPhysicsOperations") +#pragma pop_macro("REPDATATYPE_SPECIALIZATION") +#pragma pop_macro("LERP_PP") +#pragma pop_macro("IF_PP") +#pragma pop_macro("IMPLEMENT_PLATFORM_INTERFACE_SINGLETON") +#pragma pop_macro("SHOWFLAG_ALWAYS_ACCESSIBLE") +#pragma pop_macro("SHOWFLAG_FIXED_IN_SHIPPING") +#pragma pop_macro("DISABLE_ENGINE_SHOWFLAG") +#pragma pop_macro("DEBUGBROKENCONSTRAINTUPDATE") +#pragma pop_macro("GENERATE_LOD_MODEL") +#pragma pop_macro("SERIALIZE_CURVE") +#pragma pop_macro("SERIALIZE_OPTION") +#pragma pop_macro("SKIP_OLD_OPTION") +#pragma pop_macro("DECLARETEXTUREGROUPSTAT") +#pragma pop_macro("ASSIGNTEXTUREGROUPSTATNAME") +#pragma pop_macro("TEXT_TO_ENUM") +#pragma pop_macro("TEXT_TO_MIPGENSETTINGS") +#pragma pop_macro("GROUPNAMES") +#pragma pop_macro("TIMER_TEST_TEXT") +#pragma pop_macro("SCOPE_TIME_TO_VAR") +#pragma pop_macro("CALCULATE_WEIGHTING") +#pragma pop_macro("DO_ANIMSTAT_PROCESSING") +#pragma pop_macro("IS_VALID_COLLISIONCHANNEL") +#pragma pop_macro("devCode") +#pragma pop_macro("SKY_DECLARE_BLUEPRINT_SETFUNCTION") +#pragma pop_macro("SKY_DECLARE_BLUEPRINT_SETFUNCTION_LINEARCOEFFICIENT") +#pragma pop_macro("CLOUD_DECLARE_BLUEPRINT_SETFUNCTION") +#pragma pop_macro("SETUPLODGROUP") +#pragma pop_macro("TEXT_TO_SHADINGMODEL") +#pragma pop_macro("TEXT_TO_BLENDMODE") +#pragma pop_macro("SWAP_REFERENCE_TO") +#pragma pop_macro("IF_INPUT_RETURN") +#pragma pop_macro("COMPILER_OR_LOG_ERROR") +#pragma pop_macro("DECLARE_MATERIALUNIFORMEXPRESSION_TYPE") +#pragma pop_macro("IMPLEMENT_MATERIALUNIFORMEXPRESSION_TYPE") +#pragma pop_macro("WORLD_TYPE_CASE") +#pragma pop_macro("STARTQUERYTIMER") +#pragma pop_macro("CAPTUREGEOMSWEEP") +#pragma pop_macro("CAPTURERAYCAST") +#pragma pop_macro("CAPTUREGEOMOVERLAP") +#pragma pop_macro("SET_DRIVE_PARAM") +#pragma pop_macro("SUBSTEPPING_WARNING") +#pragma pop_macro("ALLOCATE_VERTEX_DATA_TEMPLATE") +#pragma pop_macro("CHECK_SUCCESS") +#pragma pop_macro("CHECK_FAIL") +#pragma pop_macro("CHECK_NOT_NULL") +#pragma pop_macro("MAKE_565") +#pragma pop_macro("MAKE_8888") +#pragma pop_macro("UNORM16") +#pragma pop_macro("UNORM16_SRGB") +#pragma pop_macro("AC_UnalignedSwap") +#pragma pop_macro("ECC_TO_BITFIELD") +#pragma pop_macro("CRC_TO_BITFIELD") +#pragma pop_macro("SCENE_QUERY_STAT_ONLY") +#pragma pop_macro("SCENE_QUERY_STAT_NAME_ONLY") +#pragma pop_macro("SCENE_QUERY_STAT") +#pragma pop_macro("MAKEFOURCC") +#pragma pop_macro("DIST_GET_RANDOM_VALUE") +#pragma pop_macro("DEFINE_GAME_DELEGATE") +#pragma pop_macro("DEFINE_GAME_DELEGATE_TYPED") +#pragma pop_macro("SET_BONE_DATA") +#pragma pop_macro("DECLARE_HIT_PROXY_STATIC") +#pragma pop_macro("DECLARE_HIT_PROXY") +#pragma pop_macro("IMPLEMENT_HIT_PROXY_BASE") +#pragma pop_macro("IMPLEMENT_HIT_PROXY") +#pragma pop_macro("EVAL_CURVE") +#pragma pop_macro("FIND_POINT") +#pragma pop_macro("IMPLEMENT_MATERIAL_SHADER_TYPE") +#pragma pop_macro("TRACE_CLASS") +#pragma pop_macro("TRACE_OBJECT") +#pragma pop_macro("TRACE_OBJECT_EVENT") +#pragma pop_macro("UNCONDITIONAL_TRACE_OBJECT_EVENT") +#pragma pop_macro("TRACE_WORLD") +#pragma pop_macro("PARTICLE_INSTANCE_PREFETCH") +#pragma pop_macro("DECLARE_PARTICLE") +#pragma pop_macro("DECLARE_PARTICLE_CONST") +#pragma pop_macro("DECLARE_PARTICLE_PTR") +#pragma pop_macro("PARTICLE_ELEMENT") +#pragma pop_macro("TRAIL_EMITTER_CHECK_FLAG") +#pragma pop_macro("TRAIL_EMITTER_SET_FLAG") +#pragma pop_macro("TRAIL_EMITTER_GET_PREVNEXT") +#pragma pop_macro("TRAIL_EMITTER_SET_PREVNEXT") +#pragma pop_macro("TRAIL_EMITTER_IS_START") +#pragma pop_macro("TRAIL_EMITTER_SET_START") +#pragma pop_macro("TRAIL_EMITTER_IS_END") +#pragma pop_macro("TRAIL_EMITTER_SET_END") +#pragma pop_macro("TRAIL_EMITTER_IS_MIDDLE") +#pragma pop_macro("TRAIL_EMITTER_SET_MIDDLE") +#pragma pop_macro("TRAIL_EMITTER_IS_ONLY") +#pragma pop_macro("TRAIL_EMITTER_SET_ONLY") +#pragma pop_macro("TRAIL_EMITTER_IS_FORCEKILL") +#pragma pop_macro("TRAIL_EMITTER_SET_FORCEKILL") +#pragma pop_macro("TRAIL_EMITTER_IS_DEADTRAIL") +#pragma pop_macro("TRAIL_EMITTER_SET_DEADTRAIL") +#pragma pop_macro("TRAIL_EMITTER_IS_HEAD") +#pragma pop_macro("TRAIL_EMITTER_IS_HEADONLY") +#pragma pop_macro("TRAIL_EMITTER_GET_PREV") +#pragma pop_macro("TRAIL_EMITTER_SET_PREV") +#pragma pop_macro("TRAIL_EMITTER_GET_NEXT") +#pragma pop_macro("TRAIL_EMITTER_SET_NEXT") +#pragma pop_macro("BEAM2_TYPEDATA_SETFREQUENCY") +#pragma pop_macro("SRA_UPDATE_CALLBACK") +#pragma pop_macro("VIEW_UNIFORM_BUFFER_MEMBER") +#pragma pop_macro("VIEW_UNIFORM_BUFFER_MEMBER_EX") +#pragma pop_macro("VIEW_UNIFORM_BUFFER_MEMBER_ARRAY") +#pragma pop_macro("STEREO_LAYER_SHAPE_BOILERPLATE") +#pragma pop_macro("CAN_TRACE_OBJECT") +#pragma pop_macro("CANNOT_TRACE_OBJECT") +#pragma pop_macro("MARK_OBJECT_TRACEABLE") +#pragma pop_macro("SET_OBJECT_TRACEABLE") +#pragma pop_macro("GET_TRACE_OBJECT_VALUE") +#pragma pop_macro("DISABLE_ENGINE_ACTOR_TRACE_FILTERING") +#pragma pop_macro("DISABLE_ENGINE_WORLD_TRACE_FILTERING") +#pragma pop_macro("ANIM_MT_SCOPE_CYCLE_COUNTER") +#pragma pop_macro("TRACE_ANIM_TICK_RECORD") +#pragma pop_macro("TRACE_SKELETAL_MESH") +#pragma pop_macro("TRACE_SKELETAL_MESH_COMPONENT") +#pragma pop_macro("TRACE_SKELETALMESH_FRAME") +#pragma pop_macro("TRACE_SCOPED_ANIM_GRAPH") +#pragma pop_macro("TRACE_SCOPED_ANIM_NODE") +#pragma pop_macro("TRACE_ANIM_NODE_VALUE") +#pragma pop_macro("TRACE_ANIM_SEQUENCE_PLAYER") +#pragma pop_macro("TRACE_ANIM_STATE_MACHINE_STATE") +#pragma pop_macro("TRACE_ANIM_NOTIFY") +#pragma pop_macro("TRACE_ANIM_SYNC_MARKER") +#pragma pop_macro("TRACE_ANIM_MONTAGE") +#pragma pop_macro("DEFINE_CONTROL_CHANNEL_MESSAGE") +#pragma pop_macro("DEFINE_CONTROL_CHANNEL_MESSAGE_ZEROPARAM") +#pragma pop_macro("DEFINE_CONTROL_CHANNEL_MESSAGE_ONEPARAM") +#pragma pop_macro("DEFINE_CONTROL_CHANNEL_MESSAGE_TWOPARAM") +#pragma pop_macro("DEFINE_CONTROL_CHANNEL_MESSAGE_THREEPARAM") +#pragma pop_macro("DEFINE_CONTROL_CHANNEL_MESSAGE_FOURPARAM") +#pragma pop_macro("DEFINE_CONTROL_CHANNEL_MESSAGE_FIVEPARAM") +#pragma pop_macro("DEFINE_CONTROL_CHANNEL_MESSAGE_SIXPARAM") +#pragma pop_macro("DEFINE_CONTROL_CHANNEL_MESSAGE_SEVENPARAM") +#pragma pop_macro("DEFINE_CONTROL_CHANNEL_MESSAGE_EIGHTPARAM") +#pragma pop_macro("IMPLEMENT_CONTROL_CHANNEL_MESSAGE") +#pragma pop_macro("UE_LOG_PACKET_NOTIFY_WARNING") +#pragma pop_macro("GRANULAR_NETWORK_MEMORY_TRACKING_INIT") +#pragma pop_macro("GRANULAR_NETWORK_MEMORY_TRACKING_TRACK") +#pragma pop_macro("GRANULAR_NETWORK_MEMORY_TRACKING_CUSTOM_WORK") +#pragma pop_macro("NETWORK_PROFILER") +#pragma pop_macro("DOREPLIFETIME_WITH_PARAMS_FAST") +#pragma pop_macro("DOREPLIFETIME_WITH_PARAMS_FAST_STATIC_ARRAY") +#pragma pop_macro("DOREPLIFETIME_WITH_PARAMS") +#pragma pop_macro("DOREPLIFETIME") +#pragma pop_macro("DOREPLIFETIME_DIFFNAMES") +#pragma pop_macro("DOREPLIFETIME_CONDITION") +#pragma pop_macro("DOREPLIFETIME_CONDITION_NOTIFY") +#pragma pop_macro("DOREPLIFETIME_ACTIVE_OVERRIDE_FAST") +#pragma pop_macro("DOREPLIFETIME_ACTIVE_OVERRIDE_FAST_STATIC_ARRAY") +#pragma pop_macro("DOREPLIFETIME_ACTIVE_OVERRIDE") +#pragma pop_macro("DOREPLIFETIME_CHANGE_CONDITION") +#pragma pop_macro("DISABLE_REPLICATED_PROPERTY") +#pragma pop_macro("DISABLE_REPLICATED_PRIVATE_PROPERTY") +#pragma pop_macro("DISABLE_REPLICATED_PROPERTY_FAST") +#pragma pop_macro("DISABLE_REPLICATED_PROPERTY_FAST_STATIC_ARRAY") +#pragma pop_macro("DISABLE_ALL_CLASS_REPLICATED_PROPERTIES") +#pragma pop_macro("DISABLE_ALL_CLASS_REPLICATED_PROPERTIES_FAST") +#pragma pop_macro("RESET_REPLIFETIME_CONDITION") +#pragma pop_macro("RESET_REPLIFETIME") +#pragma pop_macro("RESET_REPLIFETIME_CONDITION_FAST") +#pragma pop_macro("RESET_REPLIFETIME_CONDITION_FAST_STATIC_ARRAY") +#pragma pop_macro("RESET_REPLIFETIME_FAST") +#pragma pop_macro("RESET_REPLIFETIME_FAST_STATIC_ARRAY") +#pragma pop_macro("RPC_VALIDATE") +#pragma pop_macro("REDIRECT_TO_VLOG") +#pragma pop_macro("REDIRECT_OBJECT_TO_VLOG") +#pragma pop_macro("CONNECT_WITH_VLOG") +#pragma pop_macro("CONNECT_OBJECT_WITH_VLOG") +#pragma pop_macro("UE_VLOG") +#pragma pop_macro("UE_CVLOG") +#pragma pop_macro("UE_VLOG_UELOG") +#pragma pop_macro("UE_CVLOG_UELOG") +#pragma pop_macro("UE_VLOG_SEGMENT") +#pragma pop_macro("UE_CVLOG_SEGMENT") +#pragma pop_macro("UE_VLOG_SEGMENT_THICK") +#pragma pop_macro("UE_CVLOG_SEGMENT_THICK") +#pragma pop_macro("UE_VLOG_LOCATION") +#pragma pop_macro("UE_CVLOG_LOCATION") +#pragma pop_macro("UE_VLOG_BOX") +#pragma pop_macro("UE_CVLOG_BOX") +#pragma pop_macro("UE_VLOG_OBOX") +#pragma pop_macro("UE_CVLOG_OBOX") +#pragma pop_macro("UE_VLOG_CONE") +#pragma pop_macro("UE_CVLOG_CONE") +#pragma pop_macro("UE_VLOG_CYLINDER") +#pragma pop_macro("UE_CVLOG_CYLINDER") +#pragma pop_macro("UE_VLOG_CAPSULE") +#pragma pop_macro("UE_CVLOG_CAPSULE") +#pragma pop_macro("UE_VLOG_HISTOGRAM") +#pragma pop_macro("UE_CVLOG_HISTOGRAM") +#pragma pop_macro("UE_VLOG_PULLEDCONVEX") +#pragma pop_macro("UE_CVLOG_PULLEDCONVEX") +#pragma pop_macro("UE_VLOG_MESH") +#pragma pop_macro("UE_CVLOG_MESH") +#pragma pop_macro("UE_VLOG_CONVEXPOLY") +#pragma pop_macro("UE_CVLOG_CONVEXPOLY") +#pragma pop_macro("UE_VLOG_ARROW") +#pragma pop_macro("UE_CVLOG_ARROW") +#pragma pop_macro("DECLARE_VLOG_EVENT") +#pragma pop_macro("DEFINE_VLOG_EVENT") +#pragma pop_macro("UE_VLOG_EVENTS") +#pragma pop_macro("UE_CVLOG_EVENTS") +#pragma pop_macro("UE_VLOG_EVENT_WITH_DATA") +#pragma pop_macro("UE_CVLOG_EVENT_WITH_DATA") +#pragma pop_macro("UE_IFVLOG") +#pragma pop_macro("TEXT_CONDITION") +#pragma pop_macro("COLLAPSED_LOGF") +#pragma pop_macro("DEFINE_ENUM_TO_STRING") +#pragma pop_macro("DECLARE_ENUM_TO_STRING") +#pragma pop_macro("EVOLUTION_TRAIT") +#pragma pop_macro("SCOPE_CYCLE_COUNTER_GJK") +#pragma pop_macro("MAX_CLAMP") +#pragma pop_macro("MIN_CLAMP") +#pragma pop_macro("RANGE_CLAMP") +#pragma pop_macro("CHAOS_CHECK") +#pragma pop_macro("CHAOS_ENSURE") +#pragma pop_macro("CHAOS_ENSURE_MSG") +#pragma pop_macro("CHAOS_LOG") +#pragma pop_macro("CHAOS_CLOG") +#pragma pop_macro("CHAOS_PERF_TEST") +#pragma pop_macro("CHAOS_SCOPED_TIMER") +#pragma pop_macro("PARTICLE_PROPERTY") +#pragma pop_macro("PROPERTY_TYPE") +#pragma pop_macro("SHAPE_PROPERTY") +#pragma pop_macro("PARTICLE_PROPERTY_CHECKED") +#pragma pop_macro("CONSTRAINT_JOINT_PROPERPETY_IMPL") +#pragma pop_macro("SCOPE_CYCLE_COUNTER_NAROWPHASE") +#pragma pop_macro("CHAOS_COLLISION_STAT") +#pragma pop_macro("CHAOS_COLLISION_STAT_DISABLED") +#pragma pop_macro("MANAGED_ARRAY_TYPE") +#pragma pop_macro("COPY_ON_WRITE_ATTRIBUTE") +#pragma pop_macro("SCOPE_LOG_GAMEPLAYTAGS") +#pragma pop_macro("PARSE_FLOAT") +#pragma pop_macro("PARSE_INT") +#pragma pop_macro("ADDKEYMAP") +#pragma pop_macro("MAP_OEM_VK_TO_SCAN") +#pragma pop_macro("JSON_SERIALIZE") +#pragma pop_macro("JSON_SERIALIZE_ARRAY") +#pragma pop_macro("JSON_SERIALIZE_MAP") +#pragma pop_macro("JSON_SERIALIZE_SIMPLECOPY") +#pragma pop_macro("JSON_SERIALIZE_MAP_SAFE") +#pragma pop_macro("JSON_SERIALIZE_SERIALIZABLE") +#pragma pop_macro("JSON_SERIALIZE_RAW_JSON_STRING") +#pragma pop_macro("JSON_SERIALIZE_ARRAY_SERIALIZABLE") +#pragma pop_macro("JSON_SERIALIZE_MAP_SERIALIZABLE") +#pragma pop_macro("JSON_SERIALIZE_OBJECT_SERIALIZABLE") +#pragma pop_macro("JSON_SERIALIZE_DATETIME_UNIX_TIMESTAMP") +#pragma pop_macro("JSON_SERIALIZE_DATETIME_UNIX_TIMESTAMP_MILLISECONDS") +#pragma pop_macro("JSON_SERIALIZE_ENUM") +#pragma pop_macro("HEIGHTDATA") +#pragma pop_macro("CHECK_JNI_METHOD") +#pragma pop_macro("VERSION_TEXT") +#pragma pop_macro("VERSION_STRINGIFY_2") +#pragma pop_macro("VERSION_STRINGIFY") +#pragma pop_macro("SAFE_CA_CALL") +#pragma pop_macro("CORE_AUDIO_ERR") +#pragma pop_macro("NEW_GLOBAL_PROPERTY") +#pragma pop_macro("NEW_OUTPUT_PROPERTY") +#pragma pop_macro("DECLARE_RPC") +#pragma pop_macro("MOVIESCENE_DETAILED_SCOPE_CYCLE_COUNTER") +#pragma pop_macro("UE_MOVIESCENE_TODO_IMPL") +#pragma pop_macro("UE_MOVIESCENE_TODO") +#pragma pop_macro("INITIALIZE_NAVQUERY_SIMPLE") +#pragma pop_macro("INITIALIZE_NAVQUERY") +#pragma pop_macro("INITIALIZE_NAVQUERY_WLINKFILTER") +#pragma pop_macro("TEXT_WEAKOBJ_NAME") +#pragma pop_macro("REGISTER_NET_ANALYTICS") +#pragma pop_macro("CONDITIONAL_ON_PUSH_MODEL") +#pragma pop_macro("IS_PUSH_MODEL_ENABLED") +#pragma pop_macro("PUSH_MAKE_BP_PROPERTIES_PUSH_MODEL") +#pragma pop_macro("GET_PROPERTY_REP_INDEX") +#pragma pop_macro("GET_PROPERTY_REP_INDEX_STATIC_ARRAY_START") +#pragma pop_macro("GET_PROPERTY_REP_INDEX_STATIC_ARRAY_END") +#pragma pop_macro("GET_PROPERTY_REP_INDEX_STATIC_ARRAY_INDEX") +#pragma pop_macro("IS_PROPERTY_REPLICATED") +#pragma pop_macro("CONDITIONAL_ON_OBJECT_NET_ID") +#pragma pop_macro("CONDITIONAL_ON_OBJECT_NET_ID_DYNAMIC") +#pragma pop_macro("CONDITIONAL_ON_REP_INDEX_AND_OBJECT_NET_ID") +#pragma pop_macro("MARK_PROPERTY_DIRTY_UNSAFE") +#pragma pop_macro("MARK_PROPERTY_DIRTY") +#pragma pop_macro("MARK_PROPERTY_DIRTY_STATIC_ARRAY_INDEX") +#pragma pop_macro("MARK_PROPERTY_DIRTY_STATIC_ARRAY") +#pragma pop_macro("MARK_PROPERTY_DIRTY_FROM_NAME") +#pragma pop_macro("MARK_PROPERTY_DIRTY_FROM_NAME_STATIC_ARRAY_INDEX") +#pragma pop_macro("MARK_PROPERTY_DIRTY_FROM_NAME_STATIC_ARRAY") +#pragma pop_macro("GET_PROPERTY_REP_INDEX_STATIC_ARRAY") +#pragma pop_macro("REPLICATED_BASE_CLASS") +#pragma pop_macro("UE_NET_TRACE_CREATE_COLLECTOR") +#pragma pop_macro("UE_NET_TRACE_DESTROY_COLLECTOR") +#pragma pop_macro("UE_NET_TRACE_SCOPE") +#pragma pop_macro("UE_NET_TRACE_OBJECT_SCOPE") +#pragma pop_macro("UE_NET_TRACE_DYNAMIC_NAME_SCOPE") +#pragma pop_macro("UE_NET_TRACE_NAMED_SCOPE") +#pragma pop_macro("UE_NET_TRACE_NAMED_OBJECT_SCOPE") +#pragma pop_macro("UE_NET_TRACE_NAMED_DYNAMIC_NAME_SCOPE") +#pragma pop_macro("UE_NET_TRACE_SET_SCOPE_NAME") +#pragma pop_macro("UE_NET_TRACE_SET_SCOPE_OBJECTID") +#pragma pop_macro("UE_NET_TRACE_EXIT_NAMED_SCOPE") +#pragma pop_macro("UE_NET_TRACE_OFFSET_SCOPE") +#pragma pop_macro("UE_NET_TRACE") +#pragma pop_macro("UE_NET_TRACE_DYNAMIC_NAME") +#pragma pop_macro("UE_NET_TRACE_FLUSH_COLLECTOR") +#pragma pop_macro("UE_NET_TRACE_BEGIN_BUNCH") +#pragma pop_macro("UE_NET_TRACE_DISCARD_BUNCH") +#pragma pop_macro("UE_NET_TRACE_POP_SEND_BUNCH") +#pragma pop_macro("UE_NET_TRACE_EVENTS") +#pragma pop_macro("UE_NET_TRACE_END_BUNCH") +#pragma pop_macro("UE_NET_TRACE_BUNCH_SCOPE") +#pragma pop_macro("UE_NET_TRACE_ASSIGNED_GUID") +#pragma pop_macro("UE_NET_TRACE_NETHANDLE_CREATED") +#pragma pop_macro("UE_NET_TRACE_NETHANDLE_DESTROYED") +#pragma pop_macro("UE_NET_TRACE_CONNECTION_CREATED") +#pragma pop_macro("UE_NET_TRACE_CONNECTION_CLOSED") +#pragma pop_macro("UE_NET_TRACE_PACKET_DROPPED") +#pragma pop_macro("UE_NET_TRACE_PACKET_SEND") +#pragma pop_macro("UE_NET_TRACE_PACKET_RECV") +#pragma pop_macro("UE_NET_TRACE_END_SESSION") +#pragma pop_macro("UE_NET_TRACE_DO_IF") +#pragma pop_macro("UE_NET_TRACE_INTERNAL_CREATE_COLLECTOR") +#pragma pop_macro("UE_NET_TRACE_INTERNAL_DESTROY_COLLECTOR") +#pragma pop_macro("UE_NET_TRACE_INTERNAL_FLUSH_COLLECTOR") +#pragma pop_macro("UE_NET_TRACE_INTERNAL_BEGIN_BUNCH") +#pragma pop_macro("UE_NET_TRACE_INTERNAL_DISCARD_BUNCH") +#pragma pop_macro("UE_NET_TRACE_INTERNAL_POP_SEND_BUNCH") +#pragma pop_macro("UE_NET_TRACE_INTERNAL_EVENTS") +#pragma pop_macro("UE_NET_TRACE_INTERNAL_END_BUNCH") +#pragma pop_macro("UE_NET_TRACE_INTERNAL_BUNCH_SCOPE") +#pragma pop_macro("UE_NET_TRACE_INTERNAL_SCOPE") +#pragma pop_macro("UE_NET_TRACE_INTERNAL_OBJECT_SCOPE") +#pragma pop_macro("UE_NET_TRACE_INTERNAL_DYNAMIC_NAME_SCOPE") +#pragma pop_macro("UE_NET_TRACE_INTERNAL_NAMED_SCOPE") +#pragma pop_macro("UE_NET_TRACE_INTERNAL_NAMED_OBJECT_SCOPE") +#pragma pop_macro("UE_NET_TRACE_INTERNAL_NAMED_DYNAMIC_NAME_SCOPE") +#pragma pop_macro("UE_NET_TRACE_INTERNAL_SET_SCOPE_NAME") +#pragma pop_macro("UE_NET_TRACE_INTERNAL_SET_SCOPE_OBJECTID") +#pragma pop_macro("UE_NET_TRACE_INTERNAL_EXIT_NAMED_SCOPE") +#pragma pop_macro("UE_NET_TRACE_INTERNAL_OFFSET_SCOPE") +#pragma pop_macro("UE_NET_TRACE_INTERNAL") +#pragma pop_macro("UE_NET_TRACE_INTERNAL_DYNAMIC_NAME") +#pragma pop_macro("UE_NET_TRACE_INTERNAL_ASSIGNED_GUID") +#pragma pop_macro("UE_NET_TRACE_INTERNAL_NETHANDLE_CREATED") +#pragma pop_macro("UE_NET_TRACE_INTERNAL_NETHANDLE_DESTROYED") +#pragma pop_macro("UE_NET_TRACE_INTERNAL_CONNECTION_CREATED") +#pragma pop_macro("UE_NET_TRACE_INTERNAL_CONNECTION_CLOSED") +#pragma pop_macro("UE_NET_TRACE_INTERNAL_PACKET_DROPPED") +#pragma pop_macro("UE_NET_TRACE_INTERNAL_PACKET_SEND") +#pragma pop_macro("UE_NET_TRACE_INTERNAL_PACKET_RECV") +#pragma pop_macro("UE_NET_TRACE_INTERNAL_END_SESSION") +#pragma pop_macro("CASE_ENUM_TO_STR") +#pragma pop_macro("RETURN_IF_EQUAL") +#pragma pop_macro("ROTLEFT_64B") +#pragma pop_macro("_TEST_EQUAL") +#pragma pop_macro("_TEST_NOT_EQUAL") +#pragma pop_macro("_TEST_NULL") +#pragma pop_macro("_TEST_NOT_NULL") +#pragma pop_macro("TEST_EQUAL") +#pragma pop_macro("TEST_NOT_EQUAL") +#pragma pop_macro("TEST_TRUE") +#pragma pop_macro("TEST_FALSE") +#pragma pop_macro("TEST_NULL") +#pragma pop_macro("TEST_NOT_NULL") +#pragma pop_macro("TEST_BECOMES_TRUE") +#pragma pop_macro("MOCK_FUNC_NOT_IMPLEMENTED") +#pragma pop_macro("ARRAY") +#pragma pop_macro("ARRAYU64") +#pragma pop_macro("CASE_ENUM_SET") +#pragma pop_macro("MAP_TO_RESULTSTRING") +#pragma pop_macro("PrintCurlFeature") +#pragma pop_macro("EnumCase") +#pragma pop_macro("RESTRICT_SSL_TLS_PROTOCOL") +#pragma pop_macro("DEFINE_COMMAND") +#pragma pop_macro("DECLARE_COMMAND") +#pragma pop_macro("IMPL_HEADER_FIELD_GETTER") +#pragma pop_macro("OPUS_CHECK_CTL") +#pragma pop_macro("LWSWEBSOCKET_ESTATE_TOSTRING") +#pragma pop_macro("LOG_AND_GET_GL_QUERY_INT") +#pragma pop_macro("INDEX_TO_VOID") +#pragma pop_macro("ASSERT_NO_GL_ERROR") +#pragma pop_macro("LOG_GL_STRING") +#pragma pop_macro("LOG_AND_GET_GL_INT_TEMP") +#pragma pop_macro("CHECK_COMPRESSED_FORMAT") +#pragma pop_macro("LOG_GL_DEBUG_FLAG") +#pragma pop_macro("GL_CHECK") +#pragma pop_macro("LOG_AND_GET_GL_INT") +#pragma pop_macro("GET_GL_INT") +#pragma pop_macro("INTERFACE_BLOCK") +#pragma pop_macro("VERIFY_EGL") +#pragma pop_macro("MACRO_TOKENIZER") +#pragma pop_macro("MACRO_TOKENIZER2") +#pragma pop_macro("VERIFY_EGL_SCOPE_WITH_MSG_STR") +#pragma pop_macro("VERIFY_EGL_SCOPE") +#pragma pop_macro("VERIFY_EGL_FUNC") +#pragma pop_macro("QUERY_CHECK") +#pragma pop_macro("DEFINE_GL_ENTRYPOINTS") +#pragma pop_macro("GET_GL_ENTRYPOINTS") +#pragma pop_macro("CHECK_GL_ENTRYPOINTS") +#pragma pop_macro("ENUM_GL_ENTRYPOINTS") +#pragma pop_macro("ENUM_GL_ENTRYPOINTS_OPTIONAL") +#pragma pop_macro("ENUM_GL_ENTRYPOINTS_ALL") +#pragma pop_macro("DECLARE_GL_ENTRYPOINTS") +#pragma pop_macro("CHECK_GL_ENTRYPOINTS_NULL") +#pragma pop_macro("CHECK_GL_ENTRYPOINTS_OK") +#pragma pop_macro("ENUM_GL_ENTRYPOINTS_1_0") +#pragma pop_macro("ENUM_GL_ENTRYPOINTS_1_1") +#pragma pop_macro("ENUM_GL_ENTRYPOINTS_1_3") +#pragma pop_macro("ENUM_GL_ENTRYPOINTS_1_4") +#pragma pop_macro("ENUM_GL_ENTRYPOINTS_1_5") +#pragma pop_macro("ENUM_GL_ENTRYPOINTS_2_0") +#pragma pop_macro("ENUM_GL_ENTRYPOINTS_2_1") +#pragma pop_macro("ENUM_GL_ENTRYPOINTS_3_0") +#pragma pop_macro("ENUM_GL_ENTRYPOINTS_3_1") +#pragma pop_macro("ENUM_GL_ENTRYPOINTS_3_2") +#pragma pop_macro("ENUM_GL_ENTRYPOINTS_3_3") +#pragma pop_macro("ENUM_GL_ENTRYPOINTS_4_0") +#pragma pop_macro("ENUM_GL_ENTRYPOINTS_4_1") +#pragma pop_macro("ENUM_GL_ENTRYPOINTS_4_2") +#pragma pop_macro("ENUM_GL_ENTRYPOINTS_4_3") +#pragma pop_macro("ENUM_GL_ENTRYPOINTS_4_4") +#pragma pop_macro("ENUM_GL_ENTRYPOINTS_4_5") +#pragma pop_macro("GET_GL_ENTRYPOINTS_DLL") +#pragma pop_macro("ENUM_GL_ENTRYPOINTS_DLL") +#pragma pop_macro("UGL_REQUIRED") +#pragma pop_macro("UGL_OPTIONAL") +#pragma pop_macro("RHITHREAD_GLCOMMAND_PROLOGUE") +#pragma pop_macro("RHITHREAD_GLCOMMAND_EPILOGUE_RETURN") +#pragma pop_macro("RHITHREAD_GLCOMMAND_EPILOGUE_GET_RETURN") +#pragma pop_macro("RHITHREAD_GLCOMMAND_EPILOGUE") +#pragma pop_macro("RHITHREAD_GLCOMMAND_EPILOGUE_NORETURN") +#pragma pop_macro("SCOPE_CYCLE_COUNTER_DETAILED") +#pragma pop_macro("DETAILED_QUICK_SCOPE_CYCLE_COUNTER") +#pragma pop_macro("GLAF_CHECK") +#pragma pop_macro("CHECK_EXPECTED_GL_THREAD") +#pragma pop_macro("VERIFY_GL") +#pragma pop_macro("VERIFY_GL_SCOPE_WITH_MSG_STR") +#pragma pop_macro("VERIFY_GL_SCOPE") +#pragma pop_macro("VERIFY_GL_FUNC") +#pragma pop_macro("glBlitFramebuffer") +#pragma pop_macro("glTexImage2D") +#pragma pop_macro("glTexSubImage2D") +#pragma pop_macro("glCompressedTexImage2D") +#pragma pop_macro("REPORT_GL_DRAW_ARRAYS_EVENT_FOR_FRAME_DUMP") +#pragma pop_macro("REPORT_GL_DRAW_ARRAYS_INSTANCED_EVENT_FOR_FRAME_DUMP") +#pragma pop_macro("REPORT_GL_DRAW_RANGE_ELEMENTS_EVENT_FOR_FRAME_DUMP") +#pragma pop_macro("REPORT_GL_DRAW_ELEMENTS_INSTANCED_EVENT_FOR_FRAME_DUMP") +#pragma pop_macro("REPORT_GL_CLEAR_EVENT_FOR_FRAME_DUMP") +#pragma pop_macro("REPORT_GL_FRAMEBUFFER_BLIT_EVENT") +#pragma pop_macro("REPORT_GL_END_BUFFER_EVENT_FOR_FRAME_DUMP") +#pragma pop_macro("INITIATE_GL_FRAME_DUMP") +#pragma pop_macro("INITIATE_GL_FRAME_DUMP_EVERY_X_CALLS") +#pragma pop_macro("SCOPED_SCENE_READ_LOCK") +#pragma pop_macro("SCOPED_SCENE_WRITE_LOCK") +#pragma pop_macro("SCOPED_APEX_SCENE_READ_LOCK") +#pragma pop_macro("SCOPED_APEX_SCENE_WRITE_LOCK") +#pragma pop_macro("SCENE_LOCK_READ") +#pragma pop_macro("SCENE_UNLOCK_READ") +#pragma pop_macro("SCENE_LOCK_WRITE") +#pragma pop_macro("SCENE_UNLOCK_WRITE") +#pragma pop_macro("SCOPED_SCENE_READ_LOCK_INDEXED") +#pragma pop_macro("SCOPED_SCENE_WRITE_LOCK_INDEXED") +#pragma pop_macro("SQ_REPLAY_TEST") +#pragma pop_macro("BROADCAST_PROPERTY_CHANGED") +#pragma pop_macro("IMPLEMENT_COPY_RESOURCE_SHADER") +#pragma pop_macro("IMPLEMENT_COPY_RESOURCE_SHADER_ALL_TYPES") +#pragma pop_macro("IMPLEMENT_ONECOLORVS") +#pragma pop_macro("EmitRDGWarningf") +#pragma pop_macro("TEXT_TO_PIXELFORMAT") +#pragma pop_macro("DECLARE_GLOBAL_SHADER") +#pragma pop_macro("IMPLEMENT_GLOBAL_SHADER") +#pragma pop_macro("RDG_ASYNC_COMPUTE_BUDGET_SCOPE") +#pragma pop_macro("RDG_GPU_MASK_SCOPE") +#pragma pop_macro("IF_RDG_ENABLE_DEBUG") +#pragma pop_macro("IF_RDG_GPU_SCOPES") +#pragma pop_macro("IF_RDG_CPU_SCOPES") +#pragma pop_macro("RDG_EVENT_NAME") +#pragma pop_macro("RDG_EVENT_SCOPE") +#pragma pop_macro("RDG_EVENT_SCOPE_CONDITIONAL") +#pragma pop_macro("RDG_GPU_STAT_SCOPE") +#pragma pop_macro("RDG_CSV_STAT_EXCLUSIVE_SCOPE") +#pragma pop_macro("RDG_CSV_STAT_EXCLUSIVE_SCOPE_CONDITIONAL") +#pragma pop_macro("RDG_WAIT_FOR_TASKS_CONDITIONAL") +#pragma pop_macro("RDG_WAIT_FOR_TASKS") +#pragma pop_macro("SCOPED_SUSPEND_RENDERING_THREAD") +#pragma pop_macro("LogRenderCommand") +#pragma pop_macro("TASK_FUNCTION") +#pragma pop_macro("TASKNAME_FUNCTION") +#pragma pop_macro("ENQUEUE_RENDER_COMMAND") +#pragma pop_macro("SHADER_DECLARE_VTABLE") +#pragma pop_macro("INTERNAL_DECLARE_SHADER_TYPE_COMMON") +#pragma pop_macro("DECLARE_EXPORTED_SHADER_TYPE") +#pragma pop_macro("DECLARE_SHADER_TYPE") +#pragma pop_macro("DECLARE_SHADER_TYPE_EXPLICIT_BASES") +#pragma pop_macro("SHADER_TYPE_VTABLE") +#pragma pop_macro("IMPLEMENT_SHADER_TYPE") +#pragma pop_macro("IMPLEMENT_SHADER_TYPE_WITH_DEBUG_NAME") +#pragma pop_macro("IMPLEMENT_SHADER_TYPE2_WITH_TEMPLATE_PREFIX") +#pragma pop_macro("IMPLEMENT_SHADER_TYPE2") +#pragma pop_macro("IMPLEMENT_SHADER_TYPE3") +#pragma pop_macro("IMPLEMENT_SHADER_TYPE4_WITH_TEMPLATE_PREFIX") +#pragma pop_macro("IMPLEMENT_SHADERPIPELINE_TYPE_VSPS") +#pragma pop_macro("IMPLEMENT_SHADERPIPELINE_TYPE_VS") +#pragma pop_macro("IMPLEMENT_SHADERPIPELINE_TYPE_VSGSPS") +#pragma pop_macro("IMPLEMENT_SHADERPIPELINE_TYPE_VSGS") +#pragma pop_macro("IMPLEMENT_SHADERPIPELINE_TYPE_VSHSDSPS") +#pragma pop_macro("IMPLEMENT_SHADERPIPELINE_TYPE_VSHSDSGSPS") +#pragma pop_macro("IMPLEMENT_SHADERPIPELINE_TYPE_VSHSDS") +#pragma pop_macro("IMPLEMENT_SHADERPIPELINE_TYPE_VSHSDSGS") +#pragma pop_macro("IMPLEMENT_ALIGNED_TYPE") +#pragma pop_macro("INTERNAL_UNIFORM_BUFFER_STRUCT_GET_STRUCT_METADATA") +#pragma pop_macro("INTERNAL_SHADER_PARAMETER_GET_STRUCT_METADATA") +#pragma pop_macro("INTERNAL_SHADER_PARAMETER_STRUCT_BEGIN") +#pragma pop_macro("INTERNAL_SHADER_PARAMETER_EXPLICIT") +#pragma pop_macro("BEGIN_SHADER_PARAMETER_STRUCT") +#pragma pop_macro("END_SHADER_PARAMETER_STRUCT") +#pragma pop_macro("BEGIN_UNIFORM_BUFFER_STRUCT") +#pragma pop_macro("BEGIN_UNIFORM_BUFFER_STRUCT_WITH_CONSTRUCTOR") +#pragma pop_macro("END_UNIFORM_BUFFER_STRUCT") +#pragma pop_macro("IMPLEMENT_UNIFORM_BUFFER_STRUCT") +#pragma pop_macro("IMPLEMENT_UNIFORM_BUFFER_ALIAS_STRUCT") +#pragma pop_macro("IMPLEMENT_STATIC_UNIFORM_BUFFER_STRUCT") +#pragma pop_macro("IMPLEMENT_STATIC_UNIFORM_BUFFER_SLOT") +#pragma pop_macro("SHADER_PARAMETER") +#pragma pop_macro("SHADER_PARAMETER_EX") +#pragma pop_macro("SHADER_PARAMETER_ARRAY") +#pragma pop_macro("SHADER_PARAMETER_ARRAY_EX") +#pragma pop_macro("SHADER_PARAMETER_TEXTURE") +#pragma pop_macro("SHADER_PARAMETER_TEXTURE_ARRAY") +#pragma pop_macro("SHADER_PARAMETER_SRV") +#pragma pop_macro("SHADER_PARAMETER_SRV_ARRAY") +#pragma pop_macro("SHADER_PARAMETER_UAV") +#pragma pop_macro("SHADER_PARAMETER_SAMPLER") +#pragma pop_macro("SHADER_PARAMETER_SAMPLER_ARRAY") +#pragma pop_macro("SHADER_PARAMETER_RDG_TEXTURE") +#pragma pop_macro("SHADER_PARAMETER_RDG_TEXTURE_ARRAY") +#pragma pop_macro("SHADER_PARAMETER_RDG_TEXTURE_SRV") +#pragma pop_macro("SHADER_PARAMETER_RDG_TEXTURE_SRV_ARRAY") +#pragma pop_macro("SHADER_PARAMETER_RDG_TEXTURE_UAV") +#pragma pop_macro("SHADER_PARAMETER_RDG_TEXTURE_UAV_ARRAY") +#pragma pop_macro("SHADER_PARAMETER_RDG_BUFFER") +#pragma pop_macro("SHADER_PARAMETER_RDG_BUFFER_ARRAY") +#pragma pop_macro("SHADER_PARAMETER_RDG_BUFFER_SRV") +#pragma pop_macro("SHADER_PARAMETER_RDG_BUFFER_SRV_ARRAY") +#pragma pop_macro("SHADER_PARAMETER_RDG_BUFFER_UAV") +#pragma pop_macro("SHADER_PARAMETER_RDG_BUFFER_UAV_ARRAY") +#pragma pop_macro("SHADER_PARAMETER_RDG_UNIFORM_BUFFER") +#pragma pop_macro("SHADER_PARAMETER_STRUCT") +#pragma pop_macro("SHADER_PARAMETER_STRUCT_ARRAY") +#pragma pop_macro("SHADER_PARAMETER_STRUCT_INCLUDE") +#pragma pop_macro("SHADER_PARAMETER_STRUCT_REF") +#pragma pop_macro("RDG_BUFFER_ACCESS") +#pragma pop_macro("RDG_BUFFER_ACCESS_DYNAMIC") +#pragma pop_macro("RDG_TEXTURE_ACCESS") +#pragma pop_macro("RDG_TEXTURE_ACCESS_DYNAMIC") +#pragma pop_macro("SHADER_PARAMETER_RDG_BUFFER_UPLOAD") +#pragma pop_macro("RENDER_TARGET_BINDING_SLOTS") +#pragma pop_macro("SHADER_USE_PARAMETER_STRUCT_INTERNAL") +#pragma pop_macro("SHADER_USE_PARAMETER_STRUCT") +#pragma pop_macro("SHADER_USE_PARAMETER_STRUCT_WITH_LEGACY_BASE") +#pragma pop_macro("SHADER_USE_ROOT_PARAMETER_STRUCT") +#pragma pop_macro("DECLARE_SHADER_PERMUTATION_IMPL") +#pragma pop_macro("SHADER_PERMUTATION_BOOL") +#pragma pop_macro("SHADER_PERMUTATION_INT") +#pragma pop_macro("SHADER_PERMUTATION_RANGE_INT") +#pragma pop_macro("SHADER_PERMUTATION_SPARSE_INT") +#pragma pop_macro("SHADER_PERMUTATION_ENUM_CLASS") +#pragma pop_macro("STRUCTMEMBER_VERTEXSTREAMCOMPONENT") +#pragma pop_macro("IMPLEMENT_VERTEX_FACTORY_PARAMETER_TYPE") +#pragma pop_macro("DECLARE_VERTEX_FACTORY_TYPE") +#pragma pop_macro("IMPLEMENT_VERTEX_FACTORY_VTABLE") +#pragma pop_macro("IMPLEMENT_VERTEX_FACTORY_TYPE") +#pragma pop_macro("IMPLEMENT_TEMPLATE_VERTEX_FACTORY_TYPE_EX") +#pragma pop_macro("IMPLEMENT_VERTEX_FACTORY_TYPE_EX") +#pragma pop_macro("SCOPED_GPU_EVENT") +#pragma pop_macro("SCOPED_GPU_EVENT_COLOR") +#pragma pop_macro("SCOPED_GPU_EVENTF") +#pragma pop_macro("SCOPED_GPU_EVENTF_COLOR") +#pragma pop_macro("SCOPED_CONDITIONAL_GPU_EVENT") +#pragma pop_macro("SCOPED_CONDITIONAL_GPU_EVENT_COLOR") +#pragma pop_macro("SCOPED_CONDITIONAL_GPU_EVENTF") +#pragma pop_macro("SCOPED_CONDITIONAL_GPU_EVENTF_COLOR") +#pragma pop_macro("BEGIN_GPU_EVENTF") +#pragma pop_macro("BEGIN_GPU_EVENTF_COLOR") +#pragma pop_macro("STOP_GPU_EVENT") +#pragma pop_macro("SCOPED_DRAW_EVENT") +#pragma pop_macro("SCOPED_DRAW_EVENT_COLOR") +#pragma pop_macro("SCOPED_DRAW_EVENTF") +#pragma pop_macro("SCOPED_DRAW_EVENTF_COLOR") +#pragma pop_macro("SCOPED_CONDITIONAL_DRAW_EVENT") +#pragma pop_macro("SCOPED_CONDITIONAL_DRAW_EVENT_COLOR") +#pragma pop_macro("SCOPED_CONDITIONAL_DRAW_EVENTF") +#pragma pop_macro("SCOPED_CONDITIONAL_DRAW_EVENTF_COLOR") +#pragma pop_macro("BEGIN_DRAW_EVENTF") +#pragma pop_macro("BEGIN_DRAW_EVENTF_COLOR") +#pragma pop_macro("STOP_DRAW_EVENT") +#pragma pop_macro("SCOPED_RHI_DRAW_EVENT") +#pragma pop_macro("SCOPED_RHI_DRAW_EVENT_COLOR") +#pragma pop_macro("SCOPED_RHI_DRAW_EVENTF") +#pragma pop_macro("SCOPED_RHI_DRAW_EVENTF_COLOR") +#pragma pop_macro("SCOPED_RHI_CONDITIONAL_DRAW_EVENT") +#pragma pop_macro("SCOPED_RHI_CONDITIONAL_DRAW_EVENT_COLOR") +#pragma pop_macro("SCOPED_RHI_CONDITIONAL_DRAW_EVENTF") +#pragma pop_macro("SCOPED_RHI_CONDITIONAL_DRAW_EVENTF_COLOR") +#pragma pop_macro("SCOPED_COMPUTE_EVENT") +#pragma pop_macro("SCOPED_COMPUTE_EVENT_COLOR") +#pragma pop_macro("SCOPED_COMPUTE_EVENTF") +#pragma pop_macro("SCOPED_COMPUTE_EVENTF_COLOR") +#pragma pop_macro("SCOPED_CONDITIONAL_COMPUTE_EVENT") +#pragma pop_macro("SCOPED_CONDITIONAL_COMPUTE_EVENT_COLOR") +#pragma pop_macro("SCOPED_CONDITIONAL_COMPUTE_EVENTF") +#pragma pop_macro("SCOPED_CONDITIONAL_COMPUTE_EVENTF_COLOR") +#pragma pop_macro("DECLARE_GPU_STAT") +#pragma pop_macro("DECLARE_GPU_DRAWCALL_STAT") +#pragma pop_macro("DECLARE_GPU_DRAWCALL_STAT_EXTERN") +#pragma pop_macro("DECLARE_GPU_STAT_NAMED") +#pragma pop_macro("DECLARE_GPU_DRAWCALL_STAT_NAMED") +#pragma pop_macro("DECLARE_GPU_STAT_NAMED_EXTERN") +#pragma pop_macro("DEFINE_GPU_STAT") +#pragma pop_macro("DEFINE_GPU_DRAWCALL_STAT") +#pragma pop_macro("SCOPED_GPU_STAT") +#pragma pop_macro("GPU_STATS_BEGINFRAME") +#pragma pop_macro("GPU_STATS_ENDFRAME") +#pragma pop_macro("IMPLEMENT_ATMOSPHERE_TEXTURE_PARAM_SET") +#pragma pop_macro("SHADER_VARIATION") +#pragma pop_macro("IMPLEMENT_BASEPASS_VERTEXSHADER_TYPE") +#pragma pop_macro("IMPLEMENT_BASEPASS_VERTEXSHADER_ONLY_TYPE") +#pragma pop_macro("IMPLEMENT_BASEPASS_PIXELSHADER_TYPE") +#pragma pop_macro("IMPLEMENT_BASEPASS_LIGHTMAPPED_SHADER_TYPE") +#pragma pop_macro("IMPLEMENT_CAPSULE_SHADOW_TYPE") +#pragma pop_macro("IMPLEMENT_CAPSULE_APPLY_SHADER_TYPE") +#pragma pop_macro("IMPLEMENT_GetDepthPassShaders") +#pragma pop_macro("VARIATION1") +#pragma pop_macro("IMPLEMENT_REMOVE_OBJECTS_FROM_BUFFER_SHADER_TYPE") +#pragma pop_macro("IMPLEMENT_CONETRACE_CS_TYPE") +#pragma pop_macro("IMPLEMENT_CONETRACE_GLOBAL_CS_TYPE") +#pragma pop_macro("VARIATION") +#pragma pop_macro("IMPLEMENT_GLOBALDF_COMPOSITE_CS_TYPE") +#pragma pop_macro("GROUPSHARED_COMPLEX_TRANSFORM") +#pragma pop_macro("GROUPSHARED_TWO_FOR_ONE_TRANSFORM") +#pragma pop_macro("GROUPSHARED_CONVOLUTION_WTEXTURE") +#pragma pop_macro("GET_COMPLEX_SHADER") +#pragma pop_macro("GET_TWOFORONE_SHADER") +#pragma pop_macro("GET_GROUP_SHARED_TEXTURE_FILTER") +#pragma pop_macro("IMPLEMENT_DENSITY_VERTEXSHADER_TYPE") +#pragma pop_macro("IMPLEMENT_DENSITY_PIXELSHADER_TYPE") +#pragma pop_macro("IMPLEMENT_DENSITY_LIGHTMAPPED_SHADER_TYPE") +#pragma pop_macro("IMPLEMENT_MOBILE_SHADING_BASEPASS_LIGHTMAPPED_VERTEX_SHADER_TYPE") +#pragma pop_macro("IMPLEMENT_MOBILE_SHADING_BASEPASS_LIGHTMAPPED_PIXEL_SHADER_TYPE") +#pragma pop_macro("IMPLEMENT_MOBILE_SHADING_BASEPASS_LIGHTMAPPED_SHADER_TYPE") +#pragma pop_macro("IMPLEMENT_MOBILE_SCENE_CAPTURECOPY") +#pragma pop_macro("SET_SPEEDTREE_TABLE_FLOAT4V") +#pragma pop_macro("FASTVRAM_CVAR") +#pragma pop_macro("CANVAS_HEADER") +#pragma pop_macro("CANVAS_LINE") +#pragma pop_macro("IMPLEMENT_MATERIAL_SHADER_SetParameters") +#pragma pop_macro("IMPLEMENT_SHADOW_DEPTH_SHADERMODE_SHADERS") +#pragma pop_macro("IMPLEMENT_SHADOWDEPTHPASS_PIXELSHADER_TYPE") +#pragma pop_macro("IMPLEMENT_SHADOW_PROJECTION_PIXEL_SHADER") +#pragma pop_macro("IMPLEMENT_MODULATED_SHADOW_PROJECTION_PIXEL_SHADER") +#pragma pop_macro("IMPLEMENT_ONEPASS_POINT_SHADOW_PROJECTION_PIXEL_SHADER") +#pragma pop_macro("COPYMACRO") +#pragma pop_macro("IMPLEMENT_INJECTION_PIXELSHADER_TYPE") +#pragma pop_macro("IMPLEMENT_RESOLVE_SHADER") +#pragma pop_macro("ENTRY") +#pragma pop_macro("IMPLEMENT_POST_PROCESS_PARAM_SET") +#pragma pop_macro("UPDATE_HISTORY_FLAGS") +#pragma pop_macro("ANY_CAPTURE_RENDERED_RECENTLY") +#pragma pop_macro("ANY_HIGHRES_CAPTURE_RENDERED_RECENTLY") +#pragma pop_macro("GET_STENCIL_BIT_MASK") +#pragma pop_macro("STENCIL_LIGHTING_CHANNELS_MASK") +#pragma pop_macro("GET_STENCIL_MOBILE_SM_MASK") +#pragma pop_macro("SCOPED_DRAW_OR_COMPUTE_EVENT") +#pragma pop_macro("IMPLEMENT_MATERIALCHS_TYPE") +#pragma pop_macro("IMPLEMENT_VIRTUALTEXTURE_SHADER_TYPE") +#pragma pop_macro("COMPARE_FIELD_BEGIN") +#pragma pop_macro("COMPARE_FIELD") +#pragma pop_macro("A") +#pragma pop_macro("TRACE_GPUPROFILER_DEFINE_EVENT_TYPE") +#pragma pop_macro("TRACE_GPUPROFILER_DECLARE_EVENT_TYPE_EXTERN") +#pragma pop_macro("TRACE_GPUPROFILER_EVENT_TYPE") +#pragma pop_macro("TRACE_GPUPROFILER_BEGIN_FRAME") +#pragma pop_macro("TRACE_GPUPROFILER_BEGIN_EVENT") +#pragma pop_macro("TRACE_GPUPROFILER_END_EVENT") +#pragma pop_macro("TRACE_GPUPROFILER_END_FRAME") +#pragma pop_macro("RHI_DRAW_CALL_INC") +#pragma pop_macro("RHI_DRAW_CALL_STATS") +#pragma pop_macro("RHISTAT") +#pragma pop_macro("FRHICOMMAND_MACRO") +#pragma pop_macro("ALLOC_COMMAND") +#pragma pop_macro("ALLOC_COMMAND_CL") +#pragma pop_macro("SCOPED_GPU_MASK") +#pragma pop_macro("SCOPED_UNIFORM_BUFFER_GLOBAL_BINDINGS") +#pragma pop_macro("INTERNAL_DECORATOR_COMPUTE") +#pragma pop_macro("IMPLEMENT_DDPSPI_SETTING_WITH_RETURN_TYPE") +#pragma pop_macro("IMPLEMENT_DDPSPI_SETTING") +#pragma pop_macro("GEOMETRY_SHADER") +#pragma pop_macro("TESSELLATION_SHADER") +#pragma pop_macro("RTACTION_MAKE_MASK") +#pragma pop_macro("DUMP_TRANSITION") +#pragma pop_macro("UE_LOG_RIGVMMEMORY") +#pragma pop_macro("BREAK_WHEN_AUDIBLE") +#pragma pop_macro("BREAK_WHEN_TOO_LOUD") +#pragma pop_macro("CHECK_SAMPLE") +#pragma pop_macro("CHECK_SAMPLE2") +#pragma pop_macro("UI_COMMAND_EXT") +#pragma pop_macro("UI_COMMAND") +#pragma pop_macro("APPEND_FONT") +#pragma pop_macro("APPEND_EDITOR_FONT") +#pragma pop_macro("APPEND_RANGE") +#pragma pop_macro("RETURN_TRUE_IF_CHAR_WITHIN_RANGE") +#pragma pop_macro("REGISTER_UNICODE_BLOCK_RANGE") +#pragma pop_macro("AddToNextFocusableWidgetCondidateDebugResults") +#pragma pop_macro("SLATE_CROSS_THREAD_CHECK") +#pragma pop_macro("DRAG_DROP_OPERATOR_TYPE") +#pragma pop_macro("UE_TRACE_SLATE_APPLICATION_TICK_AND_DRAW_WIDGETS") +#pragma pop_macro("UE_TRACE_SLATE_WIDGET_ADDED") +#pragma pop_macro("UE_TRACE_SLATE_WIDGET_DEBUG_INFO") +#pragma pop_macro("UE_TRACE_SLATE_WIDGET_REMOVED") +#pragma pop_macro("UE_TRACE_SCOPED_SLATE_WIDGET_PAINT") +#pragma pop_macro("UE_TRACE_SLATE_WIDGET_UPDATED") +#pragma pop_macro("UE_TRACE_SLATE_WIDGET_INVALIDATED") +#pragma pop_macro("UE_TRACE_SLATE_ROOT_INVALIDATED") +#pragma pop_macro("UE_TRACE_SLATE_ROOT_CHILDORDER_INVALIDATED") +#pragma pop_macro("SLATE_METADATA_TYPE") +#pragma pop_macro("SNew") +#pragma pop_macro("SAssignNew") +#pragma pop_macro("SLATE_BEGIN_ARGS") +#pragma pop_macro("SLATE_USER_ARGS") +#pragma pop_macro("HACK_SLATE_SLOT_ARGS") +#pragma pop_macro("SLATE_END_ARGS") +#pragma pop_macro("SLATE_ATTRIBUTE") +#pragma pop_macro("SLATE_ARGUMENT") +#pragma pop_macro("SLATE_ARGUMENT_DEFAULT") +#pragma pop_macro("SLATE_STYLE_ARGUMENT") +#pragma pop_macro("SLATE_SUPPORTS_SLOT") +#pragma pop_macro("SLATE_SUPPORTS_SLOT_WITH_ARGS") +#pragma pop_macro("SLATE_NAMED_SLOT") +#pragma pop_macro("SLATE_DEFAULT_SLOT") +#pragma pop_macro("SLATE_EVENT") +#pragma pop_macro("SCOPE_CYCLE_SWIDGET") +#pragma pop_macro("IMPLEMENT_SLATE_VERTEXMATERIALSHADER_TYPE") +#pragma pop_macro("IMPLEMENT_SLATE_MATERIALSHADER_TYPE") +#pragma pop_macro("SLATE_DRAW_EVENT") +#pragma pop_macro("IMPLEMENT_SLATE_PIXELSHADER_TYPE") +#pragma pop_macro("UE_TRACE_EVENT_DEFINE") +#pragma pop_macro("UE_TRACE_EVENT_BEGIN") +#pragma pop_macro("UE_TRACE_EVENT_BEGIN_EXTERN") +#pragma pop_macro("UE_TRACE_EVENT_FIELD") +#pragma pop_macro("UE_TRACE_EVENT_END") +#pragma pop_macro("UE_TRACE_LOG") +#pragma pop_macro("UE_TRACE_LOG_SCOPED") +#pragma pop_macro("UE_TRACE_LOG_SCOPED_T") +#pragma pop_macro("UE_TRACE_CHANNEL") +#pragma pop_macro("UE_TRACE_CHANNEL_EXTERN") +#pragma pop_macro("UE_TRACE_CHANNEL_MODULE_EXTERN") +#pragma pop_macro("UE_TRACE_CHANNEL_DEFINE") +#pragma pop_macro("UE_TRACE_CHANNELEXPR_IS_ENABLED") +#pragma pop_macro("TRACE_PRIVATE_FIELD") +#pragma pop_macro("TRACE_PRIVATE_CHANNEL_DECLARE") +#pragma pop_macro("TRACE_PRIVATE_CHANNEL_IMPL") +#pragma pop_macro("TRACE_PRIVATE_CHANNEL") +#pragma pop_macro("TRACE_PRIVATE_CHANNEL_MODULE_EXTERN") +#pragma pop_macro("TRACE_PRIVATE_CHANNEL_DEFINE") +#pragma pop_macro("TRACE_PRIVATE_CHANNEL_EXTERN") +#pragma pop_macro("TRACE_PRIVATE_CHANNELEXPR_IS_ENABLED") +#pragma pop_macro("TRACE_PRIVATE_EVENT_DEFINE") +#pragma pop_macro("TRACE_PRIVATE_EVENT_BEGIN") +#pragma pop_macro("TRACE_PRIVATE_EVENT_BEGIN_EXTERN") +#pragma pop_macro("TRACE_PRIVATE_EVENT_BEGIN_IMPL") +#pragma pop_macro("TRACE_PRIVATE_EVENT_FIELD") +#pragma pop_macro("TRACE_PRIVATE_EVENT_END") +#pragma pop_macro("TRACE_PRIVATE_LOG_PRELUDE") +#pragma pop_macro("TRACE_PRIVATE_LOG_EPILOG") +#pragma pop_macro("TRACE_PRIVATE_LOG") +#pragma pop_macro("TRACE_PRIVATE_LOG_SCOPED") +#pragma pop_macro("TRACE_PRIVATE_LOG_SCOPED_T") +#pragma pop_macro("IMPLEMENT_TYPED_UMG_LIST") +#pragma pop_macro("BIND_UOBJECT_ATTRIBUTE") +#pragma pop_macro("BIND_UOBJECT_DELEGATE") +#pragma pop_macro("OPTIONAL_BINDING") +#pragma pop_macro("PROPERTY_BINDING") +#pragma pop_macro("BITFIELD_PROPERTY_BINDING") +#pragma pop_macro("PROPERTY_BINDING_IMPLEMENTATION") +#pragma pop_macro("GAME_SAFE_OPTIONAL_BINDING") +#pragma pop_macro("GAME_SAFE_BINDING_IMPLEMENTATION") +#pragma pop_macro("OPTIONAL_BINDING_CONVERT") +#pragma pop_macro("UA_SYSTEM_ERROR") +#pragma pop_macro("SOUND_CONVERT_CHECK") +#pragma pop_macro("DEBUG_AUDIO_CHECK_AUDIO_THREAD") +#pragma pop_macro("DEBUG_AUDIO_CHECK_MAIN_THREAD") +#pragma pop_macro("DEBUG_AUDIO_CHECK") +#pragma pop_macro("DEBUG_AUDIO_CHECK_MSG") +#pragma pop_macro("AUDIO_VOICE_CHECK_ERROR") +#pragma pop_macro("AUDIO_VOICE_CHECK_SUSPEND") +#pragma pop_macro("VOICE_CHECK_INITIALIZATION") +#pragma pop_macro("UA_DEVICE_PLATFORM_ERROR") +#pragma pop_macro("AU_DEVICE_PARAM_ERROR") +#pragma pop_macro("AU_DEVICE_WARNING") +#pragma pop_macro("VectorIntShuffle") +#pragma pop_macro("VK_DYNAMICAPI_TO_VULKANRHI") +#pragma pop_macro("VULKAN_REPORT_LOG") +#pragma pop_macro("VKSWITCHCASE") +#pragma pop_macro("AppendBitFieldName") +#pragma pop_macro("VULKAN_SET_DEBUG_NAME") +#pragma pop_macro("VERIFYVULKANRESULT_INIT") +#pragma pop_macro("LLM_SCOPE_VULKAN") +#pragma pop_macro("LLM_PLATFORM_SCOPE_VULKAN") +#pragma pop_macro("LLM_TRACK_VULKAN_HIGH_LEVEL_ALLOC") +#pragma pop_macro("LLM_TRACK_VULKAN_HIGH_LEVEL_FREE") +#pragma pop_macro("LLM_TRACK_VULKAN_SPARE_MEMORY_GPU") +#pragma pop_macro("ENUM_VK_ENTRYPOINTS_INSTANCE") +#pragma pop_macro("ENUM_VK_ENTRYPOINTS_SURFACE_INSTANCE") +#pragma pop_macro("ENUM_VK_ENTRYPOINTS_BASE") +#pragma pop_macro("ENUM_VK_ENTRYPOINTS_OPTIONAL_BASE") +#pragma pop_macro("ENUM_VK_ENTRYPOINTS_OPTIONAL_INSTANCE") +#pragma pop_macro("ENUM_VK_ENTRYPOINTS_ALL") +#pragma pop_macro("DECLARE_VK_ENTRYPOINTS") +#pragma pop_macro("VULKAN_LOGMEMORY") +#pragma pop_macro("VULKAN_FILL_TRACK_INFO") +#pragma pop_macro("VULKAN_FREE_TRACK_INFO") +#pragma pop_macro("VULKAN_TRACK_STRING") +#pragma pop_macro("VKSWITCH") +#pragma pop_macro("LRUPRINT") +#pragma pop_macro("LRUPRINT_DEBUG") +#pragma pop_macro("VKERRORCASE") +#pragma pop_macro("DEFINE_VK_ENTRYPOINTS") +#pragma pop_macro("CHECK_VK_ENTRYPOINTS") +#pragma pop_macro("GET_VK_ENTRYPOINTS") +#pragma pop_macro("GETINSTANCE_VK_ENTRYPOINTS") +#pragma pop_macro("CLEAR_VK_ENTRYPOINTS") +#pragma pop_macro("ENUM_VK_ENTRYPOINTS_PLATFORM_BASE") +#pragma pop_macro("ENUM_VK_ENTRYPOINTS_PLATFORM_INSTANCE") +#pragma pop_macro("ENUM_VK_ENTRYPOINTS_OPTIONAL_PLATFORM_INSTANCE") +#pragma pop_macro("VULKAN_SIGNAL_UNIMPLEMENTED") +#pragma pop_macro("VULKAN_TRACK_OBJECT_CREATE") +#pragma pop_macro("VULKAN_TRACK_OBJECT_DELETE") +#pragma pop_macro("VERIFYVULKANRESULT") +#pragma pop_macro("VERIFYVULKANRESULT_EXPANDED") +#pragma pop_macro("XAUDIO2_GOTO_CLEANUP_ON_FAIL") +#pragma pop_macro("XAUDIO2_RETURN_ON_FAIL") +#pragma pop_macro("NVAFTERMATH_ON_ERROR") +#pragma pop_macro("D3D11_STATE_CACHE_VERIFY") +#pragma pop_macro("D3D11_STATE_CACHE_VERIFY_PRE") +#pragma pop_macro("D3D11_STATE_CACHE_VERIFY_POST") +#pragma pop_macro("CACHE_NV_AFTERMATH_ENABLED") +#pragma pop_macro("START_NV_AFTERMATH") +#pragma pop_macro("STOP_NV_AFTERMATH") +#pragma pop_macro("VERIFYD3D11RESULT_EX") +#pragma pop_macro("VERIFYD3D11RESULT") +#pragma pop_macro("VERIFYD3D11RESULT_NOEXIT") +#pragma pop_macro("VERIFYD3D11SHADERRESULT") +#pragma pop_macro("VERIFYD3D11CREATETEXTURERESULT") +#pragma pop_macro("VERIFYD3D11RESIZEVIEWPORTRESULT") +#pragma pop_macro("CLEANUP_ON_FAIL") +#pragma pop_macro("RETURN_FALSE_ON_FAIL") #undef LIBCARLA_INCLUDED_FROM_UE4 diff --git a/LibCarla/source/test/server/test_benchmark_streaming.cpp b/LibCarla/source/test/server/test_benchmark_streaming.cpp index f1f55087d..b6732e595 100644 --- a/LibCarla/source/test/server/test_benchmark_streaming.cpp +++ b/LibCarla/source/test/server/test_benchmark_streaming.cpp @@ -126,7 +126,7 @@ private: static size_t get_max_concurrency() { size_t concurrency = std::thread::hardware_concurrency() / 2u; - return std::max(2ul, concurrency); + return std::max((size_t) 2u, concurrency); } static void benchmark_image( diff --git a/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Game/CarlaEngine.cpp b/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Game/CarlaEngine.cpp index d6ce0f353..72a7a7964 100644 --- a/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Game/CarlaEngine.cpp +++ b/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Game/CarlaEngine.cpp @@ -18,6 +18,16 @@ #include "PhysicsEngine/PhysicsSettings.h" #include "Carla/MapGen/LargeMapManager.h" +#include +#include +#include +#include +#include +#include +#include +#include +#include + #include // ============================================================================= @@ -62,8 +72,12 @@ void FCarlaEngine::NotifyInitGame(const UCarlaSettings &Settings) TRACE_CPUPROFILER_EVENT_SCOPE_STR(__FUNCTION__); if (!bIsRunning) { - const auto StreamingPort = Settings.StreamingPort.Get(Settings.RPCPort + 1u); - auto BroadcastStream = Server.Start(Settings.RPCPort, StreamingPort); + const auto StreamingPort = Settings.StreamingPort; + const auto SecondaryPort = Settings.SecondaryPort; + const auto PrimaryIP = Settings.PrimaryIP; + const auto PrimaryPort = Settings.PrimaryPort; + + auto BroadcastStream = Server.Start(Settings.RPCPort, StreamingPort, SecondaryPort); Server.AsyncRun(FCarlaEngine_GetNumberOfThreadsForRPCServer()); WorldObserver.SetStream(BroadcastStream); @@ -79,10 +93,78 @@ void FCarlaEngine::NotifyInitGame(const UCarlaSettings &Settings) &FCarlaEngine::OnEpisodeSettingsChanged); bIsRunning = true; + + // check to convert this as secondary server + if (!PrimaryIP.empty()) + { + // we are secondary server, connecting to primary server + bIsPrimaryServer = false; + Secondary = std::make_shared( + PrimaryIP, + PrimaryPort, + [=](carla::multigpu::MultiGPUCommand Id, carla::Buffer Data) { + struct CarlaStreamBuffer : public std::streambuf + { + CarlaStreamBuffer(char *buf, std::size_t size) { setg(buf, buf, buf + size); } + }; + switch (Id) { + case carla::multigpu::MultiGPUCommand::SEND_FRAME: + { + if(GetCurrentEpisode()) + { + TRACE_CPUPROFILER_EVENT_SCOPE_STR("MultiGPUCommand::SEND_FRAME"); + // convert frame data from buffer to istream + CarlaStreamBuffer TempStream((char *) Data.data(), Data.size()); + std::istream InStream(&TempStream); + GetCurrentEpisode()->GetFrameData().Read(InStream); + { + TRACE_CPUPROFILER_EVENT_SCOPE_STR("FramesToProcess.emplace_back"); + std::lock_guard Lock(FrameToProcessMutex); + FramesToProcess.emplace_back(GetCurrentEpisode()->GetFrameData()); + } + } + // forces a tick + Server.Tick(); + break; + } + case carla::multigpu::MultiGPUCommand::LOAD_MAP: + break; + + case carla::multigpu::MultiGPUCommand::GET_TOKEN: + { + // get the sensor id + auto sensor_id = *(reinterpret_cast(Data.data())); + // query dispatcher + carla::streaming::detail::token_type token(Server.GetStreamingServer().GetToken(sensor_id)); + carla::Buffer buf(reinterpret_cast(&token), (size_t) sizeof(token)); + carla::log_info("responding with a token for port ", token.get_port()); + Secondary->Write(std::move(buf)); + break; + } + + case carla::multigpu::MultiGPUCommand::YOU_ALIVE: + { + std::string msg("Yes, I'm alive"); + carla::Buffer buf((unsigned char *) msg.c_str(), (size_t) msg.size()); + carla::log_info("responding is alive command"); + Secondary->Write(std::move(buf)); + break; + } + } + }); + Secondary->Connect(); + // set this server in synchronous mode + bSynchronousMode = true; + } + else + { + // we are primary server, starting server + bIsPrimaryServer = true; + SecondaryServer = Server.GetSecondaryServer(); + } } bMapChanged = true; - } void FCarlaEngine::NotifyBeginEpisode(UCarlaEpisode &Episode) @@ -99,9 +181,16 @@ void FCarlaEngine::NotifyBeginEpisode(UCarlaEpisode &Episode) CurrentSettings.TileStreamingDistance = LargeMapManager->GetLayerStreamingDistance(); CurrentSettings.ActorActiveDistance = LargeMapManager->GetActorStreamingDistance(); } + + if (!bIsPrimaryServer) + { + // set this secondary server with no-rendering mode + CurrentSettings.bNoRenderingMode = true; + } + CurrentEpisode->ApplySettings(CurrentSettings); - ResetFrameCounter(); + ResetFrameCounter(GFrameNumber); // make connection between Episode and Recorder if (Recorder) @@ -112,6 +201,8 @@ void FCarlaEngine::NotifyBeginEpisode(UCarlaEpisode &Episode) } Server.NotifyBeginEpisode(Episode); + + Episode.bIsPrimaryServer = bIsPrimaryServer; } void FCarlaEngine::NotifyEndEpisode() @@ -125,29 +216,66 @@ void FCarlaEngine::OnPreTick(UWorld *, ELevelTick TickType, float DeltaSeconds) TRACE_CPUPROFILER_EVENT_SCOPE_STR(__FUNCTION__); if (TickType == ELevelTick::LEVELTICK_All) { + // process RPC commands + if (bIsPrimaryServer) + { + do + { + Server.RunSome(10u); + } + while (bSynchronousMode && !Server.TickCueReceived()); + } + else + { + do + { + Server.RunSome(10u); + } + while (!FramesToProcess.size()); + } + // update frame counter UpdateFrameCounter(); - // process RPC commands - do - { - Server.RunSome(10u); - } - while (bSynchronousMode && !Server.TickCueReceived()); - if (CurrentEpisode != nullptr) { CurrentEpisode->TickTimers(DeltaSeconds); } + if (!bIsPrimaryServer && GetCurrentEpisode()) + { + if (FramesToProcess.size()) + { + TRACE_CPUPROFILER_EVENT_SCOPE_STR("FramesToProcess.PlayFrameData"); + std::lock_guard Lock(FrameToProcessMutex); + FramesToProcess.front().PlayFrameData(GetCurrentEpisode(), MappedId); + FramesToProcess.erase(FramesToProcess.begin()); // remove first element + } + } } } + void FCarlaEngine::OnPostTick(UWorld *World, ELevelTick TickType, float DeltaSeconds) { TRACE_CPUPROFILER_EVENT_SCOPE_STR(__FUNCTION__); // tick the recorder/replayer system if (GetCurrentEpisode()) { + if (bIsPrimaryServer) + { + if (SecondaryServer->HasClientsConnected()) { + GetCurrentEpisode()->GetFrameData().GetFrameData(GetCurrentEpisode()); + std::ostringstream OutStream; + GetCurrentEpisode()->GetFrameData().Write(OutStream); + + // send frame data to secondary + std::string Tmp(OutStream.str()); + SecondaryServer->GetCommander().SendFrameData(carla::Buffer(std::move((unsigned char *) Tmp.c_str()), (size_t) Tmp.size())); + + GetCurrentEpisode()->GetFrameData().Clear(); + } + } + auto* EpisodeRecorder = GetCurrentEpisode()->GetRecorder(); if (EpisodeRecorder) { @@ -170,6 +298,7 @@ void FCarlaEngine::OnPostTick(UWorld *World, ELevelTick TickType, float DeltaSec // send the worldsnapshot WorldObserver.BroadcastTick(*CurrentEpisode, DeltaSeconds, bMapChanged, LightUpdatePending); + CurrentEpisode->GetSensorManager().PostPhysTick(World, TickType, DeltaSeconds); ResetSimulationState(); } } diff --git a/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Game/CarlaEngine.h b/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Game/CarlaEngine.h index 61f98da43..5640437c5 100644 --- a/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Game/CarlaEngine.h +++ b/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Game/CarlaEngine.h @@ -14,6 +14,15 @@ #include "Misc/CoreDelegates.h" +#include +#include +#include +#include +#include +#include + +#include + class UCarlaSettings; struct FEpisodeSettings; @@ -93,4 +102,14 @@ private: FDelegateHandle OnPostTickHandle; FDelegateHandle OnEpisodeSettingsChangeHandle; + + bool bIsPrimaryServer = true; + + std::unordered_map MappedId; + + std::shared_ptr SecondaryServer; + std::shared_ptr Secondary; + + std::vector FramesToProcess; + std::mutex FrameToProcessMutex; }; diff --git a/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Game/CarlaEpisode.cpp b/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Game/CarlaEpisode.cpp index 0a6a6190c..80d07aa0c 100644 --- a/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Game/CarlaEpisode.cpp +++ b/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Game/CarlaEpisode.cpp @@ -54,6 +54,7 @@ UCarlaEpisode::UCarlaEpisode(const FObjectInitializer &ObjectInitializer) Id(URandomEngine::GenerateRandomId()) { ActorDispatcher = CreateDefaultSubobject(TEXT("ActorDispatcher")); + FrameData.SetEpisode(this); } bool UCarlaEpisode::LoadNewEpisode(const FString &MapString, bool ResetSettings) @@ -282,6 +283,13 @@ void UCarlaEpisode::AttachActors( UActorAttacher::AttachActors(Child, Parent, InAttachmentType); + if (bIsPrimaryServer) + { + GetFrameData().AddEvent( + CarlaRecorderEventParent{ + FindCarlaActor(Child)->GetActorId(), + FindCarlaActor(Parent)->GetActorId()}); + } // recorder event if (Recorder->IsEnabled()) { @@ -405,6 +413,14 @@ TPair UCarlaEpisode::SpawnActorWithInfo( // NewTransform.AddToTranslation(-1.0f * FVector(CurrentMapOrigin)); auto result = ActorDispatcher->SpawnActor(LocalTransform, thisActorDescription, DesiredId); + if (result.Key == EActorSpawnResultStatus::Success && bIsPrimaryServer) + { + GetFrameData().CreateRecorderEventAdd( + result.Value->GetActorId(), + static_cast(result.Value->GetActorType()), + Transform, + std::move(thisActorDescription)); + } if (Recorder->IsEnabled()) { if (result.Key == EActorSpawnResultStatus::Success) diff --git a/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Game/CarlaEpisode.h b/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Game/CarlaEpisode.h index 7eaea9e5b..8b27b6bc1 100644 --- a/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Game/CarlaEpisode.h +++ b/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Game/CarlaEpisode.h @@ -13,6 +13,8 @@ #include "Carla/Settings/EpisodeSettings.h" #include "Carla/Util/ActorAttacher.h" #include "Carla/Weather/Weather.h" +#include "Carla/Game/FrameData.h" +#include "Carla/Sensor/SensorManager.h" #include "GameFramework/Pawn.h" @@ -233,6 +235,11 @@ public: bool DestroyActor(carla::rpc::ActorId ActorId) { + if (bIsPrimaryServer) + { + GetFrameData().AddEvent( + CarlaRecorderEventDel{ActorId}); + } if (Recorder->IsEnabled()) { // recorder event @@ -289,6 +296,12 @@ public: void SetCurrentMapOrigin(const FIntVector& NewOrigin) { CurrentMapOrigin = NewOrigin; } + FFrameData& GetFrameData() { return FrameData; } + + FSensorManager& GetSensorManager() { return SensorManager; } + + bool bIsPrimaryServer = true; + private: friend class ACarlaGameModeBase; @@ -340,4 +353,8 @@ private: carla::geom::GeoLocation MapGeoReference; FIntVector CurrentMapOrigin; + + FFrameData FrameData; + + FSensorManager SensorManager; }; diff --git a/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Game/FrameData.cpp b/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Game/FrameData.cpp new file mode 100644 index 000000000..2a691c99c --- /dev/null +++ b/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Game/FrameData.cpp @@ -0,0 +1,1032 @@ +// Copyright (c) 2022 Computer Vision Center (CVC) at the Universitat Autonoma +// de Barcelona (UAB). +// +// This work is licensed under the terms of the MIT license. +// For a copy, see . + +#include "FrameData.h" +#include "Carla/Game/CarlaEpisode.h" +#include "Carla/Actor/CarlaActor.h" +#include "Carla/Game/CarlaEngine.h" +#include "Carla/Game/CarlaEpisode.h" + + +void FFrameData::GetFrameData(UCarlaEpisode *ThisEpisode, bool bAdditionalData) +{ + Episode = ThisEpisode; + // PlatformTime.UpdateTime(); + const FActorRegistry &Registry = Episode->GetActorRegistry(); + + // through all actors in registry + for (auto It = Registry.begin(); It != Registry.end(); ++It) + { + FCarlaActor* View = It.Value().Get(); + + switch (View->GetActorType()) + { + // save the transform for props + case FCarlaActor::ActorType::Other: + case FCarlaActor::ActorType::Sensor: + AddActorPosition(View); + break; + + // save the transform of all vehicles + case FCarlaActor::ActorType::Vehicle: + AddActorPosition(View); + AddVehicleAnimation(View); + AddVehicleLight(View); + if (bAdditionalData) + { + AddActorKinematics(View); + } + break; + + // save the transform of all walkers + case FCarlaActor::ActorType::Walker: + AddActorPosition(View); + AddWalkerAnimation(View); + if (bAdditionalData) + { + AddActorKinematics(View); + } + break; + + // save the state of each traffic light + case FCarlaActor::ActorType::TrafficLight: + AddTrafficLightState(View); + break; + } + } + GetFrameCounter(); +} + +void FFrameData::PlayFrameData( + UCarlaEpisode *ThisEpisode, + std::unordered_map& MappedId) +{ + + for(const CarlaRecorderEventAdd &EventAdd : EventsAdd.GetEvents()) + { + uint32_t OldId = EventAdd.DatabaseId; + // Todo: check memory corruption of EventAdd.DatabaseId + auto Result = ProcessReplayerEventAdd( + EventAdd.Location, + EventAdd.Rotation, + EventAdd.Description, + EventAdd.DatabaseId, + false, + true); + switch (Result.first) + { + // actor not created + case 0: + UE_LOG(LogCarla, Log, TEXT("actor could not be created")); + break; + + // actor created but with different id + case 1: + // mapping id (recorded Id is a new Id in replayer) + MappedId[OldId] = Result.second; + break; + + // actor reused from existing + case 2: + // mapping id (say desired Id is mapped to what) + MappedId[OldId] = Result.second; + break; + } + } + + for (const CarlaRecorderEventDel &EventDel : EventsDel.GetEvents()) + { + ProcessReplayerEventDel(MappedId[EventDel.DatabaseId]); + MappedId.erase(EventDel.DatabaseId); + } + + for (const CarlaRecorderEventParent &EventParent : EventsParent.GetEvents()) + { + // ProcessReplayerEventParent(MappedId[EventParent.DatabaseId], MappedId[EventParent.DatabaseIdParent]); + } + + for (const CarlaRecorderPosition &Position : Positions.GetPositions()) + { + CarlaRecorderPosition Pos = Position; + auto NewId = MappedId.find(Pos.DatabaseId); + if (NewId != MappedId.end()) + { + Pos.DatabaseId = NewId->second; + ProcessReplayerPosition(Pos, Pos, 0.0, 0.0); + } + } + + for (const CarlaRecorderStateTrafficLight &State : States.GetStates()) + { + CarlaRecorderStateTrafficLight StateTrafficLight = State; + StateTrafficLight.DatabaseId = MappedId[StateTrafficLight.DatabaseId]; + ProcessReplayerStateTrafficLight(StateTrafficLight); + } + + for (const CarlaRecorderAnimVehicle &AnimVehicle : Vehicles.GetVehicles()) + { + CarlaRecorderAnimVehicle Vehicle = AnimVehicle; + Vehicle.DatabaseId = MappedId[Vehicle.DatabaseId]; + ProcessReplayerAnimVehicle(Vehicle); + } + + for (const CarlaRecorderAnimWalker &AnimWalker : Walkers.GetWalkers()) + { + CarlaRecorderAnimWalker Walker = AnimWalker; + Walker.DatabaseId = MappedId[Walker.DatabaseId]; + ProcessReplayerAnimWalker(Walker); + } + + for (const CarlaRecorderLightVehicle &LightVehicle : LightVehicles.GetLightVehicles()) + { + CarlaRecorderLightVehicle Light = LightVehicle; + Light.DatabaseId = MappedId[Light.DatabaseId]; + ProcessReplayerLightVehicle(Light); + } + + for (const CarlaRecorderLightScene &Light : LightScenes.GetLights()) + { + ProcessReplayerLightScene(Light); + } + + SetFrameCounter(); +} + +void FFrameData::Clear() +{ + EventsAdd.Clear(); + EventsDel.Clear(); + EventsParent.Clear(); + Collisions.Clear(); + Positions.Clear(); + States.Clear(); + Vehicles.Clear(); + Walkers.Clear(); + LightVehicles.Clear(); + LightScenes.Clear(); + Kinematics.Clear(); + BoundingBoxes.Clear(); + TriggerVolumes.Clear(); + PhysicsControls.Clear(); + TrafficLightTimes.Clear(); + FrameCounter.FrameCounter = 0; +} + +void FFrameData::Write(std::ostream& OutStream) +{ + EventsAdd.Write(OutStream); + EventsDel.Write(OutStream); + EventsParent.Write(OutStream); + Positions.Write(OutStream); + States.Write(OutStream); + Vehicles.Write(OutStream); + Walkers.Write(OutStream); + LightVehicles.Write(OutStream); + LightScenes.Write(OutStream); + TrafficLightTimes.Write(OutStream); + FrameCounter.Write(OutStream); +} +void FFrameData::Read(std::istream& InStream) +{ + Clear(); + while(!InStream.eof()) + { + Header header; + ReadValue(InStream, header.Id); + ReadValue(InStream, header.Size); + switch (header.Id) + { + // events add + case static_cast(CarlaRecorderPacketId::EventAdd): + EventsAdd.Read(InStream); + break; + + // events del + case static_cast(CarlaRecorderPacketId::EventDel): + EventsDel.Read(InStream); + break; + + // events parent + case static_cast(CarlaRecorderPacketId::EventParent): + EventsParent.Read(InStream); + break; + + // positions + case static_cast(CarlaRecorderPacketId::Position): + Positions.Read(InStream); + break; + + // states + case static_cast(CarlaRecorderPacketId::State): + States.Read(InStream); + break; + + // vehicle animation + case static_cast(CarlaRecorderPacketId::AnimVehicle): + Vehicles.Read(InStream); + break; + + // walker animation + case static_cast(CarlaRecorderPacketId::AnimWalker): + Walkers.Read(InStream); + break; + + // vehicle light animation + case static_cast(CarlaRecorderPacketId::VehicleLight): + LightVehicles.Read(InStream); + break; + + // scene lights animation + case static_cast(CarlaRecorderPacketId::SceneLight): + LightScenes.Read(InStream); + break; + + case static_cast(CarlaRecorderPacketId::FrameCounter): + FrameCounter.Read(InStream); + break; + + // unknown packet, just skip + default: + // skip packet + InStream.seekg(header.Size, std::ios::cur); + break; + + } + } +} + +void FFrameData::CreateRecorderEventAdd( + uint32_t DatabaseId, + uint8_t Type, + const FTransform &Transform, + FActorDescription ActorDescription) +{ + CarlaRecorderActorDescription Description; + Description.UId = ActorDescription.UId; + Description.Id = ActorDescription.Id; + + // attributes + Description.Attributes.reserve(ActorDescription.Variations.Num()); + for (const auto &item : ActorDescription.Variations) + { + CarlaRecorderActorAttribute Attr; + Attr.Type = static_cast(item.Value.Type); + Attr.Id = item.Value.Id; + Attr.Value = item.Value.Value; + // check for empty attributes + if (!Attr.Id.IsEmpty()) + { + Description.Attributes.emplace_back(std::move(Attr)); + } + } + + // recorder event + CarlaRecorderEventAdd RecEvent + { + DatabaseId, + Type, + Transform.GetTranslation(), + Transform.GetRotation().Euler(), + std::move(Description) + }; + AddEvent(std::move(RecEvent)); + + FCarlaActor* CarlaActor = Episode->FindCarlaActor(DatabaseId); + // Other events related to spawning actors + // check if it is a vehicle to get initial physics control + ACarlaWheeledVehicle* Vehicle = Cast(CarlaActor->GetActor()); + if (Vehicle) + { + AddPhysicsControl(*Vehicle); + } + + ATrafficLightBase* TrafficLight = Cast(CarlaActor->GetActor()); + if (TrafficLight) + { + AddTrafficLightTime(*TrafficLight); + } + + ATrafficSignBase* TrafficSign = Cast(CarlaActor->GetActor()); + if (TrafficSign) + { + // Trigger volume in global coordinates + AddTriggerVolume(*TrafficSign); + } + else + { + // Bounding box in local coordinates + AddActorBoundingBox(CarlaActor); + } +} + + +void FFrameData::AddActorPosition(FCarlaActor *CarlaActor) +{ + check(CarlaActor != nullptr); + + FTransform Transform = CarlaActor->GetActorGlobalTransform(); + // get position of the vehicle + AddPosition(CarlaRecorderPosition + { + CarlaActor->GetActorId(), + Transform.GetLocation(), + Transform.GetRotation().Euler() + }); +} + + +void FFrameData::AddVehicleAnimation(FCarlaActor *CarlaActor) +{ + check(CarlaActor != nullptr); + + if (CarlaActor->IsPendingKill()) + { + return; + } + + FVehicleControl Control; + CarlaActor->GetVehicleControl(Control); + + // save + CarlaRecorderAnimVehicle Record; + Record.DatabaseId = CarlaActor->GetActorId(); + Record.Steering = Control.Steer; + Record.Throttle = Control.Throttle; + Record.Brake = Control.Brake; + Record.bHandbrake = Control.bHandBrake; + Record.Gear = Control.Gear; + AddAnimVehicle(Record); +} + +void FFrameData::AddWalkerAnimation(FCarlaActor *CarlaActor) +{ + check(CarlaActor != nullptr); + + if (!CarlaActor->IsPendingKill()) + { + FWalkerControl Control; + CarlaActor->GetWalkerControl(Control); + AddAnimWalker(CarlaRecorderAnimWalker + { + CarlaActor->GetActorId(), + Control.Speed + }); + } +} + +void FFrameData::AddTrafficLightState(FCarlaActor *CarlaActor) +{ + check(CarlaActor != nullptr); + + ETrafficLightState LightState = CarlaActor->GetTrafficLightState(); + UTrafficLightController* Controller = CarlaActor->GetTrafficLightController(); + if (Controller) + { + ATrafficLightGroup* Group = Controller->GetGroup(); + if (Group) + { + AddState(CarlaRecorderStateTrafficLight + { + CarlaActor->GetActorId(), + Group->IsFrozen(), + Controller->GetElapsedTime(), + static_cast(LightState) + }); + } + } +} + +void FFrameData::AddVehicleLight(FCarlaActor *CarlaActor) +{ + check(CarlaActor != nullptr); + + FVehicleLightState LightState; + CarlaActor->GetVehicleLightState(LightState); + CarlaRecorderLightVehicle LightVehicle; + LightVehicle.DatabaseId = CarlaActor->GetActorId(); + LightVehicle.State = carla::rpc::VehicleLightState(LightState).light_state; + AddLightVehicle(LightVehicle); +} + +void FFrameData::AddActorKinematics(FCarlaActor *CarlaActor) +{ + check(CarlaActor != nullptr); + + FVector Velocity, AngularVelocity; + constexpr float TO_METERS = 1e-2; + Velocity = TO_METERS* CarlaActor->GetActorVelocity(); + AngularVelocity = CarlaActor->GetActorAngularVelocity(); + CarlaRecorderKinematics Kinematic = + { + CarlaActor->GetActorId(), + Velocity, + AngularVelocity + }; + AddKinematics(Kinematic); +} +void FFrameData::AddActorBoundingBox(FCarlaActor *CarlaActor) +{ + check(CarlaActor != nullptr); + + const auto &Box = CarlaActor->GetActorInfo()->BoundingBox; + CarlaRecorderActorBoundingBox BoundingBox = + { + CarlaActor->GetActorId(), + {Box.Origin, Box.Extent} + }; + + AddBoundingBox(BoundingBox); +} + +void FFrameData::AddTriggerVolume(const ATrafficSignBase &TrafficSign) +{ + TArray Triggers = TrafficSign.GetTriggerVolumes(); + if(!Triggers.Num()) + { + return; + } + UBoxComponent* Trigger = Triggers.Top(); + auto VolumeOrigin = Trigger->GetComponentLocation(); + auto VolumeExtent = Trigger->GetScaledBoxExtent(); + CarlaRecorderActorBoundingBox TriggerVolume = + { + Episode->GetActorRegistry().FindCarlaActor(&TrafficSign)->GetActorId(), + {VolumeOrigin, VolumeExtent} + }; + TriggerVolumes.Add(TriggerVolume); +} + +void FFrameData::AddPhysicsControl(const ACarlaWheeledVehicle& Vehicle) +{ + CarlaRecorderPhysicsControl Control; + Control.DatabaseId = Episode->GetActorRegistry().FindCarlaActor(&Vehicle)->GetActorId(); + Control.VehiclePhysicsControl = Vehicle.GetVehiclePhysicsControl(); + PhysicsControls.Add(Control); +} + +void FFrameData::AddTrafficLightTime(const ATrafficLightBase& TrafficLight) +{ + auto DatabaseId = Episode->GetActorRegistry().FindCarlaActor(&TrafficLight)->GetActorId(); + CarlaRecorderTrafficLightTime TrafficLightTime{ + DatabaseId, + TrafficLight.GetGreenTime(), + TrafficLight.GetYellowTime(), + TrafficLight.GetRedTime() + }; + TrafficLightTimes.Add(TrafficLightTime); +} + + +void FFrameData::AddPosition(const CarlaRecorderPosition &Position) +{ + Positions.Add(Position); +} + +void FFrameData::AddEvent(const CarlaRecorderEventAdd &Event) +{ + EventsAdd.Add(std::move(Event)); +} + +void FFrameData::AddEvent(const CarlaRecorderEventDel &Event) +{ + EventsDel.Add(std::move(Event)); +} + +void FFrameData::AddEvent(const CarlaRecorderEventParent &Event) +{ + EventsParent.Add(std::move(Event)); +} + +void FFrameData::AddCollision(AActor *Actor1, AActor *Actor2) +{ + CarlaRecorderCollision Collision; + + // // some inits + // Collision.Id = NextCollisionId++; + // Collision.IsActor1Hero = false; + // Collision.IsActor2Hero = false; + + // // check actor 1 + // FCarlaActor *FoundActor1 = Episode->GetActorRegistry().FindCarlaActor(Actor1); + // if (FoundActor1 != nullptr) { + // if (FoundActor1->GetActorInfo() != nullptr) + // { + // auto Role = FoundActor1->GetActorInfo()->Description.Variations.Find("role_name"); + // if (Role != nullptr) + // Collision.IsActor1Hero = (Role->Value == "hero"); + // } + // Collision.DatabaseId1 = FoundActor1->GetActorId(); + // } + // else { + // Collision.DatabaseId1 = uint32_t(-1); // actor1 is not a registered Carla actor + // } + + // // check actor 2 + // FCarlaActor *FoundActor2 = Episode->GetActorRegistry().FindCarlaActor(Actor2); + // if (FoundActor2 != nullptr) { + // if (FoundActor2->GetActorInfo() != nullptr) + // { + // auto Role = FoundActor2->GetActorInfo()->Description.Variations.Find("role_name"); + // if (Role != nullptr) + // Collision.IsActor2Hero = (Role->Value == "hero"); + // } + // Collision.DatabaseId2 = FoundActor2->GetActorId(); + // } + // else { + // Collision.DatabaseId2 = uint32_t(-1); // actor2 is not a registered Carla actor + // } + + Collisions.Add(std::move(Collision)); +} + +void FFrameData::AddState(const CarlaRecorderStateTrafficLight &State) +{ + States.Add(State); +} + +void FFrameData::AddAnimVehicle(const CarlaRecorderAnimVehicle &Vehicle) +{ + Vehicles.Add(Vehicle); +} + +void FFrameData::AddAnimWalker(const CarlaRecorderAnimWalker &Walker) +{ + Walkers.Add(Walker); +} + +void FFrameData::AddLightVehicle(const CarlaRecorderLightVehicle &LightVehicle) +{ + LightVehicles.Add(LightVehicle); +} + +void FFrameData::AddEventLightSceneChanged(const UCarlaLight* Light) +{ + CarlaRecorderLightScene LightScene = + { + Light->GetId(), + Light->GetLightIntensity(), + Light->GetLightColor(), + Light->GetLightOn(), + static_cast(Light->GetLightType()) + }; + + LightScenes.Add(LightScene); +} + +void FFrameData::AddKinematics(const CarlaRecorderKinematics &ActorKinematics) +{ + Kinematics.Add(ActorKinematics); +} + +void FFrameData::AddBoundingBox(const CarlaRecorderActorBoundingBox &ActorBoundingBox) +{ + BoundingBoxes.Add(ActorBoundingBox); +} + +void FFrameData::GetFrameCounter() +{ + FrameCounter.FrameCounter = FCarlaEngine::GetFrameCounter(); +} + +// create or reuse an actor for replaying +std::pair FFrameData::TryToCreateReplayerActor( + FVector &Location, + FVector &Rotation, + FActorDescription &ActorDesc, + uint32_t DesiredId, + bool SpawnSensors) +{ + check(Episode != nullptr); + + // check type of actor we need + if (ActorDesc.Id.StartsWith("traffic.")) + { + FCarlaActor* CarlaActor = FindTrafficLightAt(Location); + if (CarlaActor != nullptr) + { + // reuse that actor + return std::pair(2, CarlaActor); + } + else + { + // actor not found + UE_LOG(LogCarla, Log, TEXT("TrafficLight not found")); + return std::pair(0, nullptr); + } + } + else if (SpawnSensors || !ActorDesc.Id.StartsWith("sensor.")) + { + // check if an actor of that type already exist with same id + if (Episode->GetActorRegistry().Contains(DesiredId)) + { + auto* CarlaActor = Episode->FindCarlaActor(DesiredId); + const FActorDescription *desc = &CarlaActor->GetActorInfo()->Description; + if (desc->Id == ActorDesc.Id) + { + // we don't need to create, actor of same type already exist + // relocate + FRotator Rot = FRotator::MakeFromEuler(Rotation); + FTransform Trans2(Rot, Location, FVector(1, 1, 1)); + CarlaActor->SetActorGlobalTransform(Trans2); + return std::pair(2, CarlaActor); + } + } + // create the transform + FRotator Rot = FRotator::MakeFromEuler(Rotation); + FTransform Trans(Rot, FVector(0, 0, 100000), FVector(1, 1, 1)); + // create as new actor + TPair Result = Episode->SpawnActorWithInfo(Trans, ActorDesc, DesiredId); + if (Result.Key == EActorSpawnResultStatus::Success) + { + // relocate + FTransform Trans2(Rot, Location, FVector(1, 1, 1)); + Result.Value->SetActorGlobalTransform(Trans2); + ALargeMapManager * LargeMapManager = UCarlaStatics::GetLargeMapManager(Episode->GetWorld()); + if (LargeMapManager) + { + LargeMapManager->OnActorSpawned(*Result.Value); + } + return std::pair(1, Result.Value); + } + else + { + UE_LOG(LogCarla, Log, TEXT("Actor could't be created by replayer")); + return std::pair(0, Result.Value); + } + } + else + { + // actor ignored + return std::pair(0, nullptr); + } +} + +// replay event for creating actor +std::pair FFrameData::ProcessReplayerEventAdd( + FVector Location, + FVector Rotation, + CarlaRecorderActorDescription Description, + uint32_t DesiredId, + bool bIgnoreHero, + bool ReplaySensors) +{ + check(Episode != nullptr); + FActorDescription ActorDesc; + bool IsHero = false; + + // prepare actor description + ActorDesc.UId = Description.UId; + ActorDesc.Id = Description.Id; + for (const auto &Item : Description.Attributes) + { + FActorAttribute Attr; + Attr.Type = static_cast(Item.Type); + Attr.Id = Item.Id; + Attr.Value = Item.Value; + ActorDesc.Variations.Add(Attr.Id, std::move(Attr)); + // check for hero + if (Item.Id == "role_name" && Item.Value == "hero") + IsHero = true; + } + + auto result = TryToCreateReplayerActor( + Location, + Rotation, + ActorDesc, + DesiredId, + ReplaySensors); + + if (result.first != 0) + { + // disable physics and autopilot on vehicles + if (result.second->GetActorType() == FCarlaActor::ActorType::Vehicle) + { + // ignore hero ? + if (!(bIgnoreHero && IsHero)) + { + // disable physics + SetActorSimulatePhysics(result.second, false); + // disable autopilot + // SetActorAutopilot(result.second, false, false); + } + else + { + // reenable physics just in case + SetActorSimulatePhysics(result.second, true); + } + } + return std::make_pair(result.first, result.second->GetActorId()); + } + return std::make_pair(result.first, 0); +} + +// replay event for removing actor +bool FFrameData::ProcessReplayerEventDel(uint32_t DatabaseId) +{ + check(Episode != nullptr); + FCarlaActor* CarlaActor = Episode->FindCarlaActor(DatabaseId); + if (CarlaActor == nullptr) + { + UE_LOG(LogCarla, Log, TEXT("Actor %d not found to destroy"), DatabaseId); + return false; + } + Episode->DestroyActor(CarlaActor->GetActorId()); + return true; +} + +// replay event for parenting actors +bool FFrameData::ProcessReplayerEventParent(uint32_t ChildId, uint32_t ParentId) +{ + check(Episode != nullptr); + FCarlaActor * Child = Episode->FindCarlaActor(ChildId); + FCarlaActor * Parent = Episode->FindCarlaActor(ParentId); + if(!Child) + { + UE_LOG(LogCarla, Log, TEXT("Parenting Child actors not found")); + return false; + } + if(!Parent) + { + UE_LOG(LogCarla, Log, TEXT("Parenting Parent actors not found")); + return false; + } + Child->SetParent(ParentId); + Child->SetAttachmentType(carla::rpc::AttachmentType::Rigid); + Parent->AddChildren(Child->GetActorId()); + if(!Parent->IsDormant()) + { + if(!Child->IsDormant()) + { + Episode->AttachActors( + Child->GetActor(), + Parent->GetActor(), + static_cast(carla::rpc::AttachmentType::Rigid)); + } + } + else + { + Episode->PutActorToSleep(Child->GetActorId()); + } + return true; +} + +// reposition actors +bool FFrameData::ProcessReplayerPosition(CarlaRecorderPosition Pos1, CarlaRecorderPosition Pos2, double Per, double DeltaTime) +{ + check(Episode != nullptr); + FCarlaActor* CarlaActor = Episode->FindCarlaActor(Pos1.DatabaseId); + FVector Location; + FRotator Rotation; + if(CarlaActor) + { + // check to assign first position or interpolate between both + if (Per == 0.0) + { + // assign position 1 + Location = FVector(Pos1.Location); + Rotation = FRotator::MakeFromEuler(Pos1.Rotation); + } + else + { + // interpolate positions + Location = FMath::Lerp(FVector(Pos1.Location), FVector(Pos2.Location), Per); + Rotation = FMath::Lerp(FRotator::MakeFromEuler(Pos1.Rotation), FRotator::MakeFromEuler(Pos2.Rotation), Per); + } + // set new transform + FTransform Trans(Rotation, Location, FVector(1, 1, 1)); + CarlaActor->SetActorGlobalTransform(Trans, ETeleportType::None); + return true; + } + return false; +} + +// reposition the camera +bool FFrameData::SetCameraPosition(uint32_t Id, FVector Offset, FQuat Rotation) +{ + check(Episode != nullptr); + + // get the actor to follow + FCarlaActor* CarlaActor = Episode->FindCarlaActor(Id); + if (!CarlaActor) + return false; + // get specator pawn + APawn *Spectator = Episode->GetSpectatorPawn(); + if (!Spectator) + return false; + + FCarlaActor* CarlaSpectator = Episode->FindCarlaActor(Spectator); + if (!CarlaSpectator) + return false; + + FTransform ActorTransform = CarlaActor->GetActorGlobalTransform(); + // set the new position + FQuat ActorRot = ActorTransform.GetRotation(); + FVector Pos = ActorTransform.GetTranslation() + (ActorRot.RotateVector(Offset)); + CarlaSpectator->SetActorGlobalTransform(FTransform(ActorRot * Rotation, Pos, FVector(1,1,1))); + + return true; +} + +bool FFrameData::ProcessReplayerStateTrafficLight(CarlaRecorderStateTrafficLight State) +{ + check(Episode != nullptr); + FCarlaActor* CarlaActor = Episode->FindCarlaActor(State.DatabaseId); + if(CarlaActor) + { + CarlaActor->SetTrafficLightState(static_cast(State.State)); + UTrafficLightController* Controller = CarlaActor->GetTrafficLightController(); + if(Controller) + { + Controller->SetElapsedTime(State.ElapsedTime); + ATrafficLightGroup* Group = Controller->GetGroup(); + if (Group) + { + Group->SetFrozenGroup(State.IsFrozen); + } + } + return true; + } + return false; +} + +// set the animation for Vehicles +void FFrameData::ProcessReplayerAnimVehicle(CarlaRecorderAnimVehicle Vehicle) +{ + check(Episode != nullptr); + FCarlaActor *CarlaActor = Episode->FindCarlaActor(Vehicle.DatabaseId); + if (CarlaActor) + { + FVehicleControl Control; + Control.Throttle = Vehicle.Throttle; + Control.Steer = Vehicle.Steering; + Control.Brake = Vehicle.Brake; + Control.bHandBrake = Vehicle.bHandbrake; + Control.bReverse = (Vehicle.Gear < 0); + Control.Gear = Vehicle.Gear; + Control.bManualGearShift = false; + CarlaActor->ApplyControlToVehicle(Control, EVehicleInputPriority::User); + } +} + +// set the lights for vehicles +void FFrameData::ProcessReplayerLightVehicle(CarlaRecorderLightVehicle LightVehicle) +{ + check(Episode != nullptr); + FCarlaActor * CarlaActor = Episode->FindCarlaActor(LightVehicle.DatabaseId); + if (CarlaActor) + { + carla::rpc::VehicleLightState LightState(LightVehicle.State); + CarlaActor->SetVehicleLightState(FVehicleLightState(LightState)); + } +} + +void FFrameData::ProcessReplayerLightScene(CarlaRecorderLightScene LightScene) +{ + check(Episode != nullptr); + UWorld* World = Episode->GetWorld(); + if(World) + { + UCarlaLightSubsystem* CarlaLightSubsystem = World->GetSubsystem(); + if (!CarlaLightSubsystem) + { + return; + } + auto* CarlaLight = CarlaLightSubsystem->GetLight(LightScene.LightId); + if (CarlaLight) + { + CarlaLight->SetLightIntensity(LightScene.Intensity); + CarlaLight->SetLightColor(LightScene.Color); + CarlaLight->SetLightOn(LightScene.bOn); + CarlaLight->SetLightType(static_cast(LightScene.Type)); + } + } +} + +// set the animation for walkers +void FFrameData::ProcessReplayerAnimWalker(CarlaRecorderAnimWalker Walker) +{ + SetWalkerSpeed(Walker.DatabaseId, Walker.Speed); +} + +// replay finish +bool FFrameData::ProcessReplayerFinish(bool bApplyAutopilot, bool bIgnoreHero, std::unordered_map &IsHero) +{ + // set autopilot and physics to all AI vehicles + const FActorRegistry& Registry = Episode->GetActorRegistry(); + for (auto& It : Registry) + { + FCarlaActor* CarlaActor = It.Value.Get(); + + // enable physics only on vehicles + switch (CarlaActor->GetActorType()) + { + + // vehicles + case FCarlaActor::ActorType::Vehicle: + // check for hero + if (!(bIgnoreHero && IsHero[CarlaActor->GetActorId()])) + { + // stop all vehicles + SetActorSimulatePhysics(CarlaActor, true); + SetActorVelocity(CarlaActor, FVector(0, 0, 0)); + FVehicleControl Control; + Control.Throttle = 0.0f; + Control.Steer = 0.0f; + Control.Brake = 0.0f; + Control.bHandBrake = false; + Control.bReverse = false; + Control.Gear = 1; + Control.bManualGearShift = false; + CarlaActor->ApplyControlToVehicle(Control, EVehicleInputPriority::User); + } + break; + + // walkers + case FCarlaActor::ActorType::Walker: + // stop walker + SetWalkerSpeed(CarlaActor->GetActorId(), 0.0f); + break; + } + } + return true; +} + +void FFrameData::SetActorVelocity(FCarlaActor *CarlaActor, FVector Velocity) +{ + if (!CarlaActor) + { + return; + } + CarlaActor->SetActorTargetVelocity(Velocity); +} + +// set the animation speed for walkers +void FFrameData::SetWalkerSpeed(uint32_t ActorId, float Speed) +{ + check(Episode != nullptr); + FCarlaActor * CarlaActor = Episode->FindCarlaActor(ActorId); + if (!CarlaActor) + { + return; + } + FWalkerControl Control; + Control.Speed = Speed; + CarlaActor->ApplyControlToWalker(Control); +} + +// enable / disable physics for an actor +bool FFrameData::SetActorSimulatePhysics(FCarlaActor* CarlaActor, bool bEnabled) +{ + if (!CarlaActor) + { + return false; + } + ECarlaServerResponse Response = + CarlaActor->SetActorSimulatePhysics(bEnabled); + if (Response != ECarlaServerResponse::Success) + { + return false; + } + return true; +} + +void FFrameData::SetFrameCounter() +{ + FCarlaEngine::ResetFrameCounter(FrameCounter.FrameCounter); +} + +FCarlaActor *FFrameData::FindTrafficLightAt(FVector Location) +{ + check(Episode != nullptr); + auto World = Episode->GetWorld(); + check(World != nullptr); + + // get its position (truncated as int's) + int x = static_cast(Location.X); + int y = static_cast(Location.Y); + int z = static_cast(Location.Z); + + const FActorRegistry &Registry = Episode->GetActorRegistry(); + // through all actors in registry + for (auto It = Registry.begin(); It != Registry.end(); ++It) + { + FCarlaActor* CarlaActor = It.Value().Get(); + if(CarlaActor->GetActorType() == FCarlaActor::ActorType::TrafficLight) + { + FVector vec = CarlaActor->GetActorGlobalLocation(); + int x2 = static_cast(vec.X); + int y2 = static_cast(vec.Y); + int z2 = static_cast(vec.Z); + if ((x2 == x) && (y2 == y) && (z2 == z)) + { + // actor found + return CarlaActor; + } + } + } + // actor not found + return nullptr; +} diff --git a/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Game/FrameData.h b/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Game/FrameData.h new file mode 100644 index 000000000..b3578ffa5 --- /dev/null +++ b/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Game/FrameData.h @@ -0,0 +1,158 @@ +// Copyright (c) 2022 Computer Vision Center (CVC) at the Universitat Autonoma +// de Barcelona (UAB). +// +// This work is licensed under the terms of the MIT license. +// For a copy, see . + +#pragma once + +#include "Carla/Recorder/CarlaRecorderTraficLightTime.h" +#include "Carla/Recorder/CarlaRecorderPhysicsControl.h" +#include "Carla/Recorder/CarlaRecorderPlatformTime.h" +#include "Carla/Recorder/CarlaRecorderBoundingBox.h" +#include "Carla/Recorder/CarlaRecorderKinematics.h" +#include "Carla/Recorder/CarlaRecorderLightScene.h" +#include "Carla/Recorder/CarlaRecorderLightVehicle.h" +#include "Carla/Recorder/CarlaRecorderAnimVehicle.h" +#include "Carla/Recorder/CarlaRecorderAnimWalker.h" +#include "Carla/Recorder/CarlaRecorderCollision.h" +#include "Carla/Recorder/CarlaRecorderEventAdd.h" +#include "Carla/Recorder/CarlaRecorderEventDel.h" +#include "Carla/Recorder/CarlaRecorderEventParent.h" +#include "Carla/Recorder/CarlaRecorderFrames.h" +#include "Carla/Recorder/CarlaRecorderInfo.h" +#include "Carla/Recorder/CarlaRecorderPosition.h" +#include "Carla/Recorder/CarlaRecorderFrameCounter.h" + +#include + +class UCarlaEpisode; +class FCarlaActor; + +class FFrameData +{ + // structures + CarlaRecorderInfo Info; + CarlaRecorderFrames Frames; + CarlaRecorderEventsAdd EventsAdd; + CarlaRecorderEventsDel EventsDel; + CarlaRecorderEventsParent EventsParent; + CarlaRecorderCollisions Collisions; + CarlaRecorderPositions Positions; + CarlaRecorderStates States; + CarlaRecorderAnimVehicles Vehicles; + CarlaRecorderAnimWalkers Walkers; + CarlaRecorderLightVehicles LightVehicles; + CarlaRecorderLightScenes LightScenes; + CarlaRecorderActorsKinematics Kinematics; + CarlaRecorderActorBoundingBoxes BoundingBoxes; + CarlaRecorderActorTriggerVolumes TriggerVolumes; + CarlaRecorderPlatformTime PlatformTime; + CarlaRecorderPhysicsControls PhysicsControls; + CarlaRecorderTrafficLightTimes TrafficLightTimes; + CarlaRecorderFrameCounter FrameCounter; + + #pragma pack(push, 1) + struct Header + { + char Id; + uint32_t Size; + }; + #pragma pack(pop) + +public: + + void SetEpisode(UCarlaEpisode* ThisEpisode) {Episode = ThisEpisode;} + + void GetFrameData(UCarlaEpisode *ThisEpisode, bool bAdditionalData = false); + + void PlayFrameData(UCarlaEpisode *ThisEpisode, std::unordered_map& MappedId); + + void Clear(); + + void Write(std::ostream& OutStream); + void Read(std::istream& InStream); + + // record functions + void CreateRecorderEventAdd( + uint32_t DatabaseId, + uint8_t Type, + const FTransform &Transform, + FActorDescription ActorDescription); + void AddEvent(const CarlaRecorderEventAdd &Event); + void AddEvent(const CarlaRecorderEventDel &Event); + void AddEvent(const CarlaRecorderEventParent &Event); + +private: + void AddCollision(AActor *Actor1, AActor *Actor2); + void AddPosition(const CarlaRecorderPosition &Position); + void AddState(const CarlaRecorderStateTrafficLight &State); + void AddAnimVehicle(const CarlaRecorderAnimVehicle &Vehicle); + void AddAnimWalker(const CarlaRecorderAnimWalker &Walker); + void AddLightVehicle(const CarlaRecorderLightVehicle &LightVehicle); + void AddEventLightSceneChanged(const UCarlaLight* Light); + void AddKinematics(const CarlaRecorderKinematics &ActorKinematics); + void AddBoundingBox(const CarlaRecorderActorBoundingBox &ActorBoundingBox); + void AddTriggerVolume(const ATrafficSignBase &TrafficSign); + void AddPhysicsControl(const ACarlaWheeledVehicle& Vehicle); + void AddTrafficLightTime(const ATrafficLightBase& TrafficLight); + + void AddActorPosition(FCarlaActor *CarlaActor); + void AddWalkerAnimation(FCarlaActor *CarlaActor); + void AddVehicleAnimation(FCarlaActor *CarlaActor); + void AddTrafficLightState(FCarlaActor *CarlaActor); + void AddVehicleLight(FCarlaActor *CarlaActor); + void AddActorKinematics(FCarlaActor *CarlaActor); + void AddActorBoundingBox(FCarlaActor *CarlaActor); + + void GetFrameCounter(); + + std::pair TryToCreateReplayerActor( + FVector &Location, + FVector &Rotation, + FActorDescription &ActorDesc, + uint32_t DesiredId, + bool SpawnSensors); + + // replay event for creating actor + std::pair ProcessReplayerEventAdd( + FVector Location, + FVector Rotation, + CarlaRecorderActorDescription Description, + uint32_t DesiredId, + bool bIgnoreHero, + bool ReplaySensors); + + // replay event for removing actor + bool ProcessReplayerEventDel(uint32_t DatabaseId); + // replay event for parenting actors + bool ProcessReplayerEventParent(uint32_t ChildId, uint32_t ParentId); + // reposition actors + bool ProcessReplayerPosition(CarlaRecorderPosition Pos1, CarlaRecorderPosition Pos2, double Per, double DeltaTime); + // replay event for traffic light state + bool ProcessReplayerStateTrafficLight(CarlaRecorderStateTrafficLight State); + // set the animation for Vehicles + void ProcessReplayerAnimVehicle(CarlaRecorderAnimVehicle Vehicle); + // set the animation for walkers + void ProcessReplayerAnimWalker(CarlaRecorderAnimWalker Walker); + // set the vehicle light + void ProcessReplayerLightVehicle(CarlaRecorderLightVehicle LightVehicle); + // set scene lights + void ProcessReplayerLightScene(CarlaRecorderLightScene LightScene); + // replay finish + bool ProcessReplayerFinish(bool bApplyAutopilot, bool bIgnoreHero, std::unordered_map &IsHero); + // set the camera position to follow an actor + bool SetCameraPosition(uint32_t Id, FVector Offset, FQuat Rotation); + // set the velocity of the actor + void SetActorVelocity(FCarlaActor *CarlaActor, FVector Velocity); + // set the animation speed for walkers + void SetWalkerSpeed(uint32_t ActorId, float Speed); + // enable / disable physics for an actor + bool SetActorSimulatePhysics(FCarlaActor *CarlaActor, bool bEnabled); + + void SetFrameCounter(); + + FCarlaActor* FindTrafficLightAt(FVector Location); + + UCarlaEpisode *Episode; +}; diff --git a/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Lights/CarlaLight.cpp b/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Lights/CarlaLight.cpp index 7d560504f..6a694127b 100644 --- a/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Lights/CarlaLight.cpp +++ b/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Lights/CarlaLight.cpp @@ -50,6 +50,7 @@ void UCarlaLight::EndPlay(const EEndPlayReason::Type EndPlayReason) UCarlaLightSubsystem* CarlaLightSubsystem = World->GetSubsystem(); CarlaLightSubsystem->UnregisterLight(this); } + Super::EndPlay(EndPlayReason); } void UCarlaLight::SetLightIntensity(float Intensity) diff --git a/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/OpenDrive/OpenDrive.cpp b/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/OpenDrive/OpenDrive.cpp index c73cd7d99..9c306867c 100644 --- a/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/OpenDrive/OpenDrive.cpp +++ b/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/OpenDrive/OpenDrive.cpp @@ -7,10 +7,11 @@ #include "Carla.h" #include "Carla/OpenDrive/OpenDrive.h" #include "Carla/Game/CarlaGameModeBase.h" +#include "Carla/Game/CarlaStatics.h" #include "GenericPlatform/GenericPlatformProcess.h" #include "Runtime/Core/Public/HAL/FileManagerGeneric.h" - +#include "Misc/FileHelper.h" FString UOpenDrive::FindPathToXODRFile(const FString &InMapName){ diff --git a/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/OpenDrive/OpenDriveActor.cpp b/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/OpenDrive/OpenDriveActor.cpp index e57b6d380..cec9daa3f 100644 --- a/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/OpenDrive/OpenDriveActor.cpp +++ b/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/OpenDrive/OpenDriveActor.cpp @@ -9,6 +9,9 @@ #include "Carla/OpenDrive/OpenDrive.h" +#include "UObject/ConstructorHelpers.h" +#include "DrawDebugHelpers.h" + #include #include #include diff --git a/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Recorder/CarlaRecorder.h b/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Recorder/CarlaRecorder.h index 382718d21..bc6c8f2df 100644 --- a/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Recorder/CarlaRecorder.h +++ b/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Recorder/CarlaRecorder.h @@ -59,7 +59,8 @@ enum class CarlaRecorderPacketId : uint8_t PlatformTime, PhysicsControl, TrafficLightTime, - TriggerVolume + TriggerVolume, + FrameCounter }; /// Recorder for the simulation diff --git a/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Recorder/CarlaRecorderAnimVehicle.cpp b/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Recorder/CarlaRecorderAnimVehicle.cpp index 201fce252..055424ff8 100644 --- a/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Recorder/CarlaRecorderAnimVehicle.cpp +++ b/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Recorder/CarlaRecorderAnimVehicle.cpp @@ -8,7 +8,7 @@ #include "CarlaRecorderAnimVehicle.h" #include "CarlaRecorderHelpers.h" -void CarlaRecorderAnimVehicle::Write(std::ofstream &OutFile) +void CarlaRecorderAnimVehicle::Write(std::ostream &OutFile) { // database id WriteValue(OutFile, this->DatabaseId); @@ -18,7 +18,7 @@ void CarlaRecorderAnimVehicle::Write(std::ofstream &OutFile) WriteValue(OutFile, this->bHandbrake); WriteValue(OutFile, this->Gear); } -void CarlaRecorderAnimVehicle::Read(std::ifstream &InFile) +void CarlaRecorderAnimVehicle::Read(std::istream &InFile) { // database id ReadValue(InFile, this->DatabaseId); @@ -41,7 +41,7 @@ void CarlaRecorderAnimVehicles::Add(const CarlaRecorderAnimVehicle &Vehicle) Vehicles.push_back(Vehicle); } -void CarlaRecorderAnimVehicles::Write(std::ofstream &OutFile) +void CarlaRecorderAnimVehicles::Write(std::ostream &OutFile) { // write the packet id WriteValue(OutFile, static_cast(CarlaRecorderPacketId::AnimVehicle)); @@ -66,3 +66,22 @@ void CarlaRecorderAnimVehicles::Write(std::ofstream &OutFile) WriteValue(OutFile, Total); OutFile.seekp(PosEnd, std::ios::beg); } + +void CarlaRecorderAnimVehicles::Read(std::istream &InFile) +{ + uint16_t i, Total; + CarlaRecorderAnimVehicle Vehicle; + + // read Total Vehicles + ReadValue(InFile, Total); + for (i = 0; i < Total; ++i) + { + Vehicle.Read(InFile); + Add(Vehicle); + } +} + +const std::vector& CarlaRecorderAnimVehicles::GetVehicles() +{ + return Vehicles; +} diff --git a/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Recorder/CarlaRecorderAnimVehicle.h b/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Recorder/CarlaRecorderAnimVehicle.h index 233362776..8d8c5aeb5 100644 --- a/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Recorder/CarlaRecorderAnimVehicle.h +++ b/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Recorder/CarlaRecorderAnimVehicle.h @@ -6,7 +6,7 @@ #pragma once -#include +#include #include #pragma pack(push, 1) @@ -19,9 +19,9 @@ struct CarlaRecorderAnimVehicle bool bHandbrake; int32_t Gear; - void Read(std::ifstream &InFile); + void Read(std::istream &InFile); - void Write(std::ofstream &OutFile); + void Write(std::ostream &OutFile); }; #pragma pack(pop) @@ -34,8 +34,11 @@ public: void Clear(void); - void Write(std::ofstream &OutFile); + void Write(std::ostream &OutFile); + void Read(std::istream &InFile); + + const std::vector& GetVehicles(); private: std::vector Vehicles; diff --git a/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Recorder/CarlaRecorderAnimWalker.cpp b/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Recorder/CarlaRecorderAnimWalker.cpp index c6bcc0a5f..56e54d597 100644 --- a/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Recorder/CarlaRecorderAnimWalker.cpp +++ b/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Recorder/CarlaRecorderAnimWalker.cpp @@ -8,13 +8,13 @@ #include "CarlaRecorderAnimWalker.h" #include "CarlaRecorderHelpers.h" -void CarlaRecorderAnimWalker::Write(std::ofstream &OutFile) +void CarlaRecorderAnimWalker::Write(std::ostream &OutFile) { // database id WriteValue(OutFile, this->DatabaseId); WriteValue(OutFile, this->Speed); } -void CarlaRecorderAnimWalker::Read(std::ifstream &InFile) +void CarlaRecorderAnimWalker::Read(std::istream &InFile) { // database id ReadValue(InFile, this->DatabaseId); @@ -33,7 +33,7 @@ void CarlaRecorderAnimWalkers::Add(const CarlaRecorderAnimWalker &Walker) Walkers.push_back(Walker); } -void CarlaRecorderAnimWalkers::Write(std::ofstream &OutFile) +void CarlaRecorderAnimWalkers::Write(std::ostream &OutFile) { // write the packet id WriteValue(OutFile, static_cast(CarlaRecorderPacketId::AnimWalker)); @@ -53,3 +53,22 @@ void CarlaRecorderAnimWalkers::Write(std::ofstream &OutFile) Walkers.size() * sizeof(CarlaRecorderAnimWalker)); } } + +void CarlaRecorderAnimWalkers::Read(std::istream &InFile) +{ + uint16_t i, Total; + CarlaRecorderAnimWalker Walker; + + // read Total walkers + ReadValue(InFile, Total); + for (i = 0; i < Total; ++i) + { + Walker.Read(InFile); + Add(Walker); + } +} + +const std::vector& CarlaRecorderAnimWalkers::GetWalkers() +{ + return Walkers; +} diff --git a/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Recorder/CarlaRecorderAnimWalker.h b/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Recorder/CarlaRecorderAnimWalker.h index 469b20424..ba51f02e9 100644 --- a/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Recorder/CarlaRecorderAnimWalker.h +++ b/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Recorder/CarlaRecorderAnimWalker.h @@ -6,7 +6,7 @@ #pragma once -#include +#include #include #pragma pack(push, 1) @@ -15,9 +15,9 @@ struct CarlaRecorderAnimWalker uint32_t DatabaseId; float Speed; - void Read(std::ifstream &InFile); + void Read(std::istream &InFile); - void Write(std::ofstream &OutFile); + void Write(std::ostream &OutFile); }; #pragma pack(pop) @@ -30,8 +30,12 @@ public: void Clear(void); - void Write(std::ofstream &OutFile); + void Write(std::ostream &OutFile); + void Read(std::istream &InFile); + + const std::vector& GetWalkers(); + private: std::vector Walkers; diff --git a/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Recorder/CarlaRecorderBoundingBox.cpp b/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Recorder/CarlaRecorderBoundingBox.cpp index 470d46c77..c211e89a5 100644 --- a/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Recorder/CarlaRecorderBoundingBox.cpp +++ b/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Recorder/CarlaRecorderBoundingBox.cpp @@ -8,25 +8,25 @@ #include "CarlaRecorder.h" #include "CarlaRecorderHelpers.h" -void CarlaRecorderBoundingBox::Write(std::ofstream &OutFile) +void CarlaRecorderBoundingBox::Write(std::ostream &OutFile) { WriteFVector(OutFile, this->Origin); WriteFVector(OutFile, this->Extension); } -void CarlaRecorderBoundingBox::Read(std::ifstream &InFile) +void CarlaRecorderBoundingBox::Read(std::istream &InFile) { ReadFVector(InFile, this->Origin); ReadFVector(InFile, this->Extension); } -void CarlaRecorderActorBoundingBox::Write(std::ofstream &OutFile) +void CarlaRecorderActorBoundingBox::Write(std::ostream &OutFile) { WriteValue(OutFile, this->DatabaseId); BoundingBox.Write(OutFile); } -void CarlaRecorderActorBoundingBox::Read(std::ifstream &InFile) +void CarlaRecorderActorBoundingBox::Read(std::istream &InFile) { ReadValue(InFile, this->DatabaseId); BoundingBox.Read(InFile); @@ -45,7 +45,7 @@ void CarlaRecorderActorBoundingBoxes::Add(const CarlaRecorderActorBoundingBox &I Boxes.push_back(InObj); } -void CarlaRecorderActorBoundingBoxes::Write(std::ofstream &OutFile) +void CarlaRecorderActorBoundingBoxes::Write(std::ostream &OutFile) { // write the packet id WriteValue(OutFile, static_cast(CarlaRecorderPacketId::BoundingBox)); @@ -75,7 +75,7 @@ void CarlaRecorderActorTriggerVolumes::Add(const CarlaRecorderActorBoundingBox & Boxes.push_back(InObj); } -void CarlaRecorderActorTriggerVolumes::Write(std::ofstream &OutFile) +void CarlaRecorderActorTriggerVolumes::Write(std::ostream &OutFile) { if (Boxes.size() == 0) { diff --git a/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Recorder/CarlaRecorderBoundingBox.h b/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Recorder/CarlaRecorderBoundingBox.h index 00423e7ad..8d08397b6 100644 --- a/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Recorder/CarlaRecorderBoundingBox.h +++ b/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Recorder/CarlaRecorderBoundingBox.h @@ -6,7 +6,7 @@ #pragma once -#include +#include #include #pragma pack(push, 1) @@ -15,9 +15,9 @@ struct CarlaRecorderBoundingBox FVector Origin; FVector Extension; - void Read(std::ifstream &InFile); + void Read(std::istream &InFile); - void Write(std::ofstream &OutFile); + void Write(std::ostream &OutFile); }; #pragma pack(pop) @@ -27,9 +27,9 @@ struct CarlaRecorderActorBoundingBox uint32_t DatabaseId; CarlaRecorderBoundingBox BoundingBox; - void Read(std::ifstream &InFile); + void Read(std::istream &InFile); - void Write(std::ofstream &OutFile); + void Write(std::ostream &OutFile); }; #pragma pack(pop) @@ -41,7 +41,7 @@ class CarlaRecorderActorBoundingBoxes void Clear(void); - void Write(std::ofstream &OutFile); + void Write(std::ostream &OutFile); private: @@ -56,7 +56,7 @@ class CarlaRecorderActorTriggerVolumes void Clear(void); - void Write(std::ofstream &OutFile); + void Write(std::ostream &OutFile); private: diff --git a/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Recorder/CarlaRecorderCollision.cpp b/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Recorder/CarlaRecorderCollision.cpp index 20846c4d2..152d9c143 100644 --- a/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Recorder/CarlaRecorderCollision.cpp +++ b/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Recorder/CarlaRecorderCollision.cpp @@ -8,7 +8,7 @@ #include "CarlaRecorderCollision.h" #include "CarlaRecorderHelpers.h" -void CarlaRecorderCollision::Read(std::ifstream &InFile) +void CarlaRecorderCollision::Read(std::istream &InFile) { // id ReadValue(InFile, this->Id); @@ -19,7 +19,7 @@ void CarlaRecorderCollision::Read(std::ifstream &InFile) ReadValue(InFile, this->IsActor1Hero); ReadValue(InFile, this->IsActor2Hero); } -void CarlaRecorderCollision::Write(std::ofstream &OutFile) const +void CarlaRecorderCollision::Write(std::ostream &OutFile) const { // id WriteValue(OutFile, this->Id); @@ -47,7 +47,7 @@ void CarlaRecorderCollisions::Add(const CarlaRecorderCollision &Collision) Collisions.insert(std::move(Collision)); } -void CarlaRecorderCollisions::Write(std::ofstream &OutFile) +void CarlaRecorderCollisions::Write(std::ostream &OutFile) { // write the packet id WriteValue(OutFile, static_cast(CarlaRecorderPacketId::Collision)); @@ -65,4 +65,4 @@ void CarlaRecorderCollisions::Write(std::ofstream &OutFile) { Coll.Write(OutFile); } -} \ No newline at end of file +} diff --git a/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Recorder/CarlaRecorderCollision.h b/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Recorder/CarlaRecorderCollision.h index 248636e10..d6078b637 100644 --- a/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Recorder/CarlaRecorderCollision.h +++ b/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Recorder/CarlaRecorderCollision.h @@ -6,7 +6,7 @@ #pragma once -#include +#include #include #include @@ -19,8 +19,8 @@ struct CarlaRecorderCollision bool IsActor1Hero; bool IsActor2Hero; - void Read(std::ifstream &InFile); - void Write(std::ofstream &OutFile) const; + void Read(std::istream &InFile); + void Write(std::ostream &OutFile) const; // define operator == needed for the 'unordered_set' bool operator==(const CarlaRecorderCollision &Other) const; }; @@ -47,7 +47,7 @@ class CarlaRecorderCollisions{ public: void Add(const CarlaRecorderCollision &Collision); void Clear(void); - void Write(std::ofstream &OutFile); + void Write(std::ostream &OutFile); private: std::unordered_set Collisions; diff --git a/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Recorder/CarlaRecorderEventAdd.cpp b/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Recorder/CarlaRecorderEventAdd.cpp index 09f01400c..39b0f17c9 100644 --- a/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Recorder/CarlaRecorderEventAdd.cpp +++ b/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Recorder/CarlaRecorderEventAdd.cpp @@ -8,7 +8,7 @@ #include "CarlaRecorderEventAdd.h" #include "CarlaRecorderHelpers.h" -void CarlaRecorderEventAdd::Write(std::ofstream &OutFile) const +void CarlaRecorderEventAdd::Write(std::ostream &OutFile) const { // database id WriteValue(OutFile, this->DatabaseId); @@ -34,7 +34,7 @@ void CarlaRecorderEventAdd::Write(std::ofstream &OutFile) const } } -void CarlaRecorderEventAdd::Read(std::ifstream &InFile) +void CarlaRecorderEventAdd::Read(std::istream &InFile) { // database id ReadValue(InFile, this->DatabaseId); @@ -77,7 +77,7 @@ void CarlaRecorderEventsAdd::Add(const CarlaRecorderEventAdd &Event) Events.push_back(std::move(Event)); } -void CarlaRecorderEventsAdd::Write(std::ofstream &OutFile) +void CarlaRecorderEventsAdd::Write(std::ostream &OutFile) { // write the packet id WriteValue(OutFile, static_cast(CarlaRecorderPacketId::EventAdd)); @@ -102,3 +102,20 @@ void CarlaRecorderEventsAdd::Write(std::ofstream &OutFile) WriteValue(OutFile, Total); OutFile.seekp(PosEnd, std::ios::beg); } + +void CarlaRecorderEventsAdd::Read(std::istream &InFile) +{ + CarlaRecorderEventAdd EventAdd; + uint16_t i, Total; + ReadValue(InFile, Total); + for (i = 0; i < Total; ++i) + { + EventAdd.Read(InFile); + Add(EventAdd); + } +} + +const std::vector& CarlaRecorderEventsAdd::GetEvents() +{ + return Events; +} diff --git a/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Recorder/CarlaRecorderEventAdd.h b/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Recorder/CarlaRecorderEventAdd.h index 8919e5b6c..5a1d59de2 100644 --- a/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Recorder/CarlaRecorderEventAdd.h +++ b/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Recorder/CarlaRecorderEventAdd.h @@ -6,7 +6,7 @@ #pragma once -#include +#include #include struct CarlaRecorderActorAttribute @@ -31,8 +31,8 @@ struct CarlaRecorderEventAdd FVector Rotation; CarlaRecorderActorDescription Description; - void Read(std::ifstream &InFile); - void Write(std::ofstream &OutFile) const; + void Read(std::istream &InFile); + void Write(std::ostream &OutFile) const; }; class CarlaRecorderEventsAdd @@ -41,7 +41,9 @@ class CarlaRecorderEventsAdd public: void Add(const CarlaRecorderEventAdd &Event); void Clear(void); - void Write(std::ofstream &OutFile); + void Write(std::ostream &OutFile); + void Read(std::istream &InFile); + const std::vector& GetEvents(); private: std::vector Events; diff --git a/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Recorder/CarlaRecorderEventDel.cpp b/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Recorder/CarlaRecorderEventDel.cpp index 584644e5f..7066cfbef 100644 --- a/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Recorder/CarlaRecorderEventDel.cpp +++ b/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Recorder/CarlaRecorderEventDel.cpp @@ -8,12 +8,12 @@ #include "CarlaRecorderEventDel.h" #include "CarlaRecorderHelpers.h" -void CarlaRecorderEventDel::Read(std::ifstream &InFile) +void CarlaRecorderEventDel::Read(std::istream &InFile) { // database id ReadValue(InFile, this->DatabaseId); } -void CarlaRecorderEventDel::Write(std::ofstream &OutFile) const +void CarlaRecorderEventDel::Write(std::ostream &OutFile) const { // database id WriteValue(OutFile, this->DatabaseId); @@ -31,7 +31,7 @@ void CarlaRecorderEventsDel::Add(const CarlaRecorderEventDel &Event) Events.push_back(std::move(Event)); } -void CarlaRecorderEventsDel::Write(std::ofstream &OutFile) +void CarlaRecorderEventsDel::Write(std::ostream &OutFile) { // write the packet id WriteValue(OutFile, static_cast(CarlaRecorderPacketId::EventDel)); @@ -57,4 +57,23 @@ void CarlaRecorderEventsDel::Write(std::ofstream &OutFile) OutFile.seekp(PosStart, std::ios::beg); WriteValue(OutFile, Total); OutFile.seekp(PosEnd, std::ios::beg); -} \ No newline at end of file +} + +void CarlaRecorderEventsDel::Read(std::istream &InFile) +{ + uint16_t i, Total; + CarlaRecorderEventDel EventDel; + + // process destroy events + ReadValue(InFile, Total); + for (i = 0; i < Total; ++i) + { + EventDel.Read(InFile); + Add(EventDel); + } +} + +const std::vector& CarlaRecorderEventsDel::GetEvents() +{ + return Events; +} diff --git a/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Recorder/CarlaRecorderEventDel.h b/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Recorder/CarlaRecorderEventDel.h index 1a8455528..bea1a35a4 100644 --- a/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Recorder/CarlaRecorderEventDel.h +++ b/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Recorder/CarlaRecorderEventDel.h @@ -6,15 +6,15 @@ #pragma once -#include +#include #include struct CarlaRecorderEventDel { uint32_t DatabaseId; - void Read(std::ifstream &InFile); - void Write(std::ofstream &OutFile) const; + void Read(std::istream &InFile); + void Write(std::ostream &OutFile) const; }; class CarlaRecorderEventsDel @@ -23,7 +23,9 @@ class CarlaRecorderEventsDel public: void Add(const CarlaRecorderEventDel &Event); void Clear(void); - void Write(std::ofstream &OutFile); + void Write(std::ostream &OutFile); + void Read(std::istream &InFile); + const std::vector& GetEvents(); private: std::vector Events; diff --git a/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Recorder/CarlaRecorderEventParent.cpp b/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Recorder/CarlaRecorderEventParent.cpp index 51ad18220..8261974b0 100644 --- a/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Recorder/CarlaRecorderEventParent.cpp +++ b/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Recorder/CarlaRecorderEventParent.cpp @@ -9,14 +9,14 @@ #include "CarlaRecorderHelpers.h" -void CarlaRecorderEventParent::Read(std::ifstream &InFile) +void CarlaRecorderEventParent::Read(std::istream &InFile) { // database id ReadValue(InFile, this->DatabaseId); // database id parent ReadValue(InFile, this->DatabaseIdParent); } -void CarlaRecorderEventParent::Write(std::ofstream &OutFile) const +void CarlaRecorderEventParent::Write(std::ostream &OutFile) const { // database id WriteValue(OutFile, this->DatabaseId); @@ -36,7 +36,7 @@ void CarlaRecorderEventsParent::Add(const CarlaRecorderEventParent &Event) Events.push_back(std::move(Event)); } -void CarlaRecorderEventsParent::Write(std::ofstream &OutFile) +void CarlaRecorderEventsParent::Write(std::ostream &OutFile) { // write the packet id WriteValue(OutFile, static_cast(CarlaRecorderPacketId::EventParent)); @@ -62,4 +62,24 @@ void CarlaRecorderEventsParent::Write(std::ofstream &OutFile) OutFile.seekp(PosStart, std::ios::beg); WriteValue(OutFile, Total); OutFile.seekp(PosEnd, std::ios::beg); -} \ No newline at end of file +} + +void CarlaRecorderEventsParent::Read(std::istream &InFile) +{ + uint16_t i, Total; + CarlaRecorderEventParent EventParent; + std::stringstream Info; + + // process parenting events + ReadValue(InFile, Total); + for (i = 0; i < Total; ++i) + { + EventParent.Read(InFile); + Add(EventParent); + } +} + +const std::vector& CarlaRecorderEventsParent::GetEvents() +{ + return Events; +} diff --git a/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Recorder/CarlaRecorderEventParent.h b/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Recorder/CarlaRecorderEventParent.h index c2e25be63..1ad1e8924 100644 --- a/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Recorder/CarlaRecorderEventParent.h +++ b/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Recorder/CarlaRecorderEventParent.h @@ -6,7 +6,7 @@ #pragma once -#include +#include #include struct CarlaRecorderEventParent @@ -14,8 +14,8 @@ struct CarlaRecorderEventParent uint32_t DatabaseId; uint32_t DatabaseIdParent; - void Read(std::ifstream &InFile); - void Write(std::ofstream &OutFile) const; + void Read(std::istream &InFile); + void Write(std::ostream &OutFile) const; }; class CarlaRecorderEventsParent @@ -24,8 +24,10 @@ class CarlaRecorderEventsParent public: void Add(const CarlaRecorderEventParent &Event); void Clear(void); - void Write(std::ofstream &OutFile); - + void Write(std::ostream &OutFile); + void Read(std::istream &InFile); + const std::vector& GetEvents(); + private: std::vector Events; }; diff --git a/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Recorder/CarlaRecorderFrameCounter.cpp b/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Recorder/CarlaRecorderFrameCounter.cpp new file mode 100644 index 000000000..3ed81d09c --- /dev/null +++ b/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Recorder/CarlaRecorderFrameCounter.cpp @@ -0,0 +1,26 @@ +// Copyright (c) 2022 Computer Vision Center (CVC) at the Universitat Autonoma +// de Barcelona (UAB). +// +// This work is licensed under the terms of the MIT license. +// For a copy, see . + +#include "CarlaRecorderFrameCounter.h" +#include "CarlaRecorder.h" +#include "CarlaRecorderHelpers.h" + +void CarlaRecorderFrameCounter::Read(std::istream &InFile) +{ + ReadValue(InFile, this->FrameCounter); +} + +void CarlaRecorderFrameCounter::Write(std::ostream &OutFile) +{ + // write the packet id + WriteValue(OutFile, static_cast(CarlaRecorderPacketId::FrameCounter)); + + // write packet size + uint32_t Total = sizeof(uint64_t); + WriteValue(OutFile, Total); + + WriteValue(OutFile, this->FrameCounter); +} diff --git a/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Recorder/CarlaRecorderFrameCounter.h b/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Recorder/CarlaRecorderFrameCounter.h new file mode 100644 index 000000000..b4f00f876 --- /dev/null +++ b/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Recorder/CarlaRecorderFrameCounter.h @@ -0,0 +1,22 @@ +// Copyright (c) 2022 Computer Vision Center (CVC) at the Universitat Autonoma +// de Barcelona (UAB). +// +// This work is licensed under the terms of the MIT license. +// For a copy, see . + +#pragma once + +#include + +#pragma pack(push, 1) +struct CarlaRecorderFrameCounter +{ + + uint64_t FrameCounter; + + void Read(std::istream &InFile); + + void Write(std::ostream &OutFile); + +}; +#pragma pack(pop) diff --git a/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Recorder/CarlaRecorderFrames.cpp b/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Recorder/CarlaRecorderFrames.cpp index 0abb9f200..beb552368 100644 --- a/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Recorder/CarlaRecorderFrames.cpp +++ b/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Recorder/CarlaRecorderFrames.cpp @@ -8,12 +8,12 @@ #include "CarlaRecorderFrames.h" #include "CarlaRecorderHelpers.h" -void CarlaRecorderFrame::Read(std::ifstream &InFile) +void CarlaRecorderFrame::Read(std::istream &InFile) { ReadValue(InFile, *this); } -void CarlaRecorderFrame::Write(std::ofstream &OutFile) +void CarlaRecorderFrame::Write(std::ostream &OutFile) { WriteValue(OutFile, *this); } @@ -49,7 +49,7 @@ void CarlaRecorderFrames::SetFrame(double DeltaSeconds) ++Frame.Id; } -void CarlaRecorderFrames::WriteStart(std::ofstream &OutFile) +void CarlaRecorderFrames::WriteStart(std::ostream &OutFile) { std::streampos Pos, Offset; double Dummy = -1.0f; @@ -80,7 +80,7 @@ void CarlaRecorderFrames::WriteStart(std::ofstream &OutFile) OffsetPreviousFrame = Offset; } -void CarlaRecorderFrames::WriteEnd(std::ofstream &OutFile) +void CarlaRecorderFrames::WriteEnd(std::ostream &OutFile) { // write the packet id WriteValue(OutFile, static_cast(CarlaRecorderPacketId::FrameEnd)); diff --git a/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Recorder/CarlaRecorderFrames.h b/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Recorder/CarlaRecorderFrames.h index 498390daa..18b2a3465 100644 --- a/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Recorder/CarlaRecorderFrames.h +++ b/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Recorder/CarlaRecorderFrames.h @@ -6,7 +6,7 @@ #pragma once -#include +#include #pragma pack(push, 1) struct CarlaRecorderFrame @@ -15,9 +15,9 @@ struct CarlaRecorderFrame double DurationThis; double Elapsed; - void Read(std::ifstream &InFile); + void Read(std::istream &InFile); - void Write(std::ofstream &OutFile); + void Write(std::ostream &OutFile); }; #pragma pack(pop) @@ -32,8 +32,8 @@ public: void SetFrame(double DeltaSeconds); - void WriteStart(std::ofstream &OutFile); - void WriteEnd(std::ofstream &OutFile); + void WriteStart(std::ostream &OutFile); + void WriteEnd(std::ostream &OutFile); private: diff --git a/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Recorder/CarlaRecorderHelpers.cpp b/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Recorder/CarlaRecorderHelpers.cpp index 21daff18b..bd7e874d5 100644 --- a/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Recorder/CarlaRecorderHelpers.cpp +++ b/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Recorder/CarlaRecorderHelpers.cpp @@ -34,7 +34,7 @@ std::string GetRecorderFilename(std::string Filename) // ------ // write binary data from FVector -void WriteFVector(std::ofstream &OutFile, const FVector &InObj) +void WriteFVector(std::ostream &OutFile, const FVector &InObj) { WriteValue(OutFile, InObj.X); WriteValue(OutFile, InObj.Y); @@ -42,13 +42,13 @@ void WriteFVector(std::ofstream &OutFile, const FVector &InObj) } // write binary data from FTransform -// void WriteFTransform(std::ofstream &OutFile, const FTransform &InObj){ +// void WriteFTransform(std::ostream &OutFile, const FTransform &InObj){ // WriteFVector(OutFile, InObj.GetTranslation()); // WriteFVector(OutFile, InObj.GetRotation().Euler()); // } // write binary data from FString (length + text) -void WriteFString(std::ofstream &OutFile, const FString &InObj) +void WriteFString(std::ostream &OutFile, const FString &InObj) { // encode the string to UTF8 to know the final length FTCHARToUTF8 EncodedString(*InObj); @@ -63,7 +63,7 @@ void WriteFString(std::ofstream &OutFile, const FString &InObj) // ----- // read binary data to FVector -void ReadFVector(std::ifstream &InFile, FVector &OutObj) +void ReadFVector(std::istream &InFile, FVector &OutObj) { ReadValue(InFile, OutObj.X); ReadValue(InFile, OutObj.Y); @@ -71,7 +71,7 @@ void ReadFVector(std::ifstream &InFile, FVector &OutObj) } // read binary data to FTransform -// void ReadFTransform(std::ifstream &InFile, FTransform &OutObj){ +// void ReadFTransform(std::istream &InFile, FTransform &OutObj){ // FVector Vec; // ReadFVector(InFile, Vec); // OutObj.SetTranslation(Vec); @@ -80,7 +80,7 @@ void ReadFVector(std::ifstream &InFile, FVector &OutObj) // } // read binary data to FString (length + text) -void ReadFString(std::ifstream &InFile, FString &OutObj) +void ReadFString(std::istream &InFile, FString &OutObj) { uint16_t Length; ReadValue(InFile, Length); diff --git a/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Recorder/CarlaRecorderHelpers.h b/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Recorder/CarlaRecorderHelpers.h index c739e9492..825bb360a 100644 --- a/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Recorder/CarlaRecorderHelpers.h +++ b/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Recorder/CarlaRecorderHelpers.h @@ -6,7 +6,7 @@ #pragma once -#include +#include #include // get the final path + filename @@ -18,13 +18,13 @@ std::string GetRecorderFilename(std::string Filename); // write binary data (using sizeof()) template -void WriteValue(std::ofstream &OutFile, const T &InObj) +void WriteValue(std::ostream &OutFile, const T &InObj) { OutFile.write(reinterpret_cast(&InObj), sizeof(T)); } template -void WriteStdVector(std::ofstream &OutFile, const std::vector &InVec) +void WriteStdVector(std::ostream &OutFile, const std::vector &InVec) { WriteValue(OutFile, InVec.size()); for (const auto& InObj : InVec) @@ -34,7 +34,7 @@ void WriteStdVector(std::ofstream &OutFile, const std::vector &InVec) } template -void WriteTArray(std::ofstream &OutFile, const TArray &InVec) +void WriteTArray(std::ostream &OutFile, const TArray &InVec) { WriteValue(OutFile, InVec.Num()); for (const auto& InObj : InVec) @@ -44,12 +44,12 @@ void WriteTArray(std::ofstream &OutFile, const TArray &InVec) } // write binary data from FVector -void WriteFVector(std::ofstream &OutFile, const FVector &InObj); +void WriteFVector(std::ostream &OutFile, const FVector &InObj); // write binary data from FTransform -// void WriteFTransform(std::ofstream &OutFile, const FTransform &InObj); +// void WriteFTransform(std::ostream &OutFile, const FTransform &InObj); // write binary data from FString (length + text) -void WriteFString(std::ofstream &OutFile, const FString &InObj); +void WriteFString(std::ostream &OutFile, const FString &InObj); // --------- // replayer @@ -57,13 +57,13 @@ void WriteFString(std::ofstream &OutFile, const FString &InObj); // read binary data (using sizeof()) template -void ReadValue(std::ifstream &InFile, T &OutObj) +void ReadValue(std::istream &InFile, T &OutObj) { InFile.read(reinterpret_cast(&OutObj), sizeof(T)); } template -void ReadStdVector(std::ifstream &InFile, std::vector &OutVec) +void ReadStdVector(std::istream &InFile, std::vector &OutVec) { uint32_t VecSize; ReadValue(InFile, VecSize); @@ -77,7 +77,7 @@ void ReadStdVector(std::ifstream &InFile, std::vector &OutVec) } template -void ReadTArray(std::ifstream &InFile, TArray &OutVec) +void ReadTArray(std::istream &InFile, TArray &OutVec) { uint32_t VecSize; ReadValue(InFile, VecSize); @@ -91,9 +91,9 @@ void ReadTArray(std::ifstream &InFile, TArray &OutVec) } // read binary data from FVector -void ReadFVector(std::ifstream &InFile, FVector &OutObj); +void ReadFVector(std::istream &InFile, FVector &OutObj); // read binary data from FTransform -// void ReadTransform(std::ifstream &InFile, FTransform &OutObj); +// void ReadTransform(std::istream &InFile, FTransform &OutObj); // read binary data from FString (length + text) -void ReadFString(std::ifstream &InFile, FString &OutObj); +void ReadFString(std::istream &InFile, FString &OutObj); diff --git a/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Recorder/CarlaRecorderInfo.h b/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Recorder/CarlaRecorderInfo.h index bbe1f4437..7ad658b40 100644 --- a/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Recorder/CarlaRecorderInfo.h +++ b/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Recorder/CarlaRecorderInfo.h @@ -8,7 +8,7 @@ #include "CarlaRecorderHelpers.h" -#include +#include #include struct CarlaRecorderInfo @@ -18,7 +18,7 @@ struct CarlaRecorderInfo std::time_t Date; FString Mapfile; - void Read(std::ifstream &File) + void Read(std::istream &File) { ReadValue(File, Version); ReadFString(File, Magic); @@ -26,7 +26,7 @@ struct CarlaRecorderInfo ReadFString(File, Mapfile); } - void Write(std::ofstream &File) + void Write(std::ostream &File) { WriteValue(File, Version); WriteFString(File, Magic); diff --git a/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Recorder/CarlaRecorderKinematics.cpp b/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Recorder/CarlaRecorderKinematics.cpp index 2765168ad..68e3f7c06 100644 --- a/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Recorder/CarlaRecorderKinematics.cpp +++ b/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Recorder/CarlaRecorderKinematics.cpp @@ -8,14 +8,14 @@ #include "CarlaRecorder.h" #include "CarlaRecorderHelpers.h" -void CarlaRecorderKinematics::Write(std::ofstream &OutFile) +void CarlaRecorderKinematics::Write(std::ostream &OutFile) { WriteValue(OutFile, this->DatabaseId); WriteFVector(OutFile, this->LinearVelocity); WriteFVector(OutFile, this->AngularVelocity); } -void CarlaRecorderKinematics::Read(std::ifstream &InFile) +void CarlaRecorderKinematics::Read(std::istream &InFile) { ReadValue(InFile, this->DatabaseId); ReadFVector(InFile, this->LinearVelocity); @@ -34,7 +34,7 @@ void CarlaRecorderActorsKinematics::Add(const CarlaRecorderKinematics &InObj) Kinematics.push_back(InObj); } -void CarlaRecorderActorsKinematics::Write(std::ofstream &OutFile) +void CarlaRecorderActorsKinematics::Write(std::ostream &OutFile) { if (Kinematics.size() == 0) { diff --git a/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Recorder/CarlaRecorderKinematics.h b/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Recorder/CarlaRecorderKinematics.h index bc1bd6713..5d2e4cabf 100644 --- a/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Recorder/CarlaRecorderKinematics.h +++ b/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Recorder/CarlaRecorderKinematics.h @@ -6,7 +6,7 @@ #pragma once -#include +#include #include #pragma pack(push, 1) @@ -16,9 +16,9 @@ struct CarlaRecorderKinematics FVector LinearVelocity; FVector AngularVelocity; - void Read(std::ifstream &InFile); + void Read(std::istream &InFile); - void Write(std::ofstream &OutFile); + void Write(std::ostream &OutFile); }; #pragma pack(pop) @@ -30,7 +30,7 @@ class CarlaRecorderActorsKinematics void Clear(void); - void Write(std::ofstream &OutFile); + void Write(std::ostream &OutFile); private: diff --git a/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Recorder/CarlaRecorderLightScene.cpp b/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Recorder/CarlaRecorderLightScene.cpp index 8500986ee..b36057be0 100644 --- a/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Recorder/CarlaRecorderLightScene.cpp +++ b/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Recorder/CarlaRecorderLightScene.cpp @@ -9,7 +9,7 @@ #include "CarlaRecorderHelpers.h" -void CarlaRecorderLightScene::Write(std::ofstream &OutFile) +void CarlaRecorderLightScene::Write(std::ostream &OutFile) { WriteValue(OutFile, this->LightId); WriteValue(OutFile, this->Intensity); @@ -17,7 +17,7 @@ void CarlaRecorderLightScene::Write(std::ofstream &OutFile) WriteValue(OutFile, this->bOn); WriteValue(OutFile, this->Type); } -void CarlaRecorderLightScene::Read(std::ifstream &InFile) +void CarlaRecorderLightScene::Read(std::istream &InFile) { ReadValue(InFile, this->LightId); ReadValue(InFile, this->Intensity); @@ -38,7 +38,7 @@ void CarlaRecorderLightScenes::Add(const CarlaRecorderLightScene &Vehicle) Lights.push_back(Vehicle); } -void CarlaRecorderLightScenes::Write(std::ofstream &OutFile) +void CarlaRecorderLightScenes::Write(std::ostream &OutFile) { if (Lights.size() == 0) { @@ -63,3 +63,22 @@ void CarlaRecorderLightScenes::Write(std::ofstream &OutFile) } } + +void CarlaRecorderLightScenes::Read(std::istream &InFile) +{ + uint16_t Total; + CarlaRecorderLightScene LightScene; + + // read Total light events + ReadValue(InFile, Total); + for (uint16_t i = 0; i < Total; ++i) + { + LightScene.Read(InFile); + Add(LightScene); + } +} + +const std::vector& CarlaRecorderLightScenes::GetLights() +{ + return Lights; +} diff --git a/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Recorder/CarlaRecorderLightScene.h b/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Recorder/CarlaRecorderLightScene.h index 2aae5240a..e70cf54f4 100644 --- a/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Recorder/CarlaRecorderLightScene.h +++ b/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Recorder/CarlaRecorderLightScene.h @@ -6,7 +6,7 @@ #pragma once -#include +#include #include #include @@ -20,9 +20,9 @@ struct CarlaRecorderLightScene bool bOn; uint8 Type; - void Read(std::ifstream &InFile); + void Read(std::istream &InFile); - void Write(std::ofstream &OutFile); + void Write(std::ostream &OutFile); }; #pragma pack(pop) @@ -34,7 +34,11 @@ public: void Clear(void); - void Write(std::ofstream &OutFile); + void Write(std::ostream &OutFile); + + void Read(std::istream &InFile); + + const std::vector& GetLights(); private: diff --git a/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Recorder/CarlaRecorderLightVehicle.cpp b/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Recorder/CarlaRecorderLightVehicle.cpp index 17c73258f..da7af6489 100644 --- a/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Recorder/CarlaRecorderLightVehicle.cpp +++ b/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Recorder/CarlaRecorderLightVehicle.cpp @@ -9,13 +9,13 @@ #include "CarlaRecorderHelpers.h" -void CarlaRecorderLightVehicle::Write(std::ofstream &OutFile) +void CarlaRecorderLightVehicle::Write(std::ostream &OutFile) { // database id WriteValue(OutFile, this->DatabaseId); WriteValue(OutFile, this->State); } -void CarlaRecorderLightVehicle::Read(std::ifstream &InFile) +void CarlaRecorderLightVehicle::Read(std::istream &InFile) { // database id ReadValue(InFile, this->DatabaseId); @@ -34,7 +34,7 @@ void CarlaRecorderLightVehicles::Add(const CarlaRecorderLightVehicle &Vehicle) Vehicles.push_back(Vehicle); } -void CarlaRecorderLightVehicles::Write(std::ofstream &OutFile) +void CarlaRecorderLightVehicles::Write(std::ostream &OutFile) { // write the packet id WriteValue(OutFile, static_cast(CarlaRecorderPacketId::VehicleLight)); @@ -52,3 +52,22 @@ void CarlaRecorderLightVehicles::Write(std::ofstream &OutFile) Vehicle.Write(OutFile); } } + +void CarlaRecorderLightVehicles::Read(std::istream &InFile) +{ + uint16_t Total; + CarlaRecorderLightVehicle LightVehicle; + + // read Total walkers + ReadValue(InFile, Total); + for (uint16_t i = 0; i < Total; ++i) + { + LightVehicle.Read(InFile); + Add(LightVehicle); + } +} + +const std::vector& CarlaRecorderLightVehicles::GetLightVehicles() +{ + return Vehicles; +} diff --git a/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Recorder/CarlaRecorderLightVehicle.h b/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Recorder/CarlaRecorderLightVehicle.h index d751eeeeb..dd1839783 100644 --- a/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Recorder/CarlaRecorderLightVehicle.h +++ b/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Recorder/CarlaRecorderLightVehicle.h @@ -6,7 +6,7 @@ #pragma once -#include +#include #include #include @@ -19,9 +19,9 @@ struct CarlaRecorderLightVehicle uint32_t DatabaseId; VehicleLightStateType State; - void Read(std::ifstream &InFile); + void Read(std::istream &InFile); - void Write(std::ofstream &OutFile); + void Write(std::ostream &OutFile); }; #pragma pack(pop) @@ -33,7 +33,11 @@ public: void Clear(void); - void Write(std::ofstream &OutFile); + void Write(std::ostream &OutFile); + + void Read(std::istream &InFile); + + const std::vector& GetLightVehicles(); private: diff --git a/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Recorder/CarlaRecorderPhysicsControl.cpp b/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Recorder/CarlaRecorderPhysicsControl.cpp index 2acaed89b..f0a9ea5a7 100644 --- a/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Recorder/CarlaRecorderPhysicsControl.cpp +++ b/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Recorder/CarlaRecorderPhysicsControl.cpp @@ -13,7 +13,7 @@ #include -void CarlaRecorderPhysicsControl::Write(std::ofstream &OutFile) +void CarlaRecorderPhysicsControl::Write(std::ostream &OutFile) { carla::rpc::VehiclePhysicsControl RPCPhysicsControl(VehiclePhysicsControl); WriteValue(OutFile, this->DatabaseId); @@ -42,7 +42,7 @@ void CarlaRecorderPhysicsControl::Write(std::ofstream &OutFile) WriteStdVector(OutFile, RPCPhysicsControl.wheels); } -void CarlaRecorderPhysicsControl::Read(std::ifstream &InFile) +void CarlaRecorderPhysicsControl::Read(std::istream &InFile) { carla::rpc::VehiclePhysicsControl RPCPhysicsControl; ReadValue(InFile, this->DatabaseId); @@ -85,7 +85,7 @@ void CarlaRecorderPhysicsControls::Add(const CarlaRecorderPhysicsControl &InObj) PhysicsControls.push_back(InObj); } -void CarlaRecorderPhysicsControls::Write(std::ofstream &OutFile) +void CarlaRecorderPhysicsControls::Write(std::ostream &OutFile) { if (PhysicsControls.size() == 0) { diff --git a/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Recorder/CarlaRecorderPhysicsControl.h b/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Recorder/CarlaRecorderPhysicsControl.h index 0454e1e77..c42eb5a7a 100644 --- a/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Recorder/CarlaRecorderPhysicsControl.h +++ b/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Recorder/CarlaRecorderPhysicsControl.h @@ -6,7 +6,7 @@ #pragma once -#include +#include #include #include "Carla/Vehicle/VehiclePhysicsControl.h" @@ -17,9 +17,9 @@ struct CarlaRecorderPhysicsControl uint32_t DatabaseId; FVehiclePhysicsControl VehiclePhysicsControl; - void Read(std::ifstream &InFile); + void Read(std::istream &InFile); - void Write(std::ofstream &OutFile); + void Write(std::ostream &OutFile); }; #pragma pack(pop) @@ -31,7 +31,7 @@ class CarlaRecorderPhysicsControls void Clear(void); - void Write(std::ofstream &OutFile); + void Write(std::ostream &OutFile); private: diff --git a/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Recorder/CarlaRecorderPlatformTime.cpp b/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Recorder/CarlaRecorderPlatformTime.cpp index f0ac68a47..1f42ce682 100644 --- a/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Recorder/CarlaRecorderPlatformTime.cpp +++ b/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Recorder/CarlaRecorderPlatformTime.cpp @@ -20,12 +20,12 @@ void CarlaRecorderPlatformTime::UpdateTime() Time = diff/1000000.0; } -void CarlaRecorderPlatformTime::Read(std::ifstream &InFile) +void CarlaRecorderPlatformTime::Read(std::istream &InFile) { ReadValue(InFile, this->Time); } -void CarlaRecorderPlatformTime::Write(std::ofstream &OutFile) +void CarlaRecorderPlatformTime::Write(std::ostream &OutFile) { // write the packet id WriteValue(OutFile, static_cast(CarlaRecorderPacketId::PlatformTime)); diff --git a/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Recorder/CarlaRecorderPlatformTime.h b/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Recorder/CarlaRecorderPlatformTime.h index 34e039c07..b954d9a1c 100644 --- a/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Recorder/CarlaRecorderPlatformTime.h +++ b/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Recorder/CarlaRecorderPlatformTime.h @@ -6,7 +6,7 @@ #pragma once -#include +#include #include #pragma pack(push, 1) @@ -21,9 +21,9 @@ struct CarlaRecorderPlatformTime void SetStartTime(); void UpdateTime(); - void Read(std::ifstream &InFile); + void Read(std::istream &InFile); - void Write(std::ofstream &OutFile); + void Write(std::ostream &OutFile); }; #pragma pack(pop) diff --git a/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Recorder/CarlaRecorderPosition.cpp b/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Recorder/CarlaRecorderPosition.cpp index d2a1f0892..fa941e5e7 100644 --- a/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Recorder/CarlaRecorderPosition.cpp +++ b/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Recorder/CarlaRecorderPosition.cpp @@ -8,7 +8,7 @@ #include "CarlaRecorderPosition.h" #include "CarlaRecorderHelpers.h" -void CarlaRecorderPosition::Write(std::ofstream &OutFile) +void CarlaRecorderPosition::Write(std::ostream &OutFile) { // database id WriteValue(OutFile, this->DatabaseId); @@ -16,7 +16,7 @@ void CarlaRecorderPosition::Write(std::ofstream &OutFile) WriteFVector(OutFile, this->Location); WriteFVector(OutFile, this->Rotation); } -void CarlaRecorderPosition::Read(std::ifstream &InFile) +void CarlaRecorderPosition::Read(std::istream &InFile) { // database id ReadValue(InFile, this->DatabaseId); @@ -37,7 +37,7 @@ void CarlaRecorderPositions::Add(const CarlaRecorderPosition &Position) Positions.push_back(Position); } -void CarlaRecorderPositions::Write(std::ofstream &OutFile) +void CarlaRecorderPositions::Write(std::ostream &OutFile) { // write the packet id WriteValue(OutFile, static_cast(CarlaRecorderPacketId::Position)); @@ -57,3 +57,22 @@ void CarlaRecorderPositions::Write(std::ofstream &OutFile) Positions.size() * sizeof(CarlaRecorderPosition)); } } + +void CarlaRecorderPositions::Read(std::istream &InFile) +{ + uint16_t i, Total; + + // read all positions + ReadValue(InFile, Total); + for (i = 0; i < Total; ++i) + { + CarlaRecorderPosition Pos; + Pos.Read(InFile); + Add(Pos); + } +} + +const std::vector& CarlaRecorderPositions::GetPositions() +{ + return Positions; +} diff --git a/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Recorder/CarlaRecorderPosition.h b/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Recorder/CarlaRecorderPosition.h index be17e8a1d..59cfb53f1 100644 --- a/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Recorder/CarlaRecorderPosition.h +++ b/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Recorder/CarlaRecorderPosition.h @@ -6,7 +6,7 @@ #pragma once -#include +#include #include #pragma pack(push, 1) @@ -16,9 +16,9 @@ struct CarlaRecorderPosition FVector Location; FVector Rotation; - void Read(std::ifstream &InFile); + void Read(std::istream &InFile); - void Write(std::ofstream &OutFile); + void Write(std::ostream &OutFile); }; #pragma pack(pop) @@ -31,7 +31,11 @@ public: void Clear(void); - void Write(std::ofstream &OutFile); + void Write(std::ostream &OutFile); + + void Read(std::istream &InFile); + + const std::vector& GetPositions(); private: diff --git a/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Recorder/CarlaRecorderState.cpp b/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Recorder/CarlaRecorderState.cpp index 84b0cea29..5ea9c9892 100644 --- a/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Recorder/CarlaRecorderState.cpp +++ b/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Recorder/CarlaRecorderState.cpp @@ -8,7 +8,7 @@ #include "CarlaRecorderState.h" #include "CarlaRecorderHelpers.h" -void CarlaRecorderStateTrafficLight::Write(std::ofstream &OutFile) +void CarlaRecorderStateTrafficLight::Write(std::ostream &OutFile) { WriteValue(OutFile, this->DatabaseId); WriteValue(OutFile, this->IsFrozen); @@ -16,7 +16,7 @@ void CarlaRecorderStateTrafficLight::Write(std::ofstream &OutFile) WriteValue(OutFile, this->State); } -void CarlaRecorderStateTrafficLight::Read(std::ifstream &InFile) +void CarlaRecorderStateTrafficLight::Read(std::istream &InFile) { ReadValue(InFile, this->DatabaseId); ReadValue(InFile, this->IsFrozen); @@ -36,7 +36,7 @@ void CarlaRecorderStates::Add(const CarlaRecorderStateTrafficLight &State) StatesTrafficLights.push_back(std::move(State)); } -void CarlaRecorderStates::Write(std::ofstream &OutFile) +void CarlaRecorderStates::Write(std::ostream &OutFile) { // write the packet id WriteValue(OutFile, static_cast(CarlaRecorderPacketId::State)); @@ -54,3 +54,22 @@ void CarlaRecorderStates::Write(std::ofstream &OutFile) StatesTrafficLights[i].Write(OutFile); } } + +void CarlaRecorderStates::Read(std::istream &InFile) +{ + uint16_t i, Total; + CarlaRecorderStateTrafficLight StateTrafficLight; + + // read Total traffic light states + ReadValue(InFile, Total); + for (i = 0; i < Total; ++i) + { + StateTrafficLight.Read(InFile); + Add(StateTrafficLight); + } +} + +const std::vector& CarlaRecorderStates::GetStates() +{ + return StatesTrafficLights; +} diff --git a/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Recorder/CarlaRecorderState.h b/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Recorder/CarlaRecorderState.h index 91af60faa..10fab5167 100644 --- a/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Recorder/CarlaRecorderState.h +++ b/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Recorder/CarlaRecorderState.h @@ -6,7 +6,7 @@ #pragma once -#include +#include #pragma pack(push, 1) @@ -17,9 +17,9 @@ struct CarlaRecorderStateTrafficLight float ElapsedTime; char State; - void Read(std::ifstream &InFile); + void Read(std::istream &InFile); - void Write(std::ofstream &OutFile); + void Write(std::ostream &OutFile); }; @@ -34,7 +34,11 @@ public: void Clear(void); - void Write(std::ofstream &OutFile); + void Write(std::ostream &OutFile); + + void Read(std::istream &InFile); + + const std::vector& GetStates(); private: diff --git a/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Recorder/CarlaRecorderTraficLightTime.cpp b/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Recorder/CarlaRecorderTraficLightTime.cpp index c313d4eac..ade34381d 100644 --- a/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Recorder/CarlaRecorderTraficLightTime.cpp +++ b/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Recorder/CarlaRecorderTraficLightTime.cpp @@ -9,7 +9,7 @@ #include "CarlaRecorderHelpers.h" -void CarlaRecorderTrafficLightTime::Write(std::ofstream &OutFile) +void CarlaRecorderTrafficLightTime::Write(std::ostream &OutFile) { WriteValue(OutFile, this->DatabaseId); WriteValue(OutFile, this->GreenTime); @@ -17,7 +17,7 @@ void CarlaRecorderTrafficLightTime::Write(std::ofstream &OutFile) WriteValue(OutFile, this->RedTime); } -void CarlaRecorderTrafficLightTime::Read(std::ifstream &InFile) +void CarlaRecorderTrafficLightTime::Read(std::istream &InFile) { ReadValue(InFile, this->DatabaseId); ReadValue(InFile, this->GreenTime); @@ -37,7 +37,7 @@ void CarlaRecorderTrafficLightTimes::Add(const CarlaRecorderTrafficLightTime &In TrafficLightTimes.push_back(InObj); } -void CarlaRecorderTrafficLightTimes::Write(std::ofstream &OutFile) +void CarlaRecorderTrafficLightTimes::Write(std::ostream &OutFile) { if (TrafficLightTimes.size() == 0) { diff --git a/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Recorder/CarlaRecorderTraficLightTime.h b/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Recorder/CarlaRecorderTraficLightTime.h index d10db4fa4..fe948a720 100644 --- a/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Recorder/CarlaRecorderTraficLightTime.h +++ b/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Recorder/CarlaRecorderTraficLightTime.h @@ -6,7 +6,7 @@ #pragma once -#include +#include #include #pragma pack(push, 1) @@ -17,9 +17,9 @@ struct CarlaRecorderTrafficLightTime float YellowTime = 0; float RedTime = 0; - void Read(std::ifstream &InFile); + void Read(std::istream &InFile); - void Write(std::ofstream &OutFile); + void Write(std::ostream &OutFile); }; #pragma pack(pop) @@ -31,7 +31,7 @@ class CarlaRecorderTrafficLightTimes void Clear(void); - void Write(std::ofstream &OutFile); + void Write(std::ostream &OutFile); private: diff --git a/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Sensor/AsyncDataStream.h b/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Sensor/AsyncDataStream.h index 544989d01..3ab58492b 100644 --- a/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Sensor/AsyncDataStream.h +++ b/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Sensor/AsyncDataStream.h @@ -57,6 +57,16 @@ public: template void Send(SensorT &Sensor, ArgsT &&... Args); + /// allow to change the frame number of the header + void SetFrameNumber(uint64_t FrameNumber) + { + carla::sensor::s11n::SensorHeaderSerializer::Header *HeaderStr = reinterpret_cast(Header.data()); + if (HeaderStr) + { + HeaderStr->frame = FrameNumber; + } + } + private: friend class FDataStreamTmpl; diff --git a/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Sensor/DVSCamera.cpp b/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Sensor/DVSCamera.cpp index 03deebd4a..01784f5a5 100644 --- a/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Sensor/DVSCamera.cpp +++ b/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Sensor/DVSCamera.cpp @@ -131,7 +131,7 @@ void ADVSCamera::PostPhysTick(UWorld *World, ELevelTick TickType, float DeltaTim /// Immediate enqueues render commands of the scene at the current time. EnqueueRenderSceneImmediate(); - WaitForRenderThreadToFinsih(); + WaitForRenderThreadToFinish(); //Super (ASceneCaptureSensor) Capture the Scene in a (UTextureRenderTarget2D) CaptureRenderTarge from the CaptureComponent2D /** Read the image **/ diff --git a/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Sensor/DataStream.h b/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Sensor/DataStream.h index 4a592e2f5..2053ac249 100644 --- a/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Sensor/DataStream.h +++ b/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Sensor/DataStream.h @@ -50,6 +50,11 @@ public: return (*Stream).token(); } + bool AreClientsListening() + { + return Stream ? Stream->AreClientsListening() : false; + } + private: boost::optional Stream; diff --git a/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Sensor/PixelReader.cpp b/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Sensor/PixelReader.cpp index 9698b466d..401277846 100644 --- a/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Sensor/PixelReader.cpp +++ b/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Sensor/PixelReader.cpp @@ -46,7 +46,7 @@ static void WritePixelsToBuffer_Vulkan( uint32 Offset, FRHICommandListImmediate &InRHICmdList) { - TRACE_CPUPROFILER_EVENT_SCOPE_STR(__FUNCTION__); + TRACE_CPUPROFILER_EVENT_SCOPE_STR("WritePixelsToBuffer_Vulkan"); check(IsInRenderingThread()); auto RenderResource = static_cast(RenderTarget.Resource); @@ -177,7 +177,7 @@ void FPixelReader::WritePixelsToBuffer( bool use16BitFormat ) { - TRACE_CPUPROFILER_EVENT_SCOPE_STR(__FUNCTION__); + TRACE_CPUPROFILER_EVENT_SCOPE_STR("WritePixelsToBuffer"); check(IsInRenderingThread()); if (IsVulkanPlatform(GMaxRHIShaderPlatform) || IsD3DPlatform(GMaxRHIShaderPlatform, false)) diff --git a/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Sensor/PixelReader.h b/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Sensor/PixelReader.h index 31ee36fd0..339222802 100644 --- a/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Sensor/PixelReader.h +++ b/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Sensor/PixelReader.h @@ -126,5 +126,5 @@ void FPixelReader::SendPixelsInRenderThread(TSensor &Sensor, bool use16BitFormat ); // Blocks until the render thread has finished all it's tasks - Sensor.WaitForRenderThreadToFinsih(); + Sensor.WaitForRenderThreadToFinish(); } diff --git a/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Sensor/PixelReader2.cpp b/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Sensor/PixelReader2.cpp new file mode 100644 index 000000000..2ade20394 --- /dev/null +++ b/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Sensor/PixelReader2.cpp @@ -0,0 +1,208 @@ +// Copyright (c) 2017 Computer Vision Center (CVC) at the Universitat Autonoma +// de Barcelona (UAB). +// +// This work is licensed under the terms of the MIT license. +// For a copy, see . + +#include "Carla.h" +#include "Carla/Sensor/PixelReader2.h" + +#include "Engine/TextureRenderTarget2D.h" +#include "Async/Async.h" +#include "HighResScreenshot.h" +#include "Runtime/ImageWriteQueue/Public/ImageWriteQueue.h" + +// ============================================================================= +// -- Local variables and types ------------------------------------------------ +// ============================================================================= + +struct LockTexture2 +{ + LockTexture2(FRHITexture2D *InTexture, uint32 &Stride) + : Texture(InTexture), + Source(reinterpret_cast( + RHILockTexture2D(Texture, 0, RLM_ReadOnly, Stride, false))) {} + + ~LockTexture2() + { + RHIUnlockTexture2D(Texture, 0, false); + } + + FRHITexture2D *Texture; + + const uint8 *Source; +}; + +// ============================================================================= +// -- Static local functions --------------------------------------------------- +// ============================================================================= + +// Temporal; this avoid allocating the array each time and also avoids checking +// for a bigger texture, ReadSurfaceData will allocate the space needed. +TArray gPixels2; + +static void WritePixelsToBuffer_Vulkan2( + const UTextureRenderTarget2D &RenderTarget, + uint32 Offset, + FRHICommandListImmediate &RHICmdList, + std::function FuncForSending) +{ + TRACE_CPUPROFILER_EVENT_SCOPE_STR(__FUNCTION__); + check(IsInRenderingThread()); + + auto RenderResource = static_cast(RenderTarget.Resource); + FTexture2DRHIRef Texture = RenderResource->GetRenderTargetTexture(); + if (!Texture) + { + return; + } + + std::unique_ptr BackBufferReadback = std::make_unique(TEXT("CameraBufferReadback")); + FIntPoint BackBufferSize = Texture->GetSizeXY(); + EPixelFormat BackBufferPixelFormat = Texture->GetFormat(); + { + TRACE_CPUPROFILER_EVENT_SCOPE_STR("EnqueueCopy"); + BackBufferReadback->EnqueueCopy(RHICmdList, Texture, FResolveRect(0, 0, BackBufferSize.X, BackBufferSize.Y)); + } + { + TRACE_CPUPROFILER_EVENT_SCOPE_STR("Transition"); + RHICmdList.Transition(FRHITransitionInfo(Texture, ERHIAccess::CopySrc, ERHIAccess::Present)); + } + + TRACE_CPUPROFILER_EVENT_SCOPE_STR("Wait GPU transfer"); + + FPixelFormatInfo PixelFormat = GPixelFormats[BackBufferPixelFormat]; + int32 Count = (BackBufferSize.Y * (PixelFormat.BlockBytes * BackBufferSize.X)); + while (1) + { + void* LockedData = BackBufferReadback->Lock(Count); + if (LockedData) + { + FuncForSending(LockedData, Count, Offset); + break; + } + } + + BackBufferReadback->Unlock(); + BackBufferReadback.reset(); +} + +// Temporal; this avoid allocating the array each time +TArray gFloatPixels2; + +static void WriteFloatPixelsToBuffer_Vulkan2( + const UTextureRenderTarget2D &RenderTarget, + carla::Buffer &Buffer, + uint32 Offset, + FRHICommandListImmediate &InRHICmdList) + +{ + check(IsInRenderingThread()); + gFloatPixels2.Empty(); + auto RenderResource = + static_cast(RenderTarget.Resource); + FTexture2DRHIRef Texture = RenderResource->GetRenderTargetTexture(); + if (!Texture) + { + return; + } + + FIntPoint Rect = RenderResource->GetSizeXY(); + + // NS: Extra copy here, don't know how to avoid it. + InRHICmdList.ReadSurfaceFloatData( + Texture, + FIntRect(0, 0, Rect.X, Rect.Y), + gFloatPixels2, + CubeFace_PosX,0,0); + + TArray IntermediateBuffer; + IntermediateBuffer.Reserve(gFloatPixels2.Num() * 2); + for (FFloat16Color& color : gFloatPixels2) { + float x = (color.R.GetFloat() - 0.5f)*4.f; + float y = (color.G.GetFloat() - 0.5f)*4.f; + IntermediateBuffer.Add(x); + IntermediateBuffer.Add(y); + } + Buffer.copy_from(Offset, IntermediateBuffer); +} + +// ============================================================================= +// -- FPixelReader ------------------------------------------------------------- +// ============================================================================= + +bool FPixelReader2::WritePixelsToArray( + UTextureRenderTarget2D &RenderTarget, + TArray &BitMap) +{ + check(IsInGameThread()); + FTextureRenderTargetResource *RTResource = + RenderTarget.GameThread_GetRenderTargetResource(); + if (RTResource == nullptr) + { + UE_LOG(LogCarla, Error, TEXT("FPixelReader2: UTextureRenderTarget2D missing render target")); + return false; + } + FReadSurfaceDataFlags ReadPixelFlags(RCM_UNorm); + ReadPixelFlags.SetLinearToGamma(true); + return RTResource->ReadPixels(BitMap, ReadPixelFlags); +} + +TUniquePtr> FPixelReader2::DumpPixels( + UTextureRenderTarget2D &RenderTarget) +{ + const FIntPoint DestSize(RenderTarget.GetSurfaceWidth(), RenderTarget.GetSurfaceHeight()); + TUniquePtr> PixelData = MakeUnique>(DestSize); + TArray Pixels(PixelData->Pixels.GetData(), PixelData->Pixels.Num()); + if (!WritePixelsToArray(RenderTarget, Pixels)) + { + return nullptr; + } + return PixelData; +} + +TFuture FPixelReader2::SavePixelsToDisk( + UTextureRenderTarget2D &RenderTarget, + const FString &FilePath) +{ + return SavePixelsToDisk(DumpPixels(RenderTarget), FilePath); +} + +TFuture FPixelReader2::SavePixelsToDisk( + TUniquePtr> PixelData, + const FString &FilePath) +{ + TUniquePtr ImageTask = MakeUnique(); + ImageTask->PixelData = MoveTemp(PixelData); + ImageTask->Filename = FilePath; + ImageTask->Format = EImageFormat::PNG; + ImageTask->CompressionQuality = (int32) EImageCompressionQuality::Default; + ImageTask->bOverwriteFile = true; + ImageTask->PixelPreProcessors.Add(TAsyncAlphaWrite(255)); + + FHighResScreenshotConfig &HighResScreenshotConfig = GetHighResScreenshotConfig(); + return HighResScreenshotConfig.ImageWriteQueue->Enqueue(MoveTemp(ImageTask)); +} + +void FPixelReader2::WritePixelsToBuffer( + UTextureRenderTarget2D &RenderTarget, + uint32 Offset, + FRHICommandListImmediate &InRHICmdList, + std::function FuncForSending, + bool use16BitFormat) +{ + TRACE_CPUPROFILER_EVENT_SCOPE_STR(__FUNCTION__); + check(IsInRenderingThread()); + + if (IsVulkanPlatform(GMaxRHIShaderPlatform) || IsD3DPlatform(GMaxRHIShaderPlatform, false)) + { + if (use16BitFormat) + { + // WriteFloatPixelsToBuffer_Vulkan2(RenderTarget, Buffer, Offset, InRHICmdList); + } + else + { + WritePixelsToBuffer_Vulkan2(RenderTarget, Offset, InRHICmdList, std::move(FuncForSending)); + } + } +} diff --git a/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Sensor/PixelReader2.h b/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Sensor/PixelReader2.h new file mode 100644 index 000000000..94fdee33b --- /dev/null +++ b/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Sensor/PixelReader2.h @@ -0,0 +1,150 @@ +// Copyright (c) 2017 Computer Vision Center (CVC) at the Universitat Autonoma +// de Barcelona (UAB). +// +// This work is licensed under the terms of the MIT license. +// For a copy, see . + +#pragma once + +#include "CoreGlobals.h" +#include "Engine/TextureRenderTarget2D.h" +#include "Runtime/ImageWriteQueue/Public/ImagePixelData.h" + +#include +#include +#include +#include +#include + +// ============================================================================= +// -- FPixelReader ------------------------------------------------------------- +// ============================================================================= + +/// Utils for reading pixels from UTextureRenderTarget2D. +/// +/// @todo This class only supports PF_R8G8B8A8 format. +class FPixelReader2 +{ +public: + + /// Copy the pixels in @a RenderTarget into @a BitMap. + /// + /// @pre To be called from game-thread. + static bool WritePixelsToArray( + UTextureRenderTarget2D &RenderTarget, + TArray &BitMap); + + /// Dump the pixels in @a RenderTarget. + /// + /// @pre To be called from game-thread. + static TUniquePtr> DumpPixels( + UTextureRenderTarget2D &RenderTarget); + + /// Asynchronously save the pixels in @a RenderTarget to disk. + /// + /// @pre To be called from game-thread. + static TFuture SavePixelsToDisk( + UTextureRenderTarget2D &RenderTarget, + const FString &FilePath); + + /// Asynchronously save the pixels in @a PixelData to disk. + /// + /// @pre To be called from game-thread. + static TFuture SavePixelsToDisk( + TUniquePtr> PixelData, + const FString &FilePath); + + /// Convenience function to enqueue a render command that sends the pixels + /// down the @a Sensor's data stream. It expects a sensor derived from + /// ASceneCaptureSensor or compatible. + /// + /// Note that the serializer needs to define a "header_offset" that it's + /// allocated in front of the buffer. + /// + /// @pre To be called from game-thread. + template + static void SendPixelsInRenderThread(TSensor &Sensor, bool use16BitFormat = false); + +private: + + /// Copy the pixels in @a RenderTarget into @a Buffer. + /// + /// @pre To be called from render-thread. + static void WritePixelsToBuffer( + UTextureRenderTarget2D &RenderTarget, + uint32 Offset, + FRHICommandListImmediate &InRHICmdList, + std::function FuncForSending, + bool use16BitFormat = false); + +}; + +// ============================================================================= +// -- FPixelReader::SendPixelsInRenderThread ----------------------------------- +// ============================================================================= + +template +void FPixelReader2::SendPixelsInRenderThread(TSensor &Sensor, bool use16BitFormat) +{ + TRACE_CPUPROFILER_EVENT_SCOPE(FPixelReader2::SendPixelsInRenderThread); + check(Sensor.CaptureRenderTarget != nullptr); + + if (!Sensor.HasActorBegunPlay() || Sensor.IsPendingKill()) + { + return; + } + + /// Blocks until the render thread has finished all it's tasks. + Sensor.EnqueueRenderSceneImmediate(); + + // Enqueue a command in the render-thread that will write the image buffer to + // the data stream. The stream is created in the capture thus executed in the + // game-thread. + ENQUEUE_RENDER_COMMAND(FWritePixels2_SendPixelsInRenderThread) + ( + [&Sensor, use16BitFormat](auto &InRHICmdList) mutable + { + TRACE_CPUPROFILER_EVENT_SCOPE_STR("FWritePixels2_SendPixelsInRenderThread"); + + /// @todo Can we make sure the sensor is not going to be destroyed? + if (!Sensor.IsPendingKill()) + { + + std::function FuncForSending = [&Sensor, Frame = FCarlaEngine::GetFrameCounter()](void *LockedData, uint32 Count, uint32 Offset) + { + if (Sensor.IsPendingKill()) return; + + auto Stream = Sensor.GetDataStream(Sensor); + Stream.SetFrameNumber(Frame); + auto Buffer = Stream.PopBufferFromPool(); + + { + TRACE_CPUPROFILER_EVENT_SCOPE_STR("Buffer Copy"); + Buffer.copy_from(Offset, boost::asio::buffer(LockedData, Count)); + } + { + // send + TRACE_CPUPROFILER_EVENT_SCOPE_STR("Sending buffer"); + if(Buffer.data()) + { + SCOPE_CYCLE_COUNTER(STAT_CarlaSensorStreamSend); + TRACE_CPUPROFILER_EVENT_SCOPE_STR("Stream Send"); + Stream.Send(Sensor, std::move(Buffer)); + } + } + }; + + WritePixelsToBuffer( + *Sensor.CaptureRenderTarget, + carla::sensor::SensorRegistry::get::type::header_offset, + InRHICmdList, + std::move(FuncForSending), + use16BitFormat); + + } + } + ); + + // Blocks until the render thread has finished all it's tasks + Sensor.WaitForRenderThreadToFinish(); +} diff --git a/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Sensor/SceneCaptureCamera.cpp b/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Sensor/SceneCaptureCamera.cpp index fa095694b..6bb79258a 100644 --- a/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Sensor/SceneCaptureCamera.cpp +++ b/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Sensor/SceneCaptureCamera.cpp @@ -6,6 +6,8 @@ #include "Carla.h" #include "Carla/Sensor/SceneCaptureCamera.h" +#include "Carla/Game/CarlaEngine.h" +#include #include "Runtime/RenderCore/Public/RenderingThread.h" @@ -24,8 +26,39 @@ ASceneCaptureCamera::ASceneCaptureCamera(const FObjectInitializer &ObjectInitial TEXT("Material'/Carla/PostProcessingMaterials/PhysicLensDistortion.PhysicLensDistortion'")); } +void ASceneCaptureCamera::BeginPlay() +{ + Super::BeginPlay(); +} + +void ASceneCaptureCamera::OnFirstClientConnected() +{ +} + +void ASceneCaptureCamera::OnLastClientDisconnected() +{ +} + +void ASceneCaptureCamera::EndPlay(const EEndPlayReason::Type EndPlayReason) +{ + Super::EndPlay(EndPlayReason); +} + void ASceneCaptureCamera::PostPhysTick(UWorld *World, ELevelTick TickType, float DeltaSeconds) { TRACE_CPUPROFILER_EVENT_SCOPE(ASceneCaptureCamera::PostPhysTick); - FPixelReader::SendPixelsInRenderThread(*this); + ENQUEUE_RENDER_COMMAND(MeasureTime) + ( + [](auto &InRHICmdList) + { + std::chrono::time_point Time = + std::chrono::high_resolution_clock::now(); + auto Duration = std::chrono::duration_cast< std::chrono::milliseconds >(Time.time_since_epoch()); + uint64_t Milliseconds = Duration.count(); + FString ProfilerText = FString("(Render)Frame: ") + FString::FromInt(FCarlaEngine::GetFrameCounter()) + + FString(" Time: ") + FString::FromInt(Milliseconds); + TRACE_CPUPROFILER_EVENT_SCOPE_TEXT(*ProfilerText); + } + ); + FPixelReader2::SendPixelsInRenderThread(*this); } diff --git a/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Sensor/SceneCaptureCamera.h b/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Sensor/SceneCaptureCamera.h index 7bf4262a3..9c80fd480 100644 --- a/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Sensor/SceneCaptureCamera.h +++ b/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Sensor/SceneCaptureCamera.h @@ -20,12 +20,20 @@ class CARLA_API ASceneCaptureCamera : public AShaderBasedSensor public: + static FActorDefinition GetSensorDefinition(); ASceneCaptureCamera(const FObjectInitializer &ObjectInitializer); protected: - void PostPhysTick(UWorld *World, ELevelTick TickType, float DeltaSeconds) override; + void BeginPlay() override; + void EndPlay(const EEndPlayReason::Type EndPlayReason) override; + void PostPhysTick(UWorld *World, ELevelTick TickType, float DeltaSeconds) override; + + virtual void OnFirstClientConnected() override; + virtual void OnLastClientDisconnected() override; + +private: }; diff --git a/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Sensor/SceneCaptureSensor.cpp b/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Sensor/SceneCaptureSensor.cpp index 1ef1bc33b..ff73f61f9 100644 --- a/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Sensor/SceneCaptureSensor.cpp +++ b/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Sensor/SceneCaptureSensor.cpp @@ -457,7 +457,7 @@ float ASceneCaptureSensor::GetChromAberrOffset() const void ASceneCaptureSensor::EnqueueRenderSceneImmediate() { TRACE_CPUPROFILER_EVENT_SCOPE(ASceneCaptureSensor::EnqueueRenderSceneImmediate); // Creates an snapshot of the scene, requieres bCaptureEveryFrame = false. - CaptureComponent2D->CaptureScene(); + GetCaptureComponent2D()->CaptureScene(); } void ASceneCaptureSensor::BeginPlay() diff --git a/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Sensor/SceneCaptureSensor.h b/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Sensor/SceneCaptureSensor.h index edf370b97..0d7b2c965 100644 --- a/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Sensor/SceneCaptureSensor.h +++ b/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Sensor/SceneCaptureSensor.h @@ -32,6 +32,7 @@ class CARLA_API ASceneCaptureSensor : public ASensor friend class ACarlaGameModeBase; friend class FPixelReader; + friend class FPixelReader2; public: @@ -289,12 +290,18 @@ public: return CaptureComponent2D; } + UFUNCTION(BlueprintCallable) + UTextureRenderTarget2D *GetCaptureRenderTarget() + { + return CaptureRenderTarget; + } + /// Immediate enqueues render commands of the scene at the current time. void EnqueueRenderSceneImmediate(); /// Blocks until the render thread has finished all it's tasks. - void WaitForRenderThreadToFinsih() { - TRACE_CPUPROFILER_EVENT_SCOPE(ASceneCaptureSensor::WaitForRenderThreadToFinsih); + void WaitForRenderThreadToFinish() { + TRACE_CPUPROFILER_EVENT_SCOPE(ASceneCaptureSensor::WaitForRenderThreadToFinish); // FlushRenderingCommands(); } diff --git a/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Sensor/Sensor.cpp b/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Sensor/Sensor.cpp index 0cc5e45f9..f7e236b28 100644 --- a/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Sensor/Sensor.cpp +++ b/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Sensor/Sensor.cpp @@ -6,6 +6,7 @@ #include "Carla.h" #include "Carla/Sensor/Sensor.h" +#include "Carla/Sensor/SensorManager.h" #include "Carla/Actor/ActorDescription.h" #include "Carla/Actor/ActorBlueprintFunctionLibrary.h" @@ -23,8 +24,9 @@ ASensor::ASensor(const FObjectInitializer &ObjectInitializer) void ASensor::BeginPlay() { Super::BeginPlay(); - OnPostTickDelegate = FWorldDelegates::OnWorldPostActorTick.AddUObject( - this, &ASensor::PostPhysTickInternal); + UCarlaEpisode* Episode = UCarlaStatics::GetCurrentEpisode(GetWorld()); + FSensorManager& SensorManager = Episode->GetSensorManager(); + SensorManager.RegisterSensor(this); } void ASensor::Set(const FActorDescription &Description) @@ -42,6 +44,26 @@ void ASensor::Tick(const float DeltaTime) { TRACE_CPUPROFILER_EVENT_SCOPE(ASensor::Tick); Super::Tick(DeltaTime); + if (bClientsListening) + { + if(!Stream.AreClientsListening()) + { + OnLastClientDisconnected(); + bClientsListening = false; + } + } + else + { + if(Stream.AreClientsListening()) + { + OnFirstClientConnected(); + bClientsListening = true; + } + } + if(!bClientsListening) + { + return; + } ReadyToTick = true; PrePhysTick(DeltaTime); } @@ -77,7 +99,12 @@ void ASensor::EndPlay(EEndPlayReason::Type EndPlayReason) Super::EndPlay(EndPlayReason); Stream = FDataStream(); - FWorldDelegates::OnWorldPostActorTick.Remove(OnPostTickDelegate); + UCarlaEpisode* Episode = UCarlaStatics::GetCurrentEpisode(GetWorld()); + if(Episode) + { + FSensorManager& SensorManager = Episode->GetSensorManager(); + SensorManager.DeRegisterSensor(this); + } } void ASensor::PostPhysTickInternal(UWorld *World, ELevelTick TickType, float DeltaSeconds) diff --git a/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Sensor/Sensor.h b/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Sensor/Sensor.h index ffe7c0561..02b686459 100644 --- a/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Sensor/Sensor.h +++ b/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Sensor/Sensor.h @@ -58,6 +58,13 @@ public: virtual void PrePhysTick(float DeltaSeconds) {} virtual void PostPhysTick(UWorld *World, ELevelTick TickType, float DeltaSeconds) {} + // Small interface to notify sensors when clients are listening + virtual void OnFirstClientConnected() {}; + // Small interface to notify sensors when no clients are listening + virtual void OnLastClientDisconnected() {}; + + + void PostPhysTickInternal(UWorld *World, ELevelTick TickType, float DeltaSeconds); UFUNCTION(BlueprintCallable) URandomEngine *GetRandomEngine() @@ -104,9 +111,10 @@ protected: UPROPERTY() URandomEngine *RandomEngine = nullptr; -private: + UPROPERTY() + bool bIsActive = false; - void PostPhysTickInternal(UWorld *World, ELevelTick TickType, float DeltaSeconds); +private: FDataStream Stream; @@ -116,4 +124,7 @@ private: /// Allows the sensor to tick with the tick rate from UE4. bool ReadyToTick = false; + + bool bClientsListening = false; + }; diff --git a/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Sensor/SensorManager.cpp b/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Sensor/SensorManager.cpp new file mode 100644 index 000000000..d70c7b1c0 --- /dev/null +++ b/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Sensor/SensorManager.cpp @@ -0,0 +1,26 @@ +// Copyright (c) 2022 Computer Vision Center (CVC) at the Universitat Autonoma +// de Barcelona (UAB). +// +// This work is licensed under the terms of the MIT license. +// For a copy, see . + +#include "SensorManager.h" +#include "Sensor.h" + +void FSensorManager::RegisterSensor(ASensor* Sensor) +{ + SensorList.Emplace(Sensor); +} + +void FSensorManager::DeRegisterSensor(ASensor* Sensor) +{ + SensorList.Remove(Sensor); +} + +void FSensorManager::PostPhysTick(UWorld *World, ELevelTick TickType, float DeltaSeconds) +{ + for(ASensor* Sensor : SensorList) + { + Sensor->PostPhysTickInternal(World, TickType, DeltaSeconds); + } +} diff --git a/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Sensor/SensorManager.h b/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Sensor/SensorManager.h new file mode 100644 index 000000000..543ac1da2 --- /dev/null +++ b/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Sensor/SensorManager.h @@ -0,0 +1,26 @@ +// Copyright (c) 2022 Computer Vision Center (CVC) at the Universitat Autonoma +// de Barcelona (UAB). +// +// This work is licensed under the terms of the MIT license. +// For a copy, see . + +#pragma once + +class ASensor; + +class FSensorManager +{ + +public: + + void RegisterSensor(ASensor* Sensor); + + void DeRegisterSensor(ASensor* Sensor); + + void PostPhysTick(UWorld *World, ELevelTick TickType, float DeltaSeconds); + +private: + + TArray SensorList; + +}; diff --git a/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Server/CarlaServer.cpp b/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Server/CarlaServer.cpp index b58d1c6e5..b7e882dfb 100644 --- a/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Server/CarlaServer.cpp +++ b/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Server/CarlaServer.cpp @@ -28,6 +28,7 @@ #include #include +#include #include #include #include @@ -40,7 +41,7 @@ #include #include #include -#include "carla/rpc/LabelledPoint.h" +#include #include #include #include @@ -61,12 +62,13 @@ #include #include #include -#include +#include #include #include #include #include +#include #include #include @@ -91,14 +93,21 @@ class FCarlaServer::FPimpl { public: - FPimpl(uint16_t RPCPort, uint16_t StreamingPort) + FPimpl(uint16_t RPCPort, uint16_t StreamingPort, uint16_t SecondaryPort) : Server(RPCPort), StreamingServer(StreamingPort), BroadcastStream(StreamingServer.MakeStream()) { + // we need to create shared_ptr from the router for some handlers to live + SecondaryServer = std::make_shared(SecondaryPort); + SecondaryServer->SetCallbacks(); BindActions(); } + std::shared_ptr GetSecondaryServer() { + return SecondaryServer; + } + /// Map of pairs < port , ip > with all the Traffic Managers active in the simulation std::map TrafficManagerInfo; @@ -107,10 +116,12 @@ public: carla::streaming::Server StreamingServer; carla::streaming::Stream BroadcastStream; + + std::shared_ptr SecondaryServer; UCarlaEpisode *Episode = nullptr; - size_t TickCuesReceived = 0u; + std::atomic_size_t TickCuesReceived { 0u }; private: @@ -253,8 +264,9 @@ void FCarlaServer::FPimpl::BindActions() BIND_SYNC(tick_cue) << [this]() -> R { TRACE_CPUPROFILER_EVENT_SCOPE(TickCueReceived); - ++TickCuesReceived; - return FCarlaEngine::GetFrameCounter(); + auto Current = FCarlaEngine::GetFrameCounter(); + (void)TickCuesReceived.fetch_add(1, std::memory_order_release); + return Current + 1; }; // ~~ Load new episode ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ @@ -755,6 +767,21 @@ void FCarlaServer::FPimpl::BindActions() return GEngine->Exec(Episode->GetWorld(), UTF8_TO_TCHAR(cmd.c_str())); }; + BIND_SYNC(get_sensor_token) << [this](carla::streaming::detail::stream_id_type sensor_id) -> R + { + REQUIRE_CARLA_EPISODE(); + if (SecondaryServer->HasClientsConnected() && sensor_id > 1) + { + // multi-gpu + return SecondaryServer->GetCommander().SendGetToken(sensor_id); + } + else + { + // single-gpu + return StreamingServer.GetToken(sensor_id); + } + }; + // ~~ Actor physics ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ BIND_SYNC(set_actor_location) << [this]( @@ -2284,16 +2311,19 @@ FCarlaServer::FCarlaServer() : Pimpl(nullptr) {} FCarlaServer::~FCarlaServer() {} -FDataMultiStream FCarlaServer::Start(uint16_t RPCPort, uint16_t StreamingPort) +FDataMultiStream FCarlaServer::Start(uint16_t RPCPort, uint16_t StreamingPort, uint16_t SecondaryPort) { - Pimpl = MakeUnique(RPCPort, StreamingPort); + Pimpl = MakeUnique(RPCPort, StreamingPort, SecondaryPort); StreamingPort = Pimpl->StreamingServer.GetLocalEndpoint().port(); + SecondaryPort = Pimpl->SecondaryServer->GetLocalEndpoint().port(); + UE_LOG( LogCarlaServer, Log, - TEXT("Initialized CarlaServer: Ports(rpc=%d, streaming=%d)"), + TEXT("Initialized CarlaServer: Ports(rpc=%d, streaming=%d, secondary=%d)"), RPCPort, - StreamingPort); + StreamingPort, + SecondaryPort); return Pimpl->BroadcastStream; } @@ -2314,26 +2344,32 @@ void FCarlaServer::AsyncRun(uint32 NumberOfWorkerThreads) { check(Pimpl != nullptr); /// @todo Define better the number of threads each server gets. - int32_t RPCThreads = std::max(2u, NumberOfWorkerThreads / 2u); - int32_t StreamingThreads = std::max(2u, NumberOfWorkerThreads - RPCThreads); + int ThreadsPerServer = std::max(2u, NumberOfWorkerThreads / 3u); + int32_t RPCThreads; + int32_t StreamingThreads; + int32_t SecondaryThreads; UE_LOG(LogCarla, Log, TEXT("FCommandLine %s"), FCommandLine::Get()); if(!FParse::Value(FCommandLine::Get(), TEXT("-RPCThreads="), RPCThreads)) { - RPCThreads = std::max(2u, NumberOfWorkerThreads / 2u); + RPCThreads = ThreadsPerServer; } if(!FParse::Value(FCommandLine::Get(), TEXT("-StreamingThreads="), StreamingThreads)) { - StreamingThreads = std::max(2u, NumberOfWorkerThreads - RPCThreads); + StreamingThreads = ThreadsPerServer; + } + if(!FParse::Value(FCommandLine::Get(), TEXT("-SecondaryThreads="), SecondaryThreads)) + { + SecondaryThreads = ThreadsPerServer; } - UE_LOG(LogCarla, Log, TEXT("FCarlaServer AsyncRun %d, RPCThreads %d, StreamingThreads %d"), - NumberOfWorkerThreads, RPCThreads, StreamingThreads); + UE_LOG(LogCarla, Log, TEXT("FCarlaServer AsyncRun %d, RPCThreads %d, StreamingThreads %d, SecondaryThreads %d"), + NumberOfWorkerThreads, RPCThreads, StreamingThreads, SecondaryThreads); Pimpl->Server.AsyncRun(RPCThreads); Pimpl->StreamingServer.AsyncRun(StreamingThreads); - + Pimpl->SecondaryServer->AsyncRun(SecondaryThreads); } void FCarlaServer::RunSome(uint32 Milliseconds) @@ -2342,14 +2378,18 @@ void FCarlaServer::RunSome(uint32 Milliseconds) Pimpl->Server.SyncRunFor(carla::time_duration::milliseconds(Milliseconds)); } +void FCarlaServer::Tick() +{ + (void)Pimpl->TickCuesReceived.fetch_add(1, std::memory_order_release); +} + bool FCarlaServer::TickCueReceived() { - if (Pimpl->TickCuesReceived > 0u) - { - --(Pimpl->TickCuesReceived); - return true; - } - return false; + auto k = Pimpl->TickCuesReceived.fetch_sub(1, std::memory_order_acquire); + bool flag = (k > 0); + if (!flag) + (void)Pimpl->TickCuesReceived.fetch_add(1, std::memory_order_release); + return flag; } void FCarlaServer::Stop() @@ -2363,3 +2403,13 @@ FDataStream FCarlaServer::OpenStream() const check(Pimpl != nullptr); return Pimpl->StreamingServer.MakeStream(); } + +std::shared_ptr FCarlaServer::GetSecondaryServer() +{ + return Pimpl->GetSecondaryServer(); +} + +carla::streaming::Server &FCarlaServer::GetStreamingServer() +{ + return Pimpl->StreamingServer; +} diff --git a/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Server/CarlaServer.h b/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Server/CarlaServer.h index 2ee243bad..398b2f5da 100644 --- a/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Server/CarlaServer.h +++ b/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Server/CarlaServer.h @@ -11,6 +11,11 @@ #include "CoreMinimal.h" +#include +#include +#include +#include + class UCarlaEpisode; class FCarlaServer @@ -21,7 +26,7 @@ public: ~FCarlaServer(); - FDataMultiStream Start(uint16_t RPCPort, uint16_t StreamingPort); + FDataMultiStream Start(uint16_t RPCPort, uint16_t StreamingPort, uint16_t SecondaryPort); void NotifyBeginEpisode(UCarlaEpisode &Episode); @@ -31,12 +36,18 @@ public: void RunSome(uint32 Milliseconds); + void Tick(); + bool TickCueReceived(); void Stop(); FDataStream OpenStream() const; + std::shared_ptr GetSecondaryServer(); + + carla::streaming::Server &GetStreamingServer(); + private: class FPimpl; diff --git a/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Settings/CarlaSettings.cpp b/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Settings/CarlaSettings.cpp index 0d3c7fc6f..32cf6f4bf 100644 --- a/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Settings/CarlaSettings.cpp +++ b/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Settings/CarlaSettings.cpp @@ -68,8 +68,16 @@ static void LoadSettingsFromConfig( // CarlaServer. if (bLoadCarlaServerSection) { - ConfigFile.GetInt(S_CARLA_SERVER, TEXT("WorldPort"), Settings.RPCPort); - ConfigFile.GetInt(S_CARLA_SERVER, TEXT("RPCPort"), Settings.RPCPort); + ConfigFile.GetInt(S_CARLA_SERVER, TEXT("WorldPort"), Settings.RPCPort); + ConfigFile.GetInt(S_CARLA_SERVER, TEXT("RPCPort"), Settings.RPCPort); + Settings.StreamingPort = Settings.RPCPort + 1u; + Settings.SecondaryPort = Settings.RPCPort + 2u; + ConfigFile.GetInt(S_CARLA_SERVER, TEXT("StreamingPort"), Settings.StreamingPort); + ConfigFile.GetInt(S_CARLA_SERVER, TEXT("SecondaryPort"), Settings.SecondaryPort); + FString Tmp; + ConfigFile.GetString(S_CARLA_SERVER, TEXT("PrimaryIP"), Tmp); + Settings.PrimaryIP = TCHAR_TO_UTF8(*Tmp); + ConfigFile.GetInt(S_CARLA_SERVER, TEXT("PrimaryPort"), Settings.PrimaryPort); } ConfigFile.GetBool(S_CARLA_SERVER, TEXT("SynchronousMode"), Settings.bSynchronousMode); ConfigFile.GetBool(S_CARLA_SERVER, TEXT("DisableRendering"), Settings.bDisableRendering); @@ -118,11 +126,26 @@ void UCarlaSettings::LoadSettings() FParse::Value(FCommandLine::Get(), TEXT("-carla-world-port="), Value)) { RPCPort = Value; + StreamingPort = Value + 1u; + SecondaryPort = Value + 2u; } if (FParse::Value(FCommandLine::Get(), TEXT("-carla-streaming-port="), Value)) { StreamingPort = Value; } + if (FParse::Value(FCommandLine::Get(), TEXT("-carla-secondary-port="), Value)) + { + SecondaryPort = Value; + } + FString Tmp; + if (FParse::Value(FCommandLine::Get(), TEXT("-carla-primary-host="), Tmp)) + { + PrimaryIP = TCHAR_TO_UTF8(*Tmp); + } + if (FParse::Value(FCommandLine::Get(), TEXT("-carla-primary-port="), Value)) + { + PrimaryPort = Value; + } FString StringQualityLevel; if (FParse::Value(FCommandLine::Get(), TEXT("-quality-level="), StringQualityLevel)) { @@ -153,7 +176,8 @@ void UCarlaSettings::LogSettings() const UE_LOG(LogCarla, Log, TEXT("Last settings file loaded: %s"), *CurrentFileName); UE_LOG(LogCarla, Log, TEXT("[%s]"), S_CARLA_SERVER); UE_LOG(LogCarla, Log, TEXT("RPC Port = %d"), RPCPort); - UE_LOG(LogCarla, Log, TEXT("Streaming Port = %d"), StreamingPort.Get(RPCPort + 1u)); + UE_LOG(LogCarla, Log, TEXT("Streaming Port = %d"), StreamingPort); + UE_LOG(LogCarla, Log, TEXT("Secondary Port = %d"), SecondaryPort); UE_LOG(LogCarla, Log, TEXT("Synchronous Mode = %s"), EnabledDisabled(bSynchronousMode)); UE_LOG(LogCarla, Log, TEXT("Rendering = %s"), EnabledDisabled(!bDisableRendering)); UE_LOG(LogCarla, Log, TEXT("[%s]"), S_CARLA_QUALITYSETTINGS); diff --git a/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Settings/CarlaSettings.h b/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Settings/CarlaSettings.h index 7249aed8e..a124daebb 100644 --- a/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Settings/CarlaSettings.h +++ b/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Settings/CarlaSettings.h @@ -82,8 +82,15 @@ public: UPROPERTY(Category = "CARLA Server", VisibleAnywhere, meta = (EditCondition = bUseNetworking)) uint32 RPCPort = 2000u; - /// Optional setting for the secondary port. - TOptional StreamingPort; + /// setting for the streaming port. + uint32 StreamingPort = 2001u; + + /// setting for the secondary servers port. + uint32 SecondaryPort = 2002u; + + /// setting for the IP and Port of the primary server to connect. + std::string PrimaryIP = ""; + uint32 PrimaryPort = 2002u; /// In synchronous mode, CARLA waits every tick until the control from the /// client is received. diff --git a/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Traffic/SpeedLimitComponent.cpp b/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Traffic/SpeedLimitComponent.cpp index 06082bf5f..75d00e764 100644 --- a/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Traffic/SpeedLimitComponent.cpp +++ b/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Traffic/SpeedLimitComponent.cpp @@ -5,8 +5,16 @@ // For a copy, see . #include "SpeedLimitComponent.h" +#include "Carla/Game/CarlaStatics.h" +#include "Carla/MapGen/LargeMapManager.h" #include "Carla/Vehicle/CarlaWheeledVehicle.h" +#include "Carla/Vehicle/WheeledVehicleAIController.h" +#include +#include "carla/geom/Transform.h" +#include "carla/road/element/Waypoint.h" +#include "carla/road/element/RoadInfoSignal.h" +#include void USpeedLimitComponent::SetSpeedLimit(float Limit) { @@ -28,9 +36,9 @@ void USpeedLimitComponent::InitializeSign(const carla::road::Map &Map) { auto RoadId = Reference.first; const auto* SignalReference = Reference.second; - for(auto &validity : SignalReference->GetValidities()) + for(auto &val : SignalReference->GetValidities()) { - for(auto lane : carla::geom::Math::GenerateRange(validity._from_lane, validity._to_lane)) + for(auto lane : carla::geom::Math::GenerateRange(val._from_lane, val._to_lane)) { if(lane == 0) continue; diff --git a/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Traffic/StopSignComponent.cpp b/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Traffic/StopSignComponent.cpp index b69177d52..a40fe638a 100644 --- a/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Traffic/StopSignComponent.cpp +++ b/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Traffic/StopSignComponent.cpp @@ -6,12 +6,15 @@ #include "StopSignComponent.h" #include "TrafficLightState.h" +#include "Carla/Vehicle/CarlaWheeledVehicle.h" + #include #include "Carla/Game/CarlaStatics.h" #include "Carla/MapGen/LargeMapManager.h" #include #include +#include #include void UStopSignComponent::InitializeSign(const carla::road::Map &Map) diff --git a/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Traffic/TrafficLightComponent.cpp b/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Traffic/TrafficLightComponent.cpp index aab65384e..38614e6d4 100644 --- a/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Traffic/TrafficLightComponent.cpp +++ b/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Traffic/TrafficLightComponent.cpp @@ -13,6 +13,7 @@ #include "TrafficLightManager.h" #include "Carla/Game/CarlaStatics.h" #include "Carla/MapGen/LargeMapManager.h" +#include "carla/road/element/RoadInfoSignal.h" UTrafficLightComponent::UTrafficLightComponent() : Super() diff --git a/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Traffic/TrafficLightManager.cpp b/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Traffic/TrafficLightManager.cpp index a50fb5fdc..4cf8ca481 100644 --- a/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Traffic/TrafficLightManager.cpp +++ b/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Traffic/TrafficLightManager.cpp @@ -11,9 +11,12 @@ #include "SpeedLimitComponent.h" #include "Components/BoxComponent.h" +#include "UObject/ConstructorHelpers.h" + #include #include #include +#include #include #include diff --git a/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Vehicle/CarlaWheeledVehicle.cpp b/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Vehicle/CarlaWheeledVehicle.cpp index 1b86fe0ba..5956f66e5 100644 --- a/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Vehicle/CarlaWheeledVehicle.cpp +++ b/Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Vehicle/CarlaWheeledVehicle.cpp @@ -911,6 +911,7 @@ FVector ACarlaWheeledVehicle::GetVelocity() const void ACarlaWheeledVehicle::EndPlay(const EEndPlayReason::Type EndPlayReason) { ShowDebugTelemetry(false); + Super::EndPlay(EndPlayReason); } void ACarlaWheeledVehicle::OpenDoor(const EVehicleDoor DoorIdx) { diff --git a/Util/BuildTools/BuildCarlaUE4.bat b/Util/BuildTools/BuildCarlaUE4.bat index 2a3176b76..7438b58c2 100644 --- a/Util/BuildTools/BuildCarlaUE4.bat +++ b/Util/BuildTools/BuildCarlaUE4.bat @@ -21,10 +21,15 @@ set USE_CARSIM=false set USE_CHRONO=false set CARSIM_STATE="CarSim OFF" set CHRONO_STATE="Chrono OFF" +set EDITOR_FLAGS="" :arg-parse echo %1 if not "%1"=="" ( + if "%1"=="--editor-flags" ( + set EDITOR_FLAGS=%2 + shift + ) if "%1"=="--build" ( set BUILD_UE4_EDITOR=true ) @@ -49,6 +54,8 @@ if not "%1"=="" ( shift goto arg-parse ) +rem remove quotes from arguments +set EDITOR_FLAGS=%EDITOR_FLAGS:"=% if %REMOVE_INTERMEDIATE% == false ( if %LAUNCH_UE4_EDITOR% == false ( @@ -151,7 +158,7 @@ rem if %LAUNCH_UE4_EDITOR% == true ( echo %FILE_N% Launching Unreal Editor... call "%UE4_ROOT%\Engine\Binaries\Win64\UE4Editor.exe"^ - "%UE4_PROJECT_FOLDER%CarlaUE4.uproject" + "%UE4_PROJECT_FOLDER%CarlaUE4.uproject" %EDITOR_FLAGS% if %errorlevel% neq 0 goto error_build ) diff --git a/Util/BuildTools/BuildCarlaUE4.sh b/Util/BuildTools/BuildCarlaUE4.sh index 560dca9de..1f6337947 100755 --- a/Util/BuildTools/BuildCarlaUE4.sh +++ b/Util/BuildTools/BuildCarlaUE4.sh @@ -14,16 +14,20 @@ BUILD_CARLAUE4=false LAUNCH_UE4_EDITOR=false USE_CARSIM=false USE_CHRONO=false +EDITOR_FLAGS="" GDB= RHI="-vulkan" -OPTS=`getopt -o h --long help,build,rebuild,launch,clean,hard-clean,gdb,opengl,carsim,chrono -n 'parse-options' -- "$@"` +OPTS=`getopt -o h --long help,build,rebuild,launch,clean,hard-clean,gdb,opengl,carsim,chrono,editor-flags: -n 'parse-options' -- "$@"` eval set -- "$OPTS" while [[ $# -gt 0 ]]; do case "$1" in + --editor-flags ) + EDITOR_FLAGS=$2 + shift ;; --gdb ) GDB="gdb --args"; shift ;; @@ -163,7 +167,7 @@ fi if ${LAUNCH_UE4_EDITOR} ; then log "Launching UE4Editor..." - ${GDB} ${UE4_ROOT}/Engine/Binaries/Linux/UE4Editor "${PWD}/CarlaUE4.uproject" ${RHI} + ${GDB} ${UE4_ROOT}/Engine/Binaries/Linux/UE4Editor "${PWD}/CarlaUE4.uproject" ${RHI} ${EDITOR_FLAGS} else diff --git a/Util/BuildTools/Package.bat b/Util/BuildTools/Package.bat index 9268f711e..6be833077 100644 --- a/Util/BuildTools/Package.bat +++ b/Util/BuildTools/Package.bat @@ -20,13 +20,14 @@ rem -- Parse arguments --------------------------------------------------------- rem ============================================================================== set DOC_STRING="Makes a packaged version of CARLA for distribution." -set USAGE_STRING="Usage: %FILE_N% [-h|--help] [--no-packaging] [--no-zip] [--clean] [--clean-intermediate] [--target-archive]" +set USAGE_STRING="Usage: %FILE_N% [-h|--help] [--config={Debug,Development,Shipping}] [--no-packaging] [--no-zip] [--clean] [--clean-intermediate] [--target-archive]" set DO_PACKAGE=true set DO_COPY_FILES=true set DO_TARBALL=true set DO_CLEAN=false set PACKAGES=Carla +set PACKAGE_CONFIG=Shipping set USE_CARSIM=false set SINGLE_PACKAGE=false @@ -39,6 +40,11 @@ if not "%1"=="" ( set DO_COPY_FILES=false ) + if "%1"=="--config" ( + set PACKAGE_CONFIG=%2 + shift + ) + if "%1"=="--clean-intermediate" ( set DO_CLEAN=true ) @@ -132,16 +138,39 @@ if %DO_PACKAGE%==true ( if errorlevel 1 goto error_build_editor + echo "%UE4_ROOT%\Engine\Build\BatchFiles\Build.bat"^ + CarlaUE4^ + Win64^ + %PACKAGE_CONFIG%^ + -WaitMutex^ + -FromMsBuild^ + "%ROOT_PATH%Unreal/CarlaUE4/CarlaUE4.uproject" call "%UE4_ROOT%\Engine\Build\BatchFiles\Build.bat"^ CarlaUE4^ Win64^ - Shipping^ + %PACKAGE_CONFIG%^ -WaitMutex^ -FromMsBuild^ "%ROOT_PATH%Unreal/CarlaUE4/CarlaUE4.uproject" if errorlevel 1 goto error_build + echo "%UE4_ROOT%\Engine\Build\BatchFiles\RunUAT.bat"^ + BuildCookRun^ + -nocompileeditor^ + -TargetPlatform=Win64^ + -Platform=Win64^ + -installed^ + -nop4^ + -project="%ROOT_PATH%Unreal/CarlaUE4/CarlaUE4.uproject"^ + -cook^ + -stage^ + -build^ + -archive^ + -archivedirectory="!BUILD_FOLDER!"^ + -package^ + -clientconfig=%PACKAGE_CONFIG% + call "%UE4_ROOT%\Engine\Build\BatchFiles\RunUAT.bat"^ BuildCookRun^ -nocompileeditor^ @@ -156,7 +185,7 @@ if %DO_PACKAGE%==true ( -archive^ -archivedirectory="!BUILD_FOLDER!"^ -package^ - -clientconfig=Shipping + -clientconfig=%PACKAGE_CONFIG% if errorlevel 1 goto error_runUAT ) diff --git a/Util/BuildTools/Windows.mk b/Util/BuildTools/Windows.mk index 31804d80f..6437f9aae 100644 --- a/Util/BuildTools/Windows.mk +++ b/Util/BuildTools/Windows.mk @@ -23,7 +23,7 @@ launch: CarlaUE4Editor @"${CARLA_BUILD_TOOLS_FOLDER}/BuildCarlaUE4.bat" --launch $(ARGS) launch-only: - @"${CARLA_BUILD_TOOLS_FOLDER}/BuildCarlaUE4.bat" --launch + @"${CARLA_BUILD_TOOLS_FOLDER}/BuildCarlaUE4.bat" --launch $(ARGS) package: PythonAPI @"${CARLA_BUILD_TOOLS_FOLDER}/Package.bat" --ue-version 4.26 $(ARGS)