Create a Texture2D from larger image

Question

I am having trouble with the basic logic of this solution: Xna: Splitting one large texture into an array of smaller textures in respect to my specific problem (specifically, I'm looking at the second answer.)

How can I use my source rectangle that I already use for drawing to create a new Texture2D?

spriteBatch.Draw(CurrentMap.CollisionSet, currentMap.CellScreenRectangle(x, y),
      CurrentMap.TileSourceRectangle(currentMap.MapCells[x, y].TileDepths[4]),
      Color.FromNonPremultiplied(0,0,0, 45), 0.0f, Vector2.Zero, SpriteEffects.None, 0.91f);

I know I want a method that I started so:

//In Update Method of say the player's character.

Texture2D CollisionTexture = ExtractTexture(MapManager.CurrentMap.CollisionSet, MapManager.TileWidth, MapManager.TileHeight);

// In MapManager Class who knows everything about tiles that make up a level. 
    public Texture2D ExtractTexture(Texture2D original, int partWidth, int partheight, MapTile mapCell)
            {
                var dataPerPart = partWidth * partheight;
                Color[] originalPixelData = new Color[original.Width * original.Height];
                original.GetData<Color>(originalPixelData);
                Color[] newTextureData = new Color[dataPerPart];
                original.GetData<Color>(0, CurrentMap.TileSourceRectangle(mapCell.TileDepths[4]), originalPixelData,  0, originalPixelData.Count());
                Texture2D outTexture = new Texture2D(original.GraphicsDevice, partWidth, partheight);
            }

I think the problem is I'm just not understanding the overload of Texture2D.GetData<>

Part of my concern is creating an array of the whole texture in the first place. Can I target the original texture and create an array of colors for copying based on what I already get from the method TileSourceRecatangle(int)?

Answer 1

Here's the code you need:

Texture2D originalTexture = Content.Load<Texture2D>("myTexture");
Rectangle sourceRectangle = new Rectangle(10, 10, originalTexture.Width - 20, originalTexture.Height - 20);

Texture2D cropTexture = new Texture2D(GraphicsDevice, sourceRectangle.Width, sourceRectangle.Height);
Color[] data = new Color[sourceRectangle.Width * sourceRectangle.Height];
originalTexture.GetData(0, sourceRectangle, data, 0, data.Length);
cropTexture.SetData(data);

Answer 2

You'll want to use RenderTarget2D, which are convertible with Texture2Ds (that's probably not the proper way of saying it). This uses the graphics device to create your new texture instead of the more expensive pixel copy, and is quite simple.

You'll want to

1. Create

   RenderTarget2D newTarget = new RenderTarget2D(GraphicsDevice, partWidth, partHeight)
   

2. Set

   GraphicsDevice.SetRenderTarget(newTarget);
   

3. Draw

   SpriteBatch.Draw(original, Vector2.Zero, partSourceRectangle, <... other options you want ...>);
   

4. Reset

   GraphicsDevice.SetRenderTarget(null);
   

   (this gets you back to drawing to the backbuffer instead of your temporary target)

5. Convert

   Texture2D newTexture = (Texture2D)newTarget;
   

   (I believe the conversion is necessary so that the target is not automatically disposed of; render targets are meant to be temporary)

To summarize what I did: I set the draw target of the GraphicsDevice to a custom target which I created with the dimensions of the new texture. I then drew the new texture onto that target. Then I reset the GraphicsDevice so we are back to drawing to the screen. I then converted the render target into a more permanent texture.

Note that this will interrupt any drawing you are in the process of doing, so I wouldn't call this in the middle of a SpriteBatch run.

Also, I don't have VS open so I can't verify any of this, I'm going by memory. If anyone else has comments on the technique or syntax, feel free to edit or correct in comments.