Pe paginile „Computer News” v-am povestit în repetate rânduri, dragi cititori, despre diferite medii de dezvoltare – convenabile, frumoase, multiplatforme. Pentru că, orice s-ar spune, mediul de dezvoltare este un lucru destul de important atât pentru programator însuși, cât și pentru angajatorul său. De ce este important pentru un programator, cred că nu este nevoie să explici: el scrie cod în el și cu cât este mai convenabil să-l scrie, cu atât va fi mai ușor să lucrezi. Cu toate acestea, managerii competenți înțeleg că așa-numita comoditate a mediului de dezvoltare este, în primul rând, productivitatea lucrătorului care scrie și depanează programe. Prin urmare, orice manager competent știe fără mine că nu merită să economisiți pe un mediu de dezvoltare integrat (IDE). Cu toate acestea, dorința de a salva încă apare uneori. Adevărat, acest lucru se face și cu înțelepciune: se cumpără cea mai ieftină versiune a mediului de dezvoltare și se instalează una mai scumpă și, în consecință, mai funcțională.

Cu toate acestea, nu este necesar să economisiți într-un mod care, în general, nu poate fi numit complet legal. Puteți folosi programe gratuite în locul unei astfel de fraude cu software comercial. Oprește-te, nu scuipa! Înțeleg tot ce nu pare a fi un favorit Microsoft Visual Studio și/sau Delphi, la început îi enervează pe mulți chiar și la simpla mențiune. Și există o explicație logică pentru aceasta: majoritatea software-ului gratuit pentru programatori (în special mediile de dezvoltare) chiar și la prima pornire provoacă unul dintre cele două sentimente nu cele mai bune umane: fie dezgust, fie plictiseală. Uneori - milă profundă și sinceră. Cu toate acestea, rețineți că cea mai mare parte nu este totul software! De regulă, cele mai faimoase dintre produsele freeware și open-source merită cu adevărat atenția atât a dezvoltatorilor, cât și a managementului acestora. Este suficient să amintim proiecte precum Eclipse sau Dev-C++. Da, și multe altele. De fapt, nu în zadar tot mai mulți participanți noi se alătură mișcării open-source. Din ce în ce mai multe produse care au fost cândva comerciale câștigă amploare ca proiecte gratuite. Deși acele produse care au început ca open-source devin, de asemenea, destul de competitive în raport cu omologii comerciali după un timp. Deși, este de remarcat faptul că termenul open-source nu este întotdeauna sinonim cu termenul „software liber”. Deși, de regulă, programele open-source sunt distribuite sub licențe care le permit să fie utilizate fără nicio deducere pentru dezvoltatori.

Mediul de dezvoltare cu care vreau acum să vă prezint este doar unul dintre acele produse minunate care trezesc interes, și pe alocuri chiar admirație. Acest program se numește, după cum puteți vedea din titlul articolului, Code::Blocks, iar pe internet poate fi găsit la www.codeblocks.org . Este destinat dezvoltării de programe folosind C/C++. Dimensiunea de descărcare depinde dacă descărcați mediul cu sau fără compilator. Depinde și dacă veți descărca codul sursă IDE (și sunt disponibile, deoarece Code::Blocks este distribuit sub Licența Publică Generală GNU) sau fișiere deja compilate. În general, dimensiunea de descărcare variază de la trei la treisprezece megaocteți, ceea ce de fapt nu este atât de mult pentru un mediu de dezvoltare bun.

Deci mediul este stabilit. La prima lansare, ochiul este atras de ecranul de bun venit frumos conceput, care nu se găsește de obicei în produsele software libere. Deja după ea se poate judeca gravitatea abordării Codului::Blochează autorii în dezvoltarea descendenților lor.

Ce este pregătit să ofere mediul de dezvoltare programatorului care îl folosește? Nu atât de puțin, mai ales în comparație cu alte IDE-uri gratuite. În primul rând, multiplatformă. Cu toate acestea, este limitat la două platforme: Windows și Linux. Nu foarte multe, însă, acestea sunt principalele sisteme de operare de pe piață. Cu toate acestea, suportul pentru altele (de exemplu, Mac OS X) nu ar strica. Personal, am descărcat versiunea pentru Windows, însă, judecând după capturile de ecran de pe site-ul dezvoltatorilor, acest program arată la fel de bine sub Linux.

În al doilea rând, oricine se poate conecta la mediul compilator care îi place cel mai mult. Sau cel care este mai familiar de folosit. Și mediul de dezvoltare acceptă următoarele compilatoare: GCC (MinGW pentru Windows), Microsoft Visual C ++ Compiler, Digital Mars, Borland C ++ (versiunea 5.5), Open Watcom și Sun DCC. Dacă ați descărcat mediul împreună cu compilatorul, atunci acesta va fi, desigur, GCC. Mediul însuși transmite compilatorului toate cheile necesare pentru funcționarea sa cu opțiunile date. Mai mult, compilarea poate fi realizată atât direct, cât și prin intermediul fișierelor de tip make-file, pe care Code::Blocks le poate forma, de asemenea, complet independent.

În al treilea rând, Code::Blocks are un editor de cod convenabil și bogat în funcții, care acceptă evidențierea sintaxelor și plierea (plierea) blocurilor de cod. Mai mult, mediul poate funcționa nu numai cu texte în C/C++, ci și cu fișiere XML. În partea stângă a ferestrei programului este un ghid al claselor utilizate în textul său, precum și o listă a tuturor variabilelor, constantelor, claselor și spațiilor de nume utilizate. Există, de asemenea, un arbore de resurse și o listă de variabile vizualizate în timpul depanării. Ce e frumos este că toată lumea deschide fișierulîn mediu are propria filă. Aceasta este o abordare convenabilă și este grozav că începe să fie folosită în tot mai multe medii de dezvoltare.

În al patrulea rând, mediul Code::Blocks acceptă pluginuri, adică pluginuri. Aceasta este o caracteristică cu adevărat utilă și, cu ajutorul ei, dezvoltatorii au implementat mai multe lucruri care sunt convenabile pentru un programator care utilizează Code::Blocks. Și principalul dintre aceste lucruri este, desigur, indicii care apar pe ecran pe măsură ce tastați codul și care conțin liste de metode de clasă și parametri ai metodelor sau funcțiilor. Această caracteristică este implementată, în opinia mea, nu mai rău decât în ​​multe medii de dezvoltare comercială. Printre celelalte plugin-uri cu care se laudă site-ul proiectului Code::Blocks, mi se pare că merită să reamintiți vrăjitorul de formatare a codului, vrăjitorul de creare a noii clase, calculul statisticilor privind codul sursă al proiectului și vrăjitorul de încorporare a Manifestului XP. în resursele proiectului. Dacă tu, ca mine, ai descărcat cea mai mare versiune de Code::Blocks (cea cu compilator), atunci ai deja toate aceste plugin-uri. Desigur, fiecare își poate crea propriul plug-in pentru mediul de dezvoltare. Pentru a face acest lucru, va trebui să descărcați un SDK special (kit de dezvoltare software - kit de dezvoltare software) de pe site-ul proiectului.

Mediul folosește GNU Debugger ca depanator. Lucrul cu acesta nu este practic diferit de lucrul cu depanatoare. medii Microsoftși Borland. Tot în mediu există suport pentru o listă cu acele lucruri pe care dezvoltatorul trebuie să le facă în aplicație (to-do list). Poate fi configurat în așa fel încât dacă mediul este folosit de mai mulți dezvoltatori, pentru fiecare dintre aceștia va fi propriu și independent de listele altor dezvoltatori. De asemenea, este convenabil să lucrezi cu proiecte în mediu. Ele, ca și în Microsoft Visual Studio, sunt separate de setările spațiului de lucru (spațiul de lucru) și, ceea ce este frumos, atât proiectele, cât și mediul spațiului de lucru pot fi importate din formatul Visual Studio. Apropo, proiectele pot fi importate și din formatul Visual Studio. Formatul Dev-C ++ Adevărat, aceste caracteristici sunt descrise pur teoretic de către dezvoltatorii IDE înșiși și eu însumi nu pot spune nimic despre ele, deoarece eu însumi nu le-am încercat în acțiune.

Code::Blocks are o altă caracteristică importantă care îl diferențiază de multe alte medii de dezvoltare. Acest mediu are o integrare strânsă cu biblioteca wxWidgets, concepută pentru a crea o interfață grafică cu utilizatorul (am scris despre el odată în Computer News). Această bibliotecă are multe avantaje și, prin urmare, dezvoltatorii Code::Blocks au făcut o mare mișcare strategică, orientându-și produsul pentru a lucra cu această minunată bibliotecă. Adevărat, acest lucru este implementat, din nou, cu ajutorul unui plugin numit wxSmith, dar acestea nu sunt cele mai semnificative detalii. Plugin-ul vă permite să dezvoltați interfața aplicației într-un mod vizual, care nu poate decât să fie apreciat de dezvoltatori. Mai ales cei care au încercat să creeze o interfață într-un mod non-vizual. Modul de editare este similar cu cel al Microsoft Visual C++ sau Borland C++ Builder. Un designer similar, un editor de proprietăți obiect similar. Având în vedere natura multiplatformă a wxWidgets și Code::Blocks, aceasta este o caracteristică absolut minunată.

Ei bine, iată un mediu de dezvoltare atât de bun și util numit Code::Blocks. Poate că mulți vor spune că este departe de Visual Studio sau Borland Developer Studio și, desigur, vor avea dreptate. Nu are, ca și versiunile moderne ale acestor medii comerciale, capacitatea de a dezvolta aplicații în multe limbi și de a dezvolta pentru platforma .NET. Cu toate acestea, acest mediu este mult mai ușor și mai compact decât monștrii de la Microsoft și Borland. În plus, pentru crearea de aplicații cross-platform pentru Windows și Linux, Code::Blocks și wxWidgets par a fi una dintre cele mai bune combinații dintre toate opțiunile posibile. Prin urmare, nu ar trebui să renunțați imediat la software-ul gratuit. Este mai bine să încercați mai întâi și apoi să decideți dacă să vă întoarceți sau nu. Adevăruri comune? Pot fi. Dar cu cât afirmația este mai banală, cu atât este mai dificil pentru o singură persoană să ajungă la ea.

Vadim STANKEVICH

Integrated Development Environment (IDE) Code::Blocks (denumit în continuare CB) este un produs complet pentru dezvoltarea aplicațiilor C/C++. CB este un cadru multiplatform dezvoltat folosind biblioteca de instrumente wxWidgets. Există versiuni ale mediului atât pentru Windows, cât și pentru alte sisteme de operare (OS) - Linux și Mac OS. Acest IDE este complet gratuit, open source și construit în întregime folosind tehnologii deschise. Una dintre cele mai punctele forte CB este suport pentru crearea de aplicații wxWidgets - adică un astfel de software (software) care utilizează API-ul OS pentru a desena o interfață grafică cu utilizatorul (GUI). Cu alte cuvinte, CB vă permite să creați software multiplatform pentru fiecare gust.

CB știe să lucreze cu o cantitate mare compilatoare. Dacă în sistem sunt instalate mai multe dintre ele, puteți comuta cu ușurință între ele, în funcție de nevoie. În plus, în etapa de instalare, IDE-ul însuși va scana sistemul pentru compilatoare disponibile și va oferi să folosească unul ca principal. Puteți modifica ulterior aceste setări atât la nivel global, cât și pe bază de proiect cu proiect. Pentru setări globale mediu, există o întreagă secțiune „Setări” în meniul principal al CB. Pentru a face setări specifice specifice unui anumit proiect, trebuie să deschideți fereastra cu proprietățile proiectului. Pentru asta trebuie să suni meniul contextual proiect făcând clic dreapta pe el și selectând „Proprietăți”. Proiectele în sine (deschise în acest momentîn IDE) sunt afișate ca arbore în dock-ul „Management”, în fila „Proiecte” a acestuia. Acum, în fereastra de proprietăți care se deschide, puteți configura o mare varietate de parametri, de la editarea țintelor de construcție până la conectarea bibliotecilor terțe. Butonul „Opțiuni de construire ale proiectului” din fila „Setări proiect” din aceeași fereastră de proprietăți vă va permite să configurați foarte flexibil configurația de construire pentru un anumit proiect: cheile compilatorului, selectați compilatorul în sine, includeți biblioteci pentru linker etc. Toate acestea se pot face pentru moduri individuale: „Release” „Debug”.

Interfața grafică CB este construită în jurul panourilor de andocare plutitoare și extensibile care pot fi andocate în orice parte a ferestrei principale IDE, pur și simplu trăgându-le cu mouse-ul. Datorită acestui fapt, puteți configura în mod foarte flexibil diferite aspecte de interfață pentru diferite dimensiuni ecran, optimizând ergonomia GUI. Dacă există mai multe monitoare, este convenabil să separați unele panouri de fereastra principală și să le plasați pe monitoare adiacente.

Instrumentele de evidențiere, completare a codului și editare în CB fac ca procesul de lucru cu cod să fie ușor și confortabil. Un arsenal imens de setări vă permite să reglați mediul „pentru dumneavoastră”. Foarte util este suportul pentru lucrul cu variabile de mediu. Datorită acestei caracteristici, CB poate fi foarte strâns integrat în sistem, iar capacitățile sale pot fi extinse, de exemplu, în acest fel puteți conecta biblioteca wxWidgets.

Vreau să vă povestesc despre prima mea experiență în dezvoltarea jocurilor. Merită menționat imediat că articolul va fi pur tehnic, întrucât scopul meu a fost doar să dobândesc abilități în dezvoltarea aplicațiilor grafice folosind Direct3D, fără a implica instrumente de dezvoltare a jocurilor de nivel înalt precum Unity. În consecință, nu se va vorbi nici despre introducerea, monetizarea și promovarea jocului. Articolul se adresează începătorilor în programarea aplicațiilor Direct3D, precum și doar persoanelor care sunt interesate de mecanismele cheie ale muncii. aplicatii similare. Tot la final dau o listă de literatură despre dezvoltarea jocurilor, atent selectată de mine din peste o sută de cărți despre programarea jocurilor și grafica pe computer.

Introducere

Așa că, în timpul meu liber, am decis să studiez popularul API de grafică. După ce am citit mai multe cărți și am aranjat o grămadă de exemple și tutoriale (inclusiv cele din SDK-ul DirectX), mi-am dat seama că a venit momentul în care ar trebui să-mi încerc mâna pe cont propriu. Problema principală a fost că majoritatea exemplelor existente demonstrează pur și simplu unul sau altul Capacitate APIși sunt implementate procedural în aproape un fișier cpp și chiar folosind wrapper-ul DXUT și nu oferă o idee despre ce structură ar trebui să aibă aplicația finală, ce clase ar trebui proiectate și cum ar trebui să interacționeze toate între ele, astfel încât totul a fost frumos, lizibil și a funcționat eficient. Acest dezavantaj se aplică și cărților de pe Direct3D: de exemplu, pentru mulți începători nu este evident că stările de randare (stările de randare) nu trebuie întotdeauna actualizate la fiecare cadru și, de asemenea, că majoritatea operațiunilor grele (cum ar fi umplerea bufferului de vârfuri). ) trebuie efectuată o singură dată când aplicația este inițializată (sau la încărcarea unui nivel de joc).

Idee

În primul rând, a trebuit să mă decid asupra însăși ideea jocului. Mi-a venit imediat în minte un joc vechi din 1992 sub MS-DOS, care cred că este familiar pentru mulți. Acesta este jocul de logică Lines de Gamos.

Ei bine, provocare acceptată. Iată ce avem:

• există un câmp pătrat de celule;
• sunt bile multicolore in celulele de pe teren;
• după mutarea mingii apar bile noi;
• scopul jucătorului este de a alinia bile de o culoare într-o linie: acumularea unui anumit număr de bile de o culoare într-o linie duce la detonarea lor și la notarea de puncte;
• sarcina principală este să reziste cât mai mult până când celulele libere se epuizează pe teren.

Acum să privim din punctul de vedere al aplicației Direct3D:

• vom face un câmp de celule sub forma unei platforme tridimensionale cu margini, fiecare celulă va fi ceva ca un podium;
• Ar trebui implementate trei tipuri de animație cu minge:
  1. aspectul mingii: mai întâi apare o minge mică, care în scurt timp crește până la dimensiunea adultă;
  2. mutarea mingii: există pur și simplu o mișcare secvențială prin celule;
  3. minge care sări: atunci când selectezi o minge cu mouse-ul, aceasta ar trebui să se activeze și să înceapă să sară pe loc;
• trebuie implementat un sistem de particule care va fi folosit la animarea exploziei;
• ieșirea textului ar trebui să fie implementată: pentru a afișa punctele câștigate pe ecran;
• managementul trebuie implementat camera virtuala: Rotiți și măriți.

De fapt, punctele enumerate mai sus sunt o aparență jalnică a unui document numit proiect de design. Recomand cu tărie ca înainte de a începe dezvoltarea, să scrieți totul până la cele mai mici detalii din el, să-l tipăriți și să-l țineți în fața ochilor! Privind în perspectivă, arăt imediat un videoclip demonstrativ pentru a ilustra implementarea punctelor (apropo, videoclipul a fost înregistrat folosind programul ezvid, așa că nu vă fie teamă de ecranul lor de deschidere la început):

Începutul dezvoltării

Până acum, nu am menționat ce instrumente au fost folosite. În primul rând, aveți nevoie de software-ul DirectX Kit de dezvoltare(SDK), întotdeauna disponibil pentru descărcare gratuită de pe site-ul Microsoft: DirectX SDK. Dacă intenționați să utilizați versiunea Direct3D 9, ca și mine, atunci după instalare, trebuie să deschideți Panoul de control DirectX prin meniul principal și pe fila Direct3D 9 selectați ce versiune a bibliotecilor va fi utilizată la construirea - retail sau depanare (acest lucru afectează dacă Direct3D va raporta depanatorului despre rezultatele activității sale):

Depanare sau vânzare cu amănuntul

De ce versiunea Direct3D a 9-a? Pentru că aceasta este ultima versiune în care există încă o conductă cu funcție fixă, adică o conductă grafică fixă ​​care include, de exemplu, funcțiile de calcul al luminii, procesarea vârfurilor, amestecarea și așa mai departe. Începând cu versiunea 10, dezvoltatorii sunt încurajați să implementeze ei înșiși aceste funcții în shaders, adică avantaj incontestabil, dar, după părerea mea, este greu de perceput la primele experimente cu Direct3D.

De ce Code::blocks? Probabil că a fost stupid să folosești un IDE multiplatform pentru a dezvolta o aplicație care folosește un API non-cross-platform. Doar că Code::blocks ocupă de câteva ori mai puțin spațiu decât Visual Studio, care s-a dovedit a fi foarte relevant pentru computerul din țara mea.

Începerea dezvoltării cu Direct3D s-a dovedit a fi foarte ușoară. În Code::blocks am creat un proiect gol (proiect gol), apoi în opțiunile de construire a trebuit să fac două lucruri:

1) În fila directoare de căutare și subfila compilatorului, adăugați calea către directorul include DirectX SDK - de exemplu, astfel:

Căutați în directoare

2) În fila linker, adăugați două biblioteci - d3d9.lib și d3dx9.lib:

Linker

După aceea în cod sursa aplicațiile vor trebui să includă fișierele antet Direct3D:

#include „d3d9.h” #include „d3dx9.h”

Structura aplicației

Aici am făcut prima mea greșeală: am început să mă gândesc ce model de design să aleg. Am ajuns la concluzia că MVC (model-view-controller) este cel mai potrivit: modelul va fi clasa de joc (jocul), care include toată logica - calculul căilor de mișcare, apariția bilelor, analiza explozivilor. combinatii; vizualizarea va fi clasa de motor responsabilă pentru randarea și interacțiunea cu Direct3D; controlerul va fi ambalajul propriu-zis (aplicația) - aceasta include bucla de mesaje, procesarea intrărilor utilizatorului și, cel mai important, managerul de stat și asigurarea interacțiunii obiectelor de joc și motor. Totul pare să fie simplu și puteți începe să scrieți fișiere de antet, dar nu a fost cazul! În această etapă, s-a dovedit a fi foarte dificil de navigat și de înțeles ce metode ar trebui să aibă aceste clase. Este clar că lipsa totală de experiență a afectat, iar eu am decis să apelez la sfatul uneia dintre cărți: „Nu încerca să scrii cod perfect de la bun început, să fie suboptimal și haotic. Înțelegerea vine cu timpul, iar refactorizarea poate fi făcută mai târziu.” Ca urmare, după mai multe iterații de refactorizare layout deja funcțional definiția celor trei clase principale a luat forma:

Clasa TGame

clasa TGame ( privat: BOOL gameOver; TCell *celule; WORD *cale; WORD caleLen; scor LONG; void ClearField(); WORD GetSelected(); WORD GetNeighbors(WORD cellId, WORD *pNeighbours); BOOL CheckPipeDetonate(WORD *pPipeCells) ; public: TGame(); ~TGame(); void New(); BOOL CreateBalls(număr WORD); 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(); );

Clasa de motoare

Clasa Tengine (Private: Hwnd Hwindow, rect winrect; d3dxvector3 camerapos; lpdirect3ddevice9 pdevice; lpdirect3dtevice9 pdevice; lpdrect3dxametre9 pdevice; DPPRESENT_PARAMETERS setări; Clock_t curenttime; tgeometrie * Cellgeometry; TPTAATLICSYSTEM * Atușdystem; TAnimate *appearAnimation; scor LONG; void InitD3d(); void InitGeometry(); void InitAnimation(); void DrawPlatform(); void DrawBalls(); void UpdateView(); public: TEngine(HWND hWindow) ; ~TEngine(); void AppearBalls(TBallInfo *ballInfo, WORD count); void MoveBall(WORD *cale, WORD caleLen); 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(INT offset); void OnRotateX(INT offset); void OnZoom(INT zoom); void OnResize(); void OnUpdateScore (LUNG Scor); void Render(); );

TAClasa de aplicare

clasa TAApplication ( privat: HINSTANCE hInstance; HWND hWindow; POINT mouseCoords; TEngine* engine; TGame* game; BOOL moveStarted; BOOL detonateStarted; BOOL appearStarted; void RegWindow(); static LRESULT CALLBACK MsgProc(HWND hwnd,WPARAM,WND wwnd LPARAM lParam); void ProcessGame(); public: TApplication(HINSTANCE hInstance, INT cmdShow); ~TApplication(); TEngine* GetEngine(); TGame* GetGame(); INT MainLoop(); );

Clasa TGame are doar 3 metode pe care utilizatorul însuși le poate iniția - New (joc nou), Select (selectarea mingii) și TryMove (încercarea de a muta mingea). Restul sunt auxiliare și sunt apelate de controlor în cazuri speciale. De exemplu, DetonateTest (test pentru combinații explozive) este numit după apariția de noi bile sau după o încercare de deplasare. GetNewBallList, GetLastMovePath, GetDetonateList sunt numite, respectiv, după apariția bilelor, după mișcare și după explozie, cu un singur scop: să obțineți o listă de bile specifice și să o transmiteți obiectului motor pentru procesare astfel încât să deseneze ceva. . Nu vreau să mă opresc asupra logicii funcționării TGame, deoarece există coduri sursă cu comentarii. Voi spune doar că determinarea traseului de mișcare a mingii este implementată folosind algoritmul lui Dijkstra pe un grafic nedirecționat cu greutăți egale ale tuturor muchiilor.

Să aruncăm o privire mai atentă la clasele de motor și controler.

TEmotor

• Clasa definește câmpuri pentru stocarea mânerului ferestrei și dreptunghiului acesteia. Ele sunt folosite în metoda OnResize, pe care controlerul o apelează atunci când fereastra este redimensionată, pentru a calcula o nouă matrice de proiecție.
• Câmpul CameraPos stochează coordonatele observatorului în spațiul mondial. Nu trebuie să stocați vectorul de direcție a privirii, pentru că, după ideea mea, camera este întotdeauna îndreptată spre origine, care, de altfel, coincide cu centrul platformei.
• Există, de asemenea, indicatori către interfețele Direct3D: LPDIRECT3D9, care este necesar doar pentru a crea dispozitivul; LPDIRECT3DDEVICE9 - de fapt, dispozitivul Direct3D în sine, interfața principală cu care trebuie să lucrați; LPD3DXFONT și LPDIRECT3DTEXTURE9 pentru lucrul cu text și textura.
• Câmpul currentTime este folosit pentru a stoca ora curentă în milisecunde și este necesar pentru a reda animații netede. Faptul este că randarea fiecărui cadru durează un număr diferit de milisecunde, așa că trebuie să măsurați aceste milisecunde de fiecare dată și să le folosiți ca parametru atunci când interpolați animația. Această metodă este cunoscută ca sincronizare de timpși este folosit omniprezent în aplicațiile grafice moderne.
• Pointerii către obiecte din clasa TGeometry (cellGeometry și ballGeometry) stochează geometria unei celule și a unei bile. Obiectul TGeometry în sine, după cum sugerează și numele, este proiectat să funcționeze cu geometrie și conține tampon de vârf și index, precum și o descriere a materialului (D3DMATERIAL9). La randare, putem schimba matricea lumii și putem apela metoda Render a obiectului TGeometry, ceea ce va avea ca rezultat randarea mai multor celule sau bile.
• TParticleSystem este o clasă de sistem de particule care are metode pentru inițializarea mai multor particule, actualizarea pozițiilor acestora în spațiu și, bineînțeles, randarea.
• TBall *bile - o serie de bile cu informații despre culoare și stare [săritură, mișcare, apariție].
• Trei obiecte de tip TAnimate - pentru a oferi animație. Clasa are o metodă de inițializare a cadrelor cheie, care sunt matrici de transformare a lumii, și metode pentru calcularea poziției curente a animației și aplicarea transformării. În procedura de randare, motorul redă bilele în secvență și, dacă este necesar, apelează metoda ApplyTransform a animației dorite pentru a deforma sau a muta mingea.
• InitD3d, InitGeometry, InitAnimation sunt apelate numai din constructorul TEngine și sunt separate în metode separate pentru claritate. În InitD3d, este creat un dispozitiv Direct3D și toate stările de randare necesare sunt setate, inclusiv setarea unei surse de lumină punctuală cu o componentă speculară chiar deasupra centrului platformei.
• Cele trei metode AppearBalls, MoveBall și DetonateBalls declanșează animațiile de spawn, mutare și, respectiv, explozie.
• Metodele IsSelected, IsMoving, IsAppearing, IsDetonating sunt utilizate în funcția de gestionare a stării pentru a urmări când se termină animația.
• Metodele cu prefixul On sunt apelate de controler atunci când apar evenimentele corespunzătoare: clic de mouse, rotirea camerei etc.

Luați în considerare metoda principală de randare:

TEengine::Render()

void TEngine::Render() ( //calculează câte milisecunde au trecut de când a fost redat cadrul precedent clock_t elapsed=clock(), deltaTime=elapsed-currentTime; currentTime=elapsed; //actualizează pozițiile animației dacă sunt active if( jumpAnimation->IsActive()) ( jumpAnimation->UpdatePosition(deltaTime); ) if(appearAnimation->IsActive()) (apareAnimation->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(); //platforma de desenare DrawPlatform(); // trageți bile DrawBalls(); //dacă sistemul de particule este activ, atunci actualizați pozițiile particulelor și redați-le cu textura if(psystem->IsActive()) ( pDevice->SetTexture(0,pTex); psystem->Update( deltaTime); psystem->Render(); pDevice->SetTexture(0,0); ) //puncte de ieșire câștigate char buf="Scor: ",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(); pDispozitiv->Prezentă(NULL,NULL,NULL,NULL); )

La început, calculează câte milisecunde au trecut de la apelul anterior la Render (), apoi actualizează progresul animațiilor, dacă acestea sunt active. Tampoanele sunt curățate prin metoda Clear și platforma, bilele și sistemul de particule sunt desenate secvenţial, dacă este activ. În cele din urmă, este afișată o linie cu valoarea curentă a punctelor câștigate.

aplicarea

• Clasa are un câmp pentru stocarea coordonatelor mouse-ului, deoarece va trebui să calculăm offset-urile relative ale cursorului pentru a roti camera.
• Steagurile booleene aparStarted, moveStarted și detonateStarted sunt necesare pentru a ține evidența stării animațiilor respective.
• Metoda RegWindow conține codul pentru înregistrarea clasei ferestre.
• Metoda statică MsgProc este așa-numita procedură fereastră.
• ProcessGame este o versiune simplificată a managerului de stat, care evaluează starea curentă a jocului și ia unele măsuri în funcție de aceasta.
• MainLoop - bucla de procesare a mesajelor.

Iată un controler atât de ușor. O buclă de mesaj similară poate fi găsită în orice carte Direct3D:

TApplication::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 ( //dacă nu există mesaje, atunci procesează starea jocului și redă ProcessGame(); engine->Render(); ) ) return (INT)msg.wParam; )

Singurul lucru care merită atenție este ceea ce se află în interiorul blocului else - acesta este așa-numita Funcție Idle, care este executată în absența mesajelor.

Și iată funcția managerului de stat:

TApplication::ProcessGame()

void TApplication::ProcessGame() ( if(moveStarted) ( //așteptați până la sfârșitul animației mișcării if(!engine->IsMoving()) ( //mișcarea s-a terminat - testează pentru o explozie moveStarted=FALSE; if( joc->DetonateTest( )) ( //inițiază explozia și crește scorul WORD *detonateList, count=game->GetDetonateList(&detonateList); detonateStarted=TRUE; engine->DetonateBalls(detonateList,count); engine->OnUpdateScore( joc->GetScore()) ; ) else ( //încercați să adăugați mingi altfel if(game->CreateBalls(APPEAR_COUNT))) ( TBallInfo *appearList; WORD count=game->GetNewBallList(&appearList); appearStarted=TRUE; motor- >AppearBalls(appearList,count); ) else ( //game over! ) ) ) ) if(appearStarted) ( //așteptați până la sfârșitul animației de spawn if(!engine->IsAppearing()) ( appearStarted=FALSE; //spawn is over - testează pentru o explozie doar în cazul în care if(game->DetonateTest()) ( //inițiază explozia și mărește punctele WORD *detonateList, count=game->GetDetonateList(&detonateList); det onateStarted=TRUE; motor->DetonateBalls(detonateList,count); motor->OnUpdateScore(joc->GetScore()); ) ) ) if(detonateStarted) ( //așteptați până la sfârșitul animației exploziei if(!engine->IsDetonating()) ( //doar resetați steagul detonateStarted=FALSE; ) ) )

Ei bine, poate asta e tot!

Sper că descoperirile mele vor fi de folos cuiva. Apropo, sursa este pe github.

Multumesc pentru atentie!

Literatura promisă

1. Frank D. Luna Introducere în programarea jocurilor DirectX 9.0 3D - pentru a înțelege elementele de bază;
2. Gornakov S. Lecțiile de programare DirectX9 în C ++ sunt și ele de bază, dar există capitole despre DirectInput, DirectSound și DirectMusic. Programele exemple conțin uneori erori;
3. Flenov M. E. DirectX și C ++ arta de a programa - un stil amuzant de prezentare. Practic, scopul cărții este de a crea videoclipuri animate folosind efecte interesante, inclusiv cu shadere. Judecă singur după titlurile secțiunilor: infarct, dragon de foc;
4. Programarea jocurilor de strategie Barron Todd cu DirectX 9 - Complet dedicat subiectelor jocurilor de strategie: grafică bloc, AI, crearea de hărți și terenuri, sprite-uri, efecte ale sistemului de particule, precum și dezvoltarea interfeței ecranului și DirectSound/Music;
5. Bill Fleming 3D Creature WorkShop - o carte nu despre programare, ci despre dezvoltarea modelelor de personaje tridimensionale în LightWave, 3D Studio Max, Animation Master;
6. Thorn Alan DirectX 9 Interfețe utilizator Proiectare și implementare - carte detaliată despre dezvoltare interfețe grafice cu DirectX. Se are în vedere un model ierarhic al componentelor formulare de ecran, similar cu cel implementat în Delphi;
7. Adams Jim Advanced Animation with DirectX - ia în considerare tipurile de animație (scheletice, morphing și varietăți) și implementarea acestora, precum și lucrul cu geometria și animația din fișierele X;
8. Andre Lamotte Programare jocuri pentru Windows. Sfaturi profesionale - această carte este deja mai serioasă: probleme de optimizare, alegerea structurilor de date pentru diverse sarcini, multithreading, modelare fizică, AI. Ultimul capitol descrie crearea unui joc despre nava spatialași extratereștrii;
9. David H. Eberly 3D Game engine design este o carte bună pentru înțelegerea întregii teorii a construirii jocurilor: mai întâi descrie tehnologiile grafice API (transforme, rasterizare, umbrire, amestecare, multitexturing, ceață etc.), apoi subiecte precum ca graficul scenei, selecția obiectelor, detectarea coliziunilor, animația personajelor, nivelul de detaliu, peisaje;
10. Daniel Sánchez-Crespo Dalmau Tehnici și algoritmi de bază în programarea jocurilor - discută în detaliu algoritmii și structurile de date utilizate în sarcinile de dezvoltare a jocului, precum AI, scripting, randare în spații închise și deschise, algoritmi de tăiere, tehnici procedurale, metode pentru implementarea umbrelor, implementarea camerei etc.;
11. Andre Lamotte Programează jocuri de rol cu ​​directX 9 - 1.000 de pagini ghid detaliat pentru dezvoltarea RPG-ului. Include atât capitole teoretice despre programarea cu Direct3D, DirectInput, DirectSound, DirectPlay, cât și capitole aplicate care au legătură directă cu motorul de joc.

Etichete: Adăugați etichete

Bună seara dragi prieteni. Cu acest articol, încep o serie de lecții despre unul dintre cele mai populare limbaje de programare - c++. Lecțiile se adresează în primul rând utilizatorilor care nu sunt familiarizați cu programarea, așa că profesioniștii, nu fiți stricti, deși susțin criticile, mai ales în adresa mea. În tutorialele mele, voi folosi mediul de dezvoltare Code::Blocks, care poate fi descărcat și utilizat gratuit. Să începem desigur cu clasicul Hello, world =)

Sper că ați descărcat și instalat deja Code::Blocks, dacă da, să începem. Lansarea mediului de dezvoltare

Mai întâi de toate, creați un nou proiect gol Fișier->Nou->Proiect și selectați Proiect gol

faceți clic pe Go, apoi pe Următorul

iar în fereastra care apare, în câmpul Titlu proiect, tastați titlul proiectului, în Nume fișier proiect, numele proiectului și din nou Următorul.

În fereastra următoare, ștergeți directorul Objects din secțiunile Creare configurație „Depanare” și Creare configurație „Release”, așa cum se arată în captura de ecran de mai sus și faceți clic pe butonul Terminare. Un proiect cu numele „Hello world” ar trebui să apară în partea dreaptă.

Următorul pas este să adăugați fișierul File->New->File... la proiect și selectați sursa c/c++ în fereastra care apare.

Din nou Go, Next, selectați c++, Next și vedeți următoarea fereastră

,

aici trebuie să specificăm numele fișierului (eu l-am numit main) și calea acestuia, de preferință folderul cu proiectul. Bifați casetele pentru Debug și Release și faceți clic pe Terminare.

Și avem un fișier c++ gol în care vom scrie codul programului în sine.

Acum începem să scriem codul programului în sine. Pentru a afișa informații pe ecran, avem nevoie de biblioteca de intrare/ieșire iostream.

#include

folosind namespace std;

Apoi scriem functie principala pentru a fi executat la pornirea programului

int main()

trebuie numit „main” și specificăm tipul int pentru el (vom vorbi despre asta în lecțiile următoare). Între acolade iar codul programului va fi găsit. Vom scrie un program simplu care va afișa salutul „Bună, lume!” în consolă.

cout<<"Salut Lume!" ;

După fiecare comandă, trebuie să puneți „;”, aceasta îi spune compilatorului că comanda este terminată și o puteți procesa pe următoarea. cout - afișează valorile variabilelor sau șirurilor de caractere în linia de comandă.

Lista completă a programului.

#include

folosind namespace std;

int principal ()

cout<< "Hello, world!" ;

întoarcere 0 ;

Începem proiectul și vedem rezultatul.

Mai jos este un tutorial video pentru acest articol.

Dacă aveți întrebări, vă rugăm să scrieți comentarii la Această adresă de e-mail este protejată de spamboți. Trebuie să aveți JavaScript activat pentru a vizualiza. ,">Această adresă de e-mail este protejată de spamboți. Trebuie să aveți JavaScript activat pentru a vizualiza., voi finaliza lecțiile sau doar ajut la studierea materialelor.

• < Назад

Dezvoltare de aplicații încorporate

Partea 2: Utilizarea Code::Blocks pentru a dezvolta aplicații AVR

Seria de conținut:

În articolul anterior, am arătat cum să folosiți mediul de dezvoltare Eclipse pentru a crea aplicații pentru microprocesoarele din seria AVR de la Atmel folosind kitul de compilare GNU AVR GCC. Am abordat configurarea Eclipse folosind pluginul AVR, precum și configurarea manuală a mediului. Acum vom arăta cum poate fi rezolvată aceeași sarcină folosind un alt mediu de dezvoltare Code::Blocks, mai ușor și foarte convenabil.

Introducere în mediu

Creați un proiect

Dacă încă nu au fost create proiecte în spațiul de lucru, atunci după pornirea Code::Blocks, în panoul central este activă doar fila Începeți aici. Pentru a crea un nou proiect, selectați comanda „Creați un nou proiect” sau elementul de meniu „Fișier->Nou->Proiect”. În orice caz, se va deschide o fereastră pentru selectarea unui șablon de proiect viitor, în care specificăm șablonul „Proiect AVR” și facem clic pe butonul „Go”.

Va apărea fereastra de bun venit a asistentului de creare a proiectului AVR. Faceți clic pe butonul „Următorul” și în caseta de dialog care se deschide, introduceți numele proiectului și directorul în care va fi localizat. Pe baza acestor date, programul va oferi automat utilizatorului numele fișierului de proiect cu extensia *.cbp și directorul proiectului de creat. Apoi, faceți clic pe butonul „Următorul”.

Următoarea fereastră vă solicită să selectați configurațiile de construcție care vor fi utilizate în proiect. Ambele configurații sunt active implicit: Debug și Release. Compilatorul „GNU AVR GCC Compiler” este prespecificat. De asemenea, puteți schimba directoarele implicite pentru fișierele de configurare compilate aici.

În fereastra următoare, specificăm tipul procesorului țintă selectându-l din lista derulantă (acest lucru se poate face mai târziu în opțiunile de compilare). Dacă proiectul folosește memorie externă, ar trebui să specificați parametrii acesteia. Apoi, ar trebui să setați valoarea variabilei globale de proiect F_CPU, specificând frecvența tacului procesorului în herți. În mod implicit, este activată crearea unui fișier cu hărți de caractere (.map) și a fișierelor hexadecimale, precum și a unui fișier de listare a dezasamblatorului (.lss). De asemenea, este util să activați parametrul „Run avr-size after build” - apoi la sfârșitul jurnalului de construire a proiectului, vor apărea informații despre cât spațiu va fi ocupat în memoria programului și în memorie cu acces aleator. Din anumite motive, activarea opțiunii de construire a listei nu are efect la construirea proiectului și trebuie să adăugați manual comanda corespunzătoare la „Pașii înainte/post construirea”. Faceți clic pe butonul „Terminare” (Figura 2).

Proiectul este creat, iar primul fișier, main.c, este adăugat automat la acesta.

Configurarea mediului de proiect și dezvoltare

Dacă ați creat un proiect folosind șablonul de proiect AVR, puteți începe programarea aproape imediat. Cu toate acestea, vom parcurge setările de bază pentru a ne asigura că totul este configurat corect.

1. Selectați elementul de meniu „Proiect->Opțiuni de construcție”. Se va deschide fereastra de setări de construcție (Figura 3). Panoul din stânga conține arborele țintă de construcție. La cel mai înalt nivel se află setările de construcție pentru întregul proiect. Cel mai convenabil este să specificați mai întâi parametrii pentru întregul proiect și abia apoi să adăugați ceva în opțiunile individuale de construcție.
   
   

   În primul rând, trebuie să vă asigurați că „GNU AVR GCC Compiler” este selectat în câmpul „Selected Compiler”. Mai jos, în fila „Stavilele compilatorului”, sunt steagurile compilatorului. În mod implicit, indicatorul util „Activați toate avertismentele compilatorului” este deja activat aici. De asemenea, merită să ne asigurăm că am ales corect tipul de procesor pentru care se dezvoltă proiectul.

   Fila „#defines” arată valoarea variabilei F_CPU, dacă aceasta a fost setată la crearea proiectului.

   În fila „Opțiuni linker” din panoul „Alte opțiuni linker”, puteți vedea că linkerul este setat la opțiunea corectă -mmcu, iar în panoul din stânga „Link libraries”, trebuie să specificați bibliotecile necesare pentru proiect, dacă este cazul.

   Accesați fila „Căutare directoare”. Mai jos, în fila „Compiler”, trebuie să inserați calea către fișierele antet, de exemplu, /usr/avr/include/. Pentru a face acest lucru, utilizați butonul „Adăugați” și introduceți calea corectă. În mod similar, în fila „Linker”, specificați calea către bibliotecile AVR GCC, de exemplu, /usr/avr/lib.

   Fila pașii înainte/post construcție. În câmpul „Pași post-build”, puteți vedea comenzile pentru rularea utilitarelor avr-size, avr-objcopy, avr-objdump. De exemplu, pentru a obține o listă (deoarece activarea opțiunii „Creare fișier listare extinsă” în expertul de creare a proiectului nu are efectul dorit, cel puțin în versiunea 8.02), adăugăm următoarea comandă:

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

   Dacă treceți acum de la setările la nivel de proiect la ținte de compilare mai specifice, cum ar fi Depanare sau Lansare, puteți face unele modificări la setările de compilare. În același timp, acordați atenție faptului că parametrul „Politică” a devenit disponibil. Valoarea sa implicită este „Adăugați opțiunile țintă la opțiunile de proiect”, adică. setările pentru ținta specifică de construcție sunt adăugate la setările generale ale proiectului. Există și alte opțiuni pentru combinarea setărilor de diferite niveluri. Acest lucru vă permite să personalizați în mod flexibil proiectul fără a repeta parametrii generali deja introduși.

   Setările implicite includ activarea automată a creării informațiilor de depanare în ținta Debug (parametrul „-g”) și optimizarea dimensiunii programului rezultat în ținta Release (parametrul „-Os”).

2. Selectați elementul de meniu „Proiect->Proprietăți”. Aici, setările standard sunt destul de potrivite pentru a începe lucrul cu proiectul fără a schimba nimic în ele. Merită să acordați atenție filei „Construiți ținte”. Pentru fiecare țintă de build (implicit: Debug și Release), este indicat unde sunt scrise fișierele obiect rezultate, iar în câmpul „Build target files” puteți specifica ce fișiere sursă sunt implicate în această build (Figura 4).
   
   

   Dacă doriți, puteți salva proiectul personalizat ca șablon pentru proiecte viitoare. Pentru a face acest lucru, selectați comanda de meniu „Fișier->Salvare proiect ca șablon utilizator...” și introduceți numele șablonului. Ulterior, atunci când creați un nou proiect, puteți selecta șablonul dorit în categoria „Șabloane utilizator” (Figura 5). După aceea, va trebui să setați un director gol în care va fi creat noul proiect și apoi să editați numele proiectului.

   
   

   Puteți chiar să modificați un șablon standard existent. Pentru a face acest lucru, în fereastra de selecție a șablonului, faceți clic dreapta pe șablonul dorit și utilizați opțiunea „Editați acest script” din meniul care apare.

3. Înainte de a construi ceva, trebuie să vă uitați și la setările globale ale compilatorului. Acest lucru se face prin meniul principal: „Setări->Setări compilator și depanator”. În fereastra panoului din stânga care se deschide, faceți clic pe pictograma „Setări globale ale compilatorului”. În partea de sus a panoului din dreapta, în câmpul de sus „Compilatorul selectat”, selectați „Compilatorul GNU AVR GCC” (Figura 6).
   
   

   Nu merită să schimbați nimic în fila „Setări compilatorului”: aceste setări vor deveni standard pentru toate proiectele AVR. Dar pe filele „Căutare directoare-> Compiler” și „Căutare directoare-> Linker”, în cazul meu, existau deja căi standard /usr/include și respectiv /usr/lib, ceea ce era greșit. Aici puteți specifica căile corecte (de exemplu, /usr/avr/include și /usr/avr/lib) și puteți șterge aceleași căi din setările proiectului, tocmai am șters aceste câmpuri cu butoanele „Șterge”, deoarece setările proiectului în acest moment au fost deja configurate.

   În fila „Executabile din lanț de instrumente”, verificăm dacă numele fișierelor executabile din kitul AVR GCC și căile către acestea sunt corecte. Cu butonul „autodetect”, puteți încerca să detectați automat toate aceste valori. Dacă ceva nu a mers prost (de exemplu, distribuția AVR GCC a ajuns cu nume exotice și directoare pentru plasare), atunci acesta este doar locul în care totul poate fi reparat manual. În Figura 7, câmpul „Directorul de instalare al compilatorului” ar trebui să fie „/usr” dacă programele AVR GCC se află în directorul /usr/avr/.

   
   

   Și ultimul. Pe fila „Alte setări” există un câmp „Înregistrare compilator”. În acesta, puteți seta modul de înregistrare a procesului de compilare. Este recomandat să setați această valoare la „Linie de comandă completă”. Acest lucru vă va permite să urmăriți în detaliu comenzile utilizate în asamblare.

Acum Code::Blocks este gata să construiască proiectul!

Folosind propriul makefile pentru proiectul tău

O situație non-standard poate apărea întotdeauna atunci când procesul de construire a proiectului trebuie luat sub control deplin. Pentru a face acest lucru, Code::Blocks oferă posibilitatea de a lucra cu propriul fișier de asamblare. Pentru a-l folosi, trebuie să creați un proiect gol și să-l salvați. Acum trebuie să specificați că este folosit propriul makefile:

1. Selectați elementul de meniu „Proiect -> Proprietăți”.
2. Accesați fila „Setări proiect”.
3. Bifați caseta „Acesta este un makefile personalizat”.
4. Asigurați-vă că introduceți numele corect al fișierului în câmpul „Makefile:”.
5. Acum, în fila „Construiți ținte”, trebuie să modificați sau să adăugați ținte de construcție în conformitate cu fișierul make existent, de exemplu: all cleanall

Când utilizați propriul makefile, ar trebui să verificați ce comenzi sunt disponibile în fila „Efectuați comenzi” din elementul de meniu „Proiect ->Opțiuni de construcție”.

Program de probă

Proiectul, nou creat conform șablonului AVR, are deja fișierul main.c, care conține pregătirea modulului principal pentru programul C. Să scriem un nou program C++.

Utilizați opțiunea de meniu „File->New->File...”, selectați „C++ source” și faceți clic pe butonul „Go”. Va apărea fereastra de bun venit a Expertului Nou. fișier sursă. Faceți clic pe butonul „Următorul” și în fereastra următoare selectați limbajul de programare pentru acest fișier: C++. Apoi, specificați numele fișierului (de exemplu, sample.cpp) și calea completă către acest fișier făcând clic pe butonul „...” din dreapta câmpului cu numele fișierului. Apoi trebuie să specificați pentru ce scopuri de construcție va fi prezent acest fișier, pentru care puteți pur și simplu să faceți clic pe butonul „Toate”. Faceți clic pe butonul „Terminare”.

Introduceți cel mai simplu program C++ în fișierul gol creat:

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

Salvați fișierul apăsând Ctrl+S. Nu avem nevoie de fișierul main.c, acesta poate fi eliminat din proiect făcând clic dreapta pe numele acestuia și selectând comanda „Eliminați fișierul din proiect” din meniul care apare (Figura 8).

Când introduceam comentarii în limba rusă, am continuat să dau de o problemă enervantă în munca editorului: uneori refuză să intre în chirilic. Aparent, acest lucru se datorează faptului că funcționează în Unicode. Poți rezolva temporar problema introducând un spațiu suplimentar, după care textul este scris normal. Acest spațiu poate fi apoi îndepărtat.

Să compilam programul. Pentru a face acest lucru, selectați comanda de meniu „Build-> Build” sau apăsați combinația de taste familiară Ctrl + F9, puteți utiliza și butonul roată roată albastră din bara de instrumente. Programul va fi compilat, iar caseta de mesaje din partea de jos a ecranului va trece automat la fila „Build messages”, unde va spune că build-ul s-a terminat, au fost 0 erori și un avertisment: pe linia 8, variabila neutilizată „a”.

Un pic despre depanare

Abordarea depanării aplicațiilor AVR depinde în mare măsură de hardware-ul utilizat. Dacă aveți un dispozitiv AVR JTAG ICE, puteți efectua depanare în circuit, conectându-vă cu acesta la procesor folosind utilitarul avarice. Dacă nu există un astfel de dispozitiv, utilizați simulatorul de procesor simulavr. Din păcate, acest proiect nu a fost dezvoltat de câțiva ani, dar dezvoltatorii continuă să lanseze remedieri.

Pentru a configura depanarea în Code::Blocks, trebuie să deschideți proprietățile proiectului „Proiect->Proprietăți” și să accesați fila „Depanator”. Aici, în câmpul „Selectare țintă”, selectați „Depanare”. Pentru această configurație, fila „Conexiune la distanță” specifică parametrii pentru conectarea avr-gdb la ținta de depanare la distanță:

• „Tip de conexiune”: TCP.
• „Adresă IP”: localhost dacă depanatorul (sau simulatorul) este conectat la aceeași mașină.
• „Port”: de exemplu, 1212.

Acum, pe fila „Comenzi suplimentare” în câmpul „După conexiune”, trebuie să introduceți următoarele comenzi pentru depanator:

rupere de sarcină principal

Prima comandă va încărca programul în ținta de depanare (microprocesor sau simulator), iar a doua va insera un punct de întrerupere în funcția principală.

Înainte de depanare, trebuie să rulați simulavr în terminal:

simulavr -g -p 1212 -d atmega128

(pentru procesorul atmega128), obțineți ceva de genul acesta:

$ simulavr -g -p 1212 -d atmega128 ... main.c:415: MESAJ: Simularea frecvenței de ceas de 8000000 Hz Se așteaptă pe portul 1212 să se conecteze clientul gdb...

Dacă dispozitivul este conectat la portul serial /dev/ttyS0, puteți porni avariția cu următoarea comandă:

avariția -j /dev/ttyS0 -P atmega128:1212

Acum puteți începe depanarea în Code::Blocks folosind comanda de meniu „Debug->Start”. În fereastra în care rulează simulavr, vor fi adăugate următoarele mesaje:

Conexiune deschisă de gazda 127.0.0.1, portul -14999. decoder.c:737: MESAJ: BREAK POINT: PC = 0x00000068: ceas = 34

În acest caz, textul sursă care conține funcția principală va fi încărcat în editorul Code::Blocks, iar cursorul depanatorului se va opri la această funcție, așa cum se arată în Figura 9. Acum puteți utiliza butoanele convenabile pentru a controla depanatorul în bara de instrumente, vizualizați valorile variabilelor și așa mai departe. . Pentru mai multe informații despre depanare, consultați documentația pentru gdb, simulavr sau avarice.

Concluzie

Așadar, v-am arătat cum să începeți rapid dezvoltarea aplicațiilor AVR folosind Code::Blocks, un mediu de dezvoltare minunat și în creștere rapidă, cu un efort și timp minim, fără a vă referi la documentație și manuale. În prezent, interfața mediului a fost tradusă în multe limbi și, probabil, fișierele localizate vor deveni în curând parte din ramura principală de dezvoltare.

În articolul următor, ne vom uita la utilizarea Eclipse pentru a construi aplicații pentru o mare varietate de microprocesoare cu memorie mică pentru care este proiectat compilatorul SDCC open-source.