C# Texture.CopyToImage方法代码示例

        public static void SliceAndDice(Vector2f startPoint, Vector2f endPoint, Texture victim, out Texture sliceA,
                                        out Texture sliceB, float repeatsX, float repeatsY)
        {
            //startPoint = new Vector2f(ConvertUnits.ToDisplayUnits(startPoint.X),
            //                          ConvertUnits.ToDisplayUnits(startPoint.Y));
            //endPoint =   new Vector2f(ConvertUnits.ToDisplayUnits(endPoint.X),
            //                          ConvertUnits.ToDisplayUnits(endPoint.Y));

            var input = victim.CopyToImage();

            var outputA = new Image((uint)(input.Size.X * repeatsX), (uint)(input.Size.Y * repeatsY), Color.Transparent);
            var outputB = new Image((uint)(input.Size.X * repeatsX), (uint)(input.Size.Y * repeatsY), Color.Transparent);

            for (uint y = 0; y < input.Size.Y * repeatsY; y++)
            {
                for (uint x = 0; x < input.Size.X * repeatsX; x++)
                {
                    var pos = new Vector2f(x, y);
                    var start = new Vector2(startPoint.X, startPoint.Y);
                    var end = new Vector2(endPoint.X, endPoint.Y);
                    var line = end - start;
                    line.Normalize();
                    if (WhichSideOfLine(startPoint, endPoint, pos))
                        outputA.SetPixel(x, y, input.GetPixel(x % input.Size.X, y % input.Size.Y));
                    else
                        outputB.SetPixel(x, y, input.GetPixel(x % input.Size.X, y % input.Size.Y));
                }
            }

            sliceA = new Texture(outputA);
            sliceB = new Texture(outputB);
        }

        /// <summary>
        /// Creates a pixel collider.
        /// </summary>
        /// <param name="source">The source image to create the collider from.</param>
        /// <param name="tags">The tags to register the collider with.</param>
        public PixelCollider(string source, params int[] tags)
        {
            texture = Textures.Load(source);
            collideImage = texture.CopyToImage();

            Width = texture.Size.X;
            Height = texture.Size.Y;

            AddTag(tags);
        }

        uint[] GetBitmask(Texture texture)
        {
            uint[] mask;

            if (!Bitmasks.ContainsKey(texture))
            {
                Image image = texture.CopyToImage();
                mask = CreateBitmask(texture, image);
            }
            else
                return Bitmasks[texture];

            return mask;
        }

        private static void LoadContentInitialize()
        {
            window = new RenderWindow(
                new VideoMode(800, 600), "Project Title");

            windowSize = new Vector2f(800, 600);
            window.SetFramerateLimit(60);
            window.Closed += (a, b) => { window.Close(); };

            camera2D = new View(cameraPos, new Vector2f(640, 480));



            tempIdleN = new Sprite(new Texture("Content/tempIdleN.png"));
            tempIdleS = new Sprite(new Texture("Content/tempIdleS.png"));
            tempIdleEW = new Sprite(new Texture("Content/tempIdleEW.png"));
            background = new Sprite(new Texture("Content/background.png"));
            basicLevelDec = new Sprite(new Texture("Content/basicLevel_decorMap.png"));


            basicLevelCol = new Texture("Content/basicLevel_collisionMap.png");
            backgroundTexture = basicLevelCol;
            map = backgroundTexture.CopyToImage();

            font = new Font("Content/Font1.ttf");

            click = new SoundBuffer("Content/click.wav");
            SaD = new SoundBuffer("Content/SaD.wav");
            fart = new SoundBuffer("Content/fart.wav");
            crunch = new SoundBuffer("Content/crunch.wav");

            window.TextEntered += (object sender, TextEventArgs e) =>
            {

                if (Keyboard.IsKeyPressed(Keyboard.Key.Back))
                {
                    if (clientPlayer.textCapture.Length > 0)
                        clientPlayer.textCapture = clientPlayer.textCapture.Substring(0, clientPlayer.textCapture.Length - 1);
                }
                else if (Keyboard.IsKeyPressed(Keyboard.Key.Return))
                {
                }
                else if (Keyboard.IsKeyPressed(Keyboard.Key.LControl))
                {
                }
                else if (Keyboard.IsKeyPressed(Keyboard.Key.Tab))
                {
                }
                else
                {
                    clientPlayer.textCapture += e.Unicode;
                }

            };

            window.Closed += (object sender, EventArgs e) =>
            {
                client.Disconnect("Exit");
                System.Threading.Thread.Sleep(100);

            };

        }

        /// <summary>
        /// Copies the pixels from a <see cref="Texture"/> to a <see cref="Bitmap"/>.
        /// </summary>
        /// <param name="texture">The source <see cref="Texture"/>.</param>
        /// <param name="b">The destination <see cref="Bitmap"/>.</param>
        /// <param name="source">The source area to copy.</param>
        static unsafe void CopyToBitmap(Texture texture, Bitmap b, Rectangle source)
        {
            const int bytesPerColor = 4;

            var image = texture.CopyToImage();
            var pixels = image.Pixels;

            // Lock the whole bitmap for write only
            var rect = new Rectangle(0, 0, source.Width, source.Height);
            var data = b.LockBits(rect, ImageLockMode.WriteOnly, b.PixelFormat);

            try
            {
                var srcStride = rect.Width * bytesPerColor;
                var dataStride = data.Stride / bytesPerColor;
                var srcXtimesBPP = source.X * bytesPerColor;
                var srcY = source.Y;

                // Grab the pointer to the pixels array
                fixed (byte* p = pixels)
                {
                    var row = (int*)data.Scan0;

                    // Copy the pixel values byte-by-byte, making sure to copy the RGBA source to the ARGB destination
                    for (var y = 0; y < data.Height; y++)
                    {
                        var srcOff = ((y + srcY) * srcStride) + srcXtimesBPP;

                        for (var x = 0; x < data.Width; x++)
                        {
                            // Masks for getting the 4 bytes in the int
                            const int b0 = 255;
                            const int b1 = b0 << 8;
                            const int b2 = b0 << 16;
                            const int b3 = b0 << 24;

                            // Get the raw value at the source (pixels[]) as an int (instead of grabbing each byte at a time)
                            var raw = *((int*)(p + srcOff));

                            // Convert to the correct format by moving doing the following to the source bytes:
                            //      src 0 -> dst 2 (move left 2 bytes)
                            //      src 1 -> dst 1 (no moving)
                            //      src 2 -> dst 0 (move right 2 bytes)
                            //      src 3 -> dst 3 (no moving)
                            var converted = (raw & (b3 | b1)) | ((raw & b0) << 16) | ((raw & b2) >> 16);

                            // Store the converted result
                            row[x] = converted;

                            // Move the source over 4 bytes
                            srcOff += bytesPerColor;
                        }

                        row += dataStride;
                    }
                }
            }
            finally
            {
                b.UnlockBits(data);
            }
        }