public static Image <Rgba32> GenerateParallax(TomlTable config, Size size, ISawmill sawmill, List <Image <Rgba32> > debugLayerDump)
        {
            sawmill.Debug("Generating parallax!");
            var generator = new ParallaxGenerator();

            generator._loadConfig(config);

            sawmill.Debug("Timing start!");
            var sw = new Stopwatch();

            sw.Start();
            var image = new Image <Rgba32>(Configuration.Default, size.Width, size.Height, new Rgba32(0, 0, 0, 255));
            var count = 0;

            foreach (var layer in generator.Layers)
            {
                layer.Apply(image);
                debugLayerDump?.Add(image.Clone());
                sawmill.Debug("Layer {0} done!", count++);
            }

            sw.Stop();
            sawmill.Debug("Total time: {0}", sw.Elapsed.TotalSeconds);

            return(image);
        }
        public static Image <Rgba32> GenerateParallax(TomlTable config, Size size)
        {
            Logger.DebugS("parallax", "Generating parallax!");
            var generator = new ParallaxGenerator();

            generator._loadConfig(config);

            var image = new Image <Rgba32>(Configuration.Default, size.Width, size.Height, Rgba32.Black);
            var count = 0;

            foreach (var layer in generator.Layers)
            {
                layer.Apply(image);
                Logger.DebugS("parallax", "Layer {0} done!", count++);
            }

            return(image);
        }
        public async void LoadParallax()
        {
            if (!_configurationManager.GetCVar <bool>("parallax.enabled"))
            {
                return;
            }

            Stream    configStream = null;
            string    contents;
            TomlTable table;

            try
            {
                // Load normal config into memory
                if (!_resourceCache.TryContentFileRead(ParallaxConfigPath, out configStream))
                {
                    Logger.ErrorS("parallax", "Parallax config not found.");
                    return;
                }

                using (var reader = new StreamReader(configStream, EncodingHelpers.UTF8))
                {
                    contents = reader.ReadToEnd();
                }

                if (_resourceCache.UserData.Exists(ParallaxConfigOld))
                {
                    bool match;
                    using (var data = _resourceCache.UserData.Open(ParallaxConfigOld, FileMode.Open))
                        using (var reader = new StreamReader(data, EncodingHelpers.UTF8))
                        {
                            match = reader.ReadToEnd() == contents;
                        }

                    if (match)
                    {
                        using (var stream = _resourceCache.UserData.Open(ParallaxPath, FileMode.Open))
                        {
                            ParallaxTexture = Texture.LoadFromPNGStream(stream, "Parallax");
                        }

                        OnTextureLoaded?.Invoke(ParallaxTexture);
                        return;
                    }
                }

                table = Toml.ReadString(contents);
            }
            finally
            {
                configStream?.Dispose();
            }

            var sawmill = _logManager.GetSawmill("parallax");
            // Generate the parallax in the thread pool.
            var image = await Task.Run(() => ParallaxGenerator.GenerateParallax(table, new Size(1920, 1080), sawmill));

            // And load it in the main thread for safety reasons.
            ParallaxTexture = Texture.LoadFromImage(image, "Parallax");

            // Store it and CRC so further game starts don't need to regenerate it.
            using (var stream = _resourceCache.UserData.Open(ParallaxPath, FileMode.Create))
            {
                image.SaveAsPng(stream);
            }

            using (var stream = _resourceCache.UserData.Open(ParallaxConfigOld, FileMode.Create))
                using (var writer = new StreamWriter(stream, EncodingHelpers.UTF8))
                {
                    writer.Write(contents);
                }

            OnTextureLoaded?.Invoke(ParallaxTexture);
        }
        public async void LoadParallax()
        {
            if (!_configurationManager.GetCVar <bool>("parallax.enabled"))
            {
                return;
            }

            var       debugParallax = _configurationManager.GetCVar <bool>("parallax.debug");
            string    contents;
            TomlTable table;

            // Load normal config into memory
            if (!_resourceCache.TryContentFileRead(ParallaxConfigPath, out var configStream))
            {
                Logger.ErrorS("parallax", "Parallax config not found.");
                return;
            }

            using (configStream)
            {
                using (var reader = new StreamReader(configStream, EncodingHelpers.UTF8))
                {
                    contents = reader.ReadToEnd();
                }

                if (!debugParallax && _resourceCache.UserData.Exists(ParallaxConfigOld))
                {
                    var match = _resourceCache.UserData.ReadAllText(ParallaxConfigOld) == contents;

                    if (match)
                    {
                        using (var stream = _resourceCache.UserData.OpenRead(ParallaxPath))
                        {
                            ParallaxTexture = Texture.LoadFromPNGStream(stream, "Parallax");
                        }

                        OnTextureLoaded?.Invoke(ParallaxTexture);
                        return;
                    }
                }

                table = Toml.ReadString(contents);
            }

            List <Image <Rgba32> > debugImages = null;

            if (debugParallax)
            {
                debugImages = new List <Image <Rgba32> >();
            }

            var sawmill = _logManager.GetSawmill("parallax");
            // Generate the parallax in the thread pool.
            var image = await Task.Run(() =>
                                       ParallaxGenerator.GenerateParallax(table, new Size(1920, 1080), sawmill, debugImages));

            // And load it in the main thread for safety reasons.
            ParallaxTexture = Texture.LoadFromImage(image, "Parallax");

            // Store it and CRC so further game starts don't need to regenerate it.
            using (var stream = _resourceCache.UserData.Create(ParallaxPath))
            {
                image.SaveAsPng(stream);
            }

            if (debugParallax)
            {
                var i = 0;
                foreach (var debugImage in debugImages)
                {
                    using (var stream = _resourceCache.UserData.Create(new ResourcePath($"/parallax_debug_{i}.png")))
                    {
                        debugImage.SaveAsPng(stream);
                    }

                    i += 1;
                }
            }

            image.Dispose();

            using (var stream = _resourceCache.UserData.Create(ParallaxConfigOld))
                using (var writer = new StreamWriter(stream, EncodingHelpers.UTF8))
                {
                    writer.Write(contents);
                }

            OnTextureLoaded?.Invoke(ParallaxTexture);
        }