using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using UnityEngine;
using UnityEngine.Rendering;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[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 HowToNemo
{
internal static class NemoModel
{
internal struct Fit
{
public Quaternion Rot;
public float Scale;
public Vector3 Centre;
public string Describe;
}
private const string MeshResource = "nemo_mesh.bin";
private const string AtlasResource = "nemo_atlas.png";
private static Vector3[] _pos;
private static Vector3[] _nrm;
private static Vector2[] _uv;
private static int[] _tri;
private static Texture2D _atlas;
private static bool _tried;
private static bool _ok;
internal static Texture2D Atlas => _atlas;
internal static bool Load()
{
//IL_0032: Unknown result type (might be due to invalid IL or missing references)
//IL_003c: Expected O, but got Unknown
if (_tried)
{
return _ok;
}
_tried = true;
try
{
ReadMesh(GetResource("nemo_mesh.bin"));
byte[] resource = GetResource("nemo_atlas.png");
_atlas = new Texture2D(2, 2, (TextureFormat)4, true, false);
if (!ImageConversion.LoadImage(_atlas, resource))
{
throw new Exception("atlas PNG failed to decode");
}
((Object)_atlas).name = "NemoAtlas";
((Texture)_atlas).wrapMode = (TextureWrapMode)1;
((Texture)_atlas).filterMode = (FilterMode)1;
_atlas.Apply(true, false);
_ok = true;
Plugin.Log.LogInfo((object)$"Model loaded: {_pos.Length} verts, {_tri.Length / 3} tris, atlas {((Texture)_atlas).width}x{((Texture)_atlas).height}.");
}
catch (Exception ex)
{
Plugin.Log.LogError((object)("Could not load the embedded Nemo assets: " + ex));
_ok = false;
}
return _ok;
}
private static byte[] GetResource(string suffix)
{
Assembly executingAssembly = Assembly.GetExecutingAssembly();
string text = null;
string[] manifestResourceNames = executingAssembly.GetManifestResourceNames();
foreach (string text2 in manifestResourceNames)
{
if (text2.EndsWith(suffix, StringComparison.OrdinalIgnoreCase))
{
text = text2;
break;
}
}
if (text == null)
{
throw new Exception("embedded resource not found: " + suffix);
}
using Stream stream = executingAssembly.GetManifestResourceStream(text);
using MemoryStream memoryStream = new MemoryStream();
stream.CopyTo(memoryStream);
return memoryStream.ToArray();
}
private static void ReadMesh(byte[] data)
{
//IL_009e: Unknown result type (might be due to invalid IL or missing references)
//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
//IL_00de: Unknown result type (might be due to invalid IL or missing references)
//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
using BinaryReader binaryReader = new BinaryReader(new MemoryStream(data));
if (new string(binaryReader.ReadChars(4)) != "NEMO")
{
throw new Exception("bad mesh magic");
}
ushort num = binaryReader.ReadUInt16();
if (num != 1)
{
throw new Exception("unsupported mesh version " + num);
}
int num2 = (int)binaryReader.ReadUInt32();
int num3 = (int)binaryReader.ReadUInt32();
_pos = (Vector3[])(object)new Vector3[num2];
_nrm = (Vector3[])(object)new Vector3[num2];
_uv = (Vector2[])(object)new Vector2[num2];
for (int i = 0; i < num2; i++)
{
_pos[i] = new Vector3(binaryReader.ReadSingle(), binaryReader.ReadSingle(), binaryReader.ReadSingle());
_nrm[i] = new Vector3(binaryReader.ReadSingle(), binaryReader.ReadSingle(), binaryReader.ReadSingle());
_uv[i] = new Vector2(binaryReader.ReadSingle(), binaryReader.ReadSingle());
}
_tri = new int[num3];
for (int j = 0; j < num3; j++)
{
_tri[j] = binaryReader.ReadUInt16();
}
}
private static Vector3 Axis(int i)
{
//IL_0013: Unknown result type (might be due to invalid IL or missing references)
//IL_000d: Unknown result type (might be due to invalid IL or missing references)
//IL_0007: Unknown result type (might be due to invalid IL or missing references)
return (Vector3)(i switch
{
1 => Vector3.up,
0 => Vector3.right,
_ => Vector3.forward,
});
}
private static float Comp(Vector3 v, int i)
{
//IL_0015: Unknown result type (might be due to invalid IL or missing references)
//IL_000e: Unknown result type (might be due to invalid IL or missing references)
//IL_0007: Unknown result type (might be due to invalid IL or missing references)
return i switch
{
1 => v.y,
0 => v.x,
_ => v.z,
};
}
internal static Fit FitTo(Mesh original)
{
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
//IL_0006: Unknown result type (might be due to invalid IL or missing references)
//IL_0009: Unknown result type (might be due to invalid IL or missing references)
//IL_000e: Unknown result type (might be due to invalid IL or missing references)
//IL_002b: Unknown result type (might be due to invalid IL or missing references)
//IL_0035: Unknown result type (might be due to invalid IL or missing references)
//IL_01db: Unknown result type (might be due to invalid IL or missing references)
//IL_01e2: Unknown result type (might be due to invalid IL or missing references)
//IL_01e7: Unknown result type (might be due to invalid IL or missing references)
//IL_01eb: Unknown result type (might be due to invalid IL or missing references)
//IL_01f2: Unknown result type (might be due to invalid IL or missing references)
//IL_01f7: Unknown result type (might be due to invalid IL or missing references)
//IL_0221: Unknown result type (might be due to invalid IL or missing references)
//IL_0226: Unknown result type (might be due to invalid IL or missing references)
//IL_0228: Unknown result type (might be due to invalid IL or missing references)
//IL_022a: Unknown result type (might be due to invalid IL or missing references)
//IL_022f: Unknown result type (might be due to invalid IL or missing references)
//IL_0234: Unknown result type (might be due to invalid IL or missing references)
//IL_023b: Unknown result type (might be due to invalid IL or missing references)
//IL_0256: 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_00b4: Unknown result type (might be due to invalid IL or missing references)
//IL_00db: Unknown result type (might be due to invalid IL or missing references)
//IL_0115: Unknown result type (might be due to invalid IL or missing references)
//IL_0125: Unknown result type (might be due to invalid IL or missing references)
//IL_02c1: Unknown result type (might be due to invalid IL or missing references)
//IL_013c: Unknown result type (might be due to invalid IL or missing references)
//IL_0156: Unknown result type (might be due to invalid IL or missing references)
Bounds bounds = original.bounds;
Vector3 size = ((Bounds)(ref bounds)).size;
int[] array = new int[3] { 0, 1, 2 };
for (int i = 0; i < 2; i++)
{
for (int j = i + 1; j < 3; j++)
{
if (Comp(size, array[j]) > Comp(size, array[i]))
{
int num = array[i];
array[i] = array[j];
array[j] = num;
}
}
}
int num2 = array[0];
int num3 = array[1];
int num4 = array[2];
float num5 = 1f;
float num6 = 1f;
Vector3[] vertices = original.vertices;
if (vertices != null && vertices.Length != 0)
{
double num7 = 0.0;
for (int k = 0; k < vertices.Length; k++)
{
num7 += (double)Comp(vertices[k], num2);
}
num5 = ((num7 / (double)vertices.Length >= (double)Comp(((Bounds)(ref bounds)).center, num2)) ? 1f : (-1f));
double num8 = 0.0;
double num9 = 0.0;
int num10 = 0;
int num11 = 0;
float num12 = Comp(((Bounds)(ref bounds)).center, num3);
float num13 = Comp(((Bounds)(ref bounds)).center, num4);
for (int l = 0; l < vertices.Length; l++)
{
float num14 = Mathf.Abs(Comp(vertices[l], num4) - num13);
if (Comp(vertices[l], num3) >= num12)
{
num8 += (double)num14;
num10++;
}
else
{
num9 += (double)num14;
num11++;
}
}
if (num10 > 0 && num11 > 0)
{
num6 = ((num9 / (double)num11 >= num8 / (double)num10) ? 1f : (-1f));
}
}
if (Plugin.CfgFlipForward.Value)
{
num5 = 0f - num5;
}
if (Plugin.CfgFlipUp.Value)
{
num6 = 0f - num6;
}
Vector3 val = Axis(num2) * num5;
Vector3 val2 = Axis(num3) * num6;
Fit result = default(Fit);
result.Rot = Quaternion.Euler(Plugin.CfgRotateX.Value, Plugin.CfgRotateY.Value, Plugin.CfgRotateZ.Value) * Quaternion.LookRotation(val, val2);
result.Scale = Comp(size, num2) * Plugin.CfgScale.Value;
result.Centre = ((Bounds)(ref bounds)).center;
result.Describe = string.Format("len=axis{0}{1} up=axis{2}{3} ", num2, (num5 > 0f) ? "+" : "-", num3, (num6 > 0f) ? "+" : "-") + $"wid=axis{num4} size={size} scale={result.Scale:0.###}";
return result;
}
internal static Mesh Build(Mesh original, out Fit fit)
{
//IL_002d: Unknown result type (might be due to invalid IL or missing references)
//IL_0038: Unknown result type (might be due to invalid IL or missing references)
//IL_0043: Unknown result type (might be due to invalid IL or missing references)
//IL_0048: Unknown result type (might be due to invalid IL or missing references)
//IL_004e: Unknown result type (might be due to invalid IL or missing references)
//IL_0053: Unknown result type (might be due to invalid IL or missing references)
//IL_0058: Unknown result type (might be due to invalid IL or missing references)
//IL_0060: Unknown result type (might be due to invalid IL or missing references)
//IL_006b: 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_0075: Unknown result type (might be due to invalid IL or missing references)
//IL_0084: Unknown result type (might be due to invalid IL or missing references)
//IL_0089: Unknown result type (might be due to invalid IL or missing references)
//IL_0095: Expected O, but got Unknown
fit = FitTo(original);
Vector3[] array = (Vector3[])(object)new Vector3[_pos.Length];
Vector3[] array2 = (Vector3[])(object)new Vector3[_nrm.Length];
for (int i = 0; i < array.Length; i++)
{
array[i] = fit.Rot * (_pos[i] * fit.Scale) + fit.Centre;
array2[i] = fit.Rot * _nrm[i];
}
Mesh val = new Mesh
{
name = "Nemo"
};
if (array.Length > 65000)
{
val.indexFormat = (IndexFormat)1;
}
val.vertices = array;
val.normals = array2;
val.uv = (Vector2[])_uv.Clone();
val.triangles = (int[])_tri.Clone();
val.RecalculateBounds();
return val;
}
}
internal static class Patches
{
[HarmonyPatch(typeof(Creature), "OnStartClient")]
internal static class CreatureOnStartClient
{
[HarmonyPostfix]
private static void Postfix(Creature __instance)
{
try
{
Swapper.Apply(__instance);
}
catch (Exception ex)
{
Plugin.Log.LogError((object)("OnStartClient swap failed: " + ex));
}
}
}
[HarmonyPatch(typeof(InventorySlot), "SetItem")]
internal static class InventorySlotSetItem
{
[HarmonyPostfix]
private static void Postfix(InventorySlot __instance)
{
try
{
Swapper.SyncSlot((Component)(object)__instance);
}
catch (Exception ex)
{
Plugin.Log.LogError((object)("Inventory slot sync failed: " + ex));
}
}
}
[HarmonyPatch(typeof(JournalSlot), "SetCreature")]
internal static class JournalSlotSetCreature
{
[HarmonyPostfix]
private static void Postfix(JournalSlot __instance)
{
try
{
Swapper.SyncSlot((Component)(object)__instance);
}
catch (Exception ex)
{
Plugin.Log.LogError((object)("Journal slot sync failed: " + ex));
}
}
}
[HarmonyPatch(typeof(MachineSlot), "SetIndex")]
internal static class MachineSlotSetIndex
{
[HarmonyPostfix]
private static void Postfix(MachineSlot __instance)
{
try
{
Swapper.SyncSlot((Component)(object)__instance);
}
catch (Exception ex)
{
Plugin.Log.LogError((object)("Machine slot sync failed: " + ex));
}
}
}
}
[BepInPlugin("erwins.howtonemo", "How to Nemo", "1.0.0")]
public class Plugin : BaseUnityPlugin
{
public const string Guid = "erwins.howtonemo";
internal static ManualLogSource Log;
internal static ConfigEntry<bool> CfgEnabled;
internal static ConfigEntry<string> CfgTarget;
internal static ConfigEntry<float> CfgScale;
internal static ConfigEntry<bool> CfgFlipForward;
internal static ConfigEntry<bool> CfgFlipUp;
internal static ConfigEntry<float> CfgRotateX;
internal static ConfigEntry<float> CfgRotateY;
internal static ConfigEntry<float> CfgRotateZ;
internal static ConfigEntry<bool> CfgTexture;
internal static ConfigEntry<bool> CfgPreview;
internal static ConfigEntry<bool> CfgHideExtras;
internal static ConfigEntry<float> CfgBodyThreshold;
internal static ConfigEntry<bool> CfgVerbose;
private Harmony _harmony;
private void Awake()
{
//IL_007d: Unknown result type (might be due to invalid IL or missing references)
//IL_0087: Expected O, but got Unknown
//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
//IL_0104: Expected O, but got Unknown
//IL_0137: Unknown result type (might be due to invalid IL or missing references)
//IL_0141: Expected O, but got Unknown
//IL_0174: Unknown result type (might be due to invalid IL or missing references)
//IL_017e: Expected O, but got Unknown
//IL_0211: Unknown result type (might be due to invalid IL or missing references)
//IL_021b: Expected O, but got Unknown
//IL_0270: Unknown result type (might be due to invalid IL or missing references)
//IL_027a: Expected O, but got Unknown
Log = ((BaseUnityPlugin)this).Logger;
CfgEnabled = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "Enabled", true, "Master switch. Off leaves every model stock.");
CfgTarget = ((BaseUnityPlugin)this).Config.Bind<string>("General", "TargetPrefab", "clownfish", "Which item gets the Nemo model, by prefab name (spaces and case ignored). Any fish works if you would rather put him somewhere else. Takes effect on the next spawn.");
CfgScale = ((BaseUnityPlugin)this).Config.Bind<float>("Placement", "Scale", 1f, new ConfigDescription("Multiplier on the automatic fit. 1 matches the original fish's length exactly.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.1f, 5f), Array.Empty<object>()));
CfgFlipForward = ((BaseUnityPlugin)this).Config.Bind<bool>("Placement", "FlipForward", false, "Turn him around if he ends up swimming backwards.");
CfgFlipUp = ((BaseUnityPlugin)this).Config.Bind<bool>("Placement", "FlipUp", false, "Turn him over if he ends up upside down.");
CfgRotateX = ((BaseUnityPlugin)this).Config.Bind<float>("Placement", "RotateX", 0f, new ConfigDescription("Extra rotation in degrees, applied on top of the automatic fit.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(-180f, 180f), Array.Empty<object>()));
CfgRotateY = ((BaseUnityPlugin)this).Config.Bind<float>("Placement", "RotateY", 0f, new ConfigDescription("Extra rotation in degrees, applied on top of the automatic fit.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(-180f, 180f), Array.Empty<object>()));
CfgRotateZ = ((BaseUnityPlugin)this).Config.Bind<float>("Placement", "RotateZ", 0f, new ConfigDescription("Extra rotation in degrees, applied on top of the automatic fit.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(-180f, 180f), Array.Empty<object>()));
CfgTexture = ((BaseUnityPlugin)this).Config.Bind<bool>("Appearance", "ReplaceTexture", true, "Put Nemo's own texture on the model. Off keeps the game's clownfish texture, which will not line up with his UVs.");
CfgPreview = ((BaseUnityPlugin)this).Config.Bind<bool>("Appearance", "ReplaceInventoryPreview", true, "Also replace the small preview model in the inventory bar, the journal and the shop.");
CfgHideExtras = ((BaseUnityPlugin)this).Config.Bind<bool>("Appearance", "HideLeftoverParts", true, "Hide any small stock renderers left over after the body is replaced — stray fins or eyes that Nemo already brings his own of. Takes effect on the next spawn.");
CfgBodyThreshold = ((BaseUnityPlugin)this).Config.Bind<float>("Appearance", "BodyThreshold", 0.4f, new ConfigDescription("A renderer counts as a body (and gets replaced) when it is at least this fraction of the largest one. Lower catches more parts. Takes effect on the next spawn.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.05f, 1f), Array.Empty<object>()));
CfgVerbose = ((BaseUnityPlugin)this).Config.Bind<bool>("Debug", "VerboseLogging", false, "Log every renderer found on the fish and how the model was fitted to it. Turn this on before reporting a placement problem.");
((BaseUnityPlugin)this).Config.SettingChanged += delegate
{
Runner.RefitWanted = true;
};
_harmony = new Harmony("erwins.howtonemo");
_harmony.PatchAll(typeof(Patches.CreatureOnStartClient));
_harmony.PatchAll(typeof(Patches.InventorySlotSetItem));
_harmony.PatchAll(typeof(Patches.JournalSlotSetCreature));
_harmony.PatchAll(typeof(Patches.MachineSlotSetIndex));
((Component)this).gameObject.AddComponent<Runner>();
Log.LogInfo((object)"How to Nemo loaded. He is out there somewhere.");
}
private void OnDestroy()
{
Harmony harmony = _harmony;
if (harmony != null)
{
harmony.UnpatchSelf();
}
}
}
internal class Runner : MonoBehaviour
{
internal static bool RefitWanted;
private float _nextSweep;
private void Update()
{
if (RefitWanted)
{
RefitWanted = false;
try
{
Swapper.Refit();
}
catch (Exception ex)
{
Plugin.Log.LogError((object)("Re-fit failed: " + ex));
}
}
if (!(Time.unscaledTime < _nextSweep))
{
_nextSweep = Time.unscaledTime + 30f;
Swapper.Sweep();
}
}
}
internal static class Swapper
{
private struct Tracked
{
public Renderer Renderer;
public SkinnedMeshRenderer Skinned;
public MeshFilter Filter;
public Mesh Original;
}
private struct Candidate
{
public Renderer Renderer;
public SkinnedMeshRenderer Skinned;
public MeshFilter Filter;
public Mesh Mesh;
public float Area;
}
private const string MeshName = "Nemo";
private static readonly List<Tracked> Live = new List<Tracked>();
private static readonly HashSet<int> Handled = new HashSet<int>();
private static readonly Dictionary<int, Mesh> FitCache = new Dictionary<int, Mesh>();
private static FieldInfo _fMesh;
private static FieldInfo _fDripMesh;
private static Item _prefab;
private static readonly Dictionary<string, Mesh> PrefabOriginals = new Dictionary<string, Mesh>();
private static bool _prefabDone;
private static readonly Dictionary<int, Texture> OriginalSlotTex = new Dictionary<int, Texture>();
internal static string TargetKey => Normalise(Plugin.CfgTarget.Value);
internal static string Normalise(string s)
{
if (string.IsNullOrEmpty(s))
{
return string.Empty;
}
return s.Replace("(Clone)", string.Empty).Replace(" ", string.Empty).ToLowerInvariant();
}
internal static bool IsTarget(Item item)
{
if ((Object)(object)item == (Object)null)
{
return false;
}
return Normalise(((Object)((Component)item).gameObject).name) == TargetKey;
}
private static bool IsOurs(Mesh m)
{
if ((Object)(object)m != (Object)null && ((Object)m).name != null)
{
return ((Object)m).name.StartsWith("Nemo", StringComparison.Ordinal);
}
return false;
}
internal static void Apply(Creature creature)
{
if (!Plugin.CfgEnabled.Value || (Object)(object)creature == (Object)null || !IsTarget((Item)(object)creature) || !NemoModel.Load() || !Handled.Add(((Object)((Component)creature).gameObject).GetInstanceID()))
{
return;
}
PatchPrefabOnce();
List<Candidate> list = Collect(((Component)creature).gameObject);
if (list.Count == 0)
{
Plugin.Log.LogWarning((object)(((Object)((Component)creature).gameObject).name + ": no renderer with a mesh found; nothing to replace."));
return;
}
float num = 0f;
foreach (Candidate item in list)
{
num = Mathf.Max(num, item.Area);
}
int num2 = 0;
int num3 = 0;
foreach (Candidate item2 in list)
{
bool flag = item2.Area >= num * Plugin.CfgBodyThreshold.Value;
if (Plugin.CfgVerbose.Value)
{
Plugin.Log.LogInfo((object)(" renderer '" + ((Object)item2.Renderer).name + "' mesh '" + ((Object)item2.Mesh).name + "' " + $"area={item2.Area:0.######} skinned={(Object)(object)item2.Skinned != (Object)null} body={flag}"));
}
if (flag)
{
Tracked tracked = new Tracked
{
Renderer = item2.Renderer,
Skinned = item2.Skinned,
Filter = item2.Filter,
Original = item2.Mesh
};
Live.Add(tracked);
Fit(tracked);
num2++;
}
else if (Plugin.CfgHideExtras.Value)
{
item2.Renderer.enabled = false;
num3++;
}
}
Plugin.Log.LogInfo((object)($"{((Object)((Component)creature).gameObject).name}: replaced {num2} renderer(s)" + ((num3 > 0) ? $", hid {num3} leftover(s)" : string.Empty) + "."));
}
private static List<Candidate> Collect(GameObject root)
{
List<Candidate> list = new List<Candidate>();
SkinnedMeshRenderer[] componentsInChildren = root.GetComponentsInChildren<SkinnedMeshRenderer>(true);
foreach (SkinnedMeshRenderer val in componentsInChildren)
{
if (!((Object)(object)val == (Object)null) && !((Object)(object)val.sharedMesh == (Object)null) && !IsOurs(val.sharedMesh))
{
list.Add(Make((Renderer)(object)val, val, null, val.sharedMesh));
}
}
MeshFilter[] componentsInChildren2 = root.GetComponentsInChildren<MeshFilter>(true);
foreach (MeshFilter val2 in componentsInChildren2)
{
if (!((Object)(object)val2 == (Object)null) && !((Object)(object)val2.sharedMesh == (Object)null) && !IsOurs(val2.sharedMesh))
{
Renderer component = ((Component)val2).GetComponent<Renderer>();
if (!((Object)(object)component == (Object)null))
{
list.Add(Make(component, null, val2, val2.sharedMesh));
}
}
}
return list;
}
private static Candidate Make(Renderer r, SkinnedMeshRenderer smr, MeshFilter mf, Mesh mesh)
{
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
//IL_0006: Unknown result type (might be due to invalid IL or missing references)
//IL_0009: Unknown result type (might be due to invalid IL or missing references)
//IL_000e: Unknown result type (might be due to invalid IL or missing references)
//IL_0039: Unknown result type (might be due to invalid IL or missing references)
//IL_003f: Unknown result type (might be due to invalid IL or missing references)
//IL_0046: Unknown result type (might be due to invalid IL or missing references)
//IL_004c: Unknown result type (might be due to invalid IL or missing references)
//IL_0053: Unknown result type (might be due to invalid IL or missing references)
//IL_0059: Unknown result type (might be due to invalid IL or missing references)
Bounds bounds = mesh.bounds;
Vector3 size = ((Bounds)(ref bounds)).size;
return new Candidate
{
Renderer = r,
Skinned = smr,
Filter = mf,
Mesh = mesh,
Area = Mathf.Max(size.x * size.y, Mathf.Max(size.y * size.z, size.x * size.z))
};
}
private static void Fit(Tracked t)
{
Mesh val = BuildCached(t.Original);
if ((Object)(object)t.Skinned != (Object)null)
{
BindSkinned(t.Skinned, val, t.Original);
}
else
{
t.Filter.sharedMesh = val;
}
ApplyTexture(t.Renderer);
}
private static Mesh BuildCached(Mesh original)
{
int instanceID = ((Object)original).GetInstanceID();
if (FitCache.TryGetValue(instanceID, out var value) && (Object)(object)value != (Object)null)
{
return value;
}
NemoModel.Fit fit;
Mesh val = NemoModel.Build(original, out fit);
((Object)val).name = "Nemo";
FitCache[instanceID] = val;
if (Plugin.CfgVerbose.Value)
{
Plugin.Log.LogInfo((object)(" fit against '" + ((Object)original).name + "': " + fit.Describe));
}
return val;
}
private static void BindSkinned(SkinnedMeshRenderer smr, Mesh nemo, Mesh original)
{
//IL_0025: Unknown result type (might be due to invalid IL or missing references)
//IL_01c3: Unknown result type (might be due to invalid IL or missing references)
//IL_006e: Unknown result type (might be due to invalid IL or missing references)
//IL_0073: Unknown result type (might be due to invalid IL or missing references)
//IL_0077: Unknown result type (might be due to invalid IL or missing references)
//IL_007c: Unknown result type (might be due to invalid IL or missing references)
//IL_0081: Unknown result type (might be due to invalid IL or missing references)
//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
//IL_00db: Unknown result type (might be due to invalid IL or missing references)
//IL_0119: Unknown result type (might be due to invalid IL or missing references)
//IL_0193: Unknown result type (might be due to invalid IL or missing references)
//IL_0195: Unknown result type (might be due to invalid IL or missing references)
Matrix4x4[] bindposes = original.bindposes;
Transform[] bones = smr.bones;
if (bindposes == null || bindposes.Length == 0 || bones == null || bones.Length == 0)
{
smr.sharedMesh = nemo;
((Renderer)smr).localBounds = nemo.bounds;
return;
}
if (nemo.boneWeights == null || nemo.boneWeights.Length != nemo.vertexCount)
{
int num = Mathf.Min(bindposes.Length, bones.Length);
Vector3[] array = (Vector3[])(object)new Vector3[num];
for (int i = 0; i < num; i++)
{
int num2 = i;
Matrix4x4 inverse = ((Matrix4x4)(ref bindposes[i])).inverse;
array[num2] = ((Matrix4x4)(ref inverse)).MultiplyPoint3x4(Vector3.zero);
}
Vector3[] vertices = nemo.vertices;
BoneWeight[] array2 = (BoneWeight[])(object)new BoneWeight[vertices.Length];
for (int j = 0; j < vertices.Length; j++)
{
int num3 = -1;
int num4 = -1;
float num5 = float.MaxValue;
float num6 = float.MaxValue;
for (int k = 0; k < num; k++)
{
Vector3 val = array[k] - vertices[j];
float sqrMagnitude = ((Vector3)(ref val)).sqrMagnitude;
if (sqrMagnitude < num5)
{
num6 = num5;
num4 = num3;
num5 = sqrMagnitude;
num3 = k;
}
else if (sqrMagnitude < num6)
{
num6 = sqrMagnitude;
num4 = k;
}
}
BoneWeight val2 = default(BoneWeight);
((BoneWeight)(ref val2)).boneIndex0 = Mathf.Max(num3, 0);
if (num4 < 0)
{
((BoneWeight)(ref val2)).weight0 = 1f;
}
else
{
float num7 = Mathf.Sqrt(num5);
float num8 = Mathf.Sqrt(num6);
float num9 = num7 + num8;
((BoneWeight)(ref val2)).weight0 = ((num9 <= 1E-06f) ? 1f : (num8 / num9));
((BoneWeight)(ref val2)).weight1 = 1f - ((BoneWeight)(ref val2)).weight0;
((BoneWeight)(ref val2)).boneIndex1 = num4;
}
array2[j] = val2;
}
nemo.bindposes = bindposes;
nemo.boneWeights = array2;
}
smr.sharedMesh = nemo;
((Renderer)smr).localBounds = nemo.bounds;
}
internal static void ApplyTexture(Renderer r)
{
if (!((Object)(object)r == (Object)null) && Plugin.CfgTexture.Value)
{
ApplyTexture(r.material);
}
}
internal static void ApplyTexture(Material m)
{
//IL_0064: Unknown result type (might be due to invalid IL or missing references)
//IL_0081: Unknown result type (might be due to invalid IL or missing references)
if (!((Object)(object)m == (Object)null) && !((Object)(object)NemoModel.Atlas == (Object)null))
{
if (m.HasProperty("_BaseMap"))
{
m.SetTexture("_BaseMap", (Texture)(object)NemoModel.Atlas);
}
if (m.HasProperty("_MainTex"))
{
m.SetTexture("_MainTex", (Texture)(object)NemoModel.Atlas);
}
if (m.HasProperty("_BaseColor"))
{
m.SetColor("_BaseColor", Color.white);
}
if (m.HasProperty("_Color"))
{
m.SetColor("_Color", Color.white);
}
if (m.HasProperty("_Use_Skin"))
{
m.SetFloat("_Use_Skin", 0f);
}
}
}
internal static void Sweep()
{
Live.RemoveAll((Tracked t) => (Object)(object)t.Renderer == (Object)null || (Object)(object)t.Original == (Object)null);
}
internal static void Refit()
{
if (!NemoModel.Load())
{
return;
}
FitCache.Clear();
Sweep();
foreach (Tracked item in Live)
{
Fit(item);
}
RefitPrefab();
if (Live.Count > 0 || PrefabOriginals.Count > 0)
{
Plugin.Log.LogInfo((object)$"Re-fitted {Live.Count} renderer(s) and the inventory preview.");
}
}
internal static void PatchPrefabOnce()
{
if (_prefabDone)
{
return;
}
_prefabDone = true;
try
{
_prefab = GameInfo.GetSpawnable(TargetKey);
if ((Object)(object)_prefab == (Object)null)
{
Plugin.Log.LogWarning((object)("GameInfo has no spawnable named '" + TargetKey + "'; inventory preview left alone."));
return;
}
_fMesh = AccessTools.Field(typeof(Item), "_mesh");
_fDripMesh = AccessTools.Field(typeof(Creature), "_dripMesh");
Remember(_fMesh);
if (_prefab is Creature)
{
Remember(_fDripMesh);
}
RefitPrefab();
}
catch (Exception ex)
{
Plugin.Log.LogError((object)("Could not patch the preview mesh: " + ex));
}
}
private static void Remember(FieldInfo field)
{
if (!(field == null) && !((Object)(object)_prefab == (Object)null))
{
object? value = field.GetValue(_prefab);
Mesh val = (Mesh)((value is Mesh) ? value : null);
if (val != null && !IsOurs(val))
{
PrefabOriginals[field.Name] = val;
}
}
}
private static void RefitPrefab()
{
if ((Object)(object)_prefab == (Object)null)
{
return;
}
foreach (KeyValuePair<string, Mesh> prefabOriginal in PrefabOriginals)
{
FieldInfo fieldInfo = ((prefabOriginal.Key == "_mesh") ? _fMesh : _fDripMesh);
if (!(fieldInfo == null) && !((Object)(object)prefabOriginal.Value == (Object)null))
{
fieldInfo.SetValue(_prefab, Plugin.CfgPreview.Value ? BuildCached(prefabOriginal.Value) : prefabOriginal.Value);
}
}
}
internal static void SyncSlot(Component slot)
{
if ((Object)(object)slot == (Object)null || !Plugin.CfgPreview.Value || !Plugin.CfgTexture.Value || (Object)(object)NemoModel.Atlas == (Object)null)
{
return;
}
MeshFilter[] componentsInChildren = slot.GetComponentsInChildren<MeshFilter>(true);
foreach (MeshFilter val in componentsInChildren)
{
Renderer component = ((Component)val).GetComponent<Renderer>();
if ((Object)(object)component == (Object)null)
{
continue;
}
Material material = component.material;
if ((Object)(object)material == (Object)null)
{
continue;
}
int instanceID = ((Object)material).GetInstanceID();
Texture value;
if (IsOurs(val.sharedMesh))
{
if (!OriginalSlotTex.ContainsKey(instanceID))
{
OriginalSlotTex[instanceID] = (material.HasProperty("_BaseMap") ? material.GetTexture("_BaseMap") : null);
}
ApplyTexture(material);
}
else if (OriginalSlotTex.TryGetValue(instanceID, out value))
{
if (material.HasProperty("_BaseMap"))
{
material.SetTexture("_BaseMap", value);
}
if (material.HasProperty("_MainTex"))
{
material.SetTexture("_MainTex", value);
}
OriginalSlotTex.Remove(instanceID);
}
}
}
}
}
