using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using RandomPaintingSwap;
using UnityEngine;
using UnityEngine.SceneManagement;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("RandomPaintingSwap")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.1.0.0")]
[assembly: AssemblyInformationalVersion("1.1.0+ff6399ba9851f93138ba93ed9f826aa8c9d0ee43")]
[assembly: AssemblyProduct("Random Painting Swap")]
[assembly: AssemblyTitle("RandomPaintingSwap")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.1.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
internal sealed class EmbeddedAttribute : Attribute
{
}
}
namespace System.Runtime.CompilerServices
{
[CompilerGenerated]
[Microsoft.CodeAnalysis.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 AnotherRandomPaintingSwap
{
[BepInPlugin("phnod.randompaintingswap", "Another Random Painting Swap", "1.0.3")]
public class Plugin : BaseUnityPlugin
{
public class CustomPainting
{
public Material material;
public string textureName = "UNASSIGNED STRING";
}
public class ReplaceablePainting
{
public MeshRenderer meshRenderer;
}
public class PaintingGroup
{
public string paintingType;
public string paintingFolderName;
public HashSet<string> whitelistMaterials;
public List<CustomPainting> customPaintings;
public List<CustomPainting> unusedPaintings;
public Material baseMaterial;
public PaintingGroup(string InPaintingType, string InPaintingFolderName, HashSet<string> InWhitelistMaterials)
{
paintingType = InPaintingType;
paintingFolderName = InPaintingFolderName;
whitelistMaterials = InWhitelistMaterials;
customPaintings = new List<CustomPainting>();
unusedPaintings = new List<CustomPainting>();
}
}
[HarmonyPatch(typeof(LoadingUI), "LevelAnimationComplete")]
public class PatchLoadingUI
{
[HarmonyPostfix]
private static void Postfix()
{
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
Scene activeScene = SceneManager.GetActiveScene();
List<GameObject> list = ((Scene)(ref activeScene)).GetRootGameObjects().ToList();
DebugLog($"Num of GameObjects: [{list.Count}]");
if (list.Count > 0)
{
UpdateMaterialParameters();
GetReplacableMaterials(list);
ReplaceMaterials();
}
}
}
private const string IMAGE_LANDSCAPE_FOLDER_NAME = "RandomLandscapePaintingSwap_Images";
private const string IMAGE_SQUARE_FOLDER_NAME = "RandomSquarePaintingSwap_Images";
private const string IMAGE_PORTRAIT_FOLDER_NAME = "RandomPortraitPaintingSwap_Images";
private const string MATERIAL_LANDSCAPE_ASSET_NAME = "GrungeHorizontalMaterial";
private const string MATERIAL_PORTRAIT_ASSET_NAME = "GrungeVerticalMaterial";
private static Material _LandscapeMaterial;
private static Material _PortraitMaterial;
public static readonly HashSet<string> whitelistLandscapeMaterials;
public static readonly HashSet<string> whitelistSquareMaterials;
public static readonly HashSet<string> whitelistPortraitMaterials;
internal static List<ReplaceablePainting> replaceablePaintings;
internal static int pseudorandomSeed;
public static List<PaintingGroup> paintingGroups;
internal static ManualLogSource Logger;
public static readonly HashSet<string> imagePatterns;
private readonly Harmony harmony = new Harmony("phnod.anotherrandompaintingswap");
public static Plugin Instance { get; private set; }
static Plugin()
{
whitelistLandscapeMaterials = new HashSet<string> { "Painting_H_Landscape", "Painting_H_crow", "Painting_H_crow_0", "PaintingMedium" };
whitelistSquareMaterials = new HashSet<string> { "Painting_S_Creep", "Painting_S_Creep 2_0", "Painting_S_Creep 2", "Painting Wizard Class" };
whitelistPortraitMaterials = new HashSet<string> { "Painting_V_jannk", "Painting_V_Furman", "Painting_V_surrealistic", "Painting_V_surrealistic_0", "painting teacher01", "painting teacher02", "painting teacher03", "painting teacher04", "Painting_S_Tree" };
replaceablePaintings = new List<ReplaceablePainting>();
pseudorandomSeed = 0;
imagePatterns = new HashSet<string> { "*.png", "*.jpg", "*.jpeg", "*.psd" };
paintingGroups = new List<PaintingGroup>
{
new PaintingGroup("Landscape", "RandomLandscapePaintingSwap_Images", whitelistLandscapeMaterials),
new PaintingGroup("Square", "RandomSquarePaintingSwap_Images", whitelistSquareMaterials),
new PaintingGroup("Portrait", "RandomPortraitPaintingSwap_Images", whitelistPortraitMaterials)
};
}
private void Awake()
{
Instance = this;
Logger = ((BaseUnityPlugin)this).Logger;
Logger.LogInfo((object)"Plugin Another Random Painting Swap is loaded!");
PluginConfig.Init(((BaseUnityPlugin)this).Config);
harmony.PatchAll(Assembly.GetExecutingAssembly());
DebugLog("DebugLog enabled. Expect bad loading performance");
AssignMaterialGroups();
LoadImagesFromAllPlugins();
}
private static void UpdateMaterialParameters()
{
//IL_014b: 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_0189: Unknown result type (might be due to invalid IL or missing references)
//IL_01a8: Unknown result type (might be due to invalid IL or missing references)
//IL_009a: Unknown result type (might be due to invalid IL or missing references)
//IL_00be: 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)
//IL_0106: Unknown result type (might be due to invalid IL or missing references)
foreach (PaintingGroup paintingGroup in paintingGroups)
{
string paintingType = paintingGroup.paintingType;
if (paintingType == "Portrait")
{
paintingGroup.baseMaterial = _PortraitMaterial;
}
else
{
paintingGroup.baseMaterial = _LandscapeMaterial;
}
if ((Object)(object)paintingGroup.baseMaterial == (Object)null)
{
Logger.LogWarning((object)("No base material found for [" + paintingType + "]!"));
}
else if (PluginConfig.Grunge.enableGrunge.Value)
{
paintingGroup.baseMaterial.SetColor(((ConfigEntryBase)PluginConfig.Grunge._BaseColor).Definition.Key, PluginConfig.Grunge._BaseColor.Value);
paintingGroup.baseMaterial.SetColor(((ConfigEntryBase)PluginConfig.Grunge._MainColor).Definition.Key, PluginConfig.Grunge._MainColor.Value);
paintingGroup.baseMaterial.SetColor(((ConfigEntryBase)PluginConfig.Grunge._CracksColor).Definition.Key, PluginConfig.Grunge._CracksColor.Value);
paintingGroup.baseMaterial.SetColor(((ConfigEntryBase)PluginConfig.Grunge._OutlineColor).Definition.Key, PluginConfig.Grunge._OutlineColor.Value);
paintingGroup.baseMaterial.SetFloat(((ConfigEntryBase)PluginConfig.Grunge._CracksPower).Definition.Key, PluginConfig.Grunge._CracksPower.Value);
}
else
{
paintingGroup.baseMaterial.SetColor(((ConfigEntryBase)PluginConfig.Grunge._BaseColor).Definition.Key, Color.clear);
paintingGroup.baseMaterial.SetColor(((ConfigEntryBase)PluginConfig.Grunge._MainColor).Definition.Key, Color.clear);
paintingGroup.baseMaterial.SetColor(((ConfigEntryBase)PluginConfig.Grunge._CracksColor).Definition.Key, Color.clear);
paintingGroup.baseMaterial.SetColor(((ConfigEntryBase)PluginConfig.Grunge._OutlineColor).Definition.Key, Color.clear);
}
}
}
private void AssignMaterialGroups()
{
string? directoryName = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
string text = "painting";
string text2 = Path.Combine(directoryName, text);
Logger.LogInfo((object)("Loading [" + text2 + "]"));
if (File.Exists(text2))
{
Logger.LogInfo((object)"Asset Bundle exists");
}
else
{
Logger.LogWarning((object)"Asset Bundle doesn't exist");
}
AssetBundle val = AssetBundle.LoadFromFile(text2);
if ((Object)(object)val == (Object)null)
{
Logger.LogError((object)("Failed to load [" + text + "]"));
}
else
{
_LandscapeMaterial = val.LoadAsset<Material>("GrungeHorizontalMaterial");
if ((Object)(object)_LandscapeMaterial == (Object)null)
{
Logger.LogError((object)"Could not load landscape painting material [GrungeHorizontalMaterial]!");
}
_PortraitMaterial = val.LoadAsset<Material>("GrungeVerticalMaterial");
if ((Object)(object)_PortraitMaterial == (Object)null)
{
Logger.LogError((object)"Could not load portrait painting material [GrungeVerticalMaterial]!");
}
}
UpdateMaterialParameters();
}
private void LoadImagesFromAllPlugins()
{
string text = Path.Combine(Paths.PluginPath);
if (!Directory.Exists(text))
{
Logger.LogWarning((object)("Plugins directory not found: [" + text + "]"));
return;
}
foreach (PaintingGroup paintingGroup in paintingGroups)
{
string paintingFolderName = paintingGroup.paintingFolderName;
string[] directories = Directory.GetDirectories(text, paintingFolderName, SearchOption.AllDirectories);
if (directories.Length == 0)
{
Logger.LogWarning((object)"No 'CustomPaintings' folders found in plugins.");
break;
}
string[] array = directories;
foreach (string text2 in array)
{
Logger.LogInfo((object)("Loading images from: [" + text2 + "]"));
LoadImagesFromDirectory(paintingGroup, text2);
}
}
}
private void LoadImagesFromDirectory(PaintingGroup InPaintingGroup, string directoryPath)
{
//IL_0126: Unknown result type (might be due to invalid IL or missing references)
//IL_012d: Expected O, but got Unknown
//IL_0113: Unknown result type (might be due to invalid IL or missing references)
//IL_0118: Unknown result type (might be due to invalid IL or missing references)
//IL_0122: Expected O, but got Unknown
string paintingType = InPaintingGroup.paintingType;
if (!Directory.Exists(directoryPath))
{
Logger.LogWarning((object)("The folder [" + directoryPath + "] does not exist!"));
return;
}
Logger.LogInfo((object)("Selecting image patterns for group [" + paintingType + "] for files : " + directoryPath));
List<string> list = imagePatterns.SelectMany((string pattern) => Directory.GetFiles(directoryPath, pattern)).ToList();
if (!list.Any())
{
Logger.LogWarning((object)("No images found in the folder [" + directoryPath + "]"));
return;
}
foreach (string item in list)
{
string fileName = Path.GetFileName(item);
Texture2D val = LoadTextureFromFile(item);
if ((Object)(object)val == (Object)null)
{
Logger.LogWarning((object)("Error loading image : [" + item + "]"));
continue;
}
Material baseMaterial = InPaintingGroup.baseMaterial;
Material val2;
if ((Object)(object)baseMaterial == (Object)null)
{
val2 = new Material(Shader.Find("Standard"))
{
mainTexture = (Texture)(object)val
};
}
else
{
val2 = new Material(baseMaterial);
val2.SetTexture("_MainTex", (Texture)(object)val);
}
CustomPainting customPainting = new CustomPainting();
customPainting.material = val2;
customPainting.textureName = fileName;
InPaintingGroup.customPaintings.Add(customPainting);
Logger.LogInfo((object)("Created Material for group [" + paintingType + "] for loaded image : " + fileName));
}
InPaintingGroup.unusedPaintings.Clear();
InPaintingGroup.unusedPaintings.AddRange(InPaintingGroup.customPaintings);
Logger.LogInfo((object)$"Total Images for group [{paintingType}] : [{list.Count}]");
}
private static int HashRoundedPosition(Vector3 position)
{
//IL_0005: 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_0037: Unknown result type (might be due to invalid IL or missing references)
return ((17 * 23 + ((int)(position.x * 10f)).GetHashCode()) * 23 + ((int)(position.y * 10f)).GetHashCode()) * 23 + ((int)(position.z * 10f)).GetHashCode();
}
private static void PseudorandomSortList(List<ReplaceablePainting> InList)
{
//IL_0048: Unknown result type (might be due to invalid IL or missing references)
Logger.LogDebug((object)"Randomly sorting painting list");
if (InList == null || InList.Count <= 0)
{
return;
}
pseudorandomSeed = 17;
foreach (ReplaceablePainting In in InList)
{
MeshRenderer meshRenderer = In.meshRenderer;
pseudorandomSeed = pseudorandomSeed * 23 + HashRoundedPosition(((Component)meshRenderer).transform.position);
}
InList.Sort(delegate(ReplaceablePainting a, ReplaceablePainting b)
{
//IL_000b: Unknown result type (might be due to invalid IL or missing references)
//IL_0010: 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_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_005b: Unknown result type (might be due to invalid IL or missing references)
//IL_007b: Unknown result type (might be due to invalid IL or missing references)
//IL_0080: Unknown result type (might be due to invalid IL or missing references)
//IL_0093: Unknown result type (might be due to invalid IL or missing references)
int num = ((Component)b.meshRenderer).transform.position.z.CompareTo(((Component)a.meshRenderer).transform.position.z);
if (num != 0)
{
return num;
}
int num2 = ((Component)b.meshRenderer).transform.position.x.CompareTo(((Component)a.meshRenderer).transform.position.x);
return (num2 != 0) ? num2 : ((Component)b.meshRenderer).transform.position.y.CompareTo(((Component)a.meshRenderer).transform.position.y);
});
}
private static CustomPainting GetPseudorandomPainting(PaintingGroup InPaintingGroup, MeshRenderer InMeshRenderer, out int OutHash)
{
//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
OutHash = 0;
if (InPaintingGroup == null)
{
Logger.LogError((object)"Painting Group is NULL");
return null;
}
if ((Object)(object)InMeshRenderer == (Object)null)
{
Logger.LogError((object)"InMeshRenderer is NULL");
return null;
}
if (InPaintingGroup.customPaintings == null)
{
Logger.LogError((object)"Painting Group custompaintings is NULL");
return null;
}
if (InPaintingGroup.unusedPaintings == null)
{
Logger.LogError((object)"Painting Group unusedPaintings is NULL");
return null;
}
if (InPaintingGroup.unusedPaintings.Count <= 0)
{
InPaintingGroup.unusedPaintings.AddRange(InPaintingGroup.customPaintings);
Logger.LogInfo((object)("Added all possible custom paintings for [" + InPaintingGroup.paintingType + "], adding new set of duplicates."));
}
if (InPaintingGroup.unusedPaintings.Count <= 0)
{
return null;
}
OutHash = Mathf.Abs(HashRoundedPosition(((Component)InMeshRenderer).transform.position));
int index = OutHash % InPaintingGroup.unusedPaintings.Count;
CustomPainting result = InPaintingGroup.unusedPaintings[index];
InPaintingGroup.unusedPaintings.RemoveAt(index);
return result;
}
private Texture2D LoadTextureFromFile(string filePath)
{
//IL_0009: Unknown result type (might be due to invalid IL or missing references)
//IL_000f: Expected O, but got Unknown
byte[] array = File.ReadAllBytes(filePath);
Texture2D val = new Texture2D(2, 2);
if (!ImageConversion.LoadImage(val, array))
{
val = null;
return null;
}
val.Apply();
return val;
}
private static void ReplaceMaterials()
{
//IL_01b2: 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)
PseudorandomSortList(replaceablePaintings);
Logger.LogDebug((object)"Replacing base images with plugin images");
foreach (ReplaceablePainting replaceablePainting in replaceablePaintings)
{
MeshRenderer meshRenderer = replaceablePainting.meshRenderer;
Material[] sharedMaterials = ((Renderer)meshRenderer).sharedMaterials;
if (sharedMaterials == null)
{
continue;
}
for (int i = 0; i < sharedMaterials.Length; i++)
{
foreach (PaintingGroup paintingGroup in paintingGroups)
{
Material val = sharedMaterials[i];
if ((Object)(object)val == (Object)null || !paintingGroup.whitelistMaterials.Contains(((Object)val).name) || paintingGroup.customPaintings.Count <= 0)
{
continue;
}
int OutHash;
CustomPainting pseudorandomPainting = GetPseudorandomPainting(paintingGroup, meshRenderer, out OutHash);
if (pseudorandomPainting == null)
{
Logger.LogError((object)$"Could not get painting from [{paintingGroup}][{meshRenderer}]");
continue;
}
float num = (float)new Random(OutHash).NextDouble();
float value = PluginConfig.customPaintingChance.Value;
if (num > PluginConfig.customPaintingChance.Value)
{
Logger.LogInfo((object)$"[{((Object)val).name}] will not be replaced by a [{paintingGroup.paintingType}]. Random Probability - [{num}/{value}]");
continue;
}
sharedMaterials[i] = pseudorandomPainting.material;
Logger.LogInfo((object)("Found ------------> [" + ((Object)val).name + "] with texture [" + ((Object)val.mainTexture).name + "]"));
Logger.LogInfo((object)("Converted to -----> [" + pseudorandomPainting.textureName + "]"));
Vector3 position = ((Component)meshRenderer).transform.position;
string text = position.x.ToString("F1").PadLeft(7) + "," + position.y.ToString("F1").PadLeft(7) + "," + position.z.ToString("F1").PadLeft(7);
Logger.LogDebug((object)("Located at -> [" + text + "]"));
}
}
((Renderer)meshRenderer).sharedMaterials = sharedMaterials;
}
}
private static void GetReplacableMaterials(List<GameObject> InGameObjects)
{
Logger.LogInfo((object)"Finding replaceable paintings");
replaceablePaintings.Clear();
foreach (PaintingGroup paintingGroup in paintingGroups)
{
paintingGroup.unusedPaintings.Clear();
paintingGroup.unusedPaintings.AddRange(paintingGroup.customPaintings);
}
foreach (GameObject InGameObject in InGameObjects)
{
MeshRenderer[] componentsInChildren = InGameObject.GetComponentsInChildren<MeshRenderer>();
foreach (MeshRenderer val in componentsInChildren)
{
bool flag = false;
ReplaceablePainting replaceablePainting = null;
Material[] sharedMaterials = ((Renderer)val).sharedMaterials;
if (sharedMaterials == null)
{
continue;
}
for (int j = 0; j < sharedMaterials.Length; j++)
{
foreach (PaintingGroup paintingGroup2 in paintingGroups)
{
Material val2 = sharedMaterials[j];
if (!((Object)(object)val2 == (Object)null) && paintingGroup2.whitelistMaterials.Contains(((Object)val2).name) && paintingGroup2.customPaintings.Count > 0)
{
flag = true;
replaceablePainting = new ReplaceablePainting
{
meshRenderer = val
};
}
}
}
if (flag)
{
if (replaceablePainting == null)
{
Logger.LogError((object)"Replaceable painting is null, this shouldn't be possible!");
}
else
{
replaceablePaintings.Add(replaceablePainting);
}
}
}
}
}
private static void ReplaceWithCustomImages(List<GameObject> InGameObjects)
{
foreach (GameObject InGameObject in InGameObjects)
{
MeshRenderer[] componentsInChildren = InGameObject.GetComponentsInChildren<MeshRenderer>();
foreach (MeshRenderer val in componentsInChildren)
{
Material[] sharedMaterials = ((Renderer)val).sharedMaterials;
if (sharedMaterials == null)
{
continue;
}
for (int j = 0; j < sharedMaterials.Length; j++)
{
foreach (PaintingGroup paintingGroup in paintingGroups)
{
Material val2 = sharedMaterials[j];
if (!((Object)(object)val2 == (Object)null) && paintingGroup.whitelistMaterials.Contains(((Object)val2).name) && paintingGroup.customPaintings.Count > 0)
{
int OutHash;
CustomPainting pseudorandomPainting = GetPseudorandomPainting(paintingGroup, val, out OutHash);
float num = Random.Range(0f, 1f);
float value = PluginConfig.customPaintingChance.Value;
if (num > PluginConfig.customPaintingChance.Value)
{
Logger.LogInfo((object)$"[{((Object)val2).name}] will not be replaced by a [{paintingGroup.paintingType}]. Random Probability - [{num}/{value}]");
}
else
{
Random.Range(0, paintingGroup.customPaintings.Count);
sharedMaterials[j] = pseudorandomPainting.material;
Logger.LogInfo((object)("Found ------------> [" + ((Object)val2).name + "] with texture [" + ((Object)val2.mainTexture).name + "]"));
Logger.LogInfo((object)("Converted to -----> [" + pseudorandomPainting.textureName + "]"));
}
}
}
}
((Renderer)val).sharedMaterials = sharedMaterials;
}
}
}
public static void DebugLog(string InMessage)
{
if (PluginConfig.enableDebugLog.Value)
{
Logger.LogDebug((object)InMessage);
}
}
}
}
namespace RandomPaintingSwap
{
internal static class PluginConfig
{
internal static class Grunge
{
internal static ConfigEntry<bool> enableGrunge;
internal static ConfigEntry<Color> _BaseColor;
internal static ConfigEntry<Color> _MainColor;
internal static ConfigEntry<Color> _CracksColor;
internal static ConfigEntry<Color> _OutlineColor;
internal static ConfigEntry<float> _CracksPower;
}
internal static ConfigEntry<bool> enableDebugLog;
internal static ConfigEntry<float> customPaintingChance;
internal static void Init(ConfigFile InConfig)
{
//IL_0074: Unknown result type (might be due to invalid IL or missing references)
//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
//IL_00da: Unknown result type (might be due to invalid IL or missing references)
//IL_010d: Unknown result type (might be due to invalid IL or missing references)
enableDebugLog = InConfig.Bind<bool>("General", "DebugLog", false, "Print extra logs for debugging");
customPaintingChance = InConfig.Bind<float>("General", "CustomPaintingChance", 1f, "The chance of a painting being replaced by a custom painting (1 = 100%, 0.5 = 50%)");
Grunge.enableGrunge = InConfig.Bind<bool>("Grunge", "EnableGrunge", true, "Whether the grunge effect is enabled");
Grunge._BaseColor = InConfig.Bind<Color>("Grunge", "_GrungeBaseColor", new Color(0f, 0f, 0f, 1f), "The base color of the grunge");
Grunge._MainColor = InConfig.Bind<Color>("Grunge", "_GrungeMainColor", new Color(0f, 0f, 0f, 1f), "The color of the main overlay of grunge");
Grunge._CracksColor = InConfig.Bind<Color>("Grunge", "_GrungeCracksColor", new Color(0f, 0f, 0f, 1f), "The color of the cracks in the grunge");
Grunge._OutlineColor = InConfig.Bind<Color>("Grunge", "_GrungeOutlineColor", new Color(0f, 0f, 0f, 1f), "The color of the grunge outlining the painting");
Grunge._CracksPower = InConfig.Bind<float>("Grunge", "_GrungeCracksPow", 1f, "The inverse of intensity of the cracks. 1.0 will have plenty of cracks, higher numbers will have less cracks (Values below 1.0 will start to look bad)");
}
}
public static class MyPluginInfo
{
public const string PLUGIN_GUID = "RandomPaintingSwap";
public const string PLUGIN_NAME = "Random Painting Swap";
public const string PLUGIN_VERSION = "1.1.0";
}
}
