public static T LoadAsset <T>(AssetBundle assetBundle, string assetPath) where T : Object
{
var asset = assetBundle.LoadAsset_Internal(assetPath, Il2CppType.Of <T>()).Cast <T>();
asset.hideFlags |= HideFlags.DontUnloadUnusedAsset;
return(asset);
}
private static void OnContainerSuccess(ApiContainer container)
{
if (container == null)
{
return;
}
ApiModelListContainer <APIUser> listContainer = container.TryCast <ApiModelListContainer <APIUser> >();
if (listContainer != null)
{
try
{
for (int i = 0; i < listContainer.ResponseList.Count; i++)
{
cachedUsers[listContainer.ResponseModels.get_Item(i).id] = new UserInfoExtensionsAPIUser(listContainer.ResponseList.get_Item(i));
}
}
catch (Exception ex)
{
MelonLogger.Error("Failed while caching user from list:\n" + ex.ToString());
}
}
else if (container.Model != null && container.Model.GetIl2CppType() == Il2CppType.Of <APIUser>())
{
try
{
cachedUsers[container.Model.id] = new UserInfoExtensionsAPIUser(container.Data);
}
catch (Exception ex)
{
MelonLogger.Error("Failed while caching user:\n" + ex.ToString());
}
}
}
public Il2CppSystem.Object BoxIl2CppObject(object value)
{
if (value == null)
{
return(null);
}
try
{
var type = value.GetType();
if (!type.IsValueType)
{
return(null);
}
if (type.IsEnum)
{
return(Il2CppSystem.Enum.Parse(Il2CppType.From(type), value.ToString()));
}
if (type.IsPrimitive && AllTypes.TryGetValue($"Il2Cpp{type.FullName}", out Type cppType))
{
return(BoxIl2CppObject(MakeIl2CppPrimitive(cppType, value), cppType));
}
return(BoxIl2CppObject(value, type));
}
catch (Exception ex)
{
ExplorerCore.LogWarning("Exception in BoxIl2CppObject: " + ex);
return(null);
}
}
public PreloadedBundleContents(AssetBundle bundle)
{
StoredThingsParent = new GameObject("ModUiPreloadedBundleContents");
Object.DontDestroyOnLoad(StoredThingsParent);
StoredThingsParent.SetActive(false);
GameObject Load(string str)
{
var objectFromBundle = bundle.LoadAsset_Internal(str, Il2CppType.Of <GameObject>()).Cast <GameObject>();
var newObject = Object.Instantiate(objectFromBundle, StoredThingsParent.transform);
newObject.SetActive(true);
return(newObject.NoUnload());
}
BigMenuExpando = Load("Assets/ModUI/BigMenuSideExpando.prefab");
SettingsMenuExpando = Load("Assets/ModUI/ModSettingsTopExpando.prefab");
QuickMenuExpando = Load("Assets/ModUI/QuickMenuExpandoRoot.prefab");
QuickMenuButton = Load("Assets/ModUI/BigMenuSideButton.prefab");
QuickMenuToggle = Load("Assets/ModUI/ToggleButton.prefab");
SettingsCategory = Load("Assets/ModUI/CategoryElement.prefab");
SettingsBool = Load("Assets/ModUI/CheckboxGroup.prefab");
SettingsText = Load("Assets/ModUI/TextInputGroup.prefab");
}
public static bool GetAbility(uint id, out Il2CppSystem.Type ability)
{
try
{
if (ExploderConfigDictionary.ContainsKey(id))
{
ability = Il2CppType.Of <ExploderAbility>();
return(true);
}
if (EMPConfigDictionary.ContainsKey(id))
{
ability = Il2CppType.Of <EMPAbility>();
return(true);
}
if (ImmortalConfigDictionary.ContainsKey(id))
{
ability = Il2CppType.Of <ImmortalAbility>();
return(true);
}
}
catch
{
ability = null;
return(false);
}
ability = null;
return(false);
}
public static Vector3 GetWorldCameraPosition()
{
VRCVrCamera camera = GetVRCVrCamera();
var type = camera.GetIl2CppType();
if (type == Il2CppType.Of <VRCVrCameraSteam>())
{
VRCVrCameraSteam steam = camera.Cast <VRCVrCameraSteam>();
Transform transform1 = steam.field_Private_Transform_0;
Transform transform2 = steam.field_Private_Transform_1;
if (transform1.name == "Camera (eye)")
{
return(transform1.position);
}
else if (transform2.name == "Camera (eye)")
{
return(transform2.position);
}
}
else if (type == Il2CppType.Of <VRCVrCameraUnity>())
{
VRCVrCameraUnity unity = camera.Cast <VRCVrCameraUnity>();
return(unity.CameraStereo.transform.position);
}
else if (type == Il2CppType.Of <VRCVrCameraWave>())
{
VRCVrCameraWave wave = camera.Cast <VRCVrCameraWave>();
return(wave.transform.position);
}
return(camera.transform.parent.TransformPoint(GetLocalCameraPosition()));
}
private TypeInfo resolveTypeReference(Il2CppType typeRef)
{
TypeInfo underlyingType;
switch (typeRef.type)
{
// Classes defined in the metadata (reference to a TypeDef)
case Il2CppTypeEnum.IL2CPP_TYPE_CLASS:
case Il2CppTypeEnum.IL2CPP_TYPE_VALUETYPE:
underlyingType = TypesByDefinitionIndex[typeRef.datapoint]; // klassIndex
break;
// Constructed types
case Il2CppTypeEnum.IL2CPP_TYPE_GENERICINST:
case Il2CppTypeEnum.IL2CPP_TYPE_ARRAY:
case Il2CppTypeEnum.IL2CPP_TYPE_SZARRAY:
case Il2CppTypeEnum.IL2CPP_TYPE_PTR:
// Generic type and generic method parameters
case Il2CppTypeEnum.IL2CPP_TYPE_VAR:
case Il2CppTypeEnum.IL2CPP_TYPE_MVAR:
underlyingType = new TypeInfo(this, typeRef);
break;
// Primitive types
default:
underlyingType = getTypeDefinitionFromTypeEnum(typeRef.type);
break;
}
// Create a reference type if necessary
return(typeRef.byref ? underlyingType.MakeByRefType() : underlyingType);
}
private static Texture2D LoadTexture(string texture)
{
var texture2 = _bundle.LoadAsset_Internal(texture, Il2CppType.Of <Texture2D>()).Cast <Texture2D>();
texture2.hideFlags |= HideFlags.DontUnloadUnusedAsset | HideFlags.HideAndDontSave;
return(texture2);
}
private TypeInfo getNewTypeUsage(Il2CppType usage, MemberTypes memberType)
{
TypeInfo underlyingType;
switch (usage.type)
{
case Il2CppTypeEnum.IL2CPP_TYPE_CLASS:
case Il2CppTypeEnum.IL2CPP_TYPE_VALUETYPE:
// Classes defined in the metadata
underlyingType = TypesByDefinitionIndex[usage.datapoint]; // klassIndex
break;
case Il2CppTypeEnum.IL2CPP_TYPE_GENERICINST:
case Il2CppTypeEnum.IL2CPP_TYPE_ARRAY:
case Il2CppTypeEnum.IL2CPP_TYPE_SZARRAY:
case Il2CppTypeEnum.IL2CPP_TYPE_PTR:
case Il2CppTypeEnum.IL2CPP_TYPE_VAR:
case Il2CppTypeEnum.IL2CPP_TYPE_MVAR:
// Everything that requires special handling
underlyingType = new TypeInfo(this, usage, memberType);
break;
default:
// Primitive types
underlyingType = GetTypeFromTypeEnum(usage.type);
break;
}
// Create a reference type if necessary
return(usage.byref? underlyingType.MakeByRefType() : underlyingType);
}
private static Material LoadMateral(string assetToLoad)
{
Material loadedMaterial = Bundle.LoadAsset_Internal(assetToLoad, Il2CppType.Of <Material>()).Cast <Material>();
loadedMaterial.hideFlags |= HideFlags.DontUnloadUnusedAsset;
return(loadedMaterial);
}
public static void ExportDefaultStyle(string baseDir, StyleEngine styleEngine)
{
var textAssetType = Il2CppType.Of <TextAsset>();
var spriteType = Il2CppType.Of <Sprite>();
var audioClipType = Il2CppType.Of <AudioClip>();
MelonLogger.Msg($"Exporting default VRC skin to {baseDir}");
foreach (var keyValuePair in styleEngine.field_Private_Dictionary_2_Tuple_2_String_Type_Object_0)
{
var basePath = Path.Combine(baseDir, keyValuePair.Key.Item1);
if (keyValuePair.Key.Item2 == textAssetType)
{
Directory.CreateDirectory(Path.GetDirectoryName(basePath) !);
var textAsset = keyValuePair.Value.Cast <TextAsset>();
File.WriteAllBytes(basePath + ".txt", textAsset.bytes);
}
else if (keyValuePair.Key.Item2 == spriteType)
{
Directory.CreateDirectory(Path.GetDirectoryName(basePath) !);
var sprite = keyValuePair.Value.Cast <Sprite>();
SpriteSnipperUtil.SaveSpriteAsPngWithMetadata(sprite, basePath + ".png");
}
else if (keyValuePair.Key.Item2 == audioClipType)
{
Directory.CreateDirectory(Path.GetDirectoryName(basePath) !);
var audioClip = keyValuePair.Value.Cast <AudioClip>();
WriteWaveFile(basePath + ".wav", audioClip);
}
}
MelonLogger.Msg($"Export finished");
}
public static void ShowQuickMenuPage(QuickMenu quickMenu, Transform pageTransform, string currentMenu = "ShortcutMenu")
{
if (currentPageGetter == null)
{
var menu = quickMenu.transform.Find(currentMenu).gameObject;
var fis = Il2CppType.Of <QuickMenu>().GetFields(BindingFlags.NonPublic | BindingFlags.Instance).Where(f => f.FieldType == Il2CppType.Of <GameObject>()).ToArray();
int count = 0;
foreach (FieldInfo fi in fis)
{
var value = fi.GetValue(quickMenu)?.TryCast <GameObject>();
if (value == menu && ++count == 2)
{
currentPageGetter = fi;
break;
}
}
if (currentPageGetter == null)
{
return;
}
}
currentPageGetter.GetValue(quickMenu).TryCast <GameObject>().SetActive(false);
quickMenu.transform.Find("QuickMenu_NewElements/_InfoBar").gameObject.SetActive(false);
var quickMenuContextualDisplay = quickMenu.field_Private_QuickMenuContextualDisplay_0;
quickMenuContextualDisplay.Method_Public_Void_QuickMenuContext_0(QuickMenuContextualDisplay.QuickMenuContext.NoSelection);
pageTransform.gameObject.SetActive(true);
currentPageGetter.SetValue(quickMenu, pageTransform.gameObject);
}
public void KillVideos()
{
foreach (var vrcUiVideo in Resources.FindObjectsOfTypeAll(Il2CppType.Of <VRCUiVideo>()))
{
Object.Destroy(vrcUiVideo);
}
}
public EventInfo(Il2CppInspector pkg, int eventIndex, TypeInfo declaringType) :
base(declaringType)
{
Definition = pkg.Metadata.Events[eventIndex];
Index = eventIndex;
Name = pkg.Strings[Definition.nameIndex];
eventType = pkg.TypeUsages[Definition.typeIndex];
if ((eventType.attrs & Il2CppConstants.FIELD_ATTRIBUTE_SPECIAL_NAME) == Il2CppConstants.FIELD_ATTRIBUTE_SPECIAL_NAME)
{
Attributes |= EventAttributes.SpecialName;
}
// NOTE: This relies on methods being added to TypeInfo.DeclaredMethods in the same order they are defined in the Il2Cpp metadata
// add, remove and raise are method indices from the first method of the declaring type
if (Definition.add >= 0)
{
AddMethod = declaringType.DeclaredMethods[Definition.add];
}
if (Definition.remove >= 0)
{
RemoveMethod = declaringType.DeclaredMethods[Definition.remove];
}
if (Definition.raise >= 0)
{
RaiseMethod = declaringType.DeclaredMethods[Definition.raise];
}
}
public static void Setup()
{
using (var stream = Assembly.GetExecutingAssembly().GetManifestResourceStream("WorldPredownload.gompowpd"))
using (var tempStream = new MemoryStream((int)stream.Length))
{
stream.CopyTo(tempStream);
iconsAssetBundle = AssetBundle.LoadFromMemory_Internal(tempStream.ToArray(), 0);
iconsAssetBundle.hideFlags |= HideFlags.DontUnloadUnusedAsset;
}
hudIcon = iconsAssetBundle.LoadAsset_Internal("Assets/DownloadIcon.png", Il2CppType.Of <Sprite>())
.Cast <Sprite>();
hudIcon.hideFlags |= HideFlags.DontUnloadUnusedAsset;
var Main = CreateImage("DownloadStatusProgress");
var Secondary = CreateImage("DownloadStatusTransparent");
Secondary.color = new Color(1, 1, 1, 0.4f);
Main.type = Image.Type.Filled;
Main.fillMethod = Image.FillMethod.Horizontal;
Main.fillOrigin = (int)Image.OriginHorizontal.Left;
Main.fillAmount = 0f;
Heavy = Main;
Fade = Secondary;
Disable();
}
public override void OnApplicationStart()
{
ModPrefs.RegisterCategory(ModCategory, "Mirror Resolution");
ModPrefs.RegisterPrefInt(ModCategory, MaxResPref, 4096, "Max eye texture size");
ModPrefs.RegisterPrefInt(ModCategory, MirrorMsaaPref, 0, "Mirror MSAA (0=default)");
ModPrefs.RegisterPrefBool(ModCategory, AllMirrorsAutoPref, false, "Force auto resolution");
unsafe
{
var methodInfo = Il2CppType.Of <VRC_MirrorReflection>().GetMethod(nameof(VRC_MirrorReflection.GetReflectionData), BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
var originalMethodPointer = *(IntPtr *)IL2CPP.il2cpp_method_get_from_reflection(methodInfo.Pointer);
CompatHook((IntPtr)(&originalMethodPointer), typeof(MirrorResolutionUnlimiterMod).GetMethod(nameof(GetReflectionData), System.Reflection.BindingFlags.Static | System.Reflection.BindingFlags.NonPublic) !.MethodHandle.GetFunctionPointer());
}
OnModSettingsApplied();
if (AppDomain.CurrentDomain.GetAssemblies().Any(it => it.GetName().Name.StartsWith("UIExpansionKit")))
{
MelonModLogger.Log("Adding UIExpansionKit buttons");
typeof(UiExtensionsAddon)
.GetMethod(nameof(UiExtensionsAddon.Init),
System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.Static) !
.Invoke(null, new object[0]);
}
}
private static Vector2 BeginScrollView_ImplLayout(Vector2 scrollPosition, bool alwaysShowHorizontal, bool alwaysShowVertical,
GUIStyle horizontalScrollbar, GUIStyle verticalScrollbar, GUIStyle background, params GUILayoutOption[] options)
{
var guiscrollGroup = GUILayoutUtility.BeginLayoutGroup(background, null, Il2CppType.Of <GUIScrollGroup>())
.TryCast <GUIScrollGroup>();
EventType type = Event.current.type;
if (type == EventType.Layout)
{
guiscrollGroup.resetCoords = true;
guiscrollGroup.isVertical = true;
guiscrollGroup.stretchWidth = 1;
guiscrollGroup.stretchHeight = 1;
guiscrollGroup.verticalScrollbar = verticalScrollbar;
guiscrollGroup.horizontalScrollbar = horizontalScrollbar;
guiscrollGroup.needsVerticalScrollbar = alwaysShowVertical;
guiscrollGroup.needsHorizontalScrollbar = alwaysShowHorizontal;
guiscrollGroup.ApplyOptions(options);
}
return(BeginScrollView_Impl(guiscrollGroup.rect,
scrollPosition,
new Rect(0f, 0f, guiscrollGroup.clientWidth, guiscrollGroup.clientHeight),
alwaysShowHorizontal,
alwaysShowVertical,
horizontalScrollbar,
verticalScrollbar,
background
));
}
private static void Prefix()
{
Logger.Debug("== List of Material that can be used for Materials Parameters ==");
//TODO: Replace this to AssetShardManager Code
var fullmats = Resources.FindObjectsOfTypeAll(Il2CppType.Of <Material>());
foreach (var obj in fullmats)
{
var mat = obj.Cast <Material>();
var matName = mat?.name ?? string.Empty;
var shaderName = mat?.shader?.name ?? string.Empty;
if (string.IsNullOrEmpty(matName))
{
continue;
}
if (!ConfigManager.Current.ModelCustom.CacheAllMaterials)
{
if (!shaderName.Contains("EnemyFlesh"))
{
continue;
}
}
MaterialCustom.AddToCache(matName, mat);
Logger.Debug(matName);
}
Logger.Debug("== End of List ==");
}
private IEnumerator WaitAndRegisterEmojiButtons()
{
while (QuickMenu.prop_QuickMenu_0 == null)
{
yield return(null);
}
var emojiMenuRoot = QuickMenu.prop_QuickMenu_0.transform.Find("EmojiMenu");
if (emojiMenuRoot == null)
{
MelonLogger.LogError("Emoji menu root not found");
yield break;
}
var emojiMenu = emojiMenuRoot.GetComponent <EmojiMenu>();
var storeGo = new GameObject("ClonedPageStore");
storeGo.transform.SetParent(emojiMenu.transform);
storeGo.SetActive(false);
for (var index = 0; index < emojiMenu.pages.Count; index++)
{
var pageGo = emojiMenu.pages[index];
var clone = new GameObject($"Page{index}Button", new [] { Il2CppType.Of <RectTransform>() });
clone.transform.SetParent(storeGo.transform, false);
var grid = clone.AddComponent <GridLayoutGroup>();
grid.constraint = GridLayoutGroup.Constraint.FixedColumnCount;
grid.cellSize = new Vector2(33, 33);
grid.startAxis = GridLayoutGroup.Axis.Horizontal;
grid.startCorner = GridLayoutGroup.Corner.UpperLeft;
grid.constraintCount = 3;
foreach (var buttonXformObject in pageGo.transform)
{
var buttonTransform = buttonXformObject.Cast <Transform>();
if (!buttonTransform.gameObject.activeSelf)
{
continue;
}
var buttonClone = Object.Instantiate(buttonTransform.gameObject, clone.transform, false);
CleanStuff(buttonClone);
}
var index1 = index;
ExpansionKitApi.RegisterSimpleMenuButton(ExpandedMenu.EmojiQuickMenu, "", () =>
{
emojiMenu.pages[emojiMenu.field_Private_Int32_0].SetActive(false);
pageGo.SetActive(true);
emojiMenu.field_Private_Int32_0 = index1;
}, buttonGo =>
{
Object.Instantiate(clone, buttonGo.transform, false);
});
}
}
public static void ShowQuickmenuPage(string pagename)
{
QuickMenu quickmenu = GetQuickMenuInstance();
Transform pageTransform = quickmenu?.transform.Find(pagename);
if (currentPageGetter == null)
{
GameObject shortcutMenu = quickmenu.transform.Find("ShortcutMenu").gameObject;
if (!shortcutMenu.activeInHierarchy)
{
shortcutMenu = quickmenu.transform.Find("UserInteractMenu").gameObject;
}
FieldInfo[] fis = Il2CppType.Of <QuickMenu>().GetFields(BindingFlags.NonPublic | BindingFlags.Instance).Where((fi) => fi.FieldType == Il2CppType.Of <GameObject>()).ToArray();
int count = 0;
foreach (FieldInfo fi in fis)
{
GameObject value = fi.GetValue(quickmenu)?.TryCast <GameObject>();
if (value == shortcutMenu && ++count == 2)
{
currentPageGetter = fi;
break;
}
}
if (currentPageGetter == null)
{
Console.WriteLine("[QMStuff] Unable to find field currentPage in QuickMenu");
return;
}
}
currentPageGetter.GetValue(quickmenu)?.Cast <GameObject>().SetActive(false);
GameObject infoBar = GetQuickMenuInstance().transform.Find("QuickMenu_NewElements/_InfoBar").gameObject;
infoBar.SetActive(pagename == "ShortcutMenu");
QuickMenuContextualDisplay quickmenuContextualDisplay = GetQuickMenuInstance().field_Private_QuickMenuContextualDisplay_0;
quickmenuContextualDisplay.Method_Public_Void_EnumNPublicSealedvaUnNoToUs7vUsNoUnique_0(QuickMenuContextualDisplay.EnumNPublicSealedvaUnNoToUs7vUsNoUnique.NoSelection);
//quickmenuContextualDisplay.Method_Public_Nested0_0(QuickMenuContextualDisplay.Nested0.NoSelection);
pageTransform.gameObject.SetActive(true);
currentPageGetter.SetValue(quickmenu, pageTransform.gameObject);
if (pagename == "ShortcutMenu")
{
SetIndex(0);
}
else if (pagename == "UserInteractMenu")
{
SetIndex(3);
}
else
{
SetIndex(-1);
}
}
private static Texture2D LoadTexture(string Texture)
{ // https://github.com/KortyBoi/VRChat-TeleporterVR/blob/59bdfb200497db665621b519a9ff9c3d1c3f2bc8/Utils/ResourceManager.cs#L32
Texture2D Texture2 = assetBundleIcons.LoadAsset_Internal(Texture, Il2CppType.Of <Texture2D>()).Cast <Texture2D>();
Texture2.hideFlags |= HideFlags.DontUnloadUnusedAsset;
//Texture2.hideFlags = HideFlags.HideAndDontSave;
return(Texture2);
}
public override T Rework <T>(GameObject template, T marker)
{
template.AddComponent(Il2CppType.Of <SpriteRenderer>());
var renderer = template.GetComponentInChildren <SpriteRenderer>();
renderer.LoadCustomSprite(AbsolutelyPhysicalPath);
return(renderer.sprite.Cast <T>());
}
public AssetBundleCreateRequest LoadAssetWithSubAssetsAsync <T>(string name) where T : Object
{
if (!UnhollowerSupport.IsGeneratedAssemblyType(typeof(T)))
{
throw new System.NullReferenceException("The type must be a Generated Assembly Type.");
}
System.IntPtr intptr = LoadAssetWithSubAssetsAsync(name, Il2CppType.Of <T>().Pointer);
return((intptr != System.IntPtr.Zero) ? new AssetBundleCreateRequest(intptr) : null);
}
public Il2CppReferenceArray <T> LoadAllAssets <T>() where T : Object
{
if (!UnhollowerSupport.IsGeneratedAssemblyType(typeof(T)))
{
throw new System.NullReferenceException("The type must be a Generated Assembly Type.");
}
System.IntPtr intptr = LoadAllAssets(Il2CppType.Of <T>().Pointer);
return((intptr != System.IntPtr.Zero) ? new Il2CppReferenceArray <T>(intptr) : null);
}
public T LoadAsset <T>(string name) where T : Object
{
if (!UnhollowerSupport.IsGeneratedAssemblyType(typeof(T)))
{
throw new System.NullReferenceException("The type must be a Generated Assembly Type.");
}
System.IntPtr intptr = LoadAsset(name, Il2CppType.Of <T>().Pointer);
return((intptr != System.IntPtr.Zero) ? UnhollowerSupport.Il2CppObjectPtrToIl2CppObject <T>(intptr) : null);
}
private void CheckAutocomplete()
{
// Temporary disabling this check in BepInEx Il2Cpp.
#if BIE
#if CPP
#else
if (GUI.GetNameOfFocusedControl() != INPUT_CONTROL_NAME)
{
return;
}
#endif
#else
if (GUI.GetNameOfFocusedControl() != INPUT_CONTROL_NAME)
{
return;
}
#endif
#if CPP
textEditor = GUIUtility.GetStateObject(Il2CppType.Of <TextEditor>(), GUIUtility.keyboardControl).TryCast <TextEditor>();
#else
textEditor = (TextEditor)GUIUtility.GetStateObject(typeof(TextEditor), GUIUtility.keyboardControl);
#endif
var input = m_input;
if (!string.IsNullOrEmpty(input))
{
try
{
var splitChars = new[] { ',', ';', '<', '>', '(', ')', '[', ']', '=', '|', '&' };
// Credit ManlyMarco
// Separate input into parts, grab only the part with cursor in it
var cursorIndex = textEditor.cursorIndex;
var start = cursorIndex <= 0 ? 0 : input.LastIndexOfAny(splitChars, cursorIndex - 1) + 1;
var end = cursorIndex <= 0 ? input.Length : input.IndexOfAny(splitChars, cursorIndex - 1);
if (end < 0 || end < start)
{
end = input.Length;
}
input = input.Substring(start, end - start);
}
catch (ArgumentException) { }
if (!string.IsNullOrEmpty(input) && input != m_prevInput)
{
GetAutocompletes(input);
}
}
else
{
ClearAutocompletes();
}
m_prevInput = input;
}
private void IgnoreCollision(bool ignore)
{
Object[] colliders = Object.FindObjectsOfType(Il2CppType.Of <Collider>());
foreach (Object c in colliders)
{
Physics.IgnoreCollision(GameObject.FindWithTag("Player").transform.GetComponent(Il2CppType.Of <Collider>()).TryCast <Collider>(), c.TryCast <Collider>(), ignore);
}
}
private static TypeContainer FindType(string name)
{
Initialize();
try
{
string @namespace = string.Empty;
string typeName = null;
var lastDot = name.LastIndexOf(".");
if (lastDot == -1)
{
typeName = name;
}
else
{
@namespace = name.Substring(0, lastDot);
typeName = name.Substring(lastDot + 1);
}
var ptr = Il2CppUtilities.GetIl2CppClass(@namespace, typeName);
Type wrapperType = null;
var assemblies = AppDomain.CurrentDomain.GetAssemblies();
foreach (var assembly in assemblies)
{
try
{
var type = assembly.GetType(name, false);
if (type != null)
{
wrapperType = type;
}
}
catch
{
// don't care!
}
}
if (wrapperType != null && ptr == IntPtr.Zero)
{
XuaLogger.AutoTranslator.Warn("Could not find '" + name + "' in IL2CPP domain even though it could be found in the managed domain.");
}
if (wrapperType != null)
{
return(new TypeContainer(ptr != IntPtr.Zero ? Il2CppType.TypeFromPointer(ptr) : null, wrapperType, ptr));
}
}
catch (Exception e)
{
XuaLogger.AutoTranslator.Warn(e, "An error occurred while resolving type: " + name);
}
return(null);
}
public override UnityEngine.Object[] FindObjectsOfTypeAll(Type type)
{
var iCall = ICallManager.GetICallUnreliable <d_FindObjectsOfTypeAll>(new[]
{
"UnityEngine.Resources::FindObjectsOfTypeAll",
"UnityEngine.ResourcesAPIInternal::FindObjectsOfTypeAll" // Unity 2020+ updated to this
});
return(new Il2CppReferenceArray <UnityEngine.Object>(iCall.Invoke(Il2CppType.From(type).Pointer)));
}
public static void BeginLayoutDirection(bool vertical, GUIContent content, GUIStyle style, GUILayoutOption[] options)
{
var g = BeginLayoutGroup(style, options, Il2CppType.Of <GUILayoutGroup>());
g.isVertical = vertical;
if (style != GUIStyle.none || content != GUIContent.none)
{
GUI.Box(g.rect, content, style);
}
}
