using System;
using System.Collections.Generic;
using System.Globalization;
using System.IO;
using System.IO.Compression;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Text;
using BepInEx;
using UnityEngine;
using UnityEngine.Rendering;
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: AssemblyVersion("0.0.0.0")]
namespace HtfModelKit;
public abstract class AssetSource
{
private sealed class DiskSource : AssetSource
{
private readonly string _dir;
public override string Describe => _dir;
public DiskSource(string dir)
{
_dir = dir;
}
public override byte[] Read(string relative)
{
if (string.IsNullOrEmpty(_dir))
{
return null;
}
try
{
string path = _dir + "/" + relative;
return (!File.Exists(path)) ? null : File.ReadAllBytes(path);
}
catch (Exception e)
{
Kit.Ex("AssetSource.Folder(" + relative + ")", e);
return null;
}
}
}
private sealed class ResourceSource : AssetSource
{
private readonly Assembly _asm;
private readonly string _prefix;
public override string Describe => "built into " + ((!(_asm == null)) ? _asm.GetName().Name : "?");
public ResourceSource(Assembly asm, string prefix)
{
_asm = asm;
_prefix = prefix ?? "";
}
public override byte[] Read(string relative)
{
if (_asm == null)
{
return null;
}
try
{
string name = _prefix + relative.Replace('/', '.');
using Stream stream = _asm.GetManifestResourceStream(name);
if (stream == null)
{
return null;
}
byte[] array = new byte[stream.Length];
int num;
for (int i = 0; i < array.Length; i += num)
{
num = stream.Read(array, i, array.Length - i);
if (num <= 0)
{
break;
}
}
return array;
}
catch (Exception e)
{
Kit.Ex("AssetSource.Embedded(" + relative + ")", e);
return null;
}
}
}
private sealed class Chain : AssetSource
{
private readonly AssetSource _first;
private readonly AssetSource _second;
public override string Describe => _first.Describe + " then " + _second.Describe;
public Chain(AssetSource a, AssetSource b)
{
_first = a;
_second = b;
}
public override byte[] Read(string relative)
{
byte[] array = _first.Read(relative);
return array ?? _second.Read(relative);
}
public override byte[] ReadOrInflate(string relative)
{
byte[] array = _first.ReadOrInflate(relative);
return array ?? _second.ReadOrInflate(relative);
}
}
public abstract string Describe { get; }
public abstract byte[] Read(string relative);
public AssetSource Then(AssetSource fallback)
{
return (fallback != null) ? new Chain(this, fallback) : this;
}
public static AssetSource Folder(string path)
{
return new DiskSource(path);
}
public static AssetSource Embedded(Assembly assembly, string prefix)
{
return new ResourceSource(assembly, prefix);
}
public virtual byte[] ReadOrInflate(string relative)
{
byte[] array = Read(relative);
if (array != null)
{
return array;
}
return Inflate(Read(relative + ".gz"));
}
public string ReadText(string relative)
{
byte[] array = ReadOrInflate(relative);
if (array == null)
{
return null;
}
try
{
return new UTF8Encoding(encoderShouldEmitUTF8Identifier: false).GetString(array);
}
catch (Exception e)
{
Kit.Ex("AssetSource.ReadText(" + relative + ")", e);
return null;
}
}
public bool Has(string relative)
{
return ReadOrInflate(relative) != null;
}
internal static byte[] Inflate(byte[] compressed)
{
if (compressed == null)
{
return null;
}
try
{
using MemoryStream stream = new MemoryStream(compressed);
using GZipStream gZipStream = new GZipStream(stream, CompressionMode.Decompress);
using MemoryStream memoryStream = new MemoryStream();
byte[] array = new byte[16384];
int count;
while ((count = gZipStream.Read(array, 0, array.Length)) > 0)
{
memoryStream.Write(array, 0, count);
}
return memoryStream.ToArray();
}
catch (Exception ex)
{
Kit.Warn("could not decompress an asset: " + ex.Message);
return null;
}
}
}
public static class Kit
{
public const string Tag = "[ModelKit] ";
private static Action<string> _info;
private static Action<string> _warn;
public static void UseLogger(Action<string> info, Action<string> warn)
{
_info = info;
_warn = warn;
}
public static void Info(string message)
{
try
{
if (_info != null)
{
_info(message);
}
else
{
Debug.Log((object)("[ModelKit] " + message));
}
}
catch
{
}
}
public static void Warn(string message)
{
try
{
if (_warn != null)
{
_warn(message);
}
else
{
Debug.LogWarning((object)("[ModelKit] " + message));
}
}
catch
{
}
}
public static void Ex(string where, Exception e)
{
try
{
Warn(where + " failed: " + ((e != null) ? (e.GetType().Name + ": " + e.Message) : "(no detail)"));
}
catch
{
}
}
}
public static class Materials
{
private static readonly string[] PlainShaders = new string[6] { "Universal Render Pipeline/Lit", "Universal Render Pipeline/Simple Lit", "Universal Render Pipeline/Baked Lit", "Universal Render Pipeline/Unlit", "Standard", "Legacy Shaders/Diffuse" };
private static Shader _plain;
private static bool _plainTried;
public static Shader PlainShader()
{
if (_plainTried)
{
return _plain;
}
_plainTried = true;
for (int i = 0; i < PlainShaders.Length; i++)
{
if (!((Object)(object)_plain == (Object)null))
{
break;
}
try
{
_plain = Shader.Find(PlainShaders[i]);
}
catch
{
}
}
if ((Object)(object)_plain == (Object)null)
{
Kit.Warn("no plain lit shader was found in this build; materials will be cloned as-is");
}
return _plain;
}
public static bool IsPlainShader(Shader s)
{
if ((Object)(object)s == (Object)null)
{
return false;
}
for (int i = 0; i < PlainShaders.Length; i++)
{
if (((Object)s).name == PlainShaders[i])
{
return true;
}
}
return false;
}
public static Material FindTemplate(GameObject drawnByTheGame)
{
//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
//IL_00d2: Expected O, but got Unknown
Material val = null;
try
{
if ((Object)(object)drawnByTheGame != (Object)null)
{
Renderer[] componentsInChildren = drawnByTheGame.GetComponentsInChildren<Renderer>(true);
foreach (Renderer val2 in componentsInChildren)
{
Material val3 = ((!((Object)(object)val2 == (Object)null)) ? val2.sharedMaterial : null);
if (!((Object)(object)val3 == (Object)null))
{
if ((Object)(object)val == (Object)null)
{
val = val3;
}
if (IsPlainShader(val3.shader))
{
return val3;
}
}
}
}
}
catch (Exception e)
{
Kit.Ex("Materials.FindTemplate", e);
}
Shader val4 = PlainShader();
if ((Object)(object)val4 != (Object)null)
{
Kit.Info("no plain-shaded material to copy, so one was built from '" + ((Object)val4).name + "'");
return new Material(val4);
}
return val;
}
public static Material[] Build(ModelData model, Material template, bool calm)
{
//IL_0048: Unknown result type (might be due to invalid IL or missing references)
//IL_004f: Expected O, but got Unknown
//IL_0065: Unknown result type (might be due to invalid IL or missing references)
//IL_006b: Expected O, but got Unknown
//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
//IL_01bb: Unknown result type (might be due to invalid IL or missing references)
if (model == null || model.MaterialNames == null)
{
return (Material[])(object)new Material[0];
}
if ((Object)(object)template == (Object)null)
{
Shader val = PlainShader();
if ((Object)(object)val == (Object)null)
{
Kit.Warn("no template and no plain shader; cannot build materials");
return (Material[])(object)new Material[0];
}
template = new Material(val);
}
Material[] array = (Material[])(object)new Material[model.MaterialNames.Length];
for (int i = 0; i < array.Length; i++)
{
Material val2 = new Material(template);
((Object)val2).name = "ModelKit_" + model.MaterialNames[i];
if (calm)
{
Calm(val2);
}
if ((Object)(object)model.Textures[i] != (Object)null)
{
SetTexture(val2, (Texture)(object)model.Textures[i]);
SetColor(val2, Color.white);
if (model.Cutout[i])
{
EnableCutout(val2);
}
}
else
{
SetTexture(val2, (Texture)(object)Texture2D.whiteTexture);
SetColor(val2, model.Colors[i]);
}
array[i] = val2;
Texture val3 = (Texture)(object)model.Textures[i];
Kit.Info(" material " + (i + 1) + "/" + array.Length + " '" + model.MaterialNames[i] + "': " + ((!((Object)(object)val3 != (Object)null)) ? ("NO TEXTURE - drawn flat in " + ColorHex(model.Colors[i])) : ("texture " + ((Object)val3).name + " " + val3.width + "x" + val3.height)) + ((!model.Cutout[i]) ? "" : " (cutout)"));
}
return array;
}
public static void SetTexture(Material m, Texture tex)
{
if (!((Object)(object)m == (Object)null))
{
if (m.HasProperty("_BaseMap"))
{
m.SetTexture("_BaseMap", tex);
}
if (m.HasProperty("_MainTex"))
{
m.SetTexture("_MainTex", tex);
}
m.mainTexture = tex;
}
}
public static void SetColor(Material m, Color c)
{
//IL_0023: 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)
if (!((Object)(object)m == (Object)null))
{
if (m.HasProperty("_BaseColor"))
{
m.SetColor("_BaseColor", c);
}
if (m.HasProperty("_Color"))
{
m.SetColor("_Color", c);
}
}
}
public static void Calm(Material m)
{
//IL_002e: Unknown result type (might be due to invalid IL or missing references)
//IL_0071: Unknown result type (might be due to invalid IL or missing references)
//IL_0091: Unknown result type (might be due to invalid IL or missing references)
if ((Object)(object)m == (Object)null)
{
return;
}
try
{
m.DisableKeyword("_EMISSION");
if (m.HasProperty("_EmissionColor"))
{
m.SetColor("_EmissionColor", Color.black);
}
if (m.HasProperty("_EmissionMap"))
{
m.SetTexture("_EmissionMap", (Texture)null);
}
m.globalIlluminationFlags = (MaterialGlobalIlluminationFlags)4;
if (m.HasProperty("_MainTex"))
{
m.SetTextureOffset("_MainTex", Vector2.zero);
}
if (m.HasProperty("_BaseMap"))
{
m.SetTextureOffset("_BaseMap", Vector2.zero);
}
if (m.HasProperty("_Metallic"))
{
m.SetFloat("_Metallic", 0f);
}
if (m.HasProperty("_Smoothness"))
{
m.SetFloat("_Smoothness", 0.1f);
}
if (m.HasProperty("_Glossiness"))
{
m.SetFloat("_Glossiness", 0.1f);
}
string[] array = new string[9] { "_BumpMap", "_NormalMap", "_MetallicGlossMap", "_SpecGlossMap", "_ParallaxMap", "_OcclusionMap", "_DetailAlbedoMap", "_DetailNormalMap", "_DetailMask" };
for (int i = 0; i < array.Length; i++)
{
if (m.HasProperty(array[i]))
{
m.SetTexture(array[i], (Texture)null);
}
}
}
catch (Exception e)
{
Kit.Ex("Materials.Calm", e);
}
}
public static void EnableCutout(Material m)
{
if ((Object)(object)m == (Object)null)
{
return;
}
try
{
m.EnableKeyword("_ALPHATEST_ON");
if (m.HasProperty("_Cutoff"))
{
m.SetFloat("_Cutoff", 0.5f);
}
if (m.HasProperty("_AlphaClip"))
{
m.SetFloat("_AlphaClip", 1f);
}
if (m.HasProperty("_Surface"))
{
m.SetFloat("_Surface", 0f);
}
m.renderQueue = 2450;
}
catch (Exception e)
{
Kit.Ex("Materials.EnableCutout", e);
}
}
public static void Describe(Material m)
{
try
{
if ((Object)(object)m == (Object)null || (Object)(object)m.shader == (Object)null)
{
Kit.Info("no template material");
return;
}
StringBuilder stringBuilder = new StringBuilder();
stringBuilder.Append("template shader '").Append(((Object)m.shader).name).Append("'");
if (m.HasProperty("_Metallic"))
{
stringBuilder.Append(", metallic ").Append(m.GetFloat("_Metallic").ToString("0.##"));
}
if (m.HasProperty("_Smoothness"))
{
stringBuilder.Append(", smoothness ").Append(m.GetFloat("_Smoothness").ToString("0.##"));
}
if (m.HasProperty("_BumpMap") && (Object)(object)m.GetTexture("_BumpMap") != (Object)null)
{
stringBuilder.Append(", bump map");
}
if (m.HasProperty("_MetallicGlossMap") && (Object)(object)m.GetTexture("_MetallicGlossMap") != (Object)null)
{
stringBuilder.Append(", metallic map");
}
if (m.IsKeywordEnabled("_EMISSION"))
{
stringBuilder.Append(", emission ON");
}
Kit.Info(stringBuilder.ToString());
}
catch (Exception e)
{
Kit.Ex("Materials.Describe", e);
}
}
private static string ColorHex(Color c)
{
return "#" + Mathf.RoundToInt(c.r * 255f).ToString("X2") + Mathf.RoundToInt(c.g * 255f).ToString("X2") + Mathf.RoundToInt(c.b * 255f).ToString("X2");
}
}
public sealed class ModelData
{
public Mesh Mesh;
public string[] MaterialNames;
public Texture2D[] Textures;
public Color[] Colors;
public bool[] Cutout;
public string Source;
public int SubMeshCount => (MaterialNames != null) ? MaterialNames.Length : 0;
}
public static class ModelKit
{
public const string Version = "1.0.1";
private static readonly Dictionary<string, ModelData> _cache = new Dictionary<string, ModelData>();
public static void UseLogger(Action<string> info, Action<string> warn)
{
Kit.UseLogger(info, warn);
}
public static ModelData Load(string objName, AssetSource source)
{
return Load(objName, source, null);
}
public static ModelData Load(string objName, AssetSource source, TextureOptions textures)
{
if (string.IsNullOrEmpty(objName))
{
return null;
}
if (_cache.TryGetValue(objName, out var value))
{
return value;
}
ModelData modelData = ObjParser.Load(objName, source, textures);
_cache[objName] = modelData;
return modelData;
}
public static void Forget(string objName)
{
if (objName == null)
{
_cache.Clear();
}
else
{
_cache.Remove(objName);
}
}
public static bool Available(string objName, AssetSource source)
{
return source?.Has(objName) ?? false;
}
public static GameObject[] Attach(GameObject target, ModelData model, Material template)
{
return Attach(target, model, template, calmMaterials: true);
}
public static GameObject[] Attach(GameObject target, ModelData model, Material template, bool calmMaterials)
{
//IL_0070: Unknown result type (might be due to invalid IL or missing references)
//IL_0076: Expected O, but got Unknown
//IL_008e: Unknown result type (might be due to invalid IL or missing references)
//IL_009e: 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)
if ((Object)(object)target == (Object)null || model == null || (Object)(object)model.Mesh == (Object)null)
{
return (GameObject[])(object)new GameObject[0];
}
try
{
if ((Object)(object)template == (Object)null)
{
template = Materials.FindTemplate(target);
}
Material[] array = Materials.Build(model, template, calmMaterials);
if (array.Length == 0)
{
return (GameObject[])(object)new GameObject[0];
}
GameObject val = new GameObject("ModelKit_" + ((Object)model.Mesh).name);
val.transform.SetParent(target.transform, false);
val.transform.localPosition = Vector3.zero;
val.transform.localRotation = Quaternion.identity;
val.transform.localScale = Vector3.one;
val.layer = target.layer;
MeshFilter val2 = val.AddComponent<MeshFilter>();
val2.sharedMesh = model.Mesh;
MeshRenderer val3 = val.AddComponent<MeshRenderer>();
((Renderer)val3).sharedMaterials = array;
return (GameObject[])(object)new GameObject[1] { val };
}
catch (Exception e)
{
Kit.Ex("ModelKit.Attach", e);
return (GameObject[])(object)new GameObject[0];
}
}
public static GameObject[] Replace(GameObject target, string objName, AssetSource source)
{
return Replace(target, objName, source, null, calmMaterials: true);
}
public static GameObject[] Replace(GameObject target, string objName, AssetSource source, TextureOptions textures, bool calmMaterials)
{
if ((Object)(object)target == (Object)null)
{
return (GameObject[])(object)new GameObject[0];
}
ModelData modelData = Load(objName, source, textures);
if (modelData == null)
{
return (GameObject[])(object)new GameObject[0];
}
try
{
Material template = Materials.FindTemplate(target);
GameObject[] array = Attach(target, modelData, template, calmMaterials);
if (array.Length == 0)
{
return array;
}
Hide(target, array);
return array;
}
catch (Exception e)
{
Kit.Ex("ModelKit.Replace(" + objName + ")", e);
return (GameObject[])(object)new GameObject[0];
}
}
public static void Hide(GameObject target, GameObject[] keep)
{
if ((Object)(object)target == (Object)null)
{
return;
}
try
{
Renderer[] componentsInChildren = target.GetComponentsInChildren<Renderer>(true);
foreach (Renderer val in componentsInChildren)
{
if ((Object)(object)val == (Object)null)
{
continue;
}
bool flag = false;
if (keep != null)
{
for (int j = 0; j < keep.Length; j++)
{
if (flag)
{
break;
}
if ((Object)(object)keep[j] != (Object)null && ((Component)val).transform.IsChildOf(keep[j].transform))
{
flag = true;
}
}
}
if (!flag)
{
val.enabled = false;
}
}
}
catch (Exception e)
{
Kit.Ex("ModelKit.Hide", e);
}
}
public static void Place(GameObject[] parts, float scale, float yaw, float heightOffset)
{
//IL_002b: 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_005c: 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)
if (parts == null)
{
return;
}
for (int i = 0; i < parts.Length; i++)
{
if (!((Object)(object)parts[i] == (Object)null))
{
try
{
Transform transform = parts[i].transform;
transform.localScale = Vector3.one * ((!(scale <= 0f)) ? scale : 1f);
transform.localRotation = Quaternion.Euler(0f, yaw, 0f);
transform.localPosition = new Vector3(0f, heightOffset, 0f);
}
catch (Exception e)
{
Kit.Ex("ModelKit.Place", e);
}
}
}
}
public static Bounds BoundsOf(GameObject[] parts)
{
//IL_0002: 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)
//IL_0019: 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_007e: 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)
Bounds bounds = default(Bounds);
((Bounds)(ref bounds))..ctor(Vector3.zero, Vector3.zero);
bool flag = false;
if (parts == null)
{
return bounds;
}
foreach (GameObject val in parts)
{
if ((Object)(object)val == (Object)null)
{
continue;
}
Renderer[] componentsInChildren = val.GetComponentsInChildren<Renderer>(true);
foreach (Renderer val2 in componentsInChildren)
{
if (!((Object)(object)val2 == (Object)null))
{
if (!flag)
{
bounds = val2.bounds;
flag = true;
}
else
{
((Bounds)(ref bounds)).Encapsulate(val2.bounds);
}
}
}
}
return bounds;
}
}
public static class ObjParser
{
private static readonly char[] Space = new char[2] { ' ', '\t' };
private static readonly char[] Slashes = new char[2] { '/', '\\' };
private static float F(string s)
{
float result;
return (!float.TryParse(s, NumberStyles.Float, CultureInfo.InvariantCulture, out result)) ? 0f : result;
}
private static int Index(string s, int count)
{
if (!int.TryParse(s, NumberStyles.Integer, CultureInfo.InvariantCulture, out var result))
{
return -1;
}
if (result > 0)
{
return result - 1;
}
if (result < 0)
{
return count + result;
}
return -1;
}
public static ModelData Load(string objName, AssetSource source, TextureOptions textures)
{
if (source == null)
{
Kit.Warn("no asset source was given for '" + objName + "'");
return null;
}
string text = source.ReadText(objName);
if (text == null)
{
Kit.Info("'" + objName + "' was not found in " + source.Describe);
return null;
}
try
{
return Parse(text, objName, source, textures ?? TextureOptions.Default);
}
catch (Exception e)
{
Kit.Ex("ObjParser.Load(" + objName + ")", e);
return null;
}
}
private static ModelData Parse(string text, string objName, AssetSource source, TextureOptions texOpts)
{
//IL_02a0: Unknown result type (might be due to invalid IL or missing references)
//IL_02a7: Expected O, but got Unknown
//IL_0143: Unknown result type (might be due to invalid IL or missing references)
//IL_0179: Unknown result type (might be due to invalid IL or missing references)
//IL_01a5: Unknown result type (might be due to invalid IL or missing references)
//IL_0447: Unknown result type (might be due to invalid IL or missing references)
//IL_044c: Unknown result type (might be due to invalid IL or missing references)
List<Vector3> list = new List<Vector3>();
List<Vector3> list2 = new List<Vector3>();
List<Vector2> list3 = new List<Vector2>();
List<Vector3> list4 = new List<Vector3>();
List<Vector3> list5 = new List<Vector3>();
List<Vector2> list6 = new List<Vector2>();
Dictionary<string, int> lookup = new Dictionary<string, int>();
List<List<int>> list7 = new List<List<int>>();
List<string> list8 = new List<string>();
List<int> list9 = null;
string text2 = null;
bool missingNormals = false;
string[] array = text.Split('\n');
foreach (string text3 in array)
{
string text4 = text3.Trim();
if (text4.Length == 0 || text4[0] == '#')
{
continue;
}
string[] array2 = text4.Split(Space, StringSplitOptions.RemoveEmptyEntries);
if (array2.Length == 0)
{
continue;
}
switch (array2[0])
{
case "v":
if (array2.Length >= 4)
{
list.Add(new Vector3(0f - F(array2[1]), F(array2[2]), F(array2[3])));
}
break;
case "vn":
if (array2.Length >= 4)
{
list2.Add(new Vector3(0f - F(array2[1]), F(array2[2]), F(array2[3])));
}
break;
case "vt":
if (array2.Length >= 3)
{
list3.Add(new Vector2(F(array2[1]), F(array2[2])));
}
break;
case "mtllib":
if (array2.Length >= 2)
{
text2 = array2[1];
}
break;
case "usemtl":
{
string item = ((array2.Length < 2) ? "default" : array2[1]);
int num = list8.IndexOf(item);
if (num >= 0)
{
list9 = list7[num];
break;
}
list9 = new List<int>();
list7.Add(list9);
list8.Add(item);
break;
}
case "f":
if (list9 == null)
{
list9 = new List<int>();
list7.Add(list9);
list8.Add("default");
}
AddFace(array2, list, list2, list3, list4, list5, list6, lookup, list9, ref missingNormals);
break;
}
}
if (list4.Count == 0 || list7.Count == 0)
{
Kit.Warn("'" + objName + "' has no faces that can be drawn");
return null;
}
Mesh val = new Mesh();
((Object)val).name = objName;
val.indexFormat = (IndexFormat)(list4.Count > 65000);
val.SetVertices(list4);
bool flag = !missingNormals && list5.Count == list4.Count;
if (flag)
{
val.SetNormals(list5);
}
if (list6.Count == list4.Count)
{
val.SetUVs(0, list6);
}
List<int> list10 = new List<int>();
for (int j = 0; j < list7.Count; j++)
{
if (list7[j].Count > 0)
{
list10.Add(j);
}
}
val.subMeshCount = list10.Count;
string[] array3 = new string[list10.Count];
for (int k = 0; k < list10.Count; k++)
{
val.SetTriangles(list7[list10[k]], k);
array3[k] = list8[list10[k]];
}
if (!flag)
{
val.RecalculateNormals();
}
val.RecalculateBounds();
ModelData modelData = new ModelData();
modelData.Mesh = val;
modelData.MaterialNames = array3;
modelData.Textures = (Texture2D[])(object)new Texture2D[array3.Length];
modelData.Colors = (Color[])(object)new Color[array3.Length];
modelData.Cutout = new bool[array3.Length];
modelData.Source = source.Describe;
ModelData modelData2 = modelData;
for (int l = 0; l < array3.Length; l++)
{
ref Color reference = ref modelData2.Colors[l];
reference = Color.white;
}
if (text2 != null)
{
ApplyMtl(modelData2, text2, objName, source, texOpts);
}
Kit.Info("loaded '" + objName + "': " + list4.Count + " vertices, " + val.triangles.Length / 3 + " triangles, " + array3.Length + " material(s), from " + source.Describe + ((!flag) ? " (normals calculated - the file did not supply one for every vertex)" : ""));
return modelData2;
}
private static void AddFace(string[] p, List<Vector3> positions, List<Vector3> normals, List<Vector2> uvs, List<Vector3> outPos, List<Vector3> outNrm, List<Vector2> outUv, Dictionary<string, int> lookup, List<int> tris, ref bool missingNormals)
{
//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
//IL_012b: Unknown result type (might be due to invalid IL or missing references)
//IL_011a: Unknown result type (might be due to invalid IL or missing references)
int num = p.Length - 1;
if (num < 3)
{
return;
}
int[] array = new int[num];
for (int i = 0; i < num; i++)
{
string text = p[i + 1];
if (!lookup.TryGetValue(text, out var value))
{
string[] array2 = text.Split('/');
int num2 = Index(array2[0], positions.Count);
if (num2 < 0 || num2 >= positions.Count)
{
return;
}
int num3 = ((array2.Length <= 1 || array2[1].Length <= 0) ? (-1) : Index(array2[1], uvs.Count));
int num4 = ((array2.Length <= 2 || array2[2].Length <= 0) ? (-1) : Index(array2[2], normals.Count));
outPos.Add(positions[num2]);
outUv.Add((num3 < 0 || num3 >= uvs.Count) ? Vector2.zero : uvs[num3]);
if (num4 >= 0 && num4 < normals.Count)
{
outNrm.Add(normals[num4]);
}
else
{
outNrm.Add(Vector3.zero);
missingNormals = true;
}
value = (lookup[text] = outPos.Count - 1);
}
array[i] = value;
}
for (int j = 1; j < num - 1; j++)
{
tris.Add(array[0]);
tris.Add(array[j + 1]);
tris.Add(array[j]);
}
}
private static void ApplyMtl(ModelData model, string mtlName, string objName, AssetSource source, TextureOptions texOpts)
{
//IL_01b5: Unknown result type (might be due to invalid IL or missing references)
//IL_01b7: Unknown result type (might be due to invalid IL or missing references)
//IL_0164: Unknown result type (might be due to invalid IL or missing references)
string text = source.ReadText(mtlName);
if (text == null)
{
Kit.Info("'" + objName + "' names '" + mtlName + "' but it is not there; using plain colours");
return;
}
Dictionary<string, string> dictionary = new Dictionary<string, string>();
Dictionary<string, Color> dictionary2 = new Dictionary<string, Color>();
string text2 = null;
string[] array = text.Split('\n');
foreach (string text3 in array)
{
string text4 = text3.Trim();
if (text4.Length == 0 || text4[0] == '#')
{
continue;
}
string[] array2 = text4.Split(Space, StringSplitOptions.RemoveEmptyEntries);
if (array2.Length < 2)
{
continue;
}
if (array2[0] == "newmtl")
{
text2 = array2[1];
}
else
{
if (text2 == null)
{
continue;
}
if (array2[0] == "map_Kd")
{
string text5 = array2[^1];
int num = text5.LastIndexOfAny(Slashes);
if (num >= 0)
{
text5 = text5.Substring(num + 1);
}
dictionary[text2] = text5;
}
else if (array2[0] == "Kd" && array2.Length >= 4)
{
dictionary2[text2] = new Color(F(array2[1]), F(array2[2]), F(array2[3]), 1f);
}
}
}
Dictionary<string, Texture2D> dictionary3 = new Dictionary<string, Texture2D>();
for (int j = 0; j < model.MaterialNames.Length; j++)
{
string key = model.MaterialNames[j];
if (dictionary2.TryGetValue(key, out var value))
{
model.Colors[j] = value;
}
if (!dictionary.TryGetValue(key, out var value2))
{
continue;
}
if (!dictionary3.TryGetValue(value2, out var value3))
{
value3 = TextureLoader.Load(value2, source, texOpts);
if ((Object)(object)value3 == (Object)null)
{
Kit.Warn("the model asks for texture '" + value2 + "' but it could not be loaded - that surface will be drawn as a flat colour.");
}
dictionary3[value2] = value3;
}
model.Textures[j] = value3;
if ((Object)(object)value3 != (Object)null)
{
model.Cutout[j] = TextureLoader.HasHoles(value3);
}
}
}
}
public sealed class TextureOptions
{
public bool PointFilter = true;
public TextureWrapMode Wrap = (TextureWrapMode)0;
public bool Mipmaps = true;
public byte CutoutThreshold = 250;
public static TextureOptions Default => new TextureOptions();
}
public static class TextureLoader
{
public static Texture2D Load(string relative, AssetSource source, TextureOptions options)
{
//IL_0030: Unknown result type (might be due to invalid IL or missing references)
//IL_0036: Expected O, but got Unknown
//IL_0085: Unknown result type (might be due to invalid IL or missing references)
if (source == null)
{
return null;
}
options = options ?? TextureOptions.Default;
byte[] array = source.ReadOrInflate(relative);
if (array == null)
{
return null;
}
try
{
Texture2D val = new Texture2D(2, 2, (TextureFormat)4, options.Mipmaps);
if (!ImageConversion.LoadImage(val, array))
{
Object.Destroy((Object)(object)val);
Kit.Warn("'" + relative + "' is not an image that can be read");
return null;
}
((Object)val).name = relative;
((Texture)val).filterMode = (FilterMode)(!options.PointFilter);
((Texture)val).wrapMode = options.Wrap;
val.Apply(options.Mipmaps, false);
return val;
}
catch (Exception e)
{
Kit.Ex("TextureLoader.Load(" + relative + ")", e);
return null;
}
}
public static bool HasHoles(Texture2D tex)
{
return HasHoles(tex, 250);
}
public static bool HasHoles(Texture2D tex, byte threshold)
{
if ((Object)(object)tex == (Object)null)
{
return false;
}
try
{
Color32[] pixels = tex.GetPixels32();
for (int i = 0; i < pixels.Length; i++)
{
if (pixels[i].a < threshold)
{
return true;
}
}
return false;
}
catch
{
return false;
}
}
}
[BepInPlugin("com.htf.modelkit", "How To Fish - ModelKit", "1.0.1")]
public class ModelKitPlugin : BaseUnityPlugin
{
public const string Guid = "com.htf.modelkit";
private void Awake()
{
ModelKit.UseLogger(delegate(string m)
{
((BaseUnityPlugin)this).Logger.LogInfo((object)m);
}, delegate(string m)
{
((BaseUnityPlugin)this).Logger.LogWarning((object)m);
});
((BaseUnityPlugin)this).Logger.LogInfo((object)"ModelKit 1.0.1 ready. This is a library: it does nothing on its own.");
((BaseUnityPlugin)this).Logger.LogInfo((object)"Mods use it to load OBJ/MTL/PNG models without an AssetBundle, so a game update cannot invalidate their art.");
}
}
