Example #1
0
        /// <summary>
        /// 制作背景图片
        /// </summary>
        /// <param name="pictureFileFullPath"></param>
        /// <param name="fileDirectory"></param>
        /// <param name="textContent"></param>
        /// <returns></returns>
        static string GenerateWallPaper(string pictureFileFullPath, string fileDirectory, string textContent)
        {
            var   wic  = new SharpDX.WIC.ImagingFactory2();
            var   d2d  = new SharpDX.Direct2D1.Factory();
            float dpi  = d2d.DesktopDpi.Width;
            Size2 size = new Size2(Screen.PrimaryScreen.Bounds.Width, Screen.PrimaryScreen.Bounds.Height);

            SharpDX.WIC.FormatConverter image = CreateWicImage(wic, pictureFileFullPath);
            using var wicBitmap     = new SharpDX.WIC.Bitmap(wic, size.Width, size.Height, SharpDX.WIC.PixelFormat.Format32bppPBGRA, SharpDX.WIC.BitmapCreateCacheOption.CacheOnDemand);
            using var target        = new SharpDX.Direct2D1.WicRenderTarget(d2d, wicBitmap, new SharpDX.Direct2D1.RenderTargetProperties());
            using var dc            = target.QueryInterface <SharpDX.Direct2D1.DeviceContext>();
            using var bmpPicture    = SharpDX.Direct2D1.Bitmap.FromWicBitmap(target, image);
            using var dwriteFactory = new SharpDX.DirectWrite.Factory();
            using var brush         = new SolidColorBrush(target, SharpDX.Color.LightGoldenrodYellow);
            using var bmpLayer      = new SharpDX.Direct2D1.Bitmap1(dc, target.PixelSize,
                                                                    new SharpDX.Direct2D1.BitmapProperties1(new SharpDX.Direct2D1.PixelFormat(SharpDX.DXGI.Format.B8G8R8A8_UNorm, SharpDX.Direct2D1.AlphaMode.Premultiplied), dpi, dpi, SharpDX.Direct2D1.BitmapOptions.Target));
            var oldTarget = dc.Target;

            dc.Target = bmpLayer;
            target.BeginDraw();
            {
                var textFormat = new SharpDX.DirectWrite.TextFormat(dwriteFactory, "Tahoma", size.Height / 27);

                // draw textContent
                {
                    var textLayout = new SharpDX.DirectWrite.TextLayout(dwriteFactory, textContent, textFormat, target.Size.Width * 0.75f, float.MaxValue);
                    var center     = new Vector2((target.Size.Width - textLayout.Metrics.Width) / 2, (target.Size.Height - textLayout.Metrics.Height) / 2);
                    target.DrawTextLayout(new Vector2(center.X, center.Y), textLayout, brush);
                }
                //{
                //    // draw otherContent
                //    var textLayout = new SharpDX.DirectWrite.TextLayout(dwriteFactory, chinese, textFormat, target.Size.Width * 0.75f, float.MaxValue);
                //    var center = new Vector2((target.Size.Width - textLayout.Metrics.Width) / 2, target.Size.Height - textLayout.Metrics.Height - size.Height / 18);
                //    target.DrawTextLayout(new Vector2(center.X, center.Y), textLayout, brush);
                //}
            }
            target.EndDraw();

            // shadow
            var shadow = new SharpDX.Direct2D1.Effects.Shadow(dc);

            shadow.SetInput(0, bmpLayer, new RawBool(false));

            dc.Target = oldTarget;
            target.BeginDraw();
            {
                target.DrawBitmap(bmpPicture, new SharpDX.RectangleF(0, 0, target.Size.Width, target.Size.Height), 1.0f, BitmapInterpolationMode.Linear);
                dc.DrawImage(shadow, new Vector2(size.Height / 150.0f, size.Height / 150.0f));
                dc.UnitMode = UnitMode.Pixels;
                target.DrawBitmap(bmpLayer, 1.0f, BitmapInterpolationMode.Linear);
            }
            target.EndDraw();
            if (!Directory.Exists(fileDirectory))
            {
                Directory.CreateDirectory(fileDirectory);
            }
            string wallpaperFileName = fileDirectory + DateTime.Now.ToString("yyyyMMdd") + "_" + "wallpaper.png";

            using var wallpaperStream = File.OpenWrite(wallpaperFileName);
            SaveD2DBitmap(wic, wicBitmap, wallpaperStream);
            wallpaperStream.Close();
            return(wallpaperFileName);
        }
Example #2
0
        public static string GenerateWallpaper(string pictureFileName, string english, string chinese, string weather)
        {
            var   wic = new WIC.ImagingFactory2();
            var   d2d = new D2D.Factory();
            float dpi = d2d.DesktopDpi.Width;

            Size2 size = new Size2(Screen.PrimaryScreen.Bounds.Width, Screen.PrimaryScreen.Bounds.Height);

            WIC.FormatConverter image = CreateWicImage(wic, pictureFileName);
            using (var wicBitmap = new WIC.Bitmap(wic, size.Width, size.Height, WIC.PixelFormat.Format32bppPBGRA, WIC.BitmapCreateCacheOption.CacheOnDemand))
                using (var target = new D2D.WicRenderTarget(d2d, wicBitmap, new D2D.RenderTargetProperties()))
                    using (var dc = target.QueryInterface <D2D.DeviceContext>())
                        using (var bmpPicture = Bitmap.FromWicBitmap(target, image))
                            using (var dwriteFactory = new SharpDX.DirectWrite.Factory())
                                using (var brush = new SolidColorBrush(target, new RawColor4(255, 255, 0, 1)))
                                    using (var bmpLayer = new D2D.Bitmap1(dc, target.PixelSize,
                                                                          new D2D.BitmapProperties1(new D2D.PixelFormat(SharpDX.DXGI.Format.B8G8R8A8_UNorm, AlphaMode.Premultiplied), dpi, dpi, BitmapOptions.Target)))
                                    {
                                        var oldTarget = dc.Target;
                                        dc.Target = bmpLayer;
                                        target.BeginDraw();
                                        {
                                            var textFormat = new DWrite.TextFormat(dwriteFactory, "Tahoma", size.Height / 27);

                                            // draw English
                                            {
                                                var textLayout = new DWrite.TextLayout(dwriteFactory, english, textFormat, target.Size.Width * 0.75f, float.MaxValue);
                                                var center     = new Vector2((target.Size.Width - textLayout.Metrics.Width) / 2, (target.Size.Height - textLayout.Metrics.Height) / 2);
                                                target.DrawTextLayout(new RawVector2(center.X, center.Y), textLayout, brush);
                                            }
                                            {
                                                var textLayout = new DWrite.TextLayout(dwriteFactory, chinese, textFormat, target.Size.Width * 0.75f, float.MaxValue);
                                                var center     = new Vector2((target.Size.Width - textLayout.Metrics.Width) / 2, target.Size.Height - textLayout.Metrics.Height - size.Height / 18);
                                                target.DrawTextLayout(new RawVector2(center.X, center.Y), textLayout, brush);
                                            }
                                            {
                                                var textLayout = new DWrite.TextLayout(dwriteFactory, weather, textFormat, target.Size.Width * 0.75f, float.MaxValue);
                                                var center     = new Vector2((target.Size.Width - textLayout.Metrics.Width) / 2, size.Height / 18 + textLayout.Metrics.Height);
                                                target.DrawTextLayout(new RawVector2(center.X, center.Y), textLayout, brush);
                                            }
                                        }
                                        target.EndDraw();

                                        // shadow
                                        var shadow = new D2D.Effects.Shadow(dc);
                                        shadow.SetInput(0, bmpLayer, new RawBool(false));

                                        dc.Target = oldTarget;
                                        target.BeginDraw();
                                        {
                                            target.DrawBitmap(bmpPicture, new SharpDX.Mathematics.Interop.RawRectangleF(0, 0, target.Size.Width, target.Size.Height), 1.0f, BitmapInterpolationMode.Linear);
                                            dc.DrawImage(shadow, new RawVector2(size.Height / 150.0f, size.Height / 150.0f));
                                            dc.UnitMode = UnitMode.Pixels;
                                            target.DrawBitmap(bmpLayer, 1.0f, BitmapInterpolationMode.Linear);
                                        }
                                        target.EndDraw();

                                        string wallpaperFileName = Path.GetTempPath() + "wallpaper.png";
                                        using (var wallpaperStream = File.OpenWrite(wallpaperFileName))
                                        {
                                            SaveD2DBitmap(wic, wicBitmap, wallpaperStream);
                                            wallpaperStream.Close();
                                            return(wallpaperFileName);
                                        }
                                    }
        }
Example #3
0
        public static byte[] CreatePngImage(int width, int height, string text,
                                            float fontSize         = 30.0f,
                                            string font            = "Times New Roman",
                                            int lineCount          = 5,
                                            bool rotation          = false,
                                            float turbulenceAmount = 60.0f)
        {
            using (var wic = new WIC.ImagingFactory2())
                using (var d2d = new D2D.Factory())
                    using (var wicBitmap = new WIC.Bitmap(wic, width, height, WIC.PixelFormat.Format32bppPBGRA, WIC.BitmapCreateCacheOption.CacheOnDemand))
                        using (var target = new D2D.WicRenderTarget(d2d, wicBitmap, new D2D.RenderTargetProperties()))
                            using (var dwriteFactory = new DWrite.Factory())
                                using (var brush = new D2D.SolidColorBrush(target, Color.Yellow))
                                    using (var encoder = new WIC.PngBitmapEncoder(wic))

                                        using (var ms = new MemoryStream())
                                            using (var dc = target.QueryInterface <D2D.DeviceContext>())
                                                using (var bmpLayer = new D2D.Bitmap1(dc, target.PixelSize,
                                                                                      new D2D.BitmapProperties1(new D2D.PixelFormat(SharpDX.DXGI.Format.B8G8R8A8_UNorm, D2D.AlphaMode.Premultiplied),
                                                                                                                d2d.DesktopDpi.Width, d2d.DesktopDpi.Height,
                                                                                                                D2D.BitmapOptions.Target)))
                                                {
                                                    var r = new Random();
                                                    encoder.Initialize(ms);

                                                    D2D.Image oldTarget = dc.Target;

                                                    {
                                                        dc.Target = bmpLayer;
                                                        dc.BeginDraw();
                                                        var textFormat = new DWrite.TextFormat(dwriteFactory, font, fontSize);
                                                        for (int charIndex = 0; charIndex < text.Length; ++charIndex)
                                                        {
                                                            using (var layout = new DWrite.TextLayout(dwriteFactory, text[charIndex].ToString(), textFormat, float.MaxValue, float.MaxValue))
                                                            {
                                                                var layoutSize = new Vector2(layout.Metrics.Width, layout.Metrics.Height);
                                                                using (var b2 = new D2D.LinearGradientBrush(dc, new D2D.LinearGradientBrushProperties
                                                                {
                                                                    StartPoint = Vector2.Zero,
                                                                    EndPoint = layoutSize,
                                                                }, new D2D.GradientStopCollection(dc, new[]
                                                                {
                                                                    new D2D.GradientStop {
                                                                        Position = 0.0f, Color = ColorFromHsl(r.NextFloat(0, 1), 1.0f, 0.8f)
                                                                    },
                                                                    new D2D.GradientStop {
                                                                        Position = 1.0f, Color = ColorFromHsl(r.NextFloat(0, 1), 1.0f, 0.8f)
                                                                    },
                                                                })))
                                                                {
                                                                    var position = new Vector2(charIndex * width / text.Length, r.NextFloat(0, height - layout.Metrics.Height));
                                                                    dc.Transform =
                                                                        Matrix3x2.Translation(-layoutSize / 2) *
                                                                        Matrix3x2.Skew(r.NextFloat(0, 0.5f), r.NextFloat(0, 0.5f)) *
                                                                        (rotation ? Matrix3x2.Rotation(r.NextFloat(0, (float)(Math.PI * 2))) : Matrix3x2.Identity) *
                                                                        Matrix3x2.Translation(position + layoutSize / 2);
                                                                    dc.DrawTextLayout(Vector2.Zero, layout, b2);
                                                                }
                                                            }
                                                        }
                                                        for (var i = 0; i < lineCount; ++i)
                                                        {
                                                            target.Transform = Matrix3x2.Identity;
                                                            brush.Color      = ColorFromHsl(r.NextFloat(0, 1), 1.0f, 0.3f);
                                                            target.DrawLine(
                                                                r.NextVector2(Vector2.Zero, new Vector2(width, height)),
                                                                r.NextVector2(Vector2.Zero, new Vector2(width, height)),
                                                                brush, 3.0f);
                                                        }
                                                        target.EndDraw();
                                                    }

                                                    Color background = ColorFromHsl(r.NextFloat(0, 1), 1.0f, 0.3f);
                                                    {
                                                        dc.Target = null;
                                                        using (var displacement = new D2D.Effects.DisplacementMap(dc))
                                                        {
                                                            displacement.SetInput(0, bmpLayer, true);
                                                            displacement.Scale = turbulenceAmount;

                                                            var turbulence = new D2D.Effects.Turbulence(dc);
                                                            displacement.SetInputEffect(1, turbulence);

                                                            dc.Target = oldTarget;
                                                            dc.BeginDraw();
                                                            dc.Clear(background);
                                                            dc.DrawImage(displacement);
                                                            dc.EndDraw();

                                                            using (var frame = new WIC.BitmapFrameEncode(encoder))
                                                            {
                                                                frame.Initialize();
                                                                frame.SetSize(wicBitmap.Size.Width, wicBitmap.Size.Height);

                                                                var pixelFormat = wicBitmap.PixelFormat;
                                                                frame.SetPixelFormat(ref pixelFormat);
                                                                frame.WriteSource(wicBitmap);

                                                                frame.Commit();
                                                            }
                                                        }
                                                    }

                                                    encoder.Commit();
                                                    return(ms.ToArray());
                                                }
        }