private static IEnumerator StopParticles()
        {
            foreach (ParticleSystem particles in LoopingParticles.Keys)
            {
                if (particles == null)
                {
                    continue;
                }
                ScreenshotMachine.Log("Stopping particle " + particles.name);
                particles.Stop();
            }

            yield return(new WaitForSeconds(ScreenshotMachine.Settings.stoppedTime)); // Wait the stopped time

            foreach (ParticleSystem key in LoopingParticles.Keys)
            {
                if (key == null)
                {
                    continue;
                }

                ParticleSystem.Particle[] particleSystems = new ParticleSystem.Particle[key.particleCount];
                key.GetParticles(particleSystems);
                float extraWait = 0f;
                foreach (ParticleSystem.Particle particle in particleSystems)
                {
                    if (particle.remainingLifetime > 0f && particle.remainingLifetime > extraWait)
                    {
                        extraWait = particle.remainingLifetime;
                    }
                }

                // ReSharper disable once CompareOfFloatsByEqualityOperator
                if (extraWait != 0f)
                {
                    ScreenshotMachine.Log($"The established stopped time wasn't enough for all the particles to disappear! Waiting an extra {extraWait} seconds");
                }
                yield return(new WaitForSeconds(extraWait));

                ParticleSystem.EmissionModule emissionModule = key.emission;
                emissionModule.rateOverTimeMultiplier = 0f;
            }

            CoroutineStarter.StartCoroutine(StartParticles());
        }
        private static IEnumerator FindParticles()
        {
            yield return(null); // Wait 1 frame wait for sceneLoaded hook

            LoopingParticles.Clear();

            ScreenshotMachine.Log("Finding particles for scene " + UnityEngine.SceneManagement.SceneManager.GetActiveScene().name);

            foreach (ParticleSystem particleSystem in Object.FindObjectsOfType <ParticleSystem>().Where(particle => particle.isPlaying &&
                                                                                                        !IsParentedToLiving(particle.transform) &&
                                                                                                        LayersToStop.Contains((PhysLayers)particle.gameObject.layer)))
            {
                if (particleSystem == null)
                {
                    continue;
                }
                LoopingParticles.Add(particleSystem, particleSystem.emission.rateOverTimeMultiplier);
            }

            CoroutineStarter.StartCoroutine(StopParticles());
        }
Exemplo n.º 3
0
        private static IEnumerator DrawCenterLines()
        {
            ScreenshotMachine.Log("Drawing middle intersection lines...");

            GameObject lineCanvas = CanvasUtil.CreateCanvas(RenderMode.ScreenSpaceCamera, new Vector2(1920, 1080));


            GameObject lines = CanvasUtil.CreateImagePanel(lineCanvas, LineSprite,
                                                           new CanvasUtil.RectData(Vector2.zero, Vector2.zero, Vector2.zero, Vector2.one));

            lines.gameObject.AddComponent <CanvasGroup>();
            CanvasGroup group = lines.gameObject.GetComponent <CanvasGroup>();

            group.interactable   = false;
            group.blocksRaycasts = false;



            yield return(new WaitUntil(() => !_lineDrawn));

            ScreenshotMachine.Log("Destroying middle intersection lines...");
            Object.Destroy(lines);
        }
        private static IEnumerator StartParticles()
        {
            ScreenshotMachine.Log("Starting particles back up");

            // ReSharper disable once CompareOfFloatsByEqualityOperator
            if (ScreenshotMachine.Settings.displayTime == 0f)
            {
                yield break;
            }

            float startTime = Time.time;

            foreach (ParticleSystem key in LoopingParticles.Keys)
            {
                if (key == null)
                {
                    continue;
                }
                key.time = 0f;
                if (ScreenshotMachine.Settings.alwaysUseSameSeedForParticles)
                {
                    key.randomSeed = 1;
                }
                key.Play();
            }

            float t = 0f;

            while (t <= 1f)
            {
                foreach (KeyValuePair <ParticleSystem, float> pair in LoopingParticles)
                {
                    if (pair.Key == null)
                    {
                        continue;
                    }

                    if (!pair.Key.isPlaying)
                    {
                        pair.Key.Play();
                    }

                    ParticleSystem.EmissionModule emissionModule = pair.Key.emission;
                    emissionModule.rateOverTimeMultiplier = Mathf.Lerp(0, pair.Value, t);
                }

                t = (Time.time - startTime) / (ScreenshotMachine.Settings.displayTime);
                yield return(null);
            }

            foreach (KeyValuePair <ParticleSystem, float> pair in LoopingParticles)
            {
                ScreenshotMachine.Log("End of loop");
                if (pair.Key == null)
                {
                    continue;
                }

                ParticleSystem.EmissionModule emissionModule = pair.Key.emission;

                emissionModule.rateOverTimeMultiplier = pair.Value;
            }

            CoroutineStarter.StartCoroutine(StopParticles());
        }