コード例 #1
0
ファイル: ChromaController.cs プロジェクト: Pixelguymm/Chroma
 internal static void OnActiveSceneChanged(Scene current, Scene _)
 {
     if (current.name == "GameCore")
     {
         LightColorizer.ClearLSEColorManagers();
         ObstacleColorizer.ClearOCColorManagers();
         BombColorizer.ClearBNCColorManagers();
         NoteColorizer.ClearCNVColorManagers();
         SaberColorizer.ClearBSMColorManagers();
     }
 }
コード例 #2
0
ファイル: ChromaController.cs プロジェクト: rakso20000/Chroma
#pragma warning disable SA1313 // Parameter names should begin with lower-case letter
        internal static void OnActiveSceneChanged(Scene current, Scene _)
#pragma warning restore SA1313 // Parameter names should begin with lower-case letter
        {
            if (current.name == "GameCore")
            {
                LightColorizer.ClearLSEColorManagers();
                ObstacleColorizer.ClearOCColorManagers();
                BombColorizer.ClearBNCColorManagers();
                NoteColorizer.ClearCNVColorManagers();
                SaberColorizer.ClearBSMColorManagers();
            }
        }
コード例 #3
0
ファイル: ChromaController.cs プロジェクト: JonnyXDA/Chroma
        internal static void OnActiveSceneChanged(Scene current, Scene _)
        {
            if (current.name == "GameCore")
            {
                BombColorizer.Reset();
                LightColorizer.Reset();
                NoteColorizer.Reset();
                ObstacleColorizer.Reset();
                SaberColorizer.Reset();

                TrackLaneRingsManagerAwake.RingManagers.Clear();
            }
        }
コード例 #4
0
        private bool Colorize(ChromaLightSwitchEventEffect __instance, BasicBeatmapEventData beatmapEventData)
        {
            if (!TechnicolorConfig.Instance.TechnicolorEnabled)
            {
                return(true);
            }

            LightColorizer lightColorizer = __instance.Colorizer;
            bool           warm           = !ChromaLightSwitchEventEffect.IsColor0(beatmapEventData.value);

            if (TechnicolorConfig.Instance.TechnicolorLightsGrouping == TechnicolorLightsGrouping.ISOLATED)
            {
                foreach (ILightWithId light in lightColorizer.Lights)
                {
                    Color color = TechnicolorController.GetTechnicolor(warm, beatmapEventData.time + light.GetHashCode(), TechnicolorConfig.Instance.TechnicolorLightsStyle);
                    lightColorizer.Colorize(false, color, color, color, color);
                    __instance.Refresh(true, new[] { light }, beatmapEventData);
                }

                return(false);
            }

            if (!(TechnicolorController.TechniLightRandom.NextDouble() <
                  TechnicolorConfig.Instance.TechnicolorLightsFrequency))
            {
                return(true);
            }

            {
                Color color = TechnicolorController.GetTechnicolor(warm, beatmapEventData.time, TechnicolorConfig.Instance.TechnicolorLightsStyle);
                switch (TechnicolorConfig.Instance.TechnicolorLightsGrouping)
                {
                case TechnicolorLightsGrouping.ISOLATED_GROUP:
                    lightColorizer.Colorize(false, color, color, color, color);
                    break;

                default:
                    _manager.GlobalColorize(false, color, color, color, color);
                    break;
                }
            }

            return(true);
        }
コード例 #5
0
#pragma warning disable SA1313 // Parameter names should begin with lower-case letter
        private static bool Prefix(LightSwitchEventEffect __instance, BeatmapEventData beatmapEventData, BeatmapEventType ____event, LightWithIdManager ____lightManager)
#pragma warning restore SA1313 // Parameter names should begin with lower-case letter
        {
            if (TechnicolorConfig.Instance.TechnicolorEnabled && beatmapEventData.type == ____event &&
                beatmapEventData.value > 0 && beatmapEventData.value <= 7)
            {
                if (TechnicolorConfig.Instance.TechnicolorLightsGrouping == TechnicolorLightsGrouping.ISOLATED)
                {
                    ____lightManager.SetColorForId(__instance.lightsId, TechnicolorController.GetTechnicolor(beatmapEventData.value > 3, beatmapEventData.time, TechnicolorConfig.Instance.TechnicolorLightsStyle));

                    List <LightWithId>[] lightManagerLights = _lightsWithIdAccessor(ref ____lightManager);
                    List <LightWithId>   lights             = lightManagerLights[__instance.lightsId];
                    for (int i = 0; i < lights.Count; i++)
                    {
                        lights[i].ColorWasSet(TechnicolorController.GetTechnicolor(beatmapEventData.value > 3, beatmapEventData.time + lights[i].GetInstanceID(), TechnicolorConfig.Instance.TechnicolorLightsStyle));
                    }

                    return(false);
                }
                else if (TechnicolorController.TechniLightRandom.NextDouble() < TechnicolorConfig.Instance.TechnicolorLightsFrequency)
                {
                    bool blue = beatmapEventData.value <= 3;
                    switch (TechnicolorConfig.Instance.TechnicolorLightsGrouping)
                    {
                    case TechnicolorLightsGrouping.ISOLATED_GROUP:
                        // ternary operator gore
                        ____event.SetLightingColors(
                            blue ? (Color?)TechnicolorController.GetTechnicolor(false, beatmapEventData.time, TechnicolorConfig.Instance.TechnicolorLightsStyle) : null,
                            blue ? null : (Color?)TechnicolorController.GetTechnicolor(true, beatmapEventData.time, TechnicolorConfig.Instance.TechnicolorLightsStyle));
                        break;

                    case TechnicolorLightsGrouping.STANDARD:
                    default:
                        Color?t = TechnicolorController.GetTechnicolor(!blue, beatmapEventData.time, TechnicolorConfig.Instance.TechnicolorLightsStyle);
                        LightColorizer.SetAllLightingColors(blue ? null : t, blue ? t : null);
                        break;
                    }
                }
            }

            return(true);
        }
コード例 #6
0
ファイル: ChromaController.cs プロジェクト: TheAnnoDog/Chroma
 internal static void OnActiveSceneChanged(Scene prevScene, Scene current)
 {
     if (current.name == "GameCore")
     {
         LightColorizer.ClearLSEColorManagers();
         ObstacleColorizer.ClearOCColorManagers();
         BombColorizer.ClearBNCColorManagers();
         NoteColorizer.ClearCNVColorManagers();
         SaberColorizer.ClearBSMColorManagers();
     }
     if (current.name == "MenuViewControllers" && ChromaConfig.Instance.HueEnabled == true)
     {
         HueManager.Disconnect(LightInfo.client);
     }
     if (current.name == "EmptyTransition" && prevScene.name == "MenuViewControllers" && ChromaConfig.Instance.HueEnabled == true)
     {
         hueCts.Cancel();
         hueCts = new System.Threading.CancellationTokenSource();
         HueManager.connect(hueCts.Token);
     }
 }
コード例 #7
0
 private void RainbowLights()
 {
     if (TechnicolorConfig.Instance.TechnicolorLightsGrouping == TechnicolorLightsGrouping.ISOLATED)
     {
         LightColorizer.GlobalColorize(false, _gradientLeftColor, _gradientRightColor, _gradientLeftColor, _gradientRightColor);
         foreach (LightColorizer lightColorizer in LightColorizer.Colorizers.Values)
         {
             foreach (ILightWithId light in lightColorizer.Lights)
             {
                 float seed = Math.Abs(light.GetHashCode()) % 1000;
                 seed *= 0.001f;
                 Color colorLeft  = Color.HSVToRGB(Mathf.Repeat((Time.time * TimeMult) + _mismatchSpeedOffset + seed, 1f), 1f, 1f);
                 Color colorRight = Color.HSVToRGB(Mathf.Repeat((Time.time * TimeMult) + seed, 1f), 1f, 1f);
                 lightColorizer.Colorize(new ILightWithId[] { light }, colorLeft, colorRight, colorLeft, colorRight);
             }
         }
     }
     else
     {
         LightColorizer.GlobalColorize(true, _gradientLeftColor, _gradientRightColor, _gradientLeftColor, _gradientRightColor);
     }
 }
コード例 #8
0
        private static bool Prefix(ChromaLightSwitchEventEffect __instance, BeatmapEventData beatmapEventData, BeatmapEventType ____event)
        {
            if (TechnicolorConfig.Instance.TechnicolorEnabled && beatmapEventData.type == ____event &&
                beatmapEventData.value > 0 && beatmapEventData.value <= 7)
            {
                bool warm = !__instance.IsColor0(beatmapEventData.value);
                if (TechnicolorConfig.Instance.TechnicolorLightsGrouping == TechnicolorLightsGrouping.ISOLATED)
                {
                    LightColorizer lightColorizer = __instance.LightColorizer;
                    foreach (ILightWithId light in lightColorizer.Lights)
                    {
                        Color color = TechnicolorController.GetTechnicolor(warm, beatmapEventData.time + light.GetHashCode(), TechnicolorConfig.Instance.TechnicolorLightsStyle);
                        lightColorizer.Colorize(false, color, color, color, color);
                        __instance.Refresh(true, new ILightWithId[] { light }, beatmapEventData);
                    }

                    return(false);
                }
                else if (TechnicolorController.TechniLightRandom.NextDouble() < TechnicolorConfig.Instance.TechnicolorLightsFrequency)
                {
                    Color color = TechnicolorController.GetTechnicolor(warm, beatmapEventData.time, TechnicolorConfig.Instance.TechnicolorLightsStyle);
                    switch (TechnicolorConfig.Instance.TechnicolorLightsGrouping)
                    {
                    case TechnicolorLightsGrouping.ISOLATED_GROUP:
                        ____event.ColorizeLight(false, color, color, color, color);
                        break;

                    case TechnicolorLightsGrouping.STANDARD:
                    default:
                        LightColorizer.GlobalColorize(false, color, color, color, color);
                        break;
                    }
                }
            }

            return(true);
        }
コード例 #9
0
        private static IEnumerator WaitThenStart(ParticleSystemEventEffect instance, BeatmapEventType eventType)
        {
            yield return(new WaitForEndOfFrame());

            LightColorizer.LSEStart(instance, eventType);
        }
コード例 #10
0
 private void RainbowLights()
 {
     LightColorizer.SetAllLightingColors(_gradientLeftColor, _gradientRightColor);
     LightColorizer.SetAllActiveColors();
 }
コード例 #11
0
        internal static void InitializeComponents(Transform root, Transform original, List <GameObjectInfo> gameObjectInfos, List <IComponentData> componentDatas, int?lightID)
        {
            void GetComponentAndOriginal <T>(Action <T, T> initializeDelegate)
            {
                T[] rootComponents     = root.GetComponents <T>();
                T[] originalComponents = original.GetComponents <T>();

                for (int i = 0; i < rootComponents.Length; i++)
                {
                    initializeDelegate(rootComponents[i], originalComponents[i]);

                    if (Settings.ChromaConfig.Instance !.PrintEnvironmentEnhancementDebug)
                    {
                        Plugin.Logger.Log($"Initialized {typeof(T).Name}");
                    }
                }
            }

            GetComponentAndOriginal <LightWithIdMonoBehaviour>((rootComponent, originalComponent) =>
            {
                _lightWithIdMonoBehaviourManagerAccessor(ref rootComponent) = _lightWithIdMonoBehaviourManagerAccessor(ref originalComponent);
                LightColorizer.RegisterLight(rootComponent, lightID);
            });

            GetComponentAndOriginal <LightWithIds>((rootComponent, originalComponent) =>
            {
                _lightWithIdsManagerAccessor(ref rootComponent) = _lightWithIdsManagerAccessor(ref originalComponent);
                LightColorizer.RegisterLight(rootComponent, lightID);
            });

            GetComponentAndOriginal <TrackLaneRing>((rootComponent, originalComponent) =>
            {
                if (EnvironmentEnhancementManager.RingRotationOffsets.TryGetValue(originalComponent, out Quaternion offset))
                {
                    EnvironmentEnhancementManager.RingRotationOffsets.Add(rootComponent, offset);
                }

                _ringTransformAccessor(ref rootComponent)  = root;
                _positionOffsetAccessor(ref rootComponent) = _positionOffsetAccessor(ref originalComponent);
                _posZAccessor(ref rootComponent)           = _posZAccessor(ref originalComponent);

                TrackLaneRingsManager?managerToAdd = null;
                foreach (TrackLaneRingsManager manager in HarmonyPatches.TrackLaneRingsManagerAwake.RingManagers)
                {
                    TrackLaneRingsManagerComponentData componentData = componentDatas.OfType <TrackLaneRingsManagerComponentData>().Where(n => n.OldTrackLaneRingsManager == manager).FirstOrDefault();
                    if (componentData != null)
                    {
                        managerToAdd = componentData.NewTrackLaneRingsManager;
                    }
                    else
                    {
                        TrackLaneRingsManager managerRef = manager;
                        TrackLaneRing[] rings            = _ringsAccessor(ref managerRef);
                        if (rings.Contains(originalComponent))
                        {
                            managerToAdd = manager;
                        }
                    }

                    if (managerToAdd != null)
                    {
                        // ToList() to add and then back ToArray()
                        TrackLaneRing[] rings          = _ringsAccessor(ref managerToAdd);
                        List <TrackLaneRing> ringsList = rings?.ToList() ?? new List <TrackLaneRing>();
                        ringsList.Add(rootComponent);
                        _ringsAccessor(ref managerToAdd) = ringsList.ToArray();

                        break;
                    }
                }
            });

            GetComponentAndOriginal <TrackLaneRingsPositionStepEffectSpawner>((rootComponent, originalComponent) =>
            {
                foreach (TrackLaneRingsManager manager in HarmonyPatches.TrackLaneRingsManagerAwake.RingManagers)
                {
                    TrackLaneRingsManagerComponentData?componentData = componentDatas.OfType <TrackLaneRingsManagerComponentData>().Where(n => n.OldTrackLaneRingsManager == manager).FirstOrDefault();
                    if (componentData != null)
                    {
                        _stepSpawnerRingsManagerAccessor(ref rootComponent) = componentData.NewTrackLaneRingsManager !;

                        break;
                    }
                }
            });

            GetComponentAndOriginal <ChromaRingsRotationEffect>((rootComponent, originalComponent) =>
            {
                foreach (TrackLaneRingsManager manager in HarmonyPatches.TrackLaneRingsManagerAwake.RingManagers)
                {
                    TrackLaneRingsManagerComponentData?componentData = componentDatas.OfType <TrackLaneRingsManagerComponentData>().Where(n => n.OldTrackLaneRingsManager == manager).FirstOrDefault();
                    if (componentData != null)
                    {
                        rootComponent.SetNewRingManager(componentData.NewTrackLaneRingsManager !);

                        break;
                    }
                }
            });

            GetComponentAndOriginal <TrackLaneRingsRotationEffectSpawner>((rootComponent, originalComponent) =>
            {
                _rotationEffectSpawnerCallbackControllerAccessor(ref rootComponent) = _rotationEffectSpawnerCallbackControllerAccessor(ref originalComponent);
                _trackLaneRingsRotationEffectAccessor(ref rootComponent)            = rootComponent.GetComponent <ChromaRingsRotationEffect>();
            });

            GetComponentAndOriginal <Spectrogram>((rootComponent, originalComponent) => _spectrogramDataAccessor(ref rootComponent) = _spectrogramDataAccessor(ref originalComponent));

            GetComponentAndOriginal <LightRotationEventEffect>((rootComponent, originalComponent) => _lightCallbackControllerAccessor(ref rootComponent) = _lightCallbackControllerAccessor(ref originalComponent));

            GetComponentAndOriginal <LightPairRotationEventEffect>((rootComponent, originalComponent) =>
            {
                _lightPairCallbackControllerAccessor(ref rootComponent) = _lightPairCallbackControllerAccessor(ref originalComponent);

                Transform transformL = _transformLAccessor(ref originalComponent);
                Transform transformR = _transformRAccessor(ref originalComponent);

                _transformLAccessor(ref rootComponent) = root.GetChild(transformL.GetSiblingIndex());
                _transformRAccessor(ref rootComponent) = root.GetChild(transformR.GetSiblingIndex());

                // We have to enable the object to tell unity to run Start
                rootComponent.enabled = true;
            });

            GetComponentAndOriginal <ParticleSystemEventEffect>((rootComponent, originalComponent) =>
            {
                _particleCallbackControllerAccessor(ref rootComponent) = _particleCallbackControllerAccessor(ref originalComponent);
                _particleSystemAccessor(ref rootComponent)             = root.GetComponent <ParticleSystem>();

                rootComponent.enabled = true;
            });

            GetComponentAndOriginal <Mirror>((rootComponent, originalComponent) =>
            {
                _mirrorRendererAccessor(ref rootComponent) = UnityEngine.Object.Instantiate(_mirrorRendererAccessor(ref originalComponent));
                _mirrorMaterialAccessor(ref rootComponent) = UnityEngine.Object.Instantiate(_mirrorMaterialAccessor(ref originalComponent));
            });

            GameObjectInfo newGameObjectInfo = new GameObjectInfo(root.gameObject);

            gameObjectInfos.Add(newGameObjectInfo);

            foreach (Transform transform in root)
            {
                int index = transform.GetSiblingIndex();
                InitializeComponents(transform, original.GetChild(index), gameObjectInfos, componentDatas, lightID);
            }
        }