THOMAS buhay na buhay na: Ang lahat ng karapatan.
Hi, sa lahat.
Ako Thomas Lively.
Seminar na ito ay magiging pagsulat ng mga 2D na laro sa C gamit SDL.
Kaya alam ko na ikaw ay ang lahat ng nagtatanong, oo, i really
nais na i-play ang mga laro at gumawa ng mga laro, ngunit kung ano ito SDL negosyo?
Kaya SDL ay isang C library.
Ito ay kumakatawan sa mga Simple DirectMedia Layer.
At ito ay isang cross platform, game library unlad.
Ito ay gumagana sa Windows, Mac, Linux, kahit iOS at Android.
Ito ay pinangangasiwaan ng mga bagay tulad ng access sa mga sistema ng audio
para sa mga computer, ang keyboard, at mouse, joystick, kung sila ay naka-attach.
Sa mobile, maaari ito kahit na gawin ang pindutin ang input at ang lahat ng iyon.
At siyempre, humahawak ito graphics, pagguhit ng mga bagay sa screen.
>> Kaya ito ay masyadong malawak na ginagamit, kahit na hindi mo maaaring may narinig ng mga ito bago.
Ito ay binuo sa, halimbawa, Source engine balbula,
kung saan ang kapangyarihan mga laro tulad ng Portal at Team Fortress 2.
Ito din ay sa isang napakalaking bilang ng indie games na lumabas,
kaya ako nasasabik upang makita kung ano ang iyong lahat ay ang paggawa ng mga ito.
>> Ang mga layunin ay mga seminar upang makakuha ka nakalagay na bumubuo ng may SDL.
Kami ay pagpunta upang malaman kung paano upang lumikha ng isang window ng laro.
Kami ay pagpunta upang lumikha ng sprites, na kung saan ay ang mga imahe sa iyong mga laro
na maaaring ilipat sa paligid.
Kami ay pagpunta upang malaman kung paano sa at pagalawin ang mga sprites,
kaya ilipat ang mga ito sa paligid, gumawa silang baguhin sa paglipas ng panahon.
At kami ay pagpunta upang malaman kung paano upang makuha ang keyboard at mouse
input mula sa computer.
Ano ay hindi pinag-uusapan natin tungkol sa ngayon ay 3D graphics,
dahil iyon ay isang napaka-komplikadong paksa na hindi namin ay may oras para sa.
Hindi namin malaman kung paano i-play ang audio sa aming mga laro.
At hindi namin gusali para sa anumang ngunit Linux.
>> Ngayon ang caveats may mga iyon, sana, sa pagtatapos ng seminar,
makikita mo ang kumportable sa ang dokumentasyon SDL,
kaya makikita mo na pumunta malaman paano mag-play ng audio para sa iyong sarili.
Gusali Gayundin para sa Mac o PC ay dapat na gumana eksaktong katulad ng gusali para sa Linux,
ngunit ang setup pupuntahan maging isang maliit na naiiba.
Kaya dapat mong malaman kung paano gawin ang mga bagay na
sa pagtatapos ng seminar ngayong araw.
>> Kaya para sa pag-set up, kami ay pagpunta na gumamit ng isang virtual machine.
Nais naming gamitin ang CS50 IDE, dahil lang kami pupunta sa pagsusulat sa C.
Ngunit dahil ang IDE ay hindi isang browser, namin hindi maaaring lumikha ng mga bagong window o display
graphics sa loob nito.
Kaya kailangan namin ng isang virtual machine.
Kaya maaari mong sundin ang mga tagubilin dito sa manual.CS50.net/appliance/15
upang i-install ang mga opisyal na CS50 appliance, na kung saan ay lamang ng isang virtual Linux
machine.
>> At pagkatapos ay sa sandaling ikaw ay may na-set ang lahat up-- ito
Maaaring tumagal nang kaunti, dahil isang napakalaking download-- ikaw ay pagpunta
upang tumakbo sa VM sudo apt-get update.
At iyon ang tunay na nangyayari upang i-update ang lahat ng mga software
mga pakete sa iyong mga virtual machine.
>> Pagkatapos nito, kayo ay pagpunta upang tumakbo sudo apt-get-install, libsdl2-2.0-0,
libsdl2-DBG, libsdl2-dev, at Karagdagan libsdl2-image-2.0-0,
libsdl2-image-DBG, at libsdl2-image-dev.
Kaya kung ano na gagawin?
Nag-install na at wala na ang debug impormasyon, dokumentasyon, mga header,
at binaries para sa dalawang mga aklatan.
Regular old, SDL 2.0, at isa pang library
tinatawag Image SDL, na kami ay pagpunta sa gumagamit
upang i-load ang mga file ng imahe sa aming mga laro.
>> Kaya sa sandaling mayroon na rin sa iyo na, lamang kapag ito nagtatanong,
type mo lang oo, pindutin ang Enter mag-install ng mga pakete,
at pagkatapos ay dapat maging handa na upang patakbuhin.
Kaya upang makuha ang code na pamamahagi, ikaw can-- naku, ito ay hindi na-update.
Maliban na lamang kung ikaw ay may isang GitHub account-- kung mayroon kang isang GitHub account,
maaari mong gawin ito Git clone utos sa repo
at na i-download ang Git repo sa lahat ng mga code sa mga ito,
sa gayon ay magkakaroon ka ng code.
>> Kung hindi ka magkaroon ng isang GitHub account, ano ang dapat mong gawin ay i-type
wgithttps: //github.com/tlively/sdl seminar-- at dito ito ay different--
/archive/master.zip.
Kaya muli, na ang eksaktong parehong URL, maliban ito ay magiging
tlively / SDL_seminar / master.zip at gumagamit ka ng wgit upang i-download na.
At pagkatapos ay maaari mo lamang magsiper na archive
at pagkatapos ay magkakaroon ka ng lahat ng mga source code.
Kaya paumanhin tungkol sa na.
At pagkatapos ay ang code ay din ay naka-host sa web page CS50 seminar sa isang pares
araw.
>> Lahat tama.
Kaya paano natin umpisahan pagsusulat ng aming sariling mga laro?
Well, ang unang bagay kami ay pagpunta sa gusto mong gawin
ay tingnan ang SDL babasahin.
Kaya dito ang VM.
At narito ang mga web page.
Na nag-navigate kong mabuhay libsdl.org.
Ano ako pagpunta sa gawin dito ay pumunta sa paglipas ng sa sidebar, sa ilalim ng mga babasahin,
at i-click ang wiki.
Ito ay magdadala sa akin sa wiki na may karamihan ng mga babasahin para sa SDL.
Higit sa sidebar dito, hindi namin pagpunta sa i-click ang API sa pamamagitan ng kategorya,
dahil ay upang mabigyan kami ng isang magaling pasubali na view
ng buong API para SDL.
>> Kaya halimbawa, mayroon kaming ang pangunahing Pinasimulan
at shut down, ang lahat ng mga uri ng mga administrative mga bagay-bagay para sa paggamit ng SDL,
at pagkatapos kami ay may mga seksyon para sa pagpapakita ng mga bagay sa screen.
Iyon ang video.
Input mga kaganapan, na ang pagkuha input mula sa keyboard,
pagkuha ng input mula sa mouse, at ang joystick, kung mayroon ka nito kahit.
May lakas ng feedback para sa mga bagay tulad ng laro controllers, na
hindi namin pagpunta sa makipag-usap tungkol sa.
At narito ang audio.
At pagkatapos ay may isang bungkos ng iba pang mga mga bagay-bagay na maaaring gawin SDL para sa iyo.
>> Ngunit ngayon kami ay pagpunta sa focus sa Pinasimulan dito,
pagpapakita ng mga larawan sa video seksyon, at paghawak ng mga kaganapan ng input.
Kaya ito ang mga pangunahing seksyon ng mga babasahin
na dapat ay nababahala tungkol sa.
Katuwaan lang, kung pumunta kami sa paglipas ng dito at mag-click sa API sa pamamagitan ng pangalan,
maaari naming makita ang isang listahan ng bawat solong bagay sa SDL library.
Kaya ang lahat ng mga function, enumerations, kaayusan, isang mabaliw halaga ng mga bagay-bagay,
alpabetikong order.
At malinaw, hanggang sa alam mo ang ginagawa mo,
na ito ay hindi magiging masyadong helpful, na kung saan ay kung bakit namin API sa pamamagitan ng kategorya.
>> Kaya sabihin makapagsimula.
Sana na sa iyo na download na ang code sa pamamahagi.
At kaya kung ano ang maaari mong gawin ay, right dito sa CS50 appliance,
buksan lamang ang isang terminal.
Ayan na naman.
Kaya na-download ko ang code distribution gamit ang .zip
method.
At unzipped ko na ito.
Kaya dito ito ay sa SDL seminar master.
Kaya ako pagpunta sa pumunta sa directory na iyon.
At ano ang nakikita natin dito ay na kami ay may pitong C file.
At ito ay pagpunta sa code kami ay pagpunta sa tumitingin ka sa araw na ito.
Kami ay may isang makefile.
At kami ay may isang direktoryo na yaman, kung saan ay may lamang ng isang imahe
na ikaw ay nakakakita sa lalong madaling panahon sapat.
>> Kaya ng magbukas ng mga file na ito ipaalam gamit ang G-edit editor.
Kaya gusto ko upang buksan ang lahat ng mga file na magsimula sa hello at magtapos sa c.
Ayan na naman.
Kaya na ang isang maliit na maliit na window, kaya hindi namin pagpunta sa subukan na gumawa na ng mas malaki.
Hindi, ito ay umalis.
>> Lahat tama.
Kaya dito ay ang pinakaunang file kami ay pagpunta sa tumingin sa.
Ito ay tinatawag na hello1_sdl.c.
At lahat ng ito ay ay magpasimula ng SDL library upang maaari naming simulan ang paggamit nito.
Paano mo malalaman na dumating up sa iyong sarili ang code na ito?
Well, kung tiningnan namin sa paglipas ng ang dokumentasyon
at pumunta kami sa Pinasimulan at shut down na seksyon,
ito ay pagpunta sa sabihin sa amin ang lahat ng tungkol sa kung paano magpasimula SDL.
Kaya basahin ang tiyak na ito sa ibang panahon.
Ito ay pagpunta sa sabihin sa iyo ang lahat tungkol sa kung ano ang nangyayari sa dito.
Ngunit ang pangunahing puno ng problema ay na kailangan naming tawagan ang function na ito SDL Sa Ito
at pumasa ito sa kung ano ang mga uri ng mga bagay-bagay Gusto namin ang mga library upang magpasimula.
Kaya sa aming kaso, lang kami upang magpasimula ng video para sa ngayon,
sa gayon ay maaari simulan namin ipinapakita ang mga imahe.
>> Higit dito, maaari mong makita kung namin mag-click sa isang SDL In It, namin
ay maaaring makakuha ng mas higit pang impormasyon, kasama na ang mga halaga ng pagbabalik.
Kaya makikita natin dito na ito returnes zero sa tagumpay.
Kaya sa aming code, kami ay pagpunta sa makita kung ito ay hindi bumalik sa zero,
at kung ito ay hindi bumalik zero, kaya ito ay hindi matagumpay,
pagkatapos kami ay pagpunta upang lamang i-print ng isang error gamit ang iba pang mga function,
SDL error get, na nagbabalik ng isang string naglalarawan ng mga error na naganap.
Kami ay pagpunta sa i-print na error at pagkatapos ay hindi namin lamang
pagpunta sa lumabas sa programa na may isang error code.
>> Pagkatapos ng isa pang bagay na kailangan namin gawin ay, bago labasan program,
kung matagumpay naming initialize SDL, kailangan lang namin sa tawag na ito umalis SDL.
At na ang pagpunta sa hawakan paglilinis up lahat ng mga panloob na mga mapagkukunan SDL para sa atin.
Kaya ang mga babasahin there-- muli, dito tayo sa Pinasimulan
at shut down na seksyon ng mga babasahin.
Maaari mong i-click lamang sa function na dito, SDL umalis,
at maaari mong basahin ang lahat ng tungkol na rin.
At ng maraming mga pag-andar dokumentasyon na pahina
Mayroon halimbawa code, kaya ito ay tunay mabuti resource.
Talagang gumastos ng ilang oras pagbabasa ng mga bahagi ng mga ito wiki
kung ikaw ay pagpunta sa gawin na ito para sa isang proyekto.
>> Lahat tama.
Kaya na ang aming buong programa.
Ano ang maaari naming gawin ngayon is-- Ako pagpunta upang buksan ang makefile dito,
kaya ako pagpunta sa tumagal ng isang tumingin sa kung paano na gumagana.
At ito ay isang napaka-simpleng makefile, katulad ng kung ano ang iyong nakita bago.
Isa sa mga pangunahing pagkakaiba ay na, dito, ito
ay pagpunta sa ipasok ang resulta ng pagtakbo ang utos na ito, na kung saan na sa iyo na
naka-install na kung na-install SDL.
At ito ay isang utos na pagpunta sa bumuo ng
ilang dagdag na mga flag para sa mga compiler.
>> Bilang karagdagan sa na, kami ay nagbibigay ito lahat ng mga karaniwang mga utos, pati na rin
mga dalawang utos.
Kaya ang mga hawakan -lsdl2-image nagli-link sa SDL library ng larawan.
At ang -lm tunay na humahawak sa pag-uugnay sa standard C math library.
Kaya hindi namin ay pagpunta sa kailangan mga para sa lahat ng aming mga C file,
ngunit ilagay ang mga ito pa lang namin sa gayon maaari naming gamitin ang parehong makefile para sa lahat
walang pagbabago.
>> Sa paglipas dito sa mga pinagkukunan, ito ay kung saan Gusto mo
ilagay ang mga file na ikaw ay pagpunta sumulat ng libro para sa iyong proyekto.
Ngunit, dahil ang bawat isa sa aking C file dito ay may isang pangunahing pag-andar,
ito ay pagpunta upang makakuha ng nalilito kung namin ilagay ito lahat sa.
Kaya pupuntahan ko lamang na sabihin, para sa ngayon, hello1_sdl.c,
kung saan ay ang isa namin lamang ay tumingin sa.
Kaya kung pumunta ako pabalik sa paglipas ng dito, maaari ko gumawa.
At kung ano ito ginawa ay ito lamang pinagsama-sama na ang unang file.
At pagkatapos ay maaari naming i-type ./game, dahil ito ay ang mga maipapatupad na ito ginawa.
At lahat ng ito ay ay print matagumpay Pinasimulan.
Kaya ginawa namin ang isang bagay kanan.
Ngunit na uri ng panganganak, dahil hindi namin makita ang isang window,
walang ay gumagalaw sa paligid.
>> Kaya mahusay, nakuha namin SDL nasimulan.
Ngayon, ilipat sa isang bagay hayaan isang maliit na mas kawili-wili.
Kaya dito kami hello2_window.c, at ito ay magiging isang bahagyang mas
complex program C na initializes SDL tulad ng dati,
maliban na rin ngayon kami ay pagpunta upang magpasimula timer SDL.
At ito ay pagpunta sa ipaalam sa amin ma-access ang mga panloob na timer
at paggamit function na may kaugnayan sa oras.
>> At tingnan natin pababa dito pagkatapos ay hayaan.
Ano ang ginagawa namin ay taglay namin ang pointer sa isang SDL window struct, na
ay pagpunta sa malikha sa pamamagitan ng tawag na ito sa function, SDL lumikha ng window.
Ngayon, ito ay tumatagal ng maraming mga argumento, kaya pumunta tingnan ang dokumentasyon ipaalam.
Kaya muli, pupuntahan ko API sa pamamagitan ng kategorya, ako
babaan sa video dito, at ang unang seksyon, pagpapakita ng pamamahala window.
Kaya ang seksyon na ito ay may isang tonelada ng mga bagay-bagay sa loob nito,
ngunit kung titingnan mo sa pamamagitan ng mga function na ito, makikita mo
makita na marahil ang isa namin nais ay tinatawag SDL lumikha ng window,
na ang mangyayari sa kanan sa itaas.
>> At kaya ito ay ang babasahin para sa function na ito.
Ang bintana ay pagpunta sa magkaroon ng isang pamagat, isang x at y posisyon sa screen,
ito ay pagpunta sa magkaroon ng isang lapad, taas, at pagkatapos ito ay pagpunta sa tumagal ng ilang mga flag.
Ngayon, kami ay hindi aktwal na pag-aalaga tungkol anuman sa mga flags sa ngayon,
ngunit kung nais mong gawin ang isang bagay tulad ng gumawa ng isang full screen window,
maaari kang kumuha ng isang pagtingin sa na.
Para sa ngayon, lamang kami ay pagpunta na gamitin ang mga espesyal na mga halaga,
SDL window plus nakasentro para sa x at y sa order
upang lumikha lamang ang window sa gitna ng aming mga screen.
>> Kaya na kung ano na ang ginagawa.
At kung window mangyayari sa maging null, ibig sabihin ay may isang error,
pagkatapos ay muli na lang kami ng pagpunta sa i-print ang mga error gamit SDL get error.
At pagkatapos ay sapagkat hindi namin nasimulan SDL, kailangan namin ngayon upang isara ito.
Kaya ang tawag namin sa SDL umalis bago pagbabalik ng isa para sa main.
>> Kaya mayroon kaming buksan ang window na ito sana.
At kung ano ang namin ang pagpunta gawin ay kami ay pagpunta
upang tumawag SDL para sa 5,000 milliseconds, na kung saan ay ang parehong bilang ng limang segundo.
At kapag tapos na kami sa mga iyon, ito ay pagpunta sa sirain ang window,
linisin ang SDL library, at lumabas sa programa.
Kaya sabihin sige at bigyan na ng isang shot.
>> Kaya ngayon sa halip ng pagpapalit ang makefile sa bawat oras,
Maaari ko lang gawin, at pagkatapos ay sa command line,
pinagkukunan sabihin ay katumbas at pagkatapos ay ang file namin ay ipon.
Kaya ito ay hello2_window.c.
Hindi kapani-paniwala.
Walang erros.
Ngayon, kung nagpapatakbo namin ang aming mga executable, nakita namin ang window na ito.
Ngayon may mga ilang problema sa window.
Maaari naming ilipat ito sa paligid, ngunit ito ay ito background junk loob ng mga ito.
Kaya hindi pa namin na iginuhit kahit ano, at sa gayon ito ay
lamang na puno ng basura, na kung saan ay medyo marami kung ano ang inaasahan namin.
>> Bukod dito, hindi namin maaaring isara ang window.
Ako pagpindot ito X sa corner at wala ang nangyayari.
Kaya makikita namin makita kung paano ayusin na sa ilang sandali.
Kaya natin ayusin ang mga bahagi ipaalam kung saan ang window ay puno ng basura unang.
Kaya kung kami ay dumaan sa hello3_image.c, kung ano maaari naming makita na na nagdagdag kami ng ilang
higit pang mga bagay dito.
Nagdagdag kami ang bagong header maghain upang makuha ang timer function.
Hulaan ko ang ginawa namin na sa mga huling isa rin, at ako ay hindi banggitin ito.
Ngunit ngayon dahil hindi namin nagtatrabaho sa mga imahe,
kailangan naming isama ang SDL header na file ng imahe pati na rin.
Kaya ito ay ang parehong bagay bilang bago, Sinisimulan SDL dito,
parehong pakikitungo sa paglikha ng mga bintana.
Nakita namin na ang bago ngayon.
>> Ngayon kailangan namin upang lumikha ng isang bagay na tinatawag na isang renderer, na kung saan ang uri ng napupunta kasama
sa window.
Ngunit ito ay isang uri ng abstract object na
sa singil ng paggawa ng lahat ng mga pagguhit ng mga operasyon sa mga window.
At ito ang tunay na tumutugon sa isang programa na-load
sa graphics hardware sa iyong computer o sa iyong telepono o anuman.
Kaya ang mga flag na gusto naming ipasa it-- at maaari mong tingnan ang dokumentasyon
upang makakuha ng mas maraming mga detalye here-- ay pagpunta na SDL render pinabilis, na
ang ibig sabihin nito ay magiging gamit ang graphics hardware
at hindi lamang nakukuha sa software.
>> At kami ay pagpunta upang gamitin ang SDL renderer PRESENTVSYNC.
VSYNC ay isang bagay na lamang ay gumagawa ng iyong graphics magmukhang mas mahusay at pinipigilan
ito bagay na tinatawag na screen malaking takot, kung saan ang kalahati
ng isang frame at ang kalahati sa mga susunod na frame makakuha ng diwa at sa parehong oras
at mukha itong kakila-kilabot.
Subalit muli, maaari kang pumunta basahin tungkol na sa inyong sarili.
>> Kaya mayroon kaming ilang mga flag dito.
At kaya lang namin ang pagpunta sa tumawag sa mga function na ito SDL lumikha ng renderer.
Kami ay pagpunta sa bigyan ito ang window upang iugnay sa na taga-render.
Negatibong isa ay nangangahulugan na hindi namin pag-aalaga kung ano ang driver ng graphics kami ay pagpunta sa gamitin.
Kaya dapat na medyo marami na palaging negatibo ang isa,
maliban kung alam mo ang tungkol sa graphics driver.
At pagkatapos lamang kami ay pagpunta upang pumasa ito sa aming mga flag.
Kaya kung na nagbabalik null, pagkatapos namin upang i-print ang mga error tulad ng dati,
ngunit pagkatapos ay din namin ang pagpunta upang sirain ang window
upang linisin ang mga mapagkukunan bago pagtawag SDL umalis at bumabalik.
>> Ngayon, ang mga kagiliw-giliw na bahagi dito ay kung saan-load namin ang aming mga imahe
gamit ang function na ito IMG_load.
Ito ay ang tanging pag-andar kami ay pagpunta gamitin mula sa SDL library ng larawan.
Ito ay ang isa lamang na kailangan namin.
Ito ay isang function na tumatagal ang string iyon ay ang landas ng anumang mga mapagkukunan ng imahe.
At ito ay maaaring maging isang .png, isang GIF, bitmap, anuman ang mga bagay-bagay.
At iyon ang dahilan kung bakit ang function na ito ay kaya maganda.
Ito ay maaaring humawak ng halos anumang format.
Naglo-load ito sa memory at mga tindahan na ito parang isang bagay na tinatawag na isang SDL surface.
>> Ngayon isang SDL ibabaw ay lamang ng isang struct na kumakatawan sa data ng imahe sa memorya.
Kaya maaari mong basahin ang higit pa tungkol sa na sa papeles dalawa.
At kung ang mga error na ito, at pagkatapos ay hindi namin pagpunta sa gawin ang buong bagay na kung saan ang
print namin ang error, isara ang aming resources, at pagkatapos ay umalis sa programa.
Ngayon ang mga kagiliw-giliw na bagay ay, bago maaari naming gumuhit ng imahe na ito sa window,
kailangan namin upang aktwal na gawin itong isang texture.
Ngayon isang texture tumutugma sa data ng imahe load
sa memory hardware sa graphic ni.
>> Kaya isang ibabaw ay nasa main memory, regular memory
na hindi namin ginagamit ang lahat ng semestre, at isang texture ay nasa ito hiwalay VRAM
memory na ang mga kontrol graphics card.
Kaya ang tawag namin sa mga function na ito SDL_CreateTextureFromSurface.
Bigyan namin ito sa aming mga taga-render at ang aming mga ibabaw.
At pagkatapos ay hindi namin talaga tapos na sa ibabaw,
kaya lang kami sa libreng ito.
Hindi natin kailangan ito ngayon.
At pagkatapos ay sa gayon kung ang tawag na ito errored at bumalik null,
pagkatapos kami ay pagpunta sa gawin ang buong error sa pag-uulat muli bagay.
>> Lahat tama.
Dito, na nakukuha namin sa ilang mga aktwal na pag-andar na pag-render.
Kaya pagtawag SDL_RenderClear at pasado ito
ang taga-render na nauugnay sa aming mga window gumagawa lang ng window pumunta itim.
Kaya ito ay nagtanggal na junk na nakita natin sa ang aming window bago at ginagawang itim.
At pagkatapos kami ay pagpunta upang tumawag SDL_RenderCopy,
bigyan ito ng aming renderer, ang aming mga texture.
At kami ay makipag-usap tungkol sa kung ano mga patlang na ito ay nasa isang bit.
Ngunit na pagpunta sa kunin ang data texture
at kopyahin ito papunta sa aming window upang gumuhit ng mga larawan.
Kaya pagkatapos naming nagawa mo na ito ng kopya ang data papunta sa aming mga window,
kami ay may sa gawin ito ng karagdagang pag-andar tinatawag SDL_RenderPresent.
>> At ito ay kagiliw-giliw dahil ito ay makakakuha ng
sa isang paksa tinatawag double buffering.
Kaya double buffering ay isang pamamaraan na gumagawa ng iyong graphics ng maraming mas mahusay na hitsura.
Muli, ito ay pumipigil na screen tearing Kausap ko tungkol sa mas maaga, kung saan
mayroon kang dalawang buffer.
Mayroong isang pabalik buffer in memory at isang harap buffer.
Ang harap buffer ay literal ano ang nasa iyong screen sa ngayon.
Kaya ang ginagawa namin ang lahat ng mga gumuhit pagkakaiba-iba, tulad SDL render kopya o SDL_RenderClear
sa likod buffer.
So baguhin nila ang mga bagay sa likod buffer.
Dito maaaring pagguhit namin ito green square sa buffer likod.
>> Kaya nga kapag tapos na kami sa paggawa ng aming render operasyon, na
Maaaring tumagal ng isang tunay na matagal na panahon, kung ano ang namin ang pagpunta sa gawin
ay lumipat sa buffer.
Kaya ito literal lamang tumatagal ang front buffer at ang buffer likod
at switch ang mga ito, kaya na iyon, agad na,
sa isang operasyon, sa halip ng marahil daan-daan o libu-libo,
lahat ng aming mga bagong render bagay ang nasa screen.
At ito ang humahadlang sa mga bagay-bagay tulad ng mga nagre-refresh ng screen
kapag lamang namin ang iginuhit half ng aming mga bagay para sa mga frame.
Kaya na ang dahilan kung bakit kailangan namin upang tumawag SDL_RenderPresent, pati na rin
bilang SDL_RenderCopy.
>> Muli, lamang kami ay pagpunta maghintay para sa limang segundo.
Pagkatapos kami ay pagpunta sa linisin ang aming mga mapagkukunan.
Kami ay may lubos ng ilang higit pang mga oras na ito.
At pagkatapos lamang kami ay pagpunta upang lumabas mula sa program.
Kaya sabihin gawin iyon.
Pupunta ako mag-type ng gumawa, at pagkatapos ay pinagmumulan katumbas hello-- ito ay 3image.c ngayon.
Lahat ng karapatan, na pinagsama-sama sa walang mga error.
At maaari mong makita dito na hindi ko na ngayon inilabas ang aking image, Hello, CS50!
sa aming mga window, na kung saan mawala pagkatapos ng limang segundo.
>> Ngayon, ito ay mayroon pa ring problema, di ba?
Ito ay hindi isang mahusay na application, dahil kapag sinubukan kong isara ang window,
walang nangyari.
X Iyon ay hindi pa rin sumasagot.
Kaya sabihin kumuha ng isang pagtingin sa mga susunod na file, hello4animation.
Kaya ito ay ang file na ang pagpunta sa kitang ipakilala
gumagalaw at mga kilusan sa aming imahe.
Kaya kami ay pagpunta sa gawin ang mga parehong bagay tulad ng dati,
magpasimula SDL, lumikha ng mga window, lumikha ng mga renderer,
load ang imahe sa memory, lumikha ng mga texture.
Nakita namin na ang lahat ng iyon bago.
Ngayon, ito ay bago.
Kami ay pagpunta sa may isang istraktura na tinatawag isang SDL rect, na kung saan ay isang parihaba lamang.
Kung pumunta kami sa paglipas dito, maaari naming gawin ang isang paghahanap para sa SDL rect,
at maaari mong makita ito ay isang napaka-simpleng istraktura.
Ito ay may isang x, isang y para ang posisyon, at ito
ay may lapad at taas para sa ang laki ng parihaba.
>> Kaya kung ano ang namin ang pagpunta sa gawin ay hindi namin pagpunta upang tukuyin ang SDL rect Dest,
para sa destination.
At ito ay ang lugar sa screen kung saan
kami ay pagpunta sa pagguhit ating larawan, i-right Kaya
kung kami ay magiging paglipat ng mga imahe sa paligid,
pagkatapos ay ang destinasyon kung saan kami ay pagpunta sa gumuhit ng larawan
kailangan na gumagalaw sa paligid.
Kaya kami ay pagpunta sa tawag na ito function na SDL_QueryTexture.
At mapansin ako makapasa address ng dest.w, na kung saan ay ang lapad,
at dest.h, na kung saan ay ang taas.
At kaya SDL_QueryTexture ay pagpunta upang mag-imbak sa mga patlang ang lapad
at ang taas ng aming texture.
>> At pagkatapos ay kung ano ako pagpunta gawin ay pupuntahan ko
upang i-set dest.x na window width minus dest.w, na kung saan ay
ang lapad ng mga engkanto, na hinati sa pamamagitan ng 2.
At ito ay pagpunta sa set up na ito upang na ang mga imahe ay ganap na nakasentro
sa aming window, ang lahat ng karapatan?
Kaya ngayon ay mayroon akong isang posisyon y.
At ito ay pagpunta sa maging isang variable na
ang pagbabago, dahil kami ay pagpunta sa maging paglipat ng mga imahe sa direksyon y.
At ngayon kami ay may isang bagay tinatawag na isang animation loop.
>> Kaya kung paano gumagana ang mga animation gumagana?
Well, maaari tiktikan mata ng tao 12 natatanging mga imahe sa bawat segundo, ang lahat ng karapatan?
Kaya kung flash ka 12 image card sa akin sa isang segundo, nakita ko ang bawat isa sa mga larawang iyon
bilang sarili nitong natatanging mga indibidwal na imahe.
Ngayon, kung flash ka pa mga larawan sa akin sa isang segundo,
pagkatapos ay ang aking mga mata ay magsisimula lumabo ang mga ito nang sama-sama
at nais kong maramdaman ito bilang paggalaw, sa halip ng isang natatanging imahe.
Kaya, halimbawa, mga pelikula at telebisyon, flash sila ng mga imahe sa iyo ng 24 beses
isang segundo.
Kaya na ang 24 mga frame sa bawat segundo.
Screen ng Computer, sa kabilang banda, madalas ay sa 60 mga frame sa bawat segundo.
Iyon ang kanilang bilis refresh.
Iyan ay kung gaano kadalas sila i-refresh ang mga larawan sa screen.
Kaya aming mga target ay magiging 60 frame sa bawat segundo para sa aming mga laro.
>> Kaya sabihin makita na sa code.
Kaya para sa bawat frame, hindi namin unang pagpunta sa mga malinaw na ang window.
Ito ang pangkalahatang pattern.
Palagi kang i-clear ang window sa bawat frame, at pagkatapos ay
gawin ang lahat ng iyong mga guhit operasyon, at pagkatapos ay sa dulo,
huwag RenderPresent magpakita lahat ng bagay sa frame.
At pagkatapos ang iyong pagpunta sa Mayroon ng isang maghintay sa dulo
maghintay hanggang sa susunod na frame ay dapat na magsimula.
>> Kaya kung ako ay gumagawa ng isang pulutong ng complex pagtutuos dito
na kinuha ng higit sa 16 milliseconds, ito ay magiging imposible para sa akin
upang makakuha ng na frame rate ng 60 na Nais ko, dahil ang bawat frame ay
Masyado matagal upang makalkula.
Higit pa rito, talagang aming ginagawa uri ng isang bale-wala na halaga ng trabaho
dito, dahil mayroon lamang isang bagay na kami ay ang pagguhit.
Kaya naghihintay ako lamang 1/60 ng isang second, kung saan ay ang haba
ng isang frame sa pagitan ng mga frame.
Kaya ako uri ng pagpapanggap ginagawa lahat ng aking mga trabaho ay tumatagal ng zero oras.
Ngunit sa isang real game, gusto mo na kailangang mag-alis
ang halaga ng oras na ito kinuha upang gawin lahat ng gawaing ito mula sa iyong oras ng pahinga.
>> Kaya pa rin, kung ano ako ang tunay na ginagawa sa loop na ito?
Clear ko ang window.
I-set ang dest.y, na kung saan ay isang int sa inihagis sa isang int aking aktwal na posisyon y.
Ngayon, gusto kong lumutang resolution para sa aking mga posisyon y sa aking mga laro,
ngunit pagkatapos ay sa aktwal gumuhit ito papunta sa screen,
kailangan nito ints, dahil ito ay sa mga yunit ng pixels, kaya na kung ano ang cast ay para sa.
Pupunta ako upang gumuhit ng mga larawan.
Kaya ito ay ang pinagmulan rectangle.
At ito ay ang destination rectangle.
Kaya ako ay dumaan null para sa ang pinagmulan rectangle
upang sabihin na gusto ko upang gumuhit ng aking buong texture.
Ngunit kung ikaw ay nagkaroon ng maraming mga texture sa iyong mga laro
at ang mga ito lahat sa isang malaking mapa texture na-load sa SDL bilang isa lamang
texture, maaari mong gumamit ng isang source rectangle
upang pumili ng isa sa mga mas maliit na mga texture, ang isa sa mga mas maliit na sprites,
sa labas ng na malaking mapa texture.
>> Kaya muli, ako ng pagpasa aking render, aking texture, at ngayon ang destination.
Ito ay magiging kung saan sa window na ito ay pagpunta sa iguguhit.
At pagkatapos, dahil ako animating ang isang bagay, kailangan ko kilusan,
Pupunta ako sa pag-update ng posisyon engkanto sa bawat frame.
Kaya ko ito pare-pareho na tinatawag na mag-scroll pabilisin sa mga unit ng pixels sa bawat segundo.
Ngayon, sa bawat oras na gawin namin ang isang kilusan, mga frame ay 1/60 lamang ng isang segundo.
Kaya ako pagpunta sa hatiin na sa pamamagitan 60.
At pagkatapos, tingnan natin, Ako pagbabawas na mula y posisyon.
Bakit ako pagbabawas?
Susubukan naming makakuha ng sa na sa isang segundo.
Kaya pagkatapos kong linisin ang aking mga mapagkukunan at ang programa ay higit.
>> Kaya sabihin gawin iyon.
Kaya sabihin pumunta sa make SRCS = hello4 animation.c, ang lahat ng karapatan?
Game.
May pumunta ka.
Kaya ko ito ng pag-scroll up ng window, na kung saan ay medyo kapong baka.
Ngunit hold sa, ako ay pagbabawas mula sa posisyon y sa bawat oras.
Ano kaya ang nangyari doon?
Well, ito ay lumiliko out na sa SDL, at sa katunayan, sa karamihan ng mga graphics computer,
ang pinagmulan para sa mga sistema ng coordinate ay sa itaas na kaliwang bahagi ng window.
>> Kaya napupunta ang positibong x direksyon sa kabuuan ng iyong window sa kanan.
At ang mga positibong y direksyon tunay na napupunta down.
Kaya muli, sa pinagmulan ni kaliwang tuktok ng iyong window,
positive y direksyon ay down, at positibong x ay sa kanan.
Kaya kapag ibawas ko mula sa ang posisyon y, na ang
pagpunta sa gawin itong pumunta sa mga negatibong direksyon y, na kung saan ay up window.
Kaya na kung ano ang nangyayari doon.
Cool.
>> Tingnan natin ang mga susunod na file Hayaan.
Narito ang bahagi ng ipakita kung saan kami ay sa wakas
kumuha na X sa sulok ng window na ang dapat na isara ang window
magtrabaho.
Kaya kung ano ang nangyari?
Magpasimula kaming SDL, lumikha ng mga window, lumikha ng mga renderer, load ang imahe,
lumikha ng mga texture tulad ng nakita natin dati.
Mayroon kaming parehong destination rectangle tulad ng dati, parehong tawag sa query texture.
Ngunit oras na ito, hindi namin pagkatapos pagpunta sa hatiin ang lapad
at ang taas ng aming patutunguhan sa pamamagitan ng 4.
Ito ay ang epekto ng lamang scaling ating larawan down kapag
namin ipakita ito sa window sa pamamagitan ng apat.
Kaya na medyo kapong baka.
Maaari lang namin masukat katulad nito.
Kami ay pagpunta sa simulan ang mga engkanto sa gitna ng screen.
At ngayon kami ay x at y bilis at sila ay parehong pagpunta sa magsimula sa zero.
>> Ito ay ang maling file.
Patawad.
Kaya na ang lahat ng totoo.
Iyan ay sa file na ito ang lahat pa rin.
Mayroon kaming mga hatiin sa pamamagitan ng 4 at lahat ng bagay.
Kaya dito na namin ang aming x at y na posisyon para sa mga sentro ng window.
At namin bigyan ito ng isang paunang bilis ng pare-pareho ang bilis, na
Sa tingin ko ay 300 pixels sa bawat segundo.
Ngayon, mayroon kaming ito int maaaring lamang pati na rin maging isang boolean na tinatawag na malapit hiniling.
At sa halip ng paggawa ng isang walang-katapusang loop sa isang timer dito,
kami ay pagpunta sa ma-animating bilang Hangga't malapit ay hindi hiniling.
>> Kaya paano pinoproseso namin ang mga kaganapan?
Well, SDL queues up pangyayari sa isang literal queue sa likod ng mga eksena.
At pagkatapos ay sa bawat frame, maaari naming dequeue kaganapan
mula sa na queue gamit ito SDL_PullEvent call.
At muli, talagang pumunta basahin tungkol sa mga ito sa papeles.
May ng maraming mga detalye ng impormasyon at ng maraming higit pang mga function na maaari mong gamitin sa mga ito.
Ipasa namin ito ang address ng bagay na ito, SDL_Event
na mayroon kami dito sa stack.
>> Ngayon, kung ano ang isang SDL_event?
Dahil SDL, kung tiningnan namin sa ang documentation-- sabihin
makita, API sa pamamagitan ng kategorya, input mga kaganapan, kaganapan sa paghawak,
maaari naming tumingin sa ang bilang ng iba't-ibang mga kaganapan dito
at maaari naming makita mayroong isang buong tonelada ng mga ito.
Kaya kung ano ito SDL_Event bagay?
SDL_Event ay isang unyon.
Wow, kung ano ang isang union?
Ikaw na marahil hindi kailanman narinig na ng bago.
At iyon ang OK.
>> Ang isang union ay uri ng tulad isang struct, maliban sa isang struct
May espasyo para sa lahat ng kanyang mga patlang at memorya,
samantalang ang isang union lamang ay may sapat na espasyo upang magkasya ang pinakamalaking
isa sa kanyang mga patlang, na nangangahulugan na ito Maaari lamang mag-imbak ng isa sa kanyang mga patlang
sa isang pagkakataon, na uri ng ang akma para sa mga kaganapan, tama?
Maaari naming magkaroon ng isang keyboard kaganapan o isang kaganapan window,
ngunit ang isang kaganapan ay hindi maaaring maging parehong isang keyboard kaganapan at isang event window,
kaya gusto ito ay walang isip na magkaroon ng espasyo para sa pareho ng mga loob ng ating union kaganapan.
Kaya kung nais mong lumikha ng iyong sariling mga unyon,
ito hitsura nang eksakto ang parehong ng paglikha ng isang struct,
maliban na namin ang mga keyword union sa halip na ang struct keyword.
At tandaan, para sa lahat ng mga bagay-bagay sa loob ng iyong unyon,
ang aktwal na variable na mga unyon maaari lamang magkaroon ng isa sa mga halagang iyon
sa isang pagkakataon.
>> Kaya kung paano namin sabihin sa kung anong uri ng kaganapan pop lang namin off ng mga ito queue?
Well, maaari naming subukan para event.type.
At kung na ay pantay-pantay upang SDL_Quit, alam namin
ito ay ang mga kaganapan na ay binuo kapag kami
hit na X sa sulok ng window.
At kami ay maaaring itakda malapit hiniling ay katumbas ng 1.
Ang natitira ay lamang ng ilang mga animation na iyong nakita bago.
Kaya sabihin sige at gumawa na ito at makita kung paano ito gumagana.
Kaya ako pagpunta sa uri ng gumawa at pagkatapos SRCS = hello5_events.c.
Mayroon kaming pumunta.
Games.
>> Ngayon, maaari naming makita ang mga ito ay sa katunayan pinaliit sa pamamagitan ng apat.
At ngayon ito ay nagba-bounce sa paligid.
Mayroon akong ilang mga pagtuklas ng banggaan nangyayari sa mga panig ng window
na maaari naming tingnan ang.
At ano ang mangyayari kapag pumunta ko ba itong isara?
Magsasara ito.
Hindi kapani-paniwala.
Natanggap namin ang kaganapang iyon.
At hawakan namin ito.
>> Kaya ng lingunin ang code.
Kaya kung paano ginawa ko na ito malaki sa paligid tulad na?
Tandaan ako magse-set ang parehong x at y una sa bilis.
At bilis ay isang positibong pare-pareho, sa gayon ay
pagpunta upang makakuha ng ito nagsisimula lapag at sa kanan.
>> Ngayon, ang bawat frame, bilang karagdagan sa pag-asikaso anumang mga kaganapan na maaaring naganap,
Pupunta ako upang makita kung ang aking mga engkanto ay sinusubukan upang pumunta sa labas ng window.
Kaya maaari naming gawin na sa pamamagitan lamang ng paglagay ng tsek x_pos may 0, y_pos 0, at pagkatapos ay
din x_pos at y_pos sa window ng lapad at taas window.
Pansinin na bawas ko ang lapad ng mga engkanto.
At ito ay dahil kung hindi ko nakita ibawas ang lapad ng mga engkanto,
ay ito lamang ang check na sa pinagmulan ng mga engkanto
ay hindi pumunta sa labas ng window.
Ngunit gusto namin ang buong lapad ng mga engkanto
na laging maging sa loob ng window at ang buong taas ng engkanto
na laging maging sa loob ng window.
Kaya na kung ano ang pagbabawas ay para sa.
Ang isang pulutong ng geometry dito maaari maging kapaki-pakinabang upang gumuhit ito
sa papel na may mga coordinate system upang makita kung ano ang nangyayari.
>> Kaya kung ako mabangga, ako lamang reset lang ang posisyon
upang ito ay hindi pagpunta sa labas ng screen.
At ako pagpunta sa, kung ito bounce sa isa sa mga sidewalls,
Pupunta ako upang kontrahin ang x bilis upang ito
nagsisimula na nagba-bounce sa iba pang direksyon.
At katulad, kung hit ito sa tuktok o sa ilalim,
Pupunta ako upang itakda ang y kabilisan kapantay ng negatibong y bilis,
upang ito bounce back.
Kaya ito lamang kung paano namin nakuha na dito.
>> At ang mga posisyon sa pag-update tulad ng nakita natin dati,
hatiin sa pamamagitan ng 60, dahil hindi namin paghawak ng 1/60 ng isang segundo lamang.
At pagkatapos ay pag-render, eksaktong katulad ng dati.
At kaya na ang lahat ng bagay na nangyayari sa ang file na ito.
Kaya na kung paano namin ang mga kaganapan.
Ang pangunahing bagay na mag-alis dito ay ito SDL_PullEvent function.
At dapat mong basahin ang tiyak ang babasahin pa tungkol sa SDL_Event
unyon, dahil ang ganitong uri ng data ay tunay, tunay mahalaga, dahil ginagamit namin ito
para sa lahat ng uri ng mga kaganapan.
>> Halimbawa, ginagamit namin ito para keyboard mga kaganapan, na kung saan ay kung ano ang file na ito ay para sa.
Kaya kung ano ang mayroon tayo?
Mayroon kaming ang mga parehong bagay tulad ng dati, magpasimula SDL, lumikha ng isang window,
lumikha ng isang renderer, load ang imahe sa memory, lumikha ng mga texture.
Muli, kami ay pagpunta sa magkaroon ng ganitong Dest parihaba,
kami ay pagpunta upang baguhin ang imahe sa pamamagitan ng apat, gawin itong isang bit mas maliit.
Ngayon, kami ay pagpunta upang simulan ang engkanto sa gitna ng screen.
Ngunit oras na ito, kami ay pagpunta upang i-set ang paunang x at y velocity sa zero,
dahil ang keyboard ay pagpunta sa control iyon.
At bukod dito, kami ay pagpunta sa subaybayan ang mga variable na ito
pataas, pababa, pakaliwa, o pakanan.
At na ang pagpunta sa panatilihin track ng kung hindi namin
pinindot ang pindutan sa keyboard na tumutugma sa pataas, pababa, pakaliwa,
at kanan.
>> Ngayon, ito ang uri ng pag-iisip dahil maaari naming gamitin W, A, S,
D dito, o sa aktwal na mga arrow key.
Susubukan naming makita na sa isang segundo lang.
Kaya kami ay pagpunta upang i-proseso mga kaganapan tulad ng dati.
Hilahin namin ang kaganapan.
Ngunit ngayon kami ay pagpunta sa lumipat sa uri ng kaganapan.
Kung ito ay SDL_Quit, hindi namin pagpunta sa set ng malapit
humiling na isa, tulad lamang ng dati.
Na humahawak sa mga x in sa sulok ng window,
upang ang aming window talagang magsasara.
>> Kung hindi, kung makuha namin ang isang SDL key down event, na nangangahulugan pinindot namin ang isang key,
pagkatapos ay kung ano kami ay pagpunta sa gawin ay hindi namin pagpunta upang lumipat sa mga bagay na ito dito,
saan means-- kaya event.key nangangahulugan gamutin ang aming union kaganapan,
pumunta at makakuha ng key istraktura ng kaganapan sa loob nito.
Kaya ito ay lumiliko out na ito union ay isang mahalagang istraktura ng kaganapan.
At pagkatapos ay pumunta sa key istraktura larangan nito kaganapan
tinatawag keysym at pagkatapos scancode.
At muli, basahin tiyak ang mga babasahin tungkol dito.
Keyword input lubos na interesante.
Maaari kang makakuha ng mga code ng pag-scan o key codes.
At ito ay isang maliit na dalubhasa, ngunit ang dokumentasyon ay lubos na mabuti.
>> Kaya kung makita natin ang pag-scan ng code para aming key press pagiging W o up,
kami ay pagpunta upang i-set up katumbas ng 1.
At pagkatapos naming magsimula ng mga switch na.
Kung ito ay isang o kaliwa, namin itakda ang natitira upang 1, et iba pa, at iba pa, para sa mga pababa at kanan.
Ngayon, out na ito sa panlabas na lumipat, kung makita natin ang isang susi up event,
Nangangahulugan ito na inilabas namin ang isang key at hindi na namin ang pagpindot sa mga ito.
Kaya ako ng pagpunta sa sabihin up katumbas ng 0, kaliwang katumbas ng 0, down katumbas ng 0, right
katumbas ng 0, at iba pa.
>> At napansin na namin sa bawat isa sa mga dalawang mga kaso ilagay sa tabi mismo ng isa't isa
na walang hiwalay na code para sa unang kaso, na
Nangangahulugan ito na kung ito ay isang S o pababa karapatan dito,
ito ay pagpunta sa execute ang code na ito.
Kaya na medyo magaling.
Ito ang humahadlang sa amin na kinakailangang gawin ng mas maraming kondisyon at ifs at mga bagay
tulad niyan.
>> Kaya kami ay pagpunta sa matukoy ang bilis.
Itinakda namin ang bilis sa 0.
Pagkatapos kung up ay pinindot at hindi down, pagkatapos namin
itakda ang y bilis sa mga negatibong bilis.
Tandaan negatibong, dahil ang negatibong y direksyon ay up.
At ang mga positibong y direksyon ay down.
Kung pababa ay pinindot at hindi up, pagkatapos ay hindi namin
pagpunta sa itakda ito sa positibong bilis, na nangangahulugan na babaan ang screen.
Parehong bagay sa kaliwa at kanan.
>> At pagkatapos kami ay pagpunta upang i-update mga posisyon tulad ng dati.
Kami ay pagpunta sa gawin banggaan pagtuklas sa hangganan,
ngunit hindi kami ay pagpunta sa i-reset ang bilis, dahil ang bilis ay lamang
kontrolado ng keyboard.
Ngunit kami ay pagpunta sa i-reset ang posisyon upang panatilihin ito sa window.
At kami ay pagpunta upang i-set ang posisyon sa struct
at pagkatapos ay gawin ang lahat ng rendering bagay-bagay mula sa bago.
Kaya sabihin makita kung ano ang ginagawa nito.
Kaya gumawa hayaan SRCS-- makita, ito ay hello6_keyboard.c.
>> Oh hindi.
Kaya namin nakuha ang ilang mga babala dito.
At na lang sinasabi na hindi namin suriin para sa bawat solong posibleng uri
ng kaganapan.
Iyon ay OK, dahil may 236 sa mga ito o kaya.
Kaya ako pagpunta upang huwag pansinin ang mga babala.
Ito ay pinagsama-sama pa rin fine.
Kaya ako pagpunta upang i-play ang laro.
Ito ay hindi gumagalaw.
Ngunit ngayon, kapag mash ko sa aking keyboard, Ang maaari kong gawin ang ilang mga kilusan WASD dito,
Gamitin ko ang aking mga arrow key rin.
At mapansin, kahit na ako pagpindot karapatan sa ngayon,
hindi ito ay pagpunta sa labas ng bintana, dahil reset ko ito sa bawat frame.
Kaya na medyo kapong baka.
Maaari mong isipin ang paglipat sa paligid Mario sa ilang mga arrow key o ng isang bagay na tulad ng.
At oo, ang X ay hindi gumagana.
>> Kaya final file kami ay pagpunta upang tumingin sa, hellow7_mouse.
Ito ay tungkol sa pagkuha ng input mouse.
Kaya sa isang ito, kami ay import ang mga header matematika,
dahil kami ay pagpunta sa may isang maliit na piraso ng math dito.
Parehong lumang, parehong mga lumang bagay-bagay, patutunguhan, parehong old, nakita na bago.
Well, ito ay kawili-wili.
Kaya hindi namin pabalik sa paglalagay ng tsek lamang para sa SDL umalis kaganapan.
Bakit na?
Kaya maaari kang makakuha mouse input mula sa mga kaganapan.
Tulad nang lumipat ang mouse, makakakuha ka ng isang kaganapan para sa na.
Kapag ang isang pindutan ng mouse ay pinindot, maaari kang makakuha ng isang kaganapan para sa na.
>> Subalit mayroong isa pang, bahagyang mas simple marahil, API para sa pagkuha ng input mouse.
At na lang SDL estado get mouse.
Kaya Mayroon akong isang int para sa x at y para sa posisyon ng cursor.
Ipasa ko ito sa SDL_GetMouseState, na nagtatakda ng mga ito.
At ito ang posisyon sa coordinate system ng window.
Kaya kung ang masa ay sa kaliwang itaas ng window, na gagawin 0, 0.
>> Ngayon, kung ano ako pagpunta sa gawin ay pupuntahan ko upang gawin ang isang maliit na piraso ng vector math.
Taya ko naisip mo na hindi mo gusto makita na sa CS50, ngunit dito ito ay.
Pupunta ako sa gawin ang ilang mga vector math upang makuha ang vector
mula sa imahe sa cursor.
At kaya kung bakit ang mayroon ako ito pagbabawas dito?
Well, kung ginamit ko na lang Dest .-- kaya Kailangan ko upang i-translate ang mouse x
at y sa pamamagitan ng kalahati ang lapad at ang taas ng imahe,
dahil gusto ko sa gitna ng image na pagpunta patungo sa mouse,
hindi sa pinagmulan ng mga imahe.
>> Kaya ito lamang upang tiyakin na ako pinag tungkol sa gitna ng imahe dito.
Pagkatapos namin makuha delta x at y, na ang pagkakaiba mula sa mga target
sa aktwal na posisyon ng mga imahe.
At pagkatapos ay maaari naming makuha ang distansya dito, na
ay magiging Pythagorean teorama, square root of x
ulit x plus y beses y.
>> Ngayon upang maiwasan ang jitter, at maaari kong ipakita sa mo kung ano ang nagagawa nito kung hindi ko gawin ito,
kung distansya sa pagitan ng cursor at ang imahe center ay mas mababa sa limang,
Tingin lang ako sa hindi pagpunta sa ilipat ang imahe.
Kung hindi man, kami ay itakda ang bilis.
At kami ay itakda ito upang ang bilis ay laging pare-pareho.
At ang net resulta ng lahat ng ito matematika ay na ang imahe
ay pagpunta sa ilipat patungo ang cursor.
>> Ngayon, ito ay lumiliko out na SDL_GetMouseState,
bilang karagdagan sa pagtatakda ng x at y arguments dito,
nagbabalik din ito sa isang int na tumutugma sa estado ng ang mga pindutan ng mouse.
Kaya hindi namin maaaring basahin na direkta, ngunit maaari naming
gamitin ang mga macros, ang isang solong bitwise operator, hindi na nakakatakot,
lamang ng isang bitwise at.
Kaya sinasabi namin mga pindutan, na kung saan ay ang resulta ng ating SDL_GetMouseState, kung na
at bitwise at, ito macro dito, SDL_BUTTON_LEFT.
>> Kaya ito ay pagpunta upang malutas lamang sa bitmap na tumutugma
sa kaliwang pindutan ng mouse pipi.
At kaya kung ang bitwise at nangyayari at ito ay
hindi zero, na nangangahulugan kaliwang pindutan ay pipi,
pagkatapos ay aktwal na kami ay pagpunta upang kontrahin pareho ang x at ang y velocity,
na kung saan ay kailangan lang gumawa ng mga takas na imahe.
Update posisyon.
Collisions detections, nakita ito lahat bago, rendering, ang lahat ng karapatan.
Gumawa natin ito.
Kaya ba kayong gumawa ng SRCS = hello7_mouse.c.
Great.
Walang mga error.
At game.
>> Kaya dito mayroon ko ang aking mouse.
At ang imahe ay sa katunayan habol ang aking mouse.
Ngayon, sa isang laro na gagawin mo, baka ito ay tulad ng isang kaaway habol
sa iyong maliit na karakter o anuman.
Ngunit dito na namin ang mga image habol ang mouse.
At kapag nag-click ako, ang mouse Nagsisimula habol ang image
at ang imahe ay tumatakbo ang layo mula mouse.
Kaya na medyo cool.
At pansinin muli, may pa rin ang banggaan detection dito.
>> Kaya na ay ang huling maliit demo na-set up ko dito.
At tumagal ng isang pagtingin sa isa pang bagay ipaalam.
Kaya bumalik dito, nabanggit ko ito jitter.
Lahat tama.
Kaya kung distansya ay mas mababa sa limang pixels, Nakaupo ako x at y bilis sa zero.
Ano ang mangyayari kung natin mapupuksa ang na?
Kaya ako pagpunta sa gawin ito lamang.
Mangyaring patawarin ito horrendous style, ngunit nagkomento namin ang tamang code.
Kaya ako pagpunta sa i-save na at gawin ang mga parehong utos mula sa harap upang gawin itong.
>> Lahat tama.
At ngayon kung ano ang mangyayari?
Good.
Kami ay sumusunod pa rin ang mouse tulad ng dati,
ngunit kapag kami makakuha sa mouse, Nakakuha kami ng ganitong gross jitter.
Ano kaya ang nangyari doon?
Well, sa aming vector math, tandaan namin
paglaan ng distansiya sa pagitan ng cursor at ang gitna ng imahe?
Well, pati na pamamaraang 0, namin simulan ang pagkuha
tulad ng ganitong uri ng mga loko-uugali kung saan ang imahe ay uri ng
tulad ng oscillating sa paligid ng cursor.
At na sa paglikha ng ito jitter.
At iyan ay talagang pangit.
At marahil ay hindi nais ang iyong mga laro sa paggawa na,
maliban kung ito ay isang uri ng espesyal na epekto.
>> Kaya na ang dahilan kung bakit mayroon kaming lamang ito arbitrary
cut off ng limang pixels, na kung saan namin sabihin kung ito ay sa loob ng limang pixels, hindi namin mabuti.
Hindi namin kailangan upang ilipat ang imahe anymore.
Kaya na kung ano ang nangyayari doon.
>> Kaya na medyo marami ito.
Alam mo na ngayon kung paano lumikha ng isang window, i-load ang isang imahe,
gumuhit ng isang larawan ng window, makakuha ng input keyboard, kumuha ng input mouse,
may isang bungkos ng iba pang input na gusto mo ay hindi
malaman kung paano makakuha kung gagastusin mo lamang ng isang ilang minuto sa pagtingin sa mga babasahin.
Kaya ang tunay na may ganap ng isang ilang mga tool sa iyong pagtatapon ngayon
na magsulat ng isang ganap na laro.
>> Ngayon, ang mga pangangailangan ng ilang mga audio bawat laro, ngunit ang mga babasahin audio
ay isa ring mahusay.
At ako ay nais na taya na kung nauunawaan mo ang lahat ng mga bagay-bagay
usapan natin ang tungkol ngayon sa ang mga imahe, at ibabaw,
ang mga bintana, at lahat ng bagay, at pagkatapos ay uunawa ng mga audio API ay hindi
magiging na masama.
Kaya ako inaabangan ang nakakakita ano kang lumikha ng sa SDL.