private static ParametricBoxControllerParameters GetParameters(ParametricBoxController parametricBoxController)
{
if (!TransformParameters.TryGetValue(parametricBoxController, out ParametricBoxControllerParameters parameters))
{
parameters = new ParametricBoxControllerParameters();
TransformParameters.Add(parametricBoxController, parameters);
}
return(parameters);
}
internal static void Init(CustomBeatmapData customBeatmapData, float noteLinesDistance)
{
IEnumerable <Dictionary <string, object?> >?environmentData = customBeatmapData.customData.Get <List <object> >(ENVIRONMENT)?.Cast <Dictionary <string, object?> >();
GetAllGameObjects();
RingRotationOffsets = new Dictionary <TrackLaneRing, Quaternion>();
AvoidancePosition = new Dictionary <BeatmapObjectsAvoidance, Vector3>();
AvoidanceRotation = new Dictionary <BeatmapObjectsAvoidance, Quaternion>();
ParametricBoxControllerParameters.TransformParameters = new Dictionary <ParametricBoxController, ParametricBoxControllerParameters>();
if (environmentData != null)
{
RingRotationOffsets.Clear();
ParametricBoxControllerParameters.TransformParameters.Clear();
if (Settings.ChromaConfig.Instance !.PrintEnvironmentEnhancementDebug)
{
Plugin.Logger.Log($"=====================================");
}
foreach (Dictionary <string, object?> gameObjectData in environmentData)
{
string id = gameObjectData.Get <string>(ID) ?? throw new InvalidOperationException("Id was not defined.");
string lookupString = gameObjectData.Get <string>(LOOKUPMETHOD) ?? throw new InvalidOperationException("Lookup method was not defined.");
LookupMethod lookupMethod = (LookupMethod)Enum.Parse(typeof(LookupMethod), lookupString);
int?dupeAmount = gameObjectData.Get <int?>(DUPLICATIONAMOUNT);
bool?active = gameObjectData.Get <bool?>(ACTIVE);
Vector3?scale = GetVectorData(gameObjectData, SCALE);
Vector3?position = GetVectorData(gameObjectData, POSITION);
Vector3?rotation = GetVectorData(gameObjectData, OBJECTROTATION);
Vector3?localPosition = GetVectorData(gameObjectData, LOCALPOSITION);
Vector3?localRotation = GetVectorData(gameObjectData, LOCALROTATION);
int?lightID = gameObjectData.Get <int?>(LIGHTID);
List <GameObjectInfo> foundObjects = LookupID(id, lookupMethod);
if (Settings.ChromaConfig.Instance !.PrintEnvironmentEnhancementDebug)
{
if (foundObjects.Count > 0)
{
Plugin.Logger.Log($"ID [\"{id}\"] using method [{lookupMethod:G}] found:");
foundObjects.ForEach(n => Plugin.Logger.Log(n.FullID));
}
else
{
Plugin.Logger.Log($"ID [\"{id}\"] using method [{lookupMethod:G}] found nothing.", IPA.Logging.Logger.Level.Error);
}
}
List <GameObjectInfo> gameObjectInfos;
if (dupeAmount.HasValue)
{
gameObjectInfos = new List <GameObjectInfo>();
foreach (GameObjectInfo gameObjectInfo in foundObjects)
{
if (Settings.ChromaConfig.Instance !.PrintEnvironmentEnhancementDebug)
{
Plugin.Logger.Log($"Duplicating [{gameObjectInfo.FullID}]:");
}
GameObject gameObject = gameObjectInfo.GameObject;
Transform parent = gameObject.transform.parent;
Scene scene = gameObject.scene;
for (int i = 0; i < dupeAmount.Value; i++)
{
List <IComponentData> componentDatas = new List <IComponentData>();
ComponentInitializer.PrefillComponentsData(gameObject.transform, componentDatas);
GameObject newGameObject = UnityEngine.Object.Instantiate(gameObject);
ComponentInitializer.PostfillComponentsData(newGameObject.transform, gameObject.transform, componentDatas);
SceneManager.MoveGameObjectToScene(newGameObject, scene);
newGameObject.transform.SetParent(parent, true);
ComponentInitializer.InitializeComponents(newGameObject.transform, gameObject.transform, _gameObjectInfos, componentDatas, lightID);
List <GameObjectInfo> gameObjects = _gameObjectInfos.Where(n => n.GameObject == newGameObject).ToList();
gameObjectInfos.AddRange(gameObjects);
if (Settings.ChromaConfig.Instance !.PrintEnvironmentEnhancementDebug)
{
gameObjects.ForEach(n => Plugin.Logger.Log(n.FullID));
}
}
}
}
else
{
if (lightID.HasValue)
{
Plugin.Logger.Log($"LightID requested but no duplicated object to apply to.", IPA.Logging.Logger.Level.Error);
}
gameObjectInfos = foundObjects;
}
foreach (GameObjectInfo gameObjectInfo in gameObjectInfos)
{
GameObject gameObject = gameObjectInfo.GameObject;
if (active.HasValue)
{
gameObjectInfo.GameObject.SetActive(active.Value);
}
Transform transform = gameObject.transform;
if (scale.HasValue)
{
transform.localScale = scale.Value;
}
if (position.HasValue)
{
transform.position = position.Value * noteLinesDistance;
}
if (rotation.HasValue)
{
transform.eulerAngles = rotation.Value;
}
if (localPosition.HasValue)
{
transform.localPosition = localPosition.Value * noteLinesDistance;
}
if (localRotation.HasValue)
{
transform.localEulerAngles = localRotation.Value;
}
// Handle TrackLaneRing
TrackLaneRing trackLaneRing = gameObject.GetComponent <TrackLaneRing>();
if (trackLaneRing != null)
{
if (position.HasValue || localPosition.HasValue)
{
_positionOffsetAccessor(ref trackLaneRing) = transform.localPosition;
_posZAccessor(ref trackLaneRing) = 0;
}
if (rotation.HasValue || localRotation.HasValue)
{
RingRotationOffsets[trackLaneRing] = transform.localRotation;
_rotZAccessor(ref trackLaneRing) = 0;
}
}
// Handle ParametricBoxController
ParametricBoxController parametricBoxController = gameObject.GetComponent <ParametricBoxController>();
if (parametricBoxController != null)
{
if (position.HasValue || localPosition.HasValue)
{
ParametricBoxControllerParameters.SetTransformPosition(parametricBoxController, transform.localPosition);
}
if (scale.HasValue)
{
ParametricBoxControllerParameters.SetTransformScale(parametricBoxController, transform.localScale);
}
}
// Handle BeatmapObjectsAvoidance
BeatmapObjectsAvoidance beatmapObjectsAvoidance = gameObject.GetComponent <BeatmapObjectsAvoidance>();
if (beatmapObjectsAvoidance != null)
{
if (position.HasValue || localPosition.HasValue)
{
AvoidancePosition[beatmapObjectsAvoidance] = transform.localPosition;
}
if (rotation.HasValue || localRotation.HasValue)
{
AvoidanceRotation[beatmapObjectsAvoidance] = transform.localRotation;
}
}
GameObjectTrackController.HandleTrackData(gameObject, gameObjectData, customBeatmapData, noteLinesDistance, trackLaneRing, parametricBoxController, beatmapObjectsAvoidance);
}
if (Settings.ChromaConfig.Instance !.PrintEnvironmentEnhancementDebug)
{
Plugin.Logger.Log($"=====================================");
}
}
}
try
{
LegacyEnvironmentRemoval.Init(customBeatmapData);
}
catch (Exception e)
{
Plugin.Logger.Log("Could not run Legacy Enviroment Removal");
Plugin.Logger.Log(e);
}
}
internal static void Init(CustomBeatmapData customBeatmapData, float noteLinesDistance)
{
List <dynamic> environmentData = Trees.at(customBeatmapData.customData, ENVIRONMENT);
GetAllGameObjects();
if (environmentData != null)
{
RingRotationOffsets.Clear();
ParametricBoxControllerParameters.TransformParameters.Clear();
if (Settings.ChromaConfig.Instance.PrintEnvironmentEnhancementDebug)
{
ChromaLogger.Log($"=====================================");
}
foreach (dynamic gameObjectData in environmentData)
{
string id = Trees.at(gameObjectData, ID);
string lookupString = Trees.at(gameObjectData, LOOKUPMETHOD);
LookupMethod lookupMethod = (LookupMethod)Enum.Parse(typeof(LookupMethod), lookupString);
int?dupeAmount = (int?)Trees.at(gameObjectData, DUPLICATIONAMOUNT);
bool?active = (bool?)Trees.at(gameObjectData, ACTIVE);
Vector3?scale = GetVectorData(gameObjectData, SCALE);
Vector3?position = GetVectorData(gameObjectData, POSITION);
Vector3?rotation = GetVectorData(gameObjectData, OBJECTROTATION);
Vector3?localPosition = GetVectorData(gameObjectData, LOCALPOSITION);
Vector3?localRotation = GetVectorData(gameObjectData, LOCALROTATION);
List <GameObjectInfo> foundObjects = LookupID(id, lookupMethod);
if (Settings.ChromaConfig.Instance.PrintEnvironmentEnhancementDebug)
{
ChromaLogger.Log($"ID [\"{id}\"] using method [{lookupMethod:G}] found:");
foundObjects.ForEach(n => ChromaLogger.Log(n.FullID));
}
List <GameObjectInfo> gameObjectInfos;
if (dupeAmount.HasValue)
{
gameObjectInfos = new List <GameObjectInfo>();
foreach (GameObjectInfo gameObjectInfo in foundObjects)
{
if (Settings.ChromaConfig.Instance.PrintEnvironmentEnhancementDebug)
{
ChromaLogger.Log($"Duplicating [{gameObjectInfo.FullID}]:");
}
GameObject gameObject = gameObjectInfo.GameObject;
Transform parent = gameObject.transform.parent;
Scene scene = gameObject.scene;
for (int i = 0; i < dupeAmount.Value; i++)
{
List <IComponentData> componentDatas = new List <IComponentData>();
ComponentInitializer.PrefillComponentsData(gameObject.transform, componentDatas);
GameObject newGameObject = UnityEngine.Object.Instantiate(gameObject);
ComponentInitializer.PostfillComponentsData(newGameObject.transform, gameObject.transform, componentDatas);
SceneManager.MoveGameObjectToScene(newGameObject, scene);
newGameObject.transform.SetParent(parent, true);
ComponentInitializer.InitializeComponents(newGameObject.transform, gameObject.transform, _gameObjectInfos, componentDatas);
gameObjectInfos.AddRange(_gameObjectInfos.Where(n => n.GameObject == newGameObject));
}
}
}
else
{
gameObjectInfos = foundObjects;
}
foreach (GameObjectInfo gameObjectInfo in gameObjectInfos)
{
GameObject gameObject = gameObjectInfo.GameObject;
if (active.HasValue)
{
gameObjectInfo.GameObject.SetActive(active.Value);
}
Transform transform = gameObject.transform;
if (scale.HasValue)
{
transform.localScale = scale.Value;
}
if (position.HasValue)
{
transform.position = position.Value * noteLinesDistance;
}
if (rotation.HasValue)
{
transform.eulerAngles = rotation.Value;
}
if (localPosition.HasValue)
{
transform.localPosition = localPosition.Value * noteLinesDistance;
}
if (localRotation.HasValue)
{
transform.localEulerAngles = localRotation.Value;
}
// Handle TrackLaneRing
TrackLaneRing trackLaneRing = gameObject.GetComponent <TrackLaneRing>();
if (trackLaneRing != null)
{
if (position.HasValue || localPosition.HasValue)
{
_positionOffsetAccessor(ref trackLaneRing) = transform.localPosition;
_posZAccessor(ref trackLaneRing) = 0;
}
if (rotation.HasValue || localRotation.HasValue)
{
RingRotationOffsets[trackLaneRing] = transform.localRotation;
_rotZAccessor(ref trackLaneRing) = 0;
}
}
// Handle ParametricBoxController
ParametricBoxController parametricBoxController = gameObject.GetComponent <ParametricBoxController>();
if (parametricBoxController != null)
{
if (position.HasValue || localPosition.HasValue)
{
ParametricBoxControllerParameters.SetTransformPosition(parametricBoxController, transform.localPosition);
}
if (scale.HasValue)
{
ParametricBoxControllerParameters.SetTransformScale(parametricBoxController, transform.localScale);
}
}
if (NoodleExtensionsInstalled)
{
GameObjectTrackController.HandleTrackData(gameObject, gameObjectData, customBeatmapData, noteLinesDistance, trackLaneRing, parametricBoxController);
}
}
if (Settings.ChromaConfig.Instance.PrintEnvironmentEnhancementDebug)
{
ChromaLogger.Log($"=====================================");
}
}
}
LegacyEnvironmentRemoval.Init(customBeatmapData);
}
private void Update()
{
Quaternion?rotation = GetQuaternionNullable("_rotation");
Quaternion?localRotation = GetQuaternionNullable("_localRotation");
Vector3? position = GetVectorNullable("_position");
Vector3? localPosition = GetVectorNullable("_localPosition");
Vector3? scale = GetVectorNullable("_scale");
if (rotation.HasValue && transform.rotation != rotation.Value)
{
// Delegate positioning the object to TrackLaneRing
Quaternion finalOffset;
if (transform.parent != null)
{
finalOffset = Quaternion.Inverse(transform.parent.rotation) * rotation.Value;
}
else
{
finalOffset = rotation.Value;
}
if (_trackLaneRing != null)
{
EnvironmentEnhancementManager.RingRotationOffsets[_trackLaneRing] = finalOffset;
}
else if (_beatmapObjectsAvoidance != null)
{
EnvironmentEnhancementManager.AvoidanceRotation[_beatmapObjectsAvoidance] = finalOffset;
}
else
{
transform.rotation = rotation.Value;
}
}
if (localRotation.HasValue && transform.localRotation != localRotation.Value)
{
if (_trackLaneRing != null)
{
EnvironmentEnhancementManager.RingRotationOffsets[_trackLaneRing] = localRotation.Value;
}
else if (_beatmapObjectsAvoidance != null)
{
EnvironmentEnhancementManager.AvoidanceRotation[_beatmapObjectsAvoidance] = localRotation.Value;
}
else
{
transform.localRotation = localRotation.Value;
}
}
if (position.HasValue && transform.position != (position.Value * _noteLinesDistance))
{
Vector3 positionValue = position.Value * _noteLinesDistance;
Vector3 finalOffset;
if (transform.parent != null)
{
finalOffset = transform.parent.InverseTransformPoint(positionValue);
}
else
{
finalOffset = positionValue;
}
if (_trackLaneRing != null)
{
_positionOffsetAccessor(ref _trackLaneRing) = finalOffset;
}
else if (_beatmapObjectsAvoidance != null)
{
EnvironmentEnhancementManager.AvoidancePosition[_beatmapObjectsAvoidance] = finalOffset;
}
else
{
transform.position = positionValue;
}
}
if (localPosition.HasValue && transform.localPosition != localPosition.Value)
{
Vector3 localPositionValue = localPosition.Value * _noteLinesDistance;
if (_trackLaneRing != null)
{
_positionOffsetAccessor(ref _trackLaneRing) = localPositionValue;
}
else if (_beatmapObjectsAvoidance != null)
{
EnvironmentEnhancementManager.AvoidancePosition[_beatmapObjectsAvoidance] = localPositionValue;
}
else
{
transform.localPosition = localPositionValue;
}
}
if (scale.HasValue && transform.localScale != scale.Value)
{
transform.localScale = scale.Value;
}
// Handle ParametricBoxController
if (_parametricBoxController != null)
{
if (position.HasValue || localPosition.HasValue)
{
ParametricBoxControllerParameters.SetTransformPosition(_parametricBoxController, transform.localPosition);
}
if (scale.HasValue)
{
ParametricBoxControllerParameters.SetTransformScale(_parametricBoxController, transform.localScale);
}
}
}
