C# Texture2D.SaveAsPng方法代碼示例

    public static OcclusionMap Generate()
    {
        //Make room for edges which are always walls.
        bool[,] space = new bool[260 - 2, 260 - 2];

        for (int i = 0; i != 200; i++)
        {
            for (int j = 0; j != 200; j++)
            {
                space[i, j] = true;
            }
        }

        Texture2D Map = new Texture2D(Renderer.GraphicsDevice,260, 260);

        Color[] color = new Color[260 * 260];

        for (int i = 0; i != 260; i++)
        {
            for (int j = 0; j != 260; j++)
            {
                color[i * 260 + j] = ( i != 0 && j != 0 && i != 259 && j != 259 && space[i-1,j-1] ? FloorColor : WallColor);
            }
        }

        Map.SetData(color);
        Stream stream = File.Create("test.png");
        Map.SaveAsPng(stream, 260, 260);
        return null;
    }

        public static System.Drawing.Image Texture2Image(Texture2D texture)
        {
            if (texture == null)
            {
                return null;
            }

            if (texture.IsDisposed)
            {
                return null;
            }

            //Memory stream to store the bitmap data.
            MemoryStream ms = new MemoryStream();

            //Save the texture to the stream.
            texture.SaveAsPng(ms, texture.Width, texture.Height);

            //Seek the beginning of the stream.
            ms.Seek(0, SeekOrigin.Begin);

            //Create an image from a stream.
            System.Drawing.Image bmp2 = System.Drawing.Bitmap.FromStream(ms);

            //Close the stream, we nolonger need it.
            ms.Close();
            ms = null;
            return bmp2;
        }

        public System.Drawing.Image ConvertToImage(Texture2D source)
        {
            if (source == null) return null;

            MemoryStream mem = new MemoryStream();
            source.SaveAsPng(mem, source.Width, source.Height);
            return System.Drawing.Image.FromStream(mem);
        }

 //TODO: monogame does not support SaveAsXXX and mono does not implement gzipstream properly
 //TODO: find a fix for linux
 public static string SaveTextureData(Texture2D texture)
 {
     var streamOut = new MemoryStream();
     var width = texture.Width;
     var height = texture.Height;
     texture.SaveAsPng(streamOut, width, height);
     return Convert.ToBase64String(streamOut.ToArray());
 }

        /// <summary>
        /// Stores the current contents of the back buffer as a .PNG file.
        /// </summary>
        /// <param name="inGraphicsDevice">GraphicsDevice to grab the back buffer data from.</param>
        /// <param name="inFilename">String containing the name of the file to save.</param>
        /// <returns>True if the file is saved successfully, otherwise false.</returns>
        public static bool Capture(GraphicsDevice inGraphicsDevice,
                                   String inFilename, ScreenCaptureType inCaptureExtension)
        {
            if (inCaptureExtension == ScreenCaptureType.UseJPEG) { inFilename = inFilename + ".jpg"; }
            if (inCaptureExtension == ScreenCaptureType.UsePNG) { inFilename = inFilename + ".png"; }

            // Store the current BackBuffer data in a new array of Color values. This
            // will take what is currently on the BackBuffer; everything current being
            // drawn to the screen.
            Color[] colorData = new Color[inGraphicsDevice.Viewport.Width *
                                          inGraphicsDevice.Viewport.Height];
            inGraphicsDevice.GetBackBufferData<Color>(colorData);

            // Next set the colors into a Texture, ready for saving.
            Texture2D backBufferTexture = new Texture2D(inGraphicsDevice,
                                                        inGraphicsDevice.Viewport.Width,
                                                        inGraphicsDevice.Viewport.Height);
            backBufferTexture.SetData<Color>(colorData, 0, colorData.Length);

            // Create the file after checking whether it exists. This requires a means
            // of altering the intended filename so that it cannot overwrite an existing
            // screen-capture, for instance suffixing an incremental digit onto the file
            // name, but this would have to be saved to avoid overwritten files when the
            // game crashes and the count is lost.
            if (!File.Exists(inFilename))
            {
                using (FileStream fileStream = File.Create(inFilename))
                {
                    // The choice passed in as the 3rd parameter just exists for the sake
                    // of providing options. If one is clearly advantageous to the other
                    // I'll hard-code it to use that instead. But, for now, we allow the
                    // choice between JPEG and PNG. PNG files have transparency.
                    switch (inCaptureExtension)
                    {
                        case ScreenCaptureType.UseJPEG:
                            backBufferTexture.SaveAsJpeg(fileStream,
                                                         inGraphicsDevice.Viewport.Width,
                                                         inGraphicsDevice.Viewport.Height);
                            break;
                        case ScreenCaptureType.UsePNG:
                            backBufferTexture.SaveAsPng(fileStream,
                                                        inGraphicsDevice.Viewport.Width,
                                                        inGraphicsDevice.Viewport.Height);
                            break;
                    }

                    fileStream.Flush();
                }

                return true;
            }

            return false;
        }

        void SaveTexture(IResource resource, Texture2D texture)
        {
            if (texture == null) return;

            using (var stream = resource.Create())
            {
                // PNG only.
                texture.SaveAsPng(stream, texture.Width, texture.Height);
                texture.Name = resource.AbsoluteUri;
            }
        }

        public bool Write(string path, Texture2D texture)
        {
            if (!File.Exists(DataFolder + "\\data"))
            {
                Helper.mkdir(DataFolder + "\\data");
            }

            Stream stream = new FileStream(DataFolder + "\\data\\" + path.Replace("/", "-"), FileMode.OpenOrCreate);
            texture.SaveAsPng(stream, texture.Bounds.Width, texture.Bounds.Height);

            return true;
        }

        public static Image ImageFromTexture(Texture2D Source)
        {
            Image ToReturn;
            MemoryStream MStream = new MemoryStream();
            Source.SaveAsPng(MStream, Source.Width, Source.Height);
            ToReturn = Image.FromStream(MStream);

            MStream.Dispose();
            MStream = null;
            GC.Collect();

            return ToReturn;
        }

 /// <summary>
 /// Opens dialog for user to save screenshot
 /// </summary>
 /// <param name="texture2D">Takes in texture2D for screen information</param>
 private static void saveScreenshot(Texture2D texture2D)
 {
     SaveFileDialog saveScreenshot = new SaveFileDialog();
     saveScreenshot.DefaultExt = ".png";
     saveScreenshot.ShowDialog();
     saveScreenshot.CreatePrompt = true;
     if (saveScreenshot.FileName != string.Empty)
     {
         Stream stream = new FileStream(saveScreenshot.FileName, FileMode.Create);
         texture2D.SaveAsPng(stream, texture2D.Width, texture2D.Height);
         stream.Close();
     }
 }

		public void MakeScreenshot(string fileName)
		{
			var width = (int)window.ViewportPixelSize.Width;
			var height = (int)window.ViewportPixelSize.Height;
			using (var dstTexture = new Texture2D(device.NativeDevice, width, height, false,
				device.NativeDevice.PresentationParameters.BackBufferFormat))
			{
				var pixelColors = new Color[width * height];
				device.NativeDevice.GetBackBufferData(pixelColors);
				dstTexture.SetData(pixelColors);
				using (var stream = new FileStream(fileName, FileMode.OpenOrCreate, FileAccess.Write,
					FileShare.ReadWrite))
					dstTexture.SaveAsPng(stream, width, height);
			}
		}

    public void SetTextureSlot(int _nSlotIdx, Texture2D _tex)
    {
      if (_nSlotIdx < 0 || _nSlotIdx >= SlotsCount)
        return;

      MemoryStream mem = new MemoryStream();

      _tex.SaveAsPng(mem, 256, 256);

      m_imagesSlots[_nSlotIdx] = Image.FromStream(mem);

      Game1.SetTextureSlot(_nSlotIdx, _tex);

      Refresh();
    }

        public static void createTexture(
            GraphicsDevice graphics,
            string name, byte format,
            int width, int height,
            uint[] colorData)
        {
            Stream fStream
                = new FileStream(name,
                    FileMode.CreateNew);

            Texture2D outputTexture
                = new Texture2D(graphics,
                    width, height, false, SurfaceFormat.Color);
            outputTexture.SetData<uint>(colorData);
            outputTexture.SaveAsPng(fStream, width, height);
        }

        //, Texture2D textureB)
        public static void copyTexture(
           GraphicsDevice graphics, string name,
            Texture2D sourceTexture, SurfaceFormat format)
        {
            Stream fStream
                = new FileStream(name, FileMode.CreateNew);

            uint[] colorData = new uint[sourceTexture.Width * sourceTexture.Height];
            sourceTexture.GetData<uint>(colorData);

            Texture2D outputTexture = new Texture2D(graphics,
                                sourceTexture.Width, sourceTexture.Height,
                                    false, format);
            outputTexture.SetData<uint>(colorData);

            outputTexture.SaveAsPng(fStream, outputTexture.Width, outputTexture.Height);
        }

        public override sealed void UpdateUi(Object value)
        {
            if (value != _currentTexture) {
                _currentTexture = value as Texture2D;
                if (_currentTexture == null)
                    return;

                using (var pngImage = new MemoryStream()) {
                    _currentTexture.SaveAsPng(pngImage, 20, 20);

                    var bi = new BitmapImage();
                    bi.BeginInit();
                    bi.CacheOption = BitmapCacheOption.OnLoad;
                    bi.DecodePixelWidth = 20;
                    bi.StreamSource = pngImage;
                    bi.EndInit();
                    pngImage.Close();
                    Image.Source = bi;
                }
            }
        }

        public void ScreenShot()
        {
            int w = GraphicsDevice.PresentationParameters.BackBufferWidth;
            int h = GraphicsDevice.PresentationParameters.BackBufferHeight;

            //force a frame to be drawn (otherwise back buffer is empty)
            Draw(new GameTime());

            //pull the picture from the buffer
            int[] backBuffer = new int[w * h];
            GraphicsDevice.GetBackBufferData(backBuffer);

            //copy into a texture
            Texture2D texture = new Texture2D(GraphicsDevice, w, h, false, GraphicsDevice.PresentationParameters.BackBufferFormat);
            texture.SetData(backBuffer);

            //save to disk
            Stream stream = System.IO.File.OpenWrite("screenshot_" + File + ".png");
            texture.SaveAsPng(stream, w, h);
            stream.Close();
        }