Eccomi dopo un po' di tempo con un altro post sull'XNA e un suo utilizzo.
Questa volta mi sono detto: "voglio avere una scena con tanti, ma tanti oggetti!"
Ah, quando il masochismo non ha limiti...
Qualcosa ho comunque fatto, anche se non è proprio un granchè...
Quello che mi è venuto in mente, in modo da poterlo poi riusare anche in futuro per una qualche demo simile ad un Asteroid, è di avere un gestore di meteoriti!
Cioè questo gestore ci deve la possibilità di renderizzare a schermo tanti meteoriti.
E vogliamo pure dare la possibilità di muoversi in questo mondo no?
Quindi dovremo fare delle modifiche alla telecamera, in modo che ci pemetta di spostarci in questo universo popolato unicamente da meteoriti!
Allora per il metorManager creremo un file in un progetto per un gameWindows a se stante, mentre il file della della telecamera che andremo a modifcare è sempre quello della myLibrary.
Prima di tutto vediamo come strutturare questo fantomatico MeteorManager. Io l'ho pensato in questo modo:
-il mondo sarà visto come un cubo, dove all'interno potremo mettere i nostri meteoriti
-il mondo sarà diviso in celle: ad ogni cella sarà assegnata una sezione del mondo, e dentro ogni sezione ci sarà la lista degli elementi che sono contenuti dentro tale sezione
Perchè le sezioni? Perchè se ho un mondo molto grande potrei dover renderizzare tanti troppi elementi a schermo, e questo rallenterebbe di molto il numero di frame per secondo. Dividendo in sezioni il mondo potremmo decidere di renderizzare solo quelle adiacenti a noi.
Inoltre se poi in futuro dovremmo calcolare la collisione di una fantomatica astronave con un meteorite, invece di controllare le collisioni con tutti i meteoriti della scena (cosa veramente masochistica, che poterebbe via tantissimo tempo) potremmo semplicemente farlo con quelli adiacetni alla sezione in cui ci troviamo.
Pensante a quanto tempo occorre scorrere un cubo in cui ogni lato è diviso in 20 sezioni!
Cioè ci sono 20*20*20 sezioni da controllare! Ognuna con più elementi!
Avendo suddiviso un mondo cubico in sezioni ho deciso di usare un vettore a 3 dimensioni per gestire il gameWorld.
MeteorManager.cs Show/Hide
public struct Trasformation
{
public Vector3 position;
public float angleX, angleY, angleZ;
public float scale;
public Matrix world;
public void Update()
{
world = Matrix.CreateScale(scale) * Matrix.CreateFromYawPitchRoll(angleY, angleX, angleZ) *
Matrix.CreateTranslation(position);
}
}
public struct Sezione
{
public Vector2 xRange, yRange, zRange;
public List<Trasformation> myList;
}
/// <summary>
/// This is a game component that implements IUpdateable.
/// </summary>
public class MeteorManager : Microsoft.Xna.Framework.GameComponent
{
CameraI myCamera;
InputI inputDevice;
Model myModel;
Texture2D text;
Sezione[, ,] gameWorld;
//servono per dire in quale riga, colonna e profondità si trova la telecamera
int cameraR, cameraC, cameraP;
Effect currentEffect = null;
public Effect CurrentEffect
{
get { return currentEffect; }
set { currentEffect = value; }
}
//variabili per la dimensione del mondo
float xRange, yRange, zRange;
//numero di celle per ogni dimensione
int cells = 20;
public MeteorManager(Game game, Effect effect, int num, float xRange, float yRange, float zRange,
string myModel, string texture)
: base(game)
{
this.currentEffect = effect; //assegno l'effetto usato per il rendering
this.myModel = Game.Content.Load<Model>(myModel); //carico il modello
foreach (ModelMesh mesh in this.myModel.Meshes)
foreach (ModelMeshPart mp in mesh.MeshParts)
mp.Effect = effect; //assegno l'effetto ad ogni parte del modello
this.text = Game.Content.Load<Texture2D>(texture);//carico la texture che voglio usare
//assegno le variabili per la dimensione del mondo
this.xRange = xRange;
this.yRange = yRange;
this.zRange = zRange;
myCamera = (CameraI)game.Services.GetService(typeof(CameraI)); //recupero il servizio per la telecamera
inputDevice = (InputI)game.Services.GetService(typeof(InputI));//e quello per l'input
gameWorld = new Sezione[cells, cells, cells];//creo la matrice del mondo
makeWorld(num); //vado a creare i mondo
}
private void makeWorld(int num)
{
//calcolo quando spazio deve coprire ogni cella
float ix = xRange + xRange;
ix /= cells;
float iy = yRange + yRange;
iy /= cells;
float iz = zRange + zRange;
iz /= cells;
Random rand = new Random();
for (int i = 0; i < cells; i++)
{
for (int j = 0; j < cells; j++)
{
for (int k = 0; k < cells; k++)
{
//per ogni cella vado a inserire quale zona del mondo copre
gameWorld[i, j, k].xRange = new Vector2(i * ix - xRange, (i + 1) * ix - xRange);
gameWorld[i, j, k].yRange = new Vector2(j * iy - yRange, (j + 1) * iy - yRange);
gameWorld[i, j, k].zRange = new Vector2(k * iz - zRange, (k + 1) * iz - zRange);
//vado a creare la lista per la posizione dei meteoriti contenuti nella lista
gameWorld[i, j, k].myList = new List<Trasformation>();
for (int a = 0; a < num; a++)
{
Trasformation t = new Trasformation();
//creo la posizione all'interno della zona associata
t.position.X = rand.Next((int)gameWorld[i, j, k].xRange.X, (int)gameWorld[i, j, k].xRange.Y);
t.position.Y = rand.Next((int)gameWorld[i, j, k].yRange.X, (int)gameWorld[i, j, k].yRange.Y);
t.position.Z = rand.Next((int)gameWorld[i, j, k].zRange.X, (int)gameWorld[i, j, k].zRange.Y);
//angolo casuale
t.angleX = rand.Next(0, 360);
t.angleY = rand.Next(0, 360);
t.angleZ = rand.Next(0, 360);
//scala = 1
t.scale = 1;
//creo la world matrix per quel particolare meteorite
t.world = Matrix.CreateScale(t.scale) *
Matrix.CreateFromYawPitchRoll(t.angleY, t.angleX, t.angleZ) *
Matrix.CreateTranslation(t.position);
gameWorld[i, j, k].myList.Add(t);
}
}
}
}
}
public override void Initialize()
{
base.Initialize();
}
public override void Update(GameTime gameTime)
{
checkCameraPosition();
base.Update(gameTime);
}
public void Draw(GameTime gameTime)
{
currentEffect.Parameters["View"].SetValue(myCamera.View);
currentEffect.Parameters["Projection"].SetValue(myCamera.Projection);
currentEffect.Parameters["ColorMap"].SetValue(text);
currentEffect.Parameters["Color"].SetValue(Color.Green.ToVector4());
foreach (ModelMesh mesh in myModel.Meshes)
{
BoundingSphere s = new BoundingSphere(mesh.BoundingSphere.Center, mesh.BoundingSphere.Radius);
float radius = s.Radius;
int val = 8;
for (int i = (cameraR - val); i <= this.cameraR + val; i++)
{
for (int j = (this.cameraC - val); j <= this.cameraC + val; j++)
{
for (int k = (this.cameraP - val); k <= this.cameraP + val; k++)
{
int r = i % cells;
int c = j % cells;
int p = k % cells;
if(r < 0)
r = cells + r;
if(c < 0)
c = cells + c;
if(p < 0)
p = cells + p;
foreach (Trasformation tras in gameWorld[r % cells, c % cells, p % cells].myList)
{
s.Center = tras.position;
s.Radius = radius * tras.scale;
ContainmentType ris = myCamera.CameraBoundingFrustum.Contains(s);
if (ris == ContainmentType.Contains || ris == ContainmentType.Intersects)
{
currentEffect.Parameters["World"].SetValue(tras.world);
mesh.Draw();
}
}
}
}
}
}
}
private void checkCameraPosition()
{
float var = (xRange + xRange) / cells;
cameraR = (int)(myCamera.Position.X / var) + cells / 2;
var = (yRange + yRange) / cells;
cameraC = (int)(myCamera.Position.Y / var) + cells / 2; ;
var = (zRange + zRange) / cells;
cameraP = (int)(myCamera.Position.Z / var) + cells / 2; ;
}
}
Diamo una spiegazione di quello che ho fatto nei vari punti!
public MeteorManager(Game game, Effect effect, int num, float xRange, float yRange, float zRange,
string myModel, string texture)
: base(game)
{
this.currentEffect = effect; //assegno l'effetto usato per il rendering
this.myModel = Game.Content.Load<Model>(myModel); //carico il modello
foreach (ModelMesh mesh in this.myModel.Meshes)
foreach (ModelMeshPart mp in mesh.MeshParts)
mp.Effect = effect; //assegno l'effetto ad ogni parte del modello
this.text = Game.Content.Load<Texture2D>(texture);//carico la texture che voglio usare
//assegno le variabili per la dimensione del mondo
this.xRange = xRange;
this.yRange = yRange;
this.zRange = zRange;
myCamera = (CameraI)game.Services.GetService(typeof(CameraI)); //recupero il servizio per la telecamera
inputDevice = (InputI)game.Services.GetService(typeof(InputI));//e quello per l'input
gameWorld = new Sezione[cells, cells, cells];//creo la matrice del mondo
makeWorld(num); //vado a creare i mondo
}
Quello che fa il costruttore è questo:
assegna al currentEffect l'effetto passato (gli effect sono usati per caricare e gestire codice HLSL, che serve per renderizzare gli elementi della scena, ottenere effetti particolari etc; in questo esempio ho usato un mio piccolo effect che non fa altro che prendere la texture ed applicarla all'oggetto da renderizzare, senza calcolare nessuna luce, questo perchè è più veloce e semplice del basic Effect standard, e qui voglio andare ad ottenere più FPS possibili. Il file è allegato nella soluzione, ma qui non darò spiegazione di come funziona).
Poi carica il modello e la texture passate. Assegna il valore alle variabili che mi dicono quanto è grande il mondo.
Si recupera poi i riferimenti ai servizi della telecamera e del gestore dell'input.
GameWorld è la matrice cubica che andrà a contenere il mondo: ogni cella rappresenta una sezione, e ogni sezione avrò la sua lista di elementi.
Il metodo makeWorld, per quanto possa disorientare, non fa altro che creare e posizionare in modo radom num elementi per ogni sezione. A voi il compito di guardarlo o di chiedere qualcosa che non vi è chiaro qui.
Concentriamoci un attimo sul metodo checkCameraPosition invece, che è più curioso secondo me...
private void checkCameraPosition()
{
float var = (xRange + xRange) / cells;
cameraR = (int)(myCamera.Position.X / var) + cells / 2;
var = (yRange + yRange) / cells;
cameraC = (int)(myCamera.Position.Y / var) + cells / 2; ;
var = (zRange + zRange) / cells;
cameraP = (int)(myCamera.Position.Z / var) + cells / 2; ;
}
Questo metodo prende la posizione della telecamera e memorizza in 3 variabili l'indice di riga, colonna e profondità in cui si trova la telecamera.
Come si fa ad otterere tale risultato?
Prendo la variazione relativa ad ogni cella (cioè quanto spazio sulla dimensione X, per esempio, copre una cella). Poi prendo la posizione X della telecamera, la divido per questa variazione, e a tale risultato ci sommo la metà delle celle. La somma è necessaria perchè voglio che la posizione 0,0,0 sia il centro del mio mondo cubico!
Se non facessi così sarei invece posizionato ad un vertice del mondo.
Il metodo draw adesso, che non sto a riportare perchè è lungotto :O
Allora: nelle prime righe si assegna all'effetto usato per il rendering i valori opportuni, quindi la viewMatrix della telecamera, la projectionMatrix della telecamera, la texture dell'oggetto, e un colore.
Poi cominciamo a scorrere le mesh che compongono il nostro oggetto da renderizzare, in questo caso il nostro meteorite, che dovrà essere replicato tante volte.
Si crea una nuova BoundingSphere con centro e raggio presi dalla BoundingSphere della mesh in esame.
Le BoundingSphere sono usate per calcolare le collisioni tra volumi sferici, ma qui le userò per una cosa diversa ma molto utile ^__^
Poi cominciamo a scorrere le celli adiacenti alla posizione in cui si trova la telecamera: più val è grande maggiore è il numero di celle che considero adiacenti.
Poi riassetto gli indici, in modo che non vadano fuori dai limiti consentiti.
Scorro poi la lista di elementi della sezione data dagli indici r,c,p.
Modifico il centro ed il raggio della BoundingSphere, e calcolo se la sfera o contenuta o interseca il BoundingFrustum della telecamera e solo se lo è renderizzo il meteorite.
Perchè faccio ciò?
Perchè anche se renderizziamo solo le celle vicine a noi, eseguo di solito il draw anche per oggetti che mi sono alle spalle e che io non vedo. Facendo questo sprecherei tempo in rendering inutili, che vengono calcolati, ma il cui risultato non è visualizzato a schermo.
Il frustum della telecamera lo possiamo vedere come un cono che parte dal nostro punto di osservazione, o meglio un tronco di cono, che comincia alla distanza nearPlane e termina a farPlane.
Dato che prima di giungere a questo risultato ho fatto diverse prove, se non usassi il boundingFrustum otterrei con val = 8 qualcosa come soli 5 FPS. Con invece riesco ad arrivare a 70 FPS più o meno stabili! Un buon risultato!
Insomma quello che facciamo è controllare se il volume dato dalla boundingSphere adeguatamente settata è contenuto completamente o in parte nel cono visivo della telecamera, e solo se lo è renderizzo l'oggetto. E' molto più conveniente fare questo controllo che fare un rendering inutile!
E poi perchè usare le BoundingSphere? Perchè è un metodo comodo, semplice ed economico per calcolare il volume di un oggetto, perchè calcolarne il volume esatto controllando i poligoni/vertici è troppo oneroso secondo me (e poi non lo so fare XD).
E come lo calcolo il frustum?
Per questo bisogna andare a modifcare la telecamera!
Ecco il file della telecamera con tutte le modifiche apportate
Camera.cs Show/Hide
public enum CameraMode
{
Fixed,
Free,
Rotate,
Follow
}
public interface CameraI
{
Matrix View
{ get; }
Matrix Projection
{ get; }
Vector3 Position
{ get; set; }
Vector3 Up
{ get; set; }
Vector3 Target
{ get; set; }
float NearPlane
{ get; set; }
float FarPlane
{ get; set; }
CameraMode Mode
{ get; set; }
BoundingFrustum CameraBoundingFrustum
{ get; }
}
public class Camera : Microsoft.Xna.Framework.GameComponent, CameraI
{
//riferimento al controllo dell'input
protected InputI inputDevice;
//varibili per la telecamera
protected Matrix projection;
protected Matrix view;
protected Vector3 position = Vector3.Zero;
protected Vector3 target = Vector3.Zero;
protected Vector3 up = Vector3.Up;
protected float aspectRatio;
protected float nearPlane;
protected float farPlane;
protected BoundingFrustum cameraFrustum;
//varibili per lo spostamento e per la rotazione
protected float yaw, pitch;
protected Vector3 movimento;
protected float rotationRate = 100.0f;
protected float movementRate = 15000.0f;
protected CameraMode typeOfCamera = CameraMode.Fixed;
public Camera(Game game)
: base(game)
{
inputDevice = (InputI)game.Services.GetService(typeof(InputI));
game.Services.AddService(typeof(CameraI), this);
typeOfCamera = CameraMode.Fixed;
nearPlane = 1.0f;
farPlane = 100000f;
}
public override void Initialize()
{
base.Initialize();
aspectRatio = (float)Game.GraphicsDevice.Viewport.Width /
(float)Game.GraphicsDevice.Viewport.Height;
Matrix.CreatePerspectiveFieldOfView(MathHelper.PiOver4, aspectRatio, nearPlane, farPlane, out projection);
Matrix.CreateLookAt(ref position, ref target, ref up, out view);
cameraFrustum = new BoundingFrustum(view * projection);
}
private void updateFreeCamera(GameTime gameTime)
{
movimento = Vector3.Zero;
float delta = (float)gameTime.ElapsedGameTime.TotalSeconds;
if(inputDevice.actualKeyboardState.IsKeyDown(Keys.Up))
pitch -= rotationRate * delta;
if (inputDevice.actualKeyboardState.IsKeyDown(Keys.Down))
pitch += rotationRate * delta;
if (pitch > 89)
pitch = 89;
if (pitch < -89)
pitch = -89;
if (inputDevice.actualKeyboardState.IsKeyDown(Keys.Right))
yaw -= rotationRate * delta;
if (inputDevice.actualKeyboardState.IsKeyDown(Keys.Left))
yaw += rotationRate * delta;
if (yaw > 360)
yaw -= 360;
if (yaw < 0)
yaw += 360;
if (inputDevice.actualKeyboardState.IsKeyDown(Keys.W))
movimento.Z -= movementRate * delta;
if (inputDevice.actualKeyboardState.IsKeyDown(Keys.S))
movimento.Z += movementRate * delta;
if (inputDevice.actualKeyboardState.IsKeyDown(Keys.A))
movimento.X -= movementRate * delta;
if (inputDevice.actualKeyboardState.IsKeyDown(Keys.D))
movimento.X += movementRate * delta;
Matrix rotation = Matrix.CreateFromYawPitchRoll(MathHelper.ToRadians(yaw),
MathHelper.ToRadians(pitch), 0.0f);
Vector3.TransformNormal(ref movimento, ref rotation, out movimento);
position += movimento;
Vector3 transformedReference;
Vector3 dir = new Vector3(0, 0, -1);
Vector3.TransformNormal(ref dir, ref rotation, out transformedReference);
Vector3.Add(ref position, ref transformedReference, out target);
}
public override void Update(GameTime gameTime)
{
if (typeOfCamera == CameraMode.Free)
updateFreeCamera(gameTime);
aspectRatio = (float)Game.GraphicsDevice.Viewport.Width /
(float)Game.GraphicsDevice.Viewport.Height;
Matrix.CreatePerspectiveFieldOfView(MathHelper.PiOver4, aspectRatio, nearPlane, farPlane, out projection);
Matrix.CreateLookAt(ref position, ref target, ref up, out view);
cameraFrustum.Matrix = view * projection;
base.Update(gameTime);
}
#region CameraI Membri di
public Matrix View
{
get { return view; }
}
public Matrix Projection
{
get { return projection; }
}
public Vector3 Position
{
get { return position; }
set { position = value; }
}
public Vector3 Up
{
get { return up; }
set { up = value; }
}
public Vector3 Target
{
get { return target; }
set { target = value; }
}
public float NearPlane
{
get { return nearPlane; }
set { nearPlane = value; }
}
public float FarPlane
{
get { return farPlane; }
set { farPlane = value; }
}
public CameraMode Mode
{
get { return typeOfCamera; }
set { typeOfCamera = value; }
}
public BoundingFrustum CameraBoundingFrustum
{
get { return cameraFrustum; }
}
#endregion
}
Le parti importante da considerare sono:
l'enumeratore CameraMode: questo contiene i vari tipi di telecamera che mi sono venuti in mente. Per ora noi useremo solo Free, ma nulla vieta di implementare anche gli altri o di aggiungerne di nuovi!
Come si può vedere ho anche aggiunto alcuni campi all'interfaccia CameraI.
Aggiunta importate è la CameraBoundingFrustum, che verrà calcolato nel metodo Update.
Ora passiamo al metodo Update: per prima cosa andiamo a controllare il tipo di telecamera, e se è di tipo Free adiamo a chiamare il metodo per aggiornarla.
Poi si calcola la view e la projection matrix ed infine il boundigFrustum, dato dal prodotto delle view per la projection.
Vediamo il metodo updateFreeCamera:
private void updateFreeCamera(GameTime gameTime)
{
movimento = Vector3.Zero;
float delta = (float)gameTime.ElapsedGameTime.TotalSeconds;
if(inputDevice.actualKeyboardState.IsKeyDown(Keys.Up))
pitch -= rotationRate * delta;
if (inputDevice.actualKeyboardState.IsKeyDown(Keys.Down))
pitch += rotationRate * delta;
if (pitch > 89)
pitch = 89;
if (pitch < -89)
pitch = -89;
if (inputDevice.actualKeyboardState.IsKeyDown(Keys.Right))
yaw -= rotationRate * delta;
if (inputDevice.actualKeyboardState.IsKeyDown(Keys.Left))
yaw += rotationRate * delta;
if (yaw > 360)
yaw -= 360;
if (yaw < 0)
yaw += 360;
if (inputDevice.actualKeyboardState.IsKeyDown(Keys.W))
movimento.Z -= movementRate * delta;
if (inputDevice.actualKeyboardState.IsKeyDown(Keys.S))
movimento.Z += movementRate * delta;
Matrix rotation = Matrix.CreateFromYawPitchRoll(MathHelper.ToRadians(yaw),
MathHelper.ToRadians(pitch), 0.0f);
Vector3.Transform(ref movimento, ref rotation, out movimento);
position += movimento;
Vector3 transformedReference;
Vector3 dir = new Vector3(0, 0, -1);
Vector3.Transform(ref dir, ref rotation, out transformedReference);
Vector3.Add(ref position, ref transformedReference, out target);
}
MovementRate e RotationRate sono due variabili definite nella classe e ci dicono quanto velocemente si muove e ruota la nostra telecamera.
A seconda dei tasti che premiamo andiamo a modifcare i valori di Pitch e Yaw (che stanno rispettivamente per l'angolo sull'asse X ed Y), oppure a spostare la posizone della telecamera.
Usando yaw e pitch creo una matrice di rotazione, che uso per trasformare (cioè per spostare lungo la direzione data dalla matrice) la posizione della telecamera.
La stessa cosa la faccio per la posizione del punto che sto osservando, cioè per il target.
Come possiamo vedere in questo metodo non c'è il calcolo per la creazione della view e della projection: qui si aggiorna solo il valore della posizione e del target, la creazione viene fatta nel metodo update.
E questo è tutto.
Ora si deve solo andare in Game1.cs e mettere questo nel metodo Initialize:
defaultEffect = Content.Load<Effect>(@"Effects\Default");
mman = new MeteorManager(this, defaultEffect, 5, maxX,
maxY, maxZ, @"Models\asteroid1", @"Textures\asteroid1");
Components.Add(mman);
Le due variabili vanno naturalmente create prima ^^
Questo ci dice di caricare il file Default.fx, e di creare il MeteorManager che avrà 5 elementi per ogni sezione.
Dato che il MeteorManager è un GameComponent e non un DrawableGameComponent bisogna dirgli noi quando renderizzarlo!
Quindi nel metodo Draw di Game1.cs va messo questo:
mman.Draw(gameTime);
Ma veramente serve tutta questa palla del CameraBoundingFrustum, delle collisioni e tutto il resto?
Fate una prova:
Andate nel file del MeteorManager, nel Draw(..) mettere val = 8 e commentate la riga dove fate il controllo sul risultato del CameraBoundingFrustum.Contains(..).
Io riesco ad ottenere soltanto 5-6 FPS.
Facendo il controllo passo a circa 70.
Voi che dite? Serve?
Per me si ^___^
Poi almeno così si è visto come creare un manager per un insieme di oggetti, e come cominciare a buttare giù una semplice struttura per un gioco... qui il compito è..... contatare tutti gli asteroidi XD Sai che spasso XD
Scherzi a parte, potrebbe comunque essere un'idea di base per la struttura di un semplice gioco!
Ci dovrebbero essere altri metodi per semplificare il rendering di istanze multiple dello stesso elemento, ma ancora non sono in grado di applicarli.
Spero vi sia stato utile tutto questo.
Se ci sono cose che non tornanto o sbagliate o che si possono fare meglio (il che è molto probabile) ditelo please :)
Alla prossima!
Intanto ecco i file allegati!
XNA-tut5.rar
Argomenti trattati:
Free camera
Camera Bounding Frustum
