Sulle pagine di "Computer News" vi ho ripetutamente parlato, cari lettori, di diversi ambienti di sviluppo: convenienti, belli, multipiattaforma. Perché, qualunque cosa si possa dire, l'ambiente di sviluppo è una cosa piuttosto importante sia per il programmatore stesso che per il suo datore di lavoro. Perché è importante per un programmatore, penso, non c'è bisogno di spiegarlo: ci scrive codice e più è conveniente scriverlo, più facile sarà lavorare. Tuttavia, i manager competenti comprendono che la cosiddetta comodità di un ambiente di sviluppo è, prima di tutto, la produttività di un dipendente che scrive e esegue il debug dei programmi. Pertanto, qualsiasi leader competente sa senza di me che non vale la pena risparmiare su un ambiente di sviluppo integrato (IDE). Tuttavia, a volte appare il desiderio di risparmiare denaro. È vero, anche questo viene fatto in modo abbastanza saggio: viene acquistata la versione più economica dell'ambiente di sviluppo e viene installata una versione più costosa e, di conseguenza, più funzionale.

Tuttavia, non è necessario salvare in questo modo, che, in generale, non può essere definito del tutto legale. Puoi usare freeware invece di questa truffa di software commerciale. Aspetta, non sputare! Capisco, tutto ciò che non assomiglia ai propri cari Microsoft Visual Studio e/o Delphi, all'inizio infastidiscono molti, anche al solo accenno. E c'è una spiegazione logica per questo: la maggior parte del software libero per programmatori (soprattutto per ambienti di sviluppo), anche al primo avvio, provoca uno dei due sentimenti umani non migliori: o disgusto o noia. A volte - pietà profonda e sincera. Tuttavia, attenzione, la maggior parte non è tutto software! Di norma, i prodotti freeware e open source più famosi meritano davvero l'attenzione sia degli sviluppatori che delle loro guide. Basti ricordare progetti come Eclipse o Dev-C++. E anche molti altri. In effetti, non è per niente che sempre più nuovi partecipanti si uniscono al movimento open source. Sempre più prodotti che una volta erano commerciali stanno guadagnando terreno come progetti gratuiti. Sebbene anche quei prodotti che sono nati come open-source, dopo un po' diventino piuttosto competitivi rispetto alle loro controparti commerciali. Tuttavia, va notato che il termine open-source non è sempre sinonimo del termine "software libero". Sebbene, di norma, i programmi open source siano distribuiti con licenze che ne consentono l'utilizzo senza alcuna royalty per gli sviluppatori.

L'ambiente di sviluppo, che ora voglio presentarvi, è solo uno di quei meravigliosi prodotti che suscitano interesse, e talvolta anche ammirazione. Questo programma si chiama, come si può vedere dal titolo dell'articolo, Code :: Blocks, e in Internet lo si può trovare all'indirizzo www.codeblocks.org. È destinato allo sviluppo di programmi che utilizzano C / C ++. La dimensione del download dipende dal fatto che scaricherai l'ambiente con o senza un compilatore. Dipende anche dal fatto che scaricherai il codice sorgente dell'IDE (e sono disponibili, poiché Code :: Blocks è distribuito sotto la GNU General Public License), o file già compilati. In generale, il volume di download varia da tre a tredici megabyte, che in realtà non è molto per un buon ambiente di sviluppo.

Quindi, l'ambiente è installato. Al primo avvio, l'occhio è soddisfatto della splendida schermata di benvenuto, che di solito non è tipica dei prodotti software gratuiti. Già da esso si può giudicare la serietà dell'approccio degli autori di Code :: Blocchi allo sviluppo della loro prole.

Qual è l'ambiente di sviluppo pronto ad offrire al programmatore che lo utilizza? Non così piccolo, soprattutto se confrontato con altri IDE gratuiti. Innanzitutto, multipiattaforma. Tuttavia, è limitato a due piattaforme: Windows e Linux. Non moltissimi, ma questi sono i principali sistemi operativi in ​​commercio. Tuttavia, il supporto per alcuni altri (ad esempio, Mac OS X) sarebbe comunque utile. Personalmente, ho scaricato la versione per Windows, tuttavia, a giudicare dagli screenshot sul sito degli sviluppatori, sotto Linux questo programma non sembra peggio.

In secondo luogo, chiunque può collegare il compilatore che preferisce all'ambiente. O quello che è più familiare da usare. E compilatori l'ambiente di sviluppo supporta quanto segue: GCC (MinGW per Windows), Microsoft Visual C ++ Compiler, Digital Mars, Borland C ++ (versione 5.5), Open Watcom e Sun DCC. Se hai scaricato l'ambiente insieme al compilatore, ovviamente sarà GCC. L'ambiente stesso passa al compilatore tutte le chiavi necessarie affinché funzioni con le opzioni date. Inoltre, la compilazione può essere effettuata sia direttamente che tramite make-file, che Code :: Blocks possono generare anche in modo completamente autonomo.

In terzo luogo, Code :: Blocks ha un editor di codice conveniente e multifunzionale che supporta l'evidenziazione della sintassi e la piegatura (piegatura) dei blocchi di codice. Inoltre, l'ambiente è in grado di lavorare non solo con testi in C/C++, ma anche con file XML. Sulla sinistra nella finestra del programma c'è una guida alle classi usate nel suo testo, così come un elenco di tutte le variabili, costanti, classi e namespace usati. C'è anche un albero delle risorse e un elenco di variabili visualizzate durante il debug. La cosa bella è che tutti apri il file nell'ambiente ha la sua scheda. È un approccio pratico ed è fantastico che sempre più IDE lo utilizzino.

In quarto luogo, l'ambiente Code :: Blocks supporta i plug-in, ovvero i plug-in. Questa è una funzionalità davvero utile e con il suo aiuto gli sviluppatori hanno implementato diverse cose utili per un programmatore che utilizza Code :: Blocks. E la principale di queste cose sono, ovviamente, i suggerimenti che appaiono sullo schermo mentre digiti il ​​codice e contengono elenchi di metodi di classe e parametri di metodi o funzioni. Questa funzionalità è implementata, secondo me, non peggio che in molti ambienti di sviluppo commerciale. Tra gli altri plugin che il sito del progetto Code :: Blocks vanta, mi sembra valga la pena ricordare la procedura guidata per la formattazione del codice, la procedura guidata per la creazione di nuove classi, il calcolo delle statistiche sul codice sorgente del progetto e la procedura guidata per incorporare XP Manifest nelle risorse del progetto . Se, come me, hai scaricato la versione più grande di Code :: Blocks (quella con il compilatore), allora hai già tutti questi plugin. Naturalmente, ognuno può creare il proprio plugin per l'ambiente di sviluppo. Per fare ciò, dovrai scaricare uno speciale SDK (Software Development Kit - kit di sviluppo Software) dal sito del progetto.

L'ambiente utilizza GNU Debugger come debugger. Lavorare con esso praticamente non differisce dal lavorare con i debugger. Ambienti Microsoft e Borland. Anche nell'ambiente c'è il supporto per un elenco di quelle cose che lo sviluppatore deve fare nell'applicazione (lista delle cose da fare). Può essere configurato in modo tale che se l'ambiente è utilizzato da più sviluppatori, per ciascuno di essi sarà proprio e indipendente dalle liste di altri sviluppatori. È anche conveniente lavorare con progetti nell'ambiente. Come in Microsoft Visual Studio, sono separati dalle impostazioni dell'area di lavoro e, ciò che è bello, sia i progetti che l'ambiente degli spazi di lavoro possono essere importati dal formato Visual Studio.A proposito, i progetti possono anche essere importati dal Dev-C + + formato È vero, queste funzionalità sono descritte in modo puramente teorico dagli stessi sviluppatori IDE e io stesso non posso dire nulla su di esse, poiché io stesso non le ho provate in azione.

Code :: Blocks ha un'altra importante caratteristica che lo distingue da molti altri ambienti di sviluppo. Questo ambiente ha una stretta integrazione con la libreria wxWidgets, progettata per creare un'interfaccia utente grafica (ne ho scritto una volta in "Computer News"). Questa libreria ha molti vantaggi, e quindi gli sviluppatori di Code :: Blocks hanno fatto un'ottima mossa strategica, orientando il loro prodotto verso il lavoro con questa meravigliosa libreria. È vero, questo è implementato, ancora una volta, con l'aiuto di un plugin chiamato wxSmith, ma questi non sono i dettagli più significativi. Il plugin permette lo sviluppo dell'interfaccia dell'applicazione in modalità visuale, che non può che essere apprezzata dagli sviluppatori. Soprattutto quelli che hanno provato a creare un'interfaccia in modalità non visiva. La modalità di modifica è simile a quella di Microsoft Visual C++ o Borland C++ Builder. Un designer simile, un editor simile per le proprietà degli oggetti. Data la natura multipiattaforma di wxWidgets e Code :: Blocks, questa è una funzionalità assolutamente eccezionale.

Bene, ecco un IDE così carino e utile chiamato Code :: Blocks. Forse molti diranno che è lontano da Visual Studio o Borland Developer Studio e, ovviamente, avranno ragione. Manca, come nelle versioni moderne di questi ambienti commerciali, la capacità di sviluppare applicazioni in molti linguaggi e sviluppare per la piattaforma .NET. Tuttavia, questo ambiente è molto più leggero e compatto dei mostri di Microsoft e Borland. Inoltre, per la creazione di applicazioni multipiattaforma per Windows e Linux, la combinazione di Code :: Blocks e wxWidgets sembra essere una delle migliori opzioni tra tutte le opzioni possibili. Quindi non voltare immediatamente le spalle al software gratuito. Meglio provare prima, e poi decidere se voltare le spalle o meno. Verità comuni? Forse. Ma più l'affermazione è banale, più è difficile per una singola persona raggiungerla.

Vadim STANKEVICH

Ambiente di sviluppo integrato (IDE) Code :: Blocks (di seguito CB) è un prodotto completo per lo sviluppo di applicazioni in C/C++. CB è un framework multipiattaforma sviluppato utilizzando la libreria di strumenti wxWidgets. Esistono versioni dell'ambiente sia per Windows che per altri sistemi operativi (OS) - Linux e Mac OS. Questo IDE è completamente gratuito, open source e costruito interamente utilizzando tecnologie aperte... Uno dei più punti di forza CB è supportare la creazione di applicazioni wxWidgets, ovvero software che utilizza l'API del sistema operativo per eseguire il rendering di un'interfaccia utente grafica (GUI). In altre parole, CB ti consente di creare software multipiattaforma per tutti i gusti.

CB può lavorare con grande quantità compilatori. Se ce ne sono diversi installati nel sistema, puoi facilmente passare da uno all'altro, a seconda delle tue esigenze. Inoltre, l'IDE stesso, in fase di installazione, eseguirà la scansione del sistema per i compilatori disponibili e offrirà di utilizzarne uno come principale. È possibile modificare successivamente queste impostazioni sia globalmente che separatamente per i progetti. Per Impostazioni globali ambiente, c'è un'intera sezione "Impostazioni" nel menu principale di CB. Per effettuare impostazioni specifiche per un progetto specifico, è necessario aprire la finestra delle proprietà del progetto. Per farlo, devi chiamare menù contestuale progetto cliccandoci sopra con il tasto destro del mouse, e selezionare la voce "Proprietà". I progetti stessi (aperti nel questo momento nell'IDE) vengono visualizzati come un albero nel dock "Gestione", nella sua scheda "Progetti". Ora, nella finestra delle proprietà che si apre, puoi configurare un'ampia varietà di parametri, dalla modifica delle destinazioni di compilazione alla connessione di librerie di terze parti. Il pulsante "Opzioni di compilazione del progetto" nella scheda "Impostazioni progetto" della stessa finestra delle proprietà ti consentirà di configurare in modo molto flessibile la configurazione della build per un progetto specifico: chiavi del compilatore, selezionare il compilatore stesso, collegare librerie per il linker, ecc. Tutto questo può essere fatto per le singole modalità: "Rilascio" "Debug".

La GUI di CB è costruita attorno a banchine mobili e allungabili che possono essere ancorate su entrambi i lati della finestra principale dell'IDE semplicemente trascinandole e rilasciandole. Grazie a ciò, è possibile personalizzare in modo molto flessibile diversi layout dell'interfaccia per misure differenti schermo, ottimizzando l'ergonomia della GUI. Se sono presenti più monitor, è conveniente separare alcuni pannelli dalla finestra principale e posizionarli sui monitor adiacenti.

Gli strumenti di evidenziazione, completamento del codice e modifica in CB rendono il processo di lavoro con il codice facile e comodo. Un enorme arsenale di impostazioni ti consente di personalizzare molto finemente l'ambiente "per te". È molto utile avere il supporto per lavorare con le variabili di ambiente. Grazie a questa caratteristica, CB può essere integrato molto strettamente nel sistema ed estenderne le capacità, ad esempio, in questo modo, è possibile collegare la libreria wxWidgets.

Voglio raccontarvi la mia prima esperienza nello sviluppo di giochi. Va notato subito che l'articolo sarà puramente tecnico, poiché il mio obiettivo era proprio quello di acquisire competenze nello sviluppo di applicazioni grafiche utilizzando Direct3D, senza coinvolgere strumenti di sviluppo di giochi di alto livello come Unity. Di conseguenza, non si parlerà nemmeno dell'implementazione, della monetizzazione e della promozione del gioco. L'articolo è rivolto ai principianti nella programmazione di applicazioni Direct3D, nonché semplicemente alle persone interessate ai meccanismi chiave del lavoro. applicazioni simili... Inoltre, alla fine, presento un elenco di letteratura sullo sviluppo di giochi, da me accuratamente selezionata tra più di cento libri sulla programmazione di giochi e sulla computer grafica.

introduzione

Quindi, nel mio tempo libero, ho deciso di esplorare la popolare API grafica. Dopo aver letto diversi libri e analizzato una serie di esempi e tutorial (incluso dall'SDK DirectX), mi sono reso conto che è arrivato il momento in cui vale la pena provare da solo. Il problema principale era che la maggior parte degli esempi esistenti dimostra semplicemente l'uno o l'altro Capacità dell'API e sono implementati proceduralmente in quasi un file cpp, e anche usando il wrapper DXUT, e non danno un'idea di quale struttura dovrebbe avere l'applicazione finale, quali classi devono essere progettate e come dovrebbero interagire tra loro, quindi che tutto fosse bello, leggibile e funzionasse in modo efficiente. Questo svantaggio vale anche per i libri su Direct3D: ad esempio, per molti principianti non è ovvio che gli stati di rendering non debbano sempre essere aggiornati quando si esegue il rendering di ogni fotogramma, e anche che la maggior parte delle operazioni pesanti (come riempire il buffer dei vertici ) deve essere eseguito solo una volta durante l'inizializzazione dell'applicazione (o durante il caricamento di un livello di gioco).

Idea

Prima di tutto, dovevo decidere l'idea stessa del gioco. Mi è subito venuto in mente un vecchio gioco del 1992 sotto MS-DOS, che credo sia familiare a molti. Questo è il gioco di logica Lines di Gamos.

Ebbene, la sfida è accettata. Ecco cosa abbiamo:

• c'è un campo quadrato di celle;
• ci sono palline multicolori nelle celle sul campo;
• dopo aver spostato la palla, appaiono nuove palle;
• l'obiettivo del giocatore è quello di allineare le palline monocolore in una linea: l'accumulo di un certo numero di palline monocolore in una linea porta alla loro detonazione e all'assegnazione di punti;
• il compito principale è resistere il più a lungo possibile fino a quando il campo non esaurisce le celle libere.

Vediamo ora dal punto di vista di un'applicazione Direct3D:

• faremo un campo di celle sotto forma di una piattaforma tridimensionale con sporgenze, ogni cella sarà qualcosa come un podio;
• devono essere implementati tre tipi di animazione della palla:
  1. l'aspetto della palla: prima appare una pallina, che in breve tempo raggiunge le dimensioni adulte;
  2. movimento della palla: solo c'è un movimento sequenziale attraverso le celle;
  3. palla che rimbalza: quando selezioni una palla con il mouse, dovrebbe attivarsi e iniziare a saltare sul posto;
• deve essere implementato un sistema di particelle da utilizzare nell'animazione dell'esplosione;
• l'output testuale deve essere implementato: per visualizzare sullo schermo i punti guadagnati;
• la gestione deve essere attuata macchina fotografica virtuale: rotazione e zoom.

In effetti, i punti sopra elencati sono una misera parvenza di un documento chiamato progetto di design. Consiglio vivamente di scrivere tutto nei minimi dettagli prima di iniziare lo sviluppo, stamparlo e tenerlo davanti agli occhi! Guardando al futuro, mostro immediatamente un video dimostrativo per chiarezza sull'implementazione dei punti (a proposito, il video è stato registrato utilizzando il programma ezvid, quindi non allarmarti per la loro schermata iniziale all'inizio):

Inizio dello sviluppo

Fino ad ora, non ho menzionato quali strumenti sono stati utilizzati. Innanzitutto, è necessario il software DirectX kit di sviluppo(SDK), sempre disponibile per il download gratuito dal sito Microsoft: DirectX SDK. Se hai intenzione di utilizzare la versione Direct3D 9, come me, dopo l'installazione devi aprire il Pannello di controllo di DirectX tramite il menu principale e selezionare nella scheda Direct3D 9 quale versione delle librerie verrà utilizzata durante la build - vendita al dettaglio o debug (questo influisce sul fatto che Direct3D riporti al debugger i risultati delle sue attività):

Debug o vendita al dettaglio

Perché Direct3D 9? Perché questa è l'ultima versione, in cui è ancora presente una pipeline di funzioni fisse, ovvero una pipeline grafica fissa che include, ad esempio, funzioni per il calcolo dell'illuminazione, l'elaborazione dei vertici, il missaggio e così via. A partire dalla versione 10, gli sviluppatori sono incoraggiati a implementare in modo indipendente queste funzioni negli shader, il che è vantaggio innegabile, ma, secondo me, è difficile da capire ai primi esperimenti con Direct3D.

Perché Code :: blocchi? Probabilmente è stato sciocco utilizzare un IDE multipiattaforma per sviluppare un'applicazione che utilizza un'API non multipiattaforma. È solo che i blocchi Code :: occupano molte volte meno spazio di Visual Studio, il che si è rivelato molto rilevante per il mio PC di campagna.

Iniziare con Direct3D si è rivelato molto semplice. In Code :: block ho creato un progetto vuoto, quindi due cose dovevano essere fatte nelle opzioni di compilazione:

1) Nella scheda delle directory di ricerca e nella sottoscheda del compilatore, aggiungi il percorso alla directory include DirectX SDK, ad esempio in questo modo:

Cerca nelle directory

2) Nella scheda del linker, aggiungi due librerie - d3d9.lib e d3dx9.lib:

Linker

Dopo che in codice sorgente l'applicazione dovrà includere i file di intestazione Direct3D:

#include "d3d9.h" #include "d3dx9.h"

Struttura dell'applicazione

Qui ho commesso il mio primo errore: ho iniziato a pensare a quale design pattern scegliere. Sono giunto alla conclusione che MVC (model-view-controller) è il più adatto: il modello sarà la classe di gioco (gioco), che include tutta la logica: calcolo dei percorsi di movimento, aspetto delle palle, analisi di combinazioni esplosive; la vista sarà la classe motore responsabile del rendering e dell'interazione con Direct3D; il controller sarà il wrapper stesso (app): ciò include il ciclo dei messaggi, la gestione dell'input dell'utente e, soprattutto, il gestore dello stato e la garanzia dell'interazione tra il gioco e gli oggetti del motore. Tutto sembra semplice e puoi iniziare a scrivere file di intestazione, ma era così! In questa fase, si è rivelato molto difficile navigare e capire quali metodi dovrebbero avere queste classi. È chiaro che c'era una completa mancanza di esperienza e ho deciso di ricorrere al consiglio di uno dei libri: "Non cercare di scrivere un codice perfetto fin dall'inizio, lascia che sia sub-ottimale e disordinato. La comprensione arriva con il tempo e il refactoring può essere fatto in seguito". Di conseguenza, dopo diverse iterazioni di refactoring layout già funzionante la definizione delle tre classi principali ha preso la forma:

Classe di gioco

class TGame (privato: BOOL gameOver; TCell * cellule; WORD * percorso; WORD percorsoLen; LONG punteggio; void ClearField (); WORD GetSelected (); WORD GetNeighbors (WORD cellId, WORD * pNeighbors); BOOL CheckPipeDetonate (WORD * pPipeCipeC ; public: TGame (); ~ TGame (); void New (); BOOL CreateBalls (WORD count); void Select (WORD cellId); BOOL TryMove (WORD targetCellId); BOOL DetonateTest (); WORD GetNewBallList (TBallInfo ** ppNewList ) ; WORD GetLastMovePath (WORD ** ppMovePath); WORD GetDetonateList (WORD ** ppDetonateList); LONG GetScore (); BOOL IsGameOver (););

Classe motore

class TEngine (privato: HWND hWindow; RECT WinRect; D3DXVECTOR3 CameraPos; LPDIRECT3D9 pD3d; LPDIRECT3DDEVICE9 pDevice; LPDIRECT3DTEXTURE9 pTex; LPD3DXFONT pFont; D3DPRESENT settings_PARAM l'animazione del salto *compare il movimento delle palle; TAnimation; void; InAnimation ); void InitAnimation (); void DrawPlatform (); void DrawBalls (); void UpdateView (); public: TEngine (HWND hWindow ; ~ TEngine (); void AppearBalls (TBallInfo * ballInfo, WORD count); void MoveBall (WORD * path, WORD pathLen); void DetonateBalls (WORD * detonateList, WORD count); BOOL IsSelected (); BOOL IsMoving (); BOOL IsAppearing (); BOOL IsDetonating (); void OnResetGame (); WORD OnClick (WORD x, WORD y , BOOL * IsCell); void OnRotateY (offset INT); void OnRotateX (offset INT); void OnZoom (INT zoom); void OnResize (); void OnUpdateScore (LONG punto); rendering vuoto (); );

Classe di applicazione

class TApplication (privato: HINSTANCE hInstance; HWND hWindow; POINT mouseCoords; TEngine * engine; TGame * game; BOOL moveStarted; BOOL detonateStarted; BOOL compareStarted; void RegWindow (); statico LRESULT CALLBACK MsgProc, wpmint LPARAMGa lPameram); ; public: TApplication (HINSTANCE hInstance, INT cmdShow); ~ TApplication (); TEngine * GetEngine (); TGame * GetGame (); INT MainLoop (););

La classe TGame ha solo 3 metodi che l'utente può avviare: New (un nuovo gioco), Select (seleziona una palla) e TryMove (un tentativo di spostare una palla). Le altre sono ausiliarie e vengono chiamate dal controllore in casi particolari. Ad esempio, DetonateTest (test per combinazioni esplosive) viene chiamato dopo la comparsa di nuove palline o dopo un tentativo di movimento. GetNewBallList, GetLastMovePath, GetDetonateList vengono chiamati, rispettivamente, dopo la comparsa delle palline, dopo il movimento e dopo l'esplosione, con uno scopo: ottenere una lista di palline specifiche e passarla all'oggetto motore per l'elaborazione in modo che disegni qualcosa . Non voglio soffermarmi sulla logica del lavoro di TGame in dettaglio, poiché ci sono codici sorgente con commenti. Dirò solo che la definizione del percorso del movimento della palla è implementata usando l'algoritmo di Dijkstra per un grafo non orientato con pesi uguali di tutti i bordi.

Diamo un'occhiata più da vicino alle classi motore e controller.

TEmotore

• La classe definisce i campi per memorizzare l'handle della finestra e il suo rettangolo. Vengono utilizzati nel metodo OnResize che il controller chiama quando la finestra viene ridimensionata per calcolare una nuova matrice di proiezione.
• Il campo CameraPos memorizza le coordinate dell'osservatore nello spazio mondiale. Non è necessario memorizzare il vettore della direzione della vista, poiché, secondo la mia idea, la fotocamera è sempre diretta all'origine delle coordinate, che, tra l'altro, coincide con il centro della piattaforma.
• Ci sono anche puntatori alle interfacce Direct3D: LPDIRECT3D9, che è necessario solo per creare un dispositivo; LPDIRECT3DDEVICE9 - infatti, il dispositivo Direct3D stesso, l'interfaccia principale con cui devi lavorare; LPD3DXFONT e LPDIRECT3DTEXTURE9 per lavorare con testo e texture.
• Il campo currentTime viene utilizzato per memorizzare l'ora corrente in millisecondi ed è necessario per eseguire il rendering di un'animazione fluida. Il fatto è che il rendering di ogni fotogramma richiede un numero diverso di millisecondi, quindi devi misurare questi millisecondi ogni volta e usarli come parametro durante l'interpolazione dell'animazione. Questo metodo è noto come sincronizzazione dell'ora ed è usato ubiquitariamente nelle moderne applicazioni grafiche.
• I puntatori agli oggetti TGeometry (cellGeometry e ballGeometry) memorizzano la geometria di una cella e di una sfera. Lo stesso oggetto TGeometry, come suggerisce il nome, è progettato per funzionare con la geometria e contiene buffer di vertice e indice, nonché una descrizione del materiale (D3DMATERIAL9). Durante il rendering, possiamo cambiare la matrice del mondo e chiamare il metodo Render dell'oggetto TGeometry, che renderà più celle o sfere.
• TParticleSystem è una classe di sistema di particelle che ha metodi per inizializzare molte particelle, aggiornare le loro posizioni nello spazio e, naturalmente, il rendering.
• TBall * balls - una serie di palline con informazioni sul colore e sullo stato [rimbalzano, si muovono, emergono].
• Tre oggetti di tipo TAnimate - per fornire animazione. La classe ha un metodo per inizializzare i fotogrammi chiave, che sono matrici di trasformazione mondiale, e metodi per calcolare la posizione dell'animazione corrente e applicare la trasformazione. Nella routine di rendering, l'oggetto motore esegue il rendering sequenziale delle palline e facoltativamente chiama il metodo ApplyTransform dell'animazione desiderata per deformare o spostare la sfera.
• InitD3d, InitGeometry, InitAnimation vengono chiamati solo dal costruttore TEngine e sono separati in metodi separati per chiarezza. InitD3d crea un dispositivo Direct3D e imposta tutti gli stati di rendering richiesti, inclusa l'impostazione di una luce puntiforme con uno speculare direttamente al centro della piattaforma.
• I tre metodi AppearBalls, MoveBall e DetonateBalls attivano rispettivamente le animazioni di apparizione, spostamento ed esplosione.
• I metodi IsSelected, IsMoving, IsAppearing, IsDetonating vengono utilizzati nella funzione di gestione dello stato per tenere traccia del termine dell'animazione.
• I metodi con il prefisso On vengono chiamati dal controller quando si verificano gli eventi corrispondenti: clic del mouse, rotazione della telecamera, ecc.

Diamo un'occhiata al metodo Render principale:

TEngine :: Render ()

void TEngine :: Render() (// calcola quanti millisecondi sono trascorsi da quando è stato disegnato il frame precedente clock_t elapsed = clock (), deltaTime = elapsed-currentTime; currentTime = elapsed; // aggiorna le posizioni di animazione se sono attive if ( jumpAnimation-> IsActive ()) (jumpAnimation-> UpdatePosition (deltaTime);) if (appearAnimation-> IsActive ()) (appearAnimation-> UpdatePosition (deltaTime);) if (moveAnimation-> IsActive ()) (moveAnimation-> UpdatePosition (deltaTime );) pDevice-> Clear (0, NULL, D3DCLEAR_STENCIL | D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER, D3DCOLOR_XRGB (0,0,0), 1.0f, 0); pDevice-> BeginScene (); // disegna la piattaforma DrawPlatform () ; disegna palline DrawBalls (); // se il sistema di particelle è attivo, aggiorna le posizioni delle particelle e le rende con una texture if (psystem-> IsActive()) (pDevice-> SetTexture (0, pTex); psystem -> Update (deltaTime); psystem-> Render (); pDevice-> SetTexture (0,0);) // visualizzazione dei punti guadagnati char buf = "Score:", tmp; itoa (score, tmp, 10); strcat (buf, tmp);RECT fontRect; fontRect.left = 0; fontRect.right = GetSystemMetrics (SM_CXSCREEN); fontRect.top = 0; fontRect.bottom = 40; pFont-> DrawText (NULL, _T (buf), - 1, & fontRect, DT_CENTER, D3DCOLOR_XRGB (0,255,255)); pDevice-> EndScene (); pDevice-> Present (NULL, NULL, NULL, NULL); )

All'inizio, calcola quanti millisecondi sono trascorsi dalla precedente chiamata a Render(), quindi l'avanzamento dell'animazione viene aggiornato, se sono attivi. I tamponi vengono eliminati con il metodo Clear e la piattaforma, le sfere e il sistema di particelle vengono estratti in sequenza, se attivo. Infine viene visualizzata una riga con il valore attuale dei punti guadagnati.

TApplicazione

• La classe ha un campo per memorizzare le coordinate del mouse, poiché dovremo calcolare i relativi valori di offset del cursore per ruotare la telecamera.
• I booleani appaionoStarted, moveStarted e detonateStarted sono necessari per tenere traccia dello stato delle animazioni corrispondenti.
• Il metodo RegWindow contiene il codice per la registrazione della classe della finestra.
• Il metodo statico MsgProc è una cosiddetta procedura a finestra.
• ProcessGame è una versione semplificata del gestore dello stato, che valuta lo stato attuale del gioco e intraprende alcune azioni in base a esso.
• MainLoop - ciclo di messaggi.

Ecco un controller leggero. Un ciclo di messaggi simile può essere trovato in qualsiasi libro Direct3D:

TApplicazione :: MainLoop ()

INT TApplication :: MainLoop () (MSG msg; ZeroMemory (& msg, sizeof (MSG)); while (msg.message! = WM_QUIT) (if (PeekMessage (& msg, NULL, 0,0, PM_REMOVE)) (TranslateMessage (& msg ); DispatchMessage (& msg);) else (// se non ci sono messaggi, quindi elabora lo stato del gioco e visualizza ProcessGame (); engine-> Render ();)) return (INT) msg.wParam; )

L'unica cosa che merita attenzione è ciò che è all'interno del blocco else: questa è la cosiddetta IdleFunction, che viene eseguita in assenza di messaggi.

Ed ecco la funzione del dirigente statale:

TApplicazione :: ProcessGame ()

void TApplication :: ProcessGame () (if (moveStarted) (// aspetta fino alla fine dell'animazione del movimento if (! engine-> IsMoving ()) (// il movimento è terminato - test per l'esplosione moveStarted = FALSE; if (game-> DetonateTest ( )) (// avvia un'esplosione e aumenta i punti WORD * detonateList, count = game-> GetDetonateList (& detonateList); detonateStarted = TRUE; engine-> DetonateBalls (detonateList, count); engine-> OnUpdateScore (game-> GetScore ()) ;) else (// altrimenti proviamo ad aggiungere palline if (game-> CreateBalls (APPEAR_COUNT)) (TBallInfo * compareList; WORD count = game-> GetNewBallList (& compareList); compareStarted = TRUE; engine-> AppearBalls (appearList, count); ) else (// game over!)))) if (appearStarted) (// attendi fino alla fine dell'animazione if (! engine-> IsAppearing ()) (appearStarted = FALSE; // l'aspetto is over - verifica un'esplosione nel caso in cui if (game-> DetonateTest ()) (// avvia un'esplosione e aumenta i punti WORD * detonateList, count = game-> GetDetonateList (& detonateList); det onateStarted = TRUE; motore-> DetonateBalls (detonateList, count); motore-> OnUpdateScore (gioco-> GetScore ()); ))) if (detonateStarted) (// aspetta fino alla fine dell'animazione dell'esplosione if (! engine-> IsDetonating ()) (// resetta semplicemente il flag detonateStarted = FALSE;)))

Bene, forse è tutto!

Spero che la mia ricerca possa giovare a qualcuno. A proposito, le fonti sono su github.

Grazie per l'attenzione!

Letteratura promessa

1. Frank D. Luna Un'introduzione alla programmazione di giochi 3D con DirectX 9.0 - per comprendere le basi;
2. Gornakov S. Lezioni di programmazione DirectX9 in C ++ - anche le basi, ma ci sono capitoli su DirectInput, DirectSound e DirectMusic. A volte si verificano errori nei programmi di esempio;
3. Flenov ME DirectX e C++ l'arte della programmazione - uno stile di presentazione divertente. Fondamentalmente, lo scopo del libro è creare animazioni usando effetti interessanti, inclusi gli shader. Giudicate voi stessi dai titoli delle sezioni: infarto, drago di fuoco;
4. Barron Todd Programmazione di giochi di strategia con DirectX 9 - completamente dedicato ad argomenti relativi ai giochi di strategia: grafica a blocchi, intelligenza artificiale, creazione di mappe e paesaggi, sprite, effetti speciali con sistemi di particelle, nonché sviluppo di interfacce dello schermo e lavoro con DirectSound / Musica ;
5. Bill Fleming 3D Creature WorkShop - un libro non sulla programmazione, ma sullo sviluppo di modelli di personaggi tridimensionali in LightWave, 3D Studio Max, Animation Master;
6. Thorn Alan DirectX 9 Interfacce utente Progettazione e implementazione - libro dettagliato sullo sviluppo interfacce grafiche con DirectX. Viene considerato un modello gerarchico dei componenti schermate, simile a quello implementato in Delphi;
7. Adams Jim Advanced Animation con DirectX - discute i tipi di animazione (scheletrica, morphing e varietà) e la loro implementazione, oltre a lavorare con la geometria e l'animazione da X-files;
8. Lamotte Andre Giochi di programmazione per Windows. Consulenza professionale: questo libro è già più serio: discute problemi di ottimizzazione, scelta delle strutture dati per varie attività, multithreading, modellazione fisica, AI. L'ultimo capitolo descrive come creare un gioco su navicella spaziale e alieni;
9. David H. Eberly 3D Game Engine Design è un buon libro per comprendere l'intera teoria dello sviluppo del gioco: prima descrive le tecnologie API grafiche (trasformazioni, rasterizzazione, ombreggiatura, fusione, multitexture, nebbia, ecc.), quindi argomenti come il grafico della scena, la selezione degli oggetti, il rilevamento delle collisioni, l'animazione dei personaggi, il livello di dettaglio, i paesaggi;
10. Daniel Sánchez-Crespo Dalmau Tecniche e algoritmi di base nella programmazione di giochi - discute in dettaglio gli algoritmi e le strutture di dati utilizzati nelle attività di sviluppo del gioco, come AI, scripting, rendering in spazi chiusi e aperti, algoritmi di ritaglio, tecniche procedurali, modi di implementazione delle ombre, implementazione della telecamera, ecc.;
11. Lamotte André Programmazione di giochi di ruolo con directX 9 - mille pagine manuale dettagliato sullo sviluppo dei giochi di ruolo. Include sia capitoli teorici sulla programmazione con Direct3D, DirectInput, DirectSound, DirectPlay, sia capitoli applicati direttamente correlati al motore di gioco.

Tag: Aggiungi tag

Buon pomeriggio cari amici. Con questo articolo, inizio una serie di lezioni dedicate a uno dei linguaggi di programmazione più popolari - C++. Le lezioni sono rivolte principalmente agli utenti che non hanno dimestichezza con la programmazione, quindi professionisti, non sono severi, anche se sostengo le critiche, soprattutto nel mio indirizzo. Nelle mie lezioni utilizzerò l'ambiente di sviluppo Code :: Blocks, che può essere scaricato e utilizzato gratuitamente. Cominciamo, ovviamente, con il classico Hello, world =)

Spero che tu abbia già scaricato e installato Code :: Blocks, in tal caso, iniziamo. Avvio dell'ambiente di sviluppo

Prima di tutto, crea un nuovo progetto vuoto File-> Nuovo-> Progetto e seleziona Progetto vuoto

fai clic su Vai, quindi su Avanti

e nella finestra che compare, nel campo Titolo progetto, digita il titolo del progetto, in Nome file progetto il nome del progetto e ancora Avanti.

Nella finestra successiva, elimina la directory Oggetti dalle sezioni Crea configurazione "Debug" e Crea configurazione "Rilascia", come mostrato nella schermata sopra e fai clic sul pulsante Fine. Sulla destra dovrebbe apparire un progetto con il nome "Hello world".

Il passaggio successivo, aggiungi il file File->Nuovo->File... al progetto e seleziona c/c++ source nella finestra che appare.

Vai di nuovo, Avanti, seleziona C ++, Avanti e vedi la seguente finestra

,

qui dobbiamo specificare il nome del file (l'ho chiamato main) e il suo percorso, preferibilmente la cartella con il progetto. Seleziona le caselle Debug e Rilascio e fai clic su Fine.

E abbiamo ottenuto un file C ++ vuoto in cui scriveremo il codice del programma stesso.

Ora iniziamo a scrivere il codice del programma stesso. Per visualizzare le informazioni sullo schermo, abbiamo bisogno della libreria iostream I/O.

#includere

usando lo spazio dei nomi std;

Allora scriviamo funzione principale che verrà eseguito all'avvio del programma

intero principale ()

deve chiamarsi "main" e specificarvi il tipo int (ne parleremo nelle prossime lezioni). Tra parentesi graffe e il codice del programma verrà trovato. Scriveremo un semplice programma che stampi il saluto "Ciao, mondo!" Alla console.

cout<<"Ciao mondo!" ;

Dopo ogni comando è necessario inserire un ";", questo dice al compilatore che il comando è terminato e il successivo può essere elaborato. cout - Stampa i valori delle variabili o delle stringhe sulla riga di comando.

Elenco completo del programma.

#includere

usando lo spazio dei nomi std;

int main ()

cout<< "Hello, world!" ;

Restituzione 0 ;

Lanciamo il progetto e vediamo il risultato.

Di seguito allego un video tutorial a questo articolo.

Se hai domande, scrivi i tuoi commenti a Questo indirizzo email è protetto dagli spambots. Abilita Javascript per vederlo. ,">Questo indirizzo email è protetto dagli spambots. Abilita Javascript per vederlo., finalizzerò le lezioni o semplicemente aiuterò nello studio dei materiali.

• < Назад

Sviluppo di applicazioni per dispositivi incorporati

Parte 2. Utilizzo del codice :: Blocchi per lo sviluppo di applicazioni AVR

Serie di contenuti:

Nell'articolo precedente, abbiamo descritto come utilizzare l'IDE Eclipse per creare applicazioni per il microprocessore della serie Atmel AVR utilizzando il kit di compilazione GNU AVR GCC. Ha coperto la configurazione di Eclipse utilizzando il plug-in AVR, nonché la configurazione manuale dell'ambiente. Ora mostreremo come lo stesso problema può essere risolto utilizzando un altro ambiente di sviluppo più leggero e molto conveniente Code :: Blocks.

Conoscere l'ambiente

Creazione del progetto

Se non sono stati ancora creati progetti nell'area di lavoro, dopo aver avviato Code :: Blocks nel pannello centrale, è attiva solo la scheda "Inizia qui". Per creare un nuovo progetto selezionare il comando "Crea nuovo progetto" oppure la voce di menu "File-> Nuovo-> Progetto". In ogni caso, si aprirà una finestra per la scelta di un modello per un progetto futuro, in cui specifichiamo il modello "Progetto AVR" e premiamo il pulsante "Vai".

Apparirà la finestra di benvenuto della procedura guidata del progetto AVR. Fare clic sul pulsante Avanti e nella finestra di dialogo che si apre, inserire il nome del progetto e la directory in cui si troverà. Sulla base di questi dati, il programma proporrà automaticamente all'utente il nome del file di progetto con estensione * .cbp e la directory del progetto che verrà creato. Quindi dovresti premere il pulsante "Avanti".

La finestra successiva richiede di selezionare le configurazioni di build che verranno utilizzate nel progetto. Per impostazione predefinita, sono attive entrambe le configurazioni: Debug e Release. Il compilatore "GNU AVR GCC Compiler" è specificato in anticipo. Anche qui puoi cambiare le directory predefinite per i file di configurazione compilati.

Nella finestra successiva, indichiamo il tipo di processore di destinazione selezionandolo dall'elenco a discesa (in seguito ciò può essere fatto nei parametri di compilazione). Se il progetto utilizza una memoria esterna, è necessario specificarne i parametri. Successivamente, dovresti impostare il valore della variabile di progetto globale F_CPU, specificando la frequenza di clock del processore in hertz. Per impostazione predefinita, è abilitata la creazione di un file di mappa dei simboli (.map) e file esadecimali, nonché un file di elenco del disassemblatore (.lss). È anche utile abilitare il parametro "Run avr-size after build" - quindi alla fine del registro di build del progetto appariranno le informazioni su quanto spazio sarà occupato nella memoria del programma e in memoria ad accesso casuale... Per qualche motivo, l'abilitazione dell'opzione di creazione dell'elenco non ha alcun effetto sulla creazione del progetto ed è necessario aggiungere manualmente il comando appropriato ai passaggi pre/post build. Fare clic sul pulsante Fine (Figura 2).

Il progetto viene creato e il primo file viene automaticamente aggiunto ad esso - main.c.

Impostazione del progetto e dell'ambiente di sviluppo

Se il progetto è stato creato utilizzando il modello di progetto AVR, puoi iniziare a programmare quasi immediatamente. Tuttavia, esamineremo i parametri principali per assicurarci che tutto sia configurato correttamente.

1. Seleziona la voce di menu "Progetto-> Opzioni di costruzione". Si aprirà la finestra delle impostazioni dei parametri di compilazione (Figura 3). Il riquadro di sinistra contiene l'albero di destinazione della build. Al suo livello più alto, ci sono le impostazioni di compilazione per l'intero progetto. È più conveniente specificare prima i parametri per l'intero progetto e solo dopo aggiungere qualcosa nelle singole opzioni di compilazione.
   
   

   Prima di tutto, devi assicurarti che "GNU AVR GCC Compiler" sia selezionato nel campo "Selected Compiler". Sotto, nella scheda "Flag del compilatore", ci sono i flag del compilatore. Per impostazione predefinita, l'utile flag "Abilita tutti gli avvisi del compilatore" è già abilitato qui. Vale anche la pena assicurarsi di aver scelto il tipo di processore corretto per il quale si sta sviluppando il progetto.

   La scheda #defines mostra il valore della variabile F_CPU, se è stata impostata al momento della creazione del progetto.

   Nella scheda "Opzioni linker" nel pannello "Altre opzioni linker", puoi vedere che il linker è impostato sul parametro -mmcu corretto e nel pannello "Collega librerie" a sinistra, devi specificare le librerie richieste per il progetto, se presente.

   Vai alla scheda "Cerca directory". Di seguito, nella scheda Compilatore, è necessario inserire il percorso dei file di intestazione, ad esempio /usr/avr/include/. Per fare ciò, usa il pulsante "Aggiungi" e inserisci il percorso corretto. Allo stesso modo, nella scheda "Linker", specificare il percorso delle librerie AVR GCC, ad esempio / usr / avr / lib.

   Scheda Passaggi pre/post build. Nel campo "Passi post-compilazione" puoi vedere i comandi per eseguire le utilità avr-size, avr-objcopy, avr-objdump. Ad esempio, per ottenere un elenco (poiché abilitare il parametro "Crea file di elenco esteso" nella procedura guidata Nuovo progetto non produce l'effetto desiderato, almeno nella versione 8.02) aggiungiamo il seguente comando:

   avr-objdump -h -S $ (TARGET_OUTPUT_FILE)> $ (TARGET_OUTPUT_FILE) .lss

   Se ora passi dai parametri dell'intero progetto a destinazioni di compilazione più specifiche, ad esempio Debug o Release, puoi apportare alcune modifiche ai parametri di compilazione. Si noti, tuttavia, che il parametro "Policy" è diventato disponibile. Il suo valore predefinito è "Aggiungi opzioni di destinazione alle opzioni del progetto", ad es. i parametri generali del progetto vengono aggiunti ai parametri per il target di build specifico. Ci sono altre opzioni per combinare impostazioni di diversi livelli. Ciò consente di personalizzare in modo flessibile il progetto senza ripetere i parametri generali già inseriti.

   Le impostazioni predefinite sono di abilitare automaticamente la creazione di informazioni di debug nella destinazione di debug (parametro "-g") e ottimizzare la dimensione del programma risultante nella destinazione di rilascio (parametro "-Os").

2. Selezionare la voce di menu "Progetto-> Proprietà". Qui, le impostazioni standard sono abbastanza adatte per iniziare a lavorare con un progetto senza modificare nulla in esse. Vale la pena prestare attenzione alla scheda "Crea obiettivi". Per ogni destinazione della build (impostazione predefinita: debug e rilascio), viene indicato dove vengono scritti i file oggetto risultanti e nel campo "File di destinazione della compilazione" è possibile specificare quali file di origine sono coinvolti in questa build (Figura 4).
   
   

   Se lo desideri, puoi salvare il tuo progetto personalizzato come modello per progetti futuri. A tale scopo selezionare il comando di menu "File-> Salva progetto come modello utente ..." e inserire il nome del modello. Successivamente, durante la creazione di un nuovo progetto, è possibile selezionare il modello desiderato nella categoria "Modelli utente" (Figura 5). Successivamente, è necessario impostare una directory vuota in cui verrà creato il nuovo progetto, quindi modificare il nome del progetto.

   
   

   Puoi persino modificare un modello standard esistente. Per fare ciò, nella finestra di selezione del modello, fare clic con il pulsante destro del mouse sul modello richiesto e utilizzare l'opzione "Modifica questo script" nel menu che appare.

3. Prima di creare qualsiasi cosa, devi comunque esaminare le impostazioni globali del compilatore. Questo viene fatto attraverso il menu principale: "Impostazioni-> Compilatore e impostazioni del debugger". Nella finestra del riquadro sinistro che si apre, fare clic sull'icona "Impostazioni globali del compilatore". Nella parte superiore del riquadro di destra, nel campo "Compilatore selezionato" in alto, selezionare "Compilatore GNU AVR GCC" (Figura 6).
   
   

   Non vale la pena modificare nulla nella scheda "Impostazioni del compilatore": questi parametri diventeranno standard per tutti i progetti AVR. Ma nelle schede "Cerca directory-> Compilatore" e "Cerca directory-> Linker" nel mio caso c'erano già percorsi standard / usr / include e / usr / lib, rispettivamente, che erano sbagliati. Puoi specificare i percorsi corretti qui (ad esempio, /usr/avr/include e /usr/avr/lib), ed eliminare gli stessi percorsi nelle impostazioni del progetto, ho appena cancellato questi campi con i pulsanti "Cancella", perché il i parametri di progetto in questo momento sono già stati configurati.

   Nella scheda "Eseguibili Toolchain", controlliamo se i nomi dei file eseguibili dal pacchetto AVR GCC e i relativi percorsi sono specificati correttamente. Utilizzando il pulsante "rileva automaticamente", puoi provare a rilevare automaticamente tutti questi valori. Se qualcosa è andato storto (ad esempio, la distribuzione AVR GCC è finita con nomi e directory esotici per il posizionamento), allora questo è solo il posto dove puoi aggiustare tutto manualmente. Nella Figura 7, il campo "Directory di installazione del compilatore" deve essere "/usr" se i programmi AVR GCC si trovano nella directory /usr/avr/.

   
   

   E l'ultima cosa. Nella scheda "Altre impostazioni" è presente un campo "Registrazione del compilatore". Qui puoi impostare la modalità di registrazione del processo di compilazione. Si consiglia di impostare qui il valore "Riga di comando completa". Ciò consentirà di tracciare nel dettaglio i comandi utilizzati durante l'assemblaggio.

Ora Code :: Blocks è pronto per costruire il tuo progetto!

Usando il tuo makefile per il tuo progetto

Può sempre verificarsi una situazione non standard in cui è necessario assumere il pieno controllo del processo di creazione del progetto. Per fare ciò, Code :: Blocks offre la possibilità di lavorare con il proprio file di assieme. Per usarlo, devi creare un progetto vuoto e salvarlo. Ora devi indicare che stai usando il tuo makefile:

1. Selezionare la voce di menu "Progetto -> Proprietà".
2. Vai alla scheda "Impostazioni progetto".
3. Seleziona la casella "Questo è un makefile personalizzato".
4. Assicurati che il nome file corretto sia specificato nel campo "Makefile:".
5. Ora, nella scheda "Build target", è necessario modificare o aggiungere i target di build in base al makefile esistente, ad esempio: all cleanall

Quando usi il tuo makefile, dovresti controllare quali comandi sono disponibili nella scheda "Crea comandi" nella voce di menu "Progetto -> Opzioni di creazione".

Programma di prova

Il progetto, creato utilizzando il modello AVR, contiene già il file main.c, che contiene la preparazione del modulo principale per il programma C. Scriviamo un nuovo programma C++.

Utilizzare l'opzione di menu "File-> Nuovo-> File ...", selezionare "C++ source" e fare clic sul pulsante "Vai". Apparirà una finestra di benvenuto della Nuova procedura guidata. file sorgente... Fare clic sul pulsante "Avanti" e nella finestra successiva selezionare il linguaggio di programmazione per questo file: C++. Quindi, specifica il nome del file (ad esempio, sample.cpp) e il percorso completo di questo file, per il quale fai clic sul pulsante "..." a destra del campo del nome del file. Quindi è necessario indicare per quali scopi dell'assieme sarà presente questo file, per il quale è sufficiente fare clic sul pulsante "Tutto". Fare clic sul pulsante Fine.

Nel file vuoto creato, inserisci il programma C ++ più semplice:

int main (void) (const int some_size = 1000; while (true) (for (int i = 0; i< some_size; i++) int a = 3; // какое-нибудь действие } return 0; // никогда не дойдет сюда }

Salva il file premendo Ctrl + S. Non abbiamo bisogno del file main.c, può essere rimosso dal progetto facendo clic destro sul suo nome e selezionando il comando “Rimuovi file dal progetto” dal menu che appare (Figura 8).

Quando inserivo commenti in russo, di tanto in tanto mi imbattevo in un fastidioso errore nel lavoro dell'editore: a volte si rifiuta di inserire l'alfabeto cirillico. Apparentemente, ciò è dovuto al lavoro in Unicode. Puoi risolvere temporaneamente il problema inserendo uno spazio extra, dopodiché il testo viene scritto normalmente. Questo spazio può quindi essere rimosso.

Compiliamo il programma. Per fare ciò, seleziona il comando di menu "Costruisci-> Crea" o premi la familiare combinazione di tasti Ctrl + F9, puoi anche utilizzare il pulsante a forma di ingranaggio blu nella barra degli strumenti. Il programma verrà compilato, e la finestra di messaggio nella parte inferiore dello schermo passerà automaticamente alla scheda "Crea messaggi", dove si dirà che la compilazione è completa, ha ottenuto 0 errori e un avviso: sulla riga 8 c'è una variabile "a" non utilizzata.

Un po' di debug

L'approccio al debug delle applicazioni AVR dipende fortemente dall'hardware utilizzato. Se si dispone di un dispositivo AVR JTAG ICE, è possibile eseguire il debug in-circuit collegandolo al processore utilizzando l'utility avarice. Se non esiste tale dispositivo, utilizzare il simulatore del processore simulavr. Sfortunatamente, questo progetto non è stato sviluppato per diversi anni, ma gli sviluppatori continuano a rilasciare correzioni.

Per impostare il debug in Code :: Blocks, è necessario aprire le proprietà del progetto "Progetto-> Proprietà" e andare alla scheda "Debugger". Qui, nel campo "Seleziona destinazione", seleziona "Debug". Per questa configurazione, nella scheda "Connessione remota", sono specificati i parametri per connettere avr-gdb alla destinazione di debug remoto:

• "Tipo di connessione": TCP.
• "Indirizzo IP": localhost se allo stesso computer è connesso un dispositivo di debug (o simulatore).
• "Porta": ad esempio, 1212.

Ora nella scheda "Comandi aggiuntivi" nel campo "Dopo la connessione" è necessario inserire i seguenti comandi per il debugger:

rottura del carico principale

Il primo comando caricherà il programma nel target di debug (microprocessore o simulatore), e il secondo inserirà un breakpoint sulla funzione principale.

Prima di eseguire il debug, è necessario eseguire simulavr nel terminale:

simulavr -g -p 1212 -d atmega128

(per il processore atmega128), ottieni qualcosa del genere:

$ simulavr -g -p 1212 -d atmega128 Simulazione di un dispositivo atmega128. ... main.c: 415: MESSAGE: Simulazione della frequenza di clock di 8.000.000 Hz In attesa sulla porta 1212 per la connessione del client gdb ...

Se il dispositivo è connesso alla porta seriale /dev/ttyS0, puoi avviare avarice con il seguente comando:

avarizia -j / dev / ttyS0 -P atmega128: 1212

Ora puoi avviare il debug in Code :: Blocks utilizzando il comando di menu "Debug-> Start". Nella finestra in cui è in esecuzione simulavr, verranno aggiunti messaggi come i seguenti:

Connessione aperta dall'host 127.0.0.1, porta -14999. decoder.c: 737: MESSAGGIO: BREAK POINT: PC = 0x00000068: orologio = 34

Questo caricherà il testo sorgente contenente la funzione principale nell'editor Codice :: Blocchi e il cursore del debugger si fermerà su questa funzione, come mostrato nella Figura 9. Ora puoi usare i comodi pulsanti per controllare il debugger nella barra degli strumenti, visualizza i valori delle variabili, e così via. ... Per ulteriori informazioni sul debug, vedere la documentazione per gdb, simulavr o avarice.

Conclusione

Quindi, abbiamo detto come, dopo aver speso un minimo di sforzo e tempo, senza fare riferimento a documentazione e manuali, iniziare rapidamente a sviluppare applicazioni AVR utilizzando il meraviglioso e in rapido sviluppo dell'ambiente di sviluppo Code :: Blocks. Attualmente l'interfaccia dell'ambiente è stata tradotta in molte lingue e, possibilmente, i file localizzati entreranno presto a far parte del ramo di sviluppo principale.

Nel prossimo articolo, faremo conoscenza con l'utilizzo di Eclipse per creare applicazioni per un'ampia gamma di microprocessori con una piccola quantità di RAM, per i quali è progettato il compilatore SDCC open source.