Initial commit.

.vscode/settings.json

@@ -0,0 +1,57 @@
+{
+    "files.exclude":
+    {
+        "**/.DS_Store":true,
+        "**/.git":true,
+        "**/.gitignore":true,
+        "**/.gitmodules":true,
+        "**/*.booproj":true,
+        "**/*.pidb":true,
+        "**/*.suo":true,
+        "**/*.user":true,
+        "**/*.userprefs":true,
+        "**/*.unityproj":true,
+        "**/*.dll":true,
+        "**/*.exe":true,
+        "**/*.pdf":true,
+        "**/*.mid":true,
+        "**/*.midi":true,
+        "**/*.wav":true,
+        "**/*.gif":true,
+        "**/*.ico":true,
+        "**/*.jpg":true,
+        "**/*.jpeg":true,
+        "**/*.png":true,
+        "**/*.psd":true,
+        "**/*.tga":true,
+        "**/*.tif":true,
+        "**/*.tiff":true,
+        "**/*.3ds":true,
+        "**/*.3DS":true,
+        "**/*.fbx":true,
+        "**/*.FBX":true,
+        "**/*.lxo":true,
+        "**/*.LXO":true,
+        "**/*.ma":true,
+        "**/*.MA":true,
+        "**/*.obj":true,
+        "**/*.OBJ":true,
+        "**/*.asset":true,
+        "**/*.cubemap":true,
+        "**/*.flare":true,
+        "**/*.mat":true,
+        "**/*.meta":true,
+        "**/*.prefab":true,
+        "**/*.unity":true,
+        "build/":true,
+        "Build/":true,
+        "Library/":true,
+        "library/":true,
+        "obj/":true,
+        "Obj/":true,
+        "ProjectSettings/":true,
+        "temp/":true,
+        "Temp/":true
+    },
+    "git.ignoreLimitWarning": true
+}

App/LearnWithTouch_ios/Classes/CrashReporter.h

@@ -0,0 +1,32 @@
+#pragma once
+
+// Enabling this will force app to do a hard crash instead of a nice exit when UnhandledException
+// is thrown. This will force iOS to generate a standard crash report, that can be submitted to
+// iTunes by app users and inspected by developers.
+#define ENABLE_IOS_CRASH_REPORTING 1
+
+// Enabling this will add a custom Objective-C Uncaught Exception handler, which will print out
+// exception information to console.
+#define ENABLE_OBJC_UNCAUGHT_EXCEPTION_HANDLER 1
+
+// Enable custom crash reporter to capture crashes. Crash logs will be available to scripts via
+// CrashReport API.
+#define ENABLE_CUSTOM_CRASH_REPORTER 0
+
+// Enable submission of custom crash reports to Unity servers. This will enable custom crash
+// reporter.
+#define ENABLE_CRASH_REPORT_SUBMISSION 0
+
+
+#if ENABLE_CRASH_REPORT_SUBMISSION && !ENABLE_CUSTOM_CRASH_REPORTER
+    #undef ENABLE_CUSTOM_CRASH_REPORTER
+#define ENABLE_CUSTOM_CRASH_REPORTER 0
+#endif
+
+#if PLATFORM_TVOS
+    #undef ENABLE_CUSTOM_CRASH_REPORTER
+#define ENABLE_CUSTOM_CRASH_REPORTER 0
+#endif
+
+extern "C" void UnityInstallPostCrashCallback();
+void InitCrashHandling();

App/LearnWithTouch_ios/Classes/CrashReporter.mm

@@ -0,0 +1,126 @@
+#import "PLCrashReporter.h"
+#import "CrashReporter.h"
+#include <mach-o/ldsyms.h>
+
+extern "C" NSString* UnityGetCrashReportsPath();
+
+
+static NSUncaughtExceptionHandler* gsCrashReporterUEHandler = NULL;
+
+extern "C" uint8_t* UnityGetAppLoadAddress()
+{
+    // _mh_execute_header points to a mach header, and is located right at the address of where the
+    // app is loaded.
+    return (uint8_t*)&_mh_execute_header;
+}
+
+extern "C" const uint8_t * UnityGetAppLoadCommandAddress()
+{
+    return (const uint8_t*)(&_mh_execute_header + 1);
+}
+
+extern "C" int UnityGetAppLoadCommandCount()
+{
+    return _mh_execute_header.ncmds;
+}
+
+static void SavePendingCrashReport()
+{
+    if (![[UnityPLCrashReporter sharedReporter] hasPendingCrashReport])
+        return;
+
+    NSFileManager *fm = [NSFileManager defaultManager];
+    NSError *error;
+
+    if (![fm createDirectoryAtPath: UnityGetCrashReportsPath() withIntermediateDirectories: YES attributes: nil error: &error])
+    {
+        ::printf("CrashReporter: could not create crash report directory: %s\n", [[error localizedDescription] UTF8String]);
+        return;
+    }
+
+    NSData *data = [[UnityPLCrashReporter sharedReporter] loadPendingCrashReportDataAndReturnError: &error];
+    if (data == nil)
+    {
+        ::printf("CrashReporter: failed to load crash report data: %s\n", [[error localizedDescription] UTF8String]);
+        return;
+    }
+
+    NSString* file = [UnityGetCrashReportsPath() stringByAppendingPathComponent: @"crash-"];
+    unsigned long long seconds = (unsigned long long)[[NSDate date] timeIntervalSince1970];
+    file = [file stringByAppendingString: [NSString stringWithFormat: @"%llu", seconds]];
+    file = [file stringByAppendingString: @".plcrash"];
+    if ([data writeToFile: file atomically: YES])
+    {
+        ::printf("CrashReporter: saved pending crash report.\n");
+        if (![[UnityPLCrashReporter sharedReporter] purgePendingCrashReportAndReturnError: &error])
+        {
+            ::printf("CrashReporter: couldn't remove pending report: %s\n", [[error localizedDescription] UTF8String]);
+        }
+    }
+    else
+    {
+        ::printf("CrashReporter: couldn't save crash report.\n");
+    }
+
+    // Now copy out a pending version that we can delete if/when we send it
+    file = [UnityGetCrashReportsPath() stringByAppendingPathComponent: @"crash-pending.plcrash"];
+    if ([data writeToFile: file atomically: YES])
+    {
+        ::printf("CrashReporter: saved copy of pending crash report.\n");
+    }
+    else
+    {
+        ::printf("CrashReporter: couldn't save copy of pending crash report.\n");
+    }
+}
+
+static void InitCrashReporter()
+{
+    NSError *error;
+
+    UnityInstallPostCrashCallback();
+    if ([[UnityPLCrashReporter sharedReporter] enableCrashReporterAndReturnError: &error])
+        ::printf("CrashReporter: initialized\n");
+    else
+        NSLog(@"CrashReporter: could not enable crash reporter: %@", error);
+
+    SavePendingCrashReport();
+}
+
+static void UncaughtExceptionHandler(NSException *exception)
+{
+    NSLog(@"Uncaught exception: %@: %@\n%@", [exception name], [exception reason], [exception callStackSymbols]);
+    if (gsCrashReporterUEHandler)
+        gsCrashReporterUEHandler(exception);
+}
+
+static void InitObjCUEHandler()
+{
+    // Crash reporter sets its own handler, so we have to save it and call it manually
+    gsCrashReporterUEHandler = NSGetUncaughtExceptionHandler();
+    NSSetUncaughtExceptionHandler(&UncaughtExceptionHandler);
+}
+
+void InitCrashHandling()
+{
+#if ENABLE_CUSTOM_CRASH_REPORTER
+    InitCrashReporter();
+#endif
+
+#if ENABLE_OBJC_UNCAUGHT_EXCEPTION_HANDLER
+    InitObjCUEHandler();
+#endif
+}
+
+// This function will be called when AppDomain.CurrentDomain.UnhandledException event is triggered.
+// When running on device the app will do a hard crash and it will generate a crash log.
+extern "C" void CrashedCheckBelowForHintsWhy()
+{
+#if ENABLE_IOS_CRASH_REPORTING || ENABLE_CUSTOM_CRASH_REPORTER
+    // Make app crash hard here
+    __builtin_trap();
+
+    // Just in case above doesn't work
+    abort();
+#endif
+}

App/LearnWithTouch_ios/Classes/DynamicLibEngineAPI-functions.h

@@ -0,0 +1,245 @@
+// ? TODO: Pavell merge with TrampolineInterface.h to have singe source of truth for a function definitions
+
+UnityExternCall(bool, UnityiOS81orNewer);
+UnityExternCall(bool, UnityiOS82orNewer);
+UnityExternCall(bool, UnityiOS90orNewer);
+UnityExternCall(bool, UnityiOS91orNewer);
+UnityExternCall(bool, UnityiOS100orNewer);
+UnityExternCall(bool, UnityiOS101orNewer);
+UnityExternCall(bool, UnityiOS102orNewer);
+UnityExternCall(bool, UnityiOS103orNewer);
+UnityExternCall(bool, UnityiOS110orNewer);
+UnityExternCall(bool, UnityiOS111orNewer);
+UnityExternCall(bool, UnityiOS112orNewer);
+
+// CrashReporter.mm
+UnityExternCall(void,     CrashedCheckBelowForHintsWhy);
+UnityExternCall(uint8_t*, UnityGetAppLoadAddress);
+UnityExternCall(const uint8_t*, UnityGetAppLoadCommandAddress);
+UnityExternCall(int,      UnityGetAppLoadCommandCount);
+
+// iPhone_Sensors.mm
+UnityExternCall(void,  UnityInitJoysticks);
+UnityExternCall(void,  UnityCoreMotionStart);
+UnityExternCall(void,  UnityCoreMotionStop);
+UnityExternCall(void,  UnityUpdateAccelerometerData);
+UnityExternCall(int,   UnityIsGyroEnabled, int);
+UnityExternCall(int,   UnityIsGyroAvailable);
+UnityExternCall(void,  UnityUpdateGyroData);
+UnityExternCall(void,  UnitySetGyroUpdateInterval, int, float);
+UnityExternCall(float, UnityGetGyroUpdateInterval, int);
+UnityExternCall(void,  UnityUpdateJoystickData);
+UnityExternCall(int,   UnityGetJoystickCount);
+UnityExternCall(void,  UnityGetJoystickName, int, char*, int);
+UnityExternCall(void,  UnityGetJoystickAxisName, int, int, char*, int);
+UnityExternCall(void,  UnityGetNiceKeyname, int, char*, int);
+UnityExternCall(bool,  IsCompensatingSensors);
+UnityExternCall(void,  SetCompensatingSensors, bool);
+UnityExternCall(int,   UnityMaxQueuedAccelerationEvents);
+
+// UnityAppController.mm
+UnityExternCall(UIViewController*,  UnityGetGLViewController);
+UnityExternCall(UIView*,            UnityGetGLView);
+UnityExternCall(UIWindow*,          UnityGetMainWindow);
+UnityExternCall(void,               UnityRequestQuit);
+UnityExternCall(void,               UnityDestroyDisplayLink);
+
+// UnityAppController+Rendering.mm
+UnityExternCall(void,             UnityInitMainScreenRenderingCallback);
+UnityExternCall(void,             UnityGfxInitedCallback);
+UnityExternCall(void,             UnityPresentContextCallback, UnityFrameStats const*);
+UnityExternCall(void,             UnityFramerateChangeCallback, int);
+UnityExternCall(int,              UnitySelectedRenderingAPI);
+
+UnityExternCall(NSBundle*,            UnityGetMetalBundle);
+UnityExternCall(MTLDeviceRef,         UnityGetMetalDevice);
+UnityExternCall(MTLCommandQueueRef,   UnityGetMetalCommandQueue);
+UnityExternCall(MTLCommandQueueRef,   UnityGetMetalDrawableCommandQueue);
+UnityExternCall(EAGLContext*,         UnityGetDataContextEAGL);
+
+UnityExternCall(RenderSurfaceBase*,         UnityBackbufferColor);
+UnityExternCall(RenderSurfaceBase*,         UnityBackbufferDepth);
+UnityExternCall(void,                       DisplayManagerEndFrameRendering);
+UnityExternCall(void,                       UnityPrepareScreenshot);
+
+// Unity/MetalHelper.mm
+#if (GFX_SUPPORTS_METAL + 0) || (UNITY_CAN_USE_METAL + 0)
+UnityExternCall(void,             UnityAddNewMetalAPIImplIfNeeded, MTLDeviceRef);
+UnityExternCall(MTLTextureRef,    AcquireDrawableMTL, UnityDisplaySurfaceMTL*);
+#endif
+
+// EAGLContextHelper.mm
+UnityExternCall(void,             UnityMakeCurrentContextEAGL, EAGLContext*);
+UnityExternCall(EAGLContext*,     UnityGetCurrentContextEAGL);
+
+// UI/ActivityIndicator.mm
+UnityExternCall(void,             UnityStartActivityIndicator);
+UnityExternCall(void,             UnityStopActivityIndicator);
+
+// UI/Keyboard.mm
+UnityExternCall(void,             UnityKeyboard_Create, unsigned, int, int , int , int , const char*, const char*, int);
+UnityExternCall(void,             UnityKeyboard_Show);
+UnityExternCall(void,             UnityKeyboard_Hide);
+UnityExternCall(void,             UnityKeyboard_GetRect, float*, float*, float*, float*);
+UnityExternCall(void,             UnityKeyboard_SetText, const char*);
+UnityExternCall(NSString*,        UnityKeyboard_GetText);
+UnityExternCall(int,              UnityKeyboard_IsActive);
+UnityExternCall(int,              UnityKeyboard_Status);
+UnityExternCall(void,             UnityKeyboard_SetInputHidden, int);
+UnityExternCall(int,              UnityKeyboard_IsInputHidden);
+UnityExternCall(void,             UnityKeyboard_SetCharacterLimit, unsigned);
+
+UnityExternCall(int,              UnityKeyboard_CanGetSelection);
+UnityExternCall(void,             UnityKeyboard_GetSelection, int*, int*);
+UnityExternCall(int,              UnityKeyboard_CanSetSelection);
+UnityExternCall(void,             UnityKeyboard_SetSelection, int, int);
+
+
+// UI/UnityViewControllerBase.mm
+UnityExternCall(void,             UnityNotifyHideHomeButtonChange);
+UnityExternCall(void,             UnityNotifyDeferSystemGesturesChange);
+
+// UI/StoreReview.m
+#if PLATFORM_IOS
+UnityExternCall(bool,             UnityRequestStoreReview);
+#endif
+
+// Unity/AVCapture.mm
+UnityExternCall(int,              UnityGetAVCapturePermission, int);
+UnityExternCall(void,             UnityRequestAVCapturePermission, int);
+
+// Unity/CameraCapture.mm
+typedef void(*UnityEnumVideoCaptureDevicesCallback)(void* udata, const char* name, int frontFacing, int autoFocusPointSupported, int kind, const int* resolutions, int resCount);
+UnityExternCall(void,             UnityEnumVideoCaptureDevices, void*, UnityEnumVideoCaptureDevicesCallback);
+UnityExternCall(void*,            UnityInitCameraCapture, int, int, int, int, int, void*);
+UnityExternCall(void,             UnityStartCameraCapture, void*);
+UnityExternCall(void,             UnityPauseCameraCapture, void*);
+UnityExternCall(void,             UnityStopCameraCapture, void*);
+UnityExternCall(void,             UnityCameraCaptureExtents, void*, int*, int*);
+UnityExternCall(void,             UnityCameraCaptureReadToMemory, void*, void*, int, int);
+UnityExternCall(int,              UnityCameraCaptureVideoRotationDeg, void*);
+UnityExternCall(int,              UnityCameraCaptureVerticallyMirrored, void*);
+UnityExternCall(int,              UnityCameraCaptureSetAutoFocusPoint, void*, float, float);
+
+
+// Unity/DeviceSettings.mm
+UnityExternCall(const char*,      UnityDeviceUniqueIdentifier);
+UnityExternCall(const char*,      UnityVendorIdentifier);
+UnityExternCall(const char*,      UnityAdvertisingIdentifier);
+UnityExternCall(int,              UnityAdvertisingTrackingEnabled);
+UnityExternCall(const char*,      UnityDeviceName);
+UnityExternCall(const char*,      UnitySystemName);
+UnityExternCall(const char*,      UnitySystemVersion);
+UnityExternCall(const char*,      UnityDeviceModel);
+UnityExternCall(int,              UnityDeviceCPUCount);
+UnityExternCall(int,              UnityDeviceGeneration);
+UnityExternCall(int,              UnityDeviceSupportedOrientations);
+UnityExternCall(int,              UnityDeviceIsStylusTouchSupported);
+UnityExternCall(int,              UnityDeviceCanShowWideColor);
+UnityExternCall(float,            UnityDeviceDPI);
+UnityExternCall(const char*,      UnitySystemLanguage);
+
+// Unity/DisplayManager.mm
+UnityExternCall(EAGLContext*,     UnityGetMainScreenContextGLES);
+UnityExternCall(EAGLContext*,     UnityGetContextEAGL);
+UnityExternCall(void,             UnityStartFrameRendering);
+UnityExternCall(void,             UnityDestroyUnityRenderSurfaces);
+
+#if SUPPORT_MULTIPLE_DISPLAYS || PLATFORM_IOS
+UnityExternCall(int,              UnityDisplayManager_DisplayCount);
+UnityExternCall(void,             UnityDisplayManager_DisplayRenderingResolution, void*, int*, int*);
+UnityExternCall(int,              UnityDisplayManager_PrimaryDisplayIndex);
+UnityExternCall(bool,             UnityDisplayManager_DisplayActive, void*);
+UnityExternCall(void,             UnityDisplayManager_DisplayRenderingBuffers, void*, RenderSurfaceBase**, RenderSurfaceBase**);
+UnityExternCall(void,             UnityDisplayManager_SetRenderingResolution, void*, int, int);
+UnityExternCall(void,             UnityDisplayManager_DisplaySystemResolution, void*, int*, int*);
+#endif
+
+// Unity/Filesystem.mm
+UnityExternCall(const char*,      UnityApplicationDir);
+UnityExternCall(const char*,      UnityDocumentsDir);
+UnityExternCall(const char*,      UnityLibraryDir);
+UnityExternCall(const char*,      UnityCachesDir);
+UnityExternCall(int,              UnityUpdateNoBackupFlag, const char*, int);
+
+// iPhoneMisc.mm
+UnityExternCall(const char* const*, UnityFontFallbacks);
+
+// Unity/WWWConnection.mm
+UnityExternCall(void*,            UnityStartWWWConnectionCustom, void*, const char*, const void*, const char*);
+UnityExternCall(void,             UnitySendWWWConnection, void*, const void*, unsigned, bool, unsigned long, bool);
+UnityExternCall(void,             UnityDestroyWWWConnection, void*);
+UnityExternCall(void,             UnityShouldCancelWWW, const void*);
+UnityExternCall(bool,             UnityBlockWWWConnectionIsDone, void*);
+UnityExternCall(void,             UnityWWWClearCookieCache, const char*);
+
+// Unity/FullScreenVideoPlayer.mm
+UnityExternCall(void,             UnityPlayFullScreenVideo, const char*, const float*, unsigned, unsigned);
+UnityExternCall(int,              UnityIsFullScreenPlaying);
+
+// Unity/OnDemandResources.mm
+struct OnDemandResourcesRequestData;
+typedef void (*OnDemandResourcesRequestCompleteHandler)(void* handlerData, const char* error);
+UnityExternCall(OnDemandResourcesRequestData*, UnityOnDemandResourcesCreateRequest, NSSet*, OnDemandResourcesRequestCompleteHandler, void*);
+UnityExternCall(void,                          UnityOnDemandResourcesRelease, OnDemandResourcesRequestData*);
+UnityExternCall(float,                         UnityOnDemandResourcesGetProgress, OnDemandResourcesRequestData*);
+UnityExternCall(float,                         UnityOnDemandResourcesGetLoadingPriority, OnDemandResourcesRequestData*);
+UnityExternCall(void,                          UnityOnDemandResourcesSetLoadingPriority, OnDemandResourcesRequestData*, float);
+UnityExternCall(NSString*,                     UnityOnDemandResourcesGetResourcePath, OnDemandResourcesRequestData*, const char*);
+
+// Unity/UnityReplayKit.mm
+UnityExternCall(int,          UnityReplayKitAPIAvailable);
+UnityExternCall(int,          UnityReplayKitRecordingAvailable);
+UnityExternCall(const char*,  UnityReplayKitLastError);
+UnityExternCall(int,          UnityReplayKitStartRecording, int);
+UnityExternCall(int,          UnityReplayKitIsRecording);
+UnityExternCall(int,          UnityReplayKitStopRecording);
+UnityExternCall(int,          UnityReplayKitDiscard);
+UnityExternCall(int,          UnityReplayKitPreview);
+
+UnityExternCall(int,          UnityReplayKitBroadcastingAPIAvailable);
+UnityExternCall(void,         UnityReplayKitStartBroadcasting, void*);
+UnityExternCall(void,         UnityReplayKitStopBroadcasting);
+UnityExternCall(int,          UnityReplayKitIsBroadcasting);
+UnityExternCall(const char*,  UnityReplayKitGetBroadcastURL);
+
+UnityExternCall(int,          UnityReplayKitIsCameraEnabled);
+UnityExternCall(int,          UnityReplayKitSetCameraEnabled, bool);
+UnityExternCall(int,          UnityReplayKitIsMicrophoneEnabled);
+UnityExternCall(int,          UnityReplayKitSetMicrophoneEnabled, bool);
+UnityExternCall(int,          UnityReplayKitShowCameraPreviewAt, float, float);
+UnityExternCall(void,         UnityReplayKitHideCameraPreview);
+UnityExternCall(void,         UnityReplayKitCreateOverlayWindow);
+
+// LocationService static members to extern c
+//UnityExternCall4StaticMember(void,  LocationService, SetDistanceFilter,float);
+UnityExternCall4StaticMember(void,  LocationService, SetDesiredAccuracy, float);
+UnityExternCall4StaticMember(float, LocationService, GetDesiredAccuracy);
+UnityExternCall4StaticMember(void,  LocationService, SetDistanceFilter, float);
+UnityExternCall4StaticMember(float, LocationService, GetDistanceFilter);
+UnityExternCall4StaticMember(bool,  LocationService, IsServiceEnabledByUser);
+UnityExternCall4StaticMember(void,  LocationService, StartUpdatingLocation);
+UnityExternCall4StaticMember(void,  LocationService, StopUpdatingLocation);
+UnityExternCall4StaticMember(void,  LocationService, SetHeadingUpdatesEnabled, bool);
+UnityExternCall4StaticMember(bool,  LocationService, IsHeadingUpdatesEnabled);
+UnityExternCall4StaticMember(LocationServiceStatus, LocationService, GetLocationStatus);
+UnityExternCall4StaticMember(LocationServiceStatus, LocationService, GetHeadingStatus);
+UnityExternCall4StaticMember(bool,  LocationService, IsHeadingAvailable);
+
+//Apple TV Remote
+#if PLATFORM_TVOS
+UnityExternCall(int,      UnityGetAppleTVRemoteAllowExitToMenu);
+UnityExternCall(void,     UnitySetAppleTVRemoteAllowExitToMenu, int);
+UnityExternCall(int,      UnityGetAppleTVRemoteAllowRotation);
+UnityExternCall(void,     UnitySetAppleTVRemoteAllowRotation, int);
+UnityExternCall(int,      UnityGetAppleTVRemoteReportAbsoluteDpadValues);
+UnityExternCall(void,     UnitySetAppleTVRemoteReportAbsoluteDpadValues, int);
+UnityExternCall(int,      UnityGetAppleTVRemoteTouchesEnabled);
+UnityExternCall(void,     UnitySetAppleTVRemoteTouchesEnabled, int);
+#endif
+
+// misc not in trampoline
+UnityExternCall(bool,     Unity_il2cppNoExceptions);
+UnityExternCall(void,     RegisterStaticallyLinkedModulesGranular);
+
+UnityExternCall(NSArray<NSString*>*, GetLaunchImageNames, UIUserInterfaceIdiom, const OrientationMask&, const CGSize&, ScreenOrientation, float);

App/LearnWithTouch_ios/Classes/DynamicLibEngineAPI.mm

@@ -0,0 +1,156 @@
+/* SINGLE CPP FILE TO GENERATE SEAMLESS BRIDGE BETWEEN BINARIES < SHARED ENGINE LIBRARY WITH ABSTRACT EXTERN FUNCTIONS> | < PLAYER EXECUTABLE WITH ABSTRACT FUNCTION IMPLEMENTATION >
+1. if building shared engine library this file will:
+    define body for Unity* methods that proxy call to actual method
+    actual method will be set later from outside with respective call to SetUnity*Body
+    defines SetUnity*Body method to set actual method for call, theese functions are exported from library
+
+2. if building player against shared engine library this file will:
+    calls SetUnity*Body providing actual method to be called by shared engine library later
+    wraps all SetUnity*Body calls in one single method SetAllUnityFunctionsForDynamicPlayerLib
+
+- notes:
+  file will be included only if development / il2ccp and:
+   - for xcode project if BuildSettings.UseDynamicPlayerLib is true
+   - for player if (build.pl staticLib=1, jam BUILD_IOS_DYNAMIC_PLAYER=1)
+
+  DynamicLibEngineAPI-functions.h include list of functions to proxy calls from player to trampoline
+   - each function inlist is defined with UnityExternCall or UnityExternCall4StaticMember
+*/
+
+// deal with __VA_ARGS__ to convert them to formated lists with provided M macro
+#define VA_ARGS_COUNT(...) INTERNAL_GET_ARG_COUNT_PRIVATE(0, ## __VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0)
+#define INTERNAL_GET_ARG_COUNT_PRIVATE(_0, _1_, _2_, _3_, _4_, _5_, _6_, _7_, _8_, _9_, _10_, _11_, _12_, _13_, _14_, _15_, _16_, _17_, _18_, _19_, _20_, count, ...) count
+
+#define JOIN_VA_ARGS_0(M, ...)
+#define JOIN_VA_ARGS_1(M, T1) M(T1,1)
+#define JOIN_VA_ARGS_2(M, T1, T2) M(T1,1), M(T2,2)
+#define JOIN_VA_ARGS_3(M, T1, T2, T3) M(T1,1), M(T2,2), M(T3,3)
+#define JOIN_VA_ARGS_4(M, T1, T2, T3, T4) M(T1,1), M(T2,2), M(T3,3), M(T4,4)
+#define JOIN_VA_ARGS_5(M, T1, T2, T3, T4, T5) M(T1,1), M(T2,2), M(T3,3), M(T4,4), M(T5,5)
+#define JOIN_VA_ARGS_6(M, T1, T2, T3, T4, T5, T6) M(T1,1), M(T2,2), M(T3,3), M(T4,4), M(T5,5), M(T6,6)
+#define JOIN_VA_ARGS_7(M, T1, T2, T3, T4, T5, T6, T7) M(T1,1), M(T2,2), M(T3,3), M(T4,4), M(T5,5), M(T6,6), M(T7,7)
+#define JOIN_VA_ARGS_8(M, T1, T2, T3, T4, T5, T6, T7, T8) M(T1,1), M(T2,2), M(T3,3), M(T4,4), M(T5,5), M(T6,6), M(T7,7), M(T8,8)
+#define JOIN_VA_ARGS_9(M, T1, T2, T3, T4, T5, T6, T7, T8, T9) M(T1,1), M(T2,2), M(T3,3), M(T4,4), M(T5,5), M(T6,6), M(T7,7), M(T8,8), M(T9,9)
+
+#define JOIN_VA_ARGS___(M, N, ...) JOIN_VA_ARGS_##N(M, __VA_ARGS__ )
+#define JOIN_VA_ARGS__(M, N, ...) JOIN_VA_ARGS___(M,N,__VA_ARGS__)
+#define JOIN_VA_ARGS_(M, ...) JOIN_VA_ARGS__(M,VA_ARGS_COUNT(__VA_ARGS__), __VA_ARGS__)
+#define JOIN_VA_ARGS(M, ...) JOIN_VA_ARGS_(M,__VA_ARGS__)
+
+// convert to function definition params:
+// egz: VA_ARGS_TO_PARAMS(int, char, bool) expands to: int p3, char p2, bool p1
+#define VA_JOIN_AS_PARAMS(type, index) type p##index
+#define VA_ARGS_TO_PARAMS(...) JOIN_VA_ARGS(VA_JOIN_AS_PARAMS,__VA_ARGS__)
+
+// convert to function call params
+// egz: VA_ARGS_TO_CALL(int,char,bool) exapnds to: p3, p2, p1
+#define VA_JOIN_AS_CALL(type, index) p##index
+#define VA_ARGS_TO_CALL(...) JOIN_VA_ARGS(VA_JOIN_AS_CALL,__VA_ARGS__)
+
+#ifndef UNITY_ENGINE_DYNAMICLIB_MODE
+#define UNITY_ENGINE_DYNAMICLIB_MODE 0
+#endif
+
+#if UNITY_ENGINE_DYNAMICLIB_MODE
+// [ part of Unity Player ]
+// this part generates Unity* functions that act as proxy to call actual function from trampoline
+// for each function in DynamicLibEngineAPI-functions.h will be generated proxy function
+
+// proxy for extern "C" function
+// egz: UnityExternCall(int,   UnityTestFunctionName, int);
+// will expand to:
+//  static int(*gPtrUnityTestFunctionName)(int) = nullptr;
+//  extern "C" int UnityTestFunctionName(int p1) {
+//      assert(gPtrUnityTestFunctionName) != nullptr);
+//      return gPtrUnityTestFunctionName(p1);
+//  }
+//  __attribute__((visibility("default")))
+//  extern "C" void SetUnityTestFunctionNameBody(decltype(&UnityTestFunctionName) fPtr) {
+//      gPtrUnityTestFunctionName = fPtr;
+//  }
+    #define UnityExternCall(returnType, funcName, ...)              \
+    static returnType(*gPtr##funcName)(__VA_ARGS__) = nullptr;      \
+    extern "C" returnType funcName(VA_ARGS_TO_PARAMS(__VA_ARGS__)) {\
+        assert(gPtr##funcName != nullptr);                          \
+        return gPtr##funcName(VA_ARGS_TO_CALL(__VA_ARGS__));        \
+    }                                                               \
+    __attribute__((visibility("default")))                          \
+    extern "C" void Set##funcName##Body(decltype(&funcName) fPtr) { \
+        gPtr##funcName = fPtr;                                      \
+    }
+
+// proxy for class static methods
+// egz: UnityExternCall4StaticMember(int,  MyClass MyMethod, int);
+// will expand to:
+//  static int(*gPtrMyClassMyMethod)(int) = nullptr;
+//  int MyClass::MyMethod(int p1) {
+//      assert(gPtrMyClassMyMethod) != nullptr);
+//      return gPtrMyClassMyMethod(p1);
+//  }
+//  __attribute__((visibility("default")))
+//  extern "C" void SetMyClassMyMethodBody(decltype(gPtrMyClassMyMethod) fPtr) {
+//      gPtrMyClassMyMethod = fPtr;
+//  }
+    #define UnityExternCall4StaticMember(returnType, className, funcName, ...)                    \
+    static returnType(*gPtr##className##funcName)(__VA_ARGS__) = nullptr;                         \
+    returnType className::funcName(VA_ARGS_TO_PARAMS(__VA_ARGS__)) {                              \
+        assert(gPtr##className##funcName != nullptr);                                             \
+        return gPtr##className##funcName(VA_ARGS_TO_CALL(__VA_ARGS__));                           \
+    }                                                                                             \
+    __attribute__((visibility("default")))                                                        \
+    extern "C" void Set##className##funcName##Body(decltype(gPtr##className##funcName) fPtr) {    \
+        gPtr##className##funcName = fPtr;                                                         \
+    }
+
+    #include "PlatformDependent/iPhonePlayer/Trampoline/Classes/Unity/UnitySharedDecls.h"
+    #include "PlatformDependent/iPhonePlayer/Trampoline/Classes/Unity/UnityRendering.h"
+    #include "PlatformDependent/iPhonePlayer/TrampolineInterface.h"
+    #include "Runtime/Graphics/DisplayManager.h"
+    #include "Runtime/Input/LocationService.h"
+
+    #import <UIKit/UIKit.h>
+
+    #include "DynamicLibEngineAPI-functions.h"
+
+    #undef UnityExternCall
+    #undef UnityExternCall4StaticMember
+#else
+// [ part of Xcode project ]
+//  for each function defined in DynamicLibEngineAPI-functions.h will be generated SetUnity*Body function
+
+// for extern "C" functions
+// egz: UnityExternCall(int,   UnityTestFunctionName, int);
+// will expand to:
+//  extern "C" UnityTestFunctionName(int);
+//  extern "C" SetUnityTestFunctionName(decltype(&UnityTestFunctionName));
+    #define UnityExternCall(returnType, funcName, ...)        \
+    extern "C" returnType funcName(__VA_ARGS__);              \
+    extern "C" void Set##funcName##Body(decltype(&funcName));
+
+// for class static method
+// egz: UnityExternCall4StaticMember(int,  MyClass MyMethod, int);
+// will expand to:
+//  extern "C" void SetMyClassMyMethodBody(decltype(&MyClass::MyMethod));
+    #define UnityExternCall4StaticMember(returnType, className, funcName, ...)     \
+    extern "C" void Set##className##funcName##Body(decltype(&className::funcName));
+
+    #include "UnityRendering.h"
+    #include "Classes/iPhone_Sensors.h"
+
+    #include "DynamicLibEngineAPI-functions.h"
+
+    #undef UnityExternCall
+    #undef UnityExternCall4StaticMember
+
+// single function to call every Set*Body function from DynamicLibEngineAPI-functions.h
+    #define UnityExternCall(returnType, funcName, ...)   Set##funcName##Body(funcName);
+    #define UnityExternCall4StaticMember(returnType, className, funcName, ...) Set##className##funcName##Body(className::funcName)
+
+extern "C" void SetAllUnityFunctionsForDynamicPlayerLib()
+{
+        #include "DynamicLibEngineAPI-functions.h"
+}
+
+    #undef UnityExternCall
+    #undef UnityExternCall4StaticMember
+#endif

App/LearnWithTouch_ios/Classes/Native/Bulk_System.Diagnostics.StackTrace_0.cpp

@@ -0,0 +1,86 @@
+#include "il2cpp-config.h"
+
+#ifndef _MSC_VER
+# include <alloca.h>
+#else
+# include <malloc.h>
+#endif
+
+
+#include <cstring>
+#include <string.h>
+#include <stdio.h>
+#include <cmath>
+#include <limits>
+#include <assert.h>
+#include <stdint.h>
+
+#include "il2cpp-class-internals.h"
+#include "codegen/il2cpp-codegen.h"
+#include "il2cpp-object-internals.h"
+
+
+
+
+
+
+#ifndef U3CMODULEU3E_TDE5A299227351E064CF5069210AC8ED1294BD51A_H
+#define U3CMODULEU3E_TDE5A299227351E064CF5069210AC8ED1294BD51A_H
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Winvalid-offsetof"
+#pragma clang diagnostic ignored "-Wunused-variable"
+#endif
+
+// <Module>
+struct  U3CModuleU3E_tDE5A299227351E064CF5069210AC8ED1294BD51A 
+{
+public:
+
+public:
+};
+
+#ifdef __clang__
+#pragma clang diagnostic pop
+#endif
+#endif // U3CMODULEU3E_TDE5A299227351E064CF5069210AC8ED1294BD51A_H
+#ifndef RUNTIMEOBJECT_H
+#define RUNTIMEOBJECT_H
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Winvalid-offsetof"
+#pragma clang diagnostic ignored "-Wunused-variable"
+#endif
+
+// System.Object
+
+#ifdef __clang__
+#pragma clang diagnostic pop
+#endif
+#endif // RUNTIMEOBJECT_H
+struct Il2CppArrayBounds;
+#ifndef RUNTIMEARRAY_H
+#define RUNTIMEARRAY_H
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Winvalid-offsetof"
+#pragma clang diagnostic ignored "-Wunused-variable"
+#endif
+
+// System.Array
+
+#ifdef __clang__
+#pragma clang diagnostic pop
+#endif
+#endif // RUNTIMEARRAY_H
+
+
+
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Winvalid-offsetof"
+#pragma clang diagnostic ignored "-Wunused-variable"
+#endif
+#ifdef __clang__
+#pragma clang diagnostic pop
+#endif

App/LearnWithTouch_ios/Classes/Native/Bulk_System.Globalization.Extensions_0.cpp

@@ -0,0 +1,86 @@
+#include "il2cpp-config.h"
+
+#ifndef _MSC_VER
+# include <alloca.h>
+#else
+# include <malloc.h>
+#endif
+
+
+#include <cstring>
+#include <string.h>
+#include <stdio.h>
+#include <cmath>
+#include <limits>
+#include <assert.h>
+#include <stdint.h>
+
+#include "il2cpp-class-internals.h"
+#include "codegen/il2cpp-codegen.h"
+#include "il2cpp-object-internals.h"
+
+
+
+
+
+
+#ifndef U3CMODULEU3E_T410187D184BFEA098C57AA90C1EEBB14DCD72176_H
+#define U3CMODULEU3E_T410187D184BFEA098C57AA90C1EEBB14DCD72176_H
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Winvalid-offsetof"
+#pragma clang diagnostic ignored "-Wunused-variable"
+#endif
+
+// <Module>
+struct  U3CModuleU3E_t410187D184BFEA098C57AA90C1EEBB14DCD72176 
+{
+public:
+
+public:
+};
+
+#ifdef __clang__
+#pragma clang diagnostic pop
+#endif
+#endif // U3CMODULEU3E_T410187D184BFEA098C57AA90C1EEBB14DCD72176_H
+#ifndef RUNTIMEOBJECT_H
+#define RUNTIMEOBJECT_H
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Winvalid-offsetof"
+#pragma clang diagnostic ignored "-Wunused-variable"
+#endif
+
+// System.Object
+
+#ifdef __clang__
+#pragma clang diagnostic pop
+#endif
+#endif // RUNTIMEOBJECT_H
+struct Il2CppArrayBounds;
+#ifndef RUNTIMEARRAY_H
+#define RUNTIMEARRAY_H
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Winvalid-offsetof"
+#pragma clang diagnostic ignored "-Wunused-variable"
+#endif
+
+// System.Array
+
+#ifdef __clang__
+#pragma clang diagnostic pop
+#endif
+#endif // RUNTIMEARRAY_H
+
+
+
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Winvalid-offsetof"
+#pragma clang diagnostic ignored "-Wunused-variable"
+#endif
+#ifdef __clang__
+#pragma clang diagnostic pop
+#endif

App/LearnWithTouch_ios/Classes/Native/Bulk_System.IO.Compression_0.cpp

@@ -0,0 +1,86 @@
+#include "il2cpp-config.h"
+
+#ifndef _MSC_VER
+# include <alloca.h>
+#else
+# include <malloc.h>
+#endif
+
+
+#include <cstring>
+#include <string.h>
+#include <stdio.h>
+#include <cmath>
+#include <limits>
+#include <assert.h>
+#include <stdint.h>
+
+#include "il2cpp-class-internals.h"
+#include "codegen/il2cpp-codegen.h"
+#include "il2cpp-object-internals.h"
+
+
+
+
+
+
+#ifndef U3CMODULEU3E_T56CA3936A9EFABF2ED20401359C40BFE63F85A11_H
+#define U3CMODULEU3E_T56CA3936A9EFABF2ED20401359C40BFE63F85A11_H
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Winvalid-offsetof"
+#pragma clang diagnostic ignored "-Wunused-variable"
+#endif
+
+// <Module>
+struct  U3CModuleU3E_t56CA3936A9EFABF2ED20401359C40BFE63F85A11 
+{
+public:
+
+public:
+};
+
+#ifdef __clang__
+#pragma clang diagnostic pop
+#endif
+#endif // U3CMODULEU3E_T56CA3936A9EFABF2ED20401359C40BFE63F85A11_H
+#ifndef RUNTIMEOBJECT_H
+#define RUNTIMEOBJECT_H
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Winvalid-offsetof"
+#pragma clang diagnostic ignored "-Wunused-variable"
+#endif
+
+// System.Object
+
+#ifdef __clang__
+#pragma clang diagnostic pop
+#endif
+#endif // RUNTIMEOBJECT_H
+struct Il2CppArrayBounds;
+#ifndef RUNTIMEARRAY_H
+#define RUNTIMEARRAY_H
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Winvalid-offsetof"
+#pragma clang diagnostic ignored "-Wunused-variable"
+#endif
+
+// System.Array
+
+#ifdef __clang__
+#pragma clang diagnostic pop
+#endif
+#endif // RUNTIMEARRAY_H
+
+
+
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Winvalid-offsetof"
+#pragma clang diagnostic ignored "-Wunused-variable"
+#endif
+#ifdef __clang__
+#pragma clang diagnostic pop
+#endif

App/LearnWithTouch_ios/Classes/Native/Bulk_UnityEngine.Physics2DModule_0.cpp

@@ -0,0 +1,878 @@
+#include "il2cpp-config.h"
+
+#ifndef _MSC_VER
+# include <alloca.h>
+#else
+# include <malloc.h>
+#endif
+
+
+#include <cstring>
+#include <string.h>
+#include <stdio.h>
+#include <cmath>
+#include <limits>
+#include <assert.h>
+#include <stdint.h>
+
+#include "il2cpp-class-internals.h"
+#include "codegen/il2cpp-codegen.h"
+#include "il2cpp-object-internals.h"
+
+
+// System.Collections.Generic.List`1<System.Object>
+struct List_1_t05CC3C859AB5E6024394EF9A42E3E696628CA02D;
+// System.Collections.Generic.List`1<UnityEngine.Rigidbody2D>
+struct List_1_tB50CA57CD5918BF3026A6E1A2873B6699FDC3A8D;
+// System.String
+struct String_t;
+// System.Void
+struct Void_t22962CB4C05B1D89B55A6E1139F0E87A90987017;
+// UnityEngine.Collider2D
+struct Collider2D_tD64BE58E48B95D89D349FEAB54D0FE2EEBF83379;
+// UnityEngine.Object
+struct Object_tAE11E5E46CD5C37C9F3E8950C00CD8B45666A2D0;
+// UnityEngine.Rigidbody2D[]
+struct Rigidbody2DU5BU5D_t6283E1D3B1656D573E695711466E6E426ACA3206;
+
+extern RuntimeClass* Collider2D_tD64BE58E48B95D89D349FEAB54D0FE2EEBF83379_il2cpp_TypeInfo_var;
+extern RuntimeClass* List_1_tB50CA57CD5918BF3026A6E1A2873B6699FDC3A8D_il2cpp_TypeInfo_var;
+extern RuntimeClass* Object_tAE11E5E46CD5C37C9F3E8950C00CD8B45666A2D0_il2cpp_TypeInfo_var;
+extern RuntimeClass* Physics2D_tB21970F986016656D66D2922594F336E1EE7D5C7_il2cpp_TypeInfo_var;
+extern const RuntimeMethod* List_1__ctor_m215607BDEE600B30300565B4E05FFAA8EDF9A94D_RuntimeMethod_var;
+extern const uint32_t Physics2D__cctor_mC0D622F2EAF13BF0513DB2969E50EEC5631CDBFC_MetadataUsageId;
+extern const uint32_t RaycastHit2D_get_collider_m6A7EC53B2E179C2EFF4F29018A132B2979CBE976_MetadataUsageId;
+
+
+
+#ifndef U3CMODULEU3E_T11B36CEBA37CA1FF7C21746E808B860B676A8ECD_H
+#define U3CMODULEU3E_T11B36CEBA37CA1FF7C21746E808B860B676A8ECD_H
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Winvalid-offsetof"
+#pragma clang diagnostic ignored "-Wunused-variable"
+#endif
+
+// <Module>
+struct  U3CModuleU3E_t11B36CEBA37CA1FF7C21746E808B860B676A8ECD 
+{
+public:
+
+public:
+};
+
+#ifdef __clang__
+#pragma clang diagnostic pop
+#endif
+#endif // U3CMODULEU3E_T11B36CEBA37CA1FF7C21746E808B860B676A8ECD_H
+#ifndef RUNTIMEOBJECT_H
+#define RUNTIMEOBJECT_H
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Winvalid-offsetof"
+#pragma clang diagnostic ignored "-Wunused-variable"
+#endif
+
+// System.Object
+
+#ifdef __clang__
+#pragma clang diagnostic pop
+#endif
+#endif // RUNTIMEOBJECT_H
+struct Il2CppArrayBounds;
+#ifndef RUNTIMEARRAY_H
+#define RUNTIMEARRAY_H
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Winvalid-offsetof"
+#pragma clang diagnostic ignored "-Wunused-variable"
+#endif
+
+// System.Array
+
+#ifdef __clang__
+#pragma clang diagnostic pop
+#endif
+#endif // RUNTIMEARRAY_H
+#ifndef LIST_1_TB50CA57CD5918BF3026A6E1A2873B6699FDC3A8D_H
+#define LIST_1_TB50CA57CD5918BF3026A6E1A2873B6699FDC3A8D_H
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Winvalid-offsetof"
+#pragma clang diagnostic ignored "-Wunused-variable"
+#endif
+
+// System.Collections.Generic.List`1<UnityEngine.Rigidbody2D>
+struct  List_1_tB50CA57CD5918BF3026A6E1A2873B6699FDC3A8D  : public RuntimeObject
+{
+public:
+	// T[] System.Collections.Generic.List`1::_items
+	Rigidbody2DU5BU5D_t6283E1D3B1656D573E695711466E6E426ACA3206* ____items_1;
+	// System.Int32 System.Collections.Generic.List`1::_size
+	int32_t ____size_2;
+	// System.Int32 System.Collections.Generic.List`1::_version
+	int32_t ____version_3;
+	// System.Object System.Collections.Generic.List`1::_syncRoot
+	RuntimeObject * ____syncRoot_4;
+
+public:
+	inline static int32_t get_offset_of__items_1() { return static_cast<int32_t>(offsetof(List_1_tB50CA57CD5918BF3026A6E1A2873B6699FDC3A8D, ____items_1)); }
+	inline Rigidbody2DU5BU5D_t6283E1D3B1656D573E695711466E6E426ACA3206* get__items_1() const { return ____items_1; }
+	inline Rigidbody2DU5BU5D_t6283E1D3B1656D573E695711466E6E426ACA3206** get_address_of__items_1() { return &____items_1; }
+	inline void set__items_1(Rigidbody2DU5BU5D_t6283E1D3B1656D573E695711466E6E426ACA3206* value)
+	{
+		____items_1 = value;
+		Il2CppCodeGenWriteBarrier((&____items_1), value);
+	}
+
+	inline static int32_t get_offset_of__size_2() { return static_cast<int32_t>(offsetof(List_1_tB50CA57CD5918BF3026A6E1A2873B6699FDC3A8D, ____size_2)); }
+	inline int32_t get__size_2() const { return ____size_2; }
+	inline int32_t* get_address_of__size_2() { return &____size_2; }
+	inline void set__size_2(int32_t value)
+	{
+		____size_2 = value;
+	}
+
+	inline static int32_t get_offset_of__version_3() { return static_cast<int32_t>(offsetof(List_1_tB50CA57CD5918BF3026A6E1A2873B6699FDC3A8D, ____version_3)); }
+	inline int32_t get__version_3() const { return ____version_3; }
+	inline int32_t* get_address_of__version_3() { return &____version_3; }
+	inline void set__version_3(int32_t value)
+	{
+		____version_3 = value;
+	}
+
+	inline static int32_t get_offset_of__syncRoot_4() { return static_cast<int32_t>(offsetof(List_1_tB50CA57CD5918BF3026A6E1A2873B6699FDC3A8D, ____syncRoot_4)); }
+	inline RuntimeObject * get__syncRoot_4() const { return ____syncRoot_4; }
+	inline RuntimeObject ** get_address_of__syncRoot_4() { return &____syncRoot_4; }
+	inline void set__syncRoot_4(RuntimeObject * value)
+	{
+		____syncRoot_4 = value;
+		Il2CppCodeGenWriteBarrier((&____syncRoot_4), value);
+	}
+};
+
+struct List_1_tB50CA57CD5918BF3026A6E1A2873B6699FDC3A8D_StaticFields
+{
+public:
+	// T[] System.Collections.Generic.List`1::_emptyArray
+	Rigidbody2DU5BU5D_t6283E1D3B1656D573E695711466E6E426ACA3206* ____emptyArray_5;
+
+public:
+	inline static int32_t get_offset_of__emptyArray_5() { return static_cast<int32_t>(offsetof(List_1_tB50CA57CD5918BF3026A6E1A2873B6699FDC3A8D_StaticFields, ____emptyArray_5)); }
+	inline Rigidbody2DU5BU5D_t6283E1D3B1656D573E695711466E6E426ACA3206* get__emptyArray_5() const { return ____emptyArray_5; }
+	inline Rigidbody2DU5BU5D_t6283E1D3B1656D573E695711466E6E426ACA3206** get_address_of__emptyArray_5() { return &____emptyArray_5; }
+	inline void set__emptyArray_5(Rigidbody2DU5BU5D_t6283E1D3B1656D573E695711466E6E426ACA3206* value)
+	{
+		____emptyArray_5 = value;
+		Il2CppCodeGenWriteBarrier((&____emptyArray_5), value);
+	}
+};
+
+#ifdef __clang__
+#pragma clang diagnostic pop
+#endif
+#endif // LIST_1_TB50CA57CD5918BF3026A6E1A2873B6699FDC3A8D_H
+#ifndef VALUETYPE_T4D0C27076F7C36E76190FB3328E232BCB1CD1FFF_H
+#define VALUETYPE_T4D0C27076F7C36E76190FB3328E232BCB1CD1FFF_H
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Winvalid-offsetof"
+#pragma clang diagnostic ignored "-Wunused-variable"
+#endif
+
+// System.ValueType
+struct  ValueType_t4D0C27076F7C36E76190FB3328E232BCB1CD1FFF  : public RuntimeObject
+{
+public:
+
+public:
+};
+
+#ifdef __clang__
+#pragma clang diagnostic pop
+#endif
+// Native definition for P/Invoke marshalling of System.ValueType
+struct ValueType_t4D0C27076F7C36E76190FB3328E232BCB1CD1FFF_marshaled_pinvoke
+{
+};
+// Native definition for COM marshalling of System.ValueType
+struct ValueType_t4D0C27076F7C36E76190FB3328E232BCB1CD1FFF_marshaled_com
+{
+};
+#endif // VALUETYPE_T4D0C27076F7C36E76190FB3328E232BCB1CD1FFF_H
+#ifndef PHYSICS2D_TB21970F986016656D66D2922594F336E1EE7D5C7_H
+#define PHYSICS2D_TB21970F986016656D66D2922594F336E1EE7D5C7_H
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Winvalid-offsetof"
+#pragma clang diagnostic ignored "-Wunused-variable"
+#endif
+
+// UnityEngine.Physics2D
+struct  Physics2D_tB21970F986016656D66D2922594F336E1EE7D5C7  : public RuntimeObject
+{
+public:
+
+public:
+};
+
+struct Physics2D_tB21970F986016656D66D2922594F336E1EE7D5C7_StaticFields
+{
+public:
+	// System.Collections.Generic.List`1<UnityEngine.Rigidbody2D> UnityEngine.Physics2D::m_LastDisabledRigidbody2D
+	List_1_tB50CA57CD5918BF3026A6E1A2873B6699FDC3A8D * ___m_LastDisabledRigidbody2D_0;
+
+public:
+	inline static int32_t get_offset_of_m_LastDisabledRigidbody2D_0() { return static_cast<int32_t>(offsetof(Physics2D_tB21970F986016656D66D2922594F336E1EE7D5C7_StaticFields, ___m_LastDisabledRigidbody2D_0)); }
+	inline List_1_tB50CA57CD5918BF3026A6E1A2873B6699FDC3A8D * get_m_LastDisabledRigidbody2D_0() const { return ___m_LastDisabledRigidbody2D_0; }
+	inline List_1_tB50CA57CD5918BF3026A6E1A2873B6699FDC3A8D ** get_address_of_m_LastDisabledRigidbody2D_0() { return &___m_LastDisabledRigidbody2D_0; }
+	inline void set_m_LastDisabledRigidbody2D_0(List_1_tB50CA57CD5918BF3026A6E1A2873B6699FDC3A8D * value)
+	{
+		___m_LastDisabledRigidbody2D_0 = value;
+		Il2CppCodeGenWriteBarrier((&___m_LastDisabledRigidbody2D_0), value);
+	}
+};
+
+#ifdef __clang__
+#pragma clang diagnostic pop
+#endif
+#endif // PHYSICS2D_TB21970F986016656D66D2922594F336E1EE7D5C7_H
+#ifndef INT32_T585191389E07734F19F3156FF88FB3EF4800D102_H
+#define INT32_T585191389E07734F19F3156FF88FB3EF4800D102_H
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Winvalid-offsetof"
+#pragma clang diagnostic ignored "-Wunused-variable"
+#endif
+
+// System.Int32
+struct  Int32_t585191389E07734F19F3156FF88FB3EF4800D102 
+{
+public:
+	// System.Int32 System.Int32::m_value
+	int32_t ___m_value_0;
+
+public:
+	inline static int32_t get_offset_of_m_value_0() { return static_cast<int32_t>(offsetof(Int32_t585191389E07734F19F3156FF88FB3EF4800D102, ___m_value_0)); }
+	inline int32_t get_m_value_0() const { return ___m_value_0; }
+	inline int32_t* get_address_of_m_value_0() { return &___m_value_0; }
+	inline void set_m_value_0(int32_t value)
+	{
+		___m_value_0 = value;
+	}
+};
+
+#ifdef __clang__
+#pragma clang diagnostic pop
+#endif
+#endif // INT32_T585191389E07734F19F3156FF88FB3EF4800D102_H
+#ifndef INTPTR_T_H
+#define INTPTR_T_H
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Winvalid-offsetof"
+#pragma clang diagnostic ignored "-Wunused-variable"
+#endif
+
+// System.IntPtr
+struct  IntPtr_t 
+{
+public:
+	// System.Void* System.IntPtr::m_value
+	void* ___m_value_0;
+
+public:
+	inline static int32_t get_offset_of_m_value_0() { return static_cast<int32_t>(offsetof(IntPtr_t, ___m_value_0)); }
+	inline void* get_m_value_0() const { return ___m_value_0; }
+	inline void** get_address_of_m_value_0() { return &___m_value_0; }
+	inline void set_m_value_0(void* value)
+	{
+		___m_value_0 = value;
+	}
+};
+
+struct IntPtr_t_StaticFields
+{
+public:
+	// System.IntPtr System.IntPtr::Zero
+	intptr_t ___Zero_1;
+
+public:
+	inline static int32_t get_offset_of_Zero_1() { return static_cast<int32_t>(offsetof(IntPtr_t_StaticFields, ___Zero_1)); }
+	inline intptr_t get_Zero_1() const { return ___Zero_1; }
+	inline intptr_t* get_address_of_Zero_1() { return &___Zero_1; }
+	inline void set_Zero_1(intptr_t value)
+	{
+		___Zero_1 = value;
+	}
+};
+
+#ifdef __clang__
+#pragma clang diagnostic pop
+#endif
+#endif // INTPTR_T_H
+#ifndef SINGLE_TDDDA9169C4E4E308AC6D7A824F9B28DC82204AE1_H
+#define SINGLE_TDDDA9169C4E4E308AC6D7A824F9B28DC82204AE1_H
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Winvalid-offsetof"
+#pragma clang diagnostic ignored "-Wunused-variable"
+#endif
+
+// System.Single
+struct  Single_tDDDA9169C4E4E308AC6D7A824F9B28DC82204AE1 
+{
+public:
+	// System.Single System.Single::m_value
+	float ___m_value_0;
+
+public:
+	inline static int32_t get_offset_of_m_value_0() { return static_cast<int32_t>(offsetof(Single_tDDDA9169C4E4E308AC6D7A824F9B28DC82204AE1, ___m_value_0)); }
+	inline float get_m_value_0() const { return ___m_value_0; }
+	inline float* get_address_of_m_value_0() { return &___m_value_0; }
+	inline void set_m_value_0(float value)
+	{
+		___m_value_0 = value;
+	}
+};
+
+#ifdef __clang__
+#pragma clang diagnostic pop
+#endif
+#endif // SINGLE_TDDDA9169C4E4E308AC6D7A824F9B28DC82204AE1_H
+#ifndef VOID_T22962CB4C05B1D89B55A6E1139F0E87A90987017_H
+#define VOID_T22962CB4C05B1D89B55A6E1139F0E87A90987017_H
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Winvalid-offsetof"
+#pragma clang diagnostic ignored "-Wunused-variable"
+#endif
+
+// System.Void
+struct  Void_t22962CB4C05B1D89B55A6E1139F0E87A90987017 
+{
+public:
+	union
+	{
+		struct
+		{
+		};
+		uint8_t Void_t22962CB4C05B1D89B55A6E1139F0E87A90987017__padding[1];
+	};
+
+public:
+};
+
+#ifdef __clang__
+#pragma clang diagnostic pop
+#endif
+#endif // VOID_T22962CB4C05B1D89B55A6E1139F0E87A90987017_H
+#ifndef VECTOR2_TA85D2DD88578276CA8A8796756458277E72D073D_H
+#define VECTOR2_TA85D2DD88578276CA8A8796756458277E72D073D_H
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Winvalid-offsetof"
+#pragma clang diagnostic ignored "-Wunused-variable"
+#endif
+
+// UnityEngine.Vector2
+struct  Vector2_tA85D2DD88578276CA8A8796756458277E72D073D 
+{
+public:
+	// System.Single UnityEngine.Vector2::x
+	float ___x_0;
+	// System.Single UnityEngine.Vector2::y
+	float ___y_1;
+
+public:
+	inline static int32_t get_offset_of_x_0() { return static_cast<int32_t>(offsetof(Vector2_tA85D2DD88578276CA8A8796756458277E72D073D, ___x_0)); }
+	inline float get_x_0() const { return ___x_0; }
+	inline float* get_address_of_x_0() { return &___x_0; }
+	inline void set_x_0(float value)
+	{
+		___x_0 = value;
+	}
+
+	inline static int32_t get_offset_of_y_1() { return static_cast<int32_t>(offsetof(Vector2_tA85D2DD88578276CA8A8796756458277E72D073D, ___y_1)); }
+	inline float get_y_1() const { return ___y_1; }
+	inline float* get_address_of_y_1() { return &___y_1; }
+	inline void set_y_1(float value)
+	{
+		___y_1 = value;
+	}
+};
+
+struct Vector2_tA85D2DD88578276CA8A8796756458277E72D073D_StaticFields
+{
+public:
+	// UnityEngine.Vector2 UnityEngine.Vector2::zeroVector
+	Vector2_tA85D2DD88578276CA8A8796756458277E72D073D  ___zeroVector_2;
+	// UnityEngine.Vector2 UnityEngine.Vector2::oneVector
+	Vector2_tA85D2DD88578276CA8A8796756458277E72D073D  ___oneVector_3;
+	// UnityEngine.Vector2 UnityEngine.Vector2::upVector
+	Vector2_tA85D2DD88578276CA8A8796756458277E72D073D  ___upVector_4;
+	// UnityEngine.Vector2 UnityEngine.Vector2::downVector
+	Vector2_tA85D2DD88578276CA8A8796756458277E72D073D  ___downVector_5;
+	// UnityEngine.Vector2 UnityEngine.Vector2::leftVector
+	Vector2_tA85D2DD88578276CA8A8796756458277E72D073D  ___leftVector_6;
+	// UnityEngine.Vector2 UnityEngine.Vector2::rightVector
+	Vector2_tA85D2DD88578276CA8A8796756458277E72D073D  ___rightVector_7;
+	// UnityEngine.Vector2 UnityEngine.Vector2::positiveInfinityVector
+	Vector2_tA85D2DD88578276CA8A8796756458277E72D073D  ___positiveInfinityVector_8;
+	// UnityEngine.Vector2 UnityEngine.Vector2::negativeInfinityVector
+	Vector2_tA85D2DD88578276CA8A8796756458277E72D073D  ___negativeInfinityVector_9;
+
+public:
+	inline static int32_t get_offset_of_zeroVector_2() { return static_cast<int32_t>(offsetof(Vector2_tA85D2DD88578276CA8A8796756458277E72D073D_StaticFields, ___zeroVector_2)); }
+	inline Vector2_tA85D2DD88578276CA8A8796756458277E72D073D  get_zeroVector_2() const { return ___zeroVector_2; }
+	inline Vector2_tA85D2DD88578276CA8A8796756458277E72D073D * get_address_of_zeroVector_2() { return &___zeroVector_2; }
+	inline void set_zeroVector_2(Vector2_tA85D2DD88578276CA8A8796756458277E72D073D  value)
+	{
+		___zeroVector_2 = value;
+	}
+
+	inline static int32_t get_offset_of_oneVector_3() { return static_cast<int32_t>(offsetof(Vector2_tA85D2DD88578276CA8A8796756458277E72D073D_StaticFields, ___oneVector_3)); }
+	inline Vector2_tA85D2DD88578276CA8A8796756458277E72D073D  get_oneVector_3() const { return ___oneVector_3; }
+	inline Vector2_tA85D2DD88578276CA8A8796756458277E72D073D * get_address_of_oneVector_3() { return &___oneVector_3; }
+	inline void set_oneVector_3(Vector2_tA85D2DD88578276CA8A8796756458277E72D073D  value)
+	{
+		___oneVector_3 = value;
+	}
+
+	inline static int32_t get_offset_of_upVector_4() { return static_cast<int32_t>(offsetof(Vector2_tA85D2DD88578276CA8A8796756458277E72D073D_StaticFields, ___upVector_4)); }
+	inline Vector2_tA85D2DD88578276CA8A8796756458277E72D073D  get_upVector_4() const { return ___upVector_4; }
+	inline Vector2_tA85D2DD88578276CA8A8796756458277E72D073D * get_address_of_upVector_4() { return &___upVector_4; }
+	inline void set_upVector_4(Vector2_tA85D2DD88578276CA8A8796756458277E72D073D  value)
+	{
+		___upVector_4 = value;
+	}
+
+	inline static int32_t get_offset_of_downVector_5() { return static_cast<int32_t>(offsetof(Vector2_tA85D2DD88578276CA8A8796756458277E72D073D_StaticFields, ___downVector_5)); }
+	inline Vector2_tA85D2DD88578276CA8A8796756458277E72D073D  get_downVector_5() const { return ___downVector_5; }
+	inline Vector2_tA85D2DD88578276CA8A8796756458277E72D073D * get_address_of_downVector_5() { return &___downVector_5; }
+	inline void set_downVector_5(Vector2_tA85D2DD88578276CA8A8796756458277E72D073D  value)
+	{
+		___downVector_5 = value;
+	}
+
+	inline static int32_t get_offset_of_leftVector_6() { return static_cast<int32_t>(offsetof(Vector2_tA85D2DD88578276CA8A8796756458277E72D073D_StaticFields, ___leftVector_6)); }
+	inline Vector2_tA85D2DD88578276CA8A8796756458277E72D073D  get_leftVector_6() const { return ___leftVector_6; }
+	inline Vector2_tA85D2DD88578276CA8A8796756458277E72D073D * get_address_of_leftVector_6() { return &___leftVector_6; }
+	inline void set_leftVector_6(Vector2_tA85D2DD88578276CA8A8796756458277E72D073D  value)
+	{
+		___leftVector_6 = value;
+	}
+
+	inline static int32_t get_offset_of_rightVector_7() { return static_cast<int32_t>(offsetof(Vector2_tA85D2DD88578276CA8A8796756458277E72D073D_StaticFields, ___rightVector_7)); }
+	inline Vector2_tA85D2DD88578276CA8A8796756458277E72D073D  get_rightVector_7() const { return ___rightVector_7; }
+	inline Vector2_tA85D2DD88578276CA8A8796756458277E72D073D * get_address_of_rightVector_7() { return &___rightVector_7; }
+	inline void set_rightVector_7(Vector2_tA85D2DD88578276CA8A8796756458277E72D073D  value)
+	{
+		___rightVector_7 = value;
+	}
+
+	inline static int32_t get_offset_of_positiveInfinityVector_8() { return static_cast<int32_t>(offsetof(Vector2_tA85D2DD88578276CA8A8796756458277E72D073D_StaticFields, ___positiveInfinityVector_8)); }
+	inline Vector2_tA85D2DD88578276CA8A8796756458277E72D073D  get_positiveInfinityVector_8() const { return ___positiveInfinityVector_8; }
+	inline Vector2_tA85D2DD88578276CA8A8796756458277E72D073D * get_address_of_positiveInfinityVector_8() { return &___positiveInfinityVector_8; }
+	inline void set_positiveInfinityVector_8(Vector2_tA85D2DD88578276CA8A8796756458277E72D073D  value)
+	{
+		___positiveInfinityVector_8 = value;
+	}
+
+	inline static int32_t get_offset_of_negativeInfinityVector_9() { return static_cast<int32_t>(offsetof(Vector2_tA85D2DD88578276CA8A8796756458277E72D073D_StaticFields, ___negativeInfinityVector_9)); }
+	inline Vector2_tA85D2DD88578276CA8A8796756458277E72D073D  get_negativeInfinityVector_9() const { return ___negativeInfinityVector_9; }
+	inline Vector2_tA85D2DD88578276CA8A8796756458277E72D073D * get_address_of_negativeInfinityVector_9() { return &___negativeInfinityVector_9; }
+	inline void set_negativeInfinityVector_9(Vector2_tA85D2DD88578276CA8A8796756458277E72D073D  value)
+	{
+		___negativeInfinityVector_9 = value;
+	}
+};
+
+#ifdef __clang__
+#pragma clang diagnostic pop
+#endif
+#endif // VECTOR2_TA85D2DD88578276CA8A8796756458277E72D073D_H
+#ifndef OBJECT_TAE11E5E46CD5C37C9F3E8950C00CD8B45666A2D0_H
+#define OBJECT_TAE11E5E46CD5C37C9F3E8950C00CD8B45666A2D0_H
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Winvalid-offsetof"
+#pragma clang diagnostic ignored "-Wunused-variable"
+#endif
+
+// UnityEngine.Object
+struct  Object_tAE11E5E46CD5C37C9F3E8950C00CD8B45666A2D0  : public RuntimeObject
+{
+public:
+	// System.IntPtr UnityEngine.Object::m_CachedPtr
+	intptr_t ___m_CachedPtr_0;
+
+public:
+	inline static int32_t get_offset_of_m_CachedPtr_0() { return static_cast<int32_t>(offsetof(Object_tAE11E5E46CD5C37C9F3E8950C00CD8B45666A2D0, ___m_CachedPtr_0)); }
+	inline intptr_t get_m_CachedPtr_0() const { return ___m_CachedPtr_0; }
+	inline intptr_t* get_address_of_m_CachedPtr_0() { return &___m_CachedPtr_0; }
+	inline void set_m_CachedPtr_0(intptr_t value)
+	{
+		___m_CachedPtr_0 = value;
+	}
+};
+
+struct Object_tAE11E5E46CD5C37C9F3E8950C00CD8B45666A2D0_StaticFields
+{
+public:
+	// System.Int32 UnityEngine.Object::OffsetOfInstanceIDInCPlusPlusObject
+	int32_t ___OffsetOfInstanceIDInCPlusPlusObject_1;
+
+public:
+	inline static int32_t get_offset_of_OffsetOfInstanceIDInCPlusPlusObject_1() { return static_cast<int32_t>(offsetof(Object_tAE11E5E46CD5C37C9F3E8950C00CD8B45666A2D0_StaticFields, ___OffsetOfInstanceIDInCPlusPlusObject_1)); }
+	inline int32_t get_OffsetOfInstanceIDInCPlusPlusObject_1() const { return ___OffsetOfInstanceIDInCPlusPlusObject_1; }
+	inline int32_t* get_address_of_OffsetOfInstanceIDInCPlusPlusObject_1() { return &___OffsetOfInstanceIDInCPlusPlusObject_1; }
+	inline void set_OffsetOfInstanceIDInCPlusPlusObject_1(int32_t value)
+	{
+		___OffsetOfInstanceIDInCPlusPlusObject_1 = value;
+	}
+};
+
+#ifdef __clang__
+#pragma clang diagnostic pop
+#endif
+// Native definition for P/Invoke marshalling of UnityEngine.Object
+struct Object_tAE11E5E46CD5C37C9F3E8950C00CD8B45666A2D0_marshaled_pinvoke
+{
+	intptr_t ___m_CachedPtr_0;
+};
+// Native definition for COM marshalling of UnityEngine.Object
+struct Object_tAE11E5E46CD5C37C9F3E8950C00CD8B45666A2D0_marshaled_com
+{
+	intptr_t ___m_CachedPtr_0;
+};
+#endif // OBJECT_TAE11E5E46CD5C37C9F3E8950C00CD8B45666A2D0_H
+#ifndef RAYCASTHIT2D_T5E8A7F96317BAF2033362FC780F4D72DC72764BE_H
+#define RAYCASTHIT2D_T5E8A7F96317BAF2033362FC780F4D72DC72764BE_H
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Winvalid-offsetof"
+#pragma clang diagnostic ignored "-Wunused-variable"
+#endif
+
+// UnityEngine.RaycastHit2D
+struct  RaycastHit2D_t5E8A7F96317BAF2033362FC780F4D72DC72764BE 
+{
+public:
+	// UnityEngine.Vector2 UnityEngine.RaycastHit2D::m_Centroid
+	Vector2_tA85D2DD88578276CA8A8796756458277E72D073D  ___m_Centroid_0;
+	// UnityEngine.Vector2 UnityEngine.RaycastHit2D::m_Point
+	Vector2_tA85D2DD88578276CA8A8796756458277E72D073D  ___m_Point_1;
+	// UnityEngine.Vector2 UnityEngine.RaycastHit2D::m_Normal
+	Vector2_tA85D2DD88578276CA8A8796756458277E72D073D  ___m_Normal_2;
+	// System.Single UnityEngine.RaycastHit2D::m_Distance
+	float ___m_Distance_3;
+	// System.Single UnityEngine.RaycastHit2D::m_Fraction
+	float ___m_Fraction_4;
+	// System.Int32 UnityEngine.RaycastHit2D::m_Collider
+	int32_t ___m_Collider_5;
+
+public:
+	inline static int32_t get_offset_of_m_Centroid_0() { return static_cast<int32_t>(offsetof(RaycastHit2D_t5E8A7F96317BAF2033362FC780F4D72DC72764BE, ___m_Centroid_0)); }
+	inline Vector2_tA85D2DD88578276CA8A8796756458277E72D073D  get_m_Centroid_0() const { return ___m_Centroid_0; }
+	inline Vector2_tA85D2DD88578276CA8A8796756458277E72D073D * get_address_of_m_Centroid_0() { return &___m_Centroid_0; }
+	inline void set_m_Centroid_0(Vector2_tA85D2DD88578276CA8A8796756458277E72D073D  value)
+	{
+		___m_Centroid_0 = value;
+	}
+
+	inline static int32_t get_offset_of_m_Point_1() { return static_cast<int32_t>(offsetof(RaycastHit2D_t5E8A7F96317BAF2033362FC780F4D72DC72764BE, ___m_Point_1)); }
+	inline Vector2_tA85D2DD88578276CA8A8796756458277E72D073D  get_m_Point_1() const { return ___m_Point_1; }
+	inline Vector2_tA85D2DD88578276CA8A8796756458277E72D073D * get_address_of_m_Point_1() { return &___m_Point_1; }
+	inline void set_m_Point_1(Vector2_tA85D2DD88578276CA8A8796756458277E72D073D  value)
+	{
+		___m_Point_1 = value;
+	}
+
+	inline static int32_t get_offset_of_m_Normal_2() { return static_cast<int32_t>(offsetof(RaycastHit2D_t5E8A7F96317BAF2033362FC780F4D72DC72764BE, ___m_Normal_2)); }
+	inline Vector2_tA85D2DD88578276CA8A8796756458277E72D073D  get_m_Normal_2() const { return ___m_Normal_2; }
+	inline Vector2_tA85D2DD88578276CA8A8796756458277E72D073D * get_address_of_m_Normal_2() { return &___m_Normal_2; }
+	inline void set_m_Normal_2(Vector2_tA85D2DD88578276CA8A8796756458277E72D073D  value)
+	{
+		___m_Normal_2 = value;
+	}
+
+	inline static int32_t get_offset_of_m_Distance_3() { return static_cast<int32_t>(offsetof(RaycastHit2D_t5E8A7F96317BAF2033362FC780F4D72DC72764BE, ___m_Distance_3)); }
+	inline float get_m_Distance_3() const { return ___m_Distance_3; }
+	inline float* get_address_of_m_Distance_3() { return &___m_Distance_3; }