THOMAS LIVELY: Baiklah.
Halo semuanya.
Aku Thomas Lively.
Seminar ini akan menjadi menulis game 2D di C menggunakan SDL.
Jadi saya tahu Anda semua bertanya, yeah, aku benar-benar
ingin bermain game dan membuat permainan, tapi apa bisnis SDL ini?
Jadi SDL adalah library C.
Ini adalah singkatan untuk Wikipedia DirectMedia Layer.
Dan itu adalah lintas platform, perpustakaan pengembangan game.
Ia bekerja pada Windows, Mac, Linux, bahkan iOS dan Android.
Ini menangani hal-hal seperti akses ke sistem audio
untuk komputer, keyboard, dan mouse, joystick, jika mereka terpasang.
Pada ponsel, bahkan dapat melakukan menyentuh input dan semua itu.
Dan tentu saja, itu menangani grafis, menggambar hal ke layar.
>> Jadi itu sangat banyak digunakan, meskipun Anda mungkin tidak pernah mendengar hal itu sebelumnya.
Ini dibangun ke dalam, misalnya, Mesin sumber Valve,
yang kekuatan game seperti Portal dan Team Fortress 2.
Ini juga dalam jumlah yang sangat besar game indie yang keluar,
jadi saya bersemangat untuk melihat apa yang Anda semua akan membuat dengan itu.
>> Tujuan seminar ini adalah untuk mendapatkan Anda ditetapkan menjadi berkembang dengan SDL.
Kita akan belajar bagaimana untuk membuat jendela permainan.
Kita akan membuat sprite, yang merupakan gambar dalam permainan Anda
yang dapat bergerak di sekitar.
Kita akan belajar bagaimana untuk menghidupkan dan sprite,
sehingga memindahkan mereka sekitar, membuat mereka berubah dari waktu ke waktu.
Dan kita akan belajar bagaimana untuk menangkap keyboard dan mouse
masukan dari komputer.
Apa yang kita tidak akan berbicara tentang hari ini adalah grafis 3D,
karena itu adalah sangat rumit subjek yang kita tidak punya waktu untuk.
Kami tidak akan belajar bagaimana bermain audio pada permainan kami.
Dan kita tidak akan membangun untuk apa pun kecuali Linux.
>> Sekarang peringatan ada itu, mudah-mudahan, pada akhir seminar,
Anda akan merasa nyaman dengan dokumentasi SDL,
sehingga Anda akan dapat pergi mencari tahu cara bermain audio untuk diri sendiri.
Juga membangun untuk Mac atau PC harus bekerja persis sama dengan membangun untuk Linux,
tapi setup akan sedikit berbeda.
Jadi Anda harus dapat mencari cara untuk melakukan hal-hal
pada akhir seminar hari ini.
>> Jadi untuk mengatur, kita akan menggunakan mesin virtual.
Kami akan menggunakan IDE CS50, karena kami hanya akan menulis di C.
Tapi karena IDE tidak browser, kita tidak dapat membuat jendela baru atau tampilan
grafis di dalamnya.
Jadi kita perlu mesin virtual.
Jadi Anda dapat mengikuti petunjuk di sini di manual.CS50.net/appliance/15
untuk menginstal alat CS50 resmi, yang hanyalah virtual Linux
mesin.
>> Dan kemudian setelah Anda memiliki bahwa semua set up-- itu
mungkin mengambil sedikit waktu, karena sebuah download-- sangat besar Anda akan
untuk menjalankan di VM sudo apt-get pembaruan.
Dan itu benar-benar akan untuk memperbarui semua perangkat lunak
paket pada mesin virtual Anda.
>> Setelah itu, Anda akan menjalankan sudo apt-get install, libsdl2-2.0-0,
libsdl2-DBG, libsdl2-dev, dan tambahan libsdl2-gambar-2,0-0,
libsdl2-gambar-DBG, dan libsdl2-gambar-dev.
Jadi, apa yang dilakukan?
Yang hanya menginstal debug informasi, dokumentasi, header,
dan binari untuk dua perpustakaan.
Teratur tua, SDL 2.0, dan perpustakaan lain
disebut SDL Gambar, yang kita akan menggunakan
untuk memuat file gambar ke dalam permainan kami.
>> Jadi setelah Anda memiliki yang juga itu, hanya ketika bertanya,
Anda cukup ketik ya, tekan Enter menginstal paket tersebut,
dan kemudian Anda harus baik untuk pergi.
Jadi untuk mendapatkan kode distribusi, Anda can-- oh sayang, ini tidak diperbarui.
Kecuali Anda memiliki account-- GitHub jika Anda memiliki akun GitHub,
Anda dapat melakukan Git ini perintah clone ke repo
dan yang akan men-download Git repo dengan semua kode di dalamnya,
sehingga Anda akan memiliki kode.
>> Jika Anda tidak memiliki GitHub akun, apa yang harus Anda lakukan adalah jenis
wgithttps: //github.com/tlively/sdl seminar-- dan di sini itu different--
/archive/master.zip.
Jadi sekali lagi, itu sama persis URL, kecuali itu akan menjadi
tlively / SDL_seminar / master.zip dan Anda menggunakan wgit untuk men-download itu.
Dan kemudian Anda bisa hanya unzip arsip yang
dan kemudian Anda akan memiliki semua kode sumber.
Jadi maaf tentang itu.
Dan kemudian kode tersebut juga akan diselenggarakan di Halaman web seminar CS50 di beberapa
hari.
>> Baiklah.
Jadi bagaimana kita memulai menulis permainan kami sendiri?
Nah, hal pertama kita akan ingin melakukan
adalah melihat dokumentasi SDL.
Jadi, inilah VM.
Dan inilah halaman web.
Aku sudah navigasikan hidup libsdl.org.
Apa yang akan saya lakukan di sini adalah pergi untuk sidebar, di bawah dokumentasi,
dan klik di wiki.
Ini akan membawa saya ke wiki yang memiliki sebagian besar dokumentasi untuk SDL.
Selama di sidebar di sini, kami akan klik API berdasarkan kategori,
karena akan memberikan kita pandangan kategoris bagus
dari seluruh API untuk SDL.
>> Jadi misalnya, kita memiliki inisialisasi dasar
dan ditutup, semua jenis hal administrasi untuk menggunakan SDL,
dan kemudian kita memiliki bagian untuk menampilkan hal-hal ke layar.
Itu video.
Peristiwa masukan, itu mendapatkan input dari keyboard,
mendapatkan masukan dari mouse, dan joystick, jika Anda memiliki bahkan.
Ada umpan balik kekuatan untuk hal-hal seperti pengendali permainan, yang
kita tidak akan berbicara tentang.
Dan inilah audio.
Dan kemudian ada sekelompok lainnya hal-hal yang SDL dapat lakukan untuk Anda.
>> Tapi hari ini kita akan fokus pada inisialisasi di sini,
menampilkan gambar dalam video bagian, dan penanganan peristiwa input.
Jadi ini adalah utama bagian dokumentasi
Anda harus khawatir tentang.
Hanya untuk bersenang-senang, jika kita pergi di sini dan klik pada API dengan nama,
kita bisa melihat daftar setiap hal di perpustakaan SDL.
Jadi semua fungsi-fungsi ini, mantri, struktur, jumlah gila barang,
Sesuai abjad.
Dan jelas, sampai Anda tahu bahwa Anda lakukan,
ini tidak akan terlalu membantu, itulah sebabnya mengapa kita lakukan API berdasarkan kategori.
>> Jadi mari kita mulai.
Mudah-mudahan Anda sudah sudah download kode distribusi.
Dan apa yang dapat Anda lakukan adalah, tepat di sini di alat CS50,
cukup membuka terminal.
Kita mulai.
Jadi saya sudah download Kode distribusi menggunakan .zip yang
metode.
Dan aku sudah membuka ritsleting itu.
Jadi di sini adalah dalam master seminar SDL.
Jadi saya akan pergi ke direktori tersebut.
Dan apa yang kita lihat di sini adalah bahwa kita memiliki tujuh file C.
Dan ini akan kode kita akan melihat hari ini.
Kami memiliki makefile.
Dan kami memiliki direktori sumber, yang hanya memiliki gambar
Anda akan melihat segera.
>> Jadi mari kita membuka file-file ini menggunakan G-Sunting Editor.
Jadi saya ingin membuka semua file yang dimulai dengan halo dan diakhiri dengan c.
Kita mulai.
Jadi itu sebuah jendela kecil, jadi kita akan mencoba untuk membuat yang lebih besar.
Tidak, itu pergi.
>> Baiklah.
Jadi, inilah yang pertama File kita akan melihat.
Ini disebut hello1_sdl.c.
Dan semua ini dilakukan adalah menginisialisasi SDL perpustakaan sehingga kita dapat mulai menggunakannya.
Bagaimana Anda tahu untuk datang dengan kode ini sendiri?
Nah, jika kita melihat lebih dokumentasi
dan kami pergi ke inisialisasi dan menutup bagian,
itu akan memberitahu kita semua tentang bagaimana untuk menginisialisasi SDL.
Jadi pasti membaca ini beberapa waktu yang lain.
Ini akan memberitahu Anda semua tentang apa yang terjadi di sini.
Tapi inti utama masalah ini adalah bahwa kita perlu memanggil fungsi SDL ini Dalam Ini
dan menyebarkannya apa hal-hal kami ingin perpustakaan untuk menginisialisasi.
Jadi dalam kasus kami, kami hanya akan untuk menginisialisasi video untuk saat ini,
sehingga kita dapat mulai menampilkan gambar.
>> Di sini, Anda dapat melihat apakah kita klik SDL sebuah Dalam Ini, kita
bisa mendapatkan lebih banyak informasi, termasuk nilai kembali.
Jadi kita lihat di sini bahwa returnes nol pada keberhasilan.
Jadi dalam kode kita, kita akan melihat apakah itu tidak kembali nol,
dan jika tidak kembali nol, sehingga tidak berhasil,
maka kita akan hanya cetak kesalahan dengan menggunakan fungsi lain ini,
SDL mendapatkan kesalahan, yang mengembalikan string menggambarkan kesalahan yang terjadi.
Kita akan mencetak bahwa kesalahan dan kemudian kami hanya
akan keluar dari program dengan kode kesalahan.
>> Kemudian hal lain yang kita butuhkan lakukan adalah, sebelum keluar program,
jika kita berhasil diinisialisasi SDL, kita hanya perlu menyebutnya SDL berhenti.
Dan itu akan menangani membersihkan semua sumber daya SDL internal bagi kita dari.
Jadi dokumentasi there-- lagi, di sini kita berada di inisialisasi
dan menutup bagian dokumentasi.
Anda bisa klik pada Fungsi sini, SDL berhenti,
dan Anda dapat membaca semua tentang hal itu juga.
Dan banyak fungsi ini halaman dokumentasi
memiliki kode contoh, jadi ini adalah sumber daya yang sangat baik.
Pasti menghabiskan beberapa waktu membaca bagian dari wiki ini
jika Anda akan melakukan ini untuk sebuah proyek.
>> Baiklah.
Jadi itulah seluruh program kami.
Apa yang bisa kita lakukan sekarang is-- aku akan membuka makefile di sini,
jadi saya akan mengambil melihat bagaimana yang bekerja.
Dan itu adalah makefile yang sangat sederhana, mirip dengan apa yang telah Anda lihat sebelumnya.
Salah satu perbedaan utama adalah bahwa, di sini, ini
akan memasukkan hasil running perintah ini, yang Anda sudah sudah
diinstal jika Anda telah menginstal SDL.
Dan ini adalah perintah yang akan menghasilkan
beberapa bendera tambahan untuk compiler.
>> Selain itu, kami memberikan semua perintah biasa, serta
kedua perintah.
Jadi pegangan -lsdl2-gambar menghubungkan di perpustakaan gambar SDL.
Dan lm benar-benar menangani menghubungkan di C perpustakaan matematika standar.
Jadi kita tidak akan membutuhkan mereka untuk semua file C kami,
tapi kita hanya menempatkan mereka dalam sehingga kita bisa menggunakan makefile yang sama untuk semuanya
tanpa modifikasi.
>> Di sini di sumber, ini adalah di mana Anda akan
menempatkan file yang Anda akan untuk mengkompilasi untuk proyek Anda.
Tapi karena setiap satu dari C saya file di sini memiliki fungsi utama,
itu akan bingung jika kita menempatkan mereka semua di.
Jadi aku akan hanya mengatakan, untuk saat ini, hello1_sdl.c,
yang merupakan salah satu yang kita hanya melihat.
Jadi jika aku kembali lebih di sini, saya bisa lakukan membuat.
Dan apa itu itu hanya dikompilasi file pertama.
Dan kemudian kita dapat mengetik ./game, karena itu adalah executable yang dihasilkan.
Dan semua itu adalah cetak inisialisasi sukses.
Jadi kami melakukan sesuatu yang benar.
Tapi itu jenis membosankan, karena kita tidak melihat jendela,
tidak ada yang bergerak di sekitar.
>> Begitu besar, kami mendapat SDL diinisialisasi.
Sekarang, mari kita beralih ke sesuatu sedikit lebih menarik.
Jadi di sini kita memiliki hello2_window.c, dan ini akan menjadi sedikit lebih
Program C kompleks yang menginisialisasi SDL seperti sebelumnya,
kecuali sekarang kita juga akan menginisialisasi SDL waktu.
Dan ini akan membiarkan kita mengakses timer internal
dan fungsi penggunaan yang berkaitan dengan waktu.
>> Dan kemudian mari kita lihat di sini.
Apa yang kita lakukan adalah kita memiliki pointer ini untuk jendela struct SDL, yang
akan dibuat oleh panggilan ini ke fungsi, SDL membuat jendela.
Sekarang, ini membutuhkan banyak argumen, jadi mari kita pergi melihat dokumentasi.
Jadi sekali lagi, aku akan API berdasarkan kategori, aku
turun ke video di sini, dan yang pertama Bagian, menampilkan manajemen jendela.
Jadi bagian ini memiliki satu ton barang di dalamnya,
tetapi jika Anda melihat melalui fungsi-fungsi ini, Anda akan
melihat bahwa mungkin yang kita ingin disebut SDL membuat jendela,
yang kebetulan tepat di atas.
>> Dan jadi ini adalah dokumentasi untuk fungsi ini.
Jendela akan memiliki judul, x dan y posisi pada layar,
itu akan memiliki lebar, ketinggian, dan kemudian itu akan mengambil beberapa bendera.
Sekarang, kita tidak benar-benar peduli setiap bendera ini sekarang,
tetapi jika Anda ingin melakukan sesuatu seperti membuat jendela layar penuh,
Anda bisa melihat pada saat itu.
Untuk saat ini, kami hanya akan menggunakan nilai-nilai khusus,
Jendela SDL ditambah berpusat untuk x dan y dalam rangka
hanya membuat jendela di tengah layar kami.
>> Jadi itulah yang yang melakukan.
Dan jika jendela kebetulan null, berarti ada kesalahan,
sekali lagi kami hanya akan mencetak kesalahan menggunakan SDL get error.
Dan kemudian karena kita diinisialisasi SDL, kita sekarang perlu untuk menutupnya.
Jadi kita sebut SDL berhenti sebelum kembali satu untuk utama.
>> Jadi kita memiliki jendela ini terbuka penuh harap.
Dan apa yang kita akan lakukan adalah kita akan
untuk memanggil SDL untuk 5.000 milidetik, yang sama seperti lima detik.
Dan ketika kita sudah selesai dengan itu, itu akan menghancurkan jendela,
membersihkan perpustakaan SDL, dan keluar dari program.
Jadi mari kita pergi ke depan dan memberikan yang tembakan.
>> Jadi sekarang bukan mengubah makefile setiap kali,
Aku bisa hanya melakukan membuat, dan kemudian pada baris perintah,
mengatakan sumber equals dan kemudian file kita kompilasi.
Jadi itu hello2_window.c.
Fantastis.
Tidak ada erros.
Sekarang, jika kita menjalankan executable kami, kita melihat jendela ini.
Sekarang ada beberapa masalah dengan jendela.
Kita bisa bergerak di sekitar, tetapi memiliki latar belakang ini sampah di dalamnya.
Jadi kami belum ditarik apa-apa, dan jadi
hanya penuh dengan sampah, yang cukup banyak apa yang kita harapkan.
>> Selain itu, kami tidak bisa menutup jendela.
Aku menekan X ini di sudut dan tidak ada yang terjadi.
Jadi kita akan melihat bagaimana untuk memperbaiki bahwa dalam sedikit.
Jadi mari kita memperbaiki bagian mana jendela penuh sampah pertama.
Jadi jika kita pergi ke hello3_image.c, apa kita dapat melihat bahwa kita adalah telah menambahkan beberapa
lebih banyak hal di sini.
Kami telah menambahkan header baru ini mengajukan untuk mendapatkan fungsi waktu.
Saya kira kita melakukan itu di terakhir satu, juga, dan saya tidak menyebutkan itu.
Tapi sekarang karena kita bekerja dengan gambar,
kita perlu menyertakan SDL image file header juga.
Jadi itu adalah hal yang sama seperti sebelumnya, menginisialisasi SDL sini,
kesepakatan yang sama dengan menciptakan jendela.
Kami telah melihat bahwa sebelum sekarang.
>> Sekarang kita perlu membuat sesuatu yang disebut penyaji, yang semacam sejalan
dengan jendela.
Tapi itu semacam objek abstrak yang
jawab melakukan semua ini menggambar operasi ke jendela.
Dan itu benar-benar sesuai untuk program dimuat
ke dalam hardware grafis di Anda komputer atau ponsel Anda atau apa pun.
Jadi bendera kita ingin lulus itu-- dan Anda dapat melihat dokumentasi
untuk mendapatkan lebih rinci di sini-akan untuk SDL render dipercepat, yang
berarti itu akan menjadi menggunakan hardware grafis
dan bukan hanya ditiru dalam perangkat lunak.
>> Dan kita akan menggunakan SDL Renderer PRESENTVSYNC.
VSYNC adalah hal yang hanya membuat grafis Anda terlihat lebih baik dan mencegah
hal yang disebut layar ini teror, di mana setengah
dari satu frame dan setengah dari depan bingkai mendapatkan ditarik pada saat yang sama
dan itu tampak mengerikan.
Tapi sekali lagi, Anda dapat pergi membaca tentang itu sendiri.
>> Jadi kita memiliki beberapa bendera di sini.
Dan jadi kita hanya akan memanggil fungsi SDL ini membuat penyaji.
Kami akan memberikan jendela kaitkan dengan penyaji itu.
Satu negatif berarti kita tidak peduli apa driver grafis kita akan menggunakan.
Sehingga harus cukup banyak selalu menjadi salah satu negatif,
kecuali Anda tahu tentang driver grafis.
Dan kemudian kita hanya akan lulus bendera kami.
Jadi jika yang mengembalikan null, maka kami akan mencetak kesalahan seperti biasa,
tapi kemudian kita juga akan untuk menghancurkan jendela
untuk membersihkan sumber daya sebelum memanggil SDL berhenti dan kembali.
>> Sekarang, bagian yang menarik di sini adalah di mana kita memuat gambar kami
menggunakan fungsi IMG_load ini.
Ini adalah satu-satunya fungsi kita akan menggunakan dari perpustakaan gambar SDL.
Ini adalah satu-satunya yang kita butuhkan.
Ini adalah fungsi yang mengambil string itu adalah jalan dari setiap sumber daya gambar.
Dan dapat png, GIF sebuah, bitmap, hal-hal ini.
Dan itulah mengapa fungsi ini sangat bagus.
Ia bisa menangani cukup banyak format apapun.
Beban ke dalam memori dan menyimpannya sebagai hal yang disebut permukaan SDL.
>> Sekarang permukaan SDL hanyalah struct yang mewakili data gambar dalam memori.
Sehingga Anda dapat membaca lebih lanjut tentang bahwa dalam dokumentasi dua.
Dan jika kesalahan ini, maka kita akan melakukan semuanya di mana
kami mencetak kesalahan, menutup kami sumber daya, dan kemudian keluar dari program.
Sekarang hal yang menarik adalah, sebelum kita dapat menarik gambar ini ke jendela,
kita harus benar-benar membuatnya tekstur.
Sekarang berkoresponden tekstur untuk data gambar dimuat
ke dalam memori grafis ini perangkat keras.
>> Jadi permukaan dalam utama memori, memori biasa
bahwa kita telah menggunakan semua semester, dan tekstur dalam VRAM terpisah ini
memori yang kontrol kartu grafis.
Jadi kita sebut fungsi ini SDL_CreateTextureFromSurface.
Kami memberikan penyaji dan permukaan kami.
Dan kemudian kita benar-benar dilakukan dengan permukaan,
jadi kita hanya akan membebaskan itu.
Kita tidak perlu lagi.
Dan kemudian jadi jika panggilan ini errored dan kembali nol,
maka kita akan melakukan keseluruhan melaporkan hal lagi kesalahan.
>> Baiklah.
Di sini, kita masuk ke beberapa fungsi render yang sebenarnya.
Jadi memanggil SDL_RenderClear dan lewat
renderer yang terkait dengan jendela kita hanya membuat jendela pergi hitam.
Sehingga menghilangkan bahwa sampah yang kita lihat dalam jendela kita sebelum dan membuatnya hitam.
Dan kemudian kita akan untuk memanggil SDL_RenderCopy,
memberikan penyaji kami, tekstur kami.
Dan kita akan berbicara tentang apa bidang ini dalam sedikit.
Tapi itu akan mengambil data tekstur
dan menyalinnya ke kami window untuk menggambar gambar.
Jadi setelah kami sudah melakukan copy ini data ke jendela kita,
kita harus melakukan fungsi tambahan ini disebut SDL_RenderPresent.
>> Dan ini menarik karena ini mendapat
menjadi topik yang disebut double buffering.
Jadi double buffering adalah teknik yang membuat grafis Anda terlihat jauh lebih baik.
Sekali lagi, mencegah yang robek layar Aku sedang berbicara tentang sebelumnya, di mana
Anda memiliki dua buffer.
Ada buffer kembali memori dan buffer depan.
Depan penyangga secara harfiah apa yang ada di layar Anda saat ini.
Jadi kita melakukan semua ini menarik variasi, seperti SDL membuat salinan atau SDL_RenderClear
untuk buffer kembali.
Jadi mereka memodifikasi hal-hal dalam buffer kembali.
Di sini kita bisa menggambar ini hijau persegi untuk buffer kembali.
>> Jadi ketika kita sudah selesai melakukan membuat operasi kami, yang
mungkin mengambil sangat panjang waktu, apa yang akan kita lakukan
adalah mengganti buffer.
Sehingga benar-benar hanya mengambil penyangga depan dan buffer kembali
dan switch mereka, sehingga itu, seketika,
dalam satu operasi, bukannya mungkin ratusan atau ribuan,
semua kami baru diberikan benda yang di layar.
Dan ini mencegah hal-hal seperti menyegarkan layar
ketika kita hanya ditarik setengah benda untuk frame.
Jadi itu sebabnya kita perlu memanggil SDL_RenderPresent, serta
sebagai SDL_RenderCopy.
>> Sekali lagi, kita hanya akan menunggu selama lima detik.
Kemudian kita akan membersihkan sumber daya kami.
Kami memiliki beberapa waktu ini.
Dan kemudian kita hanya akan untuk keluar dari program.
Jadi mari kita lakukan itu.
Aku akan mengetik make, dan kemudian sumber sama hello-- ini sekarang 3image.c.
Baiklah, yang disusun tidak ada kesalahan.
Dan Anda bisa lihat di sini saya sekarang ditarik keluar gambar saya, Hello, CS50!
untuk jendela kita, yang menghilang setelah lima detik.
>> Sekarang, ini masih memiliki masalah, kan?
Ini bukan aplikasi yang baik, karena ketika saya mencoba untuk menutup jendela,
tidak ada yang terjadi.
X yang masih belum responsif.
Jadi mari kita lihat pada file selanjutnya, hello4animation.
Jadi ini adalah file yang akan memperkenalkan
bergerak dan gerakan untuk gambar kita.
Jadi kita akan melakukan hal yang sama seperti sebelumnya,
memulai SDL, menciptakan jendela, membuat renderer,
memuat gambar menjadi memori, membuat tekstur.
Kami telah melihat semua itu sebelumnya.
Sekarang, ini adalah baru.
Kita akan telah struktur yang disebut sebuah rect SDL, yang hanya persegi panjang.
Jika kita pergi ke sini, kita bisa melakukan pencarian untuk SDL rect,
dan Anda dapat melihat itu struktur yang sangat sederhana.
Ini memiliki x, y untuk posisi, dan
memiliki lebar dan tinggi untuk ukuran persegi panjang.
>> Jadi apa yang kita akan lakukan adalah kita akan menentukan SDL ini rect dest,
untuk tujuan.
Dan ini adalah tempat pada layar di mana
kita akan menggambar image kami, tepat Jadi
jika kita akan menjadi gambar bergerak di sekitar,
maka tujuan mana kita akan menggambar gambar
harus bergerak di sekitar.
Jadi kita akan menyebutnya fungsi SDL_QueryTexture.
Dan melihat aku lewat alamat dari dest.w, yang lebar,
dan dest.h, yang ketinggian.
Dan SDL_QueryTexture akan untuk menyimpan dalam bidang-bidang lebar
dan tinggi tekstur kami.
>> Dan kemudian apa yang akan saya lakukan adalah saya akan
untuk mengatur dest.x menjadi jendela lebar dikurangi dest.w, yang
lebar sprite, dibagi 2.
Dan ini akan mengaturnya sehingga bahwa gambar yang sempurna berpusat
di jendela kita, oke?
Jadi sekarang aku punya posisi y.
Dan ini akan menjadi variabel yang
berubah, karena kita akan menjadi gambar bergerak dalam arah y.
Dan sekarang kami memiliki sesuatu disebut loop animasi.
>> Jadi bagaimana bekerja animasi?
Nah, mata manusia dapat mendeteksi 12 berbeda gambar dalam setiap detik, oke?
Jadi jika Anda flash 12 kartu gambar pada saya dalam kedua, saya melihat masing-masing gambar
sebagai citra individu sendiri yang berbeda.
Sekarang, jika Anda berkedip lebih gambar pada saya di kedua,
kemudian mata saya akan mulai kabur mereka bersama-sama
dan saya akan melihatnya sebagai gerakan, bukan satu gambar yang berbeda.
Jadi, misalnya, film dan televisi, mereka flash gambar pada Anda 24 kali
Sebentar.
Jadi itu 24 frame per detik.
Layar komputer, di sisi lain, sering berada di 60 frame per detik.
Itu menyegarkan kecepatan mereka.
Itulah seberapa sering mereka menyegarkan gambar di layar.
Jadi target kami akan menjadi 60 frame per detik untuk permainan kami.
>> Jadi mari kita melihat bahwa dalam kode.
Jadi untuk setiap frame, kami pertama akan membersihkan jendela.
Ini adalah pola umum.
Anda selalu membersihkan jendela setiap frame, dan kemudian
melakukan semua gambar Anda operasi, dan kemudian pada akhirnya,
jangan RenderPresent untuk menunjukkan segala sesuatu dalam frame.
Dan kemudian Anda akan memiliki menunggu di akhir
menunggu sampai berikutnya bingkai harus dimulai.
>> Jadi jika saya melakukan banyak perhitungan kompleks di sini
yang membawa lebih dari 16 milidetik, mustahil bagi saya
untuk mendapatkan frame rate 60 yang Saya ingin, karena setiap frame
terlalu lama untuk menghitung.
Selain itu, kami benar-benar melakukan semacam jumlah diabaikan kerja
di sini, karena hanya ada satu hal kita menggambar.
Jadi aku hanya menunggu 1/60 dari kedua, yang merupakan panjang
dari bingkai di antara frame.
Jadi aku semacam berpura-pura melakukan semua pekerjaan saya membutuhkan waktu nol.
Tapi dalam permainan nyata, Anda harus mengurangi
jumlah waktu yang dibutuhkan untuk melakukan semua pekerjaan ini dari waktu istirahat Anda.
>> Jadi, apa yang aku benar-benar melakukan dalam lingkaran ini?
Aku membersihkan jendela.
Aku mengatur dest.y, yang merupakan int untuk posisi y yang sebenarnya saya dilemparkan ke sebuah int.
Sekarang, saya ingin mengapung resolusi untuk posisi y saya dalam permainan saya,
tapi kemudian untuk benar-benar menggambar ke layar,
perlu int, karena itu dalam satuan pixel, jadi itulah yang pemain untuk.
Aku akan menggambar gambar.
Jadi ini adalah persegi panjang sumber.
Dan ini adalah persegi panjang tujuan.
Jadi aku melewati null untuk persegi panjang sumber
untuk mengatakan saya ingin menarik seluruh tekstur saya.
Tetapi jika Anda memiliki banyak tekstur dalam permainan Anda
dan mereka semua dalam satu peta tekstur besar yang dimuat ke SDL sebagai salah satu
tekstur, Anda bisa menggunakan persegi panjang sumber
untuk memilih salah satu tekstur yang lebih kecil, salah satu sprite kecil,
dari yang peta tekstur besar.
>> Jadi sekali lagi, aku melewati membuat saya, saya tekstur, dan sekarang tujuan.
Ini akan menjadi tempat di jendela itu akan ditarik.
Dan kemudian, karena aku menjiwai sesuatu, saya perlu gerakan,
Aku akan memperbarui posisi sprite pada setiap frame.
Jadi saya harus menelepon gulir konstan ini mempercepat dalam satuan pixel per detik.
Sekarang, setiap kali kita melakukan gerakan, frame hanya 1/60 detik.
Jadi aku akan membagi bahwa dengan 60.
Dan kemudian, mari kita lihat, aku mengurangkan bahwa dari posisi y.
Mengapa saya mengurangkan?
Kita akan sampai ke bahwa dalam satu detik.
Jadi kemudian aku membersihkan sumber daya saya dan program berakhir.
>> Jadi mari kita membuat itu.
Jadi mari kita pergi ke make SRCS = hello4 animation.c, oke?
Permainan.
Ini dia.
Jadi saya memilikinya bergulir sampai jendela, yang cukup rapi.
Tapi tunggu, saya mengurangkan dari y posisi setiap kali.
Apa yang sedang terjadi di sana?
Nah, ternyata di SDL, dan pada kenyataannya, di sebagian besar komputer grafis,
asal untuk sistem koordinat adalah kiri atas dari jendela.
>> Jadi arah x positif pergi di jendela Anda ke kanan.
Dan y arah positif sebenarnya turun.
Jadi sekali lagi, dalam asal ini kiri atas jendela,
positif y arah turun, dan x positif adalah ke kanan.
Jadi ketika saya kurangi dari posisi y, itu
akan membuatnya pergi pada hal yang negatif y arah, yang naik jendela.
Jadi itulah yang terjadi di sana.
Keren.
>> Mari kita lihat file selanjutnya.
Berikut adalah bagian dari menunjukkan di mana kita akhirnya
mendapatkan bahwa X di sudut jendela yang seharusnya untuk menutup jendela
bekerja.
Jadi apa yang terjadi?
Kami menginisialisasi SDL, membuat jendela, membuat penyaji, memuat gambar,
membuat tekstur seperti yang telah kita lihat sebelumnya.
Kami memiliki tujuan yang sama persegi panjang seperti sebelumnya, panggilan yang sama untuk query tekstur.
Tapi kali ini, kami kemudian akan membagi lebar
dan tinggi tujuan kami dengan 4.
Ini hanya memiliki efek skala gambar kami turun saat
kami menampilkannya dalam jendela oleh empat.
Jadi itu cukup rapi.
Kami hanya dapat skala seperti itu.
Kita akan mulai sprite di tengah layar.
Dan sekarang kami memiliki x dan y dan kecepatan mereka berdua akan mulai nol.
>> Ini adalah file yang salah.
Maafkan saya.
Jadi itu semua benar.
Itu semua masih dalam file ini.
Kami memiliki bagi dengan 4 dan segala sesuatu.
Jadi di sini kita memiliki kita x dan y posisi untuk pusat jendela.
Dan kami memberikan kecepatan awal kecepatan konstan ini, yang
Saya percaya adalah 300 piksel per detik.
Sekarang, kami memiliki int ini bisa juga menjadi boolean disebut dekat diminta.
Dan bukannya melakukan sebuah loop tak terbatas pada timer di sini,
kita akan menghidupkan sebagai Selama dekat tidak diminta.
>> Jadi bagaimana kita memproses peristiwa?
Nah, SDL antrian sampai peristiwa di antrian literal belakang layar.
Dan kemudian setiap frame, kita bisa dequeue peristiwa
dari yang menggunakan antrian SDL_PullEvent panggilan ini.
Dan lagi, pasti pergi baca tentang hal ini di dokumentasi.
Ada lebih banyak detil dan banyak fungsi yang lebih Anda dapat menggunakan dengan ini.
Kami lulus alamat hal ini, SDL_Event
yang kita miliki di sini di stack.
>> Sekarang, apa yang merupakan SDL_event?
Karena SDL, jika kita melihat di yang documentation-- mari
lihat, API berdasarkan kategori, masukan peristiwa, penanganan event,
kita dapat melihat nomor dari berbagai peristiwa di sini
dan kita bisa melihat ada satu ton seluruh dari mereka.
Jadi apa hal SDL_Event ini?
SDL_Event adalah serikat buruh.
Wow, apa serikat?
Anda mungkin pernah pernah mendengar tentang itu sebelumnya.
Dan itu OK.
>> Sebuah serikat adalah jenis seperti struct, kecuali struct
memiliki ruang untuk semua bidang dan memori,
sedangkan serikat hanya memiliki cukup ruang untuk menyesuaikan terbesar
salah satu bidang, yang berarti hanya dapat menyimpan satu bidang yang
pada waktu, yang jenis masuk akal untuk acara, kan?
Kita dapat memiliki keyboard kejadian atau peristiwa jendela,
tapi peristiwa tunggal tidak dapat menjadi seorang acara keyboard dan acara jendela,
sehingga akan konyol untuk memiliki ruang untuk kedua dari mereka dalam serikat acara kami.
Jadi jika Anda ingin membuat serikat Anda sendiri,
terlihat persis sama sebagai menciptakan struct,
kecuali bahwa kita menggunakan kata kunci union bukannya kata kunci struct.
Dan ingat, untuk semua hal di dalam serikat Anda,
variabel aktual yang serikat hanya dapat memiliki satu dari nilai-nilai
pada suatu waktu.
>> Jadi bagaimana kita bisa tahu apa jenis acara kita hanya muncul dari antrian ini?
Nah, kita bisa menguji event.type.
Dan jika itu adalah sama untuk SDL_Quit, kita tahu
itu hal dihasilkan ketika kita
hit bahwa X di sudut jendela.
Dan kita bisa mengatur dekat diminta sama dengan 1.
Sisanya hanya beberapa animasi yang telah Anda lihat sebelumnya.
Jadi mari kita pergi ke depan dan membuat ini dan melihat seberapa baik kerjanya.
Jadi aku akan mengetik make dan kemudian SRCS = hello5_events.c.
Di sana kami pergi.
Pertandingan.
>> Sekarang, kita bisa melihat itu memang diperkecil oleh empat.
Dan sekarang itu terpental sekitar.
Saya memiliki beberapa tabrakan terjadi dengan sisi jendela
bahwa kita bisa melihat pada.
Dan apa yang terjadi ketika saya pergi untuk menutupnya?
Menutup.
Fantastis.
Kami menerima peristiwa itu.
Dan kami menanganinya.
>> Jadi mari kita melihat kembali kode.
Jadi bagaimana saya mendapatkannya terpental sekitar seperti itu?
Ingat saya set kedua x dan y awalnya untuk kecepatan.
Dan kecepatan adalah positif konstan, jadi itu
akan mendapatkannya mulai keluar turun dan ke kanan.
>> Sekarang, setiap frame, selain penanganan setiap peristiwa yang mungkin terjadi,
Aku akan mendeteksi apakah sprite saya sedang mencoba untuk pergi keluar dari jendela.
Jadi kita dapat melakukannya dengan hanya memeriksa x_pos dengan 0, y_pos 0, dan kemudian
juga x_pos dan y_pos dengan lebar jendela dan tinggi jendela.
Perhatikan Aku sudah dikurangi lebar sprite.
Dan ini adalah karena jika saya tidak kurangi lebar dari sprite,
itu hanya akan memeriksa bahwa asal sprite
tidak pergi ke luar jendela.
Tapi kami ingin seluruh yang lebar sprite
untuk selalu berada di dalam jendela dan seluruh ketinggian sprite
untuk selalu berada di dalam jendela.
Jadi itulah yang pengurangan adalah untuk.
Banyak geometri sini dapat membantu untuk menarik keluar
di atas kertas dengan koordinat sistem untuk melihat apa yang sedang terjadi.
>> Jadi jika saya bertabrakan, saya hanya hanya mengatur ulang posisi
sehingga tidak akan keluar dari layar.
Dan aku akan, jika memantul di salah satu dinding samping,
Aku akan meniadakan x kecepatan sehingga
mulai memantul ke arah lain.
Dan sama, jika hits bagian atas atau bawah,
Aku akan mengatur kecepatan y sama dengan kecepatan y negatif,
sehingga akan bangkit kembali.
Jadi itu hanya bagaimana kita sampai di sini.
>> Dan posisi memperbarui seperti yang telah kita lihat sebelumnya,
membagi dengan 60, karena kita hanya menangani 1/60 detik.
Dan kemudian rendering, persis sama seperti sebelumnya.
Dan jadi itu semua yang terjadi file ini.
Jadi itulah bagaimana kita melakukan acara.
Hal utama untuk mengambil di sini adalah fungsi SDL_PullEvent ini.
Dan Anda pasti harus membaca dokumentasi tentang SDL_Event
serikat, karena ini adalah tipe data sangat, sangat penting, karena kita menggunakannya
untuk segala macam acara.
>> Sebagai contoh, kita menggunakannya untuk keyboard peristiwa, yang adalah apa file ini adalah untuk.
Jadi apa yang kita miliki?
Kami memiliki hal yang sama seperti sebelumnya, menginisialisasi SDL, membuat jendela,
membuat penyaji, memuat gambar ke dalam memori, membuat tekstur.
Sekali lagi, kita akan memiliki dest persegi panjang ini,
kita akan skala gambar oleh empat, membuatnya sedikit lebih kecil.
Sekarang, kita akan memulai sprite di tengah layar.
Tapi kali ini, kita akan mengatur x dan y kecepatan awal nol,
karena keyboard adalah akan mengontrol mereka.
Dan selanjutnya, kita akan melacak variabel tersebut
atas, bawah, kiri, dan kanan.
Dan itu akan terus melacak apakah kita sudah
menekan tombol-tombol keyboard yang sesuai dengan atas, bawah, kiri,
dan kanan.
>> Sekarang, ini adalah jenis mewah karena kita dapat menggunakan W, A, S,
D sini, atau tombol panah yang sebenarnya.
Kita akan melihat bahwa hanya dalam detik.
Jadi kita akan memproses acara seperti sebelumnya.
Kita tarik acara tersebut.
Tapi sekarang kita akan beralih pada jenis acara.
Jika itu SDL_Quit, kami akan mengatur dekat
diminta untuk satu, sama seperti sebelumnya.
Yang menangani x di sudut jendela,
sehingga jendela kita benar-benar menutup.
>> Jika tidak, jika kita mendapatkan kunci SDL turun acara, yang berarti kita menekan tombol,
maka apa yang kita akan lakukan adalah kita akan beralih pada hal ini di sini,
yang means-- sehingga event.key berarti memperlakukan serikat acara kami,
pergi dan mendapatkan kunci Struktur acara di dalamnya.
Jadi ternyata bahwa ini serikat adalah struktur peristiwa penting.
Dan kemudian pergi ke tombol Struktur acara bidangnya
disebut Keysym dan kemudian scancode.
Dan lagi, pasti baca dokumentasi tentang hal ini.
Masukan kata kunci cukup menarik.
Anda bisa mendapatkan kode scan atau kode kunci.
Dan itu sedikit halus, tapi dokumentasi cukup baik.
>> Jadi jika kita melihat memindai kode untuk tekan tombol kami menjadi W atau up,
kita akan mengatur sama dengan 1.
Dan kemudian kami keluar dari saklar yang.
Jika itu A atau kiri, kami menetapkan kiri ke 1, et cetera, et cetera, untuk turun dan kanan.
Sekarang, di saklar luar ini, jika kita melihat kunci up acara,
itu berarti kita telah merilis kunci dan kita tidak lagi menekan itu.
Jadi aku akan mengatakan up sama dengan 0, kiri sama dengan 0, turun sama dengan 0, tepat
sama dengan 0, dan sebagainya.
>> Dan melihat kita miliki dalam masing-masing dua kasus diletakkan tepat di samping satu sama lain
tanpa kode yang terpisah untuk kasus pertama, yang
Artinya apakah itu S atau bawah di sini,
itu akan mengeksekusi kode ini.
Jadi itu cukup berguna.
Ini mencegah kita harus melakukan lebih kondisi dan ifs dan hal
seperti itu.
>> Jadi kita akan menentukan kecepatan.
Kami mengatur kecepatan untuk 0.
Kemudian jika up ditekan dan tidak turun, maka kita
mengatur y kecepatan untuk kecepatan negatif.
Ingat negatif, karena negatif arah y terserah.
Dan y arah positif turun.
Jika bawah ditekan dan tidak sampai, maka kita
akan mengaturnya untuk kecepatan positif, yang berarti turun layar.
Hal yang sama dengan kiri dan kanan.
>> Dan kemudian kita akan memperbarui posisi seperti sebelumnya.
Kami akan melakukan tabrakan deteksi dengan batas,
tapi kami tidak akan me-reset kecepatan, karena kecepatan hanya
dikendalikan oleh keyboard.
Tapi kita akan me-reset posisi untuk tetap di jendela.
Dan kita akan mengatur posisi di struct
dan kemudian melakukan semua render barang dari sebelumnya.
Jadi mari kita lihat apa yang dilakukannya.
Jadi membuat SRCS-- mari kita lihat, ini hello6_keyboard.c.
>> Oh tidak.
Jadi kita punya beberapa peringatan di sini.
Dan itu hanya mengatakan kami tidak memeriksa setiap kemungkinan jenis tunggal
acara.
Itu OK, karena ada 236 dari mereka atau lebih.
Jadi saya akan mengabaikan peringatan-peringatan.
Ini masih disusun dengan baik.
Jadi aku akan bermain game.
Itu tidak bergerak.
Tapi sekarang, ketika saya tumbuk pada keyboard, Aku bisa melakukan beberapa gerakan WASD sini,
Saya menggunakan tombol panah saya juga.
Dan perhatikan, meskipun aku menekan tepat sekarang,
itu tidak akan keluar dari jendela, karena saya ulang pada setiap frame.
Jadi itu cukup rapi.
Anda bisa membayangkan bergerak Mario dengan beberapa tombol panah atau sesuatu seperti itu.
Dan ya, X tidak bekerja.
>> File sehingga akhir kita akan untuk melihat, hellow7_mouse.
Ini adalah tentang mendapatkan masukan mouse.
Jadi dalam satu ini, kita mengimpor header matematika,
karena kita akan memiliki sedikit matematika di sini.
Sama tua, sama tua hal, tujuan, sama tua, melihat itu sebelumnya.
Nah, ini menarik.
Jadi kita kembali ke hanya memeriksa untuk SDL berhenti acara.
Kenapa itu?
Jadi Anda bisa mendapatkan masukan mouse dari acara.
Seperti ketika mouse bergerak, Anda mendapatkan sebuah acara untuk itu.
Ketika tombol mouse ditekan, Anda bisa mendapatkan sebuah acara untuk itu.
>> Tapi ada yang lain, sedikit lebih sederhana mungkin, API untuk mendapatkan masukan mouse.
Dan itu hanya SDL negara get tikus.
Jadi saya memiliki int untuk x dan y untuk posisi kursor.
Saya lulus ke SDL_GetMouseState, yang menetapkan ini.
Dan ini adalah posisi di sistem jendela koordinat.
Jadi jika massa berada di kiri atas jendela, yang akan 0, 0.
>> Sekarang, apa yang akan saya lakukan adalah saya akan untuk melakukan sedikit vektor matematika.
Saya yakin Anda pikir Anda tidak akan melihat bahwa dalam CS50, tapi di sini adalah.
Aku akan melakukan beberapa vektor matematika untuk mendapatkan vektor
dari gambar untuk kursor.
Dan jadi mengapa saya harus pengurangan ini di sini?
Nah, jika saya hanya menggunakan dest .-- sehingga Saya perlu menerjemahkan mouse x
dan y setengah lebar dan ketinggian gambar,
karena saya ingin pusat gambar yang akan pergi ke arah mouse,
tidak asal gambar.
>> Jadi itu hanya untuk memastikan saya bicarakan tentang tengah gambar di sini.
Kemudian kita mendapatkan delta x dan y, yang adalah perbedaan dari target
ke posisi yang sebenarnya dari gambar.
Dan kemudian kita bisa mendapatkan menjauhkan sini, yang
akan menjadi Pythagoras teorema, akar kuadrat dari x
kali x ditambah y kali y.
>> Sekarang untuk mencegah jitter, dan saya bisa menunjukkan Anda apa yang dilakukan jika saya tidak melakukan ini,
jika jarak antara kursor dan pusat gambar kurang dari lima,
Aku hanya tidak akan memindahkan gambar.
Jika tidak, kita mengatur kecepatan.
Dan kita mengaturnya sehingga kecepatan akan selalu konstan.
Dan hasil bersih dari semua matematika ini adalah bahwa gambar
akan bergerak menuju kursor.
>> Sekarang, ternyata bahwa SDL_GetMouseState,
selain pengaturan x dan y argumen di sini,
itu juga mengembalikan sebuah int yang sesuai dengan keadaan tombol mouse.
Jadi kita tidak bisa membaca bahwa langsung, tapi kita bisa
menggunakan macro ini, satu Operator bitwise, tidak menakutkan,
hanya bitwise dan.
Jadi kita katakan tombol, yang merupakan hasil dari SDL_GetMouseState kami, jika itu
dan bitwise dan, makro ini di sini, SDL_BUTTON_LEFT.
>> Jadi ini akan hanya menyelesaikan ke bitmap yang sesuai
untuk tombol kiri mouse ditekan.
Dan jadi jika bitwise dan terjadi dan itu
tidak nol, yang berarti tombol kiri ditekan,
maka kita benar-benar akan meniadakan kedua x dan y kecepatan,
yang hanya akan membuat pelarian gambar.
Posisi Update.
Tabrakan deteksi, melihatnya semua sebelumnya, rendering, baik-baik.
Mari kita membuatnya.
Jadi Anda punya membuat SRCS = hello7_mouse.c.
Besar.
Tidak ada kesalahan.
Dan permainan.
>> Jadi di sini saya punya mouse saya.
Dan gambar memang mengejar mouse.
Sekarang, dalam permainan Anda membuat, mungkin ini adalah seperti mengejar musuh
karakter kecil Anda atau apa pun.
Tapi di sini kita memiliki gambar mengejar mouse.
Dan ketika saya klik, mouse mulai mengejar gambar
dan gambar melarikan diri dari tikus.
Jadi itu cukup keren.
Dan pemberitahuan lagi, ada masih deteksi tabrakan di sini.
>> Jadi itu adalah sedikit akhir demo Saya telah menyiapkan sini.
Dan mari kita lihat satu hal lagi.
Jadi kembali ke sini, saya sebutkan jitter ini.
Baiklah.
Jadi jika jarak kurang dari lima piksel, Aku sedang menyiapkan x dan y kecepatan nol.
Apa yang terjadi jika kita menyingkirkan itu?
Jadi aku akan lakukan ini.
Maafkan gaya menghebohkan ini, tapi kami komentar kode yang benar.
Jadi aku akan menyimpan itu dan melakukan perintah yang sama dari sebelumnya untuk membuatnya.
>> Baiklah.
Dan sekarang apa yang terjadi?
Baik.
Kami masih mengikuti tikus seperti sebelumnya,
tapi ketika kita sampai ke mouse, kita punya jitter kotor ini.
Apa yang sedang terjadi di sana?
Nah, di vektor kami matematika, ingat kami
mengambil jarak antara kursor dan tengah gambar?
Nah, karena itu pendekatan 0, kita mulai mendapatkan
seperti perilaku semacam ini gila di mana gambar adalah semacam
seperti berosilasi di sekitar kursor.
Dan itu membuat jitter ini.
Dan itu benar-benar jelek.
Dan Anda mungkin tidak ingin permainan Anda melakukan hal itu,
kecuali itu semacam efek khusus.
>> Jadi itu sebabnya kita memiliki hanya ini sewenang-wenang
memotong lima piksel, di mana kita mengatakan jika dalam waktu lima piksel, kita baik.
Kita tidak perlu memindahkan gambar lagi.
Jadi itulah yang terjadi di sana.
>> Jadi itu cukup banyak itu.
Anda sekarang tahu cara membuat jendela, memuat gambar,
menggambar gambar ke jendela, dapatkan input keyboard, mendapatkan masukan mouse,
ada sekelompok lainnya masukan bahwa Anda tidak akan
tahu bagaimana untuk mendapatkan jika Anda hanya menghabiskan beberapa menit melihat dokumentasi.
Jadi Anda benar-benar memiliki cukup Beberapa alat yang Anda inginkan sekarang
untuk menulis permainan penuh.
>> Sekarang, setiap pertandingan membutuhkan beberapa audio, tapi dokumentasi audio yang
ini juga cukup bagus.
Dan aku berani bertaruh bahwa jika Anda memahami semua hal
kita berbicara tentang hari ini dengan gambar, dan permukaan,
jendela, dan segala sesuatu, maka mencari tahu API audio tidak
akan menjadi yang buruk.
Jadi saya berharap untuk melihat apa yang Anda buat dengan SDL.