Programրագրավորման հետաքրքիր ուղեցույց դիզայների համար. Գործարկեք ձեր պատկերը (մաս առաջին). 16 քայլ

2024 Հեղինակ: John Day | [email protected]. Վերջին փոփոխված: 2024-01-30 09:53

Վազիր: Վազիր: Վազիր:

Programրագրավորումը այնքան էլ դժվար չէ: Հիմնական բանը `գտնել ձեր ռիթմը և դա անել մեկ առ մեկ:

Մինչև այս գլուխը կարդալը, հույս ունեմ, որ դուք արդեն ծանոթ եք հիմնական գործառույթների գծագրման մեթոդին, կամ գլխապտույտ և շփոթություն կզգաք գլխի երկու մեծ գործառույթներով ՝ կարգավորում և նկարում:

Քանի որ մենք ցանկանում ենք շարժական գրաֆիկա պատրաստել, մենք պետք է իմանանք, թե ինչպես է արտադրվում անիմացիան:

Վերոնշյալ պատկերը բավականին գրավիչ է թվում և տեսողականորեն բացահայտում է անիմացիայի իրականացման սկզբունքը:

Անիմացիան կախարդական է: Դա կախարդություն է տեսողական խաբեության մեջ: Այնուամենայնիվ, այս տեղեկատվությունը պայթեց, տեսանյութը հեղեղեց դարաշրջանում, մենք արդեն սովոր ենք դրան: Քիչ մարդիկ կզարմանան, որ անիմացիան տեսնելը զարմանալի բան է:

Նույն սկզբունքը կարող է կիրառվել ծրագրով անիմացիա նկարելու մեջ: Մենք պետք է հաշվի առնենք, թե ինչպես կարելի է յուրաքանչյուր շրջանակում նկարել տարբեր գրաֆիկա, և ծրագիրը ինքնաբերաբար կշրջի էջերը, մինչ մենք լրացնում ենք ավարտված անիմացիան մեր գլխում: Հաջորդ գլխում մենք կխոսենք այն մասին, թե ինչպես իրականացնել հիմնական գրաֆիկական շարժումը: Մինչ այդ, մենք պետք է որոշ հիմնական գիտելիքներ իմանանք փոփոխականների մասին:

Քայլ 1: Փոփոխական

Փոփոխական է տվյալների կոնտեյները: Այն կարող է բազմիցս օգտագործվել ծրագրի շրջանակներում:

Օրինակ:

[cceN_cpp theme = "լուսաբաց"] չափ (500, 500); էլիպս (100, 250, 50, 50); էլիպս (200, 250, 50, 50); էլիպս (300, 250, 50, 50); էլիպս (400, 250, 50, 50);

[/cceN_cpp]

Կոդի այս հատվածը չի օգտագործել որևէ փոփոխական: Այն նկարում է չորս շրջանակ էկրանին: Մենք կարող ենք գտնել, որ նրանք ունեն նույն լայնությունը և բարձրությունը: Այժմ, երբ միևնույն է, տվյալների կրկնվող մուտքագրումը նվազագույնի հասցնելու համար մենք կարող ենք սահմանել այն ներկայացնող նշան: Այս նշանը փոփոխական է:

Ահա փոփոխական ավելացնելուց հետո ծածկագիրը.

[cceN_cpp theme = "լուսաբաց"] չափ (500, 500); int a = 50; էլիպս (100, 250, ա, ա); էլիպս (200, 250, ա, ա); էլիպս (300, 250, ա, ա); էլիպս (400, 250, ա, ա);

[/cceN_cpp]

Մենք ստանում ենք բոլորովին նույն արդյունքը:

Քանի որ մենք սահմանել ենք փոփոխական a, մենք կարող ենք հարմարավետորեն փոխել պարամետրերը: Եթե a = 50 -ը փոխենք a = 100 -ի, ապա բոլոր շրջանակների լայնությունն ու բարձրությունը 100 կդառնան միատեսակ: Այսպիսով, մենք չպետք է պարամետրերը փոխենք մեկ առ մեկ: Փոփոխականն իսկապես լավ գյուտ է:

Քայլ 2: Փոփոխականի ստեղծում

Փոփոխականն օգտագործելուց առաջ մենք պետք է կազմենք հայտարարություն և նշենք դրա տվյալների տեսակը:

int i;

ես 50 ֆունտ;

Կոդի առաջին նախադասությունը կազմել է i փոփոխականի համար հայտարարություն: int- ը խորհրդանիշ է, որը հիմնականում օգտագործվում է փոփոխական հայտարարելու համար: Հայտարարելիս այն կխնայի համակարգչի հիշողության մեջ գտնվող սենյակը, որը համարժեք է «տուփ» առաջացնելուն, որը հատուկ օգտագործվում է ամբողջ թվային տվյալները վերականգնելու համար: Երկրորդ նախադասությունը նշանակում է, որ 50 հանձնարարականը պետք է իրականացվի i փոփոխականով: Այս նախադասության կիրառումից հետո տվյալները կայուն կպահվեն i փոփոխականում: Կամ դուք կարող եք ավելի ծույլ լինել ՝ հայտարարություն անելիս վերը նշված երկու նախադասությունը մեկ և ամբողջական առաջադրանքի մեջ միավորել:

int i ＝ 50;

Համեմատաբար ազատ է փոփոխական անվանել: Բայց երբեմն մենք պետք է ուշադրություն դարձնենք ինչ -որ բանի:

Քայլ 3. Փոփոխականի անվանման կարգավորում

• Այն պետք է լինի այբուբենի և ընդգծման համադրություն: Այն կարող է լինել խորհրդանիշ կամ բառ:

• Գործի նկատմամբ զգայուն: Անունը և անունը կարող են լինել տարբեր փոփոխականների համար:

• Փորձեք հնարավորինս հեշտ անվանել այն, որպեսզի թույլ տաք հասկանալ մեկ հայացքից: Սկզբնական նիշը պետք է լինի այբուբեն `թվի կամ հատուկ նշանի փոխարեն:

• Int, float- ի նման առանցքային բառեր չկան

Հետևյալները որոշ սխալ հայտարարություններ են:

int $ a;

int 89 բ;

Ահա ճիշտ հայտարարությունները.

int r;

int super_24;

int openTheDoor;

Քայլ 4: Փոփոխական տեսակը

Բացառությամբ ամբողջ թվերի տվյալների հայտարարման, մենք կարող ենք տասնորդական տվյալների համար (նաև կոչվում են լողացող կետերի տվյալներ) բանալին `float:

բոց բ = 0.5

Մենք պետք է հիշենք, թե տվյալների ինչ տեսակ ենք օգտագործել մեր հայտարարության համար: Եթե մենք օգտագործել ենք int բառը, ապա վերջին առաջադրանքը չի կարող գրել i ＝ 0.5 կամ նման բան, կամ ծրագիրը կդառնա սխալ: Բայց եթե հակառակ գրենք, ամեն ինչ կարգին է: Օրինակ, float i = 5 -ը ճիշտ քերականություն է, բայց ծրագիրը այն կճանաչի որպես տասնորդական թիվ:

Որոշ փոփոխականներ արդեն սահմանվել են ըստ համակարգի: Պարտադիր չէ, որ դրանք ինքներս հայտարարենք: Ինչպես նախկինում նշված «լայնություն, բարձրություն», այն ինքնաբերաբար ձեռք կբերի համակարգչի էկրանի լայնությունն ու բարձրությունը: Օգտագործման այնպիսի բարձր հաճախականություն, որ դիզայներն ուղղակիորեն այն սահմանում է որպես կանխադրված փոփոխական, որպեսզի մեզ համար ավելի հարմար դարձնի օգտագործումը:

Քայլ 5: Օպերատոր

Հետևյալը մշակման օպերատորներ են.

+ գումարած

- մինուս

* բազմապատկել

բաժանել

Rem Մնացած մոդուլ

Դուք պետք է ծանոթ լինեք այս բոլոր օպերատորներին, բացառությամբ %-ի: Դա բավականին տարօրինակ է թվում, քանի որ դրա արդյունքը մնացորդ է: 9%3 -ը 0. Մինչ 9%5 -ը 4 է:

Օպերատորները կարող են օգտագործվել առաջադրանքների և փոփոխականների միջև:

[cceN_cpp theme = "լուսաբաց"] int a = 1; // հայտարարեք a ամբողջ փոփոխական, նշանակումը 1. int b = 2; // Հռչակել ամբողջ փոփոխական b, նշանակումը `2. int c; // Հռչակել ամբողջ փոփոխական գ. c = a + b; // Գումարած երկու հանձնարարություն և դրա արդյունքը վերագրիր ք. տպել (գ); // Ելքային փոփոխական գ.

[/cceN_cpp]

Քայլ 6: Գործողության արդյունք

Արդյունքի արդյունքը չի ցուցադրվի պատուհանում, այլ ներքևի վահանակում:

Չորրորդ տողի գրելու մեթոդը բավականին տարօրինակ է թվում: Բայց դա սովորական ձևաչափ է, որը հաճախ օգտագործվում է համակարգչային առաջադրանքների ժամանակ: Հավասար նշանի ձախ կողմը պետք է լինի վերջնական նշանակված փոփոխականը, իսկ աջ կողմը `գործողության գործընթացը:

Հինգերորդ տողում տպման գործառույթը կարող է փոփոխականներ տպել մխիթարելում, որը հաճախ օգտագործվում է տվյալների ելքի վիճակը ստուգելու համար:

Քայլ 7: Գործողության կանոնակարգ

Մշակման խնդրահարույց կետն այն է, որ մենք պետք է հստակեցնենք փոփոխականի տեսակը: Մենք պետք է հատուկ ուշադրություն դարձնենք լողացող կետի համարի և ամբողջ տիպի գործընթացին:

տպել （6/5）; // արդյունք 1

Ամբողջ թվերի միջև գործողությունը կունենա նոր ամբողջ թիվ: 6 -ը բաժանված է 5 -ի ՝ 1,2 է: Բայց ծրագրի ելքային արդյունքը 1. Սա հակասում է մեր ինտուիցիային: Programրագիրը չի զբաղվի կլորով, այլ կջնջի տասնորդական կետի հետևի թիվը:

տպել (6.0 / 5.0); // արդյունք 1.2

Լողացող կետերի միջև աշխատանքը կհանգեցնի լողացող կետի նոր համարի: Եթե փաստացի արդյունքը 1.2 է, ծրագրի արդյունքը նույնը կլինի:

տպել (6 / 5.0); // արդյունք 1.2

տպել (6.0 / 5); // արդյունք 1.2

Ի վերջո, դա ամբողջական և լողացող կետերի թվի խառնուրդ է: Վերջնական արդյունքը կլինի 1.2:

• Իրականում, պետք է նկատի ունենալ, որ այս կանոնակարգի նպատակը տվյալների ճշգրտությունը չկորցնելն է: Այսպիսով, եթե մեկ տարրը լողացող կետի թիվ է, արդյունքը կլինի նաև լողացող կետի թիվը:

Քայլ 8: Կարգավորել գործառույթը և նկարել գործառույթը

Նախկինում մենք խոսել ենք հիմնավոր գիտելիքների մի փաթեթ: Հիմա, վերջապես, եկանք հետաքրքիր բան խաղալու: Ֆունկցիայի կարգավորումը և գծագրումը համարժեք են մշակման հիմնական գործառույթներին: Այս երկու գործառույթները շատ յուրահատուկ են: Այն կարող է վերահսկել ծրագրի ընթացակարգը: Համեմատաբար բարդ ծրագիրը կներառի այս երկու գործառույթները, քանի որ դրանք ծրագրի հիմնական շրջանակն են: Ձևաչափ:

void setup () {

}

դատարկ վիճակահանություն () {

}

Հատուկ օգտագործումը նրանց կանչելու ձևաչափը տարբերում է մյուս գործառույթներից: Մենք պետք է ավելացնենք «դատարկություն» գործառույթի անունից առաջ, որը նշանակում է «վերադարձված արժեք»: Ֆունկցիայի անվան հետևում մենք պետք է ավելացնենք փակագծեր և փակագծեր:

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

Եկեք մի օրինակ նայենք.

Գործողության կոճակը սեղմելիս մխիթարիչը նախ դուրս կգա «1», այնուհետև անընդհատ կթողնի «2», մինչև չսեղմեք «կանգ» կոճակը կամ փակեք պատուհանը:

Կարգավորման գործառույթում փակագծերում տեղադրված ծածկագիրը կիրականացվի միայն մեկ անգամ: Մինչդեռ գործառույթի ներսում գծագրումը անընդհատ շրջանառության մեջ կլինի (կանխադրված իրականացումը 60 անգամ/վայրկյան):

Այս բնույթի պատճառով կարգավորումը սովորաբար օգտագործվում է միջավայրի հատկությունների նախաստորագրման համար, ինչպիսիք են էկրանի լայնությունը և բարձրությունը, ֆոնի գույնը և բոլոր տեսակի փոփոխականների նշանակումը: Մինչ մենք հաճախ գծագրման գործառույթները դնում ենք ֆունկցիայի գծման մեջ `շարունակաբար փոփոխվող գրաֆիկա ստեղծելու համար:

Քայլ 9. Շրջանակ հորիզոնական շարժման մեջ

Ֆունկցիայի գծումով մենք կարող ենք սկսել ստեղծել մեր անիմացիաները: Մշակման միջոցով անիմացիոն էֆեկտ գրելու մեթոդը բավականին «անհարմար» է: Այն գոյություն չունեցող որևէ հրաման չունի: Օրինակ, որոշակի ձև նշանակեք ՝ ուղղաձիգ կատարելու համար:

Մենք պետք է ինքներս սահմանենք այս մանրամասները: Դուք պետք է ծրագրին ասեք, թե ինչպիսի գրաֆիկա է պետք յուրաքանչյուր շրջանակին:

Գրեք հետևյալ կոդը դրա մեջ (Հիմա եկեք սկսենք դա անել ձեռքով).

[cceN_cpp theme = "լուսաբաց"] int x; int y; void setup () {չափը (300, 300); x = 0; y = բարձրություն/2; } void draw () {background (234, 113, 107); noStroke (); էլիպս (x, y, 50, 50); x = x+1; }

[/cceN_cpp]

Կոդի այս հատվածը ցուցադրում է շարժական շրջան: Նախկին հայտարարված փոփոխական x, y օգտագործվում են կոորդինատի դիրքը պահելու համար: Նրա առաջադրանքները գործում են գործառույթների կարգավորման մեջ: Հիմնական ծածկագիրը գործառույթի գծագրության մեջ հետևյալն է.

x = x + 1

Մի դիտեք այն որպես մաթեմատիկական հավասարություն, այլապես դա շատ տարօրինակ կլինի: Այստեղ «＝» - ը նշանակման խորհրդանիշ է: Այն ցույց է տալիս ձախ փոփոխականի մեջ աջ թվերի տեղադրումը: Ենթադրենք x- ը 50 է, երբ կոդը գործարկվի, «＝» - ի աջ կողմը հավասար է 50+1, այսինքն ՝ 51. Վերջնական արդյունքը կհատկացվի x փոփոխականին: Այսպիսով, x- ի արժեքը դառնում է 51:

Հետևեք ծրագրի ընթացակարգին, ամեն անգամ, երբ ֆունկցիայի նկարչությունը գործում է մեկ անգամ, x արժեքը կաճի 1. Այսպիսով, ամեն անգամ, երբ նկարում ենք, շրջանակը կշարժի պիքսելային ուղղահայաց ուղղություն դեպի աջ ՝ նախկին շրջանակի համեմատ: Հետեւաբար, գրաֆիկը դառնում է շարժական:

• Որպեսզի ծածկագիրն ավելի լավ ընթեռնելիություն ունենա, մենք պետք է որոշակի տարածք հատկացնենք փակագծերի յուրաքանչյուր կոդի տողից առաջ: Եվ դա պետք է լինի հնարավորինս հավասարեցված: Սեղմեք TAB կամ մի քանի դատարկ տարածք, այն կարող է հետ քաշվել:

• blankրագրում դատարկ տարածության և տողի ընդմիջման նշանը չի ազդի ծրագրի վրա: Այնպես որ, լավ է, եթե մեկը ավելի կամ պակաս մուտքագրենք:

Ահա այն արտահայտելու ևս մեկ պարզ միջոց: Փոփոխական շրջանագծի ինքնաբերաբար ավելացման համար մենք պետք է այն գրենք հետևյալ ձևաչափով.

շրջան ＝ շրջան 1

Բավականին անհարմար! Եթե փոփոխականի անունն ավելի երկար է, ապա մենք պետք է ավելի շատ բառեր մուտքագրենք: Այսպիսով, մեր ծույլ նախորդները մտածում են այսպիսի գաղափարի մասին:

շրջան

Շատ պարզ չէ՞: Դա նշանակում է ինքնաբերաբար ավելացնել 1 -ը: Նրա նման, կա - -, ինչը նշանակում է, որ ինքնաբերաբար նվազեցրեք 1 -ը:

Բայց եթե հույս ունենք, որ ավտոմատ աճի քանակը 2 -ի նման թիվ է, ապա պետք է փորձել մեկ այլ արտահայտություն:

շրջան += 2

Սա հավասար է

շրջան = շրջան +2

Նմանապես, կա - ＝, /=, *=:

Քայլ 10: Շարժման ուղղություն

Թե որ ուղղությամբ է շարժվում գրաֆիկը, կախված է նրանից, թե ինչպես եք փոխում ձեր կոորդինատը: Եթե այն փոխվի y ＝ y ＋ 1 -ի, շրջանակը կշարժվի դեպի ներքև: Եթե երկուսն էլ, իսկ y- ն ավելանում են 1 -ով, շրջանակը ներքևից ներքև կտեղափոխվի: Եթե գրենք, որ այն լինի մինուս խորհրդանիշ, այն կշարժվի հակառակ ուղղությամբ:

[cceN_cpp theme = "լուսաբաց"] int x, y; // Կարող է միաժամանակ հայտարարել մի քանի փոփոխական, առանձնացնելու համար օգտագործել ստորակետ: void setup () {չափը (300, 300); x = 0; y = 0; } void draw () {background (234, 113, 107); noStroke (); էլիպս (x, y, 50, 50); x ++; y ++; }

[/cceN_cpp]

Շարժման տոկոսադրույքը

Հիշու՞մ եք ֆունկցիայի վիճակահանության մեջ կանխադրված 60 կադր վայրկյանում: Այս տեմպի համաձայն, վերը նշված շրջանակը վայրկյանում 60 պիքսել կտեղափոխի աջ:

Եթե մենք ուզում ենք փոխել գրաֆիկական շարժման արագությունը, կա երկու մեթոդ. Մեկը `յուրաքանչյուր անգամ x արժեքի բարձրացումն այն փոխվելուց ի վեր:

x ＝ x ＋ 10

Այն 10 անգամ բարձրացրել է արագությունը օրիգինալի համեմատ:

Մյուս մեթոդը կտավի թարմացման հաճախականությունը փոխելն է: frameRate ()

Այս գործառույթը կարող է փոխել կտավի հեռարձակման հաճախականությունը: Գրեք frameRate (10) գործառույթի կարգաբերման մեջ, այն վայրկյանում 60 կադրը կփոխի վայրկյանում 10 շրջանակի: Արագությունը դանդաղում է 6 անգամ, քան նախկինում:

Քայլ 11: Անտեսված նախապատմություն

Նախորդ բոլոր օրինակները ֆոնը գրում են ֆունկցիայի գծագրման մեջ: Երբևէ մտածե՞լ եք այն գրել գործառույթի կարգաբերման մեջ: Արդյո՞ք դա տարբերություններ կունենա: Հիմա եկեք թարմացնենք հորիզոնական շարժման օրինակը:

[cceN_cpp theme = "լուսաբաց"] int x, y; void setup () {չափը (300, 300); ֆոն (234, 113, 107); x = 0; y = բարձրություն/2; } void draw () {noStroke (); էլիպս (x, y, 50, 50); x += 1; } [/cceN_cpp]

Ինչ է պատահել? Գուցե այն չի կարող ճիշտ հասկանալ խնդրի ճիշտ արտադրության պատճառը: Deնջել noStroke գործառույթը, նորից ավելացնել հարված և տեսնել շրջանագծի շարժման ուղին:

Օ, դա այն պատճառով է, որ նախկինում ստեղծված շրջանակը չի ջնջվել: Քանի որ ֆունկցիայի կարգավորումը գործում է ընդամենը մեկ անգամ, եթե դրա վերևում գրենք ֆոնը, այն կլրացնի ֆոնը միայն մեկ անգամ, իսկ վերջինը այլևս ազդեցություն չի ունենա: Ֆունկցիայի ֆոնը նման է ներկի դույլի գործիքի: Օգտագործելուց հետո այն կտարածի կտավի բոլոր բովանդակությունը `միայն ֆոնի գույն սահմանելու փոխարեն: Մենք գրում ենք այն ֆունկցիայի գծումից առաջ, որպեսզի նախկին շրջանակը ծածկված լինի ամեն անգամ, երբ մենք ստեղծում ենք նոր նախշ: Հետևաբար, շրջանակը կարող է ընթանալ այնպես, ինչպես մենք սպասում էինք: Բացառությամբ յուրաքանչյուր գործառույթի օգտագործման մասին հիշելը, մենք պետք է մտածենք կոդի դիրքի մասին: Շատ ժամանակ ՝ կոդերի վերև կամ ներքև տող և այն փակագծի ներսում կամ դրա սահմաններից դուրս գրելու համար, դա կստեղծի բոլորովին այլ էֆեկտներ: Կոդի ուղղությունը երկչափ է: Եթե սխալ է հայտնվում, մենք պետք է չափագրենք այս երկու հարթությունում:

• Նկարչության այս չկրկնվող մեթոդը կարող է շատ հատուկ ազդեցություն ստեղծել, եթե ճիշտ օգտագործվի: Կարող եք պատճենել հետևյալ ծածկագիրը և փորձել:

[cceN_cpp theme = "dawn"] void setup () {size (400, 400); } void draw () {ellipse (width/2-mouseX, height/2-mouseX, mouseY, mouseY); էլիպս (լայնություն/2-mouseX, բարձրություն/2+mouseX, mouseY, mouseY); էլիպս (լայնություն/2+mouseX, բարձրություն/2-mouseX, mouseY, mouseY); էլիպս (լայնություն/2+mouseX, բարձրություն/2+mouseX, mouseY, mouseY); } [/cceN_cpp]

Այստեղ մենք օգտագործել ենք mouseX և mouseY կախարդական փոփոխականը: Հետագայում մենք դրա մասին մանրամասն կխոսենք:

Քայլ 12: Շրջանակի թափահարում

Ի՞նչ անել, եթե ես ուզում եմ շրջանագծի շարժման ուղղությունը դարձնել անկանոն: Պատահականորեն խելացիորեն գործածելով, դուք նույնպես կարող եք գիտակցել այս ազդեցությունը: Պատահականությունը հաճախ օգտագործվող գործառույթ է: Այն կարող է օգտագործվել պատահական գործառույթ ստեղծելու համար: Այն նման է անշեղ ոգու: Փոփոխականների հետ կապվելուց հետո չեք կարող պատկերացնել, թե ինչ է լինելու հետո:

Հրավիրման ձևաչափ.

պատահական (բարձր)

Բարձրը ներկայացնում է պատահական վերին սահմանը, իսկ կանխադրված ստորին սահմանը `0. Օրինակ, պատահական (10): Այն պատահականորեն կստեղծի 0 -ից 10 համար (0 -ն ընդգրկված է, բայց 10 -ը ներառված չէ):

պատահական (ցածր, բարձր)

Եթե մենք սահմանենք երկու պարամետր, ապա այն կվերադառնա նրանց միջև պատահական արժեքին: Օրինակ ՝ պատահական (5, 10): Այն կստեղծի 5 -ից 10 համարը պատահականորեն (5 -ը ներառված է, բայց 10 -ը ներառված չէ):

Օրինակ:

[cceN_cpp theme = "լուսաբաց"] բոց x;

x = պատահական (50, 100);

տպել (x); [/cceN_cpp]

Ամեն անգամ, երբ մենք գործարկում ենք ծրագիրը, վահանակը տարբեր արժեքներ է թողնում:

• Նշում. Գործառույթով ստեղծված արժեքները պատկանում են լողացող կետի տիպին (տասնորդական համարի տեսակը): Եթե մենք ուզում ենք արժեք նշանակել ամբողջ փոփոխականին, մենք պետք է փոխակերպենք այն int () ֆունկցիայի միջոցով: Փոխակերպումը չի հետևում կլորին, այլ ուղղակի ջնջում է տասնորդական մասը: Այսպիսով, int- ի ելքը (պատահական (5)), ունի ընդամենը 5 հնարավորություն ՝ 0, 1, 2, 3, 4:

Այն բանից հետո, երբ մենք ծանոթանանք ֆունկցիայի պատահական օգտագործմանը, կարող ենք անմիջապես անդրադառնալ ստորև նշված գործին:

[cceN_cpp theme = "լուսաբաց"] int x, y; void setup () {չափը (300, 300); x = լայնություն/2; y = բարձրություն/2; } void draw () {background (234, 113, 107); noStroke (); x += int (պատահական (-5, 5)); y += int (պատահական (-5, 5)); էլիպս (x, y, 50, 50); }

[/cceN_cpp]

Նախկին ավելացված կոորդինատային արժեքները ամրագրված են: Միայն եթե ավելացնենք պատահական արժեքը, շրջանակը կշարժվի անորոշ ուղղությամբ: Ավելի մեծ պատահական տիրույթի դեպքում այն ավելի հաճախ է ցնցվում: Քանի որ շրջանակների միջև արժեքի փոփոխությունը ցատկում է, շարժումն այլևս հարթ չի լինի: Մինչ նախկին շրջանակը գտնվում է (150, 150), երկրորդ շրջանակը մի ակնթարթում կտեղափոխվի (170, 170) դիրքի:

Քայլ 13: Տեղափոխվող շրջան

Միգրացիոն շրջան

Արդյո՞ք դա կստեղծի սահուն շարժում: Ֆունկցիայի աղմուկը կարող է օգնել մեզ: Այն ավելի լավ ռիթմ ունի, քան սովորական պատահականությունը: Եվ պատահականորեն առաջացած պատահական թվերը շարունակաբար են:

Հրավիրման ձևաչափ.

աղմուկ （t

Ֆունկցիայի աղմուկը չի կարող սահմանել դրա ելքային տիրույթը: Defineրագիրը սահմանում է, որ այն կարող է առաջացնել միայն 0 -ից 1 -ի լողացող կետերի համարներ, իսկ ֆիքսված մուտքը կարող է ունենալ միայն ֆիքսված ելք:

[cceN_cpp theme = "լուսաբաց"] բոց x = աղմուկ (5); բոց y = աղմուկ (5); տպել (x, y); [/cceN_cpp]

Քանի որ վերը նշված մուտքային պարամետրերը 5 են, այնպես որ ելքային արդյունքները նույնն են: Հետո ինչպե՞ս փոխել արդյունքը: Պատասխանը մուտքային պարամետրերի դինամիկ փոփոխությունն է: Իրականում մենք կարող ենք աղմուկը դիտել որպես անսահմանափակ ձայնային ուղի, մուտքային պարամետրերը նման են «ներկա ժամանակի»: Եթե պարամետրի մուտքը շարունակական է, ելքը նույնպես շարունակական կլինի:

[cceN_cpp theme = "լուսաբաց"] բոց x, y; void setup () {չափը (700, 100); x = 0; ֆոն (0); } դատարկ վիճակահանություն () {x += 1; y = աղմուկ (frameCount/100.0)*100; noStroke (); էլիպս (x, y, 2, 2); }

[/cceN_cpp]

Այս դեպքում մենք գծում ենք Y- ի փոփոխման ուղին, որպեսզի ավելի լավ հասկանանք գործառույթի աղմուկը:

• Դրա մեջ փոփոխական frameCount- ը կստանա ներկա շրջանակը: Նախկինում տարբերվող լայնությունից և բարձրությունից, այն կայուն է առանց որևէ փոփոխության: Բացի այդ, այն սկսում է աճել 0 -ից: Եթե մենք դա հասկանում ենք մեր սկզբնական ցուցադրվող անիմացիոն գրաֆիկայով, այն ցույց է տալիս այն էջը, որին մենք դիմել ենք (ավելի շուտ ՝ ծրագրի ժամանակի հասկացությանը):

• frameCount- ը ամբողջ փոփոխական է: Մեկ այլ ամբողջ փոփոխականով բաժանված ՝ ծրագիրը լռելյայն կզարգացնի արդյունքը ՝ որպես ամբողջ թիվ:Արդյունքի ճշգրտությունը բարելավելու համար մենք պետք է 100 -ը փոխենք 100.0 -ի: Լողացող կետի համարով բաժանված ՝ մենք նույնպես կստանանք լողացող կետի թիվ:

• Y առանցքը 0 -ից 100 փոխելու համար մենք պետք է բազմապատկենք աղմուկի արդյունքը 100 -ով: Այսպիսով, մենք կարող ենք վերահսկել պատահական արժեքների տիրույթը:

Ձեզանից ոմանք, ովքեր լավ մտածում են, կարող են հարցնել. Իհարկե, դուք կարող եք! Բայց այստեղ, գործառական աղմուկի բնութագրիչներն ավելի լավ ցուցադրելու համար մենք դանդաղեցնում ենք «հեռարձակման արագությունը»: Ստորև բերված օրինակը ցույց է տալիս ելքային արժեքի փոփոխությունները տարբեր փոփոխությունների արագության ներքո:

[cceN_cpp theme = "լուսաբաց"] բոց x, y1, y2, y3, y4, y5; void setup () {չափը (700, 500); x = 0; ֆոն (0); } դատարկ վիճակահանություն () {x += 1; y1 = աղմուկ (frameCount)*100; y2 = աղմուկ (frameCount/10.0)*100; y3 = աղմուկ (frameCount/100.0)*100; y4 = աղմուկ (frameCount/1000.0)*100; y5 = աղմուկ (frameCount/10000.0)*100; noStroke (); էլիպս (x, y1, 2, 2); էլիպս (x, y2+100, 2, 2); էլիպս (x, y3+200, 2, 2); էլիպս (x, y4+300, 2, 2); էլիպս (x, y5+400, 2, 2); կաթված (80); գիծ (0, 100, լայնություն, 100); գիծ (0, 200, լայնություն, 200); գիծ (0, 300, լայնություն, 300); գիծ (0, 400, լայնություն, 400); }

[/cceN_cpp]

Ֆունկցիայի աղմուկի փոփոխվող պարամետրերը կարող եք դիտարկել որպես առաջընթացի տող: Փոխել պարամետրը, կարծես շարժենք առաջընթացի բարը: Այսպիսով, երբ այս «ձայնային ուղու» փոփոխվող շրջանակն ավելի մեծ լինի, ելքային արժեքի առջևի և հետևի շարունակական բնութագրիչներն ավելի թույլ կլինեն: (Մենք կարող ենք պատկերացնել, թե ինչ կլինի, եթե երաժշտություն կամ տեսահոլովակ հեռարձակենք 2 անգամ արագությամբ, 5 անգամ արագություն, 20 անգամ արագություն): Երբ շրջանակն ավելի մեծ է, քան որոշակի արժեք, ապա արժեքի ստեղծման ժամանակ պատահական գործելու մեծ տարբերություն չունի:

Եթե դուք կարողանաք հասկանալ վերը նշված բոլոր օրինակները, ապա դուք կզգաք, որ ոչ մի տեղ ավելի հեշտ չէ նկարել միգրացիոն շրջան: Դուք կարող եք հասկանալ նաև ներքին սկզբունքները:

[cceN_cpp theme = "լուսաբաց"] բոց x, y; void setup () {չափը (300, 300); x = 0; } void draw () {background (234, 113, 107); x = աղմուկ (frameCount/100.0 + 100)*300; y = աղմուկ (frameCount/100.0)*300; noStroke (); էլիպս (x, y, 50, 50); }

[/cceN_cpp]

Այժմ, շարժումն ավելի հետաքրքիր է, ինչպես պտտվող գիրոն:

• Ֆունկցիայի աղմուկի մեջ փոփոխական x- ի գումարած 100 -ի պատճառն այն է, որ դրանք հեռավորության վրա բաժանելու համար: Եթե ֆունկցիայի աղմուկի մեջ xy- ի պարամետրերը նույնն են կամ բավականին մոտ, ապա x, y կոորդինատի փոփոխությունը կփակվի նույնին: Սա այն է, որ շարժումը շատ ավելի պատահական դառնա:

Քայլ 14: Մկնիկը տեղափոխեց շրջան

Հաջորդը, մենք վերջապես գալիս ենք երկու փոփոխականի, որոնք ինձ ամենաշատն են դուր գալիս ՝ mouseX և mouseY: Երկու հայեցակարգերի առաջին հայացքից աչքերս փայլում են լույսով: Քանի որ դա գրաֆիկայի հետ փոխգործակցության ամենաուղիղ միջոցն է: Մենք կարող ենք ստեղծել շատ հետաքրքիր ծրագիր դրա հետ:

Գործը բավականին պարզ է.

[cceN_cpp theme = "լուսաբաց"] int x, y; void setup () {չափը (300, 300); x = 0; y = 0; } void draw () {background (234, 113, 107); noStroke (); x = մուկ x; y = մուկ Y; էլիպս (x, y, 50, 50); }

[/cceN_cpp]

mouseX- ը կարող է ձեռք բերել մկնիկի x կոորդինատ, իսկ mouseY- ն կարող է ստանալ y կոորդինատ:

• Փորձենք փոխել դրական և բացասական խորհրդանիշը, կամ փոխանակել mouseX և mouseY:

Քայլ 15: Վերջ

Այս ծանոթ հրամաններից դուք գուցե կարողանաք իրականացնել գրաֆիկայի շարժը: Վերջին գլխի բովանդակությամբ, ճիշտ օգտագործեք ձեր երևակայությունը, կարող եք ստեղծել շատ հետաքրքիր անիմացիոն էֆեկտներ:

Մեր հաջորդ գլխում մենք կարող ենք տեսնել ավելի առատ օրինակներ: Միևնույն ժամանակ, մենք կօգտագործենք մաթեմատիկական գործառույթները և այն կհամատեղենք գրաֆիկական շարժման հետ:

Այս հոդվածը գալիս է դիզայներ Վենզիից:

Քայլ 16: Հարաբերական ընթերցումներ

Programրագրավորման հետաքրքիր ուղեցույց դիզայների համար `նախնական հպման մշակում

Programրագրավորման հետաքրքիր ուղեցույց դիզայների համար. Ստեղծեք ձեր առաջին մշակման ծրագիրը

Այս հոդվածը ՝ https://www.elecfreaks.com/10893.html կայքից է:

Եթե օգնության կարիք ունեք, կարող եք կապվել ՝ [email protected]: