using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Text;
using BoneLib;
using BoneLib.BoneMenu;
using Il2CppInterop.Runtime.InteropTypes;
using Il2CppInterop.Runtime.InteropTypes.Arrays;
using Il2CppSLZ.Marrow;
using Il2CppSLZ.VRMK;
using Il2CppSystem;
using MelonLoader;
using Microsoft.CodeAnalysis;
using OffsetRemover;
using UnityEngine;
using UnityEngine.Rendering;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: MelonInfo(typeof(Core), "Head Offset Remover", "1.0.0", "Hiiiiii :3", null)]
[assembly: MelonGame("Stress Level Zero", "BONELAB")]
[assembly: TargetFramework(".NETCoreApp,Version=v6.0", FrameworkDisplayName = ".NET 6.0")]
[assembly: AssemblyVersion("0.0.0.0")]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
[CompilerGenerated]
[Embedded]
internal sealed class EmbeddedAttribute : Attribute
{
}
}
namespace System.Runtime.CompilerServices
{
[CompilerGenerated]
[Embedded]
[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
internal sealed class RefSafetyRulesAttribute : Attribute
{
public readonly int Version;
public RefSafetyRulesAttribute(int P_0)
{
Version = P_0;
}
}
}
namespace OffsetRemover
{
internal sealed class BonePair
{
public Transform src;
public Transform dst;
public bool isHeadSubtree;
public Vector3 headRestLocal;
}
internal sealed class RendererPair
{
public Renderer src;
public Renderer dst;
public bool forceDisable;
}
public class Core : MelonMod
{
private enum CameraKind
{
Headset,
Spectator,
Other
}
public static GameObject headlessAvatarClone;
public static Animator headlessAvatarCloneAnimator;
public static bool IsEnabled = true;
public static bool ignoreSpectator = true;
private static BonePair[] bonePairsArr = new BonePair[0];
private static int bonePairCount = 0;
private static RendererPair[] rendererPairsArr = new RendererPair[0];
private static int rendererPairCount = 0;
private static readonly Dictionary<int, CameraKind> cameraKindCache = new Dictionary<int, CameraKind>();
private static Transform headBoneOnClone;
private static Transform headBoneOnSource;
private static Vector3 headLocalRestPosition;
private static Quaternion headLocalRestRotation;
private static bool hasHeadCorrection;
private static Dictionary<string, Vector3> headSubtreeLocalPositions = new Dictionary<string, Vector3>(StringComparer.OrdinalIgnoreCase);
private static List<Renderer> selfRenderers = new List<Renderer>(64);
private static List<Renderer> cloneAvatarRenderers = new List<Renderer>(64);
private static int cloneBuiltForAvatarId = 0;
private static volatile bool buildInProgress = false;
private static float lastBuildAttemptTime = -999f;
private const float RetryCooldownSeconds = 3f;
private const float MinAcceptableRendererFraction = 0.5f;
private static float lastErrorLogTime = -999f;
private const float ErrorLogCooldownSeconds = 5f;
private static readonly StringBuilder pathSb = new StringBuilder(256);
private static readonly string[] nameStack = new string[64];
private static int lastSyncedFrame = -1;
private static readonly HashSet<string> ExcludedBoneNames = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
private static readonly HashSet<Transform> boneCollectScratch = new HashSet<Transform>();
private static CameraKind ClassifyCamera(Camera cam)
{
int instanceID = ((Object)cam).GetInstanceID();
if (cameraKindCache.TryGetValue(instanceID, out var value))
{
return value;
}
value = ((!(((Object)cam).name == "Headset")) ? ((((Object)cam).name == "Spectator Camera") ? CameraKind.Spectator : CameraKind.Other) : CameraKind.Headset);
cameraKindCache[instanceID] = value;
return value;
}
public override void OnInitializeMelon()
{
//IL_0067: Unknown result type (might be due to invalid IL or missing references)
//IL_0079: Unknown result type (might be due to invalid IL or missing references)
//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
MelonLogger.Msg("[OffsetRemover] Community Patch loaded.");
RenderPipelineManager.beginCameraRendering += Action<ScriptableRenderContext, Camera>.op_Implicit((Action<ScriptableRenderContext, Camera>)OnBeginCameraRendering);
Hooking.OnSwitchAvatarPostfix += delegate
{
if (IsEnabled)
{
MelonCoroutines.Start(RebuildClone(Player.RigManager));
}
};
Page obj = Page.Root.CreatePage("OffsetRemover", Color.green, 0, true);
obj.CreateBool("Enable OffsetRemover", Color.white, IsEnabled, (Action<bool>)delegate(bool v)
{
IsEnabled = v;
if (!v)
{
DisableAndCleanUp();
ApplyVisibilityToAllCameras();
}
else
{
ForceRebuild();
ApplyVisibilityToAllCameras();
}
});
obj.CreateBool("Don't Fix Spectator Camera", Color.yellow, ignoreSpectator, (Action<bool>)delegate(bool v)
{
ignoreSpectator = v;
ApplyVisibilityToAllCameras();
});
obj.CreateFunction("Rebuild Clone", Color.red, (Action)ForceRebuild);
MelonCoroutines.Start(SelfHealLoop());
}
private static void DisableAndCleanUp()
{
RigManager rigManager = Player.RigManager;
if ((Object)(object)rigManager != (Object)null && Object.op_Implicit((Object)(object)rigManager.avatar))
{
Il2CppArrayBase<Renderer> componentsInChildren = ((Component)rigManager.avatar).gameObject.GetComponentsInChildren<Renderer>(true);
for (int i = 0; i < componentsInChildren.Length; i++)
{
if (!((Object)(object)componentsInChildren[i] == (Object)null))
{
try
{
componentsInChildren[i].forceRenderingOff = false;
}
catch
{
}
}
}
}
if ((Object)(object)headlessAvatarClone != (Object)null)
{
Object.DestroyImmediate((Object)(object)headlessAvatarClone);
}
ResetCloneState();
}
private static void ApplyVisibilityToAllCameras()
{
try
{
foreach (Camera item in (Il2CppArrayBase<Camera>)(object)Camera.allCameras)
{
if ((Object)(object)item != (Object)null)
{
CheckRenderLoop(ClassifyCamera(item));
}
}
}
catch
{
}
}
private static void OnBeginCameraRendering(ScriptableRenderContext ctx, Camera cam)
{
if (!IsEnabled)
{
return;
}
try
{
CameraKind num = ClassifyCamera(cam);
if (num != CameraKind.Headset)
{
SyncCloneIfNeeded();
}
CheckRenderLoop(num);
}
catch (Exception value)
{
if (Time.time - lastErrorLogTime > 5f)
{
lastErrorLogTime = Time.time;
MelonLogger.Error($"[OffsetRemover] Render hook error: {value}");
}
}
}
private static IEnumerator SelfHealLoop()
{
while (true)
{
yield return (object)new WaitForSeconds(2f);
if (!IsEnabled)
{
continue;
}
RigManager rigManager = Player.RigManager;
if (!((Object)(object)rigManager == (Object)null) && Object.op_Implicit((Object)(object)rigManager.avatar))
{
int instanceID = ((Object)rigManager.avatar).GetInstanceID();
if ((!((Object)(object)headlessAvatarClone != (Object)null) || cloneBuiltForAvatarId != instanceID) && !buildInProgress && Time.time - lastBuildAttemptTime > 3f)
{
MelonCoroutines.Start(RebuildClone(rigManager));
}
}
}
}
private static void SyncCloneIfNeeded()
{
//IL_0080: Unknown result type (might be due to invalid IL or missing references)
//IL_0087: Unknown result type (might be due to invalid IL or missing references)
//IL_0062: Unknown result type (might be due to invalid IL or missing references)
//IL_0070: Unknown result type (might be due to invalid IL or missing references)
//IL_0143: Unknown result type (might be due to invalid IL or missing references)
if ((Object)(object)headlessAvatarCloneAnimator == (Object)null || Time.frameCount == lastSyncedFrame)
{
return;
}
lastSyncedFrame = Time.frameCount;
try
{
BonePair[] array = bonePairsArr;
for (int i = 0; i < bonePairCount; i++)
{
BonePair bonePair = array[i];
Transform src = bonePair.src;
Transform dst = bonePair.dst;
if (!((Object)(object)src == (Object)null) && !((Object)(object)dst == (Object)null))
{
if (bonePair.isHeadSubtree)
{
dst.localPosition = bonePair.headRestLocal;
dst.localRotation = src.localRotation;
}
else
{
dst.SetPositionAndRotation(src.position, src.rotation);
}
}
}
RendererPair[] array2 = rendererPairsArr;
for (int j = 0; j < rendererPairCount; j++)
{
RendererPair rendererPair = array2[j];
Renderer src2 = rendererPair.src;
Renderer dst2 = rendererPair.dst;
if (!((Object)(object)src2 == (Object)null) && !((Object)(object)dst2 == (Object)null))
{
if (rendererPair.forceDisable)
{
dst2.forceRenderingOff = true;
continue;
}
dst2.forceRenderingOff = false;
dst2.enabled = src2.enabled && ((Component)src2).gameObject.activeInHierarchy;
}
}
if (hasHeadCorrection && (Object)(object)headBoneOnSource == (Object)null && (Object)(object)headBoneOnClone != (Object)null)
{
headBoneOnClone.localRotation = headLocalRestRotation;
}
}
catch (Exception ex)
{
if (Time.time - lastErrorLogTime > 5f)
{
lastErrorLogTime = Time.time;
MelonLogger.Warning("[OffsetRemover] Clone sync failed, rebuilding: " + ex.Message);
}
if ((Object)(object)headlessAvatarClone != (Object)null)
{
Object.DestroyImmediate((Object)(object)headlessAvatarClone);
}
ResetCloneState();
}
}
public static void ForceRebuild()
{
if (!IsEnabled)
{
MelonLogger.Msg("[OffsetRemover] Rebuild ignored -- disabled.");
return;
}
RigManager rigManager = Player.RigManager;
if ((Object)(object)rigManager == (Object)null)
{
MelonLogger.Warning("[OffsetRemover] Rebuild: no RigManager.");
}
else
{
MelonCoroutines.Start(RebuildClone(rigManager));
}
}
private static IEnumerator RebuildClone(RigManager manager)
{
if (buildInProgress)
{
yield break;
}
buildInProgress = true;
lastBuildAttemptTime = Time.time;
cameraKindCache.Clear();
if ((Object)(object)headlessAvatarClone != (Object)null)
{
Object.DestroyImmediate((Object)(object)headlessAvatarClone);
}
ResetCloneState();
float waitStart = Time.time;
while ((Object)(object)manager == (Object)null || !Object.op_Implicit((Object)(object)manager.avatar) || (Object)(object)manager.avatar.animator == (Object)null || ((Component)manager.avatar).gameObject.GetComponentsInChildren<SkinnedMeshRenderer>(true).Length == 0)
{
if (Time.time - waitStart > 5f)
{
buildInProgress = false;
yield break;
}
yield return null;
}
selfRenderers.Clear();
Il2CppArrayBase<Renderer> componentsInChildren = ((Component)manager.avatar).gameObject.GetComponentsInChildren<Renderer>(true);
for (int i = 0; i < componentsInChildren.Length; i++)
{
selfRenderers.Add(componentsInChildren[i]);
}
GameObject val = null;
bool flag = true;
try
{
GameObject val2 = new GameObject("DISABLED CONTAINER");
val2.SetActive(false);
val = Object.Instantiate<GameObject>(((Component)manager.avatar).gameObject, val2.transform);
CleanClone(val);
val.transform.parent = null;
Object.Destroy((Object)(object)val2);
}
catch (Exception ex)
{
flag = false;
_ = "instantiate/clean: " + ex.Message;
}
if (!flag)
{
if ((Object)(object)val != (Object)null)
{
Object.DestroyImmediate((Object)(object)val);
}
ResetCloneState();
buildInProgress = false;
yield break;
}
cloneAvatarRenderers.Clear();
Il2CppArrayBase<Renderer> componentsInChildren2 = val.GetComponentsInChildren<Renderer>(true);
for (int j = 0; j < componentsInChildren2.Length; j++)
{
cloneAvatarRenderers.Add(componentsInChildren2[j]);
}
int length = componentsInChildren.Length;
Avatar componentInChildren = val.GetComponentInChildren<Avatar>();
Animator clnAnim = (((Object)(object)componentInChildren != (Object)null) ? componentInChildren.animator : null);
try
{
BuildPairings(manager.avatar.animator, clnAnim, ((Component)manager.avatar).gameObject, val);
}
catch (Exception ex2)
{
flag = false;
_ = "pairing: " + ex2.Message;
}
if (length > 0 && (float)cloneAvatarRenderers.Count < (float)length * 0.5f)
{
flag = false;
}
if (!flag)
{
if ((Object)(object)val != (Object)null)
{
Object.DestroyImmediate((Object)(object)val);
}
ResetCloneState();
buildInProgress = false;
yield break;
}
((Object)val).name = "HEADFIX DISPLAY CLONE";
headlessAvatarClone = val;
headlessAvatarCloneAnimator = clnAnim;
cloneBuiltForAvatarId = ((Object)manager.avatar).GetInstanceID();
buildInProgress = false;
ApplyVisibilityToAllCameras();
MelonLogger.Msg($"[OffsetRemover] Clone built -- bonePairs={bonePairCount}, renderers={cloneAvatarRenderers.Count}, headCorrection={(hasHeadCorrection ? "yes" : "no")}");
}
private static void BuildPairings(Animator srcAnim, Animator clnAnim, GameObject srcRoot, GameObject clnRoot)
{
//IL_0012: Unknown result type (might be due to invalid IL or missing references)
//IL_0017: Unknown result type (might be due to invalid IL or missing references)
//IL_001c: Unknown result type (might be due to invalid IL or missing references)
//IL_0021: Unknown result type (might be due to invalid IL or missing references)
//IL_01fa: Unknown result type (might be due to invalid IL or missing references)
//IL_01ff: Unknown result type (might be due to invalid IL or missing references)
//IL_0206: Unknown result type (might be due to invalid IL or missing references)
//IL_020b: Unknown result type (might be due to invalid IL or missing references)
//IL_0313: Unknown result type (might be due to invalid IL or missing references)
//IL_0315: Unknown result type (might be due to invalid IL or missing references)
//IL_025b: Unknown result type (might be due to invalid IL or missing references)
//IL_0488: Unknown result type (might be due to invalid IL or missing references)
//IL_048a: Unknown result type (might be due to invalid IL or missing references)
headBoneOnClone = null;
headBoneOnSource = null;
hasHeadCorrection = false;
headLocalRestPosition = Vector3.zero;
headLocalRestRotation = Quaternion.identity;
headSubtreeLocalPositions.Clear();
Transform[] array = CollectSkinnedBones(srcRoot);
Transform[] array2 = CollectSkinnedBones(clnRoot);
Dictionary<string, Transform> dictionary = new Dictionary<string, Transform>(StringComparer.OrdinalIgnoreCase);
Dictionary<string, Transform> dictionary2 = new Dictionary<string, Transform>(StringComparer.OrdinalIgnoreCase);
foreach (Transform val in array)
{
if (!((Object)(object)val == (Object)null))
{
string relativePathFast = GetRelativePathFast(val, srcRoot.transform);
if (!dictionary.ContainsKey(relativePathFast))
{
dictionary[relativePathFast] = val;
}
}
}
foreach (Transform val2 in array2)
{
if (!((Object)(object)val2 == (Object)null))
{
string relativePathFast2 = GetRelativePathFast(val2, clnRoot.transform);
if (!dictionary2.ContainsKey(relativePathFast2))
{
dictionary2[relativePathFast2] = val2;
}
}
}
Transform val3 = (((Object)(object)srcAnim != (Object)null && srcAnim.isHuman) ? srcAnim.GetBoneTransform((HumanBodyBones)10) : null);
Transform val4 = (((Object)(object)clnAnim != (Object)null && clnAnim.isHuman) ? clnAnim.GetBoneTransform((HumanBodyBones)10) : null);
if ((Object)(object)val4 == (Object)null)
{
foreach (KeyValuePair<string, Transform> item in dictionary2)
{
if (item.Key.IndexOf("head", StringComparison.OrdinalIgnoreCase) >= 0)
{
val4 = item.Value;
break;
}
}
}
if ((Object)(object)val3 == (Object)null)
{
foreach (KeyValuePair<string, Transform> item2 in dictionary)
{
if (item2.Key.IndexOf("head", StringComparison.OrdinalIgnoreCase) >= 0)
{
val3 = item2.Value;
break;
}
}
}
if ((Object)(object)val4 != (Object)null)
{
if (clnAnim != null)
{
clnAnim.Rebind();
}
if (clnAnim != null)
{
clnAnim.Update(0f);
}
headBoneOnClone = val4;
headBoneOnSource = val3;
headLocalRestPosition = val4.localPosition;
headLocalRestRotation = val4.localRotation;
hasHeadCorrection = true;
Il2CppArrayBase<Transform> componentsInChildren = ((Component)val4).GetComponentsInChildren<Transform>(true);
for (int k = 0; k < componentsInChildren.Length; k++)
{
Transform val5 = componentsInChildren[k];
if (!((Object)(object)val5 == (Object)null) && !headSubtreeLocalPositions.ContainsKey(((Object)val5).name))
{
headSubtreeLocalPositions[((Object)val5).name] = val5.localPosition;
}
}
}
EnsureBonePairCapacity(array.Length);
EnsureRendererPairCapacity(Math.Max(16, clnRendersCountEstimate(clnRoot)));
bonePairCount = 0;
rendererPairCount = 0;
HashSet<Transform> hashSet = new HashSet<Transform>();
foreach (KeyValuePair<string, Transform> item3 in dictionary)
{
if (dictionary2.TryGetValue(item3.Key, out var value))
{
BonePair bonePair = new BonePair
{
src = item3.Value,
dst = value,
isHeadSubtree = IsInHeadSubtreeCached(value)
};
if (bonePair.isHeadSubtree && headSubtreeLocalPositions.TryGetValue(((Object)value).name, out var value2))
{
bonePair.headRestLocal = value2;
}
bonePairsArr[bonePairCount++] = bonePair;
hashSet.Add(value);
}
}
Dictionary<string, List<Transform>> dictionary3 = BuildNameMap(array);
Dictionary<string, List<Transform>> dictionary4 = BuildNameMap(array2);
foreach (KeyValuePair<string, List<Transform>> item4 in dictionary3)
{
List<Transform> value3 = item4.Value;
if (!dictionary4.TryGetValue(item4.Key, out var value4) || value4.Count == 0)
{
continue;
}
for (int l = 0; l < value3.Count; l++)
{
Transform val6 = value3[l];
bool flag = false;
for (int m = 0; m < bonePairCount; m++)
{
if ((Object)(object)bonePairsArr[m].src == (Object)(object)val6)
{
flag = true;
break;
}
}
if (flag)
{
continue;
}
Transform val7 = null;
for (int n = 0; n < value4.Count; n++)
{
if (!hashSet.Contains(value4[n]))
{
val7 = value4[n];
break;
}
}
if ((Object)(object)val7 == (Object)null)
{
val7 = value4[0];
}
if (!((Object)(object)val7 == (Object)null))
{
BonePair bonePair2 = new BonePair
{
src = val6,
dst = val7,
isHeadSubtree = IsInHeadSubtreeCached(val7)
};
if (bonePair2.isHeadSubtree && headSubtreeLocalPositions.TryGetValue(((Object)val7).name, out var value5))
{
bonePair2.headRestLocal = value5;
}
bonePairsArr[bonePairCount++] = bonePair2;
hashSet.Add(val7);
}
}
}
Il2CppArrayBase<Renderer> componentsInChildren2 = srcRoot.GetComponentsInChildren<Renderer>(true);
Il2CppArrayBase<Renderer> componentsInChildren3 = clnRoot.GetComponentsInChildren<Renderer>(true);
Dictionary<string, List<Renderer>> dictionary5 = new Dictionary<string, List<Renderer>>(StringComparer.OrdinalIgnoreCase);
for (int num = 0; num < componentsInChildren3.Length; num++)
{
Renderer val8 = componentsInChildren3[num];
if (!((Object)(object)val8 == (Object)null))
{
if (!dictionary5.TryGetValue(((Object)val8).name, out var value6))
{
value6 = new List<Renderer>(2);
dictionary5[((Object)val8).name] = value6;
}
value6.Add(val8);
}
}
HashSet<Renderer> hashSet2 = new HashSet<Renderer>();
for (int num2 = 0; num2 < componentsInChildren2.Length; num2++)
{
Renderer val9 = componentsInChildren2[num2];
if ((Object)(object)val9 == (Object)null || string.IsNullOrEmpty(((Object)val9).name) || !dictionary5.TryGetValue(((Object)val9).name, out var value7) || value7.Count == 0)
{
continue;
}
Renderer val10 = null;
for (int num3 = 0; num3 < value7.Count; num3++)
{
if (!hashSet2.Contains(value7[num3]))
{
val10 = value7[num3];
break;
}
}
if ((Object)(object)val10 == (Object)null)
{
val10 = value7[0];
}
if (!((Object)(object)val10 == (Object)null))
{
try
{
val10.sharedMaterials = val9.sharedMaterials;
}
catch
{
}
RendererPair rendererPair = new RendererPair
{
src = val9,
dst = val10,
forceDisable = ((Object)(object)val9.sharedMaterial != (Object)null && (Object)(object)val9.sharedMaterial.shader != (Object)null && ((Object)val9.sharedMaterial.shader).name == "SLZ/Icon Billboard")
};
rendererPairsArr[rendererPairCount++] = rendererPair;
hashSet2.Add(val10);
}
}
}
private static Transform[] CollectSkinnedBones(GameObject root)
{
boneCollectScratch.Clear();
Il2CppArrayBase<SkinnedMeshRenderer> componentsInChildren = root.GetComponentsInChildren<SkinnedMeshRenderer>(true);
for (int i = 0; i < componentsInChildren.Length; i++)
{
Il2CppReferenceArray<Transform> bones = componentsInChildren[i].bones;
if (bones == null)
{
continue;
}
for (int j = 0; j < ((Il2CppArrayBase<Transform>)(object)bones).Length; j++)
{
if ((Object)(object)((Il2CppArrayBase<Transform>)(object)bones)[j] != (Object)null)
{
boneCollectScratch.Add(((Il2CppArrayBase<Transform>)(object)bones)[j]);
}
}
}
Transform[] array = (Transform[])(object)new Transform[boneCollectScratch.Count];
boneCollectScratch.CopyTo(array);
return array;
}
private static int clnRendersCountEstimate(GameObject clnRoot)
{
return clnRoot.GetComponentsInChildren<Renderer>(true)?.Length ?? 0;
}
private static bool IsInHeadSubtreeCached(Transform t)
{
if (!hasHeadCorrection || (Object)(object)t == (Object)null || (Object)(object)headBoneOnClone == (Object)null)
{
return false;
}
Transform val = t;
while ((Object)(object)val != (Object)null)
{
if ((Object)(object)val == (Object)(object)headBoneOnClone)
{
return true;
}
val = val.parent;
}
return false;
}
private static Dictionary<string, List<Transform>> BuildNameMap(Transform[] arr)
{
Dictionary<string, List<Transform>> dictionary = new Dictionary<string, List<Transform>>(StringComparer.OrdinalIgnoreCase);
foreach (Transform val in arr)
{
if (!((Object)(object)val == (Object)null) && !string.IsNullOrEmpty(((Object)val).name))
{
if (!dictionary.TryGetValue(((Object)val).name, out var value))
{
value = new List<Transform>(2);
dictionary[((Object)val).name] = value;
}
value.Add(val);
}
}
return dictionary;
}
private static void EnsureBonePairCapacity(int needed)
{
if (bonePairsArr.Length < needed)
{
BonePair[] array = new BonePair[Math.Max(needed, Math.Max(8, bonePairsArr.Length * 2))];
for (int i = 0; i < bonePairsArr.Length; i++)
{
array[i] = bonePairsArr[i];
}
bonePairsArr = array;
}
}
private static void EnsureRendererPairCapacity(int needed)
{
if (rendererPairsArr.Length < needed)
{
RendererPair[] array = new RendererPair[Math.Max(needed, Math.Max(8, rendererPairsArr.Length * 2))];
for (int i = 0; i < rendererPairsArr.Length; i++)
{
array[i] = rendererPairsArr[i];
}
rendererPairsArr = array;
}
}
private static void ResetCloneState()
{
//IL_001e: Unknown result type (might be due to invalid IL or missing references)
//IL_0023: Unknown result type (might be due to invalid IL or missing references)
//IL_0028: Unknown result type (might be due to invalid IL or missing references)
//IL_002d: Unknown result type (might be due to invalid IL or missing references)
headlessAvatarClone = null;
headlessAvatarCloneAnimator = null;
headBoneOnClone = null;
headBoneOnSource = null;
hasHeadCorrection = false;
headLocalRestPosition = Vector3.zero;
headLocalRestRotation = Quaternion.identity;
headSubtreeLocalPositions.Clear();
bonePairCount = 0;
rendererPairCount = 0;
selfRenderers.Clear();
cloneAvatarRenderers.Clear();
}
private static void CleanClone(GameObject clone)
{
try
{
SafeDestroyAll<ConfigurableJoint>(Il2CppArrayBase<ConfigurableJoint>.op_Implicit(clone.GetComponentsInChildren<ConfigurableJoint>(true)));
}
catch
{
}
try
{
SafeDestroyAll<Collider>(Il2CppArrayBase<Collider>.op_Implicit(clone.GetComponentsInChildren<Collider>(true)));
}
catch
{
}
try
{
SafeDestroyAll<Rigidbody>(Il2CppArrayBase<Rigidbody>.op_Implicit(clone.GetComponentsInChildren<Rigidbody>(true)));
}
catch
{
}
try
{
SafeDestroyAll<InteractableHost>(Il2CppArrayBase<InteractableHost>.op_Implicit(clone.GetComponentsInChildren<InteractableHost>(true)));
}
catch
{
}
Il2CppArrayBase<MonoBehaviour> componentsInChildren = clone.GetComponentsInChildren<MonoBehaviour>(true);
for (int i = 0; i < componentsInChildren.Length; i++)
{
MonoBehaviour val = componentsInChildren[i];
if ((Object)(object)val == (Object)null || (Object)(object)((Il2CppObjectBase)val).TryCast<Avatar>() != (Object)null)
{
continue;
}
PlayerAvatarArt val2 = ((Il2CppObjectBase)val).TryCast<PlayerAvatarArt>();
if ((Object)(object)val2 != (Object)null)
{
((Behaviour)val2).enabled = false;
continue;
}
try
{
Object.DestroyImmediate((Object)(object)val);
}
catch
{
}
}
}
private static void SafeDestroyAll<T>(T[] comps) where T : Object
{
foreach (T val in comps)
{
if (!((Object)(object)val == (Object)null))
{
try
{
Object.DestroyImmediate((Object)(object)val);
}
catch
{
}
}
}
}
private static string GetRelativePathFast(Transform t, Transform root)
{
if ((Object)(object)t == (Object)(object)root)
{
return "";
}
int num = 0;
Transform val = t;
while ((Object)(object)val != (Object)null && (Object)(object)val != (Object)(object)root && num < nameStack.Length)
{
nameStack[num++] = ((Object)val).name;
val = val.parent;
}
pathSb.Clear();
for (int num2 = num - 1; num2 >= 0; num2--)
{
pathSb.Append(nameStack[num2]);
if (num2 > 0)
{
pathSb.Append('/');
}
}
return pathSb.ToString();
}
private static void CheckRenderLoop(CameraKind kind)
{
if (!Player.HandsExist || !Object.op_Implicit((Object)(object)Player.Avatar))
{
return;
}
bool flag = kind switch
{
CameraKind.Headset => true,
CameraKind.Spectator => ignoreSpectator,
_ => false,
};
bool flag2 = (Object)(object)headlessAvatarClone != (Object)null && cloneAvatarRenderers.Count > 0;
if (flag || !flag2)
{
ToggleAvatarVisibility(selfRenderers, visible: true);
if ((Object)(object)headlessAvatarClone != (Object)null)
{
ToggleAvatarVisibility(cloneAvatarRenderers, visible: false);
}
}
else
{
ToggleAvatarVisibility(selfRenderers, visible: false);
ToggleAvatarVisibility(cloneAvatarRenderers, visible: true);
}
}
private static void ToggleAvatarVisibility(List<Renderer> renderers, bool visible)
{
for (int i = 0; i < renderers.Count; i++)
{
Renderer val = renderers[i];
if (!((Object)(object)val == (Object)null))
{
try
{
val.forceRenderingOff = !visible;
}
catch
{
}
}
}
}
}
}
