/// <summary>
 /// Initializes a new instance of the <c>LightWeightPolylineVertex</c> class.
 /// </summary>
 public LightWeightPolylineVertex()
 {
     this.location = Vector2d.Zero;
     this.bulge = 0.0f;
     this.beginThickness = 0.0f;
     this.endThickness = 0.0f;
 }

        public void Rotate(Vector2d startPoint, Vector2d endPoint)
        {
            var rotation = CalculateRotation(startPoint, endPoint);
            _tempCameraOrientation = rotation.GetRotationMatrix();

            FireCameraChanged();
        }

 public static Vector2d Next(this Random random, Vector2d min, Vector2d max)
 {
     return new Vector2d(
         min.X + random.NextDouble() * (max.X - min.X),
         min.Y + random.NextDouble() * (max.Y - min.Y)
     );
 }

 public Bullet(Vector2d From, Vector2d To, DateTime st)
 {
     ShootTime = DateTime.Now;
     this.From = From;
     this.To = To;
     this.dir = Vector2d.Normalize(To - From);
 }

 /// <summary>
 /// Initializes a new instance of the <c>LightWeightPolylineVertex</c> class.
 /// </summary>
 /// <param name="location">Lightweight polyline <see cref="netDxf.Vector2d">vertex</see> coordinates.</param>
 public LightWeightPolylineVertex(Vector2d location)
 {
     this.location = location;
     this.bulge = 0.0;
     this.beginThickness = 0.0f;
     this.endThickness = 0.0f;
 }

 public Vertex(double px, double py, double pz, /*double nx, double ny, double nz,*/ double tcx, double tcy)
 {
     Position = new Vector3d(px, py, pz);
     //Normal = new Vector3d(nx, ny, nz);
     TexCoord = new Vector2d(tcx, tcy);
     Color = Vector4.One;
 }

        public Vector2d TransformToRelative(Vector2d absoluteCoordinate)
        {
            var x = absoluteCoordinate.X / Control.Width * 2 - 1;
            var y = (Control.Height - absoluteCoordinate.Y) / Control.Height * 2 - 1;

            return new Vector2d(x, y);
        }

        public void Loop(TimeSpan loopTime)
        {
            foreach (var connection in Graph.Connectivities)
            {
                var node1 = connection.Node1;
                var node2 = connection.Node2;

                var distance = Vector2d.GetDistance(node1.Position, node2.Position);
                if (distance < 0.1)
                {
                    // Jitter
                    distance = 0.1;
                }

                var forceS = Settings.DistanceToForceFct(distance);
                forceS *= Settings.ForceFactor;
                forceS *= connection.Connectivity;

                var dX = Math.Max(0.1, node1.Position.X - node2.Position.X);
                var dY = Math.Max(0.1, node1.Position.Y - node2.Position.Y);

                Vector2d force = new Vector2d(forceS * dX / distance, forceS * dY / distance);
                node1.ForceN.AddTo(force.Negate());
                node2.ForceN.AddTo(force);
            }
        }

	/*
     * Returns the square distance between the given point and the line
     * defined by this segment.
     *
     * @param p a point.
     */
	public double LineDistSq(Vector2d p) 
	{
		Vector2d ap = p - a;
		double dotprod = ab.Dot(ap);
		double projLenSq = dotprod * dotprod / ab.SqrMagnitude();
		return ap.SqrMagnitude() - projLenSq;
	}

 public static bool IsReal(Vector2d v)
 {
     return !IsNaN(v) && !double.IsPositiveInfinity(v.X) &&
         !double.IsNegativeInfinity(v.X) &&
         !double.IsPositiveInfinity(v.Y) &&
         !double.IsNegativeInfinity(v.Y);
 }

 public void Update()
 {
     double elapsed = (DateTime.Now - st).TotalMilliseconds;
     //dir = Vector2d.Normalize(To - From);
     //position = From + ((elapsed * Speed) * dir);
     position = P.GetPosition(elapsed, Speed);
 }

        public Vector2d TransformToRelative(Vector2d absoluteCoordinate)
        {
            var x = absoluteCoordinate.X / Interface.Width * 2 - 1;
            var y = (Interface.Height - absoluteCoordinate.Y) / Interface.Height * 2 - 1;

            return new Vector2d(x, y);
        }

	public Vector4d(Vector2d v, double z, double w) 
	{ 
		x = v.x; 
		y = v.y; 
		this.z = z;
		this.w = w;
	}

        public void Rotate(Vector2d startPoint, Vector2d endPoint)
        {
            var rotation = CalculateRotation(startPoint, endPoint);

            var result = Vector3d.Transform(_camera.Position, rotation);
            _camera.Position = result;
        }

 public static void Circle(Vector2d origin, double radius, double currentZoom = 1, int sides = 0, bool loop = false)
 {
     if (sides < 3)
     {
         if (radius < 20) sides = 16;
         else if (radius < 50) sides = 24;
         else if (radius < 100) sides = 42;
         else if (radius < 300) sides = 64;
         else sides = 128;
     }
     radius /= currentZoom;
     var diff = (2 * Math.PI) / sides;
     var last = new Vector2d(0, 0);
     for (var i = 0; i < sides; i++)
     {
         var deg = diff * i;
         var point = new Vector2d(origin.X + Math.Cos(deg) * radius, origin.Y + Math.Sin(deg) * radius);
         if (i > 0 || loop)
         {
             if (!loop) GL.Vertex2(last);
             GL.Vertex2(point);
         }
         last = point;
     }
     if (loop) return;
     GL.Vertex2(last);
     GL.Vertex2(origin.X + radius, origin.Y);
 }

 public RenderElement(Vector3d[] pos, Vector3d[] nor, Vector2d[] tex, int[] idx)
 {
     this.pos = pos;
     this.nor = nor;
     this.tex = tex;
     this.idx = idx;
 }

 /// <summary>
 /// Constructor with default velocity, i.e. 1.0.
 /// </summary>
 /// <param name="initialPosition">The particle's initial position</param>
 /// <param name="maxLifetime">The particle's maximum lifetime</param>
 /// <param name="agingVelocity">The particle's aging velocity</param>
 public AirParticle(Vector2d initialPosition, int maxLifetime, int agingVelocity)
     : base(initialPosition, maxLifetime, agingVelocity)
 {
     this.Position = initialPosition;
     this.RemainingLifetime = maxLifetime;
     SetAgingVelocity(agingVelocity);
 }

 public override void Initialize(LSAgent agent)
 {
     Body = agent.Body;
     timescaledTurnRate = TurnRate * LockstepManager.Timestep >> FixedMath.SHIFT_AMOUNT;
     TargetReached = true;
     TargetRotation = Vector2d.up;
 }

 public void Update(DateTime st)
 {
     double t = (DateTime.Now - ShootTime).TotalMilliseconds;
     position = From + Vector2d.Multiply(dir, Bullet.Speed * t);
     if ((position - From).LengthSquared > (From - To).LengthSquared)
         HitEnd = true;
 }

        /// <see cref="PositionUpdater.UpdatePositions(List{Particle})"/>
        /// <summary>
        /// Initiates the particle moving behaviour and directions
        /// </summary>
        public void UpdatePositions(List<Particle> particles)
        {
            bool isFire = true;
            foreach (var particle in particles) {
                if (isFire) {
                    Random rand = new Random ();
                    double x = rand.NextDouble ();
                    // To generate movings of the particles
                    if (x > 0.5) {
                        x = x - 1;
                    }
                    x = x / 5;

                    Vector2d Translation = new Vector2d (x, DEFAULT_DELTA);
                    particle.updatePosition (Translation);
                    isFire = false;
                } else {
                    Random rand = new Random ();
                    double x = rand.NextDouble ();
                    if (x > 0.5) {
                        x = x - 1;
                    }
                    x = x / 5;

                    Vector2d Translation = new Vector2d (x, -DEFAULT_DELTA);
                    particle.updatePosition (Translation);
                    isFire = true;
                }
            }
        }