Share
In questa serie di tutorial, ti mostrerò come creare uno sparatutto twin-stick ispirato a Geometry Wars, con grafica al neon, effetti pazzeschi e musica fantastica, per iOS che utilizza C ++ e OpenGL ES 2.0. In questa parte, aggiungeremo esplosioni e stile visivo.
Nella serie finora, abbiamo impostato il gameplay e aggiunto i controlli virtuali del gamepad. Successivamente, aggiungeremo effetti particellari.
Gli effetti particellari vengono creati facendo un gran numero di piccole particelle. Sono molto versatili e possono essere usati per aggiungere stile a quasi tutti i giochi. In Shape Blaster creeremo esplosioni usando effetti particellari. Useremo anche effetti particellari per creare fuoco di scarico per la nave del giocatore e per aggiungere un tocco visivo ai buchi neri. Inoltre, vedremo come far interagire le particelle con la gravità dai buchi neri.
Fino ad ora, probabilmente state costruendo ed eseguendo Shape Blaster usando tutti i valori predefiniti mettere a punto costruzione del progetto. Mentre questo è ok e ottimo quando esegui il debug del tuo codice, il debug disattiva la maggior parte delle ottimizzazioni di velocità e matematica che è possibile eseguire, oltre a mantenere attive tutte le asserzioni nel codice.
In effetti, se esegui il codice in modalità di debug da qui in avanti, noterai che l'inizio della frequenza fotogrammi diminuisce drasticamente. Ciò è dovuto al fatto che abbiamo scelto come target un dispositivo che ha una quantità ridotta di RAM, clock clockspeed e hardware 3D più piccolo rispetto a un computer desktop o persino a un laptop.
Quindi a questo punto puoi disattivare il debugging e attivare la modalità "rilascio". La modalità di rilascio ci offre l'ottimizzazione completa del compilatore e della matematica, oltre alla rimozione del codice di debug inutilizzato e delle asserzioni.
Una volta aperto il progetto, scegli il Prodotto menu, schema, poi Modifica schema ... .
Si aprirà la seguente finestra di dialogo. Scegliere Correre sul lato sinistro della finestra di dialogo e da Costruisci la configurazione, cambia l'elemento a comparsa da mettere a punto a pubblicazione.
Noterai immediatamente i guadagni di velocità. Il processo è facilmente reversibile se è necessario eseguire nuovamente il debug del programma: basta scegliere mettere a punto invece di pubblicazione e hai finito.
Mancia: Si noti tuttavia che qualsiasi modifica dello schema come questa richiede una ricompilazione completa del programma.
Inizieremo creando un ParticleManager classe che memorizzerà, aggiornerà e disegnerà tutte le particelle. Renderemo questa classe abbastanza generale da poter essere facilmente riutilizzata in altri progetti, ma richiederà comunque alcune personalizzazioni da progetto a progetto. Per mantenere il ParticleManager nel modo più generale possibile, non sarà responsabile del modo in cui le particelle appaiono o si muovono; lo gestiremo altrove.
Le particelle tendono a essere create e distrutte rapidamente e in gran numero. Useremo un pool di oggetti per evitare di creare grandi quantità di spazzatura. Ciò significa che alloceremo un gran numero di particelle in primo piano e quindi continueremo a riutilizzare queste stesse particelle.
Faremo anche ParticleManager avere una capacità fissa. Ciò lo semplificherà e ci aiuterà a garantire che non superiamo le nostre prestazioni o limiti di memoria creando troppe particelle. Quando viene superato il numero massimo di particelle, inizieremo a sostituire le particelle più vecchie con quelle nuove. Faremo il ParticleManager una classe generica. Ciò ci consentirà di archiviare le informazioni di stato personalizzate per le particelle senza codificarle nel codiceParticleManager si.
Creeremo anche un particella classe:
class Particle public: ParticleState mState; tColor4f mColor; tVector2f mPosition; tVector2f mScale; tTexture * mTexture; float mOrientation; float mDuration; float mPercentLife; public: Particle (): mScale (1,1), mPercentLife (1.0f) ;
Il particella classe ha tutte le informazioni necessarie per visualizzare una particella e gestirne la durata. ParticleState è lì per contenere tutti i dati aggiuntivi di cui potremmo aver bisogno per le nostre particelle. Quali dati sono necessari varieranno a seconda degli effetti particellari desiderati; potrebbe essere utilizzato per memorizzare velocità, accelerazione, velocità di rotazione o qualsiasi altra cosa che potrebbe essere necessario.
Per aiutare a gestire le particelle, avremo bisogno di una classe che funzioni come un array circolare, nel senso che gli indici che normalmente sarebbero fuori limite verranno invece avvolti all'inizio dell'array. Ciò renderà facile sostituire prima le particelle più vecchie se esauriamo lo spazio per nuove particelle nel nostro array. Per questo, aggiungiamo il seguente come una classe annidata in ParticleManager:
class CircularParticleArray protected: std :: vectormlist; size_t mStart; size_t mCount; public: CircularParticleArray (int capacity) mList.resize ((size_t) capacity); size_t getStart () return mStart; void setStart (valore size_t) mStart = valore% mList.size (); size_t getCount () return mCount; void setCount (valore size_t) mCount = valore; size_t getCapacity () return mList.size (); Particle & operator [] (const size_t i) return mList [(mStart + i)% mList.size ()]; const Particle & operator [] (const size_t i) const return mList [(mStart + i)% mList.size ()]; ;
Possiamo impostare il MStart membro per regolare dove indice zero nel nostro CircularParticleArray corrisponde all'array sottostante, e mCount verrà utilizzato per tenere traccia di quante particelle attive sono presenti nell'elenco. Faremo in modo che la particella a zero indice sia sempre la particella più vecchia. Se sostituiamo la particella più vecchia con una nuova, semplicemente aumenteremo MStart, che sostanzialmente ruota l'array circolare.
Ora che abbiamo le nostre classi di aiuto, possiamo iniziare a compilare il ParticleManager classe. Avremo bisogno di una nuova variabile membro e di un costruttore.
CircularParticleArray mParticleList; ParticleManager :: ParticleManager (capacità int): mParticleList (capacità)
Noi creiamo mParticleList e riempirlo con particelle vuote. Il costruttore è l'unico posto in cui il ParticleManager alloca la memoria.
Successivamente, aggiungiamo il createParticle () metodo, che crea una nuova particella usando la particella successiva non utilizzata nel pool, o la particella più vecchia se non ci sono particelle inutilizzate.
void ParticleManager :: createParticle (trama tTexture *, const tVector2f e posizione, const tColor4f & tint, durata float, const tVector2f & scale, const ParticleState e stato, float theta) size_t index; if (mParticleList.getCount () == mParticleList.getCapacity ()) index = 0; mParticleList.setStart (mParticleList.getStart () + 1); else index = mParticleList.getCount (); mParticleList.setCount (mParticleList.getCount () + 1); Particle & ref = mParticleList [indice]; ref.mTexture = texture; ref.mPosition = posizione; ref.mColor = tinta; ref.mDuration = duration; ref.mPercentLife = 1.0f; ref.mScale = scala; ref.mOrientation = theta; ref.mState = state;
Le particelle possono essere distrutte in qualsiasi momento. Dobbiamo rimuovere queste particelle mentre assicuriamo che le altre particelle rimangano nello stesso ordine. Possiamo farlo ripetendo l'elenco delle particelle tenendo traccia di quante sono state distrutte. Mentre andiamo, spostiamo ogni particella attiva davanti a tutte le particelle distrutte scambiandola con la prima particella distrutta. Una volta che tutte le particelle distrutte sono alla fine della lista, le disattiviamo impostando la lista mCount variabile al numero di particelle attive. Le particelle distrutte rimarranno nell'array sottostante, ma non verranno aggiornate o disegnate.
ParticleManager :: update () gestisce l'aggiornamento di ogni particella e la rimozione di particelle distrutte dall'elenco:
void ParticleManager :: update () size_t removalCount = 0; per (size_t i = 0; i < mParticleList.getCount(); i++) Particle& ref = mParticleList[i]; ref.mState.updateParticle(ref); ref.mPercentLife -= 1.0f / ref.mDuration; Swap(mParticleList, i - removalCount, i); if (ref.mPercentLife < 0) removalCount++; mParticleList.setCount(mParticleList.getCount() - removalCount); void ParticleManager::Swap(typename ParticleManager::CircularParticleArray& list, size_t index1, size_t index2) const Particle temp = list[index1]; list[index1] = list[index2]; list[index2] = temp;
L'ultima cosa da implementare in ParticleManager sta disegnando le particelle:
void ParticleManager :: draw (tSpriteBatch * spriteBatch) for (size_t i = 0; i < mParticleList.getCount(); i++) Particle particle = mParticleList[(size_t)i]; tPoint2f origin = particle.mTexture->getSurfaceSize () / 2; spriteBatch-> draw (2, particle.mTexture, tPoint2f ((int) particle.mPosition.x, (int) particle.mPosition.y), tOptional(), particle.mColor, particle.mOrientation, origin, particle.mScale);
La prossima cosa da fare è creare una classe o una struttura personalizzata per personalizzare l'aspetto delle particelle in Shape Blaster. Ci saranno diversi tipi di particelle in Shape Blaster che si comportano in modo leggermente diverso, quindi inizieremo creando un enum per il tipo di particella. Avremo anche bisogno di variabili per la velocità della particella e la lunghezza iniziale.
class ParticleState public: enum ParticleType kNone = 0, kEnemy, kBullet, kIgnoreGravity; public: tVector2f mVelocity; ParticleType mType; float mLengthMultiplier; pubblico: ParticleState (); ParticleState (const tVector2f & velocity, tipo ParticleType, float lengthMultiplier = 1.0f); ParticleState getRandom (float minVel, float maxVel); void updateParticle (Particle & particle); ;
Ora siamo pronti a scrivere le particelle aggiornare() metodo. È una buona idea rendere questo metodo veloce, dal momento che potrebbe essere necessario chiamare un gran numero di particelle.
Inizieremo alla semplicità. Aggiungiamo il seguente metodo a ParticleState:
void ParticleState :: updateParticle (Particle & particle) tVector2f vel = particle.mState.mVelocity; particle.mPosition + = vel; particle.mOrientation = Extensions :: toAngle (vel); // i float denormalizzati causano problemi di prestazioni significativi se (fabs (vel.x) + fabs (vel.y) < 0.00000000001f) vel = tVector2f(0,0); vel *= 0.97f; // Particles gradually slow down particle.mState.mVelocity = vel;
Torneremo e miglioreremo questo metodo tra un momento. Innanzitutto, creiamo alcuni effetti particellari in modo che possiamo testare realmente le nostre modifiche.
Nel GameRoot, dichiarare un nuovo ParticleManager e chiamatelo aggiornare() e disegnare() metodi:
// in GameRoot protected: ParticleManager mParticleManager; public: ParticleManager * getParticleManager () return & mParticleManager; // nel costruttore di GameRoot GameRoot :: GameRoot (): mParticleManager (1024 * 20), mViewportSize (800, 600), mSpriteBatch (NULL) // in GameRoot :: onRedrawView () mParticleManager.update (); mParticleManager.draw (mSpriteBatch);
Inoltre, dichiareremo una nuova istanza di tTexture classe nel Arte classe chiamata mLineParticle per la consistenza della particella. Lo caricheremo come facciamo con gli sprite dell'altro gioco:
Accentsconagua
// Nel costruttore di Art mLineParticle = new tTexture (tSurface ("laser.png")); Ora facciamo esplodere i nemici. Modificheremo il Enemy :: wasShot () metodo come segue:
void Enemy :: wasShot () mIsExpired = true; per (int i = 0; i < 120; i++) float speed = 18.0f * (1.0f - 1 / Extensions::nextFloat(1, 10)); ParticleState state(Extensions::nextVector2(speed, speed), ParticleState::kEnemy, 1); tColor4f color(0.56f, 0.93f, 0.56f, 1.0f); GameRoot::getInstance()->getParticleManager () -> createParticle (Art :: getInstance () -> getLineParticle (), mPosition, colore, 190, 1.5f, stato);
Questo crea 120 particelle che spareranno verso l'esterno con velocità diverse in tutte le direzioni. La velocità casuale è ponderata in modo tale che le particelle abbiano maggiori probabilità di spostarsi vicino alla velocità massima. Questo farà sì che più particelle si trovino sul bordo dell'esplosione mentre si espande. Le particelle durano 190 frame, o poco più di tre secondi.
Ora puoi giocare e vedere i nemici esplodere. Tuttavia, ci sono ancora alcuni miglioramenti da apportare agli effetti particellari.
Il primo problema è che le particelle scompaiono bruscamente una volta esaurita la loro durata. Sarebbe più bello se potessero sfumare gradualmente, ma andiamo un po 'oltre e rendere le particelle più luminose quando si muovono velocemente. Inoltre, è bello se allunghiamo le particelle in rapido movimento e accorciamo quelle lente.
Modifica il ParticleState.UpdateParticle () metodo come segue (le modifiche sono evidenziate).
void ParticleState :: updateParticle (Particle & particle) tVector2f vel = particle.mState.mVelocity; particle.mPosition + = vel; particle.mOrientation = Extensions :: toAngle (vel); velocità di galleggiamento = vel.length (); float alpha = tMath :: min (1.0f, tMath :: min (particle.mPercentLife * 2, speed * 1.0f)); alfa * = alfa; particle.mColor.a = alfa; particle.mScale.x = particle.mState.mLengthMultiplier * tMath :: min (tMath :: min (1.0f, 0.2f * speed + 0.1f), alpha); // i float denormalizzati causano problemi di prestazioni significativi se (fabs (vel.x) + fabs (vel.y) < 0.00000000001f) vel = tVector2f(0,0); vel *= 0.97f; // Particles gradually slow down particle.mState.mVelocity = vel;
Le esplosioni sembrano molto meglio ora, ma sono tutte dello stesso colore.
Le esplosioni monocromatiche sono un buon inizio, ma possiamo fare di meglio? Possiamo dare loro più varietà scegliendo colori casuali. Un metodo per produrre colori casuali consiste nel scegliere casualmente i componenti rosso, blu e verde, ma questo produrrà un sacco di colori opachi e vorremmo che le nostre particelle avessero un aspetto di luce al neon. Possiamo avere maggiore controllo sui nostri colori specificandoli nello spazio colore HSV. HSV sta per tonalità, saturazione e valore. Vorremmo scegliere i colori con una tonalità casuale ma con una saturazione e un valore fissi. Abbiamo bisogno di una funzione di supporto che possa produrre un colore dai valori HSV.
tColor4f ColorUtil :: HSVToColor (float h, float s, float v) if (h == 0 && s == 0) return tColor4f (v, v, v, 1.0f); float c = s * v; float x = c * (1 - abs (int32_t (h)% 2 - 1)); float m = v - c; se (h < 1) return tColor4f(c + m, x + m, m, 1.0f); else if (h < 2) return tColor4f(x + m, c + m, m, 1.0f); else if (h < 3) return tColor4f(m, c + m, x + m, 1.0f); else if (h < 4) return tColor4f(m, x + m, c + m, 1.0f); else if (h < 5) return tColor4f(x + m, m, c + m, 1.0f); else return tColor4f(c + m, m, x + m, 1.0f);
Ora possiamo modificare Enemy :: wasShot () usare colori casuali. Per rendere il colore dell'esplosione meno monotono, selezioneremo due colori chiave nelle vicinanze per ogni esplosione e interpoleremo linearmente tra di loro di una quantità casuale per ogni particella:
void Enemy :: wasShot () mIsExpired = true; float hue1 = Estensioni :: nextFloat (0, 6); float hue2 = fmodf (hue1 + Estensioni :: nextFloat (0, 2), 6.0f); tColor4f color1 = ColorUtil :: HSVToColor (hue1, 0.5f, 1); tColor4f color2 = ColorUtil :: HSVToColor (hue2, 0.5f, 1); per (int i = 0; i < 120; i++) float speed = 18.0f * (1.0f - 1 / Extensions::nextFloat(1, 10)); ParticleState state(Extensions::nextVector2(speed, speed), ParticleState::kEnemy, 1); tColor4f color = Extensions::colorLerp(color1, color2, Extensions::nextFloat(0, 1)); GameRoot::getInstance()->getParticleManager () -> createParticle (Art :: getInstance () -> getLineParticle (), mPosition, colore, 190, 1.5f, stato);
Le esplosioni dovrebbero assomigliare all'animazione seguente:
Puoi giocare con la generazione del colore per soddisfare le tue preferenze. Una tecnica alternativa che funziona bene è scegliere una serie di modelli di colori per le esplosioni e selezionare casualmente dalle combinazioni di colori preselezionate.
Possiamo anche far esplodere i proiettili quando raggiungono il bordo dello schermo. Faremo essenzialmente la stessa cosa che abbiamo fatto per le esplosioni nemiche.
Modifichiamo Proiettile :: update () come segue:
if (! tRectf (0, 0, GameRoot :: getInstance () -> getViewportSize ()). contiene (tPoint2f ((int32_t) mPosition.x, (int32_t) mPosition.y))) mIsExpired = true; per (int i = 0; i < 30; i++) GameRoot::getInstance()->getParticleManager () -> createParticle (Art :: getInstance () -> getLineParticle (), mPosition, tColor4f (0.67f, 0.85f, 0.90f, 1), 50, 1, ParticleState (Estensioni :: nextVector2 (0, 9) , ParticleState :: kBullet, 1));
Potresti notare che dare alle particelle una direzione casuale è dispendioso, perché almeno la metà delle particelle andrà immediatamente fuori dallo schermo (di più se il proiettile esplode in un angolo). Potremmo fare un po 'di lavoro extra per garantire che le particelle abbiano solo velocità opposte al muro che stanno affrontando. Invece, prenderemo spunto da Geometry Wars e faremo rimbalzare tutte le particelle sui muri, così tutte le particelle che si dirigono fuori dallo schermo verranno rimbalzate indietro.
Aggiungi le seguenti linee a ParticleState.UpdateParticle () ovunque tra la prima e l'ultima riga:
tVector2f pos = particle.mPosition; int width = (int) GameRoot :: getInstance () -> getViewportSize (). width; int height = (int) GameRoot :: getInstance () -> getViewportSize (). height; // collide con i bordi dello schermo se (pos.x < 0) vel.x = (float)fabs(vel.x); else if (pos.x > larghezza) vel.x = (float) -fabs (vel.x); if (pos.y < 0) vel.y = (float)fabs(vel.y); else if (pos.y > altezza) vel.y = (float) -fabs (vel.y);
Faremo una grande esplosione quando il giocatore viene ucciso. Modificare PlayerShip :: kill () così:
void PlayerShip :: kill () PlayerStatus :: getInstance () -> removeLife (); mFramesUntilRespawn = PlayerStatus :: getInstance () -> getIsGameOver ()? 300: 120; tColor4f explosionColor = tColor4f (0.8f, 0.8f, 0.4f, 1.0f); per (int i = 0; i < 1200; i++) float speed = 18.0f * (1.0f - 1 / Extensions::nextFloat(1.0f, 10.0f)); tColor4f color = Extensions::colorLerp(tColor4f(1,1,1,1), explosionColor, Extensions::nextFloat(0, 1)); ParticleState state(Extensions::nextVector2(speed, speed), ParticleState::kNone, 1); GameRoot::getInstance()->getParticleManager () -> createParticle (Art :: getInstance () -> getLineParticle (), mPosition, colore, 190, 1.5f, stato);
Questo è simile alle esplosioni nemiche, ma usiamo più particelle e usiamo sempre la stessa combinazione di colori. Anche il tipo di particella è impostato su ParticleState :: kNone.
Nella demo, le particelle provenienti dalle esplosioni nemiche rallentano più velocemente rispetto alle particelle esplosive della nave del giocatore. Ciò rende l'esplosione del giocatore durare un po 'più a lungo e sembrare un po' più epica.
Ora che abbiamo effetti particellari, rivisitiamo i buchi neri e li facciamo interagire con le particelle.
I buchi neri dovrebbero influenzare le particelle in aggiunta ad altre entità, quindi dobbiamo modificarle ParticleState :: updateParticle (). Aggiungiamo le seguenti linee:
