WPF создание эффекта «Созвездия».

Что такое WPF?

Windows Presentation Foundation — один из компонентов ядра .NET Framework, который позволяет разработчикам создавать богатые, различные Windows приложения.

Как создать эффект созвездия для WPF?

Для того, чтобы создать эффект созвездия, для начала необходимо понять, как он работает. Алгоритм достаточно прост. На поле существуют точки, которые постоянно перемещаются в случайном направлении. Если расстояние между точками меньше чем допустимого, появляется связь.

Кроме этого, курсор мыши так же считается точкой, поэтому, когда вы перемещаетесь по фону, от курсора до ближайшей точки создаётся связь.

Перейдём к настройке и написанию кода. Для начала стоит настроить форму. Она выглядит следующим образом:

Точки - Настройка формы

Элементы, которые используются на данной сцене:

<Canvas x:Name="canvas"/>
<Grid>
<Label Content="Введите логин:" HorizontalAlignment="Center" Margin="266,190,384,288" VerticalAlignment="Center" Width="110"/>
<TextBox HorizontalAlignment="Center" Height="22" Margin="266,220,294,262" TextWrapping="Wrap" Text="" VerticalAlignment="Center" Width="200"/>
<Label Content="Введите пароль:" HorizontalAlignment="Center" Margin="266,248,384,230" VerticalAlignment="Center" Width="110"/>
<PasswordBox HorizontalAlignment="Center" Margin="266,279,294,201" VerticalAlignment="Center" Width="200" Height="24"/>
<Button Content="Войти" HorizontalAlignment="Center" Margin="266,308,420,176" VerticalAlignment="Center" Width="74"/>
</Grid>
  • Canvas – используется для создания эффекта созвездия;
  • Label, TextBox, PasswordBox – дополнительные элементы для авторизации.

Самый важный элемент, это Canvas, который имеет x:Name = “canvas”. Через него и будет создаваться эффект созвездия.

Весь эффект создаётся в три слоя:

  • 1 слой со светлыми серыми точками на заднем фоне;
  • 2 слой с серыми точками на заднем фоне;
  • 3 слой с чёрными точками на переднем фоне.

И так, переходим к написанию кода, отвечающего за создание точек.

Пишем эффект созвездия.

Для начала объявим переменный, необходимые для работы скрипта:

/// <summary> /// колличество точек в слое /// </summary>
public int count = 75; /// <summary> /// шаг перемещения точки /// </summary> 
public int maxTranform = 1; /// <summary> /// минимальная длина между токами для создания связи на переднем слое /// </summary> 
public float minDistantion = 50; /// <summary> /// минимальная длина между токами для создания связи на заднем слое /// </summary> 
public float minDistantionBackground = 60; /// <summary> /// минимальная длина между токами для создания связи на втором заднем слое /// </summary> 
public float minDistantionBackground2 = 70; /// <summary> /// максимальный размер точек /// </summary> 
public int maxSize = 8; /// <summary> /// класс с информацией о точке /// </summary> 
public class ellipseInfo {     /// <summary>     /// координата точки     /// </summary>     
    public int x { get; set; }     /// <summary>     /// координата точки     /// </summary>     
    public int y { get; set; }     /// <summary>     /// фигура точки     /// </summary>     
    public Ellipse ellipse { get; set; }     /// <summary>     /// линия точки     /// </summary>     
    public List<Line> lines = new List<Line>();
} /// <summary> /// массив точек на переднем плане /// </summary> 
public List<ellipseInfo> allEllipse = new List<ellipseInfo>(); /// <summary> /// массив точек на заднем плане /// </summary> 
public List<ellipseInfo> allEllipseBackground = new List<ellipseInfo>(); /// <summary> /// массив точек на втором заднем плане /// </summary> 
public List<ellipseInfo> allEllipseBackground2 = new List<ellipseInfo>(); /// <summary> /// таймер запускающий функции перемещения точек /// </summary> 
DispatcherTimer dispatcherTimer = new DispatcherTimer(); 

Далее необходимо создать три одинаковые функции, которые будут создавать точки на разных слоях. Почему три? Не знаю. Я сделал разделение так. Если вы не плохо разбираетесь в коде, то вы можете переписать всё в одну.

/// <summary> /// Метод создающий первоначальные точки для paralax /// </summary> 
public void CreateParalax() {
    Random random = new Random();
    for (int i = 0; i < count; i++)
    {
        ellipseInfo newElement = new ellipseInfo();
        newElement.x = random.Next(20, (int)Width - 20);
        newElement.y = random.Next(20, (int)Height - 20);
        Ellipse ellipse = new Ellipse();
        Canvas.SetLeft(ellipse, newElement.x);
        Canvas.SetTop(ellipse, newElement.y);
        int widthEllips = random.Next(3, maxSize);
        ellipse.Width = widthEllips;
        ellipse.Height = widthEllips;
        ellipse.Fill = new SolidColorBrush(Colors.Black);
        newElement.ellipse = ellipse;
        canvas.Children.Add(newElement.ellipse);
        allEllipse.Add(newElement);
    }
    ellipseInfo mouseElement = new ellipseInfo();
    mouseElement.x = (int)Mouse.GetPosition(canvas).X;
    mouseElement.y = (int)Mouse.GetPosition(canvas).Y;
    Ellipse mouseEllipse = new Ellipse();
    mouseEllipse.Width = 2;
    mouseEllipse.Height = 2;
    Canvas.SetLeft(mouseEllipse, mouseElement.x);
    Canvas.SetTop(mouseEllipse, mouseElement.y);
    mouseElement.ellipse = mouseEllipse;
    canvas.Children.Add(mouseElement.ellipse);
    allEllipse.Add(mouseElement); } /// <summary> /// Метод создающий первоначальные точки для paralax /// </summary>
public void CreateParalaxBackground() {
    // создаём рандом    
    Random random = new Random();     // создаём точки  
    for (int i = 0; i < count; i++)
    {         // создаём жллемент      
        ellipseInfo newElement = new ellipseInfo();         // устанавливаем рандомные координаты, обходя границы формы   
        newElement.x = random.Next(20, (int)Width - 20);
        newElement.y = random.Next(20, (int)Height - 20);         // создаём круг       
        Ellipse ellipse = new Ellipse();         // задаём координаты точки     
        Canvas.SetLeft(ellipse, newElement.x);
        Canvas.SetTop(ellipse, newElement.y);         // задаём рандомную ширину и высоту точки 
        int widthEllips = random.Next(3, maxSize);         // устанавливаем ширину и высоту точек    
        ellipse.Width = widthEllips;
        ellipse.Height = widthEllips;         // задаём цвет точки        
        ellipse.Fill = new SolidColorBrush(Colors.LightGray);         // присваиваем информации о точке, точку на canvas'e   
        newElement.ellipse = ellipse;         // создаём точку на canvas'e   
        canvas.Children.Add(newElement.ellipse);         // добавляем информацию о точке, в массив точек     
        allEllipseBackground.Add(newElement);
    }     // создаём информацию о точке для курсора мыши
    ellipseInfo mouseElement = new ellipseInfo();     // устанавливаем координаты для точки  
    mouseElement.x = (int)Mouse.GetPosition(canvas).X;
    mouseElement.y = (int)Mouse.GetPosition(canvas).Y;     // создаём круг
    Ellipse mouseEllipse = new Ellipse();     // задаём ширину и высоту круга
    mouseEllipse.Width = 2;
    mouseEllipse.Height = 2;
    Canvas.SetLeft(mouseEllipse, mouseElement.x);
    Canvas.SetTop(mouseEllipse, mouseElement.y);     // присваиваем информации о точке, круг на canvas'e  
    mouseElement.ellipse = mouseEllipse;     // создаём круг на canvas'e   
    canvas.Children.Add(mouseElement.ellipse);     // добовляем информацию о точке в массив точек  
    allEllipseBackground.Add(mouseElement); } /// <summary> /// Метод создающий первоначальные точки для paralax /// </summary> 
public void CreateParalaxBackground2() {
    Random random = new Random();
    for (int i = 0; i < count; i++)
    {
        ellipseInfo newElement = new ellipseInfo();
        newElement.x = random.Next(20, (int)Width - 20);
        newElement.y = random.Next(20, (int)Height - 20);
        Ellipse ellipse = new Ellipse();
        Canvas.SetLeft(ellipse, newElement.x);
        Canvas.SetTop(ellipse, newElement.y);
        int widthEllips = random.Next(3, maxSize);
        ellipse.Width = widthEllips;
        ellipse.Height = widthEllips;
        ellipse.Fill = new SolidColorBrush(Colors.Gray);
        newElement.ellipse = ellipse;
        canvas.Children.Add(newElement.ellipse);
        allEllipseBackground2.Add(newElement);
    }
    ellipseInfo mouseElement = new ellipseInfo();
    mouseElement.x = (int)Mouse.GetPosition(canvas).X;
    mouseElement.y = (int)Mouse.GetPosition(canvas).Y;
    Ellipse mouseEllipse = new Ellipse();
    mouseEllipse.Width = 2;
    mouseEllipse.Height = 2;
    Canvas.SetLeft(mouseEllipse, mouseElement.x);
    Canvas.SetTop(mouseEllipse, mouseElement.y);
    mouseElement.ellipse = mouseEllipse;
    canvas.Children.Add(mouseElement.ellipse);
    allEllipseBackground2.Add(mouseElement);
}

Данные функции необходимо вызвать в функции, после инициализации формы в следующем порядке:

CreateParalaxBackground();
CreateParalaxBackground2();
CreateParalax();

При запуске приложения можно увидеть что функции создают точки на заднем фоне приложения:

Точки - Созданные точки

Следующими методами станут три функции, которые отвечают за перемещение и создание линий между точками на каждом из слоёв.

Код для перемещения:

/// <summary> /// Обновление позиции точек /// </summary> /// 
//<param name="sender"></param> /// <param name="e"></param> 
private void UpdateParalax(object sender, EventArgs e)
{
    // создаём андом  
    Random random = new Random();     // переназначаем точке курсора координаты курсора  
    allEllipse[count].x = (int)Mouse.GetPosition(canvas).X;
    allEllipse[count].y = (int)Mouse.GetPosition(canvas).Y;     // перебираем все точки в слое   
    for (int i = 0; i < allEllipse.Count; i++)
    {         // если точка из списка созданных     
        if (i < count)
        {             // ограничиваем перемещение по лувому и правому краю     
            if (allEllipse[i].x < 20)
            {                 // перемещаем точку на новую координату         
                allEllipse[i].x += random.Next(0, maxTranform);
            }
            else if (allEllipse[i].x > Width - 20)
            {                 // перемещаем точку на новую координату  
                allEllipse[i].x += random.Next(-maxTranform, 0);
            }
            else                 // перемещаем точку на новую координату        
                allEllipse[i].x += random.Next(-maxTranform, maxTranform + 1);             // ограничиваем перемещение по верхнему и нижнему краю      
            if (allEllipse[i].y < 20)
            {                 // перемещаем точку на новую координату              
                allEllipse[i].y += random.Next(0, maxTranform);
            }
            else if (allEllipse[i].y > Height - 20)
            {                 // перемещаем точку на новую координату           
                allEllipse[i].y += random.Next(-maxTranform, 0);
            }
            else                 // перемещаем точку на новую координату   
                allEllipse[i].y += random.Next(-maxTranform, maxTranform + 1);
        }         // перемещаем точку на canvas'e    
        Canvas.SetLeft(allEllipse[i].ellipse, allEllipse[i].x);
        Canvas.SetTop(allEllipse[i].ellipse, allEllipse[i].y);         // перебираем линии точки, удаляя все созданные   
        for (int j = 0; j < allEllipse[i].lines.Count; j++)
        {
            canvas.Children.Remove(allEllipse[i].lines[j]);
            allEllipse[i].lines.Remove(allEllipse[i].lines[j]);
        }         // перебираем оставшиеся точки, для создания линий   
        for (int j = i + 1; j < allEllipse.Count; j++)
        {             // вычисляем координаты точки 1          
            double x1 = allEllipse[i].x + allEllipse[i].ellipse.Width / 2;
            double y1 = allEllipse[i].y + allEllipse[i].ellipse.Width / 2;             // вычисляем координаты точки 2  
            double x2 = allEllipse[j].x + allEllipse[j].ellipse.Width / 2;
            double y2 = allEllipse[j].y + allEllipse[j].ellipse.Width / 2;
            double distantion = Math.Sqrt(Math.Pow((x2 - x1), 2) + Math.Pow((y2 - y1), 2));
            if (distantion < minDistantion)
            {
                Line line = new Line();
                line.X1 = x1;
                line.Y1 = y1;
                line.X2 = x2;
                line.Y2 = y2;
                line.Stroke = new SolidColorBrush(Colors.Black);
                line.StrokeThickness = 1;
                canvas.Children.Add(line);
                allEllipse[i].lines.Add(line);
            }
        }
    }
} /// <summary> /// Обновление позиции точек заднего фона /// </summary> /// <param name="sender"></param> /// <param name="e"></param> 
private void UpdateParalaxBackground(object sender, EventArgs e)
{
    Random random = new Random();
    allEllipseBackground[count].x = (int)Mouse.GetPosition(canvas).X;
    allEllipseBackground[count].y = (int)Mouse.GetPosition(canvas).Y;
    for (int i = 0; i < allEllipseBackground.Count; i++)
    {
        if (i < count)
        {             // Ограничение перемещения по лувому и правому краю    
            if (allEllipseBackground[i].x < 20)
            {
                allEllipseBackground[i].x += random.Next(0, maxTranform);
            }
            else if (allEllipseBackground[i].x > Width - 20)
            { allEllipseBackground[i].x += random.Next(-maxTranform, 0); }
            else allEllipseBackground[i].x += random.Next(-maxTranform, maxTranform + 1);             // ограничение перемещение по верхнему и нижнему краю    
            if (allEllipseBackground[i].y < 20) { allEllipseBackground[i].y += random.Next(0, maxTranform);
            } else if (allEllipseBackground[i].y > Height - 20) {
                allEllipseBackground[i].y += random.Next(-maxTranform, 0);
            } else allEllipseBackground[i].y += random.Next(-maxTranform, maxTranform + 1);
        }
        Canvas.SetLeft(allEllipseBackground[i].ellipse, allEllipseBackground[i].x);
        Canvas.SetTop(allEllipseBackground[i].ellipse, allEllipseBackground[i].y);
        for (int j = 0; j < allEllipseBackground[i].lines.Count; j++) {
            canvas.Children.Remove(allEllipseBackground[i].lines[j]);
            allEllipseBackground[i].lines.Remove(allEllipseBackground[i].lines[j]);
        }
        for (int j = i + 1; j < allEllipse.Count; j++) {
            double x1 = allEllipseBackground[i].x + allEllipseBackground[i].ellipse.Width / 2;
            double y1 = allEllipseBackground[i].y + allEllipseBackground[i].ellipse.Width / 2;
            double x2 = allEllipseBackground[j].x + allEllipseBackground[j].ellipse.Width / 2;
            double y2 = allEllipseBackground[j].y + allEllipseBackground[j].ellipse.Width / 2;
            double distantion = Math.Sqrt(Math.Pow((x2 - x1), 2) + Math.Pow((y2 - y1), 2));
            if (distantion < minDistantionBackground) {
                Line line = new Line();
                line.X1 = x1;
                line.Y1 = y1;
                line.X2 = x2;
                line.Y2 = y2;
                line.Stroke = new SolidColorBrush(Colors.LightGray);
                line.StrokeThickness = 1;
                canvas.Children.Add(line);
                allEllipseBackground[i].lines.Add(line);
            }
        }
    }
} /// <summary> /// Обновление позиции точек заднего фона /// </summary> /// <param name="sender"></param> /// <param name="e"></param> 
private void UpdateParalaxBackground2(object sender, EventArgs e)
{
    Random random = new Random();
    allEllipseBackground2[count].x = (int)Mouse.GetPosition(canvas).X;
    allEllipseBackground2[count].y = (int)Mouse.GetPosition(canvas).Y;
    for (int i = 0; i < allEllipseBackground2.Count; i++)
    {
        if (i < count)
        {             // Ограничение перемещения по лувому и правому краю           
            if (allEllipseBackground2[i].x < 20) { allEllipseBackground2[i].x += random.Next(0, maxTranform);
            } else if (allEllipseBackground2[i].x > Width - 20) {
                allEllipseBackground2[i].x += random.Next(-maxTranform, 0);
            } else allEllipseBackground2[i].x += random.Next(-maxTranform, maxTranform + 1);             // ограничение перемещение по верхнему и нижнему краю      
            if (allEllipseBackground2[i].y < 20) {
                allEllipseBackground2[i].y += random.Next(0, maxTranform);
            } else if (allEllipseBackground2[i].y > Height - 20) {
                allEllipseBackground2[i].y += random.Next(-maxTranform, 0);
            } else allEllipseBackground2[i].y += random.Next(-maxTranform, maxTranform + 1);
        }
        Canvas.SetLeft(allEllipseBackground2[i].ellipse, allEllipseBackground2[i].x);
        Canvas.SetTop(allEllipseBackground2[i].ellipse, allEllipseBackground2[i].y);
        for (int j = 0; j < allEllipseBackground2[i].lines.Count; j++) {
            canvas.Children.Remove(allEllipseBackground2[i].lines[j]);
            allEllipseBackground2[i].lines.Remove(allEllipseBackground2[i].lines[j]);
        }
        for (int j = i + 1; j < allEllipse.Count; j++) {
            double x1 = allEllipseBackground2[i].x + allEllipseBackground2[i].ellipse.Width / 2;
            double y1 = allEllipseBackground2[i].y + allEllipseBackground2[i].ellipse.Width / 2;
            double x2 = allEllipseBackground2[j].x + allEllipseBackground2[j].ellipse.Width / 2;
            double y2 = allEllipseBackground2[j].y + allEllipseBackground2[j].ellipse.Width / 2;
            double distantion = Math.Sqrt(Math.Pow((x2 - x1), 2) + Math.Pow((y2 - y1), 2));
            if (distantion < minDistantionBackground2) {
                Line line = new Line();
                line.X1 = x1;
                line.Y1 = y1;
                line.X2 = x2;
                line.Y2 = y2;
                line.Stroke = new SolidColorBrush(Colors.Gray);
                line.StrokeThickness = 1;
                canvas.Children.Add(line);
                allEllipseBackground2[i].lines.Add(line);
            }
        }
    }
}

Последним действием необходимо после инициализации формы и создания точек вызвать создать таймер, который будет вызывать эти самые функции перемещение через некоторое время.

dispatcherTimer.Interval = new TimeSpan(0, 0, 0, 0, 1000 / 30);
dispatcherTimer.Tick += UpdateParalaxBackground;
dispatcherTimer.Tick += UpdateParalaxBackground2;
dispatcherTimer.Tick += UpdateParalax;
dispatcherTimer.Start();

На этом, создание эффекта созвездия завершено, всё то вам необходимо сделать, это запустить приложение.

Точки - Эффект созвездия

При перемещении мыши вы увидите, как происходит создание связей между точками и курсором.

Весь код:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Data;
using System.Windows.Documents;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Imaging;
using System.Windows.Navigation;
using System.Windows.Shapes;
using System.Windows.Threading;
namespace Paralax
{     /// <summary>     /// Логика взаимодействия для MainWindow.xaml     /// </summary>     
    public partial class MainWindow : Window
    {         /// <summary>         /// колличество точек в слое         /// </summary>         
        public int count = 75;         /// <summary>         /// шаг перемещения точки         /// </summary>        
        public int maxTranform = 1;         /// <summary>         /// минимальная длина между токами для создания связи на переднем слое         /// </summary>     
        public float minDistantion = 50;         /// <summary>         /// минимальная длина между токами для создания связи на заднем слое         /// </summary>       
        public float minDistantionBackground = 60;         /// <summary>         /// минимальная длина между токами для создания связи на втором заднем слое         /// </summary>    
        public float minDistantionBackground2 = 70;         /// <summary>         /// максимальный размер точек         /// </summary>     
        public int maxSize = 8;         /// <summary>         /// класс с информацией о точке         /// </summary>      
        public class ellipseInfo
        {             /// <summary>             /// координата точки             /// </summary>        
            public int x { get; set; }             /// <summary>             /// координата точки             /// </summary>       
            public int y { get; set; }             /// <summary>             /// фигура точки             /// </summary>        
            public Ellipse ellipse { get; set; }             /// <summary>             /// линия точки             /// </summary>      
            public List<Line> lines = new List<Line>();
        }         /// <summary>         /// массив точек на переднем плане         /// </summary>    
        public List<ellipseInfo> allEllipse = new List<ellipseInfo>();         /// <summary>         /// массив точек на заднем плане         /// </summary>    
        public List<ellipseInfo> allEllipseBackground = new List<ellipseInfo>();         /// <summary>         /// массив точек на втором заднем плане         /// </summary>      
        public List<ellipseInfo> allEllipseBackground2 = new List<ellipseInfo>();         /// <summary>         /// таймер запускающий функции перемещения точек         /// </summary>       
        DispatcherTimer dispatcherTimer = new DispatcherTimer();
        public MainWindow() {
            InitializeComponent();
            CreateParalaxBackground();
            CreateParalaxBackground2();
            CreateParalax();
            dispatcherTimer.Interval = new TimeSpan(0, 0, 0, 0, 1000 / 30);
            dispatcherTimer.Tick += UpdateParalaxBackground;
            dispatcherTimer.Tick += UpdateParalaxBackground2;
            dispatcherTimer.Tick += UpdateParalax; dispatcherTimer.Start();
        }         /// <summary>         /// Обновление позиции точек         /// </summary>         /// <param name="sender"></param>         /// <param name="e"></param>     
        private void UpdateParalax(object sender, EventArgs e)
        {             // создаём андом    
            Random random = new Random();             // переназначаем точке курсора координаты курсора   
            allEllipse[count].x = (int)Mouse.GetPosition(canvas).X;
            allEllipse[count].y = (int)Mouse.GetPosition(canvas).Y;             // перебираем все точки в слое      
            for (int i = 0; i < allEllipse.Count; i++)
            {                 // если точка из списка созданных             
                if (i < count)
                {                     // ограничиваем перемещение по лувому и правому краю         
                    if (allEllipse[i].x < 20)
                    {                         // перемещаем точку на новую координату             
                        allEllipse[i].x += random.Next(0, maxTranform);
                    }
                    else if (allEllipse[i].x > Width - 20)
                    {                         // перемещаем точку на новую координату                 
                        allEllipse[i].x += random.Next(-maxTranform, 0);
                    }
                    else                         // перемещаем точку на новую координату         
                        allEllipse[i].x += random.Next(-maxTranform, maxTranform + 1);                     // ограничиваем перемещение по верхнему и нижнему краю        
                    if (allEllipse[i].y < 20)
                    {                         // перемещаем точку на новую координату                  
                        allEllipse[i].y += random.Next(0, maxTranform);
                    }
                    else if (allEllipse[i].y > Height - 20)
                    {                         // перемещаем точку на новую координату                     
                        allEllipse[i].y += random.Next(-maxTranform, 0);
                    }
                    else                         // перемещаем точку на новую координату    
                        allEllipse[i].y += random.Next(-maxTranform, maxTranform + 1);
                }                                  // перемещаем точку на canvas'e          
                Canvas.SetLeft(allEllipse[i].ellipse, allEllipse[i].x);
                Canvas.SetTop(allEllipse[i].ellipse, allEllipse[i].y);                 // перебираем линии точки, удаляя все созданные            
                for (int j = 0; j < allEllipse[i].lines.Count; j++) {
                    canvas.Children.Remove(allEllipse[i].lines[j]);
                    allEllipse[i].lines.Remove(allEllipse[i].lines[j]);
                }                 // перебираем оставшиеся точки, для создания линий            
                for (int j = i + 1; j < allEllipse.Count; j++)
                {                     // вычисляем координаты точки 1              
                    double x1 = allEllipse[i].x + allEllipse[i].ellipse.Width/2;
                    double y1 = allEllipse[i].y + allEllipse[i].ellipse.Width / 2;                     // вычисляем координаты точки 2               
                    double x2 = allEllipse[j].x + allEllipse[j].ellipse.Width / 2;
                    double y2 = allEllipse[j].y + allEllipse[j].ellipse.Width / 2;
                    double distantion = Math.Sqrt(Math.Pow((x2 - x1), 2) + Math.Pow((y2 - y1), 2));
                    if (distantion < minDistantion)
                    {
                        Line line = new Line();
                        line.X1 = x1;
                        line.Y1 = y1;
                        line.X2 = x2;
                        line.Y2 = y2;
                        line.Stroke = new SolidColorBrush(Colors.Black);
                        line.StrokeThickness = 1;
                        canvas.Children.Add(line);
                        allEllipse[i].lines.Add(line);
                    }
                }
            }
        }         /// <summary>         /// Обновление позиции точек заднего фона         /// </summary>         /// <param name="sender"></param>         /// <param name="e"></param>   
        private void UpdateParalaxBackground(object sender, EventArgs e)
        {
            Random random = new Random();
            allEllipseBackground[count].x = (int)Mouse.GetPosition(canvas).X;
            allEllipseBackground[count].y = (int)Mouse.GetPosition(canvas).Y;
            for (int i = 0; i < allEllipseBackground.Count; i++)
            {
                if (i < count)
                {                     // Ограничение перемещения по лувому и правому краю     
                    if (allEllipseBackground[i].x < 20)
                    {
                        allEllipseBackground[i].x += random.Next(0, maxTranform);
                    }
                    else if (allEllipseBackground[i].x > Width - 20)
                    {
                        allEllipseBackground[i].x += random.Next(-maxTranform, 0);
                    }
                    else
                        allEllipseBackground[i].x += random.Next(-maxTranform, maxTranform + 1);
                    // ограничение перемещение по верхнему и нижнему краю           
                    if (allEllipseBackground[i].y < 20)
                    {
                        allEllipseBackground[i].y += random.Next(0, maxTranform);
                    }
                    else if (allEllipseBackground[i].y > Height - 20)
                    {
                        allEllipseBackground[i].y += random.Next(-maxTranform, 0);
                    }
                    else
                        allEllipseBackground[i].y += random.Next(-maxTranform, maxTranform + 1);
                }
                Canvas.SetLeft(allEllipseBackground[i].ellipse, allEllipseBackground[i].x);
                Canvas.SetTop(allEllipseBackground[i].ellipse, allEllipseBackground[i].y);
                for (int j = 0; j < allEllipseBackground[i].lines.Count; j++)
                {
                    canvas.Children.Remove(allEllipseBackground[i].lines[j]);
                    allEllipseBackground[i].lines.Remove(allEllipseBackground[i].lines[j]);
                }
                for (int j = i + 1; j < allEllipse.Count; j++)
                {
                    double x1 = allEllipseBackground[i].x + allEllipseBackground[i].ellipse.Width / 2;
                    double y1 = allEllipseBackground[i].y + allEllipseBackground[i].ellipse.Width / 2;
                    double x2 = allEllipseBackground[j].x + allEllipseBackground[j].ellipse.Width / 2;
                    double y2 = allEllipseBackground[j].y + allEllipseBackground[j].ellipse.Width / 2;
                    double distantion = Math.Sqrt(Math.Pow((x2 - x1), 2) + Math.Pow((y2 - y1), 2));
                    if (distantion < minDistantionBackground)
                    {
                        Line line = new Line();
                        line.X1 = x1;
                        line.Y1 = y1;
                        line.X2 = x2;
                        line.Y2 = y2;
                        line.Stroke = new SolidColorBrush(Colors.LightGray);
                        line.StrokeThickness = 1;
                        canvas.Children.Add(line);
                        allEllipseBackground[i].lines.Add(line);
                    }
                }
            }
        }         /// <summary>         /// Обновление позиции точек заднего фона         /// </summary>         /// <param name="sender"></param>         /// <param name="e"></param>  
        private void UpdateParalaxBackground2(object sender, EventArgs e)
        {
            Random random = new Random();
            allEllipseBackground2[count].x = (int)Mouse.GetPosition(canvas).X;
            allEllipseBackground2[count].y = (int)Mouse.GetPosition(canvas).Y;
            for (int i = 0; i < allEllipseBackground2.Count; i++)
            {
                if (i < count)
                {                     // Ограничение перемещения по лувому и правому краю              
                    if (allEllipseBackground2[i].x < 20)
                    {
                        allEllipseBackground2[i].x += random.Next(0, maxTranform);
                    }
                    else if (allEllipseBackground2[i].x > Width - 20)
                    {
                        allEllipseBackground2[i].x += random.Next(-maxTranform, 0);
                    }
                    else
                        allEllipseBackground2[i].x += random.Next(-maxTranform, maxTranform + 1);                     // ограничение перемещение по верхнему и нижнему краю     
                    if (allEllipseBackground2[i].y < 20)
                    {
                        allEllipseBackground2[i].y += random.Next(0, maxTranform);
                    }
                    else if (allEllipseBackground2[i].y > Height - 20)
                    {
                        allEllipseBackground2[i].y += random.Next(-maxTranform, 0);
                    }
                    else
                        allEllipseBackground2[i].y += random.Next(-maxTranform, maxTranform + 1);
                }
                Canvas.SetLeft(allEllipseBackground2[i].ellipse, allEllipseBackground2[i].x);
                Canvas.SetTop(allEllipseBackground2[i].ellipse, allEllipseBackground2[i].y);
                for (int j = 0; j < allEllipseBackground2[i].lines.Count; j++)
                {
                    canvas.Children.Remove(allEllipseBackground2[i].lines[j]);
                    allEllipseBackground2[i].lines.Remove(allEllipseBackground2[i].lines[j]);
                }
                for (int j = i + 1; j < allEllipse.Count; j++)
                {
                    double x1 = allEllipseBackground2[i].x + allEllipseBackground2[i].ellipse.Width / 2;
                    double y1 = allEllipseBackground2[i].y + allEllipseBackground2[i].ellipse.Width / 2;
                    double x2 = allEllipseBackground2[j].x + allEllipseBackground2[j].ellipse.Width / 2;
                    double y2 = allEllipseBackground2[j].y + allEllipseBackground2[j].ellipse.Width / 2;
                    double distantion = Math.Sqrt(Math.Pow((x2 - x1), 2) + Math.Pow((y2 - y1), 2));
                    if (distantion < minDistantionBackground2)
                    {
                        Line line = new Line();
                        line.X1 = x1;
                        line.Y1 = y1;
                        line.X2 = x2;
                        line.Y2 = y2;
                        line.Stroke = new SolidColorBrush(Colors.Gray);
                        line.StrokeThickness = 1;
                        canvas.Children.Add(line);
                        allEllipseBackground2[i].lines.Add(line);
                    }
                }
            }
        }         /// <summary>         /// Метод создающий первоначальные точки для paralax    
    /// </summary>     
public void CreateParalax()   
    {
            Random random = new Random();
            for (int i = 0; i < count; i++)
            {
                ellipseInfo newElement = new ellipseInfo();
                newElement.x = random.Next(20, (int)Width - 20);
                newElement.y = random.Next(20, (int)Height - 20);
                Ellipse ellipse = new Ellipse();
                Canvas.SetLeft(ellipse, newElement.x);
                Canvas.SetTop(ellipse, newElement.y);
                int widthEllips = random.Next(3, maxSize);
                ellipse.Width = widthEllips;
                ellipse.Height = widthEllips;
                ellipse.Fill = new SolidColorBrush(Colors.Black);
                newElement.ellipse = ellipse;
                canvas.Children.Add(newElement.ellipse);
                allEllipse.Add(newElement);
            }
            ellipseInfo mouseElement = new ellipseInfo();
            mouseElement.x = (int)Mouse.GetPosition(canvas).X;
            mouseElement.y = (int)Mouse.GetPosition(canvas).Y;
            Ellipse mouseEllipse = new Ellipse();
            mouseEllipse.Width = 2;
            mouseEllipse.Height = 2;
            Canvas.SetLeft(mouseEllipse, mouseElement.x);
            Canvas.SetTop(mouseEllipse, mouseElement.y);
            mouseElement.ellipse = mouseEllipse;
            canvas.Children.Add(mouseElement.ellipse);
            allEllipse.Add(mouseElement);
        }         /// <summary>         /// Метод создающий первоначальные точки для paralax         /// </summary>         
        public void CreateParalaxBackground()
        {             // создаём рандом     
            Random random = new Random();             // создаём точки      
            for (int i = 0; i < count; i++)
            {                 // создаём жллемент          
                ellipseInfo newElement = new ellipseInfo();                 // устанавливаем рандомные координаты, обходя границы формы      
                newElement.x = random.Next(20, (int)Width - 20);
                newElement.y = random.Next(20, (int)Height - 20);                 // создаём круг                 
                Ellipse ellipse = new Ellipse();                 // задаём координаты точки              
                Canvas.SetLeft(ellipse, newElement.x);
                Canvas.SetTop(ellipse, newElement.y);                 // задаём рандомную ширину и высоту точки          
                int widthEllips = random.Next(3, maxSize);                 // устанавливаем ширину и высоту точек             
                ellipse.Width = widthEllips;
                ellipse.Height = widthEllips;                 // задаём цвет точки             
                ellipse.Fill = new SolidColorBrush(Colors.LightGray);                 // присваиваем информации о точке, точку на canvas'e               
                newElement.ellipse = ellipse;                 // создаём точку на canvas'e           
                canvas.Children.Add(newElement.ellipse);                 // добавляем информацию о точке, в массив точек           
                allEllipseBackground.Add(newElement);
            }             // создаём информацию о точке для курсора мыши      
            ellipseInfo mouseElement = new ellipseInfo();             // устанавливаем координаты для точки       
            mouseElement.x = (int)Mouse.GetPosition(canvas).X;
            mouseElement.y = (int)Mouse.GetPosition(canvas).Y;             // создаём круг         
            Ellipse mouseEllipse = new Ellipse();             // задаём ширину и высоту круга         
            mouseEllipse.Width = 2;
            mouseEllipse.Height = 2;
            Canvas.SetLeft(mouseEllipse, mouseElement.x);
            Canvas.SetTop(mouseEllipse, mouseElement.y);             // присваиваем информации о точке, круг на canvas'e   
            mouseElement.ellipse = mouseEllipse;             // создаём круг на canvas'e       
            canvas.Children.Add(mouseElement.ellipse);             // добовляем информацию о точке в массив точек        
            allEllipseBackground.Add(mouseElement);         }         /// <summary>         /// Метод создающий первоначальные точки для paralax         /// </summary>    
        public void CreateParalaxBackground2()
        {
            Random random = new Random();
            for (int i = 0; i < count; i++)
            {
                ellipseInfo newElement = new ellipseInfo();
                newElement.x = random.Next(20, (int)Width - 20);
                newElement.y = random.Next(20, (int)Height - 20);
                Ellipse ellipse = new Ellipse();
                Canvas.SetLeft(ellipse, newElement.x);
                Canvas.SetTop(ellipse, newElement.y);
                int widthEllips = random.Next(3, maxSize);
                ellipse.Width = widthEllips;
                ellipse.Height = widthEllips;
                ellipse.Fill = new SolidColorBrush(Colors.Gray);
                newElement.ellipse = ellipse;
                canvas.Children.Add(newElement.ellipse);
                allEllipseBackground2.Add(newElement);
            }
            ellipseInfo mouseElement = new ellipseInfo();
            mouseElement.x = (int)Mouse.GetPosition(canvas).X;
            mouseElement.y = (int)Mouse.GetPosition(canvas).Y;
            Ellipse mouseEllipse = new Ellipse();
            mouseEllipse.Width = 2;
            mouseEllipse.Height = 2;
            Canvas.SetLeft(mouseEllipse, mouseElement.x);
            Canvas.SetTop(mouseEllipse, mouseElement.y);
            mouseElement.ellipse = mouseEllipse;
            canvas.Children.Add(mouseElement.ellipse);
            allEllipseBackground2.Add(mouseElement);
        }
    }
} 

Автор статьи: Александр Каримов.

Пока нет оценок, но вы можете быть первым!

Оцените