Panduan Pengaturcaraan Menarik untuk Pereka - Menjalankan Gambar Anda (Bahagian Satu): 16 Langkah

2024 Pengarang: John Day | [email protected]. Diubah suai terakhir: 2024-01-30 11:13

Lari! Lari! Lari!

Pengaturcaraan tidak begitu sukar. Perkara utama adalah mencari irama anda dan melakukannya satu persatu.

Sebelum membaca bab ini, saya harap anda sudah biasa dengan kaedah menggambar fungsi asas, atau anda akan merasa pening dan bingung dengan dua fungsi kepala besar: persediaan dan gambar.

Oleh kerana kita ingin membuat grafik gerakan, kita harus tahu bagaimana animasi dihasilkan.

Gambar di atas nampaknya cukup menarik dan secara visual memperlihatkan prinsip pelaksanaan animasi.

Animasi adalah sihir. Ini adalah keajaiban mengenai kecurangan visual. Namun, dalam maklumat ini meletup, usia banjir video, kita sudah terbiasa dengannya. Sedikit orang akan terkejut kerana ia adalah sesuatu yang luar biasa apabila dapat melihat animasinya.

Prinsip yang sama dapat diterapkan dalam menggambar animasi dengan program. Kita harus mempertimbangkan cara menggambar grafik yang berbeza di setiap bingkai, dan program akan mengubah halaman secara automatik sementara kita menambahkan animasi yang lengkap di kepala kita. Dalam bab berikut, kita akan membincangkan tentang bagaimana mewujudkan pergerakan grafik asas. Sebelum itu, kita perlu mengetahui beberapa pengetahuan asas mengenai pemboleh ubah.

Langkah 1: Pembolehubah

Pemboleh ubah adalah wadah untuk data. Ia boleh digunakan berulang kali dalam program.

Sebagai contoh:

[cceN_cpp tema = "fajar"] saiz (500, 500); elips (100, 250, 50, 50); elips (200, 250, 50, 50); elips (300, 250, 50, 50); elips (400, 250, 50, 50);

[/cceN_cpp]

Bahagian kod ini tidak menggunakan sebarang pemboleh ubah. Ia melukis empat bulatan di skrin. Kita dapati mereka mempunyai lebar dan tinggi yang sama. Sekarang ia sama, untuk meminimumkan input data berulang, kita dapat menentukan tanda untuk mewakili itu. Tanda ini berubah-ubah.

Inilah kodnya setelah menambahkan pemboleh ubah:

[cceN_cpp tema = "fajar"] saiz (500, 500); int a = 50; elips (100, 250, a, a); elips (200, 250, a, a); elips (300, 250, a, a); elips (400, 250, a, a);

[/cceN_cpp]

Kami mendapat hasil yang sama!

Oleh kerana kita telah menentukan pemboleh ubah a, kita dapat mengubah parameter dengan mudah. Sekiranya kita mengubah a = 50 menjadi a = 100, maka lebar dan tinggi semua bulatan akan menjadi 100 seragam. Jadi kita tidak perlu mengubah parameter satu persatu. Pemboleh ubah benar-benar penemuan yang baik.

Langkah 2: Penciptaan Pembolehubah

Sebelum menggunakan pemboleh ubah, kita harus membuat pernyataan dan menetapkan jenis datanya.

int i;

saya ＝ 50;

Kalimat ayat pertama telah membuat pernyataan untuk pemboleh ubah i. int adalah simbol yang digunakan terutamanya untuk menyatakan pemboleh ubah. Ketika menyatakan, ia akan mengosongkan ruang dalam memori komputer, yang setara dengan menghasilkan "kotak", yang digunakan khas untuk memulihkan data integer. Ayat kedua bermaksud membuat tugasan 50 yang akan dilaksanakan oleh pemboleh ubah i. Selepas pelaksanaan ayat ini, data akan disimpan dalam pemboleh ubah secara stabil. Atau anda boleh menjadi lebih malas untuk menggabungkan dua ayat di atas menjadi satu dan menyelesaikan tugasan semasa membuat pernyataan.

int i ＝ 50;

Secara relatifnya bebas untuk menamakan pemboleh ubah. Tetapi kadang-kadang kita harus memperhatikan sesuatu.

Langkah 3: Menamakan Peraturan Pembolehubah

• Ini mestilah gabungan abjad dan garis bawah. Ia boleh menjadi simbol atau perkataan.

• Kes sensitif. Nama dan nama boleh mewakili pemboleh ubah yang berbeza.

• Cuba sebut semudah mungkin untuk membolehkan anda memahami pada satu pandangan. Karakter awal mestilah abjad bukan nombor atau watak khas.

• Tiada kata kunci seperti int, float

Berikut adalah beberapa penyataan yang salah.

int $ a;

int 89b;

Inilah pernyataan yang betul:

int r;

int super_24;

int terbukaTheDoor;

Langkah 4: Jenis Pembolehubah

Kecuali untuk menyatakan data bilangan bulat, kita dapat menyatakan untuk data perpuluhan (juga disebut data titik terapung) dengan kata kunci mengambang.

apungan b = 0.5

Kita harus ingat jenis data yang kita gunakan untuk penyataan kita. Sekiranya kita telah menggunakan kata kunci int, tugas terakhir tidak dapat menulis i ＝ 0,5 atau sesuatu seperti itu, atau program akan menjadi kesalahan. Tetapi jika kita menulis secara berlawanan, tidak apa-apa. Sebagai contoh, float i = 5 adalah tatabahasa yang tepat tetapi program akan mengenalinya sebagai nombor perpuluhan.

Sebilangan pemboleh ubah telah ditentukan oleh sistem. Kita tidak perlu menyatakannya sendiri. Sama seperti "lebar, tinggi" yang disebut sebelumnya, secara automatik ia akan memperoleh lebar dan tinggi skrin komputer. Kekerapan penggunaan yang begitu tinggi sehingga pereka secara langsung menentukannya sebagai pemboleh ubah lalai untuk menjadikannya lebih mudah untuk kita gunakan.

Langkah 5: Operator

Berikut adalah pengendali pemprosesan:

+ tambah

- tolak

* banyakkan

membahagi

Ulus Modulus baki

Anda mesti biasa dengan semua pengendali ini kecuali%. Nampaknya agak pelik kerana hasilnya masih ada. 9% 3 adalah 0. Manakala 9% 5 adalah 4.

Pengendali boleh digunakan di antara tugasan dan pemboleh ubah.

[cceN_cpp tema = "fajar"] int a = 1; // menyatakan pembolehubah integer a, tugasan adalah 1. int b = 2; // Menyatakan pemboleh ubah integer b, tugasan adalah 2. int c; // Menyatakan pemboleh ubah integer c. c = a + b; // Ditambah dua tugasan dan berikan hasilnya kepada c. mencetak (c); // Pemboleh ubah output c.

[/cceN_cpp]

Langkah 6: Hasil Operasi:

Hasil output tidak akan dipaparkan di tingkap tetapi di konsol di bahagian bawah.

Kaedah penulisan baris keempat kelihatan agak pelik. Tetapi ia adalah format biasa yang sering digunakan semasa penugasan komputer. Sisi kiri simbol sama mestilah pemboleh ubah yang ditetapkan terakhir, sementara sebelah kanan haruslah proses operasi.

Fungsi mencetak pada baris kelima dapat mencetak pemboleh ubah dalam konsol, yang sering digunakan untuk menguji keadaan output data.

Langkah 7: Peraturan Operasi

Titik yang menyusahkan dalam Pemprosesan adalah kita harus menjelaskan jenis pemboleh ubah. Kita harus memberi perhatian khusus pada proses nombor titik terapung dan jenis bilangan bulat.

cetak （6/5）; // keputusan 1

Operasi antara bilangan bulat akan mempunyai bilangan bulat baru. 6 dibahagi dengan 5 ialah 1.2. Tetapi hasil output program adalah 1. Ini bertentangan dengan gerak hati kita. Program tidak akan berurusan dengan bulat tetapi menghapus nombor di belakang titik perpuluhan.

cetak (6.0 / 5.0); // hasil 1.2

Operasi antara titik terapung akan menghasilkan nombor titik terapung baru. Sekiranya hasil sebenar adalah 1.2, hasil output program akan sama.

cetak (6 / 5.0); // hasil 1.2

cetak (6.0 / 5); // hasil 1.2

Akhirnya ia adalah gabungan nombor bulat dan nombor terapung. Hasil keluaran akhir adalah 1.2.

• Sebenarnya, anda harus ingat bahawa tujuan reka bentuk peraturan ini adalah untuk tidak kehilangan ketepatan data. Oleh itu, jika satu elemen adalah nombor titik terapung, hasilnya juga nombor titik terapung.

Langkah 8: Fungsi Persediaan & Fungsi Lukis

Sebelum ini kita telah bercakap tentang pengetahuan asas. Sekarang, kami akhirnya datang untuk bermain sesuatu yang menarik. Penyediaan dan penarikan fungsi setara dengan fungsi utama pemprosesan. Kedua-dua fungsi ini sangat istimewa. Ia dapat mengawal prosedur program. Program yang agak rumit akan merangkumi kedua fungsi ini kerana merupakan kerangka asas untuk program ini. Format:

batal persediaan () {

}

undian tidak sah () {

}

Penggunaan khas menjadikan format panggilan mereka berbeza dengan fungsi lain. Kita mesti menambah "void" sebelum nama fungsi, yang bermaksud "nilai dikembalikan". Di belakang nama fungsi, kita harus menambah tanda kurung dan tanda kurung.

[cceN_cpp tema = "fajar"] batal persediaan () {cetak (1); } undian tidak sah () {cetak (2); } [/cceN_cpp]

Mari kita lihat contohnya:

Semasa menekan butang operasi, konsol pertama akan mengeluarkan "1" dan kemudian terus mengeluarkan "2" sehingga anda menekan butang berhenti atau menutup tingkap.

Kod dalam kurungan dalam fungsi penyediaan akan dilaksanakan hanya sekali. Sementara kod dalam undian fungsi akan terus berjalan dalam edaran (pelaksanaan lalai 60 kali / saat).

Oleh kerana watak ini, penyiapan biasanya digunakan untuk properti lingkungan yang diinisialisasi, seperti lebar dan tinggi layar, warna latar belakang, dan semua jenis tugas pemboleh ubah. Walaupun kita sering meletakkan fungsi menggambar ke dalam fungsi fungsi untuk menghasilkan grafik yang terus berubah.

Langkah 9: Lingkaran dalam Pergerakan Mendatar

Dengan undian fungsi, kita dapat mula membuat animasi kita. Kaedah menulis kesan animasi dengan Pemprosesan agak "janggal". Tidak ada perintah yang ada. Contohnya, tentukan bentuk tertentu untuk melakukan curvilinear.

Kita mesti menentukan sendiri perincian ini. Anda harus memberitahu program apa jenis grafik yang perlu setiap bingkai.

Tuliskan kod berikut ke dalamnya (Sekarang mari kita mulai melakukannya dengan tangan):

[cceN_cpp tema = "fajar"] int x; int y; batal persediaan () {saiz (300, 300); x = 0; y = tinggi / 2; } undian tidak sah () {latar belakang (234, 113, 107); noStroke (); elips (x, y, 50, 50); x = x + 1; }

[/cceN_cpp]

Bahagian kod ini memaparkan bulatan pergerakan. Pemboleh ubah yang dinyatakan sebelumnya x, y digunakan untuk menyimpan kedudukan koordinat. Tugasannya dijalankan dalam penyediaan fungsi. Kod utama adalah yang berikut dalam cabutan fungsi:

x = x + 1

Jangan melihatnya sebagai persamaan matematik, atau akan menjadi sangat pelik. Di sini, "＝" adalah simbol untuk tugasan. Ini mewakili untuk meletakkan nombor kanan ke pemboleh ubah kiri. Katakan x adalah 50, setelah kod berjalan, sebelah kanan "＝" sama dengan 50 + 1, iaitu 51. Hasil akhir akan diberikan ke dalam pemboleh ubah x. Jadi nilai x menjadi 51.

Ikuti prosedur program, setiap kali undian fungsi beroperasi sekali, nilai x akan meningkat 1. Jadi setiap kali ketika kita melukis, lingkaran akan memindahkan arah piksel secara mendatar ke kanan, berbanding dengan bingkai sebelumnya. Oleh itu, grafik menjadi tidak bergerak.

• Untuk membuat kod mendapat keterbacaan yang lebih baik, kita harus mengosongkan ruangan tertentu sebelum setiap baris kod berada dalam pendakap. Dan selaras mungkin. Tekan TAB atau beberapa ruang kosong, ia boleh menarik balik.

• Simbol ruang kosong dan garis putus dalam program tidak akan mempengaruhi program. Oleh itu, tidak mengapa jika kita menaip satu lebih kurang.

Inilah kaedah lain yang lebih mudah untuk menyatakannya. Untuk menjadikan bulatan berubah menjadi 1 secara automatik, kita harus menulisnya menjadi format berikut.

bulatan ＝ bulatan ＋1

Cukup menyusahkan! Sekiranya nama pemboleh ubah lebih panjang, maka kita harus menaip lebih banyak perkataan. Oleh itu, pendahulunya yang malas memikirkan idea seperti ini.

bulatan ＋＋

Bukankah sangat mudah? Ini bermaksud kenaikan 1 secara automatik. Sama dengan itu, ada - -, yang bermaksud penurunan 1 secara automatik.

Tetapi jika kita berharap jumlah kenaikan automatik adalah angka lain seperti 2, kita harus mencuba ungkapan lain.

bulatan + = 2

Ini sama dengan

bulatan = bulatan + 2

Begitu juga, terdapat - ＝, / =, * =.

Langkah 10: Arah Pergerakan

Arah mana grafik bergerak bergantung pada bagaimana anda menukar koordinat anda. Sekiranya diubah menjadi y ＝ y ＋ 1, bulatan akan bergerak ke bawah. Sekiranya keduax dan y meningkat 1, bulatan akan bergerak ke bawah ke kanan bawah. Sekiranya kita menulisnya menjadi simbol tolak, ia akan bergerak ke arah yang bertentangan.

[cceN_cpp tema = "fajar"] int x, y; // Dapat menyatakan beberapa pemboleh ubah pada masa yang sama, gunakan koma untuk memisahkan. batal persediaan () {saiz (300, 300); x = 0; y = 0; } undian tidak sah () {latar belakang (234, 113, 107); noStroke (); elips (x, y, 50, 50); x ++; y ++; }

[/cceN_cpp]

Kadar Pergerakan

Ingat 60 bingkai lalai sesaat dalam cabutan fungsi? Mengikut kadar ini, bulatan di atas akan bergerak 60 piksel sesaat ke kanan.

Sekiranya kita ingin mengubah kadar pergerakan grafik, ada dua kaedah: satu adalah meningkatkan nilai x setiap kali kerana ia akan diubah.

x ＝ x ＋ 10

Ia telah meningkatkan kelajuan selama 10 kali ganda berbanding yang asal!

Kaedah lain adalah mengubah frekuensi menyegarkan kanvas. kadar bingkai()

Fungsi ini dapat mengubah frekuensi penyiaran kanvas. Tulis frameRate (10) ke dalam penyediaan fungsi, ia akan mengubah 60 bingkai sesaat menjadi 10 bingkai sesaat. Kelajuannya diperlahankan selama 6 kali daripada sebelumnya.

Langkah 11: Latar Belakang Terlihat

Semua contoh sebelumnya menulis latar belakang menjadi cabutan fungsi. Pernahkah anda terfikir untuk memasukkannya ke dalam penyediaan fungsi? Adakah ia akan mempunyai perbezaan? Sekarang, mari kita kemas kini contoh pergerakan mendatar.

[cceN_cpp tema = "fajar"] int x, y; batal persediaan () {saiz (300, 300); latar belakang (234, 113, 107); x = 0; y = tinggi / 2; } undian tidak sah () {noStroke (); elips (x, y, 50, 50); x + = 1; } [/cceN_cpp]

Apa yang berlaku? Mungkin tidak dapat memahami sebab penghasilan masalah dengan betul. Hapus fungsi noStroke, tambahkan stroke lagi, dan lihat jalan pergerakan bulatan.

Oh, ini kerana bulatan yang dibuat sebelumnya belum dipadamkan! Kerana penyediaan fungsi beroperasi hanya sekali, jika kita menulis latar belakang di atasnya, ia akan mengisi latar belakang hanya untuk satu kali dan yang terakhir tidak akan berpengaruh lagi. Latar belakang fungsi adalah seperti alat baldi cat. Setelah digunakan, ia akan merangkumi semua kandungan di kanvas dan bukannya menetapkan warna latar belakang sahaja. Kami menulisnya sebelum penggambaran fungsi supaya bingkai yang pertama akan dilindungi setiap kali kami membuat corak baru. Oleh itu, bulatan dapat berjalan seperti yang kami harapkan. Kecuali untuk mengingat penggunaan setiap fungsi, kita harus memikirkan kedudukan kod. Banyak masa, garis ke atas atau ke bawah untuk codea dan untuk menulisnya di dalam atau di luar pendakap, ia akan menghasilkan kesan yang sangat berbeza. Arah kod adalah dua dimensi. Sekiranya pepijat muncul, kita mesti menentukur dalam dua dimensi ini.

• Kaedah melukis yang tidak berulang ini dapat menghasilkan kesan yang sangat istimewa jika digunakan dengan betul. Anda boleh menyalin kod berikut dan mencuba.

[cceN_cpp tema = "fajar"] batal persediaan () {size (400, 400); } undian batal () {elips (lebar / 2-tetikusX, tinggi / 2-tetikusX, tetikusY, tetikusY); elips (lebar / 2-tetikusX, tinggi / 2 + tetikusX, tetikusY, tetikusY); elips (lebar / 2 + tetikusX, tinggi / 2-tetikusX, tetikusY, tetikusY); elips (lebar / 2 + tetikusX, tinggi / 2 + tetikusX, tetikusY, tetikusY); } [/cceN_cpp]

Di sini kami telah menggunakan pemboleh ubah ajaib mouseX dan mouseY. Kami akan membincangkannya secara terperinci.

Langkah 12: Lingkaran Bergetar

Bagaimana jika saya ingin menjadikan pergerakan pergerakan bulatan menjadi tidak teratur? Dengan fungsi secara rawak, anda dapat menyedari kesan ini juga. Rawak adalah fungsi yang sering digunakan. Ia boleh digunakan untuk menghasilkan fungsi rawak. Ia seperti semangat tanpa jejak. Setelah berkaitan dengan pemboleh ubah, anda tidak dapat membayangkan apa yang akan menjadi seterusnya.

Memohon Format:

rawak (tinggi)

Tinggi mewakili had atas rawak, dan had bawah lalai adalah 0. Contohnya, rawak (10). Ia akan menghasilkan nombor dari 0 hingga 10 secara rawak (0 disertakan tetapi 10 tidak termasuk).

rawak (rendah, tinggi)

Sekiranya kita menetapkan dua parameter, maka ia akan kembali ke nilai rawak di antara mereka. Sebagai contoh, rawak (5, 10). Ia akan menghasilkan nombor dari 5 hingga 10 secara rawak (5 disertakan tetapi 10 tidak termasuk).

Contoh:

[cceN_cpp tema = "fajar"] terapung x;

x = rawak (50, 100);

cetak (x); [/cceN_cpp]

Setiap kali kita menjalankan program, konsol akan menghasilkan nilai yang berbeza.

• Catatan: Nilai yang dibuat oleh fungsi rawak tergolong dalam jenis titik terapung (jenis nombor perpuluhan). Sekiranya kita ingin memberikan nilai kepada pemboleh ubah integer, kita harus mengubahnya melalui fungsi int (). Transformasi tidak mematuhi bulat tetapi menghapus bahagian perpuluhan secara langsung. Oleh itu, output int (rawak (5)), hanya mempunyai 5 kemungkinan: 0, 1, 2, 3, 4.

Setelah kita mengetahui penggunaan fungsi secara rawak, kita dapat langsung masuk ke dalam kasus di bawah ini.

[cceN_cpp tema = "fajar"] int x, y; batal persediaan () {saiz (300, 300); x = lebar / 2; y = tinggi / 2; } undian tidak sah () {latar belakang (234, 113, 107); noStroke (); x + = int (rawak (-5, 5)); y + = int (rawak (-5, 5)); elips (x, y, 50, 50); }

[/cceN_cpp]

Nilai koordinat yang ditambah sebelumnya adalah tetap. Hanya jika kita meningkatkan nilai rawak, bulatan akan bergerak ke arah yang tidak tentu. Dengan julat rawak yang lebih besar, goncangan lebih kerap. Oleh kerana perubahan nilai antara bingkai dilambung, pergerakannya tidak akan lancar lagi. Sementara bingkai sebelumnya berada pada (150, 150), bingkai terakhir akan bergerak ke posisi (170, 170) dalam sekejap.

Langkah 13: Migrasi Bulatan

Migrasi Bulatan

Adakah ia akan menghasilkan pergerakan yang lancar? Kebisingan fungsi dapat membantu kita. Ia mempunyai irama yang lebih baik daripada rawak biasa. Dan nombor rawak yang dihasilkan secara berterusan adalah berterusan.

Memohon Format:

bunyi bising （t）

Bunyi fungsi tidak dapat menentukan julat keluarannya. Program menentukan bahawa ia hanya dapat menghasilkan nombor titik terapung dari 0 hingga 1 dan input tetap hanya dapat menghasilkan output tetap.

[cceN_cpp tema = "fajar"] terapung x = bunyi bising (5); apungan y = bunyi bising (5); cetak (x, y); [/cceN_cpp]

Kerana parameter input di atas adalah 5, jadi hasil outputnya sama. Lalu bagaimana cara mengubah hasilnya? Jawapannya adalah mengubah parameter input secara dinamik. Sebenarnya kita boleh menganggap bunyi sebagai trek suara tanpa had, parameter inputnya sama seperti "masa sekarang". Sekiranya input parameter berterusan, output juga akan berterusan.

[cceN_cpp tema = "fajar"] terapung x, y; batal persediaan () {saiz (700, 100); x = 0; latar belakang (0); } undian tidak sah () {x + = 1; y = bunyi bising (frameCount / 100.0) * 100; noStroke (); elips (x, y, 2, 2); }

[/cceN_cpp]

Dalam kes ini, kita melukis jalur perubahan Y supaya kita dapat memahami fungsi bunyi dengan lebih baik.

• Antaranya, frameCount berubah akan memperoleh bingkai sekarang. Berbeza dengan lebar, ketinggian sebelumnya, ia stabil tanpa perubahan. Selain itu, ia mulai meningkat dari 0. Jika kita memahaminya dengan grafik animasi paparan awal kita, ini menunjukkan halaman yang telah kita buka (dan bukan pada konsep waktu dalam program).

• frameCount adalah pemboleh ubah integer. Dibahagi oleh pemboleh ubah bilangan bulat yang lain, program ini secara lalai memproses hasilnya menjadi bilangan bulat. Untuk meningkatkan ketepatan hasil, kita perlu mengubah 100 hingga 100.0. Dibahagi dengan nombor titik terapung, kita juga akan mendapat nombor titik terapung.

• Untuk mengubah gandar Y dari 0 hingga 100, kita harus mengalikan hasil bunyi dengan 100. Oleh itu kita dapat mengawal julat nilai rawak.

Sebilangan daripada anda yang pandai berfikir mungkin bertanya "mengapa kita harus membahagikan frameCountby 100? Tidak baik menulis frameCount secara langsung?" Sudah tentu anda boleh! Tetapi di sini, untuk memperlihatkan ciri-ciri kebisingan fungsi dengan lebih baik, kami melambatkan "kadar penyiaran". Contoh di bawah menunjukkan perubahan nilai output di bawah kadar perubahan yang berbeza.

[cceN_cpp tema = "fajar"] terapung x, y1, y2, y3, y4, y5; persediaan tidak sah () {saiz (700, 500); x = 0; latar belakang (0); } undian tidak sah () {x + = 1; y1 = kebisingan (frameCount) * 100; y2 = bunyi bising (frameCount / 10.0) * 100; y3 = bunyi bising (frameCount / 100.0) * 100; y4 = bunyi bising (frameCount / 1000.0) * 100; y5 = bunyi bising (frameCount / 10000.0) * 100; noStroke (); elips (x, y1, 2, 2); elips (x, y2 + 100, 2, 2); elips (x, y3 + 200, 2, 2); elips (x, y4 + 300, 2, 2); elips (x, y5 + 400, 2, 2); strok (80); garis (0, 100, lebar, 100); garis (0, 200, lebar, 200); garis (0, 300, lebar, 300); garis (0, 400, lebar, 400); }

[/cceN_cpp]

Anda boleh menganggap perubahan parameter dalam fungsi bunyi sebagai bar kemajuan. Ubah parameternya seperti kita menggerakkan bar kemajuan. Oleh itu, apabila perubahan skop "trek suara" ini lebih besar, ciri-ciri nilai output berterusan dan depan akan menjadi lebih lemah. (Kita dapat membayangkan apa yang akan terjadi sekiranya kita menyiarkan muzik atau video dengan kelajuan 2 kali, 5 kali kelajuan, 20 kali kelajuan). Apabila ruang lingkup lebih besar daripada nilai tertentu, maka tidak ada perbezaan besar untuk berfungsi secara rawak pada penjanaan nilai.

Sekiranya anda dapat memahami semua contoh di atas, maka anda akan merasa tidak ada yang lebih mudah untuk melukis lingkaran berpindah. Anda juga dapat memahami prinsip dalamannya.

[cceN_cpp tema = "fajar"] terapung x, y; batal persediaan () {saiz (300, 300); x = 0; } undian tidak sah () {latar belakang (234, 113, 107); x = kebisingan (frameCount / 100.0 + 100) * 300; y = bunyi bising (frameCount / 100.0) * 300; noStroke (); elips (x, y, 50, 50); }

[/cceN_cpp]

Sekarang, pergerakannya lebih menarik seperti gyro berputar.

• Sebab mengapa pemboleh ubah x dalam fungsi berfungsi harus ditambah 100 adalah kerana untuk memisahkannya dari jarak jauh. Sekiranya parameter xy dalam kebisingan fungsi sama atau cukup dekat, perubahan koordinat x, y akan hampir sama. Ini untuk menjadikan pergerakan menjadi lebih rawak.

Langkah 14: Lingkaran Dipindahkan oleh Tetikus

Seterusnya, kami akhirnya menemui dua pemboleh ubah yang paling saya sukai: mouseX dan mouseY. Pada pandangan pertama kedua konsep itu, mata saya berkilauan dengan cahaya. Kerana ia adalah kaedah paling langsung untuk berinteraksi dengan grafik. Kita boleh membuat banyak program menarik dengannya.

Kesnya agak mudah:

[cceN_cpp tema = "fajar"] int x, y; batal persediaan () {saiz (300, 300); x = 0; y = 0; } undian tidak sah () {latar belakang (234, 113, 107); noStroke (); x = tetikusX; y = tetikusY; elips (x, y, 50, 50); }

[/cceN_cpp]

mouseX dapat memperoleh koordinat x tetikus, sementara mouseY dapat memperoleh koordinat y.

• Mari cuba menukar simbol positif dan negatif, atau menukar mouseX dan mouseY.

Langkah 15: Tamat

Dari arahan yang biasa ini, anda mungkin dapat melakukan pergerakan grafik. Dengan kandungan bab terakhir, gunakan imaginasi anda dengan betul, anda boleh membuat banyak kesan animasi yang menarik.

Dalam bab seterusnya, kita dapat melihat lebih banyak contoh. Pada masa yang sama, kami akan menggunakan fungsi matematik dan menggabungkannya dengan pergerakan grafik.

Artikel ini berasal dari pereka Wenzy.

Langkah 16: Bacaan Relatif:

Panduan Pengaturcaraan Menarik untuk Pereka - Memproses Sentuhan Awal

Panduan Pengaturcaraan Menarik untuk Pereka - Buat Program Pemprosesan Pertama Anda

Artikel ini berasal dari:

Sekiranya memerlukan bantuan, anda boleh menghubungi: [email protected].