THOMAS LIVELY ყველა უფლება.
გამარჯობა ყველას.
მე თომას Lively.
ეს სემინარი იქნება წერა 2D თამაშები C გამოყენებით SDL.
ასე რომ, მე ვიცი, რომ თქვენ ყველა ითხოვს, ჰო, მე ნამდვილად
მინდა, რომ ითამაშოს თამაშები და თამაშები, მაგრამ რა არის ეს SDL ბიზნესი?
ასე რომ, SDL არის C ბიბლიოთეკა.
იგი დგას მარტივი DirectMedia Layer.
და ეს არის ჯვარი პლატფორმა, თამაშის განვითარების ბიბლიოთეკა.
მუშაობს Windows, Mac, Linux, მაშინაც კი, iOS და Android.
ეს სახელურები რამ, როგორიცაა ხელმისაწვდომობის აუდიო სისტემები
კომპიუტერი, კლავიატურა, და მაუსი, ჯოისტიკით, თუ ისინი ერთვის.
მობილური, ის კი არ შეყვანა და ყველა რომ.
და რა თქმა უნდა, ეს სახელურები გრაფიკა, ხატვის რამ ეკრანზე.
>> ასე რომ, ეს ძალიან ფართოდ გამოიყენება, მიუხედავად იმისა, თქვენ შეიძლება არ მსმენია ეს ადრე.
ის აშენებულია შევიდა, მაგალითად, Valve წყარო ძრავა,
რომელიც უფლებამოსილების თამაშები, როგორიცაა Portal და Team Fortress 2.
ეს არის ასევე ძალიან დიდი რაოდენობით ინდი თამაშები რომ გამოვა,
ასე რომ მე ვარ აღფრთოვანებული, რომ ის, რაც თქვენ ყველა იქნება მიღების იგი.
>> სემინარის მიზნები, რომ თქვენ გადმოცემულია იყოს ვითარდება SDL.
ჩვენ ვაპირებთ, რომ ისწავლონ, თუ როგორ თამაშის შექმნა ფანჯარა.
ჩვენ ვაპირებთ, რომ შევქმნათ sprites, რომლებიც სურათები თქვენი თამაში
რომ შეუძლიათ გადაადგილება.
ჩვენ ვაპირებთ, რომ ისწავლონ, თუ როგორ და animate sprites,
ასე რომ, მათი გადაადგილება, რათა მათ დროთა განმავლობაში შეიცვლება.
და ჩვენ ვაპირებთ, რომ ისწავლონ ხელში კლავიატურა და მაუსი
შეყვანის კომპიუტერი.
ის, რაც ჩვენ არ იქნება ლაპარაკი დღეს არის 3D გრაფიკა,
იმიტომ, რომ ძალიან რთული სათაური, რომ ჩვენ არ გვაქვს დრო.
ჩვენ არ ისწავლოს აუდიო ჩვენს თამაშები.
და ჩვენ არ უნდა მშენებლობის არაფერი მაგრამ Linux.
>> ახლა აპირებს არსებობს, რომ, იმედია, ბოლოს სემინარის
თქვენ უნდა იყოს კომფორტული, SDL დოკუმენტაცია,
ასე რომ თქვენ შეძლებთ წასვლა გაერკვნენ როგორ ითამაშოს აუდიო თავს.
ასევე აშენებს Mac ან PC უნდა იმუშაოს ზუსტად ისევე, როგორც მშენებლობის ენაზე,
მაგრამ setup აპირებს იქნება ცოტა განსხვავებული.
ასე, რომ თქვენ უნდა შეეძლოს გაერკვნენ თუ როგორ უნდა გავაკეთოთ ეს ყველაფერი
ბოლოსთვის დღევანდელი სემინარის.
>> ასე რომ შეიქმნა, ჩვენ ვაპირებთ გამოიყენოთ ვირტუალური მანქანა.
ჩვენ გვინდა, გამოიყენოთ CS50 IDE, რადგან ჩვენ უბრალოდ უნდა წერა C.
მაგრამ მას შემდეგ, IDE არ არის ბრაუზერის მეშვეობით, ჩვენ არ შეუძლია შექმნას ახალი ფანჯარა ან ჩვენება
გრაფიკული იგი.
ამიტომ, ჩვენ უნდა ვირტუალური მანქანა.
ასე რომ თქვენ შეგიძლიათ მიყევით ინსტრუქციას აქ manual.CS50.net/appliance/15
ინსტალაცია ოფიციალური CS50 ელექტრო მოწყობილობების, რომელიც არის მხოლოდ Linux ვირტუალური
მანქანა.
>> და მერე კიდევ თქვენ გაქვთ რომ ყველა მითითებული up-- ეს
შეიძლება ცოტა ხნით, რადგან ძალიან დიდი download-- თქვენ აპირებს
გასაშვებად VM sudo apt-get update.
და რომ მართლაც აპირებს განახლება ყველა პროგრამული უზრუნველყოფა
პაკეტი თქვენი ვირტუალური მანქანა.
>> ამის შემდეგ, თქვენ ვაპირებთ აწარმოებს sudo apt-get install, libsdl2-2.0-0,
libsdl2-DBG, libsdl2-dev და დამატებით libsdl2-image-2.0-0,
libsdl2-image-DBG, და libsdl2-image-dev.
ასე რომ, რას აკეთებთ?
ეს მხოლოდ მოყვება გამართვის ინფორმაციის, დოკუმენტაციის, სათაურების,
და binaries ორი ბიბლიოთეკები.
რეგულარული ძველი, SDL 2.0, და კიდევ ერთი ბიბლიოთეკა
მოუწოდა SDL გამოსახულება, რომელიც ჩვენ ვაპირებთ იყოს გამოყენებით
ჩატვირთვა ფაილები ჩვენი თამაში.
>> ასე რომ, კიდევ გაქვთ, რომ ასევე რომ, უბრალოდ, როდესაც იგი ითხოვს,
თქვენ უბრალოდ აკრიფოთ დიახ, დააჭიროთ დააყენოთ ის პაკეტი,
და მაშინ უნდა იყოს კარგი წავიდეთ.
ასე რომ მიიღოს განაწილების კოდი, თქვენ can-- OH ძვირფასო, ეს არ არის განახლება.
თუ თქვენ გაქვთ GitHub account-- თუ თქვენ გაქვთ GitHub ანგარიში,
თქვენ შეგიძლიათ ამის გაკეთება Git კლონი ბრძანება რეპო
და რომელიც ჩამოტვირთოთ Git რეპო ყველა კოდი მასში,
ასე, რომ თქვენ უნდა კოდი.
>> თუ თქვენ არ გაქვთ GitHub ანგარიში, რაც თქვენ უნდა გააკეთოთ ტიპი
wgithttps: //github.com/tlively/sdl სემინარი და აქ ის different--
/archive/master.zip.
ასე რომ, კიდევ ერთხელ, რომ ზუსტად იგივე URL, გარდა იქნება
tlively / SDL_seminar / master.zip და თქვენ იყენებთ wgit რომ ჩამოტვირთოთ.
და მაშინ მხოლოდ unzip რომ არქივი
და მაშინ გვექნება ყველა კოდის.
ასე რომ, ბოდიში, რომ.
და მაშინ კოდი იქნება ასევე უმასპინძლა რომ CS50 სემინარი ვებ-გვერდზე დღეზე
დღის განმავლობაში.
>> კარგი.
ასე რომ, ჩვენ უნდა დავიწყოთ წერილობით საკუთარი თამაში?
ისე, პირველი, რაც ჩვენ ვაპირებთ, რომ გსურთ
შევხედოთ SDL დოკუმენტაცია.
ასე რომ აქ VM.
აქ არის ვებ-გვერდზე.
მე ნავიგაცია ცხოვრება libsdl.org.
რა მე ვაპირებ აქ წავიდეთ მეტი to sidebar, ქვეშ დოკუმენტაცია,
და დააკლიკეთ wiki.
ეს მოუტანს ჩემთვის ვიკი, რომ აქვს ყველაზე დოკუმენტაცია SDL.
დასრულდა sidebar აქ, ჩვენ ვაპირებ დააჭირეთ API კატეგორიის მიხედვით,
იმიტომ, რომ აპირებს ჩვენს ლამაზი კატეგორიული კალენდარი
მთელი API for SDL.
>> ასე მაგალითად, ჩვენ გვაქვს ძირითადი ინიციალიზაციისას
და დახურეს, ყველა სახის ადმინისტრაციული პერსონალის გამოყენებით SDL,
და მაშინ ჩვენ გვაქვს განყოფილებაში ჩვენებისას რამ ეკრანზე.
ეს არის ვიდეო.
შეყვანის მოვლენები, რომ მიღების შეიტანენ კლავიატურაზე,
მიღების შეიტანენ მაუსის და ჯოისტიკი, თუ თქვენ გაქვთ ეს კი.
არსებობს ძალის კავშირი რამ მსგავსი თამაში კონტროლერები, რომელიც
ჩვენ არ ვაპირებთ ვისაუბროთ.
აქ არის აუდიო.
და მაშინ იქ რამოდენიმე სხვა პერსონალი, რომ SDL შეუძლია თქვენთვის.
>> მაგრამ დღეს ჩვენ ვაპირებთ ფოკუსირება on ინიციალიზაციისას აქ,
ჩვენებისას გამოსახულებები, ვიდეო სექცია, და გატარება შეყვანის მოვლენები.
ასე რომ, ეს არის ის ძირითადი მონაკვეთზე დოკუმენტაცია
რომ თქვენ უნდა შემაშფოთებელია შესახებ.
Just for fun, თუ ჩვენ მეტი აქ და დააჭირეთ API სახელი,
ჩვენ ვხედავთ ჩამონათვალი ყველა ერთი რამ SDL ბიბლიოთეკა.
ასე რომ, ყველა ამ ფუნქციების Enumerations, სტრუქტურები, გიჟები თანხის პერსონალი,
ანბანური თანმიმდევრობა.
და ნათლად, სანამ თქვენ იცით, თუ რას აკეთებს,
ეს არ იქნება ძალიან სასარგებლო, სწორედ ამიტომ ჩვენ ამის API კატეგორიის მიხედვით.
>> მოდით დავიწყოთ.
იმედია თქვენ უკვე გადმოწერილი განაწილების კოდი.
ასე რომ, რა შეგიძლიათ გააკეთოთ, უფლება აქ CS50 ელექტრო მოწყობილობების,
უბრალოდ გახსენით ტერმინალი.
აქ ჩვენ მივდივართ.
ასე რომ, მე უკვე გადმოწერილი განაწილების კოდი გამოყენებით .zip
მეთოდი.
და მე unzipped იგი.
ასე რომ, აქ არის SDL სემინარი ოსტატი.
ამიტომ, მე ვაპირებ წასვლას, რომ დირექტორია.
რასაც ვხედავთ აქ არის რომ ჩვენ გვაქვს შვიდი C ფაილი.
და ეს ხდება იმ კოდი ჩვენ ვაპირებთ, რომ ეძებს დღეს.
ჩვენ გვყავს makefile.
და ჩვენ გვაქვს რესურსების კატალოგი, რომელიც უბრალოდ იმიჯი
რომ თქვენ უნდა ხედავს მალე საკმარისი.
>> ასე რომ, მოდით გახსენით ეს ფაილი გამოყენებით G-რედაქტირება რედაქტორი.
ასე რომ, მინდა გახსნა ყველა ფაილი, რომელიც დასაწყისისთვის მიესალმები და მთავრდება გ.
აქ ჩვენ მივდივართ.
ასე რომ, პატარა ფანჯარაში, ასე რომ, ჩვენ ვაპირებ ცდილობენ, რათა, რომ დიდია.
არა, ეს არ წავიდა.
>> კარგი.
ასე რომ აქ პირველი ფაილი ჩვენ ვაპირებთ შევხედოთ.
ეს ე.წ. hello1_sdl.c.
და ეს ყველაფერი არ არის, რომ ვრთავ SDL ბიბლიოთეკაში ისე, რომ ჩვენ შეგვიძლია დავიწყოთ გამოყენებით იგი.
რა ვიცი, მოვა ერთად ეს კოდი საკუთარ თავს?
ისე, თუ ჩვენ გამოიყურებოდეს მეტი დოკუმენტაცია
და ჩვენ წასვლას ინიციალიზაციისას და დახურეს განყოფილებიანი,
ის აპირებს გვითხრათ ყველა იმაზე, თუ როგორ უნდა ინიციალიზაცია SDL.
ასე რომ, ნამდვილად წაიკითხა ეს სხვა დროს.
ის აპირებს გითხრათ ყველა შესახებ, თუ რა ხდება აქ.
მაგრამ მთავარი არსი იმაში მდგომარეობს, რომ ჩვენ უნდა მოვუწოდებთ ამ ფუნქციის SDL In It
და გაიაროს ეს რა სახის ნივთები ჩვენ გვინდა ბიბლიოთეკა ვრთავ.
ასე რომ, ჩვენს შემთხვევაში, ჩვენ უბრალოდ აპირებს ვრთავ ვიდეო ახლა,
ასე რომ ჩვენ შეგვიძლია დავიწყოთ ჩვენებისას გამოსახულებები.
>> აქ, თქვენ ხედავთ, თუ ჩვენ დააწკაპუნეთ SDL ეს, ჩვენ
შეგიძლიათ მიიღოთ უფრო მეტი ინფორმაცია, მათ შორის დაბრუნებული მნიშვნელობა.
ასე რომ, ჩვენ ვხედავთ, რომ აქ ეს returnes ნულის წარმატება.
ასე რომ, ჩვენი კოდი, ჩვენ ვაპირებთ თუ ეს არ დაბრუნდება ნულოვანი,
და თუ ის არ დაბრუნდება ნულოვანი, ასე რომ არ იყო წარმატებული,
მაშინ ჩვენ ვაპირებთ, უბრალოდ ბეჭდვითი შეცდომა გამოყენებისას სხვა ფუნქცია,
SDL მისაღებად შეცდომა, რომელიც დააბრუნებს string აღწერს შეცდომა, რომ მოხდა.
ჩვენ ვაპირებთ, რომ ბეჭდვა, რომ შეცდომა და შემდეგ ჩვენ უბრალოდ
აპირებს გაითიშება პროგრამა ერთად შეცდომის კოდი.
>> შემდეგ კიდევ ერთი რამ, რომ ჩვენ უნდა არ არის, სანამ პროგრამა გასასვლელი,
თუ ჩვენ წარმატებით ინიციალიზაცია SDL, ჩვენ უბრალოდ უნდა ეძახით SDL დატოვა.
და რომ აპირებს გაუმკლავდეს დასუფთავების ყველა SDL შიდა რესურსების ჩვენთვის.
ასე რომ, დოკუმენტაცია იქ, კიდევ ერთხელ, ჩვენ აქ ვართ ინიციალიზაციისას
და დახურეს განყოფილებაში დოკუმენტაცია.
თქვენ არ შეგიძლიათ უბრალოდ დააჭირეთ ფუნქცია აქ, SDL დატოვა,
და თქვენ შეგიძლიათ წაიკითხოთ ყველაფერი, რომ ისევე.
და ბევრი ამ ფუნქციის დოკუმენტაცია გვერდები
აქვს მაგალითად კოდი, ასე რომ ეს არის ძალიან კარგი რესურსი.
აუცილებლად გარკვეული დრო გაატაროს კითხულობს ნაწილები ამ ვიკი
თუ ვაპირებთ გავაკეთოთ ეს პროექტი.
>> კარგი.
ასე რომ, მთელი ჩვენი პროგრამა.
რა შეგვიძლია გავაკეთოთ ახლა is-- ვარ ვაპირებ გახსნა makefile აქ,
ამიტომ მე ვაპირებ მიიღოს შეხედეთ, როგორ მუშაობს.
და ეს არის ძალიან მარტივი makefile, მსგავსი, თუ რა ვნახე ადრე.
ერთ-ერთი ძირითადი განსხვავებები ის არის, რომ აქ, ამ
აპირებს ჩადეთ შედეგი გაშვებული ეს ბრძანება, რომელიც თქვენ უკვე
დამონტაჟებულია თუ თქვენ დაყენებული SDL.
და ეს არის ბრძანება რომ აპირებს გენერირება
ზოგიერთი დამატებითი დროშები შემდგენელი.
>> გარდა ამისა, ჩვენ ვაძლევთ მას ყველა ჩვეულებრივი ბრძანებები, ისევე როგორც
ამ ორი ბრძანებები.
ასე რომ, -lsdl2 სურათი სახელურები აკავშირებს ამ SDL იმიჯი ბიბლიოთეკა.
და -lm რეალურად ემსახურება აკავშირებს სტანდარტული C მათემატიკის ბიბლიოთეკაში.
ასე რომ, ჩვენ არ ვაპირებთ უნდა იმ ყველა ჩვენი C ფაილი,
მაგრამ ჩვენ უბრალოდ დააყენა მათ ისე, რომ ჩვენ შეგვიძლია გამოიყენოთ იგივე makefile ყველაფერი
გარეშე ცვლილებები.
>> მეტი აქ წყაროები, ეს არის სადაც თქვენ მინდა
იმისათვის, რომ ფაილი, რომ თქვენ აპირებს შეადგინონ თქვენი პროექტი.
მაგრამ მას შემდეგ, რაც ყველა ერთი ჩემი C ფაილი აქ მთავარი ფუნქცია,
ის აპირებს დაბნეული თუ ჩვენ მათ ყველა.
ამიტომ, მე ვაპირებ, უბრალოდ, ვამბობთ, ახლა, hello1_sdl.c,
რომელიც ერთი ჩვენ უბრალოდ შევხედე.
ასე რომ, თუ მე დავუბრუნდეთ მეტი აქ, მე არ მიიღოს.
და რომ ის, რაც არის, ეს მხოლოდ შედგენილი, რომ პირველი ფაილი.
და მაშინ ჩვენ შეგვიძლია აკრიფოთ ./game, რადგან ეს შემსრულებელი წარმოებული.
და ყველა ეს მოხდა იყო ბეჭდვითი ინიციალიზაციისას წარმატებული.
ასე რომ, ჩვენ გავაკეთეთ რაღაც უფლება.
მაგრამ ეს იყო ერთგვარი მოსაწყენი, იმიტომ, რომ ჩვენ არ ვხედავთ, ფანჯარა,
არაფერი არ მოძრაობდნენ.
>> ასე რომ, დიდი, მივიღეთ SDL ინიციალიზაცია.
ახლა, მოდით გადაადგილება, რათა რაღაც ცოტა უფრო საინტერესო.
ასე რომ აქ გვაქვს hello2_window.c და ეს იქნება ოდნავ მეტი
კომპლექსი C პროგრამა, რომელიც ველში SDL ისევე, როგორც ადრე,
გარდა ახლა ჩვენ ასევე ვაპირებთ ინიციალიზაცია SDL ტაიმერი.
და ეს ხდება მოდით ხელმისაწვდომობის შიდა ტაიმერი
და გამოყენების ფუნქცია, რომელიც ეხება დროს.
>> და მაშინ მოდით შევხედოთ ქვემოთ აქ.
რას ვაკეთებთ ჩვენ ეს მაჩვენებელი რომ SDL window struct, რომელიც
იქნება შექმნილ დარეკეთ ფუნქცია, SDL შექმნა ფანჯარა.
ახლა, ეს იღებს ბევრი არგუმენტები, ასე რომ, მოდით შევხედოთ დოკუმენტაცია.
ასე რომ კიდევ ერთხელ, მე ვაპირებ API კატეგორიის მიხედვით, მე
აპირებს ქვემოთ ვიდეო აქ, და პირველი განყოფილებიანი, ჩვენებისას window მართვა.
ასე რომ, ეს სექცია ტონა პერსონალი,
მაგრამ თუ გადავხედავთ ეს ფუნქციები, თქვენ
ვხედავ, რომ, ალბათ, ერთი ჩვენ გსურთ ეწოდება SDL შექმნა ფანჯარა,
რაც ხდება, რომ მარჯვენა ზედა.
>> ასე რომ, ეს არის დოკუმენტაცია ამ ფუნქციას.
ფანჯარა აპირებს სათაური, x და y პოზიცია ეკრანზე,
ის აპირებს აქვს სიგანე, სიმაღლე, და მაშინ ის აპირებს ზოგიერთი დროშებით.
ახლა, ჩვენ რეალურად არ აინტერესებს რომელიმე ამ დროშები ახლა,
მაგრამ თუ მინდოდა, რომ რამე მოსწონს სრულ ეკრანზე ფანჯარა,
თქვენ შეიძლება შევხედოთ, რომ.
ახლა, ჩვენ უბრალოდ აპირებს გამოიყენოს ეს განსაკუთრებული ღირებულებები,
SDL window პლუს ორიენტირებული x და y, რათა
უბრალოდ შექმნათ window ცენტრში ჩვენი ეკრანზე.
>> ასე რომ, რა რომ აკეთებს.
და თუ ფანჯრის ხდება, null, რაც იმას ნიშნავს, არ არის შეცდომა,
მერე ისევ ჩვენ უბრალოდ აპირებს ბეჭდვა შეცდომა გამოყენებით SDL მისაღებად შეცდომა.
და მერე იმიტომ, რომ ჩვენ ინიციალიზაცია SDL, ჩვენ ახლა უნდა დახუროს იგი.
ამიტომ, ჩვენ მოვუწოდებთ SDL დატოვა ადრე დაბრუნების ერთ-ერთი ძირითადი.
>> ასე რომ, ჩვენ ამ ფანჯარაში გახსნა იმედია.
და რასაც ჩვენ ვაპირებთ რომ არის ჩვენ ვაპირებთ
მოვუწოდებთ SDL 5000 მილიწამებში, რომელიც არის იგივე, რაც ხუთ წამში.
და როდესაც ჩვენ გავაკეთეთ, რომ, ის აპირებს გაანადგუროს ფანჯარა,
გაწმენდა SDL ბიბლიოთეკა, და გასვლა პროგრამა.
მოდით წავიდეთ წინ და მისცეს, რომ გასროლა.
>> ასე რომ, ახლა ნაცვლად შეცვლის makefile ყოველ ჯერზე,
შემიძლია უბრალოდ არ მიიღოს და მაშინ ბრძანების,
აცხადებენ წყაროების უტოლდება და შემდეგ ფაილი ჩვენ შედგენა.
ასე რომ, ეს hello2_window.c.
Fantastic.
არარის Erros.
ახლა, თუ ჩვენ აწარმოებს ჩვენი შესრულებადი, ჩვენ ვხედავთ, ეს ფანჯარა.
ახლა არსებობს რამდენიმე პრობლემა ფანჯარა.
ჩვენ შეგვიძლია გადატანა გარშემო, მაგრამ მას აქვს ამ ფონზე უსარგებლო შიგნით მას.
ასე რომ, ჩვენ არ დგება არაფერი, და ამიტომ
მხოლოდ სავსე ნაგვის, რომელიც არის საკმაოდ ბევრი, რასაც ჩვენ ველით.
>> გარდა ამისა, ჩვენ ვერ დახურეთ ფანჯარა.
მე დაჭერით ეს X წელს კუთხეში და არაფერი ხდება.
ასე რომ, ჩვენ დავინახავთ, თუ როგორ უნდა დააფიქსიროს რომ ცოტა.
მოდით დაფიქსირება ნაწილი, სადაც ფანჯარა დანაგვიანებული პირველი.
ასე რომ, თუ ჩვენ მეტი hello3_image.c, რა ჩვენ ვხედავთ, რომ ჩვენ დასძინა რამდენიმე
უფრო მეტი რამ აქ.
ჩვენ დასძინა ახალი header ფაილის მისაღებად ტაიმერი ფუნქციები.
ვფიქრობ, ჩვენ გავაკეთეთ, რომ ბოლო ერთ-ერთი, ძალიან, და მე არ უხსენებია ის.
მაგრამ ახლა, რადგან ჩვენ სამუშაო სურათებით,
ჩვენ უნდა შეიცავდეს SDL სურათი header ფაილი ისევე.
ასე რომ, ეს არის იგივე როგორც ადრე, ინიციალიზაციისას SDL აქ,
იგივე გარიგება ქმნის ფანჯრები.
ჩვენ ვნახეთ, რომ აქამდე.
>> ახლა ჩვენ უნდა შევქმნათ რაღაც მოუწოდა renderer, რომელიც ერთგვარი გადის
ფანჯრის.
მაგრამ ეს ერთგვარი აბსტრაქტული ობიექტი, რომელიც არის
პასუხისმგებელი აკეთებს ყველა ამ ნახაზი ოპერაციების ფანჯარა.
და ეს რეალურად შეესაბამება პროგრამა დატვირთული
შევიდა გრაფიკული ტექნიკის თქვენს კომპიუტერული და ტელეფონის ან რასაც.
ასე რომ, დროშების ჩვენ გვინდა გავლა it-- და თქვენ შეგიძლიათ შევხედოთ დოკუმენტაცია
მისაღებად უფრო დეტალურად აქ ვაპირებთ უნდა SDL გაწევა დააჩქარა, რომელიც
ნიშნავს, რომ ის იქნება გამოყენებით გრაფიკული ტექნიკის
და არა მხოლოდ მიბაძონ პროგრამული უზრუნველყოფა.
>> და ჩვენ ვაპირებთ გამოვიყენოთ SDL Renderer PRESENTVSYNC.
Vsync არის ის, რომ უბრალოდ ხდის თქვენი გრაფიკა გამოიყურებოდეს უკეთესად და ხელს უშლის
ეს რამ მოუწოდა ეკრანზე ტერორი, სადაც ნახევარი
ერთ-ერთი ჩარჩო და ნახევარი შემდეგი ჩარჩო იზიდავს და ამავე დროს
და ეს გამოიყურება საშინელი.
მაგრამ ერთხელ, შეგიძლიათ წაიკითხოთ იმის შესახებ, რომ თქვენი საკუთარი.
>> ასე რომ, ჩვენ გვაქვს გარკვეული დროშები აქ.
ასე რომ, ჩვენ უბრალოდ ვაპირებ მოვუწოდო ამ ფუნქციის SDL შექმნა renderer.
ჩვენ ვაპირებთ, რათა ეს window გაერთიანდნენ, რომ renderer.
უარყოფითი ნიშნავს, რომ ჩვენ არ მაინტერესებს, რა გრაფიკული მძღოლი ჩვენ ვაპირებთ გამოვიყენოთ.
ასე რომ, უნდა საკმაოდ ბევრი ყოველთვის იქნება უარყოფითი,
თუ თქვენ არ იცით, თუ გრაფიკული მძღოლები.
და მაშინ ჩვენ უბრალოდ აპირებს უნდა გაიაროს ეს ჩვენი დროშები.
ასე რომ, თუ ბრუნდება null, მაშინ ჩვენ აპირებს ბეჭდვა შეცდომა, როგორც ყოველთვის,
მაგრამ მაშინ ჩვენ ასევე ვაპირებთ განადგურება window
გაწმენდა იმ რესურსებს ადრე მოუწოდებს SDL დატოვა და ბრუნდებიან.
>> ახლა, საინტერესო ნაწილი აქ არის, სადაც ჩვენ გადაწეროთ ჩვენი სურათი
გამოყენებით ამ ფუნქციას IMG_load.
ეს არის ერთადერთი ფუნქცია ჩვენ ვაპირებთ გამოიყენოთ საწყისი SDL იმიჯი ბიბლიოთეკა.
ეს არის მხოლოდ ერთი გვჭირდება.
ეს არის ფუნქცია, რომელიც იღებს სიმებიანი რომ არის გზა, ნებისმიერი გამოსახულების რესურსი.
და ეს შეიძლება იყოს .png, GIF, bitmap, ნებისმიერი რამ.
ამიტომაც არის, რომ ეს ფუნქცია იმდენად ლამაზი.
მას შეუძლია საკმაოდ ბევრი ნებისმიერ ფორმატში.
იტვირთება მეხსიერებაში და ინახავს მას როგორც რამ მოუწოდა SDL ზედაპირზე.
>> ახლა SDL ზედაპირზე მხოლოდ struct რომელიც წარმოადგენს იმიჯი მონაცემების მეხსიერებაში.
ასე, რომ თქვენ შეგიძლიათ დაწვრილებით რომ დოკუმენტაცია ორი.
და თუ ეს შეცდომები, მაშინ ჩვენ აპირებს მთელი რამ, სადაც
ჩვენ ბეჭდვა შეცდომა, დავხუჭავთ რესურსები, და შემდეგ დატოვა პროგრამა.
ახლა საინტერესო ის არის, სანამ შეგვიძლია ეს სურათი ფანჯარა,
ჩვენ უნდა რეალურად, რათა ის ტექსტურა.
ახლა ტექსტურა შეესაბამება გამოსახულების მონაცემების დატვირთული
შევიდა გრაფიკული ტექნიკის მეხსიერებაში.
>> ასე რომ, ზედაპირზე არის მთავარი მეხსიერება, რეგულარული მეხსიერება
რომ ჩვენ უკვე გამოყენებით ყველა სემესტრში, და ფაქტურის ამ ცალკე VRAM
მეხსიერება, რომელიც კარტა კონტროლი.
ასე რომ, ჩვენ მოვუწოდებთ ამ ფუნქციის SDL_CreateTextureFromSurface.
ჩვენ გაძლევთ, რომ ეს ჩვენი renderer და ჩვენი ზედაპირზე.
და მაშინ ჩვენ, ფაქტობრივად, კეთდება ზედაპირზე,
ასე რომ, ჩვენ უბრალოდ აპირებს გასათავისუფლებლად იგი.
ჩვენ არ გვჭირდება, რომ აღარ.
და მაშინ ასე რომ, თუ ეს მოწოდება errored და დაბრუნდა null,
მაშინ ჩვენ ვაპირებთ, რომ მთელი შეცდომა ანგარიშგების რამ ერთხელ.
>> კარგი.
აქ, ჩვენ მოხვდება ფაქტობრივი გაწევის ფუნქციები.
ასე მოუწოდებდა SDL_RenderClear გადააწოდა
renderer უკავშირდება ჩვენს window უბრალოდ ხდის window წასვლა შავი.
ასე რომ, ეს ხსნის, რომ უსარგებლო, რომ ჩვენ ვნახეთ ჩვენი ფანჯარაში და ხდის შავი.
და მაშინ ჩვენ ვაპირებთ მოვუწოდებთ SDL_RenderCopy,
მისთვის ჩვენი renderer, ჩვენი ტექსტურა.
და ჩვენ ვსაუბრობთ იმაზე, თუ რა ამ სფეროში არიან ცოტა.
მაგრამ, რომ აპირებს მიიღოს ტექსტურა მონაცემები
და კოპირება გადატანა ჩვენი window მიაპყროს იმიჯი.
ასე რომ, მას შემდეგ, რაც ჩვენ გავაკეთეთ ეს ასლი მონაცემების გადატანა ჩვენი ფანჯარა,
ჩვენ უნდა გავაკეთოთ ამ დამატებითი ფუნქცია მოუწოდა SDL_RenderPresent.
>> ეს საინტერესოა იმიტომ, რომ ეს იღებს
შევიდა თემაზე ეწოდება ორმაგი buffering.
ასე რომ, ორმაგი buffering არის ტექნიკა, რომელიც რაც თქვენი გრაფიკა გამოიყურებოდეს ბევრი უკეთესი.
ისევ და ისევ, ეს ხელს უშლის, რომ ეკრანზე tearing მე ლაპარაკი ადრე, სადაც
თქვენ გაქვთ ორი ბუფერი.
აქ არის უკან ბუფერულ მეხსიერება და წინა ბუფერული.
წინა ბუფერი ფაქტიურად რა არის თქვენს ეკრანზე მომენტში.
ასე რომ, ჩვენ ყველა ამ მიაპყროს ვარიაციები, ისევე როგორც SDL გაწევა ასლი ან SDL_RenderClear
უკან ბუფერული.
ასე რომ, ისინი ცვლილებები რამ წელს დაბრუნდა ბუფერულ.
აქ ჩვენ შეიძლება ხატვის ეს მწვანე მოედანზე უკან ბუფერული.
>> ასე რომ, მაშინ, როდესაც ჩვენ გავაკეთეთ აკეთებს ჩვენი გაწევა ოპერაციები, რომელიც
შესაძლოა, მართლაც დიდი დროს, რასაც ჩვენ ვაპირებთ, რომ
გადართოთ ბუფერი.
ასე რომ, ეს ფაქტიურად იღებს წინა ბუფერული და უკან ბუფერული
და კონცენტრატორები მათ, ასე რომ, რომ მომენტალურად,
ერთ ოპერაციას, ნაცვლად შესაძლოა, ასობით და ათასობით,
ყველა ჩვენი ახლად გაწეული ობიექტების ეკრანზე.
და ეს ხელს უშლის რამ როგორც ეკრანზე გამაგრილებელი
როდესაც ჩვენ მხოლოდ შედგენილი ნახევარი ჩვენი ობიექტების ფარგლებში.
ასე რომ, რატომ უნდა დაუკავშირდეთ SDL_RenderPresent, ასევე
როგორც SDL_RenderCopy.
>> ისევ და ისევ, ჩვენ უბრალოდ აპირებს დაველოდოთ ხუთ წამში.
მაშინ ჩვენ ვაპირებთ გაწმენდა ჩვენი რესურსები.
ჩვენ გვაქვს საკმაოდ მეტი ამ დროს.
და მაშინ ჩვენ უბრალოდ აპირებს გასასვლელად პროგრამა.
ასე რომ, მოდით გავაკეთოთ, რომ.
მე ვაპირებ აკრიფოთ მიიღოს და შემდეგ წყაროები უდრის მიესალმები ეს არის 3image.c.
ყველა უფლება, რომელიც შედგენილი არ შეცდომები.
და თქვენ შეგიძლიათ ნახოთ აქ მე ახლა შედგენილი ჩემი სურათი, Hello, CS50!
ჩვენი ფანჯარა, რომელიც ქრება მას შემდეგ, ხუთ წამში.
>> ახლა, ეს ჯერ კიდევ აქვს პრობლემები, არა?
ეს არ არის კარგი პროგრამა, იმიტომ, რომ როდესაც ვცდილობ დახურეთ ფანჯარა,
არაფერი ხდება.
ეს x კვლავ არ პასუხობს.
მოდით შევხედოთ შემდეგი ფაილის ნახვა, hello4animation.
ასე რომ, ეს არის ფაილი, რომ აპირებს გააცნოს
მოძრავი და მოძრაობა ჩვენი იმიჯი.
ამიტომ, ჩვენ ვაპირებთ გავაკეთოთ იგივე როგორც ადრე,
ინიცირება SDL, შექმნა window, შექმნა renderer,
ჩატვირთვა გამოსახულება მეხსიერება, შექმნა ტექსტურა.
ჩვენ ვნახეთ ყველა, რომ ადრე.
ახლა, ეს არის ახალი.
ჩვენ ვაპირებთ, რომ არ სტრუქტურა მოუწოდა SDL rect, რომელიც მხოლოდ მართკუთხედი.
თუ ჩვენ აქ, ჩვენ შეგვიძლია გავაკეთოთ ძიება SDL rect,
და თქვენ შეგიძლიათ ნახოთ ის ძალიან მარტივი სტრუქტურა.
მას აქვს x, y for პოზიცია და ის
აქვს სიგანე და სიმაღლე ზომა ოთხკუთხედი.
>> ასე რომ, რასაც ჩვენ ვაპირებთ გავაკეთოთ, არის ის, რომ ჩვენ აპირებს განსაზღვროს ამ SDL rect dest,
დანიშნულების.
ეს არის ადგილი, ეკრანზე, სადაც
ჩვენ ვაპირებთ, რომ ხატვის ჩვენი იმიჯი, მარჯვენა ასე
თუ ჩვენ ვაპირებთ, რომ იყოს მოძრავი გამოსახულება გარშემო,
მაშინ დანიშნულების, სადაც ჩვენ ვაპირებთ, რომ დავხატოთ სურათი
უნდა მოძრაობდნენ.
ამიტომ, ჩვენ ვაპირებთ, რომ მოვუწოდო ამ ფუნქცია SDL_QueryTexture.
და შენიშნავს, მე გავლის მისამართი საქართველოს dest.w, რომელიც არის სიგანე,
და dest.h, რომელიც სიმაღლეზე.
ასე რომ, SDL_QueryTexture აპირებს შესანახად იმ სფეროებში სიგანე
და სიმაღლე ჩვენი ტექსტურა.
>> და მერე რა მე ვაპირებ რომ გააკეთოთ, არის მე ვაპირებ
მითითებული dest.x იყოს window სიგანე მინუს dest.w, რომელიც
სიგანე Sprite, გაყოფილი 2.
და ეს ხდება, რომ მითითებული ეს ისე, რომ გამოსახულება კარგად ორიენტირებული
ჩვენს window, ყველა უფლება?
ასე რომ, ახლა მე მაქვს y პოზიცია.
და ამ აპირებს იყოს ცვლადი რომ
იცვლება, იმიტომ, რომ ჩვენ ვაპირებთ, რომ იყოს მოძრავი გამოსახულების y მიმართულებით.
და ახლა ჩვენ გვაქვს რაღაც ე.წ. ანიმაცია loop.
>> ასე რომ, როგორ ანიმაცია მუშაობა?
ისე, ადამიანის თვალის შეუძლია აღმოაჩინოს 12 მკაფიო სურათები ყოველ მეორე, ყველა უფლება?
ასე რომ, თუ ფლეშის 12 სურათი ბარათები at me მეორე, მე დავინახე, თითოეული იმ სურათები
როგორც საკუთარი მკაფიო ინდივიდუალური იმიჯი.
ახლა კი, თუ ფლეშის მეტი სურათები at me მეორე,
მაშინ ჩემი თვალი დაიწყება ბუნდოვანი მათ ერთად
და მე აღქმული იქნება, როგორც მოძრაობის, ნაცვლად ერთი მკაფიო გამოსახულება.
ასე, მაგალითად, ფილმები და სატელევიზიო, ისინი ფლეშის images თქვენ 24-ჯერ
მეორე.
ასე რომ, 24 კადრი წამში.
კომპიუტერის ეკრანები, მეორეს მხრივ, ხშირად 60 კადრი წამში.
სწორედ მათი განახლება სიჩქარე.
ეს არის ის, თუ როგორ ხშირად ისინი ამოცნობა სურათი ეკრანზე.
ასე რომ, ჩვენი სამიზნე იქნება 60 ფარგლებში წამში ჩვენი თამაშები.
>> ასე რომ, ვნახოთ, რომ კოდი.
ამიტომ თითოეული ჩარჩო, ჩვენ პირველი ვაპირებ გარკვევას ფანჯარა.
ეს არის ზოგადი ნიმუში.
თქვენ ყოველთვის გარკვევა window თითოეული ჩარჩო, და შემდეგ
ყველაფერი თქვენი ნახაზი ოპერაციების, და მერე ბოლოს,
არ RenderPresent უნდა ნახოთ ყველაფერი ფარგლებში.
და მაშინ თქვენ აპირებს უნდა დაველოდოთ ბოლოს
დაველოდოთ შემდეგი ჩარჩო უნდა დაიწყოს.
>> ასე რომ, თუ მე აკეთებდა ბევრი რთული გამოთვლები აქ
რომ აიღო 16-ზე მეტი მილიწამებში, შეუძლებელი იქნება ჩემთვის
უნდა, რომ გადაღების სიხშირე 60 რომ მინდოდა, იმიტომ, რომ ყოველ ჩარჩო
აღების დიდი ხნის გამოთვლაც.
გარდა ამისა, ჩვენ ნამდვილად აკეთებს ერთგვარი უმნიშვნელო რაოდენობით სამუშაო
აქ, იმიტომ, რომ იქ მხოლოდ ერთი რამ ჩვენ ხატვის.
ასე რომ, მე უბრალოდ დაველოდოთ 1/60 ერთი მეორე, რომელიც არის სიგრძეზე
ჩარჩო შორის ფარგლებში.
ასე რომ, მე ერთგვარი თითქოს აკეთებს ყველა ჩემი მუშაობის იღებს ნულოვანი დრო.
მაგრამ რეალური თამაში, ნეტავ უნდა გამოვაკლოთ
თანხის დრო დასჭირდა ამის გაკეთება ყველა ამ სამუშაოს თქვენი დასვენების დრო.
>> ასე რომ მაინც, რა ვარ მე რეალურად აკეთებს ამ loop?
მე გარკვევა ფანჯარა.
I მითითებული dest.y, რომელიც არის int to ჩემი ფაქტობრივი y პოზიცია მიცემული int.
ახლა, მე მინდა ათწილადი გაფართოება ჩემი y პოზიცია ჩემი თამაში,
მაგრამ მაშინ რეალურად შევაჩერო ეს გადატანა ეკრანზე,
მას სჭირდება ints, იმიტომ, რომ ეს ერთეული pixels, ისე, რომ ის, რაც მსახიობი არის.
მე ვაპირებ შევაჩერო იმიჯი.
ასე რომ, ეს არის წყარო მართკუთხედი.
და ეს არის დანიშნულების მართკუთხედი.
ასე რომ, მე გაიარა null for წყარო მართკუთხედი
ვთქვა, მინდა რომ ჩემი მთელი ტექსტურა.
მაგრამ თუ ჰქონდა ბევრი ტექსტურები თქვენი თამაში
და ისინი ყველა ერთ დიდ ტექსტურა რუკა რომ დატვირთულია SDL როგორც მხოლოდ ერთი
ტექსტურა, თქვენ შეიძლება გამოიყენოთ წყარო მართკუთხედი
აირჩიოთ ერთი პატარა ტექსტურები, ერთი პატარა sprites,
გარეთ რომ დიდი ტექსტურა რუკა.
>> ასე რომ კიდევ ერთხელ, მე გავლით ჩემი გაწევა, ჩემი ტექსტურა, და ახლა დანიშნულების.
ეს იქნება, სადაც window ის აპირებს იყოს.
და მაშინ, იმიტომ, რომ მე ანიმაციური რაღაც, მე უნდა მოძრაობა,
მე ვაპირებ განახლება Sprite, პოზიცია თითოეული ჩარჩო.
ასე რომ, მე ამ მუდმივი მოუწოდა გადახვევა დააჩქაროს ერთეული პიქსელი წამში.
ახლა, ყოველ ჯერზე ჩვენ გავაკეთებთ მოძრაობა, ჩარჩო არის მხოლოდ 1/60 მეორე.
ამიტომ, მე ვაპირებ, რომ გაყოფა, რომ 60.
და შემდეგ, ვნახოთ, მე გამოკლებით, რომ y პოზიცია.
რატომ ვაკლებთ?
ჩვენ კიდევ, რომ მეორე.
ასე რომ მერე გაწმენდა ჩემი რესურსები და პროგრამა დასრულდა.
>> მოდით, რომ.
ასე რომ, მოდით წასვლას მიიღოს SRCS = Hello4 animation.c, ყველა უფლება?
თამაშის.
ესეც ასე.
ასე რომ მე სენსორული მდე ფანჯარა, რომელიც არის საკმაოდ სუფთა.
მაგრამ გამართავს, მე გამოკლება საწყისი y პოზიცია ყოველ ჯერზე.
რა ხდება იქ?
ისე, გამოდის, რომ ამ SDL და სინამდვილეში, ყველაზე კომპიუტერული გრაფიკა,
წარმოშობის საკოორდინატო სისტემა არის ზედა მარცხენა ფანჯარა.
>> ასე რომ, დადებითი x მიმართულებით მიდის მთელს თქვენს window უფლება.
და დადებითი y მიმართულებით რეალურად მიდის ქვემოთ.
ასე რომ კიდევ ერთხელ, წარმოშობის ს ზედა მარცხენა ფანჯარა,
დადებითი y მიმართულებით ქვემოთ, და დადებითი x არის სწორი.
ასე რომ, როცა სხვაობა შ პოზიცია, რომ
ვაპირებთ, რათა ის წასვლა უარყოფითი y მიმართულებით, რომელიც არის up ფანჯარა.
ასე რომ, რა ხდება იქ.
ზემოთ.
>> მოდით შევხედოთ შემდეგი ფაილი.
აქ არის ნაწილი შოუ, სადაც ჩვენ საბოლოოდ
მიიღოს, რომ X კუთხეში ფანჯარა რომ უნდა დახუროთ ფანჯარა
მუშაობა.
რა ხდება?
ჩვენ ინიციალიზაცია SDL, შექმნა ფანჯარა, შექმნა renderer, ჩატვირთვა გამოსახულება,
შექმნა ტექსტურა როგორც ჩვენ ვნახეთ ადრე.
ჩვენ გვყავს იგივე დანიშნულების მართკუთხედი როგორც ადრე, იგივე ზარი შეკითხვის ტექსტურა.
მაგრამ ამ დროს, ჩვენ მაშინ ვაპირებთ, რომ დაყოფის სიგანე
და სიმაღლე ჩვენი დანიშნულების 4.
ეს მხოლოდ აქვს ეფექტი სკალირების ჩვენი იმიჯი, როდესაც
არიან ეს ფანჯარა ოთხი.
ასე რომ, საკმაოდ სუფთა.
ჩვენ შეგვიძლია მხოლოდ მასშტაბის, ისევე, როგორც, რომ.
ჩვენ ვაპირებთ, რომ დაიწყოს Sprite, ცენტრში ეკრანზე.
და ახლა ჩვენ გვაქვს x და y სიჩქარე და ისინი ორივე აპირებს დაიწყოს ნულოვანი.
>> ეს არის არასწორი ფაილი.
ბოდიში.
ასე რომ, ყველა ჭეშმარიტი.
ეს ყველაფერი ჯერ კიდევ ამ ფაილის.
ჩვენ გვაქვს გაყოფილი 4 და ყველაფერი.
ასე რომ, აქ ჩვენ გვაქვს ჩვენი x და y პოზიცია ცენტრში ფანჯარა.
და ვაძლევთ მას საწყისი სიჩქარე ამ მუდმივი სიჩქარით, რომელიც
მე მჯერა, არის 300 პიქსელი წამში.
ახლა, ჩვენ გვაქვს ეს int შეიძლება უბრალოდ ისევე იყოს ლოგიკური უწოდა ახლოს მოითხოვა.
და ნაცვლად აკეთებს უსასრულო ციკლი ტაიმერი აქ,
ჩვენ ვაპირებთ, რომ იყოს ანიმაციური, როგორც სანამ ახლოს არ არის მოთხოვნილი.
>> ასე რომ, თუ ჩვენ შევძლებთ მოვლენები?
ისე, SDL რიგები up მოვლენების ლიტერატურული მდგომ კულისებში.
და მაშინ თითოეული ჩარჩო, ჩვენ შეგვიძლია dequeue მოვლენები
რომ მდგომ გამოყენებით ეს მოწოდება SDL_PullEvent.
ისევ და ისევ, აუცილებლად წაიკითხავს ამ დოკუმენტაცია.
არსებობს უამრავი უფრო დეტალურად და ბევრი მეტი ფუნქციები შეგიძლიათ გამოიყენოთ ეს.
ჩვენ გაიაროს ეს მისამართი ამ რამ, SDL_Event
რომ ჩვენ გვაქვს აქ Stack.
>> ახლა, რა არის SDL_event?
იმის გამო, რომ SDL, თუ გადავხედავთ documentation-- მოდით
ვხედავ, API კატეგორიის მიხედვით, input მოვლენები, ღონისძიების გატარება,
ჩვენ შეგვიძლია შევხედოთ ნომერი სხვადასხვა მოვლენების აქ
და ჩვენ ვხედავთ, რომ იქ მთელი ტონა მათ.
რა არის ეს SDL_Event რამ?
SDL_Event არის კავშირი.
Wow, რა კავშირი?
თქვენ ალბათ არასოდეს გამიგია, რომ ადრე.
და რომ კარგადაა.
>> კავშირი არის სახის მოსწონს struct, გარდა struct
აქვს ფართი ყველა მისი სფეროებში და მეხსიერება,
ხოლო კავშირი მხოლოდ საკმარისი სივრცე, რათა შეწყობოდა უდიდესი
მისი ერთ-ერთი სფეროებში, რაც იმას ნიშნავს, შესაძლებელია მხოლოდ შესანახად მისი ერთ-ერთი სფეროებში
იმ დროს, რომელიც სახის აზრი მოვლენები, არა?
ჩვენ შეგვიძლია კლავიატურის მოვლენის ან window ღონისძიება,
მაგრამ ერთი ღონისძიება არ შეიძლება იყოს, როგორც კლავიატურის ღონისძიება და window ღონისძიება,
ამიტომ მინდა იყოს სულელური ჰქონდეს ფართი ორივე შიგნით ჩვენი ღონისძიება კავშირი.
ასე რომ, თუ თქვენ სურდა შექმნათ თქვენი საკუთარი კავშირი,
ეს გამოიყურება ზუსტად იგივე შექმნის struct,
გარდა იმისა, რომ ჩვენ ვიყენებთ კავშირის სიტყვით ნაცვლად struct სიტყვით.
და მახსოვს, რომ ყველა რამ შიგნით თქვენი კავშირი,
ფაქტობრივი ცვლადი, რომელიც არის კავშირი შეიძლება ჰქონდეს მხოლოდ ერთი იმ ფასეულობებს
დროულად.
>> მაშ, როგორ შეგვიძლია გითხრათ, თუ რა სახის ღონისძიება ჩვენ უბრალოდ გამოჩნდა off ამ მდგომ?
ისე, ჩვენ შეგვიძლია შევამოწმოთ event.type.
და თუ ეს უდრის რომ SDL_Quit, ჩვენ ვიცით,
ეს არის ღონისძიება, რომელიც გენერირებული როდესაც ჩვენ
მოხვდა, რომ X კუთხეში ფანჯარა.
და ჩვენ შეგვიძლია მითითებული ახლოს მოითხოვა უდრის 1.
დანარჩენი არის მხოლოდ გარკვეული ანიმაცია რომ ვნახე ადრე.
მოდით, წავიდეთ წინ და ამ და ვნახოთ რამდენად კარგად მუშაობს.
ამიტომ, მე ვაპირებ აკრიფოთ მიიღოს და მაშინ SRCS = hello5_events.c.
იქ ჩვენ წავიდეთ.
თამაშები.
>> ახლა, ჩვენ ვხედავთ, რომ ეს იყო მართლაც მასშტაბური ქვემოთ ოთხი.
და ახლა ის bouncing გარშემო.
მაქვს რამდენიმე შეჯახების აღმოჩენისა მიმდინარეობს მხარეს window
რომ ჩვენ შეგვიძლია შევხედოთ.
და რა ხდება, როდესაც მე წასვლა დახურვა?
ეს იხურება.
Fantastic.
ჩვენ მივიღეთ, რომ ღონისძიება.
ჩვენ სიფრთხილით იგი.
>> მოდით ვიხსენებთ კოდი.
ასე რომ, როგორ მივიღებ bouncing გარშემო, რომ?
დამახსოვრება I მითითებული ორივე x და y თავდაპირველად სიჩქარეზე.
და სიჩქარე არის დადებითი მუდმივი, ისე, რომ
აპირებს მიიღოს ეს დაწყებული გარეთ მიდის ქვემოთ და მარჯვნივ.
>> ახლა, ყოველ ფარგლებში, გარდა გატარება რაიმე მოვლენების, რომელიც არ უნდა მომხდარიყო,
მე ვაპირებ აღმოაჩინოს თუ არა ჩემი Sprite, ცდილობს გარეთ ფანჯარა.
ასე რომ, ჩვენ შეგვიძლია გავაკეთოთ, რომ მხოლოდ შემოწმების x_pos 0, y_pos 0, და მაშინ
ასევე x_pos და y_pos ერთად window სიგანე და window სიმაღლეზე.
ყურადღება მიაქციეთ, მე გამოაკლდა სიგანე Sprite.
და ეს იმიტომ, რომ თუ არ სხვაობა სიგანე Sprite,
ეს მხოლოდ შეამოწმოს, რომ წარმოშობის Sprite,
არ წავიდეთ გარეთ ფანჯარა.
მაგრამ ჩვენ გვინდა, რომ მთელი სიგანე Sprite,
ყოველთვის იქნება შიგნით ფანჯარა და მთელ სიმაღლეზე Sprite,
ყოველთვის იქნება შიგნით ფანჯარა.
ასე რომ, რა გამოკლება არის.
ბევრი გეომეტრია აქ შეგიძლიათ სასარგებლო იქნება დაგეხატა
ქაღალდზე კოორდინირებული სისტემა, თუ რა ხდება.
>> ასე რომ, თუ დაეჯახება, მე მხოლოდ უბრალოდ აღადგინოთ პოზიცია
ისე, რომ იგი არ აპირებს გარეთ ეკრანზე.
და მე ვაპირებ, თუ იგი ხტება ერთი sidewalls,
მე ვაპირებ უარყოფს x სიჩქარე ისე, რომ იგი
იწყება bouncing სხვა მიმართულებით.
და ანალოგიურად, თუ იგი ჰიტები ზედა და ქვედა,
მე ვაპირებ მითითებული y სიჩქარე ტოლი უარყოფითი y სიჩქარე,
ისე, რომ ახსნას.
ასე რომ, მხოლოდ, როგორ მივიღეთ ეს აქ.
>> და განახლება თანამდებობებზე ისევე, როგორც ჩვენ ვნახეთ ადრე,
გავყოთ 60, იმიტომ, რომ ჩვენ მხოლოდ გატარება 1/60 მეორე.
და მაშინ გაწევის, ზუსტად ისევე, როგორც ადრე.
და ისე, რომ ყველაფერი რომ ხდებოდა ეს ფაილი.
ასე რომ, თუ როგორ გავაკეთოთ მოვლენები.
მთავარია, რომ წართმევას აქ ეს არის SDL_PullEvent ფუნქცია.
და თქვენ უნდა აუცილებლად წაიკითხეთ დოკუმენტაცია უფრო მეტი SDL_Event
კავშირი, იმიტომ, რომ ეს მონაცემები ტიპის ძალიან, ძალიან მნიშვნელოვანია, იმიტომ, რომ ჩვენ ვიყენებთ
ყველა სახის ღონისძიებები.
>> მაგალითად, ჩვენ ვიყენებთ მას კლავიატურის მოვლენები, რაც ეს ფაილი.
ასე რომ, რა გვაქვს?
ჩვენ გვყავს იგივე რამ, როგორც ადრე, ინიციალიზაცია SDL, შექმნა ფანჯარა,
შექმნა renderer, ჩატვირთვა გამოსახულება მეხსიერებაში, შექმნა ტექსტურა.
კიდევ ერთხელ, ჩვენ ვაპირებთ აქვს ამ dest მართკუთხედი,
ჩვენ ვაპირებთ, რომ მასშტაბის იმიჯი ოთხი, რათა ის ცოტა პატარა.
ახლა, ჩვენ ვაპირებთ, რომ დაიწყოს Sprite-ცენტრში ეკრანზე.
მაგრამ ამ დროს, ჩვენ ვაპირებთ, რომ მითითებული საწყის x და y სიჩქარეების ნულოვანი,
იმიტომ, რომ კლავიატურაზე აპირებს გაკონტროლება იმ.
და უფრო მეტიც, ჩვენ ვაპირებთ ტრეკზე ამ ცვლადის
up, down, მარცხენა და მარჯვენა.
და რომ აპირებს შენარჩუნება ტრეკზე თუ არა ჩვენ
დაპრესილი კლავიატურის ღილაკების, რომ შეესაბამება up, down, მარცხენა,
და მარჯვენა.
>> ახლა, ეს არის ერთგვარი ლამაზი იმიტომ, რომ ჩვენ შეგვიძლია გამოვიყენოთ W, A, S,
D აქ, ან ფაქტობრივი ისრიანი ღილაკები.
ჩვენ დავინახავთ, რომ მხოლოდ მეორე.
ამიტომ, ჩვენ ვაპირებთ, რომ გადაამუშავებს იმ შემთხვევაში, ისევე, როგორც ადრე.
ჩვენ გაიყვანოს ღონისძიება.
მაგრამ ახლა ჩვენ ვაპირებთ ჩართვის ღონისძიება ტიპის.
თუ ეს SDL_Quit, ჩვენ შექმნას აპირებს ახლოს
მოითხოვა ერთი, ისევე როგორც ადრე.
რომელიც ახორციელებს x in კუთხეში ფანჯარა,
ასე რომ, ჩვენი ფანჯარა რეალურად ხურავს.
>> წინააღმდეგ შემთხვევაში, თუ მივიღებთ SDL გასაღები ქვემოთ ღონისძიება, რაც იმას ნიშნავს, დაპრესილი გასაღები,
შემდეგ, რაც ჩვენ ვაპირებთ გავაკეთოთ არის, რომ ჩვენ ვაპირებ გადახვიდეთ ამ რამ აქ,
რომელიც ნიშნავს, ასე რომ event.key იმას ნიშნავს, მკურნალობა ჩვენი ღონისძიება კავშირის,
წავიდეთ და მიიღოს გასაღები ღონისძიების სტრუქტურა მას.
გამოდის, რომ ეს კავშირი არის მნიშვნელოვანი მოვლენა, სტრუქტურა.
და მერე გასაღები ღონისძიების სტრუქტურა თავის სფეროში
მოუწოდა keysym და შემდეგ scancode.
ისევ და ისევ, აუცილებლად წაიკითხონ დოკუმენტაცია შესახებ.
საკვანძო საშუალებებით საკმაოდ საინტერესო.
თქვენ შეგიძლიათ სკანირების კოდები და გასაღები კოდები.
და ეს ცოტა დახვეწილი, მაგრამ დოკუმენტაცია საკმაოდ კარგი.
>> ასე რომ, თუ ჩვენ ვხედავთ სკანირების კოდი ჩვენი ძირითადი პრესაში უკვე W ან,
ჩვენ ვაპირებთ, რომ შეიქმნას თანაბარი 1.
და მაშინ ჩვენ შესვენება გარეთ რომ შეცვლა.
თუ ის ან მარცხენა, ჩვენ მითითებული დარჩა 1, და cetera, et cetera, ქვევით და მარჯვენა.
ახლა, ამ გარე switch, თუ ჩვენ ვხედავთ საკვანძო ღონისძიება,
ეს ნიშნავს, რომ ჩვენ გაავრცელა გასაღები და ჩვენ აღარ დაჭერით იგი.
ამიტომ, მე ვაპირებ ვთქვა უდრის 0, მარცხენა უდრის 0, ქვემოთ უდრის 0, მარჯვენა
უდრის 0, et cetera.
>> და შენიშნავს, ჩვენ თითოეული ამ ორ შემთხვევაში მას უფლება შემდეგი ერთმანეთს
არ ცალკე კოდი პირველი საქმე, რომელიც
იმას ნიშნავს, რომ თუ არა ეს S ან ქვემოთ აქ,
ის აპირებს შეასრულოს ეს კოდი.
ასე რომ, საკმაოდ მოსახერხებელია.
ეს ხელს უშლის ჩვენს რომელსაც ამის გაკეთება უფრო პირობები და IFS და რამ
ეგრე.
>> ასე რომ, ჩვენ ვაპირებთ დადგინდეს, სიჩქარე.
ჩვენ მითითებული სიჩქარე 0.
მაშინ, თუ up დაჭერის და არა ქვემოთ, მაშინ ჩვენ
მითითებული y სიჩქარე უარყოფითი სიჩქარე.
დამახსოვრება უარყოფითი, რადგან უარყოფითი y მიმართულებით არის.
და დადებითი y მიმართულებით ქვემოთ.
თუ ქვემოთ არის დაპრესილი და არა, მაშინ ჩვენ
შექმნას აპირებს, რომ ეს დადებითი სიჩქარე, რაც იმას ნიშნავს, აპირებს ქვემოთ ეკრანზე.
იგივე მარცხენა და მარჯვენა.
>> და მაშინ ჩვენ ვაპირებთ განაახლოს იმ პოზიციებზე, ისევე როგორც ადრე.
ჩვენ ვაპირებთ, რომ შეჯახება გამოვლენის საზღვრები,
მაგრამ ჩვენ არ ვაპირებთ, რომ აღადგინოთ სიჩქარე, რადგან სიჩქარე არის მხოლოდ
აკონტროლებს კლავიატურაზე.
მაგრამ ჩვენ ვაპირებთ, რომ აღადგინოთ პოზიციების შენარჩუნება ეს ფანჯარა.
და ჩვენ ვაპირებთ, რომ მითითებული თანამდებობებზე struct
და ამის შემდეგ ყველაფერი გაწევის პერსონალის წინაშე.
მოდით ვნახოთ, თუ რას აკეთებს.
ასე რომ SRCS-- ვნახოთ, ეს არის hello6_keyboard.c.
>> ო არა.
ასე რომ, ჩვენ რაღაც გაფრთხილება აქ.
და ეს უბრალოდ ვამბობ, ჩვენ არ შეამოწმეთ თითოეული შესაძლო სახის
ღონისძიება.
ეს კარგია, რადგან იქ 236 მათგანი ან ასე.
ამიტომ, მე ვაპირებ იგნორირება იმ გაფრთხილება.
ეს ჯერ კიდევ შედგენილი ჯარიმა.
ამიტომ, მე ვაპირებ, რომ ითამაშოს თამაში.
ეს არ მოძრაობს.
მაგრამ ახლა, როდესაც მე ბადაგი ჩემს კლავიატურაზე, მე შემიძლია ამის გაკეთება რაღაც WASD გადაადგილება აქ,
მე ჩემი arrow გასაღებები, ასევე.
და შეამჩნია, მიუხედავად იმისა, რომ მე დაჭერით მარჯვენა ახლა,
ის არ აპირებს ფანჯრიდან, იმიტომ, რომ მე აღადგინოთ ის ყოველ ჩარჩო.
ასე რომ, საკმაოდ სუფთა.
თქვენ წარმოიდგინეთ, მოძრაობდნენ Mario ერთად ზოგიერთი ისრიანი ღილაკები ან რამე მაგდაგვარს.
დიახ, X არ იმუშავებს.
>> ასე რომ, საბოლოო ფაილის ჩვენ ვაპირებთ შევხედოთ, hellow7_mouse.
ეს არის დაახლოებით მიღების მაუსის შეყვანა.
ასე რომ, ამ ერთი, ჩვენ იმპორტი მათემატიკის header,
იმიტომ, რომ ჩვენ ვაპირებთ აქვს ცოტა მათემატიკა აქ.
იმავე წლის, იმავე წლის პერსონალი, დანიშნულების, იმავე წლის, ჩანს, რომ ადრე.
ისე, ეს არის საინტერესო.
ასე რომ, ჩვენ უკან მხოლოდ შემოწმების იმ SDL დატოვა ღონისძიება.
ეს რატომ?
ასე რომ თქვენ შეგიძლიათ მაუსის შეტანის მოვლენები.
ასე, როდესაც მაუსი გადავიდა, თქვენ ღონისძიება, რომ.
როდესაც მაუსის ღილაკზე დაჭერის, თქვენ შეგიძლიათ მიიღოთ ღონისძიება, რომ.
>> მაგრამ არსებობს კიდევ ერთი, ოდნავ მარტივი ალბათ, API მისაღებად მაუსის შეყვანა.
და ეს უბრალოდ SDL მისაღებად მაუსის სახელმწიფო.
ასე რომ, მე int x და y კურსორი პოზიცია.
გაივლის მას SDL_GetMouseState, რომელიც ადგენს ამ.
და ეს არის პოზიცია საკოორდინატო სისტემაში ფანჯარა.
ასე რომ, თუ მასა ზედა მარცხენა ფანჯარა, რომ 0, 0.
>> ახლა, რა მე ვაპირებ ამის გაკეთებას, მე ვაპირებ უნდა გავაკეთოთ ცოტა ვექტორი მათემატიკის.
მე დადებს თქვენ ეგონა, თქვენ არ ვხედავ, რომ CS50, მაგრამ აქ არის.
მე ვაპირებ დაკავდით ვექტორი მათემატიკის მისაღებად ვექტორი
იმიჯი კურსორი.
ასე რომ, რატომ მაქვს ეს გამოკლება აქ?
ისე, თუ უბრალოდ გამოიყენება dest .-- ასე მე უნდა თარგმნოს მაუსის x
და y ნახევარი სიგანე და სიმაღლე იმიჯი,
იმიტომ, რომ მინდა ცენტრში იმიჯი უნდა სვლას მაუსი,
წარმოშობის იმიჯი.
>> ასე რომ, უბრალოდ დარწმუნდით, მე ვსაუბრობ შესახებ ცენტრში იმიჯი აქ.
ამის შემდეგ მივიღებთ დელტა x და y, რომელიც არის განსხვავება სამიზნე
ფაქტობრივი პოზიცია იმიჯი.
და მაშინ ჩვენ შეგვიძლია მისაღებად დისტანცირება აქ,
იქნება პითაგორას თეორემა, კვადრატული ფესვი x
x + y ჯერ y.
>> ახლა თავიდან ასაცილებლად დაზიანებული, და მე შემიძლია, თქვენ რა ეს იმას, თუ არ გააკეთებს,
თუ მანძილი კურსორი და image ცენტრი ხუთზე ნაკლებია,
მე უბრალოდ არ აპირებს გადავიდეს გამოსახულება.
წინააღმდეგ შემთხვევაში, ჩვენ მითითებული სიჩქარე.
და ჩვენ დავსახეთ ისე, რომ სიჩქარე ყოველთვის იქნება მუდმივი.
და წმინდა შედეგად ყველა მათემატიკის არის, რომ გამოსახულება
აპირებს სვლა კურსორი.
>> ახლა ირკვევა, რომ SDL_GetMouseState,
გარდა იმისა, რომ შექმნის x და y არგუმენტები აქ,
მას ასევე ბრუნდება int, რომელიც შეესაბამება სახელმწიფო მაუსის ღილაკების.
ამიტომ, ჩვენ ვერ წავიკითხე, რომ პირდაპირ, მაგრამ შეგვიძლია
გამოიყენოთ ეს macros, ერთი bitwise ოპერატორი, არ არის, რომ საშინელი,
უბრალოდ bitwise და.
ამიტომ ჩვენ ვამბობთ, ღილაკები, რომელიც არის შედეგი ჩვენი SDL_GetMouseState, თუ ეს
და bitwise და ამ მაკრო აქ, SDL_BUTTON_LEFT.
>> ასე რომ, ეს უბრალოდ გადავწყვიტოთ რომ bitmap, რომელიც შეესაბამება
მარცხენა ღილაკს მიმდინარეობს ზეწოლა.
ასე რომ, თუ bitwise და ხდება და ეს
ნულოვანი, რაც იმას ნიშნავს, მარცხენა ღილაკს დაპრესილი,
მაშინ ჩვენ რეალურად აპირებს უარყოფს ორივე x და y სიჩქარეები,
რომელიც მხოლოდ იმიჯის გაქცეული.
განახლების პოზიციებზე.
შეჯახება გამოვლენის, ჩანს, რომ ყველა ადრე, გაწევის, ყველა უფლება.
მოდით ეს.
ასე რომ, შენ, რათა SRCS = hello7_mouse.c.
შესანიშნავი.
შეცდომები.
და თამაში.
>> ასე რომ, აქ მაქვს ჩემი მაუსი.
და იმიჯი მართლაც გატანა ჩემი მაუსი.
ახლა კი, თამაში თქვენ, შესაძლოა, ეს არის, როგორც მტრის დევნა
თქვენი პატარა ხასიათი ან რასაც.
მაგრამ აქ ჩვენ გვაქვს სურათი გატანა მაუსის.
და როდესაც მე დააჭირეთ მაუსის იწყება დევნა იმიჯი
და სურათი არის გარბიან მაუსი.
ასე რომ, საკმაოდ გრილი.
და შეამჩნია, რომ მიუხედავად კიდევ შეჯახების აღმოჩენის აქ.
>> ასე რომ, საბოლოო პატარა დემო მე არ შეიქმნას აქ.
და მოდით შევხედოთ კიდევ ერთი რამ.
ასე რომ, უკან აქ, ვთქვი ეს დაზიანებული.
კარგი.
ასე რომ, თუ მანძილი ნაკლებია, ვიდრე ხუთი პიქსელი, მე შექმნის x და y სიჩქარე ნულის ტოლია.
რა მოხდება, თუ ჩვენ დავაღწიოთ რომ?
ამიტომ, მე ვაპირებ, რომ მხოლოდ ამის გაკეთება.
გთხოვთ ამართლებს ამ საშინელი სტილი, მაგრამ ჩვენ კომენტარს out სწორი კოდი.
ამიტომ, მე ვაპირებ გადარჩენა, და გავაკეთოთ იგივე ბრძანება სანამ, რათა ის.
>> კარგი.
და ახლა რა ხდება?
კარგი.
ჩვენ ჯერ კიდევ შემდეგ მაუსი, ისევე, როგორც ადრე,
მაგრამ, როდესაც ჩვენ ვიღებთ მაუსი, ჩვენ მივიღეთ ეს მთლიანი დაზიანებული.
რა ხდება იქ?
ისე, ჩვენი ვექტორი მათემატიკის, უნდა გვახსოვდეს, რომ იყო
აღების შორის მანძილი კურსორი და ცენტრში იმიჯი?
ისე, როგორც, რომ უახლოვდება 0, ჩვენ ვიწყებთ მისაღებად
ამ სახის გიჟები ქცევა სადაც იმიჯი არის ერთგვარი
როგორიცაა მოძრავი გარშემო კურსორი.
და ეს ქმნის ამ დაზიანებული.
და ეს მართლაც მახინჯი.
და თქვენ ალბათ არ გსურთ თქვენი თამაშები აკეთებს, რომ,
თუ იგი არ არის გარკვეული სპეციალური ეფექტი.
>> ასე რომ, რატომ ჩვენ მხოლოდ ამ თვითნებურ
შეწყვიტა ხუთ პიქსელი, სადაც ჩვენ ვამბობთ თუ ის ხუთ პიქსელი, ჩვენ კარგი.
ჩვენ არ უნდა გადავიდეს გამოსახულება აღარ.
ასე რომ, რა ხდება იქ.
>> ასე რომ, საკმაოდ ბევრი იყო.
თქვენ ახლა უკვე იცის თუ როგორ უნდა შექმნათ ფანჯარა, ჩატვირთვა გამოსახულება,
მიაპყროს გამოსახულების ფანჯარაში, მიიღოს კლავიატურის შეყვანის, მიიღოს მაუსის შეტანის,
აქ არის რამოდენიმე სხვა input, რომ თქვენ არ
ვიცი, როგორ უნდა თუ უბრალოდ გაატარონ რამდენიმე წუთის ეძებს დოკუმენტაცია.
ასე, რომ თქვენ რეალურად საკმაოდ რამდენიმე ინსტრუმენტები თქვენს განკარგულებაშია ახლა
დაწერა სრულფასოვანი თამაში.
>> ახლა, ყოველ თამაში საჭიროებს აუდიო, მაგრამ აუდიო დოკუმენტაცია
ასევე საკმაოდ კარგი.
და მე ვარ სურვილი, რომ დადებს, რომ თუ თქვენ იცით, ყველა რამ,
ჩვენ ვისაუბრეთ დღეს სურათები, და ზედაპირზე,
ფანჯრები, და ყველაფერი, მაშინ მჭიდროდაა out აუდიო API არ არის
იქნება, რომ ცუდია.
ასე რომ, მე მჯერა, რომ ხედავს ის, რაც თქვენ შექმნათ SDL.