Interesantas programmēšanas vadlīnijas dizainerim-uzņemiet attēlu (pirmā daļa): 16 soļi

2024 Autors: John Day | [email protected]. Pēdējoreiz modificēts: 2024-01-30 11:00

Skrien! Skrien! Skrien!

Programmēšana nav tik grūta. Galvenais ir atrast savu ritmu un darīt to pa vienam.

Pirms šīs nodaļas lasīšanas es ceru, ka jūs jau esat iepazinušies ar pamatfunkciju zīmēšanas metodi, vai arī jūs jutīsieties reiboni un apjukumu divu lielu galvas funkciju dēļ: iestatīšana un zīmēšana.

Tā kā mēs vēlamies veidot kustīgu grafiku, mums ir jāzina, kā tiek veidota animācija.

Iepriekš redzamais attēls šķiet diezgan pievilcīgs un vizuāli atklāj animācijas ieviešanas principu.

Animācija ir maģija. Tā ir burvība par vizuālu krāpšanos. Tomēr šajā informācijā eksplodēja video plūdu laikmets, mēs jau esam pie tā pieraduši. Tikai daži cilvēki būs pārsteigti, ka ir pārsteidzoši redzēt animāciju.

To pašu principu var izmantot zīmēšanas animācijā ar programmu. Mums ir jāapsver, kā katrā kadrā uzzīmēt dažādas grafikas, un programma automātiski pāršķirs lapas, kamēr mēs savā galvā papildināsim pabeigtu animāciju. Nākamajā nodaļā mēs runāsim par to, kā realizēt pamata grafikas kustības. Pirms tam mums jāzina dažas pamatzināšanas par mainīgajiem.

1. darbība. Mainīgais

Mainīgais ir datu konteiners. To var atkārtoti izmantot programmas ietvaros.

Piemēram:

[cceN_cpp theme = "dawn"] izmērs (500, 500); elipse (100, 250, 50, 50); elipse (200, 250, 50, 50); elipse (300, 250, 50, 50); elipse (400, 250, 50, 50);

[/cceN_cpp]

Šajā koda sadaļā nav izmantoti nekādi mainīgie. Tas ekrānā uzzīmē četrus apļus. Mēs varam atrast, ka tiem ir vienāds platums un augstums. Tagad, kad tas ir tas pats, lai samazinātu atkārtotu datu ievadi, mēs varam definēt zīmi, kas to attēlo. Šī zīme ir mainīga.

Šeit ir kods pēc mainīgā pievienošanas:

[cceN_cpp theme = "dawn"] izmērs (500, 500); int a = 50; elipse (100, 250, a, a); elipse (200, 250, a, a); elipse (300, 250, a, a); elipse (400, 250, a, a);

[/cceN_cpp]

Mēs iegūstam pilnīgi tādu pašu rezultātu!

Tā kā esam definējuši mainīgo a, mēs varam ērti mainīt parametrus. Ja mainīsim a = 50 uz a = 100, tad visu apļu platums un augstums vienmērīgi kļūs par 100. Tāpēc mums nav jāmaina parametri pa vienam. Mainīgais tiešām ir labs izgudrojums.

2. darbība. Mainīgā izveide

Pirms mainīgā izmantošanas mums jāizveido paziņojums un jānosaka tā datu tips.

int i;

i ＝ 50;

Koda pirmais teikums ir sniedzis paziņojumu par mainīgo i. int ir simbols, ko galvenokārt izmanto, lai deklarētu mainīgo. Deklarējot, tas atbrīvos vietu datora atmiņā, kas ir līdzvērtīga "kastes" ģenerēšanai, ko īpaši izmanto veselu skaitļu datu atjaunošanai. Otrais teikums nozīmē uzdevuma 50 izpildi ar mainīgo i. Pēc šī teikuma izpildes dati mainīgajā i tiks glabāti stabili. Vai arī jūs varat būt slinkāks, apvienojot iepriekš minētos divus teikumus vienā un pabeigt uzdevumu, veidojot paziņojumu.

int i ＝ 50;

Mainīgā nosaukšana ir salīdzinoši brīva. Bet dažreiz mums ir jāpievērš uzmanība kaut kam.

3. darbība. Mainīgā nosaukuma regulēšana

• Tam jābūt alfabēta un pasvītrojuma kombinācijai. Tas var būt simbols vai vārds.

• reģistrjutīga. Vārds un nosaukums var nozīmēt dažādus mainīgos.

• Mēģiniet to nosaukt pēc iespējas vienkāršāk, lai jūs varētu saprast vienā mirklī. Sākotnējai rakstzīmei ir jābūt alfabētam, nevis skaitlim vai īpašai rakstzīmei.

• Nav atslēgas vārdu, piemēram, int, float

Tālāk ir daži nepareizi apgalvojumi.

int $ a;

int 89b;

Lūk, pareizie apgalvojumi:

int r;

int super_24;

int openTheDoor;

4. darbība. Mainīgā tips

Izņemot veselu skaitļu datu deklarēšanu, mēs varam deklarēt decimāldaļas datus (tos sauc arī par peldošā komata datiem) ar atslēgas vārdu pludiņš.

pludiņš b = 0,5

Mums ir jāpatur prātā, kāda veida datus mēs izmantojām mūsu paziņojumam. Ja mēs esam izmantojuši atslēgas vārdu int, pēdējo uzdevumu nevar uzrakstīt i ＝ 0,5 vai tamlīdzīgi, pretējā gadījumā programma kļūs kļūda. Bet, ja mēs rakstām pretēji, viss ir kārtībā. Piemēram, pludiņš i = 5 ir pareizā gramatika, bet programma to atpazīs kā decimālo skaitli.

Dažus mainīgos lielumus sistēma jau ir definējusi. Mums pašiem tie nav jādeklarē. Tāpat kā iepriekš minētais "platums, augstums", tas automātiski iegūs datora ekrāna platumu un augstumu. Tik augsta lietošanas biežums, ka dizainers to tieši definē kā noklusējuma mainīgo, lai mums būtu ērtāk to lietot.

5. solis: operators

Apstrādes operatori ir šādi:

+ plus

- mīnus

* pavairot

sadalīt

％ Atlikuma modulis

Jums jāzina visi šie operatori, izņemot %. Tas šķiet diezgan dīvaini, jo tā rezultāts ir palicis. 9%3 ir 0. Kamēr 9%5 ir 4.

Operatorus var izmantot starp uzdevumiem un mainīgajiem.

[cceN_cpp theme = "dawn"] int a = 1; // deklarēt veselu skaitļu mainīgo a, piešķiršana ir 1. int b = 2; // Deklarēt veselu skaitļu mainīgo b, piešķiršana ir 2. int c; // Deklarēt veselu skaitļu mainīgo c. c = a + b; // Plus divi uzdevumi un piešķir tā rezultātu c. drukāt (c); // Izvades mainīgais c.

[/cceN_cpp]

6. darbība: darbības rezultāts:

Izvades rezultāts netiks parādīts logā, bet apakšā esošajā konsolē.

Ceturtās rindas rakstīšanas metode izskatās diezgan dīvaina. Bet tas ir izplatīts formāts, ko bieži izmanto datora piešķiršanas laikā. Vienāda simbola kreisajai pusei jābūt pēdējam piešķirtajam mainīgajam, bet labajai pusei jābūt darbības procesam.

Drukāšanas funkcija piektajā rindā var izdrukāt mainīgos lielumus konsolē, ko bieži izmanto, lai pārbaudītu datu izvades stāvokli.

7. darbība: darbības regulēšana

Apgrūtinošs punkts apstrādē ir jānoskaidro mainīgā veids. Mums jāpievērš īpaša uzmanība peldošā komata skaitļa un vesela skaitļa veida procesam.

drukāt （6 /5）; // rezultāts 1

Darbībai starp veseliem skaitļiem būs jauns vesels skaitlis. 6 dalīts ar 5 ir 1,2. Bet programmas iznākuma rezultāts ir 1. Tas ir pretrunā ar mūsu intuīciju. Programma nenodarbojas ar apaļo, bet izdzēš skaitli aiz komata.

drukāt (6,0 / 5,0); // rezultāts 1.2

Darbojoties starp peldošajiem punktiem, tiks iegūts jauns peldošā komata numurs. Ja faktiskais rezultāts ir 1,2, programmas izvades rezultāts būs tāds pats.

drukāt (6 / 5,0); // rezultāts 1.2

drukāt (6,0 / 5); // rezultāts 1.2

Visbeidzot, tas ir vesels skaitlis un peldošā komata skaitlis. Gala rezultāts būs 1,2.

• Patiesībā jums jāpatur prātā, ka šīs regulas izstrādes mērķis ir nezaudēt datu precizitāti. Tātad, ja viens elements ir peldošā komata skaitlis, rezultāts būs arī peldošā komata numurs.

8. darbība: iestatīšanas funkcija un zīmēšanas funkcija

Iepriekš mēs esam runājuši par zināšanu kaudzi. Tagad mēs beidzot spēlējam kaut ko interesantu. Funkciju iestatīšana un zīmēšana ir līdzvērtīga apstrādes galvenajām funkcijām. Šīs divas funkcijas ir ļoti īpašas. Tas var kontrolēt programmas darbību. Salīdzinoši sarežģītā programma ietvers šīs divas funkcijas, jo tās ir programmas pamatrāmis. Formāts:

void setup () {

}

void draw () {

}

Īpašais lietojums padara to izsaukšanas formātu atšķirīgu no citām funkcijām. Pirms funkcijas nosaukuma ir jāpievieno "void", kas nozīmē "atgriezto vērtību". Aiz funkcijas nosaukuma mums jāpievieno iekavas un iekavas.

[cceN_cpp theme = "dawn"] void setup () {print (1); } void draw () {print (2); } [/cceN_cpp]

Apskatīsim piemēru:

Nospiežot darbības pogu, konsole vispirms izvadīs "1" un pēc tam pastāvīgi izvadīs "2", līdz būsit nospiedis apturēšanas pogu vai aizvēris logu.

Iestatīšanas funkcijas iekavās esošais kods tiks ieviests tikai vienu reizi. Kamēr funkcijas izlozes kods pastāvīgi darbosies apritē (noklusējuma ieviešana 60 reizes sekundē).

Šī rakstura dēļ iestatīšana parasti tiek izmantota, lai inicializētu vides rekvizītus, piemēram, ekrāna platumu un augstumu, fona krāsu un visu veidu mainīgo piešķiršanu. Lai gan mēs bieži ievietojam zīmēšanas funkcijas funkciju zīmēšanā, lai ģenerētu nepārtraukti mainītu grafiku.

9. solis: aplis horizontālā kustībā

Izmantojot funkciju draw, mēs varam sākt veidot savas animācijas. Animācijas efekta rakstīšanas metode, izmantojot apstrādi, ir diezgan “neērta”. Tam nav nevienas komandas. Piemēram, norādiet noteiktu formu, lai veiktu izliekumu.

Mums pašiem jādefinē šīs detaļas. Programmai ir jāpasaka, kāda grafika noteikti nepieciešama katram kadram.

Ierakstiet tajā šādu kodu (tagad sāksim to darīt ar rokām):

[cceN_cpp theme = "rītausma"] int x; int y; void setup () {izmērs (300, 300); x = 0; y = augstums/2; } void draw () {fons (234, 113, 107); noStroke (); elipse (x, y, 50, 50); x = x+1; }

[/cceN_cpp]

Šajā koda sadaļā tiek parādīts kustības aplis. Bijušais deklarētais mainīgais x, y tiek izmantots koordinātu pozīcijas saglabāšanai. Tās uzdevumi tiek veikti funkciju iestatīšanā. Funkcijas zīmējumā atslēgas kods ir šāds:

x = x + 1

Neskatiet to kā matemātisku vienādojumu, pretējā gadījumā tas būs ļoti dīvaini. Šeit "＝" ir uzdevuma simbols. Tas nozīmē pareizo skaitļu ievietošanu kreisajā mainīgajā. Pieņemsim, ka x ir 50, kad kods sāk darboties, "＝" labā puse ir vienāda ar 50+1, t.i. 51. Gala rezultāts tiks piešķirts mainīgajā x. Tātad x vērtība kļūst par 51.

Izpildiet programmas procedūru, katru reizi, kad funkciju zīmēšana darbojas vienu reizi, x vērtība palielināsies. Tātad katru reizi, kad zīmēsim, aplis horizontāli pa labi pārvietos pikseļu virzienu, salīdzinot ar iepriekšējo kadru. Tāpēc grafika kļūst kustīga.

• Lai kods būtu labāk lasāms, pirms katras iekavas rindas iekavās ir jāatbrīvo noteikta vieta. Un tam jābūt pēc iespējas saskaņotam. Nospiediet taustiņu TAB vai vairākas tukšas vietas, tas var atsaukt.

• Tukšas vietas un rindas pārtraukuma simbols programmā neietekmēs. Tāpēc ir labi, ja mēs ierakstām vienu vairāk vai mazāk.

Šeit ir vēl viens vienkāršāks veids, kā to izteikt. Lai mainīgais aplis automātiski palielinātu 1, mums tas jāraksta šādā formātā.

aplis ＝ aplis ＋1

Diezgan neērti! Ja mainīgā nosaukums ir garāks, mums jāievada vairāk vārdu. Tātad mūsu slinkie priekšteči izdomā šādu ideju.

aplis ＋＋

Vai tas nav ļoti vienkārši? Tas nozīmē automātiski palielināt 1. Līdzīgi tam ir - -, kas nozīmē automātiski samazināt 1.

Bet, ja mēs ceram, ka automātiskā palielinājuma daudzums ir cits skaitlis, piemēram, 2, mums ir jāizmēģina cita izteiksme.

aplis += 2

Tas ir vienāds ar

aplis = aplis + 2

Līdzīgi ir - ＝, /=, *=.

10. solis: kustības virziens

Grafikas virziena virziens ir atkarīgs no tā, kā maināt koordinātu. Ja tas tiek mainīts uz y ＝ y ＋ 1, aplis pārvietosies uz leju. Ja abas un y palielinās par 1, aplis pārvietosies lejup pa labo apakšējo daļu. Ja mēs to uzrakstīsim kā mīnusa simbolu, tas pārvietosies pretējā virzienā.

[cceN_cpp theme = "dawn"] int x, y; // Var deklarēt vairākus mainīgos vienlaikus, atdalīšanai izmantojiet komatu. void setup () {izmērs (300, 300); x = 0; y = 0; } void draw () {fons (234, 113, 107); noStroke (); elipse (x, y, 50, 50); x ++; y ++; }

[/cceN_cpp]

Kustības ātrums

Vai atcerieties noklusējuma 60 kadrus sekundē funkciju izlozē? Saskaņā ar šo ātrumu augšējais aplis pārvietosies pa 60 pikseļiem sekundē.

Ja mēs vēlamies mainīt grafisko kustību ātrumu, ir divas metodes: viena ir palielināt x vērtību katru reizi, kopš tā tiks mainīta.

x ＝ x ＋ 10

Tas ir uzlabojis ātrumu 10 reizes, salīdzinot ar sākotnējo!

Otra metode ir mainīt audekla atsvaidzināšanas biežumu. kadru ātrums()

Šī funkcija var mainīt audekla apraides frekvenci. Ierakstiet frameRate (10) funkciju iestatījumos, tas mainīs sākotnējos 60 kadrus sekundē uz 10 kadriem sekundē. Ātrums tiek palēnināts par 6 reizēm nekā iepriekš.

11. darbība. Aizmirstamais fons

Visi iepriekšējie piemēri raksta fonu funkciju zīmējumā. Vai esat kādreiz domājuši to ierakstīt funkciju iestatīšanā? Vai tam būs kādas atšķirības? Tagad atjaunināsim horizontālās kustības piemēru.

[cceN_cpp theme = "dawn"] int x, y; void setup () {izmērs (300, 300); fons (234, 113, 107); x = 0; y = augstums/2; } void draw () {noStroke (); elipse (x, y, 50, 50); x += 1; } [/cceN_cpp]

Kas notika? Varbūt tā nevar saprast problēmas rašanās cēloni pareizi. Izdzēsiet funkciju noStroke, vēlreiz pievienojiet gājienu un redziet apļa kustības ceļu.

Ak, tas ir tāpēc, ka iepriekš izveidotais aplis nav izdzēsts! Tā kā funkciju iestatīšana darbojas tikai vienu reizi, tad, ja virs tā rakstām fonu, tā aizpildīs fonu tikai vienu reizi, bet vēlāk tai vairs nebūs nekādas ietekmes. Funkcijas fons ir kā krāsas kausa rīks. Pēc izmantošanas tas aptvers visu audekla saturu, nevis iestatīs tikai fona krāsu. Mēs to rakstām pirms funkciju izlozes, lai bijušais rāmis tiktu pārklāts katru reizi, kad veidojam jaunu modeli. Tāpēc aplis var darboties tā, kā mēs gaidījām. Izņemot katras funkcijas pielietošanas atcerēšanos, mums ir jādomā par koda stāvokli. Daudz laika, augšup vai lejup vērsta līnija kodam un tās ierakstīšana iekavās vai ārpus tās, radīs diezgan atšķirīgus efektus. Koda virziens ir divdimensiju. Ja parādās kļūda, mums ir jākalibrē šajā divās dimensijās.

• Šī neatkārtota zīmēšanas metode var radīt ļoti īpašu efektu, ja to pareizi izmanto. Varat nokopēt šādu kodu un izmēģināt.

[cceN_cpp theme = "dawn"] void setup () {izmērs (400, 400); } void draw () {elipse (platums/2-mouseX, augstums/2-mouseX, mouseY, mouseY); elipse (platums/2-mouseX, augstums/2+mouseX, mouseY, mouseY); elipse (platums/2+mouseX, augstums/2-mouseX, mouseY, mouseY); elipse (platums/2+mouseX, augstums/2+mouseX, mouseY, mouseY); } [/cceN_cpp]

Šeit mēs esam izmantojuši burvju mainīgo mouseX un mouseY. Vēlāk mēs par to runāsim sīkāk.

12. solis: kratīšanas aplis

Ko darīt, ja vēlos panākt, lai apļa kustības virziens kļūtu neregulārs? Izmantojot gudru nejaušu funkciju, jūs varat arī realizēt šo efektu. Nejaušība ir bieži izmantota funkcija. To var izmantot nejaušu funkciju ģenerēšanai. Tas ir kā bezceļa gars. Kad esat saistīts ar mainīgajiem, jūs nevarat iedomāties, kas notiks tālāk.

Izsaukuma formāts:

nejaušs (augsts)

Augsts apzīmē izlases augšējo robežu, un noklusējuma apakšējā robeža ir 0. Piemēram, nejauša (10). Tas nejauši radīs skaitli no 0 līdz 10 (0 ir iekļauts, bet 10 nav iekļauts).

nejaušs (zems, augsts)

Ja mēs iestatām divus parametrus, tas atgriezīsies starp nejaušo vērtību. Piemēram, nejauši (5, 10). Tas nejauši radīs skaitli no 5 līdz 10 (5 ir iekļauti, bet 10 nav iekļauti).

Piemērs:

[cceN_cpp theme = "dawn"] pludiņš x;

x = nejaušs (50, 100);

drukāt (x); [/cceN_cpp]

Katru reizi, kad palaižam programmu, konsole izvadīs dažādas vērtības.

• Piezīme. Funkcijas random radītās vērtības pieder pie peldošā komata tipa (decimālskaitļa tips). Ja mēs vēlamies piešķirt vērtību veselu skaitļu mainīgajam, mums tas ir jāpārveido, izmantojot funkciju int (). Pārveidošana neievēro apaļu, bet tieši izdzēš decimāldaļu. Tādējādi int (izlases (5)) izvadei ir tikai 5 iespējas: 0, 1, 2, 3, 4.

Pēc tam, kad esam iepazinušies ar nejaušas funkcijas izmantošanu, mēs varam nonākt tieši zemāk esošajā gadījumā.

[cceN_cpp theme = "dawn"] int x, y; void setup () {izmērs (300, 300); x = platums/2; y = augstums/2; } void draw () {fons (234, 113, 107); noStroke (); x += int (nejauši (-5, 5)); y += int (nejauši (-5, 5)); elipse (x, y, 50, 50); }

[/cceN_cpp]

Iepriekšējās pievienotās koordinātu vērtības ir fiksētas. Tikai tad, ja mēs palielināsim nejaušu vērtību, aplis virzīsies nenoteiktā virzienā. Ar lielāku izlases diapazonu tas kratās biežāk. Tā kā vērtību maiņa starp kadriem ir atlēcusi, kustība vairs nebūs vienmērīga. Kamēr pirmais kadrs atrodas (150, 150), otrais kadrs ieskatīšanās laikā pārvietosies uz (170, 170) pozīciju.

13. darbība: migrējošais aplis

Migrējošais loks

Vai tas radīs vienmērīgu kustību? Funkciju troksnis var mums palīdzēt. Tam ir labāks ritms nekā standarta random. Un nejauši ģenerētie nejaušie skaitļi ir nepārtraukti.

Izsaukuma formāts:

troksnis （t）

Funkciju troksnis nevar noteikt tā izvades diapazonu. Programma nosaka, ka tā var ģenerēt tikai peldošā komata skaitļus no 0 līdz 1, un fiksētajai ieejai var būt tikai fiksēta izeja.

[cceN_cpp theme = "dawn"] pludiņš x = troksnis (5); pludiņš y = troksnis (5); drukāt (x, y); [/cceN_cpp]

Tā kā iepriekš minētie ievades parametri ir 5, tāpēc izvades rezultāti ir vienādi. Tad kā mainīt rezultātu? Atbilde ir dinamiski mainīt ievades parametrus. Patiesībā troksni varam uzskatīt par neierobežotu balss celiņu, ievades parametri ir tādi paši kā "pašreizējais laiks". Ja parametru ievade ir nepārtraukta, arī izeja būs nepārtraukta.

[cceN_cpp theme = "dawn"] pludiņš x, y; void setup () {izmērs (700, 100); x = 0; fons (0); } void draw () {x += 1; y = troksnis (frameCount/100.0)*100; noStroke (); elipse (x, y, 2, 2); }

[/cceN_cpp]

Šajā gadījumā mēs zīmējam Y izmaiņu ceļu, lai mēs varētu labāk izprast funkciju troksni.

• Starp tiem mainīgais frameCount iegūs pašreizējo kadru. Atšķirībā no platuma, augstuma iepriekšējā, tas ir stabils bez izmaiņām. Turklāt tas sāk pieaugt no 0. Ja mēs to saprotam ar mūsu sākotnējo displeja animēto grafiku, tas parāda lapu, uz kuru esam vērsušies (drīzāk uz laika koncepciju programmā).

• frameCount ir vesels skaitlis. Sadalīta ar citu veselu skaitļu mainīgo, programma pēc noklusējuma apstrādā rezultātu kā veselu skaitli. Lai uzlabotu rezultātu precizitāti, mums jāmaina 100 uz 100.0. Sadalot ar peldošā komata skaitli, mēs iegūsim arī peldošā komata numuru.

• Lai mainītu Y asi no 0 uz 100, trokšņa rezultāts jāreizina ar 100. Tādējādi mēs varam kontrolēt nejaušo vērtību diapazonu.

Daži no jums, kas labi domā, varētu jautāt: "kāpēc mums ir jāsadala frameCountby 100? Vai nav pareizi rakstīt frameCount tieši?" Protams tu vari! Bet šeit, lai labāk parādītu funkciju trokšņa īpašības, mēs palēninām "apraides ātrumu". Zemāk redzamais piemērs parāda izvades vērtības izmaiņas ar atšķirīgu izmaiņu ātrumu.

[cceN_cpp theme = "dawn"] pludiņš x, y1, y2, y3, y4, y5; void setup () {izmērs (700, 500); x = 0; fons (0); } void draw () {x += 1; y1 = troksnis (kadru skaits)*100; y2 = troksnis (frameCount/10,0)*100; y3 = troksnis (frameCount/100.0)*100; y4 = troksnis (frameCount/1000.0)*100; y5 = troksnis (frameCount/10000.0)*100; noStroke (); elipse (x, y1, 2, 2); elipse (x, y2+100, 2, 2); elipse (x, y3+200, 2, 2); elipse (x, y4+300, 2, 2); elipse (x, y5+400, 2, 2); insults (80); līnija (0, 100, platums, 100); līnija (0, 200, platums, 200); līnija (0, 300, platums, 300); līnija (0, 400, platums, 400); }

[/cceN_cpp]

Funkciju trokšņa mainīgos parametrus varat uzskatīt par progresa joslu. Mainīt parametru ir tā, it kā mēs pārvietotu progresa joslu. Tātad, ja mainās šī "balss celiņa" apjoms, izvades vērtības priekšējās un aizmugurējās nepārtrauktās īpašības būs vājākas. (Mēs varam iedomāties, kas notiks, ja pārraidīsim mūzikas gabalu vai videoklipu ar 2 reizes lielāku ātrumu, 5 reizes ātrums, 20 reizes ātrums). Ja tvērums ir lielāks par noteiktu vērtību, tam nav lielas atšķirības, lai vērtību ģenerēšanas gadījumā funkcionētu nejauši.

Ja jūs saprotat visus iepriekš minētos piemērus, tad jums šķitīs, ka migrācijas loku nav vieglāk izdarīt. Jūs varat arī saprast iekšējos principus.

[cceN_cpp theme = "dawn"] pludiņš x, y; void setup () {izmērs (300, 300); x = 0; } void draw () {fons (234, 113, 107); x = troksnis (frameCount/100.0 + 100)*300; y = troksnis (frameCount/100.0)*300; noStroke (); elipse (x, y, 50, 50); }

[/cceN_cpp]

Tagad kustība ir interesantāka tāpat kā rotējošs žiroskops.

• Iemesls, kāpēc mainīgajiem x funkcijas trokšņos ir jāpievieno plus 100, ir tāpēc, ka, lai tos atdalītu no attāluma. Ja funkcijas trokšņa parametri xy ir vienādi vai diezgan tuvi, x, y koordinātas izmaiņas būs tuvu tām pašām. Tas jādara, lai kustība kļūtu daudz nejaušāka.

14. solis: aplis pārvietots ar peli

Tālāk mēs beidzot nonākam pie diviem mainīgajiem, kas man patīk visvairāk: mouseX un mouseY. No pirmā acu uzmetiena abas koncepcijas manas acis mirdz ar gaismu. Tā kā tas ir vistiešākais veids, kā mijiedarboties ar grafiku. Ar to mēs varam izveidot daudz interesantu programmu.

Lieta ir pavisam vienkārša:

[cceN_cpp theme = "dawn"] int x, y; void setup () {izmērs (300, 300); x = 0; y = 0; } void draw () {fons (234, 113, 107); noStroke (); x = peleX; y = peleY; elipse (x, y, 50, 50); }

[/cceN_cpp]

mouseX var iegūt peles x koordinātu, bet mouseY var iegūt y koordinātu.

• Mēģināsim mainīt pozitīvo un negatīvo simbolu vai apmainīties ar mouseX un mouseY.

15. solis: beigas

Izmantojot šīs pazīstamās komandas, jūs, iespējams, varēsit veikt grafikas kustību. Izmantojot pēdējās nodaļas saturu, pareizi izmantojiet savu iztēli, jūs varat izveidot daudz interesantu animētu efektu.

Nākamajā nodaļā mēs varam redzēt daudz vairāk piemēru. Tajā pašā laikā mēs izmantosim matemātiskās funkcijas un apvienosim to ar grafisko kustību.

Šis raksts nāk no dizainera Venzi.

16. darbība. Relatīvie rādījumi:

Interesanti programmēšanas norādījumi dizainerim-sākotnējā pieskāriena apstrāde

Interesanti programmēšanas norādījumi dizainerim-izveidojiet savu pirmo apstrādes programmu

Šis raksts ir no:

Ja jums nepieciešama palīdzība, varat sazināties: [email protected].