Na początku zarzucę kodem:
/// <summary>
/// This is the main type for your game
/// </summary>
public class Game1 :
Microsoft.Xna.Framework.Game
{
GraphicsDeviceManager
graphics;
SpriteBatch
spriteBatch;
Texture2D
textura; // klasa naszej tekstury
public
Game1()
{
graphics = new
GraphicsDeviceManager(this);
Content.RootDirectory = "Content";
}
/// <summary>
/// Allows the game to perform any initialization it needs to
before starting to run.
/// This is where it can query for any required services and
load any non-graphic
/// related content.
Calling base.Initialize will enumerate through any components
/// and initialize them as well.
/// </summary>
protected
override void
Initialize()
{
// TODO:
Add your initialization logic here
base.Initialize();
}
/// <summary>
/// LoadContent will be called once per game and is the place
to load
/// all of your content.
/// </summary>
protected
override void
LoadContent()
{
// Create
a new SpriteBatch, which can be used to draw textures.
spriteBatch = new SpriteBatch(GraphicsDevice);
// TODO:
use this.Content to load your game content here
}
/// <summary>
/// UnloadContent will be called once per game and is the
place to unload
/// all content.
/// </summary>
protected
override void
UnloadContent()
{
// TODO:
Unload any non ContentManager content here
}
/// <summary>
/// Allows the game to run logic such as updating the world,
/// checking for collisions, gathering input, and playing
audio.
/// </summary>
/// <param
name="gameTime">Provides a
snapshot of timing values.</param>
protected
override void
Update(GameTime gameTime)
{
// Allows
the game to exit
if
(GamePad.GetState(PlayerIndex.One).Buttons.Back
== ButtonState.Pressed)
this.Exit();
// TODO:
Add your update logic here
if
(textura == null)
{
//
inicjacja wymiarów naszej tekstury
int
szerokość = 500;
int
wysokość = 300;
textura = new Texture2D(graphics.GraphicsDevice,szerokość,wysokość);
// konstruktor nowej textury
Color[]
colorMap = new Color[szerokość
* wysokość]; // inicjacja i konstruktor tablicy mapy
kolorów
Random
rand = new Random();
// opcjonalna klasa w tym wypadku - służy do
losowania liczb
for
(int x = 0; x < szerokość * wysokość; x++) // zapełnianie mapy kolorów losowymi kolorami
{
colorMap[x] = new Color(rand.Next(255),
rand.Next(255), rand.Next(255));
}
textura.SetData(colorMap); // wrzucenie mapy kolorów do textury
}
base.Update(gameTime);
}
/// <summary>
/// This is called when the game should draw itself.
/// </summary>
/// <param
name="gameTime">Provides a
snapshot of timing values.</param>
protected
override void
Draw(GameTime gameTime)
{
GraphicsDevice.Clear(Color.CornflowerBlue);
//
narysowanie textury w celu podglądowym
spriteBatch.Begin();
spriteBatch.Draw(textura,new Rectangle(100,100,textura.Width,textura.Height),Color.White);
spriteBatch.End();
// TODO:
Add your drawing code here
base.Draw(gameTime);
}
}
Powyższy kod generuje nam obraz rozmiarów 100x100 z losowymi pixelami. Jak widzimy w powyższej klasie oprócz podstawowych klas które mamy od razu po wygenerowaniu nowego projektu XNA, użyliśmy jedynie dodatkowej klasy Texture2D. Całość przypisania odbywa się w metodzie Update() naszego projektu.
Ja zdecydowałem się na jedno razowe wywołania tej metody i tylko w tedy kiedy nasza textura nie wskazuje na żaden obiekt(czyli jest pusta).
Następnie określiłem szerokość i wysokość naszej nowo powstającej textury a także wstępnie stworzyłem jej surową instancję.
Dalej zainicjializowałem i utworzyłem mapę kolorów w postaci tablicy klasy Color o wielkości odpowiadającej wcześniej zdefiniowanym rozmiarowi textury. Czyli jak mozna zobaczyć w powyższym kodzie wielkością tablicy jest iloczyn szerokości i wysokości textury.
Nastepnie(opcjonalnie) utworzyłem klasę odpowiedzialną za losowanie int`ów oraz zainicjowałem pętle for, która będzie się wywoływać tyle razy ile wynosi iloczyn wysokości i szerokości naszej tekstury.
Można więc powiedzieć że dzięki temu z takiej tablicy 2 wymiarowej [szerokość, wysokość]:[1 6 112 7 123 8 134 9 145 10 15]zrobiłem jej uproszczoną 1 wymiarową [szerokość * wysokość] wersję:[123456789]... itd.*UWAGA: Wyżej wymieniony układ tablic odnosi się do pixeli przechowywanych w klasie Textura2D i wywołując z niej metodę SetData(colorMap) nasza 1 wymiarowa tablica z kolorami jest przekształcana w odpowiednią 2 wymiarową. Począwszy od lewej górnej strony idąc w dół aż do końca wysokości naszej tekstury a potem przeskakując o 1 szerokość w prawo(+ 1 dla x) i znowu idąc w dół aż do końca wysokości i tak aż nie zapełni wszystkich elementów w swojej tablicy.
W pętli for następuje losowanie kolorów do tablicy z kolorami a następnie w metodzie textura.SetData(colorMap) następuje namalowanie ich w naszej texsturze.
Po co nam takie czynności?
Ano dzięki temu możemy zrobić z naszej aplikacji Painta, ale warto wiedzieć że może się to przydać chociażby w generatorach. Zamiast wyświetlania 1000 kafli jako jeden obraz kamery można go zapisać jako tylko 1 texture(oszczędzamy w tedy mniejszą ilością wywoływanych metod spriteBatch.Begin() i End() - co znacznie przyczynia się do przyśpieszenia) - chociaż gdy obraz jest dosyć dynamiczny i musiałby zmieniać się ciągle w tedy już fakt przerabiania całego widoku na 1 bitmape już tak optymistyczny nie jest. Ale zawsze możemy użyć tej opcji do zrobienia screnshoota z naszej gry:)
