/// <summary>
 /// Draws out the particle with the given drawable at the
 /// particle's position.
 /// </summary>
 public void Draw(IDrawable drawable, DrawingArgs args)
 {
     double ratio = secondsRemaining / Constants.MaxSwarmParticleLife;
     Color c = Color.FromArgb((int) (ratio * 255.0), Color.White);
     PointF p = new PointF(CurrentX, CurrentY);
     drawable.Draw(p, c, args.BackendDrawingArgs);
 }

 public BeamRenderer(int count, IDrawable part, Vector3 dist)
 {
     Count = count;
     Part = part;
     Distance = dist;
     Offset = Matrix4Extensions.FromTranslation(Distance);
 }

 public GlListDrawable(IDrawable drawable)
 {
     if (drawable == null) { throw new ArgumentNullException("drawable"); }
     this.refresh = -1;
     this.drawable = drawable;
     this.bufferedDrawable = drawable as BufferedDrawable;
 }

 internal static void AddObject (IDrawable obj)
 {
     var client = CallContext.Client;
     if (!objects.ContainsKey (client))
         objects [client] = new List<IDrawable> ();
     objects [client].Add (obj);
 }

        /// <summary>
        /// Constructs the tile drawable object.
        /// </summary>
        public TileDrawable(
			Tile tile,
			IDrawable drawable)
        {
            this.tile = tile;
            this.drawable = drawable;
        }

 public void Add(IDrawable drawable)
 {
     if (drawable == null) throw new ArgumentNullException("drawable"); 
     lock (_drawingsSync) {
         _grpdrawings.Add(drawable);
     }
 }

 public IDrawable remove(IDrawable d)
 {
     bool removed=myDrawables.Remove(d);
     if (index >= myDrawables.Count)
         index = 0;
     return removed?d:null;
 }

 public Drawable(Generator g)
     : base(g, typeof(IDrawable), false)
 {
     inner = (IDrawable)Handler;
     inner.Create ();
     Initialize ();
 }

 public Computer(CPU cpu, RAM ram, HardDriver hardDriver, IDrawable videoCard)
 {
     this.CPU = cpu;
     this.RAM = ram;
     this.HardDrives = hardDriver;
     this.VideoCard = videoCard;
  }

        public Direction IntersectWith(IDrawable obj)
        {
            if ((this.Position.Left > obj.Position.Left && this.Position.Left < obj.Position.Left + obj.Size.Width)
                || (this.Position.Left + this.Size.Width > obj.Position.Left && this.Position.Left + this.Size.Width < obj.Position.Left + obj.Size.Width)
                || (this.Position.Left == obj.Position.Left && this.Position.Left + this.Size.Width == obj.Position.Left + obj.Size.Width))
            {
                if (this.Position.Top + this.Size.Height >= obj.Position.Top && this.Position.Top + this.Size.Height < obj.Position.Top + obj.Size.Height)
                {
                    return Direction.Down;
                }

                if (this.Position.Top <= obj.Position.Top + obj.Size.Height && this.Position.Top > obj.Position.Top)
                {
                    return Direction.Up;
                }
            }

            if ((this.Position.Top > obj.Position.Top && this.Position.Top < obj.Position.Top + obj.Size.Height)
                || (this.Position.Top + this.Size.Height > obj.Position.Top && this.Position.Top + this.Size.Height < obj.Position.Top + obj.Size.Height)
                || (this.Position.Top == obj.Position.Top && this.Position.Top + this.Size.Height == obj.Position.Top + obj.Size.Height))
            {
                if (this.Position.Left <= obj.Position.Left + obj.Size.Width && this.Position.Left > obj.Position.Left)
                {
                    return Direction.Left;
                }

                if (this.Position.Left + this.Size.Width >= obj.Position.Left && this.Position.Left + this.Size.Width < obj.Position.Left + obj.Size.Width)
                {
                    return Direction.Right;
                }
            }

            return Direction.None;
        }

 internal static void RemoveObject (IDrawable obj)
 {
     var client = CallContext.Client;
     if (!objects.ContainsKey (client) || !objects [client].Contains (obj))
         throw new ArgumentException ("Drawing object not found");
     obj.Destroy ();
     objects [client].Remove (obj);
 }

 public bool unregister(IDrawable component)
 {
     if (isRegistered(component)) {
         list.Remove(component);
         return true;
     }
     return false;
 }

		public Image( IDrawable drawable, Scaling scaling = Scaling.Stretch, int align = AlignInternal.center )
		{
			setDrawable( drawable );
			_scaling = scaling;
			_align = align;
			setSize( preferredWidth, preferredHeight );
			touchable = Touchable.Disabled;
		}

 public bool register(IDrawable component)
 {
     if (!isRegistered(component)) {
         list.Add(component);
         list.Sort((x, y) => priority(x).CompareTo(priority(y)));
         return true;
     }
     return false;
 }

        public virtual void SetParameters(IDrawable a_renderable)
        {
            if (SetUserParameters != null)
            {
                SetUserParameters(BackingEffect, a_renderable);
            }

            BackingEffect.CommitChanges();
        }

        /// <summary>
        /// Poistaa olion, kun kerrosta ei tunneta.
        /// Käy läpi kaikki kerrokset, kunnes olio löytyy.
        /// </summary>
        /// <param name="obj">Poistettava olio.</param>
        /// <returns></returns>
        public static bool RemoveFromDraw(IDrawable obj)
        {
            for (int i = 0; i < Layers.Length; i++)
            {
                if (Layers[i].objectsOnLayer.Remove(obj))
                    return true;
            }

            return false;
        }

        public Asteroid(float radius, IDrawable model)
        {
            Draw = new ArrayList();

            Draw.Add(model);
            Radius = radius;
            RenderRadius = Radius;

            Hull = new Hull(1000);
        }

        IDrawable run(IDrawable input)
        {
            if (!(input is CircleSet))
            {
                throw new Exception("CircleTest. Input is not Circles.");
            }

            var inp = input as CircleSet;

            Circle a = inp[0];
            Circle b = inp[1];

            bool x = Intersect.IsIntersected(a,b);
            if (x) return DrawableElement.Text(0, 0, "Vse horosho");
            else return DrawableElement.Text(0, 0, "Vse ploho");
        }

        public static void Draw(IDrawable drawling)
        {
            if (drawling.Texture == null)
                return;

            Color color =
                (drawling.Transparent) ? Color.Transparent : drawling.Color;

            if (drawling.SourceRectangle != Rectangle.Empty && drawling.SourceRectangle != null)
            {
                DrawWithSourceRect(drawling);
                return;
            }
            if (drawling.Visible)
                spriteBatch.Draw(drawling.Texture, drawling.Rectangle, color );
        }

 private int priority(IDrawable idrawable)
 {
     if (idrawable.GetType() == typeof(Player)
         || idrawable.GetType() == typeof(DummyBoss)
         || idrawable.GetType() == typeof(Boss)) {
         return 0;
     } else if (idrawable.GetType() == typeof(HUD)) {
         return 1;
     } else if (idrawable.GetType() == typeof(Fader)) {
         return 2;
     } else if (idrawable.GetType() == typeof(PauseScreen)) {
         return 4;
     } else {
         return 3;
     }
 }