/*
* BSM ColorSO holders
*/
internal static void BSMStart(SaberModelController bcm, SaberType saberType)
{
if (saberType == SaberType.SaberA || saberType == SaberType.SaberB)
{
BSMColorManager.CreateBSMColorManager(bcm, saberType);
}
}
private void UpdateSaberColor(SaberModelController saberModel, Color color)
{
SetSaberGlowColor[] glowColors = Helper.GetValue <SetSaberGlowColor[]>(saberModel, "_setSaberGlowColors");
SetSaberFakeGlowColor[] fakeGlowColors = Helper.GetValue <SetSaberFakeGlowColor[]>(saberModel, "_setSaberFakeGlowColors");
Color trailTintColor = Helper.GetValue <SaberModelController.InitData>(saberModel, "_initData").trailTintColor;
SaberTrail trail = Helper.GetValue <SaberTrail>(saberModel, "_saberTrail");
Helper.SetValue <Color>(trail, "_color", (color * trailTintColor).linear);
TubeBloomPrePassLight light = Helper.GetValue <TubeBloomPrePassLight>(saberModel, "_saberLight");
if (light != null)
{
light.color = color;
}
foreach (SetSaberGlowColor glowColor in glowColors)
{
glowColor.SetColors();
}
foreach (SetSaberFakeGlowColor fakeGlowColor in fakeGlowColors)
{
fakeGlowColor.SetColors();
}
}
private async Task <GameObject> GetSaberModel(Saber saber)
{
//return saber.GetComponentInChildren<SaberModelController>()?.gameObject;
SaberModelController smc = null;
var timeout = 2000;
var interval = 300;
var time = 0;
while (!smc)
{
smc = saber.GetComponentInChildren <SaberModelController>();
if (smc)
{
return(smc.gameObject);
}
if (time > timeout)
{
return(null);
}
time += interval;
await Task.Delay(interval);
}
return(null);
}
public void Init(SaberTrailRenderer TrailRendererPrefab, ColorManager colorManager, Transform PointStart, Transform PointEnd, Material TrailMaterial, Color TrailColor, int Length, int Granularity, Color multiplierSaberColor, ColorType colorType)
{
_colorManager = colorManager;
_multiplierSaberColor = multiplierSaberColor;
_customColor = TrailColor;
_customMaterial = TrailMaterial;
_saberType = colorType;
_pointStart = PointStart;
_pointEnd = PointEnd;
_trailDuration = Length / 75f;
if (!Settings.Configuration.DisableWhitestep)
{
_whiteSectionMaxDuration = 0.04f;
}
Logger.log.Info($"Granularity: {_granularity}");
_granularity = Granularity;
_trailRendererPrefab = TrailRendererPrefab;
SaberModelController saberModelController = Resources.FindObjectsOfTypeAll <SaberModelController>().FirstOrDefault();
SaberModelController.InitData initData = saberModelController?.GetField <SaberModelController.InitData, SaberModelController>("_initData");
if (initData != null)
{
trailTintColor = initData.trailTintColor;
}
_trailRenderer = Instantiate <SaberTrailRenderer>(TrailRendererPrefab, Vector3.zero, Quaternion.identity);
}
internal static BSMColorManager CreateBSMColorManager(SaberModelController bsm, SaberType saberType)
{
BSMColorManager bsmcm;
bsmcm = new BSMColorManager(bsm, saberType);
_bsmColorManagers.Add(bsmcm);
return(bsmcm);
}
private BSMColorManager(SaberModelController bsm, SaberType saberType)
{
_bsm = bsm;
_saberType = saberType;
_saberWeaponTrail = _saberWeaponTrailAccessor(ref _bsm);
_trailTintColor = _initDataAccessor(ref _bsm).trailTintColor;
_setSaberGlowColors = _setSaberGlowColorsAccessor(ref _bsm);
_setSaberFakeGlowColors = _SetSaberFakeGlowAccessor(ref _bsm);
_saberLight = _saberLightAccessor(ref _bsm);
}
internal static bool Prefix(ref Saber ____saber, ref DiContainer ____container, ref SaberModelContainer __instance, SaberModelController ____saberModelControllerPrefab)
{
var providers = ____container.Resolve <List <IModelProvider> >().Where(x => x.Type.DerivesFrom(typeof(SaberModelController)));
if (providers.Count() == 0)
{
var provider = ____container.Resolve <SaberProvider>();
if (!provider.IsSafe())
{
provider.ModelPrefab = ____saberModelControllerPrefab;
}
return(true);
}
var baseProvider = providers.OrderByDescending(x => x.Priority).First();
SaberModelController saberModelController = null;
var providerX = ____container.Resolve <SaberProvider>();
if (!providerX.IsSafe())
{
saberModelController = providerX.ModelPrefab = new GameObject(baseProvider.GetType().FullName).AddComponent(baseProvider.Type) as SaberModelController;
}
else
{
saberModelController = providerX.ModelPrefab;
}
____container.Inject(saberModelController);
Accessors.SaberTrail(ref saberModelController) = Accessors.SaberTrail(ref ____saberModelControllerPrefab);
Accessors.SaberGlowColor(ref saberModelController) = Accessors.SaberGlowColor(ref ____saberModelControllerPrefab);
var glowColors = Accessors.SaberGlowColor(ref saberModelController);
for (int i = 0; i < glowColors.Length; i++)
{
____container.Inject(glowColors[i]);
}
Accessors.FakeSaberGlowColor(ref saberModelController) = Accessors.FakeSaberGlowColor(ref ____saberModelControllerPrefab);
var fakeGlowColors = Accessors.FakeSaberGlowColor(ref saberModelController);
for (int i = 0; i < fakeGlowColors.Length; i++)
{
____container.Inject(fakeGlowColors[i]);
}
Accessors.SaberLight(ref saberModelController) = Accessors.SaberLight(ref ____saberModelControllerPrefab);
saberModelController.gameObject.transform.SetParent(__instance.transform, false);
saberModelController.Init(__instance.transform, ____saber);
return(false);
}
/// <summary>
/// Change the color of a saber.
/// </summary>
/// <param name="_">The saber.</param>
/// <param name="color">The color to change the saber to.</param>
/// <param name="smc">The model controller of the saber.</param>
/// <param name="tintColor">The tint color of the new color.</param>
/// <param name="setSaberGlowColors">The glow color groups of the saber.</param>
/// <param name="setSaberFakeGlowColors">The fake glow color groups of the saber.</param>
/// <param name="light">The light of the saber.</param>
public static void ChangeColor(this Saber _, Color color, SaberModelController smc, Color tintColor, SetSaberGlowColor[] setSaberGlowColors, SetSaberFakeGlowColor[] setSaberFakeGlowColors, TubeBloomPrePassLight light)
{
Accessors.TrailColor(ref Accessors.SaberTrail(ref smc)) = (color * tintColor).linear;
for (int i = 0; i < setSaberGlowColors.Length; i++)
{
setSaberGlowColors[i].OverrideColor(color);
}
for (int i = 0; i < setSaberFakeGlowColors.Length; i++)
{
setSaberFakeGlowColors[i].OverrideColor(color);
}
if (light != null)
{
light.color = color;
}
}
private static void SetupSaber(DiContainer container, SaberModelController prefab, SaberModelController destination)
{
Accessors.SaberTrail(ref destination) = Accessors.SaberTrail(ref prefab);
Accessors.SaberGlowColor(ref destination) = Accessors.SaberGlowColor(ref prefab);
var glowColors = Accessors.SaberGlowColor(ref destination);
for (int i = 0; i < glowColors.Length; i++)
{
container.Inject(glowColors[i]);
}
Accessors.FakeSaberGlowColor(ref destination) = Accessors.FakeSaberGlowColor(ref prefab);
var fakeGlowColors = Accessors.FakeSaberGlowColor(ref destination);
for (int i = 0; i < fakeGlowColors.Length; i++)
{
container.Inject(fakeGlowColors[i]);
}
Accessors.SaberLight(ref destination) = Accessors.SaberLight(ref prefab);
}
/// <summary>
/// Gets the color of a saber.
/// </summary>
/// <param name="saber">The saber to get the color of.</param>
/// <returns></returns>
public static Color GetColor(this Saber saber)
{
if (saber is IColorable saberColorable)
{
return(saberColorable.Color);
}
SaberModelController modelController = saber.gameObject.GetComponentInChildren <SaberModelController>(true);
if (modelController is IColorable)
{
var colorable = modelController as IColorable;
return(colorable.Color);
}
else if (modelController is SaberModelController smc)
{
return(Accessors.TrailColor(ref Accessors.SaberTrail(ref smc)).gamma);
}
return(Color.white);
}
protected override void Init()
{
saberColorLeft = colorScheme.saberAColor;
saberColorRight = colorScheme.saberBColor;
noteColorLeft = colorScheme.saberAColor;
noteColorRight = colorScheme.saberBColor;
wallColor = colorScheme.obstaclesColor;
leftSaberModel = saberManager.leftSaber.GetComponentInChildren <SaberModelController>(true);
rightSaberModel = saberManager.rightSaber.GetComponentInChildren <SaberModelController>(true);
if (PluginManager.GetPluginFromId("SiraUtil") != null)
{
CheckCustomSabers();
}
customNotesActive = PluginManager.GetPluginFromId("Custom Notes") != null;
enabled = false;
}
internal static IEnumerator ChangeColorCoroutine(Saber saber, Color color, float time = 0.05f)
{
if (time != 0)
{
yield return(new WaitForSeconds(time));
}
SaberModelController modelController = saber.gameObject.GetComponentInChildren <SaberModelController>(true);
if (modelController is IColorable colorable)
{
colorable.SetColor(color);
}
if (modelController is SaberModelController smc)
{
Color tintColor = Accessors.ModelInitData(ref smc).trailTintColor;
SetSaberGlowColor[] setSaberGlowColors = Accessors.SaberGlowColor(ref smc);
SetSaberFakeGlowColor[] setSaberFakeGlowColors = Accessors.FakeSaberGlowColor(ref smc);
TubeBloomPrePassLight light = Accessors.SaberLight(ref smc);
saber.ChangeColor(color, smc, tintColor, setSaberGlowColors, setSaberFakeGlowColors, light);
}
}
private IEnumerator PreloadDefaultSabers()
{
bool isSceneLoaded = false;
string sceneName;
try
{
sceneName = "StandardGameplay";
Logger.log.Debug($"Loading {sceneName} scene");
var loadScene = SceneManager.LoadSceneAsync(sceneName, LoadSceneMode.Additive);
while (!loadScene.isDone)
{
yield return(null);
}
sceneName = "GameCore";
Logger.log.Debug($"Loading {sceneName} scene");
loadScene = SceneManager.LoadSceneAsync(sceneName, LoadSceneMode.Additive);
while (!loadScene.isDone)
{
yield return(null);
}
isSceneLoaded = true;
Logger.log.Debug("Loaded!");
yield return(new WaitForSecondsRealtime(0.1f));
SaberModelController saber = Resources.FindObjectsOfTypeAll <SaberModelController>().FirstOrDefault();
Logger.log.Debug("Got sabers!");
Logger.log.Debug($"Saber: {saber.name}, GameObj: {saber.gameObject.name}, {saber.ToString()}");
// Left Saber
defaultLeftSaber = Instantiate(saber).gameObject;
DestroyImmediate(defaultLeftSaber.GetComponent <SaberModelController>());
DestroyImmediate(defaultLeftSaber.GetComponentInChildren <ConditionalMaterialSwitcher>());
foreach (var c in defaultLeftSaber.GetComponentsInChildren <SetSaberGlowColor>())
{
DestroyImmediate(c);
}
DontDestroyOnLoad(defaultLeftSaber);
defaultLeftSaber.transform.SetParent(this.transform);
defaultLeftSaber.gameObject.name = "LeftSaber";
defaultLeftSaber.transform.localPosition = Vector3.zero;
defaultLeftSaber.transform.localRotation = Quaternion.identity;
defaultLeftSaber.AddComponent <DummySaber>();
// Right Saber
defaultRightSaber = Instantiate(saber).gameObject;
DestroyImmediate(defaultRightSaber.GetComponent <SaberModelController>());
DestroyImmediate(defaultRightSaber.GetComponentInChildren <ConditionalMaterialSwitcher>());
foreach (var c in defaultRightSaber.GetComponentsInChildren <SetSaberGlowColor>())
{
DestroyImmediate(c);
}
DontDestroyOnLoad(defaultRightSaber);
defaultRightSaber.transform.SetParent(this.transform);
defaultRightSaber.gameObject.name = "RightSaber";
defaultRightSaber.transform.localPosition = Vector3.zero;
defaultRightSaber.transform.localRotation = Quaternion.identity;
defaultRightSaber.AddComponent <DummySaber>();
Logger.log.Debug("Finished! Got default sabers! Setting active state");
if (defaultLeftSaber)
{
Logger.log.Debug("Found default left saber");
defaultLeftSaber.SetActive(false);
}
if (defaultRightSaber)
{
Logger.log.Debug("Found default right saber");
defaultRightSaber.SetActive(false);
}
if (defaultLeftSaber && defaultRightSaber)
{
// Add them as the first Object in the list, replacing the empty version.
CustomSaberData defaultSabers = new CustomSaberData(defaultLeftSaber.gameObject, defaultRightSaber.gameObject);
SaberAssetLoader.CustomSabers[0] = defaultSabers;
isCompleted = true;
}
}
finally
{
if (isSceneLoaded)
{
sceneName = "StandardGameplay";
Logger.log.Debug($"Unloading {sceneName}");
SceneManager.UnloadSceneAsync(sceneName);
sceneName = "GameCore";
Logger.log.Debug($"Unloading {sceneName}");
SceneManager.UnloadSceneAsync(sceneName);
}
}
}
private IEnumerator PreloadDefaultSabers()
{
bool sceneLoaded = false;
try {
string sceneName = "StandardGameplay";
AsyncOperation loadScene = SceneManager.LoadSceneAsync(sceneName, LoadSceneMode.Additive);
while (!loadScene.isDone)
{
yield return(null);
}
sceneName = "GameCore";
loadScene = SceneManager.LoadSceneAsync(sceneName, LoadSceneMode.Additive);
while (!loadScene.isDone)
{
yield return(null);
}
sceneLoaded = true;
yield return(new WaitForSecondsRealtime(0.1f));
SaberModelController saberModelController = Resources.FindObjectsOfTypeAll <SaberModelController>().FirstOrDefault();
defaultLeftSaber = Instantiate(saberModelController).gameObject;
DestroyImmediate(defaultLeftSaber.GetComponent <SaberModelController>());
DestroyImmediate(defaultLeftSaber.GetComponentInChildren <ConditionalMaterialSwitcher>());
SetSaberGlowColor[] componentsInChildren = defaultLeftSaber.GetComponentsInChildren <SetSaberGlowColor>();
for (int i = 0; i < componentsInChildren.Length; i++)
{
DestroyImmediate(componentsInChildren[i]);
}
SetSaberFakeGlowColor[] componentsInChildren2 = defaultLeftSaber.GetComponentsInChildren <SetSaberFakeGlowColor>();
for (int i = 0; i < componentsInChildren2.Length; i++)
{
DestroyImmediate(componentsInChildren2[i]);
}
SaberTrail[] componentsInChildren3 = defaultLeftSaber.GetComponentsInChildren <SaberTrail>();
for (int i = 0; i < componentsInChildren3.Length; i++)
{
DestroyImmediate(componentsInChildren3[i]);
}
DontDestroyOnLoad(defaultLeftSaber);
defaultLeftSaber.transform.SetParent(transform);
defaultLeftSaber.gameObject.name = "SSLeftSaber";
defaultLeftSaber.transform.localPosition = Vector3.zero;
defaultLeftSaber.transform.localRotation = Quaternion.identity;
defaultLeftSaber.AddComponent <PreviewSaber>();
if (defaultLeftSaber)
{
defaultLeftSaber.SetActive(false);
isCompleted = true;
}
loadScene = null;
} finally {
if (sceneLoaded)
{
string sceneName = "StandardGameplay";
SceneManager.UnloadSceneAsync(sceneName);
sceneName = "GameCore";
SceneManager.UnloadSceneAsync(sceneName);
}
}
yield break;
}
internal static bool Prefix(ref Saber ____saber, ref DiContainer ____container, ref SaberModelContainer __instance, SaberModelController ____saberModelControllerPrefab)
{
var providers = ____container.Resolve <List <IModelProvider> >().Where(x => x.Type.DerivesFrom(typeof(SaberModelController)) && x.Priority >= 0);
var provider = GetProvider(____container);
if (providers.Count() == 0)
{
if (!provider.IsSafe())
{
provider.ModelPrefab = ____saberModelControllerPrefab;
}
return(true);
}
var baseProvider = providers.OrderByDescending(x => x.Priority).First();
var originalPrefab = ____saberModelControllerPrefab;
var instanceTransform = __instance.transform;
var container = ____container;
var saber = ____saber;
if (!provider.IsSafe(false))
{
var smc = new GameObject(baseProvider.GetType().FullName).AddComponent(baseProvider.Type) as SaberModelController;
SetupSaber(____container, ____saberModelControllerPrefab, smc);
provider.ModelPrefab = smc;
}
provider.GetModel((smc) =>
{
container.QueueForInject(smc);
SetupSaber(container, originalPrefab, smc);
smc.gameObject.transform.SetParent(instanceTransform, false);
smc.Init(instanceTransform, saber);
});
return(false);
}
public void ModelsReady()
{
_saberModelController = _saberProvider.GetModel();
_saberProvider.ControllerReady -= ModelsReady;
_saberModelController.Init(transform, _saber);
}
public static bool Prefix(SaberModelController __instance, Transform parent, Saber saber)
{
ColorController.sabers[saber.saberType == SaberType.SaberA ? 0 : 1] = __instance;
return(true);
}
#pragma warning disable SA1313 // Parameter names should begin with lower-case letter
private static void Prefix(SaberModelController __instance, Saber saber)
#pragma warning restore SA1313 // Parameter names should begin with lower-case letter
{
SaberColorizer.BSMStart(__instance, saber.saberType);
}
