using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.IO.Compression;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Serialization;
using System.Runtime.Serialization.Json;
using System.Runtime.Versioning;
using BepInEx;
using BepInEx.Configuration;
using Microsoft.CodeAnalysis;
using UnityEngine;
using UnityEngine.Rendering;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETFramework,Version=v4.7.2", FrameworkDisplayName = ".NET Framework 4.7.2")]
[assembly: AssemblyCompany("IcarusModelReplacement")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+2dd13133085a24341e5edad1e8f497dfec2a7318")]
[assembly: AssemblyProduct("IcarusModelReplacement")]
[assembly: AssemblyTitle("IcarusModelReplacement")]
[assembly: AssemblyVersion("1.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 IcarusModelReplacement
{
internal sealed class Model : IDisposable
{
private readonly PackInfo info;
private readonly Transform[] bones;
private readonly Vector3[] rest;
private readonly Vector3[] positions;
private readonly Vector3[] rotations;
private readonly MaterialPropertyBlock lighting = new MaterialPropertyBlock();
private readonly SphericalHarmonicsL2[] probe = (SphericalHarmonicsL2[])(object)new SphericalHarmonicsL2[1];
private Material material;
private Mesh mesh;
private Texture2D texture;
private SkinnedMeshRenderer renderer;
private static readonly int Ambient0 = Shader.PropertyToID("_Global_AmbientColor0");
private static readonly int Ambient1 = Shader.PropertyToID("_Global_AmbientColor1");
private static readonly int Ambient2 = Shader.PropertyToID("_Global_AmbientColor2");
public GameObject Root { get; }
public Model(ModelPack pack, Transform parent, int layer)
{
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
//IL_000b: Expected O, but got Unknown
//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
//IL_00c2: Expected O, but got Unknown
//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
//IL_0132: Unknown result type (might be due to invalid IL or missing references)
//IL_0137: Unknown result type (might be due to invalid IL or missing references)
//IL_0148: Unknown result type (might be due to invalid IL or missing references)
//IL_014d: Unknown result type (might be due to invalid IL or missing references)
//IL_0196: Unknown result type (might be due to invalid IL or missing references)
//IL_026e: Unknown result type (might be due to invalid IL or missing references)
//IL_0273: Unknown result type (might be due to invalid IL or missing references)
//IL_0290: Unknown result type (might be due to invalid IL or missing references)
//IL_0295: Unknown result type (might be due to invalid IL or missing references)
//IL_02ac: Unknown result type (might be due to invalid IL or missing references)
//IL_02b1: Unknown result type (might be due to invalid IL or missing references)
//IL_02bc: Unknown result type (might be due to invalid IL or missing references)
//IL_0332: Unknown result type (might be due to invalid IL or missing references)
//IL_0334: Unknown result type (might be due to invalid IL or missing references)
//IL_034a: Unknown result type (might be due to invalid IL or missing references)
//IL_034f: Unknown result type (might be due to invalid IL or missing references)
//IL_0360: Unknown result type (might be due to invalid IL or missing references)
//IL_036c: Expected O, but got Unknown
//IL_03d7: Unknown result type (might be due to invalid IL or missing references)
//IL_03dc: Unknown result type (might be due to invalid IL or missing references)
//IL_03ed: Unknown result type (might be due to invalid IL or missing references)
//IL_03f4: Unknown result type (might be due to invalid IL or missing references)
//IL_0400: Expected O, but got Unknown
//IL_01c1: Unknown result type (might be due to invalid IL or missing references)
//IL_01ba: Unknown result type (might be due to invalid IL or missing references)
//IL_0421: Unknown result type (might be due to invalid IL or missing references)
//IL_0426: Unknown result type (might be due to invalid IL or missing references)
//IL_0437: Unknown result type (might be due to invalid IL or missing references)
//IL_0443: Unknown result type (might be due to invalid IL or missing references)
//IL_0444: Unknown result type (might be due to invalid IL or missing references)
//IL_0453: Expected O, but got Unknown
//IL_01c6: Unknown result type (might be due to invalid IL or missing references)
//IL_01cb: Unknown result type (might be due to invalid IL or missing references)
//IL_01e1: Unknown result type (might be due to invalid IL or missing references)
//IL_01ee: Unknown result type (might be due to invalid IL or missing references)
//IL_01f0: Unknown result type (might be due to invalid IL or missing references)
//IL_01f5: 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_05b1: Unknown result type (might be due to invalid IL or missing references)
//IL_05b6: Unknown result type (might be due to invalid IL or missing references)
//IL_05d6: Unknown result type (might be due to invalid IL or missing references)
//IL_052f: Unknown result type (might be due to invalid IL or missing references)
Shader val = Shader.Find("Standard");
if ((Object)(object)val == (Object)null || !val.isSupported)
{
throw new InvalidOperationException("The game's Standard shader is unavailable.");
}
info = pack.Info;
bones = (Transform[])(object)new Transform[info.Bones.Length];
rest = (Vector3[])(object)new Vector3[bones.Length];
positions = (Vector3[])(object)new Vector3[bones.Length + 1];
rotations = (Vector3[])(object)new Vector3[bones.Length + 1];
Root = new GameObject(info.Name)
{
layer = layer
};
Root.SetActive(false);
Root.transform.SetParent(parent, false);
Root.transform.localScale = Vector3.one * info.Scale;
try
{
Matrix4x4[] array = (Matrix4x4[])(object)new Matrix4x4[bones.Length];
for (int i = 0; i < bones.Length; i++)
{
BoneInfo boneInfo = info.Bones[i];
Vector3 val2 = Vector(boneInfo.Position);
bones[i] = new GameObject(boneInfo.Name)
{
layer = layer
}.transform;
bones[i].SetParent((boneInfo.Parent < 0) ? Root.transform : bones[boneInfo.Parent], false);
rest[i] = val2 - ((boneInfo.Parent < 0) ? Vector3.zero : Vector(info.Bones[boneInfo.Parent].Position));
bones[i].localPosition = rest[i];
array[i] = Matrix4x4.Translate(-val2);
}
Vector3[] array2 = (Vector3[])(object)new Vector3[pack.Vertices.Length];
Vector3[] array3 = (Vector3[])(object)new Vector3[array2.Length];
Vector2[] array4 = (Vector2[])(object)new Vector2[array2.Length];
BoneWeight[] array5 = (BoneWeight[])(object)new BoneWeight[array2.Length];
for (int j = 0; j < array2.Length; j++)
{
Vertex vertex = pack.Vertices[j];
array2[j] = new Vector3(vertex.X, vertex.Y, vertex.Z);
array3[j] = new Vector3(vertex.Nx, vertex.Ny, vertex.Nz);
array4[j] = new Vector2(vertex.U, vertex.V);
int num = j;
BoneWeight val3 = default(BoneWeight);
((BoneWeight)(ref val3)).boneIndex0 = vertex.B0;
((BoneWeight)(ref val3)).boneIndex1 = vertex.B1;
((BoneWeight)(ref val3)).boneIndex2 = vertex.B2;
((BoneWeight)(ref val3)).boneIndex3 = vertex.B3;
((BoneWeight)(ref val3)).weight0 = vertex.W0;
((BoneWeight)(ref val3)).weight1 = vertex.W1;
((BoneWeight)(ref val3)).weight2 = vertex.W2;
((BoneWeight)(ref val3)).weight3 = vertex.W3;
array5[num] = val3;
}
mesh = new Mesh
{
name = info.Name,
indexFormat = (IndexFormat)1
};
mesh.vertices = array2;
mesh.normals = array3;
mesh.uv = array4;
mesh.boneWeights = array5;
mesh.bindposes = array;
mesh.triangles = pack.Indices;
mesh.RecalculateBounds();
mesh.UploadMeshData(true);
texture = new Texture2D(2, 2, (TextureFormat)4, true)
{
name = info.Name,
filterMode = (FilterMode)2,
wrapMode = (TextureWrapMode)1
};
if (!ImageConversion.LoadImage(texture, pack.Texture, true))
{
throw new InvalidOperationException("Cannot decode model texture.");
}
material = new Material(val)
{
name = info.Name,
mainTexture = (Texture)(object)texture,
color = Color.white
};
material.SetFloat("_Metallic", info.Material.Metallic);
material.SetFloat("_Glossiness", info.Material.Smoothness);
if (!info.Material.SpecularHighlights)
{
material.SetFloat("_SpecularHighlights", 0f);
material.EnableKeyword("_SPECULARHIGHLIGHTS_OFF");
}
if (info.Material.Emission > 0f)
{
material.EnableKeyword("_EMISSION");
material.SetTexture("_EmissionMap", (Texture)(object)texture);
float emission = info.Material.Emission;
material.SetVector("_EmissionColor", new Vector4(emission, emission, emission, 1f));
}
renderer = Root.AddComponent<SkinnedMeshRenderer>();
renderer.sharedMesh = mesh;
((Renderer)renderer).sharedMaterial = material;
renderer.bones = bones;
renderer.rootBone = Root.transform;
renderer.quality = (SkinQuality)4;
((Renderer)renderer).lightProbeUsage = (LightProbeUsage)4;
Bounds bounds = mesh.bounds;
((Bounds)(ref bounds)).Expand(info.BoundsPadding * 2f);
((Renderer)renderer).localBounds = bounds;
Animate(Motion.Sample(0.0, 0f, 0f, 0f));
}
catch
{
Dispose();
throw;
}
}
private static Vector3 Vector(float[] v)
{
//IL_0009: Unknown result type (might be due to invalid IL or missing references)
return new Vector3(v[0], v[1], v[2]);
}
public void UpdateLighting()
{
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
//IL_000f: Unknown result type (might be due to invalid IL or missing references)
//IL_0014: Unknown result type (might be due to invalid IL or missing references)
//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_002d: Unknown result type (might be due to invalid IL or missing references)
//IL_0032: Unknown result type (might be due to invalid IL or missing references)
//IL_003a: Unknown result type (might be due to invalid IL or missing references)
//IL_0051: Unknown result type (might be due to invalid IL or missing references)
//IL_0068: Unknown result type (might be due to invalid IL or missing references)
//IL_007f: 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_0095: Unknown result type (might be due to invalid IL or missing references)
Color val = (Shader.GetGlobalColor(Ambient0) + Shader.GetGlobalColor(Ambient1) + Shader.GetGlobalColor(Ambient2)) / 3f;
val.r = Mathf.Max(0.12f, val.r);
val.g = Mathf.Max(0.12f, val.g);
val.b = Mathf.Max(0.12f, val.b);
probe[0] = RenderSettings.ambientProbe;
((SphericalHarmonicsL2)(ref probe[0])).AddAmbientLight(val);
lighting.CopySHCoefficientArraysFrom(probe);
((Renderer)renderer).SetPropertyBlock(lighting);
}
public void Animate(Motion state)
{
//IL_005c: Unknown result type (might be due to invalid IL or missing references)
//IL_0067: Unknown result type (might be due to invalid IL or missing references)
//IL_006d: Unknown result type (might be due to invalid IL or missing references)
//IL_0072: 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_008e: Unknown result type (might be due to invalid IL or missing references)
//IL_0099: Unknown result type (might be due to invalid IL or missing references)
//IL_009f: Unknown result type (might be due to invalid IL or missing references)
//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
//IL_00ce: 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_00e0: Unknown result type (might be due to invalid IL or missing references)
//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
//IL_0100: Unknown result type (might be due to invalid IL or missing references)
//IL_0132: Unknown result type (might be due to invalid IL or missing references)
//IL_0145: Unknown result type (might be due to invalid IL or missing references)
//IL_014a: Unknown result type (might be due to invalid IL or missing references)
//IL_016a: Unknown result type (might be due to invalid IL or missing references)
//IL_016f: Unknown result type (might be due to invalid IL or missing references)
//IL_0182: Unknown result type (might be due to invalid IL or missing references)
//IL_0187: Unknown result type (might be due to invalid IL or missing references)
//IL_018c: Unknown result type (might be due to invalid IL or missing references)
Array.Clear(positions, 0, positions.Length);
Array.Clear(rotations, 0, rotations.Length);
MotionInfo[] motions = info.Motions;
foreach (MotionInfo motionInfo in motions)
{
float num = state.Get(motionInfo.Kind);
ref Vector3 reference = ref positions[motionInfo.Index];
reference += Vector(motionInfo.Position) * num;
ref Vector3 reference2 = ref rotations[motionInfo.Index];
reference2 += Vector(motionInfo.Rotation) * num;
}
for (int j = 0; j < bones.Length; j++)
{
bones[j].localPosition = rest[j] + positions[j];
bones[j].localRotation = Quaternion.Euler(rotations[j]);
}
Root.transform.localPosition = Vector(info.Offset) + positions[bones.Length];
Root.transform.localRotation = Quaternion.Euler(Vector(info.Rotation)) * Quaternion.Euler(rotations[bones.Length]);
}
public void Dispose()
{
if ((Object)(object)Root != (Object)null)
{
Root.SetActive(false);
Object.Destroy((Object)(object)Root);
}
if ((Object)(object)mesh != (Object)null)
{
Object.Destroy((Object)(object)mesh);
}
if ((Object)(object)material != (Object)null)
{
Object.Destroy((Object)(object)material);
}
if ((Object)(object)texture != (Object)null)
{
Object.Destroy((Object)(object)texture);
}
}
}
[DataContract]
internal sealed class PackInfo
{
[DataMember(Name = "format", IsRequired = true)]
public int Format { get; set; }
[DataMember(Name = "name", IsRequired = true)]
public string Name { get; set; }
[DataMember(Name = "author", IsRequired = true)]
public string Author { get; set; }
[DataMember(Name = "license", IsRequired = true)]
public string License { get; set; }
[DataMember(Name = "source")]
public string Source { get; set; }
[DataMember(Name = "scale", IsRequired = true)]
public float Scale { get; set; }
[DataMember(Name = "offset")]
public float[] Offset { get; set; }
[DataMember(Name = "rotation")]
public float[] Rotation { get; set; }
[DataMember(Name = "boundsPadding")]
public float BoundsPadding { get; set; }
[DataMember(Name = "material")]
public MaterialInfo Material { get; set; }
[DataMember(Name = "bones", IsRequired = true)]
public BoneInfo[] Bones { get; set; }
[DataMember(Name = "motions")]
public MotionInfo[] Motions { get; set; }
}
[DataContract]
internal sealed class BoneInfo
{
[DataMember(Name = "name", IsRequired = true)]
public string Name { get; set; }
[DataMember(Name = "parent", IsRequired = true)]
public int Parent { get; set; }
[DataMember(Name = "position", IsRequired = true)]
public float[] Position { get; set; }
}
[DataContract]
internal sealed class MaterialInfo
{
[DataMember(Name = "smoothness")]
public float Smoothness { get; set; }
[DataMember(Name = "metallic")]
public float Metallic { get; set; }
[DataMember(Name = "emission")]
public float Emission { get; set; }
[DataMember(Name = "specularHighlights")]
public bool SpecularHighlights { get; set; }
}
[DataContract]
internal sealed class MotionInfo
{
public int Index;
public Signal Kind;
[DataMember(Name = "target", IsRequired = true)]
public string Target { get; set; }
[DataMember(Name = "signal", IsRequired = true)]
public string Signal { get; set; }
[DataMember(Name = "position")]
public float[] Position { get; set; }
[DataMember(Name = "rotation")]
public float[] Rotation { get; set; }
}
internal struct Vertex
{
public float X;
public float Y;
public float Z;
public float Nx;
public float Ny;
public float Nz;
public float U;
public float V;
public byte B0;
public byte B1;
public byte B2;
public byte B3;
public float W0;
public float W1;
public float W2;
public float W3;
}
internal sealed class ModelPack
{
public PackInfo Info;
public Vertex[] Vertices;
public int[] Indices;
public byte[] Texture;
public static ModelPack Load(string directory)
{
//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_0038: Expected O, but got Unknown
//IL_0033: Unknown result type (might be due to invalid IL or missing references)
ModelPack modelPack = new ModelPack();
using (FileStream fileStream = Open(directory, "model.json", 1048576L))
{
modelPack.Info = (PackInfo)((XmlObjectSerializer)new DataContractJsonSerializer(typeof(PackInfo), new DataContractJsonSerializerSettings
{
MaxItemsInObjectGraph = 20000
})).ReadObject((Stream)fileStream);
}
modelPack.ValidateInfo();
using (FileStream stream = Open(directory, "mesh.bin.gz", 33554432L))
{
using GZipStream input = new GZipStream(stream, CompressionMode.Decompress);
using BinaryReader reader = new BinaryReader(input);
modelPack.ReadMesh(reader);
}
using (FileStream fileStream2 = Open(directory, "texture.png", 67108864L))
{
using BinaryReader binaryReader = new BinaryReader(fileStream2);
modelPack.Texture = binaryReader.ReadBytes((int)fileStream2.Length);
}
modelPack.ValidateTexture();
return modelPack;
}
private static FileStream Open(string directory, string name, long limit)
{
string path = Path.Combine(directory, name);
Require((File.GetAttributes(path) & FileAttributes.ReparsePoint) == 0, "Asset must be a regular file: " + name);
FileStream fileStream = File.OpenRead(path);
if (fileStream.Length > 0 && fileStream.Length <= limit)
{
return fileStream;
}
fileStream.Dispose();
throw new InvalidDataException("Asset size limit exceeded or empty: " + name);
}
private static void Require(bool condition, string message)
{
if (!condition)
{
throw new InvalidDataException(message);
}
}
private static bool Finite(float value)
{
if (!float.IsNaN(value))
{
return !float.IsInfinity(value);
}
return false;
}
private static void Range(float value, float min, float max, string name)
{
Require(Finite(value) && value >= min && value <= max, "Invalid " + name);
}
private static float[] Vector(float[] value, bool required = false)
{
if (value == null && !required)
{
return new float[3];
}
Require(value != null && value.Length == 3, "Expected a three-component vector");
for (int i = 0; i < value.Length; i++)
{
Range(value[i], -1000f, 1000f, "vector component");
}
return value;
}
private void ValidateInfo()
{
Require(Info != null && Info.Format == 1, "Unsupported model format");
Require(!string.IsNullOrWhiteSpace(Info.Name) && !string.IsNullOrWhiteSpace(Info.Author) && !string.IsNullOrWhiteSpace(Info.License), "Model name, author and license are required");
Range(Info.Scale, 0.001f, 100f, "scale");
Range(Info.BoundsPadding, 0f, 100f, "bounds padding");
Info.Offset = Vector(Info.Offset);
Info.Rotation = Vector(Info.Rotation);
Info.Material = Info.Material ?? new MaterialInfo();
Range(Info.Material.Smoothness, 0f, 1f, "smoothness");
Range(Info.Material.Metallic, 0f, 1f, "metallic");
Range(Info.Material.Emission, 0f, 2f, "emission");
Require(Info.Bones != null && Info.Bones.Length >= 1 && Info.Bones.Length <= 256, "Bone count must be 1..256");
Dictionary<string, int> dictionary = new Dictionary<string, int>(StringComparer.Ordinal);
for (int i = 0; i < Info.Bones.Length; i++)
{
BoneInfo boneInfo = Info.Bones[i];
Require(boneInfo != null && !string.IsNullOrWhiteSpace(boneInfo.Name) && boneInfo.Name.Length <= 128 && boneInfo.Name != "$root" && !dictionary.ContainsKey(boneInfo.Name), "Invalid or duplicate bone name");
Require(boneInfo.Parent >= -1 && boneInfo.Parent < i, "Bone parents must precede children");
boneInfo.Position = Vector(boneInfo.Position, required: true);
dictionary.Add(boneInfo.Name, i);
}
dictionary.Add("$root", Info.Bones.Length);
Info.Motions = Info.Motions ?? Array.Empty<MotionInfo>();
Require(Info.Motions.Length <= 1024, "Too many motion bindings");
MotionInfo[] motions = Info.Motions;
foreach (MotionInfo motionInfo in motions)
{
Require(motionInfo != null && motionInfo.Target != null && dictionary.TryGetValue(motionInfo.Target, out motionInfo.Index), "Unknown motion target");
Require(Enum.TryParse<Signal>(motionInfo.Signal, out motionInfo.Kind) && Enum.GetName(typeof(Signal), motionInfo.Kind) == motionInfo.Signal, "Unknown motion signal");
motionInfo.Position = Vector(motionInfo.Position);
motionInfo.Rotation = Vector(motionInfo.Rotation);
}
}
private static float ReadFloat(BinaryReader reader)
{
float num = reader.ReadSingle();
Require(Finite(num), "Non-finite mesh value");
return num;
}
private void ReadMesh(BinaryReader reader)
{
Require(reader.ReadUInt32() == 1145918025 && reader.ReadInt32() == 1, "Unsupported mesh format");
int num = reader.ReadInt32();
int num2 = reader.ReadInt32();
Require(num >= 3 && num <= 250000 && num2 >= 3 && num2 <= 1500000 && num2 % 3 == 0, "Mesh size limit exceeded");
Vertices = new Vertex[num];
for (int i = 0; i < num; i++)
{
Vertex vertex = new Vertex
{
X = ReadFloat(reader),
Y = ReadFloat(reader),
Z = ReadFloat(reader),
Nx = ReadFloat(reader),
Ny = ReadFloat(reader),
Nz = ReadFloat(reader),
U = ReadFloat(reader),
V = ReadFloat(reader),
B0 = reader.ReadByte(),
B1 = reader.ReadByte(),
B2 = reader.ReadByte(),
B3 = reader.ReadByte(),
W0 = ReadFloat(reader),
W1 = ReadFloat(reader),
W2 = ReadFloat(reader),
W3 = ReadFloat(reader)
};
Require(Math.Abs(vertex.X) <= 1000f && Math.Abs(vertex.Y) <= 1000f && Math.Abs(vertex.Z) <= 1000f, "Mesh coordinate out of range");
Require(Math.Abs(vertex.Nx * vertex.Nx + vertex.Ny * vertex.Ny + vertex.Nz * vertex.Nz - 1f) < 0.01f, "Mesh normals must be unit length");
Require(vertex.U >= 0f && vertex.U <= 1f && vertex.V >= 0f && vertex.V <= 1f, "Atlas UV out of range");
Require(vertex.B0 < Info.Bones.Length && vertex.B1 < Info.Bones.Length && vertex.B2 < Info.Bones.Length && vertex.B3 < Info.Bones.Length, "Mesh bone index out of range");
Require(vertex.W0 >= vertex.W1 && vertex.W1 >= vertex.W2 && vertex.W2 >= vertex.W3 && vertex.W3 >= 0f && Math.Abs(vertex.W0 + vertex.W1 + vertex.W2 + vertex.W3 - 1f) < 1E-05f, "Skin weights must be sorted and normalized");
Vertices[i] = vertex;
}
Indices = new int[num2];
for (int j = 0; j < num2; j++)
{
Indices[j] = reader.ReadInt32();
Require(Indices[j] >= 0 && Indices[j] < num, "Triangle index out of range");
}
Require(reader.BaseStream.ReadByte() == -1, "Unexpected trailing mesh data");
}
private void ValidateTexture()
{
byte[] array = new byte[16]
{
137, 80, 78, 71, 13, 10, 26, 10, 0, 0,
0, 13, 73, 72, 68, 82
};
Require(Texture.Length >= 33, "Truncated PNG");
for (int i = 0; i < array.Length; i++)
{
Require(Texture[i] == array[i], "Expected PNG with IHDR");
}
uint num = BigEndian(16);
uint num2 = BigEndian(20);
Require(num != 0 && num2 != 0 && num <= 8192 && num2 <= 8192 && (ulong)((long)num * (long)num2) <= 16777216uL, "Texture exceeds 16 megapixels");
}
private uint BigEndian(int at)
{
return (uint)((Texture[at] << 24) | (Texture[at + 1] << 16) | (Texture[at + 2] << 8) | Texture[at + 3]);
}
}
internal enum Signal
{
Constant,
Stride,
Step,
LeftStep,
RightStep,
Air,
Sail
}
internal struct Motion
{
private float stride;
private float air;
private float sail;
public static Motion Sample(double phase, float run, float air, float sail)
{
return new Motion
{
stride = (float)Math.Sin(phase) * run * (1f - air),
air = air,
sail = sail
};
}
public float Get(Signal signal)
{
return signal switch
{
Signal.Constant => 1f,
Signal.Stride => stride,
Signal.Step => Math.Abs(stride),
Signal.LeftStep => Math.Max(0f, stride),
Signal.RightStep => Math.Max(0f, 0f - stride),
Signal.Air => air,
Signal.Sail => sail,
_ => throw new ArgumentOutOfRangeException("signal"),
};
}
}
[BepInPlugin("org.fyyy.icarusmodelreplacement", "Icarus Model Replacement", "1.0.0")]
public sealed class Plugin : BaseUnityPlugin
{
private struct HiddenRenderer
{
private Renderer renderer;
private bool wasHidden;
public void Set(Renderer next)
{
if (!((Object)(object)renderer == (Object)(object)next))
{
if ((Object)(object)renderer != (Object)null)
{
renderer.forceRenderingOff = wasHidden;
}
renderer = next;
if ((Object)(object)renderer != (Object)null)
{
wasHidden = renderer.forceRenderingOff;
renderer.forceRenderingOff = true;
}
}
}
}
private const string Builtin = "builtin";
private MechaArmorModel armor;
private Model model;
private ConfigEntry<string> modelDirectory;
private string selected;
private HiddenRenderer[] parts = Array.Empty<HiddenRenderer>();
private HiddenRenderer[] bones = Array.Empty<HiddenRenderer>();
private HiddenRenderer[] wrecks = Array.Empty<HiddenRenderer>();
private GameObject wreckageGroup;
private void Awake()
{
modelDirectory = ((BaseUnityPlugin)this).Config.Bind<string>("Model", "Directory", "builtin", "builtin uses the included Gugugaga. Otherwise, a model folder relative to BepInEx/plugins or absolute. Empty keeps vanilla Icarus. Changes apply in game.");
}
private void LateUpdate()
{
Player val = (GameMain.isRunning ? GameMain.mainPlayer : null);
MechaArmorModel val2 = ((val != null) ? val.mechaArmorModel : null);
if ((Object)(object)val2 != (Object)null && !((ManualBehaviour)val2).inited)
{
val2 = null;
}
string text = modelDirectory.Value.Trim();
if (armor != val2 || selected != text)
{
Clear();
armor = val2;
selected = text;
if ((Object)(object)armor != (Object)null && text.Length != 0)
{
try
{
SkinnedMeshRenderer[] componentsInChildren = ((Component)armor).GetComponentsInChildren<SkinnedMeshRenderer>(true);
ModelPack modelPack = ModelPack.Load((text == "builtin") ? Path.Combine(Path.GetDirectoryName(((BaseUnityPlugin)this).Info.Location), "model") : Path.Combine(Paths.PluginPath, text));
model = new Model(modelPack, val.controller.model, ((Component)armor).gameObject.layer);
Renderer[] renderers = (Renderer[])(object)componentsInChildren;
parts = Hide(renderers);
bones = new HiddenRenderer[armor.boneModels.Length];
((BaseUnityPlugin)this).Logger.LogInfo((object)("Model attached: " + modelPack.Info.Name + " by " + modelPack.Info.Author + " (" + modelPack.Info.License + ")."));
}
catch (Exception arg)
{
Clear();
((BaseUnityPlugin)this).Logger.LogError((object)$"Cannot load model '{text}'; keeping Icarus. {arg}");
return;
}
}
}
if ((Object)(object)armor == (Object)null || model == null)
{
return;
}
for (int i = 0; i < bones.Length; i++)
{
bones[i].Set((Renderer)(object)armor.boneModels[i]?.meshRenderer);
}
if ((Object)(object)wreckageGroup != (Object)(object)armor.wreckageGroup)
{
Restore(wrecks);
wreckageGroup = armor.wreckageGroup;
HiddenRenderer[] array;
if (!((Object)(object)wreckageGroup != (Object)null))
{
array = Array.Empty<HiddenRenderer>();
}
else
{
Renderer[] renderers = (Renderer[])(object)wreckageGroup.GetComponentsInChildren<MeshRenderer>(true);
array = Hide(renderers);
}
wrecks = array;
}
model.Root.SetActive(((ManualBehaviour)armor).active && val.isAlive);
model.UpdateLighting();
PlayerAnimator animator = val.animator;
if (!((TrackedReference)(object)animator.run_slow == (TrackedReference)null))
{
float air = Mathf.Clamp01(animator.driftWeight + animator.flyWeight + animator.sailWeight);
Motion state = Motion.Sample((double)animator.run_slow.normalizedTime * Math.PI * 2.0, Mathf.Clamp01(animator.runWeight), air, Mathf.Clamp01(animator.sailWeight));
model.Animate(state);
}
}
private static HiddenRenderer[] Hide(Renderer[] renderers)
{
HiddenRenderer[] array = new HiddenRenderer[renderers.Length];
for (int i = 0; i < array.Length; i++)
{
array[i].Set(renderers[i]);
}
return array;
}
private static void Restore(HiddenRenderer[] renderers)
{
for (int i = 0; i < renderers.Length; i++)
{
renderers[i].Set(null);
}
}
private void OnDisable()
{
Clear();
armor = null;
}
private void Clear()
{
Restore(parts);
Restore(bones);
Restore(wrecks);
parts = (bones = (wrecks = Array.Empty<HiddenRenderer>()));
model?.Dispose();
model = null;
wreckageGroup = null;
}
}
}
