C# Surface.Update方法代碼示例

        public static void Main(string[] args)
        {
            Events.Quit += new EventHandler<QuitEventArgs>(ApplicationQuitEventHandler);

            Surface plate = Video.SetVideoMode(220, 220, 32, false, false, false, true);
            Surface pic = new Surface("nyanbig.png");
            pic.Update();

            Population fellows = new Population(15, 100);
            List<float> fitnesses;

            while (fellows.members[0].fitness < 700f)
            {
                fitnesses = new List<float>();
                foreach (Genome g in fellows.members)
                {
                    g.Draw(plate);
                    Console.Read();
                    float f = g.GetFitness(plate, pic);
                    fitnesses.Add(f);
                    g.fitness = f;
                }

                fellows.members.Sort();
                fellows.members[0].Draw(plate);
                Console.WriteLine(fellows.members[0].fitness);
                int x = 0;
            }
        }

        public virtual void SetAlert(bool on, string message)
        {
            _onAlert = on;
            if (_onAlert && string.IsNullOrEmpty(message)) _onAlert = false;
            if (_alertSurface != null) _alertSurface.Dispose();
            if (!_onAlert) _alertSurface = null;

            if (_onAlert)
            {
                message += "\n\n" + Properties.Resources.Str_AlertTail;
                string[] lines = message.Split('\n');
                Size[] sizes = Array.ConvertAll<string, Size>(lines, (l) => { return ResourceManager.SmallPFont.SizeText(l); });

                int maxWidth = 0; int height = 0;
                foreach (Size s in sizes)
                {
                    if (maxWidth < s.Width) maxWidth = s.Width;
                    height += (int)(s.Height * Constants.LineHeight);
                }

                _alertSurface = new Surface(maxWidth + Constants.WindowPadding * 2, height + Constants.WindowPadding * 2);
                SdlDotNet.Graphics.Primitives.Box box = new SdlDotNet.Graphics.Primitives.Box(
                    Point.Empty, new Size(maxWidth + Constants.WindowPadding * 2 - 1, height + Constants.WindowPadding * 2 - 1));

                _alertSurface.Lock();
                _alertSurface.Draw(box, Constants.Color_AlertBackground, false, true);
                _alertSurface.Draw(box, Constants.Color_AlertForeground, false, false);
                _alertSurface.Unlock();

                int y = Constants.WindowPadding; int idx = 0;
                foreach (string l in lines)
                {
                    using (Surface ts = ResourceManager.SmallPFont.Render(l, Constants.Color_AlertForeground))
                    {
                        if (idx == lines.Length - 1)
                        {
                            _alertSurface.Blit(ts, new Point((int)(_alertSurface.Width / 2.0 - ts.Width / 2.0), y));
                        }
                        else
                        {
                            _alertSurface.Blit(ts, new Point(Constants.WindowPadding, y));
                        }
                        y += (int)(ts.Height * Constants.LineHeight);
                    }
                    idx++;
                }
                _alertSurface.Update();
            }
        }

        private void drawOctaveSelecting(SdlDotNet.Graphics.Surface s)
        {
            if (_octaveSelectingSurface == null)
            {
                using (Surface ts = ImageUtil.CreateMultilineStringSurface(new string[] { 
                Properties.Resources.Str_OctaveSelecting,
                null, null, null,
                Properties.Resources.Str_OctaveSelecting_Operation },
                    ResourceManager.SmallPFont, Constants.Color_Background, TextAlign.Center))
                {
                    _octaveSelectingSurface = new Surface(
                        ts.Width + Constants.WindowPadding * 2,
                        ts.Height + Constants.WindowPadding * 2);

                    _octaveSelectingSurface.Fill(Constants.Color_Foreground);
                    _octaveSelectingSurface.Blit(ts, new Point(Constants.WindowPadding, Constants.WindowPadding));
                    _octaveSelectingSurface.Update();
                }

                _octaveUpSurface = ResourceManager.SmallPFont.Render(Properties.Resources.Str_UpArrow, Constants.Color_Background);
                _octaveDownSurface = ResourceManager.SmallPFont.Render(Properties.Resources.Str_DownArrow, Constants.Color_Background);
            }

            s.Blit(_octaveSelectingSurface, new Point(
                    (int)(Constants.ScreenWidth / 2.0 - _octaveSelectingSurface.Width / 2.0),
                    (int)(Constants.ScreenHeight / 2.0 - _octaveSelectingSurface.Height / 2.0)));

            int fh = (int)(ResourceManager.SmallPFont.Height * Constants.LineHeight);
            int y = Constants.WindowPadding + 
                (int)(Constants.ScreenHeight / 2.0 - _octaveSelectingSurface.Height / 2.0) + fh;

            if (_octave < Constants.MaxOctave)
            {
                s.Blit(_octaveUpSurface, new Point((int)(Constants.ScreenWidth / 2.0 - _octaveUpSurface.Width / 2.0), y));
            }
            y += fh;

            using (Surface ts = ResourceManager.SmallPFont.Render(_octave.ToString(), Constants.Color_Background))
            {
                s.Blit(ts, new Point((int)(Constants.ScreenWidth / 2.0 - ts.Width / 2.0), y));
            }
            y += fh;

            if (_octave > Constants.MinOctave)
            {
                s.Blit(_octaveDownSurface, new Point((int)(Constants.ScreenWidth / 2.0 - _octaveDownSurface.Width / 2.0), y));
            }
        }

        //Main program loop
        private void Go()
        {
            //Set up screen
            if (File.Exists(Path.Combine(dataDirectory, "background.png")))
            {
                filePath = "";
            }
            background = new Surface(Path.Combine(filePath, Path.Combine(dataDirectory, "background.png")));
            Video.WindowIcon();
            Video.WindowCaption = "SDL.NET - Bounce Sprites";
            screen = Video.SetVideoMode(width, height);
            screen.Blit(background);
            screen.Update();

            //This loads the various images (provided by Moonfire) 
            // into a SurfaceCollection for animation
            SurfaceCollection marbleSurfaces = new SurfaceCollection();
            marbleSurfaces.Add(new Surface(Path.Combine(filePath, Path.Combine(dataDirectory, "marble1.png"))), new Size(50, 50));

            for (int i = 0; i < this.maxBalls; i++)
            {
                //Create a new Sprite at a random location on the screen
                master.Add(new BounceSprite(marbleSurfaces,
                    new Point(rand.Next(screen.Rectangle.Left, screen.Rectangle.Right),
                    rand.Next(screen.Rectangle.Top, screen.Rectangle.Bottom))));
            }

            //The collection will respond to mouse button clicks, mouse movement and the ticker.
            master.EnableMouseButtonEvent();
            master.EnableMouseMotionEvent();
            master.EnableTickEvent();

            //These bind the events to the above methods.
            Events.KeyboardDown +=
                new EventHandler<KeyboardEventArgs>(this.KeyboardDown);
            Events.Tick += new EventHandler<TickEventArgs>(this.Tick);
            Events.Quit += new EventHandler<QuitEventArgs>(this.Quit);

            //Start the event ticker
            Events.Run();
        }

        public static SurfaceCollection LoadSurfacesFromFile(string filePath, Size tileSize)
        {
            SurfaceCollection ret = new SurfaceCollection();
            ret.AlphaBlending = true;
            if (!File.Exists(filePath)) return ret;

            using (Bitmap bmp = (Bitmap)Bitmap.FromFile(filePath))
            {
                using (Surface s = new Surface(bmp))
                {
                    s.Lock();
                    for (int i = 0; i < s.Width; i += tileSize.Width)
                    {
                        for (int j = 0; j < s.Height; j += tileSize.Height)
                        {
                            Surface ss = new Surface(tileSize.Width, tileSize.Height, 32, s.RedMask, s.GreenMask, s.BlueMask, s.AlphaMask);
                            ss.Transparent = true;
                            ss.AlphaBlending = true;

                            Color[,] tmp = s.GetColors(new Rectangle(i, j, tileSize.Width, tileSize.Height));
                            ss.Lock();
                            ss.SetPixels(Point.Empty, tmp);
                            tmp = ss.GetColors(new Rectangle(0, 0, ss.Width, ss.Height));
                            ss.Unlock();
                            ss.Update();
                            ret.Add(ss);
                        }
                    }
                    s.Unlock();
                }
            }

            return ret;
        }

        public void DrawInfoPanel(Surface surface, LeadActor player, Skin[] skinGroup)
        {
            /* Draws the information panel on the surface.

                surface: The area of the surface to draw into from the pygame window: surface class
                player: The lead actor being used for the player: lead_actor class
                skin_group: The group of skins to be used in the engines isometric view: skin class
            */
            if (surface == null)
            {
                throw new ArgumentNullException("surface");
            }
            if (player == null)
            {
                throw new ArgumentNullException("player");
            }
            //draw titlebar
            Rectangle rect = surface.Blit(this.titleSprite.Surface, this.titleSprite.Rectangle);
            int[] draw_order;
            //draw inventory
            Object3d[] inventory_array = new Object3d[player.Inventory.Count];
            for (int i = 0; i < player.Inventory.Count; i++)
            {
                inventory_array[i] = (Object3d)player.Inventory[i];
            }
            if (player.Inventory.Count > 0)
            {
                Sprite[] sprite_group = Sprites.UpdateImages(skinGroup, inventory_array);
                int p = 155;
                draw_order = new int[player.Inventory.Count];
                int q = 0;
                for (int i = player.UsingObject; i < player.Inventory.Count; i++)
                {
                    draw_order[q] = i;
                    q++;
                }
                for (int i = 0; i < player.UsingObject; i++)
                {
                    draw_order[q] = i;
                    q++;
                }

                foreach (int i in draw_order)
                {
                    sprite_group[i].X = p;
                    sprite_group[i].Y = 38 - sprite_group[i].Height;
                    surface.Blit(sprite_group[i].Surface, sprite_group[i].Rectangle);
                    Surface text = this.font.Render(skinGroup[inventory_array[i].ObjectType].Name, Color.FromArgb(255, 255, 255));
                    Point textpos = new Point(0, 0);
                    textpos.X = p - skinGroup[inventory_array[i].ObjectType].Name.Length * 3 + sprite_group[i].Width / 2;
                    textpos.Y = 35;
                    surface.Blit(text, textpos);
                    p = p + sprite_group[i].Width + 20;
                }
            }
            //Update the display with the panel changes
            surface.Update(rect);
        }

 public static SurfaceCollection LoadSurfaces(string[] resourceNames)
 {
     SurfaceCollection ret = new SurfaceCollection();
     System.Reflection.Assembly asm = System.Reflection.Assembly.GetExecutingAssembly();
     foreach (string resourceName in resourceNames)
     {
         using (Bitmap bmp = new Bitmap(asm.GetManifestResourceStream(getImgResourceFullName(resourceName))))
         {
             Surface s = new Surface(bmp);
             s.AlphaBlending = true;
             s.Update();
             ret.Add(s);
         }
     }
     ret.AlphaBlending = true;
     return ret;
 }

 public static void SetAlpha(Surface s, float a)
 {
     if (s == null) return;
     Color[,] colors = s.GetColors(new Rectangle(0, 0, s.Width, s.Height));
     s.Lock();
     for (int i = 0; i < colors.GetLength(0); i++)
     {
         for (int j = 0; j < colors.GetLength(1); j++)
         {
             Color c = colors[i, j];
             int na = (int)(c.A * a);
             colors[i, j] = Color.FromArgb(na < 0 ? 0 : (na > 255 ? 255 : na), c.R, c.G, c.B);
         }
     }
     s.SetPixels(Point.Empty, colors);
     s.Unlock();
     s.Update();
 }

 public static Surface LoadSurface(string resourceName)
 {
     Surface ret = null;
     using (Bitmap bmp = getImgResource(resourceName))
     {
         ret = new Surface(bmp);
         ret.AlphaBlending = true;
     }
     ret.Update();
     return ret;
 }

 public static void SetColor(Surface s, Color c)
 {
     if (s == null) return;
     Color[,] colors = s.GetColors(new Rectangle(0, 0, s.Width, s.Height));
     s.Lock();
     for (int i = 0; i < colors.GetLength(0); i++)
     {
         for (int j = 0; j < colors.GetLength(1); j++)
         {
             colors[i, j] = Color.FromArgb(colors[i, j].A, c.R, c.G, c.B);
         }
     }
     s.SetPixels(Point.Empty, colors);
     s.Unlock();
     s.Update();
 }

        public static Surface CreateColored(Surface s, Color c0, Color c1)
        {
            if (s == null) return null;
            Color[,] colors = s.GetColors(new Rectangle(0, 0, s.Width, s.Height));

            for (int i = 0; i < colors.GetLength(0); i++)
            {
                for (int j = 0; j < colors.GetLength(1); j++)
                {
                    Color c = colors[i, j];
                    float br = (c.R / 255.0f + c.G / 255.0f + c.B / 255.0f) / 3.0f;
                    if (br > 0.8f)
                    {
                        br = 1.0f;
                    }
                    else if (br < 0.2f)
                    {
                        br = 0.0f;
                    }
                    int r = (int)((1 - br) * c0.R + br * c1.R);
                    int g = (int)((1 - br) * c0.G + br * c1.G);
                    int b = (int)((1 - br) * c0.B + br * c1.B);
                    r = r < 0 ? 0 : (r > 255 ? 255 : r);
                    g = g < 0 ? 0 : (g > 255 ? 255 : g);
                    b = b < 0 ? 0 : (b > 255 ? 255 : b);
                    colors[i, j] = Color.FromArgb(c.A, r, g, b);
                    Color nc = Color.FromArgb(c.A, r, g, b);
                }
            }

            Surface ns = new Surface(s.Width, s.Height, s.BitsPerPixel, s.RedMask, s.GreenMask, s.BlueMask, s.AlphaMask);
            ns.AlphaBlending = s.AlphaBlending;
            ns.Alpha = s.Alpha;
            ns.Transparent = s.Transparent;
            ns.TransparentColor = s.TransparentColor;

            ns.Lock();
            ns.SetPixels(Point.Empty, colors);
            ns.Unlock();
            ns.Update();
            return ns;
        }

        public virtual void Render(Surface s, Rectangle r)
        {
            if (_startLineSurface == null)
            {
#warning パフォーマンスチェック
                using (Surface ts = ResourceManager.LargePFont.Render("START", _foreColor, true))
                {
                    _startLineSurface = new Surface(ts.Width + 20, view.Height, 32, ts.RedMask, ts.GreenMask, ts.BlueMask, ts.AlphaMask);

                    Color[,] tmp = ts.GetColors(new Rectangle(0, 0, ts.Width, ts.Height));
                    for (int i = 0; i < tmp.GetLength(0); i++)
                    {
                        for (int j = 0; j < tmp.GetLength(1); j++)
                        {
                            Color c = tmp[i, j];
                            tmp[i, j] = Color.FromArgb((int)(c.A / 2.0), c.R, c.G, c.B);
                        }
                    }
                    _startLineSurface.Lock();
                    _startLineSurface.SetPixels(new Point(20, (int)(_startLineSurface.Height / 2.0 - ts.Height / 2.0)), tmp);
                    _startLineSurface.Unlock();
                }
                _startLineSurface.Fill(new Rectangle(0, 0, 3, _startLineSurface.Height), Color.FromArgb(128, _foreColor.R, _foreColor.G, _foreColor.B));
                _startLineSurface.Update();
                _startLineSurface.AlphaBlending = true;
            }
            if (_goalLineSurface == null)
            {
                using (Surface ts = ResourceManager.LargePFont.Render("GOAL", _foreColor, true))
                {
                    _goalLineSurface = new Surface(ts.Width + 20, view.Height, 32, ts.RedMask, ts.GreenMask, ts.BlueMask, ts.AlphaMask);
                    Color[,] tmp = ts.GetColors(new Rectangle(0, 0, ts.Width, ts.Height));
                    for (int i = 0; i < tmp.GetLength(0); i++)
                    {
                        for (int j = 0; j < tmp.GetLength(1); j++)
                        {
                            Color c = tmp[i, j];
                            tmp[i, j] = Color.FromArgb((int)(c.A / 2.0), c.R, c.G, c.B);
                        }
                    }
                    _goalLineSurface.Lock();
                    _goalLineSurface.SetPixels(new Point(0, (int)(_goalLineSurface.Height / 2.0 - ts.Height / 2.0)), tmp);
                    _goalLineSurface.Unlock();
                }
                _goalLineSurface.Fill(new Rectangle(_goalLineSurface.Width - 3, 0, 3, _goalLineSurface.Height), Color.FromArgb(128, _foreColor.R, _foreColor.G, _foreColor.B));
                _goalLineSurface.Update();
                _goalLineSurface.AlphaBlending = true;
            }


            renderBackground(s, r);

            if (_startLineSurface.Width >= view.X && view.X + view.Width >= 0)
            {
                s.Blit(_startLineSurface, new Point(
                    (int)(r.X - view.X),
                    (int)(r.Y + view.Height / 2.0 - _startLineSurface.Height / 2.0)));
            }
            if (this.HasEnd)
            {
                if (this.Width >= view.X && view.X + view.Width >= this.Width - _goalLineSurface.Width)
                {
                    s.Blit(_goalLineSurface, new Point(
                        (int)(r.X + this.Width - _goalLineSurface.Width - view.X),
                        (int)(r.Y + view.Height / 2.0 - _goalLineSurface.Height / 2.0)));
                }
            }

            renderForeground(s, r);
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="surface"></param>
        /// <param name="objectGroup"></param>
        /// <param name="skin_group"></param>
        /// <param name="offset"></param>
        /// <param name="old_rect"></param>
        /// <returns></returns>
        public static Rectangle[] ViewUpdate(Surface surface, Object3d[] objectGroup, Skin[] skinGroup, int[] offset, Rectangle[] oldRect)
        {
            /* Update the isometric view based only on the changes in the screen

                surface: The pygame display area to be drawn into: surface
                object_group: a list of objects to be displayed: list of objects_3d or subclass
                skin_group: a list of skins which will be used to find the correct image for the objects sprite: list of skins
                offset: 2d vector to add to the isometric coordinates: list of 2 integers [x,y]
                old_rect: A list of pygame rectangles where the old sprites were drawn for updating: list of rect
                Returns old_rect: see above
            */
            if (skinGroup == null)
            {
                throw new ArgumentNullException("skinGroup");
            }
            if (objectGroup == null)
            {
                throw new ArgumentNullException("objectGroup");
            }
            if (surface == null)
            {
                throw new ArgumentNullException("surface");
            }

            // Find out what objects are visable
            int visable_limit = skinGroup.Length;
            //Object3d[] visable_object_group;
            ArrayList visable_object_list = new ArrayList();
            foreach (Object3d obj in objectGroup)
            {
                if (obj.ObjectType < visable_limit)
                {
                    visable_object_list.Add(obj);
                }
            }
            Object3d[] visable_object_group = new Object3d[visable_object_list.Count];
            visable_object_list.CopyTo(visable_object_group);

            // Draw the isometric view in the display surface
            Rectangle[] sprite_rect = ViewDraw(surface, (Object3d[])visable_object_group, skinGroup, offset);

            // Combines the rectangles that need updating: the new sprites and the old background rectangles   
            Rectangle[] update_rect = Sprites.CombineRectangles(sprite_rect, oldRect);

            // Update the display
            surface.Update(update_rect);

            // Remember the sprite rectangles
            oldRect = new Rectangle[sprite_rect.Length];
            for (int rect = 0; rect < sprite_rect.Length; rect++)
            {
                oldRect[rect] = sprite_rect[rect];
            }
            return (oldRect);
        }

        //public Surface UpdateImage(ImageBox imageBox)
        //{
        //    //_surface.Update(
        //}
        /// <summary>
        /// Render surface
        /// </summary>
        /// <returns></returns>
        public Surface Render(Rectangle rect, bool forceRender)
        {
            //Create temporary surface
            Surface tempSurface = new Surface(rect.Width, _size.Height);
            tempSurface.Fill(Color.White);

            //Render surface
            if (Rearrange() || _surface == null || forceRender) //Check is redraw necessary
            {
                lock (_spriteCln)
                {
                    Surface oldSurface = _surface;
                    _surface = new Surface(_size);
                    if (oldSurface != null)
                        oldSurface.Dispose();   //Clean up old surface memory
                    _surface.Fill(Color.White);
                    Collection<Rectangle> rects = _surface.Blit(_spriteCln);
                    _surface.Update(rects);
                }
            }

            //Blit surface to temporary surface
            tempSurface.Blit(_surface);
            tempSurface.Fill(new Rectangle(_size.Width, 0, rect.Width - _size.Width, _size.Height)
                , Color.White); //Fill the gap with white

            Debug.WriteLine("Render size: " + tempSurface.Width + "," + tempSurface.Height);
            return tempSurface;
        }