Interessante programmeergeleiding vir ontwerpers-laat u prentjie loop (deel een): 16 stappe

2024 Outeur: John Day | [email protected]. Laas verander: 2024-01-30 07:28

Hardloop! Hardloop! Hardloop!

Programmering is nie so moeilik nie. Die belangrikste punt is om jou ritme te vind en dit een vir een te doen.

Voordat ek hierdie hoofstuk lees, hoop ek dat u reeds vertroud was met die basiese metode om funksies te teken, of dat u duiselig en verward voel deur twee groot kopfunksies: opstel en teken.

Aangesien ons bewegingsgrafika wil maak, moet ons weet hoe animasie vervaardig word.

Bogenoemde prentjie lyk redelik aantreklik en onthul die implementeringsbeginsel van animasie visueel.

Animasie is towerkuns. Dit is 'n magie oor visuele bedrog. Maar in hierdie inligting wat ontplof het, video -oorstromingsouderdom, was ons reeds daaraan gewoond. Min mense sal verbaas wees dat dit 'n wonderlike ding is om die animasie te kan sien.

Dieselfde beginsel kan toegepas word by die teken van animasie met die program. Ons moet oorweeg hoe om verskillende grafika in elke raam te teken, en die program sal outomaties blaai terwyl ons 'n voltooide animasie in ons kop aanvul. In die volgende hoofstuk sal ons praat oor hoe om basiese grafiese beweging te realiseer. Voor dit moet ons basiese kennis van veranderlikes ken.

Stap 1: Veranderlik

Veranderlik is die houer vir data. Dit kan herhaaldelik binne 'n program gebruik word.

Byvoorbeeld:

[cceN_cpp tema = "dagbreek"] grootte (500, 500); ellips (100, 250, 50, 50); ellips (200, 250, 50, 50); ellips (300, 250, 50, 50); ellips (400, 250, 50, 50);

[/cceN_cpp]

Hierdie gedeelte van die kode het geen veranderlikes gebruik nie. Dit trek vier sirkels in die skerm. Ons kan vind dat hulle dieselfde breedte en hoogte het. Noudat dit dieselfde is, om herhaalde data -invoer tot die minimum te beperk, kan ons 'n teken definieer om dit voor te stel. Hierdie teken is veranderlik.

Hier is die kode nadat u 'n veranderlike bygevoeg het:

[cceN_cpp tema = "dagbreek"] grootte (500, 500); int a = 50; ellips (100, 250, a, a); ellips (200, 250, a, a); ellips (300, 250, a, a); ellips (400, 250, a, a);

[/cceN_cpp]

Ons kry dieselfde resultaat!

Aangesien ons veranderlike a gedefinieer het, kan ons parameters gerieflik verander. As ons a = 50 verander in a = 100, dan word al die sirkels se breedte en hoogte 100 eenvormig. Ons hoef dus nie parameters een vir een te verander nie. Veranderlike is regtig 'n goeie uitvinding.

Stap 2: Die skep van veranderlike

Voordat ons 'n veranderlike gebruik, moet ons 'n verklaring aflê en die datatipe aanwys.

int ek;

ek ＝ 50;

Die eerste sin van die kode het 'n stelling gemaak vir 'n veranderlike i. int is 'n simbool wat hoofsaaklik gebruik word om veranderlike te verklaar. As dit verklaar word, sal dit 'n ruimte in die rekenaargeheue spaar, wat gelykstaande is aan die opwekking van 'n 'boks', spesiaal gebruik om heelgetaldata te herstel. Die tweede sin staan vir die maak van opdrag 50 wat geïmplementeer word deur veranderlike i. Na die implementering van hierdie sin word data stabiel in die veranderlike gestoor. Of u kan lui wees om die twee sin hierbo in een opdrag saam te voeg terwyl u verklaring aflê.

int i ＝ 50;

Dit is relatief gratis om 'n veranderlike te noem. Maar soms moet ons aandag gee aan iets.

Stap 3: Benoem regulering van veranderlike

• Dit moet die kombinasie van alfabet en onderstreep wees. Dit kan 'n simbool of 'n woord wees.

• Kassensitief. Naam en naam kan vir verskillende veranderlikes staan.

• Probeer om dit so maklik as moontlik te noem sodat u dit op een oogopslag kan verstaan. Die aanvanklike karakter moet 'n alfabet wees in plaas van 'n getal of 'n spesiale karakter.

• Geen sleutelwoorde soos int, float nie

Die volgende is 'n paar verkeerde stellings.

int $ a;

int 89b;

Hier is die korrekte stellings:

int r;

int super_24;

int openTheDoor;

Stap 4: Veranderlike tipe

Behalwe vir die verklaring van heelgetaldata, kan ons verklaar vir desimale data (ook floating point data genoem) met die sleutelwoord float.

vlot b = 0,5

Ons moet in gedagte hou watter tipe datatipe ons vir ons stelling gebruik het. As ons die sleutelwoord int gebruik het, kan laasgenoemde opdrag nie i ＝ 0.5 of iets dergeliks skryf nie, of kan die program 'n fout word. Maar as ons teenoorgestelde skryf, is dit reg. Float i = 5 is byvoorbeeld die regte grammatika, maar die program herken dit as desimale getal.

Sommige veranderlikes is reeds deur stelsel gedefinieer. Ons hoef dit nie self te verklaar nie. Net soos die voorheen verwys na "breedte, hoogte", sal dit outomaties die breedte en hoogte van die rekenaarskerm verkry. So 'n hoë gebruiksfrekwensie dat die ontwerper dit direk definieer as 'n standaardveranderlike om dit vir ons makliker te maak om te gebruik.

Stap 5: Operateur

Die volgende is operateurs van verwerking:

+ plus

- minus

* vermenigvuldig

verdeel

％ Module van die res

U moet al hierdie operateurs, behalwe %, ken. Dit lyk nogal vreemd, want die resultaat daarvan is die res. 9%3 is 0. Terwyl 9%5 4 is.

Operateurs kan gebruik word onder opdragte en veranderlikes.

[cceN_cpp tema = "dagbreek"] int a = 1; // verklaar heelgetal veranderlike a, opdrag is 1. int b = 2; // Verklaar heelgetal veranderlike b, opdrag is 2. int c; // Verklaar heelgetal veranderlike c. c = a + b; // Plus twee opdragte en ken die resultaat toe aan c. druk (c); // Uitset veranderlike c.

[/cceN_cpp]

Stap 6: Operasie resultaat:

Die uitsetresultaat word nie op die venster vertoon nie, maar in die konsole onderaan.

Die skryfmetode van die vierde reël lyk nogal vreemd. Maar dit is 'n algemene formaat wat gereeld tydens rekenaaropdragte gebruik word. Die linkerkant van die gelyke simbool moet die finale veranderlike wees, terwyl die regterkant die bewerkingsproses moet wees.

Die drukfunksie in die vyfde reël kan veranderlikes in die konsole uitdruk, wat gereeld gebruik word om die toestand van data -uitset te toets.

Stap 7: Bedryfsregulasie

'N Probleme by die verwerking is dat ons die tipe veranderlike moet verduidelik. Ons moet spesiale aandag skenk aan die proses van dryfpuntgetal en tipe heelgetal.

druk （6 /5）; // resultaat 1

Die werking tussen heelgetalle sal 'n nuwe heelgetal hê. 6 gedeel deur 5 is 1.2. Maar die uitslag van die program is 1. Dit is in stryd met ons intuïsie. Die program handel nie met ronde nie, maar verwyder die getal agter die desimale punt.

druk (6.0 / 5.0); // resultaat 1.2

'N Nuwe dryfpuntgetal sal lei tot werking tussen drywende punte. As die werklike resultaat 1.2 is, is die uitset van die program dieselfde.

druk (6 / 5.0); // resultaat 1.2

druk (6.0 / 5); // resultaat 1.2

Laastens is dit die mengsel van heelgetal en dryfpuntgetal. Die finale uitslaguitslag sal 1.2 wees.

• Eintlik moet u in gedagte hou dat die doel van hierdie regulasie -ontwerp is om nie die akkuraatheid van data te verloor nie. As een element dus 'n dryfpuntgetal is, sal die resultaat ook die dryfpuntnommer wees.

Stap 8: Opstelfunksie en tekenfunksie

Voorheen het ons 'n stapel grondkennis gepraat. Nou kom ons uiteindelik iets interessants speel. Die opstel en teken van funksies is gelykstaande aan die belangrikste funksies van die verwerking. Hierdie twee funksies is baie spesiaal. Dit kan die prosedure van die program beheer. 'N Vergelykend ingewikkelde program bevat hierdie twee funksies omdat dit die basiese raam vir die program is. Formaat:

ongeldige opstelling () {

}

nietige trekking () {

}

Die spesiale gebruik maak die oproepformaat anders as die ander funksies. Ons moet 'leegte' byvoeg voor die funksienaam, wat staan vir geen 'geretourneerde waarde' nie. Agter die funksienaam moet ons hakies en draadjies byvoeg.

[cceN_cpp tema = "dagbreek"] leemte -opstelling () {druk (1); } ongeldig trek () {druk (2); } [/cceN_cpp]

Kom ons kyk na 'n voorbeeld:

As u op die bedieningsknoppie druk, gee die konsole eerstens '1' uit en dan voortdurend '2' totdat u die stopknoppie ingedruk het of die venster toegemaak het.

Kode binne hakies in die opstelfunksie sal slegs vir een keer geïmplementeer word, terwyl kode binne funksie -teken voortdurend in omloop sal wees (standaard implementering 60 keer/sekonde).

As gevolg van hierdie karakter word die opstelling gewoonlik gebruik om die omgewingseiendom te begin, soos die breedte en hoogte van die skerm, agtergrondkleur en allerhande veranderlikes se toewysing. Terwyl ons dikwels tekenfunksies in funksie teken plaas om voortdurend veranderde grafika te genereer.

Stap 9: Omkring in horisontale beweging

Met funksie -teken kan ons ons animasies begin skep. Die metode om animasie -effek deur verwerking te skryf, is nogal 'ongemaklik'. Dit het geen bestaande opdrag nie. Gee byvoorbeeld 'n sekere vorm om kromlynig te maak.

Ons moet hierdie besonderhede self definieer. U moet die program vertel watter soort grafika elke raam beslis nodig het.

Skryf die volgende kode daarin (laat ons dit nou met die hand begin doen):

[cceN_cpp tema = "dagbreek"] int x; int y; ongeldige opstelling () {grootte (300, 300); x = 0; y = hoogte/2; } leegte trek () {agtergrond (234, 113, 107); noStroke (); ellips (x, y, 50, 50); x = x+1; }

[/cceN_cpp]

Hierdie gedeelte van die kode vertoon 'n bewegingsirkel. Die voormalige verklaarde veranderlike x, y word gebruik om die posisie van koördinaat op te slaan. Die opdragte word uitgevoer in funksie -opstelling. Die sleutelkode is die volgende in funksie -trekking:

x = x + 1

Moenie dit as 'n wiskundige vergelyking beskou nie, anders sal dit baie vreemd wees. Hier is '＝' 'n simbool vir opdrag. Dit verteenwoordig om die regte getalle in die linker veranderlike te plaas. Gestel x is 50, sodra die kode aan die gang is, is die regterkant van "＝" gelyk aan 50+1, dit wil sê 51. Die finale uitslag word in veranderlike x toegeken. Dus word die waarde van x 51.

Volg die prosedure van die program; elke keer dat funksie teken vir een keer werk, sal die waarde van x toeneem 1. Elke keer as ons teken, sal die sirkel 'n pixelrigting horisontaal na regs beweeg, in vergelyking met die vorige raam. Daarom word die grafiese beweging.

• Om kode beter leesbaar te maak, moet ons 'n sekere kamer spaar voor elke reël kode binne draadjies. En dit moet so in lyn wees as moontlik. Druk TAB of verskeie spasies, dit kan intrek.

• Die simbool van leë spasie en reëlbreuk in die program beïnvloed nie die program nie. Dit is dus goed as ons een of meer tik.

Hier is nog 'n eenvoudiger manier om dit uit te druk. Om die veranderlike sirkel outomaties 1 te laat toeneem, moet ons dit skryf in die volgende formaat.

sirkel ＝ sirkel ＋1

Nogal ongerieflik! As die naam van die veranderlike langer is, moet ons meer woorde tik. Ons lui voorgangers dink dus aan 'n idee soos hierdie.

sirkel ＋＋

Is dit nie baie eenvoudig nie? Dit beteken dat u 1 outomaties verhoog. Soortgelyk daaraan is daar - -, wat outomaties 1 verminder.

Maar as ons hoop dat die hoeveelheid outomatiese toename 'n ander getal soos 2 is, moet ons 'n ander uitdrukking probeer.

sirkel += 2

Dit is gelyk aan

sirkel = sirkel + 2

Net so is daar - ＝, /=, *=.

Stap 10: Bewegingsrigting

Watter rigting die grafiese beweeg, hang af van hoe u u koördinaat verander. As dit verander word na y ＝ y ＋ 1, sal die sirkel afwaarts beweeg. As bothx en y 1 toeneem, sal die sirkel na onder regs beweeg. As ons skryf dat dit 'n minus -simbool is, sal dit in die teenoorgestelde rigting beweeg.

[cceN_cpp tema = "dagbreek"] int x, y; // Kan verskeie veranderlikes op dieselfde tyd verklaar, gebruik komma om te skei. ongeldige opstelling () {grootte (300, 300); x = 0; y = 0; } leegte trek () {agtergrond (234, 113, 107); noStroke (); ellips (x, y, 50, 50); x ++; y ++; }

[/cceN_cpp]

Bewegingstempo

Onthou u die standaard 60 rame per sekonde binne funksie -trekking? Volgens hierdie tempo sal die sirkel hierbo 60 pixels per sekonde na regs beweeg.

As ons die grafiese bewegingsnelheid wil verander, is daar twee metodes: een is om die x -waarde elke keer te verhoog, aangesien dit verander sal word.

x ＝ x ＋ 10

Dit het die snelheid tien keer verbeter in vergelyking met die oorspronklike!

Die ander metode is om die frekwensie van die verversing van die doek te verander. frameRate ()

Hierdie funksie kan die uitsaaifrekwensie van die doek verander. Skryf frameRate (10) in die funksie -opstelling, dit verander die oorspronklike 60 rame per sekonde in 10 rame per sekonde. Die snelheid word 6 keer vertraag as voorheen.

Stap 11: Agtergrond wat uitkyk

Al die vorige voorbeelde skryf agtergrond in funksieteken. Het u al ooit daaraan gedink om dit in funksie -opstelling in te skryf? Sal daar enige verskille wees? Laat ons nou die voorbeeld van horisontale beweging bywerk.

[cceN_cpp tema = "dagbreek"] int x, y; ongeldige opstelling () {grootte (300, 300); agtergrond (234, 113, 107); x = 0; y = hoogte/2; } ongeldig trek () {noStroke (); ellips (x, y, 50, 50); x += 1; } [/cceN_cpp]

Wat het gebeur? Miskien kan dit nie die rede vir die produksie van die probleem behoorlik verstaan nie. Vee funksie noStroke uit, voeg weer 'n slag by en sien die bewegingspad van die sirkel.

O, dit is omdat die sirkel wat voorheen geskep is nie uitgevee is nie! Omdat die funksie -opstelling net een keer werk, as ons die agtergrond daarbo skryf, sal dit slegs een keer die agtergrond vul, en laasgenoemde het geen effek meer nie. Die agtergrond van die funksie is soos 'n verfemmer. Sodra dit gebruik is, dek dit alle inhoud op die doek in plaas van slegs 'n agtergrondkleur. Ons skryf dit voor funksie trek, sodat die vorige raam elke keer as ons 'n nuwe patroon skep, bedek sal word. Daarom kan die sirkel loop soos ons verwag het. Behalwe om die gebruike van elke funksie te onthou, moet ons nadink oor die posisie van die kode. Baie tyd, die opwaartse of afwaartse lyn vir die codea en om dit binne of buite 'n stut te skryf, het 'n heel ander effek. Die rigting van die kode is tweedimensioneel. As 'n fout verskyn, moet ons in hierdie twee dimensies kalibreer.

• Hierdie nie -herhaalde tekenmetode kan 'n baie spesiale effek skep as dit reg gebruik word. U kan die volgende kode kopieer en probeer.

[cceN_cpp tema = "dagbreek"] leemte -opstelling () {size (400, 400); } leegte teken () {ellips (breedte/2-mouseX, hoogte/2-mouseX, mouseY, mouseY); ellips (breedte/2-mouseX, hoogte/2+mouseX, mouseY, mouseY); ellips (breedte/2+mouseX, hoogte/2-mouseX, mouseY, mouseY); ellips (breedte/2+mouseX, hoogte/2+mouseX, mouseY, mouseY); } [/cceN_cpp]

Hier het ons die magiese veranderlike mouseX en mouseY gebruik. Ons sal later in detail daaroor praat.

Stap 12: Skud sirkel

Wat as ek die sirkel se bewegingsrigting onreëlmatig wil maak? Met slim willekeurige funksie, kan u ook hierdie effek besef. Willekeurig is 'n funksie wat gereeld gebruik word. Dit kan gebruik word om ewekansige funksie te genereer. Dit is soos 'n spoorlose gees. As u eers verband hou met veranderlikes, kan u nie dink wat volgende gaan word nie.

Roep formaat op:

ewekansig (hoog)

Hoog verteenwoordig die ewekansige boonste grens, en die standaard onderste limiet is 0. Byvoorbeeld, ewekansig (10). Dit sal willekeurig 'n getal van 0 tot 10 oplewer (0 is ingesluit, maar 10 is nie ingesluit nie).

ewekansig (laag, hoog)

As ons twee parameters stel, sal dit terugkeer na die ewekansige waarde tussen hulle, byvoorbeeld ewekansig (5, 10). Dit sal willekeurig 'n getal van 5 tot 10 oplewer (5 is ingesluit, maar 10 is nie ingesluit nie).

Voorbeeld:

[cceN_cpp tema = "dagbreek"] float x;

x = ewekansig (50, 100);

druk (x); [/cceN_cpp]

Elke keer as ons die program uitvoer, lewer die konsole verskillende waardes af.

• Let wel: Waardes wat deur funksie willekeurig geskep word, behoort tot die tipe swaai (desimale getal). As ons 'n waarde aan heelgetalveranderlike wil toewys, moet ons dit verander deur funksie int (). Die transformasie volg nie die rondte nie, maar verwyder die desimale deel direk. Dus het die uitset van int (random (5)) slegs 5 moontlikhede: 0, 1, 2, 3, 4.

Nadat ons vertroud is geraak met die gebruik van funksie willekeurig, kan ons direk in die onderstaande geval ingaan.

[cceN_cpp tema = "dagbreek"] int x, y; ongeldige opstelling () {grootte (300, 300); x = breedte/2; y = hoogte/2; } leegte trek () {agtergrond (234, 113, 107); noStroke (); x += int (ewekansig (-5, 5)); y += int (random (-5, 5)); ellips (x, y, 50, 50); }

[/cceN_cpp]

Die voormalige bygevoegde koördinaatwaardes is vasgestel. Slegs as ons 'n ewekansige waarde verhoog, sal die sirkel in 'n onbepaalde rigting beweeg. Met die groter ewekansige omvang, skud dit meer gereeld. Aangesien die waardeverandering tussen rame weerkaats word, sal die beweging nie meer glad wees nie. Terwyl die voormalige raam op (150, 150) is, sal laasgenoemde raam binne 'n blik na die posisie van (170, 170) beweeg.

Stap 13: Migrasiekring

Migrasiekring

Sal dit gladde beweging skep? Funksieruis kan ons help. Dit het 'n beter ritme as standaard ewekansig. En die ewekansige gegenereerde ewekansige getalle is voortdurend.

Roep formaat op:

geraas (t)

Funksieruis kan die uitsetbereik nie definieer nie. Die program definieer dat dit slegs swewende puntgetalle van 0 tot 1 kan genereer en vaste insette kan slegs vaste uitset hê.

[cceN_cpp tema = "dagbreek"] vlot x = geraas (5); float y = geraas (5); druk (x, y); [/cceN_cpp]

Omdat die bogenoemde invoerparameters 5 is, is die uitsetresultate dieselfde. Hoe kan u die resultaat dan verander? Die antwoord is om die invoerparameters dinamies te verander. Eintlik kan ons geraas as 'n onbeperkte stemspoor beskou; die invoerparameters is net soos 'die huidige tyd'. As die parameterinvoer deurlopend is, sal die uitset ook deurlopend wees.

[cceN_cpp tema = "dagbreek"] float x, y; leemte opstelling () {grootte (700, 100); x = 0; agtergrond (0); } leegte trek () {x += 1; y = geraas (frameCount/100.0)*100; noStroke (); ellips (x, y, 2, 2); }

[/cceN_cpp]

In hierdie geval teken ons die veranderingspad van Y sodat ons funksieruis beter kan verstaan.

• Onder dit sal veranderlike frameCount die huidige raam kry. Anders as die breedte, hoogte in die vorige, is dit stabiel sonder enige verandering. Boonop begin dit toeneem van 0. As ons dit verstaan deur ons aanvanklike grafiese weergawe, vertoon dit die bladsy waarna ons gekyk het (eerder na die tydsopvatting in die program).

• frameCount is heelgetal veranderlike. Verdeel deur 'n ander heelgetalveranderlike, sal die program standaard die resultaat as 'n heelgetal verwerk. Om die akkuraatheid van die resultaat te verbeter, moet ons 100 na 100.0 verander. Verdeel deur 'n dryfpuntgetal, kry ons ook 'n dryfpuntnommer.

• Om die Y -as van 0 na 100 te verander, moet ons die resultaat van geraas met 100 vermenigvuldig. Ons kan dus die willekeurige waarde -reeks beheer.

Sommige van u kan goed dink: "hoekom moet ons frameCountby 100 verdeel? Is dit nie reg om frameCount direk te skryf nie?" Natuurlik kan jy! Maar hier, om die kenmerke van funksieruis beter te vertoon, vertraag ons die "uitsaaitempo". Die onderstaande voorbeeld toon die veranderings in die uitsetwaarde onder verskillende veranderingstempo's.

[cceN_cpp tema = "dagbreek"] float x, y1, y2, y3, y4, y5; ongeldige opstelling () {grootte (700, 500); x = 0; agtergrond (0); } leegte trek () {x += 1; y1 = geraas (frameCount)*100; y2 = geraas (frameCount/10.0)*100; y3 = geraas (frameCount/100.0)*100; y4 = geraas (frameCount/1000.0)*100; y5 = geraas (frameCount/10000.0)*100; noStroke (); ellips (x, y1, 2, 2); ellips (x, y2+100, 2, 2); ellips (x, y3+200, 2, 2); ellips (x, y4+300, 2, 2); ellips (x, y5+400, 2, 2); beroerte (80); lyn (0, 100, breedte, 100); lyn (0, 200, breedte, 200); lyn (0, 300, breedte, 300); lyn (0, 400, breedte, 400); }

[/cceN_cpp]

U kan die veranderende parameters binne funksieruis as 'n voortgangsbalk beskou. Verander die parameter asof ons die vorderingsbalk skuif. As die veranderende omvang van hierdie "stemspoor" groter is, sal die voortdurende eienskappe van die uitsetwaarde voor en agter swakker wees. keer spoed, 20 keer spoed). As die omvang groter is as 'n sekere waarde, het dit geen groot verskil om lukraak te funksioneer by waardegenerering nie.

As u al die voorbeelde hierbo kan verstaan, sal u voel dat niks makliker is om 'n migrerende sirkel te teken nie. U kan ook die interne beginsels verstaan.

[cceN_cpp tema = "dagbreek"] float x, y; ongeldige opstelling () {grootte (300, 300); x = 0; } leegte trek () {agtergrond (234, 113, 107); x = geraas (frameCount/100.0 + 100)*300; y = geraas (frameCount/100.0)*300; noStroke (); ellips (x, y, 50, 50); }

[/cceN_cpp]

Nou, die beweging is meer interessant, net soos 'n roterende gyro.

• Die rede waarom veranderlike x binne funksiegeruis plus 100 moet wees, is omdat hulle dit vir 'n afstand moet skei. As die parameters van xy binne funksieruis dieselfde of redelik naby is, sal die verandering van x, y -koördinaat byna dieselfde wees. Dit is om die beweging baie meer lukraak te laat word.

Stap 14: Omkring deur muis verplaas

Vervolgens kom ons uiteindelik by twee veranderlikes waarvan ek die meeste hou: mouseX en mouseY. By die eerste aanblik van die twee opvattings skitter my oë van lig. Omdat dit die mees direkte manier is om met grafika te kommunikeer. Ons kan baie interessante programme daarmee saamstel.

Die saak is redelik eenvoudig:

[cceN_cpp tema = "dagbreek"] int x, y; ongeldige opstelling () {grootte (300, 300); x = 0; y = 0; } leegte trek () {agtergrond (234, 113, 107); noStroke (); x = muisX; y = muis Y; ellips (x, y, 50, 50); }

[/cceN_cpp]

mouseX kan x -koördinaat van die muis verkry, terwyl mouseY y -koördinaat kan verkry.

• Kom ons probeer om die positiewe en negatiewe simbool te verander, of om mouseX en mouseY uit te ruil.

Stap 15: Einde

Vanuit hierdie bekende opdragte kan u die beweging van grafika moontlik uitvoer. Met die inhoud van die laaste hoofstuk, gebruik u verbeelding behoorlik; u kan baie interessante geanimeerde effekte skep.

In ons volgende hoofstuk kan ons meer voorbeelde sien. Terselfdertyd gebruik ons wiskundige funksies en kombineer dit met grafiese beweging.

Hierdie artikel kom van ontwerper Wenzy.

Stap 16: Relatiewe lesings:

Interessante programmeergeleiding vir ontwerper-verwerking van eerste aanraking

Interessante programmeergeleiding vir ontwerpers-skep u eerste verwerkingsprogram

Hierdie artikel is afkomstig van:

As u hulp nodig het, kan u kontak: [email protected].