Kagiliw-giliw na Patnubay sa Programming para sa taga-disenyo - Kunin ang Iyong Pagpapatakbo ng Larawan (Ikalawang Bahagi): 8 Mga Hakbang

2024 May -akda: John Day | [email protected]. Huling binago: 2024-01-30 13:10

Ang Math, para sa karamihan sa inyo, parang walang silbi. Ang pinaka-karaniwang ginagamit sa ating pang-araw-araw na buhay ay idagdag lamang, ibawas, i-multiply at hatiin. Gayunpaman, ito ay lubos na naiiba kung maaari kang lumikha sa programa. Mas alam mo, mas kahanga-hangang resulta na makukuha mo.

Hakbang 1: Kilusan at Pag-andar

Hayaan akong ipakita sa iyo ang maraming mga hindi kilalang mga larawan upang pasiglahin ang iyong panlasa.

Ano ito? Ngayon lamang panatilihin ang katanungang ito muna at huli ay malalaman mo at magagamit mo ito.

Sa huling kabanata, natutunan namin ang pag-setup ng pag-andar at pagguhit ng pag-andar, na maaaring gawing pabago-bago ang mga static na graphics. Gayunpaman, ang format ng paggalaw na ito ay masyadong simple. Gagamitin namin ang kaalaman sa pag-andar na pinagkadalubhasaan natin dati upang patakbuhin ang aming mga graphic sa kanilang sariling karakter.

Ilan ang mga pagpapaandar na maaari mong makilala mula sa mga larawan sa itaas? Ano ang uri ng ugnayan na mayroon sila sa paggalaw? Ngayon ay kunin natin ang isang quadratic function mula rito, magdagdag ng ilang mga parameter nang sapalaran at tingnan kung ano ang mangyayari. Halimbawa, y = x² / 100.

Ito ang hitsura ng imahe ng pag-andar. Kopyahin ang code sa ibaba.

[cceN_cpp tema = "bukang-liwayway"] float x, y; walang bisa ang pag-setup () {laki (300, 300); background (0); x = 0; } walang bisa na pagguhit () {stroke (255); strokeWeight (2); y = pow (x, 2) / 100.0; // Ang function pow ay babalik sa ika-n na lakas ng numero ng pagtatalaga. (x, 2) kumakatawan sa parisukat ng x. Ang unang parameter ay ang base number at ang pangalawa ay ang index. point (x, y); x ++; } [/cceN_cpp]

Tumatakbo na Epekto

Susunod, piliin ang kasalanan sa pagpapaandar. Formula: y = 150 + kasalanan (x).

Kopyahin ang sumusunod na code.

[cceN_cpp tema = "bukang-liwayway"] float x, y; walang bisa ang pag-setup () {laki (300, 300); background (0); x = 0; } void draw () {y = taas / 2 + sin (radians (x)) * 150; // Function radian ibahin ang anyo ng x sa anggulo. x ++; stroke (255); strokeWeight (2); point (x, y); } [/cceN_cpp]

Tumatakbo na Epekto

Ito ang graphic na nakukuha namin pagkatapos na mapatakbo ang code. At iyon ang kanilang mga track ng paggalaw. Kung ikukumpara sa dating isa, halata ang resulta. Ang imahe ng pagpapaandar ay talagang naaayon sa track ng paggalaw! Ito ay sapat na simple. Kailangan mo lang palitan ang halaga ng x, y sa coordinate. Ang dating track na iguhit namin ay katumbas ng graphic ng pagpapaandar y = x² / 100. Habang ang huli na track ay katumbas ng graphic ng pagpapaandar y = 150 + sin (x). Ngunit sa programa, ang direksyon ng y axle ay kabaligtaran. Kaya, kung ihahambing sa orihinal na graphic, ang track ay babaligtad. Ngayon, sa palagay ko dapat mayroon kang isang pakiramdam na ang ilang mga mahihirap na katanungan na pinagmumultuhan sa iyong ulo nang mahabang panahon ay malulutas kaagad. Kamangha-mangha na ang mga kamangha-manghang pag-andar na natutunan natin bago ito ay maaaring magamit upang makontrol ang paggalaw ng grapiko!

Hakbang 2: Upang Isulat ang Pag-andar

Nakalista ako ng maraming madalas na pag-andar sa ibaba. Inaasahan kong makakatulong ito sa amin upang isalin ang mga pag-andar sa code na maaaring makilala ng computer.

Samakatuwid, ang pormula sa ibaba sa programa ay dapat isulat na ganito:

y = x² → y = pow (x, 2) o y = sq (x)

y = x³ → y = pow (x, 3)

y = xⁿ → y = pow (x, n)

y = 4ⁿ → y = pow (4, n)

y ＝ logₑ² → y = log (2)

y = e² → y = exp (2)

y = √5 → y = sqrt (5)

Maaari mo ring random na magsulat ng isang pagpapaandar sa programa at makita kung ano ang magiging hitsura ng track ng paggalaw nito. Tandaang isaalang-alang ang saklaw ng patlang ng halaga at kahulugan ng domain, o mauubusan ng iyong screen ang iyong graphic.

TrigonometricFunction

Ngayon, magpatuloy tayo upang malaman ang ilang mga pagsusulat ng mga trigonometric function.

Kailangan nating bigyang pansin na sa programa ang pag-input ng parameter ng pag-andar na kaugnay sa anggulo ay gumagamit ng radian. Sa gayon ang sin90 ° ay isusulat sa kasalanan (PI ／ 2). Kung hindi ka pamilyar sa pamamaraang ito, maaari mong gamitin ang mga function randian upang ibahin ang anyo ng anggulo sa radian, at pagkatapos ay isulat ang sin （radians (90)).

Ang paggamit ng mga degree na pag-andar ay medyo kabaligtaran. Maaari nitong baguhin ang radian sa anggulo. Input print (degree (PI / 2)) nang direkta sa lugar ng pag-edit, at tingnan kung ano ang makukuha mo.

Hakbang 3: Kontrolin ang Kilusan ng Grapiko Sa Trigonometric Function

Narito ang isang kaso para makita mo ang aktwal na epekto ng paggalaw ng grapiko.

[cceN_cpp tema = "bukang-liwayway"] float x, y; walang bisa ang pag-setup () {laki (700, 300); } walang bisa na pagguhit () {background (234, 113, 107); y = kasalanan (radians (x)) * 150 + 150; x ++; noStroke (); ellipse (x, y, 50, 50); } [/cceN_cpp]

Ang pagpapaandar ng kasalanan ay isang pana-panahong pag-andar. Ang pinakamaliit na halaga nito ay －1, at ang maximum na halaga ay 1. Ang taas ng screen ay 300. Sumangguni sa y = sin (radians (x)) * 150 + 150, samakatuwid ang saklaw ng pagbabago ng halagang y ay mahusay na makokontrol sa loob ng 0 hanggang 300.

Umiikot na Circle

Sa gayon, sa wakas ay napunta kami sa pinaka-import na bahagi sa kabanatang ito. Paano iguhit ang isang landas ng bilog sa isang programa? Paano gamitin ang mga pagpapaandar upang maipakita ito? Hayaan mong ipakita ko sa iyo ang dalawang larawan na nakita natin sa simula ng artikulong ito muli.

Sa totoo lang nalantad nilang biswal ang ugnayan sa pagitan ng sirkulasyon ng koordinasyon at pag-andar ng trigonometric. Ang paggalaw sa mga larawan sa itaas ay hinihimok ng patuloy na pagtaas ng independiyenteng variable θ. Ang kaliwa ay ang imahe ng pag-andar ng kasalanan at cos, at ang kanan ay nangangahulugang isang punto na gumagawa ng pabilog na paggalaw matapos ma-map. Hindi ba ito matalino? Hindi na ito mahiwaga. Maaari mong gamitin ang code upang mapagtanto ito.

Isang simpleng halimbawa:

[cceN_cpp tema = "bukang-liwayway"] float x, y, r, R, anggulo; walang bisa ang pag-setup () {laki (300, 300); r = 20; // Circle diameter R = 100; // Radius ng paggalaw ng landas x = 0; anggulo = 0; y = taas / 2; } walang bisa na pagguhit () {background (234, 113, 107); isalin (lapad / 2, taas / 2); // Ilipat ang orihinal na point sa screen center. noStroke (); x = R * cos (anggulo); y = R * kasalanan (anggulo); ellipse (x, y, r, r); anggulo + = 0.05; } [/cceN_cpp]

Tingnan mo! Lumilitaw ang isang umiikot na bilog! Dito, ang independiyenteng variable ay wala na sa patuloy na pagtaas ng bit maging anggulo (katumbas ng θ sa larawan). Ito ay paninindigan para sa anggulo. Kabilang dito, xy ay medyo nagparami ng coefficient R, na humahantong sa pagpapahaba ng radius ng paggalaw ng bilog (R ay para sa radius). Kung hindi ito magpaparami ng R, ang landas ng paggalaw nito ay limitado sa loob ng saklaw mula -1 hanggang 1.

Bakit hindi gamitin ang pagtaas ng x? Ayon sa pag-aari mismo ng pag-andar, ang anumang x sa loob ng kahulugan ng domain ay may tanging y upang maitugma ito. Kaya sa system na hugis-parihaba na koordinasyon ng dimensyon na sukat, hindi mo malalaman ang isang "simpleng pag-andar" upang direktang gumuhit ng bilog. Iyon ay upang sabihin na hindi na natin magagamit ang format na ito.

y = (Ang hindi kilalang pagpapahayag ng x?);

x ＋＋;

Kaya kailangan nating baguhin ang ating ideya. Pumili ng isa pang anggulo bilang independiyenteng variable, at pagkatapos ay gamitin ang function sin at cos upang ibahin ito sa pahalang at patayong coordinate.

x = R * cos (anggulo);

y = R * kasalanan (anggulo);

anggulo + = 0.05;

Ang ilan sa inyo ay maaaring magtaka kung bakit ito maaaring ipakita ang landas ng paggalaw ng bilog. Ayon sa kahulugan ng pag-andar ng trigonometric, madali nating maituwiran na ang paggana ay nagkakasala sa ratio ng kabaligtaran na bahagi sa hypotenuse; Ang function cos ay ang ratio ng katabi ng hypotenuse. Hindi mahalaga kung nasaan ang punto ng bilog, ang r (radius) ay mananatiling hindi nagbabago. Samakatuwid maaari nating tapusin ang pagpapahayag ng x coordinate at y coordinate.

Dahil dito ay hindi isang gabay sa matematika, narito na titigil ako sa pagpapakita ng higit pang kaalaman tungkol sa pagpapaandar ng trigonometric sa iyo. Kung nais mong malaman ito o nakalimutan mo lang ito, maaari mong subukang suriin itong muli at kayo mismo.

Siyempre, ayos lang kung hindi mo ito lubos na maunawaan. Kailangan mo lamang malaman kung paano gamitin ito upang gumuhit ng isang bilog. Ito ay isang uri ng "ideya ng programa" din. Sa paglaon, madalas naming mahihiling ang ilan sa mga umiiral na mga module na ginawa ng iba upang mapagtanto ang isang tiyak na uri ng pag-andar. Huwag lamang itulak ang iyong sarili na malaman ito nang detalyado.

Gayunpaman, ang kasalanan sa pag-andar at cos ay karaniwan. Kung nais mong gumawa ng mas mataas na antas ng paglikha, mas mahusay mong subukang malaman ito nang lubusan. Kung ang katanungang ito mismo ay maaaring humimok sa ating sarili upang malaman ang higit na kaalaman sa matematika, maraming mga kagiliw-giliw na bagay na naghihintay para sa iyo na maghukay.

Ito ang mga larawan na malapit na nauugnay sa pagpapaandar ng trigonometric.

Hakbang 4: Sistema ng Coordinate ng Pagkilos

Ang mga nakaraang epekto ay tungkol sa mga pagbabago sa coordinate ng graphic. Ang sistema ng coordinate mismo ay static. Talagang maaari nating gawin ang koordinasyon na paglipat upang mapagtanto ang pang-aksyon na epekto. Ito ay tulad ng mga tao sa tabing-dagat na pinapanood ang ibang mga tao sa bangka. Para sa mga tao sa bangka, ang bangka ay static. Ngunit paano kung ang bangka mismo ay gumagalaw, kung gayon ang mga tao sa bangka ay gumagalaw kasama nito. Ang mga dating kaso ay tungkol sa "mga taong tumatakbo sa bangka". Sa totoo lang, hindi gumagalaw ang bangka. Ang sumusunod ay ilang mga karaniwang pag-andar para sa pagbabago ng coordinate system.

Pag-andar isalin

Pag-translate ng pagpapaandar, napag-usapan na namin dati, ay ginagamit upang ilipat ang koordinasyon ng system ng graphic nang pahalang.

Format ng pag-apply:

isalin (a, b)

Ang unang parameter ay nangangahulugang paglipat sa positibong direksyon ng x axle para sa isang pixel. Ang pangalawang parameter ay nangangahulugang paglipat sa positibong direksyon ng y axle para sa mga b pixel.

Ihambing ang dalawang code at subukang makahanap ng anumang pagkakaiba. (Upang gawing simple ang code, maaari naming tanggalin ang laki ng pag-andar, ang lapad ng screen at taas ay na-default na maging 100.)

Bago namin gamitin:

ellipse (0, 0, 20, 20);

Pagkatapos naming magamit:

isalin (50, 50);

ellipse (0, 0, 20, 20);

Paikutin ang pagpapaandar

Format ng pag-apply:

paikutin (a)

Ginagamit ito sa umiikot na sistema ng coordinate. Kapag positibo ang parameter, pipiliin nito ang orihinal na punto bilang gitnang punto at paikutin sa direksyon sa direksyon ng relo. Ang input ng parameter ay pareho sa pagpapaandar ng trigonometric upang magamit ang radian.

Bago gamitin:

ellipse (50, 50, 20, 20);

Pagkatapos gamitin:

paikutin (radian (30));

ellipse (50, 50, 20, 20);

Epekto sa programa ay upang paikutin ang bilog sa paligid ng point ng coordinate center sa direksyon ng direksyon ng relo para sa 30 degree.

Sukat ng pagpapaandar

Format ng pag-apply:

sukatan (a)

Ang pagpapaandar na ito ay maaaring mag-zoom out ng coordinate system. Ang halaga ay para sa pag-scale. Kapag ang parameter ay lampas sa 1, pagkatapos ay mag-zoom in; kung ito ay mas mababa sa 1, pagkatapos ay mag-zoom out.

Bago gamitin:

ellipse (0, 0, 20, 20);

Pagkatapos gamitin:

sukat (4);

ellipse (0, 0, 20, 20);

Ang bilog sa larawan sa itaas ay pinalakas sa apat na beses ng orihinal na laki. Gayundin, maaari mong gamitin ang dalawang mga parameter upang mag-zoom out sa x axle at y axle na direksyon nang magkahiwalay.

sukat (4, 2);

ellipse (0, 0, 20, 20);

Superposisyon ng Pag-andar ng Pagbabago

Dito, ang superposisyon ay tungkol sa mga pagbabago na may kaugnayan sa kasalukuyang sistema ng coordinate. Sa madaling salita, ang mga epekto ay maaaring mapangibabaw.

isalin (40, 10);

isalin (10, 40);

ellipse (0, 0, 20, 20);

Ang huling epekto ay katumbas ng

isalin (50, 50);

ellipse (0, 0, 20, 20);

Parehas upang gumana paikutin

paikutin (radian (10));

paikutin (radian (20));

ellipse (50, 50, 20, 20);

Katumbas ng

paikutin (radian (30));

ellipse (50, 50, 20, 20);

Parehong function scale at paikutin ang center sa orihinal na point to scale at rotate. Kung nais nating makuha ang paikutin na epekto sa isang gitnang posisyon sa (50, 50), kailangan nating mag-isip sa kabaligtaran na paraan. Una ilipat ang orihinal na punto sa posisyon ng (50, 50), pagkatapos ay idagdag ang umiikot na pagpapaandar ng pagbabago. Panghuli gawin ang iyong graphic na ipininta sa orihinal na punto.

Bago gamitin:

ellipse (50, 50, 50, 20);

Pagkatapos gamitin:

isalin (50, 50);

paikutin (radian (45));

ellipse (0, 0, 50, 20); // Upang makita ang pag-ikot ng pagbabago ng anggulo, gumawa kami ng isang hugis-itlog.

Maaaring parang umiikot ito. Kailangan mo lang magsanay ng higit pa at mauunawaan mo ito. (Maaari mo ring subukang baguhin ang pagkakasunud-sunod ng pag-andar na isalin at paikutin upang makita ang pagkakaiba.)

Pahalang na Kilusan at Kilusan ng Paikot

Sa mga sumusunod na kaso, malalaman natin ang epekto ng paggalaw sa pamamagitan ng pagbabago ng sistema ng pagsama. Sa parehong oras, nais kong hilingin sa iyo na sumangguni sa dating halimbawa ng kabanata. Karamihan sa mga oras, mahahanap mo upang mapagtanto ang isang tiyak na uri ng epekto, maaari mong gamitin ang isang ganap na naiibang pamamaraan.

Hakbang 5: Pahalang na Kilusan

[cceN_cpp tema = "bukang-liwayway"]

int x, y; walang bisa ang pag-setup () {laki (300, 300); x = 0; y = taas / 2; } walang bisa na pagguhit () {background (234, 113, 107); noStroke (); isalin (x, y); ellipse (0, 0, 50, 50); x ++; } [/cceN_cpp]

Ang coordinate ng bilog ay hindi binago ngunit ang coordinate system nito ay binago.

Paikutin ang Kilusan

[cceN_cpp tema = "bukang-liwayway"] float r, R, anggulo; walang bisa ang pag-setup () {laki (300, 300); r = 20; // Dimensyon ng bilog R = 100; // Radius ng track ng paggalaw} walang bisa na pagguhit () {background (234, 113, 107); isalin (lapad / 2, taas / 2); // Ilipat ang orihinal na point sa screen center. paikutin (anggulo); noStroke (); ellipse (0, R, r, r); anggulo + = 0.05; } [/cceN_cpp]

Hindi ba ito mas malinaw at simple kaysa sa trigonometric function? Maaari kang magkaroon ng isang katanungan dito. Dalhin bilang isang halimbawa ang umiikot na code. Malinaw na, ang tinukoy sa itaas na pag-andar ng pagbabago ay kamag-anak at pinapayagan ang superimposition. Kung nagsusulat kami ng isalin (lapad / 2, taas / 2) sa pagguhit ng pag-andar, hindi ba nangangahulugan ito na tuwing gumana ang paggana ng pagpapaandar ng isang beses nang sabay-sabay, ang coordinate system ay lilipat ng isang distansya sa kanang direksyon sa ibaba mula sa orihinal na base? Makatuwirang hindi ito mananatili sa gitna ng screen magpakailanman.

Maaari mong maunawaan sa ganitong paraan. Sa sandaling ang code sa pagguhit ng function ay nakumpleto ang isang operasyon mula sa hanggang sa ilalim, ang sistema ng coordinate ay babalik sa paunang katayuan sa pangalawang operasyon. Ang orihinal na punto ng coordinate system ay mai-default upang bumalik sa kaliwang tuktok na sulok. Kaya kung nais naming gawing patuloy na nagbabago ang sistema ng coordinate, ang mga parameter ng anggulo sa loob ng pag-andar na paikutin ay patuloy na tataas ang halaga nito.

I-access ang Katayuan ng Coordinate

Minsan, hindi namin nais na ang pagbabago ng katayuan ng coordinate system ay nakabatay sa dating isa. Sa oras na ito, kailangan nating gamitin ang function na pushMatrix at popMatrix. Ang dalawang pag-andar ay karaniwang lilitaw sa mag-asawa. Ang pagpapaandar na pushMatrix ay bago ang popMatrix. Hindi sila maaaring magamit lamang, o magkamali.

Halimbawa:

[cceN_cpp tema = "bukang-liwayway"] pushMatrix (); // Store coordinate system status translate (50, 50); ellipse (0, 0, 20, 20); popMatrix (); // Basahin ang koordinasyon ng katayuan ng system (0, 0, 20, 20); [/cceN_cpp]

Sa halimbawang ito, bago gamitin ang translate (50, 50), gumagamit kami ng function na pushMatrix.to iimbak ang kasalukuyang katayuan ng coordinate system. Ito, sa parehong oras, ang paunang katayuan. Pagkatapos naming gumuhit ng isang bilog, pagkatapos ay ipatupad ang popMatrix, babalik ito sa katayuang ito. Sa oras na ito, ipatupad ang pag-andar ng pag-andar, makikita mo na hindi ito nagdusa ng impluwensya mula sa pag-translate ng function sa halip ay gumuhit ito ng isang parisukat sa kaliwang tuktok na sulok ng orihinal na punto.

Bukod, payagan ang pushMatrix at popMatrix na manaugin.

Halimbawa

pushMatrix ();

pushMatrix ();

popMatrix ();

popMatrix ();

Upang maipakita nang maigi ang ugnayan nito, pipiliin namin ang format na condense.

Pinagsamang Kilusan o Kilusan sa Kilusan?

Ngayon nagsisimula ang pangalawang alon ng mahalagang bahagi. Subukan mo lamang na itulak. Dati, gumamit kami ng isang talinghaga ng bangka at mga tao. Naisip mo ba kung ano kung gagawin natin ang parehong tao at ang bangka na lumipat, anong uri ng pakiramdam ang magkakaroon ng mga tao sa tabing dagat?

Tulad ng pagsamahin ang pahalang na paggalaw sa umiikot na kilusan ng coordinate system. Ang punto dito ay talagang lumilipat sa isang direksyon lamang.

[cceN_cpp tema = "bukang-liwayway"] int x, y; anggulo ng float; walang bisa ang pag-setup () {laki (300, 300); background (234, 113, 107); noStroke (); x = 0; // Kapag ang paunang halaga ng x ay 0, maaari nating mapabayaan ang pangungusap na ito ng code. Kapag nagdeklara ng variable, ang default na halaga ay 0. y = 0; // Parehas sa nabanggit. anggulo = 0; // Parehas sa nabanggit. } walang bisa na pagguhit () {anggulo + = 0.25; y--; isalin (lapad / 2, taas / 2); pushMatrix (); paikutin (anggulo); ellipse (x, y, 5, 5); popMatrix (); } [/cceN_cpp]

At may pabilog na kilusan at iugnay ang pag-scale ng system.

[cceN_cpp tema = "bukang-liwayway"] float x, y, anggulo; walang bisa ang pag-setup () {laki (300, 300); background (234, 113, 107); noStroke (); } walang bisa na gumuhit () {anggulo + = 0.01; x = kasalanan (anggulo) * 100; y = cos (anggulo) * 100; isalin (lapad / 2, taas / 2); pushMatrix (); sukat (1 + 0.1 * kasalanan (anggulo * 10)); ellipse (x, y, 5, 5); popMatrix (); } [/cceN_cpp]

Huwag lokohin nito! Ang bilog na point ay talagang gumagawa ng pabilog na paggalaw. Hindi mahirap maunawaan kung ihinahambing namin ito sa pag-scale sa isang video camera. Ang isang video camera na patuloy na gumagalaw sa harap o likod ay pagbaril ng isang punto sa pabilog na paggalaw.

Nagulat? Ang mga ito ay simpleng pangunahing pag-andar. Ngunit sa magkakaibang kumbinasyon, makakagawa kami ng napakaraming iba't ibang mga epekto. Hanggang ngayon, tumitigil ang aking pagkakalantad upang makatipid ng ilang silid para sa iyong paggalugad.

Hakbang 6: Komprehensibong Paggamit

Malapit na itong magtapos para sa kabanatang ito. Ang huling dalawang kabanata, ipinakilala ko ang pangunahing pamamaraan ng paggalaw ng grapiko. Naniniwala ako na maaari kang magkaroon ng isang mas malalim na pag-unawa para dito, kumpara sa iyong mga paunang ideya. Huling sa pinakamaliit, narito ang ilang nakumpletong halimbawa para sa iyong sanggunian.

[cceN_cpp tema = "bukang-liwayway"] lumutang x1, y1, x2, y2, r, R; float anggulo1, anggulo2; walang bisa ang pag-setup () {laki (300, 300); r = 12; R = 120; anggulo1 = 0; anggulo2 = PI / 4; } walang bisa na pagguhit () {background (234, 113, 107); noStroke (); isalin (lapad / 2, taas / 2); anggulo1 + = 0.02; anggulo2 + = 0.06; x1 = R * sin (anggulo1); y1 = R * cos (anggulo1); x2 = R / 2 * kasalanan (anggulo2); y2 = R / 2 * cos (anggulo2); ellipse (x1, y1, r / 2, r / 2); ellipse (x2, y2, r, r); ellipse (-x1, -y1, r / 2, r / 2); ellipse (-x2, -y2, r, r); ellipse (x1, -y1, r / 2, r / 2); ellipse (x2, -y2, r, r); ellipse (-x1, y1, r / 2, r / 2); ellipse (-x2, y2, r, r); stroke (255); strokeWeight (3); linya (x1, y1, x2, y2); linya (-x1, -y1, -x2, -y2); linya (x1, -y1, x2, -y2); linya (-x1, y1, -x2, y2); } [/cceN_cpp]

Ang halimbawang ito ay hindi naglalaman ng anumang kaalaman na lampas sa naunang ipinakilala na kabanata.

Para sa aling mga puntos ang tumutugma? Aling mga linya ang tumutugma? Hindi ko rin mawari. Ngunit naalala ko na nagmula ito sa isang maliit na seksyon ng code.

Ito ang likas na katangian ng paggalaw nito. Ang mga linya ng natitira ay mirror effect lamang. Kung magpapatuloy ka sa pagsunod sa patnubay na ito, maaari kang gumawa ng isang na-update na bersyon at magdagdag ng isang tagakontrol sa iyong graphic upang mabago ang iyong katayuan sa paggalaw ng graphic sa real time.

Ang kagiliw-giliw na punto ng programa ay nakasalalay sa na maaari mong disenyo o pagsamahin ang mga regulasyon. Gayunpaman, kung ano ang magiging panghuling programa ay depende sa iyong kakayahan. Karaniwan ang mga taga-disenyo ay may malakas na imahinasyong graphic. Maaari mong i-sketch ang isang larawan sa iyong ulo, at pagkatapos ay subukang isalin ito sa code. Gayundin, maaari kang magsimula mula sa code at mga regulasyon mismo, mga pagpapaandar sa disenyo at variable na nais. Naaalala ba ang Pagproseso ay ang iyong sketch at ang code ay ang iyong mga brush! I-spray lamang ang iyong mga ideya nang malaya!

Hakbang 7: WAKAS

Huling sa aming kabanata, bumalik tayo sa isang tanong na napanatili natin nang mahabang panahon mula pa noong simula. Ano ang paggamit ng paggastos ng labis na pagsisikap upang makagawa ng isang larawan kasama ng programa? Matapos mong malaman ang kabanatang ito, mahahanap mo na maraming mga pamamaraan sa paglalaro na naghihintay para sa iyong galugarin.

[cceN_cpp tema = "bukang-liwayway"] float browX, earD, eyeD, faceD; walang bisa ang pag-setup () {laki (500, 500); } walang bisa na pagguhit () {background (200, 0, 0); browX = 150 + kasalanan (frameCount / 30.0) * 20; taingaD = 180 + kasalanan (frameCount / 10.0) * 20; eyeD = 60 + kasalanan (frameCount / 30.0) * 50; mukhaD = 300; strokeWeight (8); ellipse (175, 220, taingaD, taingaD); ellipse (lapad - 175, 220, taingaD, taingaD); tumbong (100, 100, mukhaD, mukhaD); linya (kilayX, 160, 220, 240); linya (lapad-kilayX, 160, lapad-220, 240); punan (random (255), random (255), random (255)); ellipse (175, 220, eyeD, eyeD); ellipse (lapad-175, 220, eyeD, eyeD); punan (255); point (lapad / 2, taas / 2); tatsulok (170 - cos (frameCount / 10.0) * 20, 300 - sin (frameCount / 10.0) * 20, lapad - (170 + cos (frameCount / 10.0) * 20), 300 + sin (frameCount / 10.0) * 20, 250, 350); } [/cceN_cpp]

Hindi ba mahika para sa pabuong graphic? Dito hindi ako masyadong nagpapakita sa iyo ng mga kaso. Maaari kang mag-disenyo ng isang mas mahusay na epekto kaysa sa akin. Ang bentahe ng pagguhit sa programa ay umiiral na maaari mong i-play sa bawat pixel. Dahil ang iyong graphic ay hindi bitmap, ang bawat pangunahing punto sa iyong graphic ay maaaring makontrol. Maaari itong mapagtanto ang ilang mga epekto na hindi mapagtanto ng ibang software.

Kung mayroon kang isang puso na nais na sirain ang lahat at pagsamahin ito muli, ang programa sa pag-aaral ay makakatulong sa iyo upang matupad ang ideyang ito.

Ang artikulong ito ay nagmula sa taga-disenyo na Wenzy.

Hakbang 8: Mga Kamag-anak na Pagbasa:

Kagiliw-giliw na Patnubay sa Programming para sa taga-disenyo - Pagproseso ng Paunang Pag-ugnay

Kagiliw-giliw na Patnubay sa Programming para sa taga-disenyo - Lumikha ng Iyong Unang Programa sa Pagpoproseso

Kagiliw-giliw na Patnubay sa Programming para sa taga-disenyo – Kunin ang Iyong Pagpapatakbo ng Larawan (Unang Bahagi)

Kung mayroon kang anumang mga katanungan, maaari kang magpadala ng isang email sa [email protected].

Ang artikulong ito ay mula sa: