1
00:00:00,000 --> 00:00:05,069

2
00:00:05,069 --> 00:00:06,110
THOMAS LIVELY ყველა უფლება.

3
00:00:06,110 --> 00:00:07,450
გამარჯობა ყველას.

4
00:00:07,450 --> 00:00:08,690
მე თომას Lively.

5
00:00:08,690 --> 00:00:15,160
ეს სემინარი იქნება
წერა 2D თამაშები C გამოყენებით SDL.

6
00:00:15,160 --> 00:00:17,970
ასე რომ, მე ვიცი, რომ თქვენ ყველა
ითხოვს, ჰო, მე ნამდვილად

7
00:00:17,970 --> 00:00:22,050
მინდა, რომ ითამაშოს თამაშები და თამაშები,
მაგრამ რა არის ეს SDL ბიზნესი?

8
00:00:22,050 --> 00:00:25,320
ასე რომ, SDL არის C ბიბლიოთეკა.

9
00:00:25,320 --> 00:00:28,270
იგი დგას მარტივი
DirectMedia Layer.

10
00:00:28,270 --> 00:00:31,340
და ეს არის ჯვარი პლატფორმა,
თამაშის განვითარების ბიბლიოთეკა.

11
00:00:31,340 --> 00:00:37,160
მუშაობს Windows, Mac,
Linux, მაშინაც კი, iOS და Android.

12
00:00:37,160 --> 00:00:40,380
ეს სახელურები რამ, როგორიცაა
ხელმისაწვდომობის აუდიო სისტემები

13
00:00:40,380 --> 00:00:44,900
კომპიუტერი, კლავიატურა, და
მაუსი, ჯოისტიკით, თუ ისინი ერთვის.

14
00:00:44,900 --> 00:00:48,300
მობილური, ის კი არ
შეყვანა და ყველა რომ.

15
00:00:48,300 --> 00:00:53,030
და რა თქმა უნდა, ეს სახელურები გრაფიკა,
ხატვის რამ ეკრანზე.

16
00:00:53,030 --> 00:00:56,470
>> ასე რომ, ეს ძალიან ფართოდ გამოიყენება, მიუხედავად იმისა,
თქვენ შეიძლება არ მსმენია ეს ადრე.

17
00:00:56,470 --> 00:01:00,860
ის აშენებულია შევიდა, მაგალითად,
Valve წყარო ძრავა,

18
00:01:00,860 --> 00:01:04,970
რომელიც უფლებამოსილების თამაშები, როგორიცაა
Portal და Team Fortress 2.

19
00:01:04,970 --> 00:01:08,680
ეს არის ასევე ძალიან დიდი რაოდენობით
ინდი თამაშები რომ გამოვა,

20
00:01:08,680 --> 00:01:13,545
ასე რომ მე ვარ აღფრთოვანებული, რომ ის, რაც თქვენ
ყველა იქნება მიღების იგი.

21
00:01:13,545 --> 00:01:20,000
>> სემინარის მიზნები, რომ თქვენ
გადმოცემულია იყოს ვითარდება SDL.

22
00:01:20,000 --> 00:01:22,700
ჩვენ ვაპირებთ, რომ ისწავლონ, თუ როგორ
თამაშის შექმნა ფანჯარა.

23
00:01:22,700 --> 00:01:26,130
ჩვენ ვაპირებთ, რომ შევქმნათ sprites,
რომლებიც სურათები თქვენი თამაში

24
00:01:26,130 --> 00:01:27,744
რომ შეუძლიათ გადაადგილება.

25
00:01:27,744 --> 00:01:29,910
ჩვენ ვაპირებთ, რომ ისწავლონ, თუ როგორ
და animate sprites,

26
00:01:29,910 --> 00:01:32,910
ასე რომ, მათი გადაადგილება, რათა
მათ დროთა განმავლობაში შეიცვლება.

27
00:01:32,910 --> 00:01:35,580
და ჩვენ ვაპირებთ, რომ ისწავლონ
ხელში კლავიატურა და მაუსი

28
00:01:35,580 --> 00:01:38,240
შეყვანის კომპიუტერი.

29
00:01:38,240 --> 00:01:41,550
ის, რაც ჩვენ არ იქნება ლაპარაკი
დღეს არის 3D გრაფიკა,

30
00:01:41,550 --> 00:01:45,520
იმიტომ, რომ ძალიან რთული
სათაური, რომ ჩვენ არ გვაქვს დრო.

31
00:01:45,520 --> 00:01:49,010
ჩვენ არ ისწავლოს
აუდიო ჩვენს თამაშები.

32
00:01:49,010 --> 00:01:53,300
და ჩვენ არ უნდა მშენებლობის
არაფერი მაგრამ Linux.

33
00:01:53,300 --> 00:01:58,330
>> ახლა აპირებს არსებობს, რომ,
იმედია, ბოლოს სემინარის

34
00:01:58,330 --> 00:02:01,660
თქვენ უნდა იყოს კომფორტული,
SDL დოკუმენტაცია,

35
00:02:01,660 --> 00:02:05,370
ასე რომ თქვენ შეძლებთ წასვლა გაერკვნენ
როგორ ითამაშოს აუდიო თავს.

36
00:02:05,370 --> 00:02:12,150
ასევე აშენებს Mac ან PC უნდა იმუშაოს
ზუსტად ისევე, როგორც მშენებლობის ენაზე,

37
00:02:12,150 --> 00:02:14,700
მაგრამ setup აპირებს
იქნება ცოტა განსხვავებული.

38
00:02:14,700 --> 00:02:17,700
ასე, რომ თქვენ უნდა შეეძლოს გაერკვნენ
თუ როგორ უნდა გავაკეთოთ ეს ყველაფერი

39
00:02:17,700 --> 00:02:20,900
ბოლოსთვის დღევანდელი სემინარის.

40
00:02:20,900 --> 00:02:26,980
>> ასე რომ შეიქმნა, ჩვენ ვაპირებთ
გამოიყენოთ ვირტუალური მანქანა.

41
00:02:26,980 --> 00:02:31,010
ჩვენ გვინდა, გამოიყენოთ CS50 IDE, რადგან
ჩვენ უბრალოდ უნდა წერა C.

42
00:02:31,010 --> 00:02:35,120
მაგრამ მას შემდეგ, IDE არ არის ბრაუზერის მეშვეობით, ჩვენ
არ შეუძლია შექმნას ახალი ფანჯარა ან ჩვენება

43
00:02:35,120 --> 00:02:36,410
გრაფიკული იგი.

44
00:02:36,410 --> 00:02:38,450
ამიტომ, ჩვენ უნდა ვირტუალური მანქანა.

45
00:02:38,450 --> 00:02:47,790
ასე რომ თქვენ შეგიძლიათ მიყევით ინსტრუქციას
აქ manual.CS50.net/appliance/15

46
00:02:47,790 --> 00:02:53,290
ინსტალაცია ოფიციალური CS50 ელექტრო მოწყობილობების,
რომელიც არის მხოლოდ Linux ვირტუალური

47
00:02:53,290 --> 00:02:55,110
მანქანა.

48
00:02:55,110 --> 00:02:58,090
>> და მერე კიდევ თქვენ გაქვთ
რომ ყველა მითითებული up-- ეს

49
00:02:58,090 --> 00:03:02,090
შეიძლება ცოტა ხნით, რადგან
ძალიან დიდი download-- თქვენ აპირებს

50
00:03:02,090 --> 00:03:07,060
გასაშვებად VM sudo apt-get update.

51
00:03:07,060 --> 00:03:09,410
და რომ მართლაც აპირებს
განახლება ყველა პროგრამული უზრუნველყოფა

52
00:03:09,410 --> 00:03:12,670
პაკეტი თქვენი ვირტუალური მანქანა.

53
00:03:12,670 --> 00:03:20,130
>> ამის შემდეგ, თქვენ ვაპირებთ აწარმოებს
sudo apt-get install, libsdl2-2.0-0,

54
00:03:20,130 --> 00:03:27,960
libsdl2-DBG, libsdl2-dev და
დამატებით libsdl2-image-2.0-0,

55
00:03:27,960 --> 00:03:32,560
libsdl2-image-DBG,
და libsdl2-image-dev.

56
00:03:32,560 --> 00:03:33,640
ასე რომ, რას აკეთებთ?

57
00:03:33,640 --> 00:03:38,440
ეს მხოლოდ მოყვება გამართვის
ინფორმაციის, დოკუმენტაციის, სათაურების,

58
00:03:38,440 --> 00:03:41,260
და binaries ორი ბიბლიოთეკები.

59
00:03:41,260 --> 00:03:45,090
რეგულარული ძველი, SDL 2.0,
და კიდევ ერთი ბიბლიოთეკა

60
00:03:45,090 --> 00:03:50,110
მოუწოდა SDL გამოსახულება, რომელიც
ჩვენ ვაპირებთ იყოს გამოყენებით

61
00:03:50,110 --> 00:03:54,560
ჩატვირთვა ფაილები ჩვენი თამაში.

62
00:03:54,560 --> 00:03:57,860
>> ასე რომ, კიდევ გაქვთ, რომ ასევე
რომ, უბრალოდ, როდესაც იგი ითხოვს,

63
00:03:57,860 --> 00:04:01,100
თქვენ უბრალოდ აკრიფოთ დიახ, დააჭიროთ
დააყენოთ ის პაკეტი,

64
00:04:01,100 --> 00:04:04,430
და მაშინ უნდა იყოს კარგი წავიდეთ.

65
00:04:04,430 --> 00:04:14,800
ასე რომ მიიღოს განაწილების კოდი, თქვენ
can-- OH ძვირფასო, ეს არ არის განახლება.

66
00:04:14,800 --> 00:04:18,480
თუ თქვენ გაქვთ GitHub account--
თუ თქვენ გაქვთ GitHub ანგარიში,

67
00:04:18,480 --> 00:04:24,450
თქვენ შეგიძლიათ ამის გაკეთება Git
კლონი ბრძანება რეპო

68
00:04:24,450 --> 00:04:30,490
და რომელიც ჩამოტვირთოთ Git
რეპო ყველა კოდი მასში,

69
00:04:30,490 --> 00:04:31,700
ასე, რომ თქვენ უნდა კოდი.

70
00:04:31,700 --> 00:04:36,470
>> თუ თქვენ არ გაქვთ GitHub
ანგარიში, რაც თქვენ უნდა გააკეთოთ ტიპი

71
00:04:36,470 --> 00:04:48,867
wgithttps: //github.com/tlively/sdl
სემინარი და აქ ის different--

72
00:04:48,867 --> 00:04:49,700
/archive/master.zip.

73
00:04:49,700 --> 00:04:55,610

74
00:04:55,610 --> 00:04:59,220
ასე რომ, კიდევ ერთხელ, რომ ზუსტად იგივე
URL, გარდა იქნება

75
00:04:59,220 --> 00:05:09,010
tlively / SDL_seminar / master.zip და
თქვენ იყენებთ wgit რომ ჩამოტვირთოთ.

76
00:05:09,010 --> 00:05:12,940
და მაშინ მხოლოდ
unzip რომ არქივი

77
00:05:12,940 --> 00:05:14,900
და მაშინ გვექნება
ყველა კოდის.

78
00:05:14,900 --> 00:05:17,580
ასე რომ, ბოდიში, რომ.

79
00:05:17,580 --> 00:05:23,880
და მაშინ კოდი იქნება ასევე უმასპინძლა
რომ CS50 სემინარი ვებ-გვერდზე დღეზე

80
00:05:23,880 --> 00:05:25,230
დღის განმავლობაში.

81
00:05:25,230 --> 00:05:26,590
>> კარგი.

82
00:05:26,590 --> 00:05:29,932
ასე რომ, ჩვენ უნდა დავიწყოთ
წერილობით საკუთარი თამაში?

83
00:05:29,932 --> 00:05:31,890
ისე, პირველი, რაც
ჩვენ ვაპირებთ, რომ გსურთ

84
00:05:31,890 --> 00:05:34,740
შევხედოთ SDL დოკუმენტაცია.

85
00:05:34,740 --> 00:05:37,020
ასე რომ აქ VM.

86
00:05:37,020 --> 00:05:38,720
აქ არის ვებ-გვერდზე.

87
00:05:38,720 --> 00:05:40,340
მე ნავიგაცია ცხოვრება libsdl.org.

88
00:05:40,340 --> 00:05:43,110

89
00:05:43,110 --> 00:05:48,140
რა მე ვაპირებ აქ წავიდეთ მეტი
to sidebar, ქვეშ დოკუმენტაცია,

90
00:05:48,140 --> 00:05:51,040
და დააკლიკეთ wiki.

91
00:05:51,040 --> 00:05:56,870
ეს მოუტანს ჩემთვის ვიკი, რომ
აქვს ყველაზე დოკუმენტაცია SDL.

92
00:05:56,870 --> 00:06:01,360
დასრულდა sidebar აქ, ჩვენ
ვაპირებ დააჭირეთ API კატეგორიის მიხედვით,

93
00:06:01,360 --> 00:06:04,300
იმიტომ, რომ აპირებს
ჩვენს ლამაზი კატეგორიული კალენდარი

94
00:06:04,300 --> 00:06:07,770
მთელი API for SDL.

95
00:06:07,770 --> 00:06:12,390
>> ასე მაგალითად, ჩვენ გვაქვს
ძირითადი ინიციალიზაციისას

96
00:06:12,390 --> 00:06:18,380
და დახურეს, ყველა სახის
ადმინისტრაციული პერსონალის გამოყენებით SDL,

97
00:06:18,380 --> 00:06:21,630
და მაშინ ჩვენ გვაქვს განყოფილებაში
ჩვენებისას რამ ეკრანზე.

98
00:06:21,630 --> 00:06:23,000
ეს არის ვიდეო.

99
00:06:23,000 --> 00:06:25,790
შეყვანის მოვლენები, რომ მიღების
შეიტანენ კლავიატურაზე,

100
00:06:25,790 --> 00:06:29,710
მიღების შეიტანენ მაუსის და
ჯოისტიკი, თუ თქვენ გაქვთ ეს კი.

101
00:06:29,710 --> 00:06:32,901
არსებობს ძალის კავშირი რამ
მსგავსი თამაში კონტროლერები, რომელიც

102
00:06:32,901 --> 00:06:34,150
ჩვენ არ ვაპირებთ ვისაუბროთ.

103
00:06:34,150 --> 00:06:35,630
აქ არის აუდიო.

104
00:06:35,630 --> 00:06:38,940
და მაშინ იქ რამოდენიმე სხვა
პერსონალი, რომ SDL შეუძლია თქვენთვის.

105
00:06:38,940 --> 00:06:43,830
>> მაგრამ დღეს ჩვენ ვაპირებთ ფოკუსირება
on ინიციალიზაციისას აქ,

106
00:06:43,830 --> 00:06:48,332
ჩვენებისას გამოსახულებები, ვიდეო
სექცია, და გატარება შეყვანის მოვლენები.

107
00:06:48,332 --> 00:06:50,290
ასე რომ, ეს არის ის ძირითადი
მონაკვეთზე დოკუმენტაცია

108
00:06:50,290 --> 00:06:53,050
რომ თქვენ უნდა შემაშფოთებელია შესახებ.

109
00:06:53,050 --> 00:06:57,170
Just for fun, თუ ჩვენ მეტი
აქ და დააჭირეთ API სახელი,

110
00:06:57,170 --> 00:07:04,350
ჩვენ ვხედავთ ჩამონათვალი ყველა
ერთი რამ SDL ბიბლიოთეკა.

111
00:07:04,350 --> 00:07:11,330
ასე რომ, ყველა ამ ფუნქციების Enumerations,
სტრუქტურები, გიჟები თანხის პერსონალი,

112
00:07:11,330 --> 00:07:12,820
ანბანური თანმიმდევრობა.

113
00:07:12,820 --> 00:07:14,580
და ნათლად, სანამ
თქვენ იცით, თუ რას აკეთებს,

114
00:07:14,580 --> 00:07:19,100
ეს არ იქნება ძალიან სასარგებლო,
სწორედ ამიტომ ჩვენ ამის API კატეგორიის მიხედვით.

115
00:07:19,100 --> 00:07:20,810
>> მოდით დავიწყოთ.

116
00:07:20,810 --> 00:07:25,680
იმედია თქვენ უკვე
გადმოწერილი განაწილების კოდი.

117
00:07:25,680 --> 00:07:30,070
ასე რომ, რა შეგიძლიათ გააკეთოთ, უფლება
აქ CS50 ელექტრო მოწყობილობების,

118
00:07:30,070 --> 00:07:31,150
უბრალოდ გახსენით ტერმინალი.

119
00:07:31,150 --> 00:07:33,750

120
00:07:33,750 --> 00:07:34,440
აქ ჩვენ მივდივართ.

121
00:07:34,440 --> 00:07:40,740
ასე რომ, მე უკვე გადმოწერილი
განაწილების კოდი გამოყენებით .zip

122
00:07:40,740 --> 00:07:41,690
მეთოდი.

123
00:07:41,690 --> 00:07:43,140
და მე unzipped იგი.

124
00:07:43,140 --> 00:07:46,120
ასე რომ, აქ არის SDL სემინარი ოსტატი.

125
00:07:46,120 --> 00:07:49,750
ამიტომ, მე ვაპირებ წასვლას, რომ დირექტორია.

126
00:07:49,750 --> 00:07:55,310
რასაც ვხედავთ აქ არის
რომ ჩვენ გვაქვს შვიდი C ფაილი.

127
00:07:55,310 --> 00:07:58,070
და ეს ხდება იმ კოდი
ჩვენ ვაპირებთ, რომ ეძებს დღეს.

128
00:07:58,070 --> 00:08:00,040
ჩვენ გვყავს makefile.

129
00:08:00,040 --> 00:08:06,950
და ჩვენ გვაქვს რესურსების კატალოგი,
რომელიც უბრალოდ იმიჯი

130
00:08:06,950 --> 00:08:09,070
რომ თქვენ უნდა ხედავს მალე საკმარისი.

131
00:08:09,070 --> 00:08:16,060
>> ასე რომ, მოდით გახსენით ეს ფაილი
გამოყენებით G-რედაქტირება რედაქტორი.

132
00:08:16,060 --> 00:08:22,000
ასე რომ, მინდა გახსნა ყველა ფაილი, რომელიც
დასაწყისისთვის მიესალმები და მთავრდება გ.

133
00:08:22,000 --> 00:08:23,380
აქ ჩვენ მივდივართ.

134
00:08:23,380 --> 00:08:28,180
ასე რომ, პატარა ფანჯარაში, ასე რომ, ჩვენ
ვაპირებ ცდილობენ, რათა, რომ დიდია.

135
00:08:28,180 --> 00:08:28,900
არა, ეს არ წავიდა.

136
00:08:28,900 --> 00:08:32,836

137
00:08:32,836 --> 00:08:34,570
>> კარგი.

138
00:08:34,570 --> 00:08:37,959
ასე რომ აქ პირველი
ფაილი ჩვენ ვაპირებთ შევხედოთ.

139
00:08:37,959 --> 00:08:39,000
ეს ე.წ. hello1_sdl.c.

140
00:08:39,000 --> 00:08:41,890

141
00:08:41,890 --> 00:08:47,980
და ეს ყველაფერი არ არის, რომ ვრთავ SDL
ბიბლიოთეკაში ისე, რომ ჩვენ შეგვიძლია დავიწყოთ გამოყენებით იგი.

142
00:08:47,980 --> 00:08:51,550
რა ვიცი, მოვა
ერთად ეს კოდი საკუთარ თავს?

143
00:08:51,550 --> 00:08:53,850
ისე, თუ ჩვენ გამოიყურებოდეს მეტი
დოკუმენტაცია

144
00:08:53,850 --> 00:08:58,040
და ჩვენ წასვლას ინიციალიზაციისას
და დახურეს განყოფილებიანი,

145
00:08:58,040 --> 00:09:02,230
ის აპირებს გვითხრათ ყველა
იმაზე, თუ როგორ უნდა ინიციალიზაცია SDL.

146
00:09:02,230 --> 00:09:06,630
ასე რომ, ნამდვილად წაიკითხა ეს სხვა დროს.

147
00:09:06,630 --> 00:09:09,230
ის აპირებს გითხრათ ყველა
შესახებ, თუ რა ხდება აქ.

148
00:09:09,230 --> 00:09:14,360
მაგრამ მთავარი არსი იმაში მდგომარეობს, რომ
ჩვენ უნდა მოვუწოდებთ ამ ფუნქციის SDL In It

149
00:09:14,360 --> 00:09:18,910
და გაიაროს ეს რა სახის ნივთები
ჩვენ გვინდა ბიბლიოთეკა ვრთავ.

150
00:09:18,910 --> 00:09:23,620
ასე რომ, ჩვენს შემთხვევაში, ჩვენ უბრალოდ აპირებს
ვრთავ ვიდეო ახლა,

151
00:09:23,620 --> 00:09:26,690
ასე რომ ჩვენ შეგვიძლია დავიწყოთ ჩვენებისას გამოსახულებები.

152
00:09:26,690 --> 00:09:32,370
>> აქ, თქვენ ხედავთ, თუ
ჩვენ დააწკაპუნეთ SDL ეს, ჩვენ

153
00:09:32,370 --> 00:09:36,160
შეგიძლიათ მიიღოთ უფრო მეტი ინფორმაცია,
მათ შორის დაბრუნებული მნიშვნელობა.

154
00:09:36,160 --> 00:09:39,050
ასე რომ, ჩვენ ვხედავთ, რომ აქ ეს
returnes ნულის წარმატება.

155
00:09:39,050 --> 00:09:43,320
ასე რომ, ჩვენი კოდი, ჩვენ ვაპირებთ
თუ ეს არ დაბრუნდება ნულოვანი,

156
00:09:43,320 --> 00:09:47,020
და თუ ის არ დაბრუნდება
ნულოვანი, ასე რომ არ იყო წარმატებული,

157
00:09:47,020 --> 00:09:50,650
მაშინ ჩვენ ვაპირებთ, უბრალოდ ბეჭდვითი
შეცდომა გამოყენებისას სხვა ფუნქცია,

158
00:09:50,650 --> 00:09:56,260
SDL მისაღებად შეცდომა, რომელიც დააბრუნებს string
აღწერს შეცდომა, რომ მოხდა.

159
00:09:56,260 --> 00:09:58,510
ჩვენ ვაპირებთ, რომ ბეჭდვა, რომ
შეცდომა და შემდეგ ჩვენ უბრალოდ

160
00:09:58,510 --> 00:10:02,270
აპირებს გაითიშება პროგრამა
ერთად შეცდომის კოდი.

161
00:10:02,270 --> 00:10:06,470
>> შემდეგ კიდევ ერთი რამ, რომ ჩვენ უნდა
არ არის, სანამ პროგრამა გასასვლელი,

162
00:10:06,470 --> 00:10:10,830
თუ ჩვენ წარმატებით ინიციალიზაცია SDL,
ჩვენ უბრალოდ უნდა ეძახით SDL დატოვა.

163
00:10:10,830 --> 00:10:15,750
და რომ აპირებს გაუმკლავდეს დასუფთავების
ყველა SDL შიდა რესურსების ჩვენთვის.

164
00:10:15,750 --> 00:10:21,240
ასე რომ, დოკუმენტაცია იქ, კიდევ ერთხელ,
ჩვენ აქ ვართ ინიციალიზაციისას

165
00:10:21,240 --> 00:10:23,640
და დახურეს განყოფილებაში
დოკუმენტაცია.

166
00:10:23,640 --> 00:10:26,680
თქვენ არ შეგიძლიათ უბრალოდ დააჭირეთ
ფუნქცია აქ, SDL დატოვა,

167
00:10:26,680 --> 00:10:28,700
და თქვენ შეგიძლიათ წაიკითხოთ ყველაფერი, რომ ისევე.

168
00:10:28,700 --> 00:10:31,400
და ბევრი ამ ფუნქციის
დოკუმენტაცია გვერდები

169
00:10:31,400 --> 00:10:35,630
აქვს მაგალითად კოდი, ასე რომ ეს
არის ძალიან კარგი რესურსი.

170
00:10:35,630 --> 00:10:39,610
აუცილებლად გარკვეული დრო გაატაროს
კითხულობს ნაწილები ამ ვიკი

171
00:10:39,610 --> 00:10:42,520
თუ ვაპირებთ გავაკეთოთ
ეს პროექტი.

172
00:10:42,520 --> 00:10:43,760
>> კარგი.

173
00:10:43,760 --> 00:10:46,590
ასე რომ, მთელი ჩვენი პროგრამა.

174
00:10:46,590 --> 00:10:53,935
რა შეგვიძლია გავაკეთოთ ახლა is-- ვარ
ვაპირებ გახსნა makefile აქ,

175
00:10:53,935 --> 00:10:56,150
ამიტომ მე ვაპირებ მიიღოს
შეხედეთ, როგორ მუშაობს.

176
00:10:56,150 --> 00:10:59,500
და ეს არის ძალიან მარტივი makefile,
მსგავსი, თუ რა ვნახე ადრე.

177
00:10:59,500 --> 00:11:04,010
ერთ-ერთი ძირითადი განსხვავებები
ის არის, რომ აქ, ამ

178
00:11:04,010 --> 00:11:07,870
აპირებს ჩადეთ შედეგი გაშვებული
ეს ბრძანება, რომელიც თქვენ უკვე

179
00:11:07,870 --> 00:11:10,850
დამონტაჟებულია თუ თქვენ დაყენებული SDL.

180
00:11:10,850 --> 00:11:13,230
და ეს არის ბრძანება
რომ აპირებს გენერირება

181
00:11:13,230 --> 00:11:16,710
ზოგიერთი დამატებითი დროშები შემდგენელი.

182
00:11:16,710 --> 00:11:22,050
>> გარდა ამისა, ჩვენ ვაძლევთ მას
ყველა ჩვეულებრივი ბრძანებები, ისევე როგორც

183
00:11:22,050 --> 00:11:23,430
ამ ორი ბრძანებები.

184
00:11:23,430 --> 00:11:30,270
ასე რომ, -lsdl2 სურათი სახელურები
აკავშირებს ამ SDL იმიჯი ბიბლიოთეკა.

185
00:11:30,270 --> 00:11:36,200
და -lm რეალურად ემსახურება აკავშირებს
სტანდარტული C მათემატიკის ბიბლიოთეკაში.

186
00:11:36,200 --> 00:11:40,630
ასე რომ, ჩვენ არ ვაპირებთ უნდა
იმ ყველა ჩვენი C ფაილი,

187
00:11:40,630 --> 00:11:43,900
მაგრამ ჩვენ უბრალოდ დააყენა მათ ისე, რომ ჩვენ შეგვიძლია
გამოიყენოთ იგივე makefile ყველაფერი

188
00:11:43,900 --> 00:11:44,816
გარეშე ცვლილებები.

189
00:11:44,816 --> 00:11:46,970

190
00:11:46,970 --> 00:11:50,080
>> მეტი აქ წყაროები,
ეს არის სადაც თქვენ მინდა

191
00:11:50,080 --> 00:11:53,680
იმისათვის, რომ ფაილი, რომ თქვენ აპირებს
შეადგინონ თქვენი პროექტი.

192
00:11:53,680 --> 00:11:57,570
მაგრამ მას შემდეგ, რაც ყველა ერთი ჩემი C
ფაილი აქ მთავარი ფუნქცია,

193
00:11:57,570 --> 00:12:00,000
ის აპირებს დაბნეული
თუ ჩვენ მათ ყველა.

194
00:12:00,000 --> 00:12:06,930
ამიტომ, მე ვაპირებ, უბრალოდ, ვამბობთ,
ახლა, hello1_sdl.c,

195
00:12:06,930 --> 00:12:11,150
რომელიც ერთი ჩვენ უბრალოდ შევხედე.

196
00:12:11,150 --> 00:12:18,740
ასე რომ, თუ მე დავუბრუნდეთ მეტი
აქ, მე არ მიიღოს.

197
00:12:18,740 --> 00:12:22,160
და რომ ის, რაც არის, ეს მხოლოდ
შედგენილი, რომ პირველი ფაილი.

198
00:12:22,160 --> 00:12:28,780
და მაშინ ჩვენ შეგვიძლია აკრიფოთ ./game, რადგან
ეს შემსრულებელი წარმოებული.

199
00:12:28,780 --> 00:12:31,660
და ყველა ეს მოხდა იყო ბეჭდვითი
ინიციალიზაციისას წარმატებული.

200
00:12:31,660 --> 00:12:33,300
ასე რომ, ჩვენ გავაკეთეთ რაღაც უფლება.

201
00:12:33,300 --> 00:12:36,200
მაგრამ ეს იყო ერთგვარი მოსაწყენი,
იმიტომ, რომ ჩვენ არ ვხედავთ, ფანჯარა,

202
00:12:36,200 --> 00:12:37,900
არაფერი არ მოძრაობდნენ.

203
00:12:37,900 --> 00:12:41,030
>> ასე რომ, დიდი, მივიღეთ SDL ინიციალიზაცია.

204
00:12:41,030 --> 00:12:43,520
ახლა, მოდით გადაადგილება, რათა რაღაც
ცოტა უფრო საინტერესო.

205
00:12:43,520 --> 00:12:54,700
ასე რომ აქ გვაქვს hello2_window.c და
ეს იქნება ოდნავ მეტი

206
00:12:54,700 --> 00:13:00,010
კომპლექსი C პროგრამა, რომელიც
ველში SDL ისევე, როგორც ადრე,

207
00:13:00,010 --> 00:13:04,250
გარდა ახლა ჩვენ ასევე ვაპირებთ
ინიციალიზაცია SDL ტაიმერი.

208
00:13:04,250 --> 00:13:07,720
და ეს ხდება მოდით
ხელმისაწვდომობის შიდა ტაიმერი

209
00:13:07,720 --> 00:13:10,550
და გამოყენების ფუნქცია, რომელიც ეხება დროს.

210
00:13:10,550 --> 00:13:11,920
>> და მაშინ მოდით შევხედოთ ქვემოთ აქ.

211
00:13:11,920 --> 00:13:16,840
რას ვაკეთებთ ჩვენ ეს მაჩვენებელი
რომ SDL window struct, რომელიც

212
00:13:16,840 --> 00:13:21,160
იქნება შექმნილ დარეკეთ
ფუნქცია, SDL შექმნა ფანჯარა.

213
00:13:21,160 --> 00:13:25,380
ახლა, ეს იღებს ბევრი არგუმენტები,
ასე რომ, მოდით შევხედოთ დოკუმენტაცია.

214
00:13:25,380 --> 00:13:27,930
ასე რომ კიდევ ერთხელ, მე ვაპირებ
API კატეგორიის მიხედვით, მე

215
00:13:27,930 --> 00:13:33,820
აპირებს ქვემოთ ვიდეო აქ, და პირველი
განყოფილებიანი, ჩვენებისას window მართვა.

216
00:13:33,820 --> 00:13:36,470
ასე რომ, ეს სექცია
ტონა პერსონალი,

217
00:13:36,470 --> 00:13:39,970
მაგრამ თუ გადავხედავთ
ეს ფუნქციები, თქვენ

218
00:13:39,970 --> 00:13:43,620
ვხედავ, რომ, ალბათ, ერთი ჩვენ
გსურთ ეწოდება SDL შექმნა ფანჯარა,

219
00:13:43,620 --> 00:13:46,600
რაც ხდება, რომ მარჯვენა ზედა.

220
00:13:46,600 --> 00:13:49,080
>> ასე რომ, ეს არის
დოკუმენტაცია ამ ფუნქციას.

221
00:13:49,080 --> 00:13:53,710
ფანჯარა აპირებს სათაური,
x და y პოზიცია ეკრანზე,

222
00:13:53,710 --> 00:13:56,960
ის აპირებს აქვს სიგანე, სიმაღლე,
და მაშინ ის აპირებს ზოგიერთი დროშებით.

223
00:13:56,960 --> 00:14:01,220
ახლა, ჩვენ რეალურად არ აინტერესებს
რომელიმე ამ დროშები ახლა,

224
00:14:01,220 --> 00:14:04,560
მაგრამ თუ მინდოდა, რომ რამე
მოსწონს სრულ ეკრანზე ფანჯარა,

225
00:14:04,560 --> 00:14:07,920
თქვენ შეიძლება შევხედოთ, რომ.

226
00:14:07,920 --> 00:14:13,190
ახლა, ჩვენ უბრალოდ აპირებს
გამოიყენოს ეს განსაკუთრებული ღირებულებები,

227
00:14:13,190 --> 00:14:18,775
SDL window პლუს ორიენტირებული
x და y, რათა

228
00:14:18,775 --> 00:14:21,800
უბრალოდ შექმნათ window
ცენტრში ჩვენი ეკრანზე.

229
00:14:21,800 --> 00:14:24,370
>> ასე რომ, რა რომ აკეთებს.

230
00:14:24,370 --> 00:14:27,960
და თუ ფანჯრის ხდება,
null, რაც იმას ნიშნავს, არ არის შეცდომა,

231
00:14:27,960 --> 00:14:32,570
მერე ისევ ჩვენ უბრალოდ აპირებს
ბეჭდვა შეცდომა გამოყენებით SDL მისაღებად შეცდომა.

232
00:14:32,570 --> 00:14:36,570
და მერე იმიტომ, რომ ჩვენ ინიციალიზაცია
SDL, ჩვენ ახლა უნდა დახუროს იგი.

233
00:14:36,570 --> 00:14:40,900
ამიტომ, ჩვენ მოვუწოდებთ SDL დატოვა ადრე
დაბრუნების ერთ-ერთი ძირითადი.

234
00:14:40,900 --> 00:14:42,905
>> ასე რომ, ჩვენ ამ ფანჯარაში გახსნა იმედია.

235
00:14:42,905 --> 00:14:44,613
და რასაც ჩვენ ვაპირებთ
რომ არის ჩვენ ვაპირებთ

236
00:14:44,613 --> 00:14:50,340
მოვუწოდებთ SDL 5000 მილიწამებში,
რომელიც არის იგივე, რაც ხუთ წამში.

237
00:14:50,340 --> 00:14:55,640
და როდესაც ჩვენ გავაკეთეთ, რომ,
ის აპირებს გაანადგუროს ფანჯარა,

238
00:14:55,640 --> 00:14:59,470
გაწმენდა SDL ბიბლიოთეკა,
და გასვლა პროგრამა.

239
00:14:59,470 --> 00:15:05,240
მოდით წავიდეთ წინ და მისცეს, რომ გასროლა.

240
00:15:05,240 --> 00:15:08,660
>> ასე რომ, ახლა ნაცვლად შეცვლის
makefile ყოველ ჯერზე,

241
00:15:08,660 --> 00:15:12,180
შემიძლია უბრალოდ არ მიიღოს და
მაშინ ბრძანების,

242
00:15:12,180 --> 00:15:16,090
აცხადებენ წყაროების უტოლდება და შემდეგ
ფაილი ჩვენ შედგენა.

243
00:15:16,090 --> 00:15:17,090
ასე რომ, ეს hello2_window.c.

244
00:15:17,090 --> 00:15:21,390

245
00:15:21,390 --> 00:15:21,890
Fantastic.

246
00:15:21,890 --> 00:15:22,970
არარის Erros.

247
00:15:22,970 --> 00:15:26,085
ახლა, თუ ჩვენ აწარმოებს ჩვენი შესრულებადი,
ჩვენ ვხედავთ, ეს ფანჯარა.

248
00:15:26,085 --> 00:15:27,960
ახლა არსებობს რამდენიმე
პრობლემა ფანჯარა.

249
00:15:27,960 --> 00:15:32,820
ჩვენ შეგვიძლია გადატანა გარშემო, მაგრამ მას აქვს
ამ ფონზე უსარგებლო შიგნით მას.

250
00:15:32,820 --> 00:15:34,660
ასე რომ, ჩვენ არ დგება
არაფერი, და ამიტომ

251
00:15:34,660 --> 00:15:38,210
მხოლოდ სავსე ნაგვის, რომელიც
არის საკმაოდ ბევრი, რასაც ჩვენ ველით.

252
00:15:38,210 --> 00:15:41,010
>> გარდა ამისა, ჩვენ ვერ დახურეთ ფანჯარა.

253
00:15:41,010 --> 00:15:44,780
მე დაჭერით ეს X წელს
კუთხეში და არაფერი ხდება.

254
00:15:44,780 --> 00:15:47,840
ასე რომ, ჩვენ დავინახავთ, თუ როგორ უნდა დააფიქსიროს
რომ ცოტა.

255
00:15:47,840 --> 00:15:51,750
მოდით დაფიქსირება ნაწილი, სადაც
ფანჯარა დანაგვიანებული პირველი.

256
00:15:51,750 --> 00:16:00,850
ასე რომ, თუ ჩვენ მეტი hello3_image.c, რა
ჩვენ ვხედავთ, რომ ჩვენ დასძინა რამდენიმე

257
00:16:00,850 --> 00:16:03,360
უფრო მეტი რამ აქ.

258
00:16:03,360 --> 00:16:08,740
ჩვენ დასძინა ახალი header
ფაილის მისაღებად ტაიმერი ფუნქციები.

259
00:16:08,740 --> 00:16:11,490
ვფიქრობ, ჩვენ გავაკეთეთ, რომ ბოლო
ერთ-ერთი, ძალიან, და მე არ უხსენებია ის.

260
00:16:11,490 --> 00:16:13,550
მაგრამ ახლა, რადგან ჩვენ
სამუშაო სურათებით,

261
00:16:13,550 --> 00:16:18,720
ჩვენ უნდა შეიცავდეს SDL
სურათი header ფაილი ისევე.

262
00:16:18,720 --> 00:16:22,087
ასე რომ, ეს არის იგივე როგორც
ადრე, ინიციალიზაციისას SDL აქ,

263
00:16:22,087 --> 00:16:23,420
იგივე გარიგება ქმნის ფანჯრები.

264
00:16:23,420 --> 00:16:25,380
ჩვენ ვნახეთ, რომ აქამდე.

265
00:16:25,380 --> 00:16:29,870
>> ახლა ჩვენ უნდა შევქმნათ რაღაც მოუწოდა
renderer, რომელიც ერთგვარი გადის

266
00:16:29,870 --> 00:16:30,800
ფანჯრის.

267
00:16:30,800 --> 00:16:33,860
მაგრამ ეს ერთგვარი
აბსტრაქტული ობიექტი, რომელიც არის

268
00:16:33,860 --> 00:16:37,370
პასუხისმგებელი აკეთებს ყველა ამ
ნახაზი ოპერაციების ფანჯარა.

269
00:16:37,370 --> 00:16:41,580
და ეს რეალურად შეესაბამება
პროგრამა დატვირთული

270
00:16:41,580 --> 00:16:47,880
შევიდა გრაფიკული ტექნიკის თქვენს
კომპიუტერული და ტელეფონის ან რასაც.

271
00:16:47,880 --> 00:16:51,005
ასე რომ, დროშების ჩვენ გვინდა გავლა it--
და თქვენ შეგიძლიათ შევხედოთ დოკუმენტაცია

272
00:16:51,005 --> 00:16:56,160
მისაღებად უფრო დეტალურად აქ ვაპირებთ
უნდა SDL გაწევა დააჩქარა, რომელიც

273
00:16:56,160 --> 00:16:58,550
ნიშნავს, რომ ის იქნება
გამოყენებით გრაფიკული ტექნიკის

274
00:16:58,550 --> 00:17:01,490
და არა მხოლოდ მიბაძონ პროგრამული უზრუნველყოფა.

275
00:17:01,490 --> 00:17:07,390
>> და ჩვენ ვაპირებთ გამოვიყენოთ
SDL Renderer PRESENTVSYNC.

276
00:17:07,390 --> 00:17:12,280
Vsync არის ის, რომ უბრალოდ ხდის
თქვენი გრაფიკა გამოიყურებოდეს უკეთესად და ხელს უშლის

277
00:17:12,280 --> 00:17:14,970
ეს რამ მოუწოდა ეკრანზე
ტერორი, სადაც ნახევარი

278
00:17:14,970 --> 00:17:17,720
ერთ-ერთი ჩარჩო და ნახევარი შემდეგი
ჩარჩო იზიდავს და ამავე დროს

279
00:17:17,720 --> 00:17:20,056
და ეს გამოიყურება საშინელი.

280
00:17:20,056 --> 00:17:23,130
მაგრამ ერთხელ, შეგიძლიათ წაიკითხოთ
იმის შესახებ, რომ თქვენი საკუთარი.

281
00:17:23,130 --> 00:17:24,319
>> ასე რომ, ჩვენ გვაქვს გარკვეული დროშები აქ.

282
00:17:24,319 --> 00:17:27,810
ასე რომ, ჩვენ უბრალოდ ვაპირებ მოვუწოდო
ამ ფუნქციის SDL შექმნა renderer.

283
00:17:27,810 --> 00:17:31,340
ჩვენ ვაპირებთ, რათა ეს window
გაერთიანდნენ, რომ renderer.

284
00:17:31,340 --> 00:17:34,520
უარყოფითი ნიშნავს, რომ ჩვენ არ მაინტერესებს, რა
გრაფიკული მძღოლი ჩვენ ვაპირებთ გამოვიყენოთ.

285
00:17:34,520 --> 00:17:36,603
ასე რომ, უნდა საკმაოდ ბევრი
ყოველთვის იქნება უარყოფითი,

286
00:17:36,603 --> 00:17:39,010
თუ თქვენ არ იცით, თუ გრაფიკული მძღოლები.

287
00:17:39,010 --> 00:17:41,650
და მაშინ ჩვენ უბრალოდ აპირებს
უნდა გაიაროს ეს ჩვენი დროშები.

288
00:17:41,650 --> 00:17:47,240
ასე რომ, თუ ბრუნდება null, მაშინ ჩვენ
აპირებს ბეჭდვა შეცდომა, როგორც ყოველთვის,

289
00:17:47,240 --> 00:17:49,550
მაგრამ მაშინ ჩვენ ასევე ვაპირებთ
განადგურება window

290
00:17:49,550 --> 00:17:54,970
გაწმენდა იმ რესურსებს ადრე
მოუწოდებს SDL დატოვა და ბრუნდებიან.

291
00:17:54,970 --> 00:17:58,110
>> ახლა, საინტერესო ნაწილი აქ
არის, სადაც ჩვენ გადაწეროთ ჩვენი სურათი

292
00:17:58,110 --> 00:18:00,870
გამოყენებით ამ ფუნქციას IMG_load.

293
00:18:00,870 --> 00:18:04,050
ეს არის ერთადერთი ფუნქცია ჩვენ ვაპირებთ
გამოიყენოთ საწყისი SDL იმიჯი ბიბლიოთეკა.

294
00:18:04,050 --> 00:18:05,480
ეს არის მხოლოდ ერთი გვჭირდება.

295
00:18:05,480 --> 00:18:12,950
ეს არის ფუნქცია, რომელიც იღებს სიმებიანი
რომ არის გზა, ნებისმიერი გამოსახულების რესურსი.

296
00:18:12,950 --> 00:18:18,024
და ეს შეიძლება იყოს .png, GIF,
bitmap, ნებისმიერი რამ.

297
00:18:18,024 --> 00:18:19,690
ამიტომაც არის, რომ ეს ფუნქცია იმდენად ლამაზი.

298
00:18:19,690 --> 00:18:22,560
მას შეუძლია საკმაოდ ბევრი ნებისმიერ ფორმატში.

299
00:18:22,560 --> 00:18:27,240
იტვირთება მეხსიერებაში და ინახავს მას
როგორც რამ მოუწოდა SDL ზედაპირზე.

300
00:18:27,240 --> 00:18:34,660
>> ახლა SDL ზედაპირზე მხოლოდ struct
რომელიც წარმოადგენს იმიჯი მონაცემების მეხსიერებაში.

301
00:18:34,660 --> 00:18:38,054
ასე, რომ თქვენ შეგიძლიათ დაწვრილებით
რომ დოკუმენტაცია ორი.

302
00:18:38,054 --> 00:18:40,720
და თუ ეს შეცდომები, მაშინ ჩვენ
აპირებს მთელი რამ, სადაც

303
00:18:40,720 --> 00:18:44,480
ჩვენ ბეჭდვა შეცდომა, დავხუჭავთ
რესურსები, და შემდეგ დატოვა პროგრამა.

304
00:18:44,480 --> 00:18:48,970
ახლა საინტერესო ის არის, სანამ
შეგვიძლია ეს სურათი ფანჯარა,

305
00:18:48,970 --> 00:18:51,390
ჩვენ უნდა რეალურად, რათა ის ტექსტურა.

306
00:18:51,390 --> 00:18:54,460
ახლა ტექსტურა შეესაბამება
გამოსახულების მონაცემების დატვირთული

307
00:18:54,460 --> 00:18:57,820
შევიდა გრაფიკული ტექნიკის მეხსიერებაში.

308
00:18:57,820 --> 00:19:00,720
>> ასე რომ, ზედაპირზე არის მთავარი
მეხსიერება, რეგულარული მეხსიერება

309
00:19:00,720 --> 00:19:05,550
რომ ჩვენ უკვე გამოყენებით ყველა სემესტრში,
და ფაქტურის ამ ცალკე VRAM

310
00:19:05,550 --> 00:19:09,410
მეხსიერება, რომელიც კარტა კონტროლი.

311
00:19:09,410 --> 00:19:13,170
ასე რომ, ჩვენ მოვუწოდებთ ამ ფუნქციის
SDL_CreateTextureFromSurface.

312
00:19:13,170 --> 00:19:17,104
ჩვენ გაძლევთ, რომ ეს ჩვენი renderer და ჩვენი ზედაპირზე.

313
00:19:17,104 --> 00:19:19,020
და მაშინ ჩვენ, ფაქტობრივად,
კეთდება ზედაპირზე,

314
00:19:19,020 --> 00:19:20,311
ასე რომ, ჩვენ უბრალოდ აპირებს გასათავისუფლებლად იგი.

315
00:19:20,311 --> 00:19:22,210
ჩვენ არ გვჭირდება, რომ აღარ.

316
00:19:22,210 --> 00:19:26,650
და მაშინ ასე რომ, თუ ეს მოწოდება
errored და დაბრუნდა null,

317
00:19:26,650 --> 00:19:29,630
მაშინ ჩვენ ვაპირებთ, რომ მთელი
შეცდომა ანგარიშგების რამ ერთხელ.

318
00:19:29,630 --> 00:19:30,920
>> კარგი.

319
00:19:30,920 --> 00:19:34,810
აქ, ჩვენ მოხვდება
ფაქტობრივი გაწევის ფუნქციები.

320
00:19:34,810 --> 00:19:37,730
ასე მოუწოდებდა SDL_RenderClear
გადააწოდა

321
00:19:37,730 --> 00:19:42,550
renderer უკავშირდება ჩვენს window
უბრალოდ ხდის window წასვლა შავი.

322
00:19:42,550 --> 00:19:47,650
ასე რომ, ეს ხსნის, რომ უსარგებლო, რომ ჩვენ ვნახეთ
ჩვენი ფანჯარაში და ხდის შავი.

323
00:19:47,650 --> 00:19:50,750
და მაშინ ჩვენ ვაპირებთ
მოვუწოდებთ SDL_RenderCopy,

324
00:19:50,750 --> 00:19:53,010
მისთვის ჩვენი renderer, ჩვენი ტექსტურა.

325
00:19:53,010 --> 00:19:55,800
და ჩვენ ვსაუბრობთ იმაზე, თუ რა
ამ სფეროში არიან ცოტა.

326
00:19:55,800 --> 00:19:57,830
მაგრამ, რომ აპირებს
მიიღოს ტექსტურა მონაცემები

327
00:19:57,830 --> 00:20:03,100
და კოპირება გადატანა ჩვენი
window მიაპყროს იმიჯი.

328
00:20:03,100 --> 00:20:07,020
ასე რომ, მას შემდეგ, რაც ჩვენ გავაკეთეთ ეს ასლი
მონაცემების გადატანა ჩვენი ფანჯარა,

329
00:20:07,020 --> 00:20:11,180
ჩვენ უნდა გავაკეთოთ ამ დამატებითი ფუნქცია
მოუწოდა SDL_RenderPresent.

330
00:20:11,180 --> 00:20:15,360
>> ეს საინტერესოა
იმიტომ, რომ ეს იღებს

331
00:20:15,360 --> 00:20:18,770
შევიდა თემაზე ეწოდება ორმაგი buffering.

332
00:20:18,770 --> 00:20:24,380
ასე რომ, ორმაგი buffering არის ტექნიკა, რომელიც
რაც თქვენი გრაფიკა გამოიყურებოდეს ბევრი უკეთესი.

333
00:20:24,380 --> 00:20:28,240
ისევ და ისევ, ეს ხელს უშლის, რომ ეკრანზე tearing
მე ლაპარაკი ადრე, სადაც

334
00:20:28,240 --> 00:20:29,590
თქვენ გაქვთ ორი ბუფერი.

335
00:20:29,590 --> 00:20:32,260
აქ არის უკან ბუფერულ
მეხსიერება და წინა ბუფერული.

336
00:20:32,260 --> 00:20:36,410
წინა ბუფერი ფაქტიურად
რა არის თქვენს ეკრანზე მომენტში.

337
00:20:36,410 --> 00:20:42,070
ასე რომ, ჩვენ ყველა ამ მიაპყროს ვარიაციები,
ისევე როგორც SDL გაწევა ასლი ან SDL_RenderClear

338
00:20:42,070 --> 00:20:43,080
უკან ბუფერული.

339
00:20:43,080 --> 00:20:44,800
ასე რომ, ისინი ცვლილებები რამ
წელს დაბრუნდა ბუფერულ.

340
00:20:44,800 --> 00:20:48,970
აქ ჩვენ შეიძლება ხატვის ეს
მწვანე მოედანზე უკან ბუფერული.

341
00:20:48,970 --> 00:20:52,300
>> ასე რომ, მაშინ, როდესაც ჩვენ გავაკეთეთ აკეთებს
ჩვენი გაწევა ოპერაციები, რომელიც

342
00:20:52,300 --> 00:20:55,700
შესაძლოა, მართლაც დიდი
დროს, რასაც ჩვენ ვაპირებთ, რომ

343
00:20:55,700 --> 00:20:57,860
გადართოთ ბუფერი.

344
00:20:57,860 --> 00:21:00,720
ასე რომ, ეს ფაქტიურად იღებს
წინა ბუფერული და უკან ბუფერული

345
00:21:00,720 --> 00:21:02,990
და კონცენტრატორები მათ, ასე რომ,
რომ მომენტალურად,

346
00:21:02,990 --> 00:21:06,630
ერთ ოპერაციას, ნაცვლად
შესაძლოა, ასობით და ათასობით,

347
00:21:06,630 --> 00:21:10,910
ყველა ჩვენი ახლად გაწეული
ობიექტების ეკრანზე.

348
00:21:10,910 --> 00:21:13,160
და ეს ხელს უშლის რამ
როგორც ეკრანზე გამაგრილებელი

349
00:21:13,160 --> 00:21:16,710
როდესაც ჩვენ მხოლოდ შედგენილი ნახევარი
ჩვენი ობიექტების ფარგლებში.

350
00:21:16,710 --> 00:21:21,280
ასე რომ, რატომ უნდა დაუკავშირდეთ
SDL_RenderPresent, ასევე

351
00:21:21,280 --> 00:21:23,320
როგორც SDL_RenderCopy.

352
00:21:23,320 --> 00:21:25,749
>> ისევ და ისევ, ჩვენ უბრალოდ აპირებს
დაველოდოთ ხუთ წამში.

353
00:21:25,749 --> 00:21:27,540
მაშინ ჩვენ ვაპირებთ
გაწმენდა ჩვენი რესურსები.

354
00:21:27,540 --> 00:21:29,540
ჩვენ გვაქვს საკმაოდ მეტი ამ დროს.

355
00:21:29,540 --> 00:21:31,750
და მაშინ ჩვენ უბრალოდ აპირებს
გასასვლელად პროგრამა.

356
00:21:31,750 --> 00:21:35,350
ასე რომ, მოდით გავაკეთოთ, რომ.

357
00:21:35,350 --> 00:21:41,880
მე ვაპირებ აკრიფოთ მიიღოს და შემდეგ წყაროები
უდრის მიესალმები ეს არის 3image.c.

358
00:21:41,880 --> 00:21:49,632

359
00:21:49,632 --> 00:21:52,240
ყველა უფლება, რომელიც შედგენილი არ შეცდომები.

360
00:21:52,240 --> 00:21:57,210
და თქვენ შეგიძლიათ ნახოთ აქ მე ახლა
შედგენილი ჩემი სურათი, Hello, CS50!

361
00:21:57,210 --> 00:22:00,560
ჩვენი ფანჯარა, რომელიც
ქრება მას შემდეგ, ხუთ წამში.

362
00:22:00,560 --> 00:22:02,090
>> ახლა, ეს ჯერ კიდევ აქვს პრობლემები, არა?

363
00:22:02,090 --> 00:22:05,750
ეს არ არის კარგი პროგრამა,
იმიტომ, რომ როდესაც ვცდილობ დახურეთ ფანჯარა,

364
00:22:05,750 --> 00:22:06,500
არაფერი ხდება.

365
00:22:06,500 --> 00:22:09,540
ეს x კვლავ არ პასუხობს.

366
00:22:09,540 --> 00:22:17,420
მოდით შევხედოთ
შემდეგი ფაილის ნახვა, hello4animation.

367
00:22:17,420 --> 00:22:21,850
ასე რომ, ეს არის ფაილი,
რომ აპირებს გააცნოს

368
00:22:21,850 --> 00:22:25,124
მოძრავი და მოძრაობა ჩვენი იმიჯი.

369
00:22:25,124 --> 00:22:27,040
ამიტომ, ჩვენ ვაპირებთ გავაკეთოთ
იგივე როგორც ადრე,

370
00:22:27,040 --> 00:22:30,190
ინიცირება SDL, შექმნა
window, შექმნა renderer,

371
00:22:30,190 --> 00:22:33,030
ჩატვირთვა გამოსახულება
მეხსიერება, შექმნა ტექსტურა.

372
00:22:33,030 --> 00:22:35,090
ჩვენ ვნახეთ ყველა, რომ ადრე.

373
00:22:35,090 --> 00:22:36,770
ახლა, ეს არის ახალი.

374
00:22:36,770 --> 00:22:42,305
ჩვენ ვაპირებთ, რომ არ სტრუქტურა მოუწოდა
SDL rect, რომელიც მხოლოდ მართკუთხედი.

375
00:22:42,305 --> 00:22:49,950
თუ ჩვენ აქ, ჩვენ შეგვიძლია
გავაკეთოთ ძიება SDL rect,

376
00:22:49,950 --> 00:22:54,040
და თქვენ შეგიძლიათ ნახოთ ის
ძალიან მარტივი სტრუქტურა.

377
00:22:54,040 --> 00:22:56,760
მას აქვს x, y for
პოზიცია და ის

378
00:22:56,760 --> 00:23:02,080
აქვს სიგანე და სიმაღლე
ზომა ოთხკუთხედი.

379
00:23:02,080 --> 00:23:07,785
>> ასე რომ, რასაც ჩვენ ვაპირებთ გავაკეთოთ, არის ის, რომ ჩვენ
აპირებს განსაზღვროს ამ SDL rect dest,

380
00:23:07,785 --> 00:23:09,480
დანიშნულების.

381
00:23:09,480 --> 00:23:14,130
ეს არის ადგილი,
ეკრანზე, სადაც

382
00:23:14,130 --> 00:23:16,005
ჩვენ ვაპირებთ, რომ ხატვის
ჩვენი იმიჯი, მარჯვენა ასე

383
00:23:16,005 --> 00:23:17,880
თუ ჩვენ ვაპირებთ, რომ იყოს
მოძრავი გამოსახულება გარშემო,

384
00:23:17,880 --> 00:23:20,300
მაშინ დანიშნულების, სადაც
ჩვენ ვაპირებთ, რომ დავხატოთ სურათი

385
00:23:20,300 --> 00:23:22,620
უნდა მოძრაობდნენ.

386
00:23:22,620 --> 00:23:24,910
ამიტომ, ჩვენ ვაპირებთ, რომ მოვუწოდო ამ
ფუნქცია SDL_QueryTexture.

387
00:23:24,910 --> 00:23:27,550

388
00:23:27,550 --> 00:23:33,500
და შენიშნავს, მე გავლის მისამართი
საქართველოს dest.w, რომელიც არის სიგანე,

389
00:23:33,500 --> 00:23:36,950
და dest.h, რომელიც სიმაღლეზე.

390
00:23:36,950 --> 00:23:40,425
ასე რომ, SDL_QueryTexture აპირებს
შესანახად იმ სფეროებში სიგანე

391
00:23:40,425 --> 00:23:41,675
და სიმაღლე ჩვენი ტექსტურა.

392
00:23:41,675 --> 00:23:44,680

393
00:23:44,680 --> 00:23:47,030
>> და მერე რა მე ვაპირებ
რომ გააკეთოთ, არის მე ვაპირებ

394
00:23:47,030 --> 00:23:55,580
მითითებული dest.x იყოს window
სიგანე მინუს dest.w, რომელიც

395
00:23:55,580 --> 00:23:59,000
სიგანე Sprite, გაყოფილი 2.

396
00:23:59,000 --> 00:24:03,860
და ეს ხდება, რომ მითითებული ეს ისე,
რომ გამოსახულება კარგად ორიენტირებული

397
00:24:03,860 --> 00:24:06,780
ჩვენს window, ყველა უფლება?

398
00:24:06,780 --> 00:24:08,652
ასე რომ, ახლა მე მაქვს y პოზიცია.

399
00:24:08,652 --> 00:24:10,360
და ამ აპირებს
იყოს ცვლადი რომ

400
00:24:10,360 --> 00:24:16,390
იცვლება, იმიტომ, რომ ჩვენ ვაპირებთ, რომ იყოს
მოძრავი გამოსახულების y მიმართულებით.

401
00:24:16,390 --> 00:24:19,050
და ახლა ჩვენ გვაქვს რაღაც
ე.წ. ანიმაცია loop.

402
00:24:19,050 --> 00:24:21,180
>> ასე რომ, როგორ ანიმაცია მუშაობა?

403
00:24:21,180 --> 00:24:27,630
ისე, ადამიანის თვალის შეუძლია აღმოაჩინოს 12 მკაფიო
სურათები ყოველ მეორე, ყველა უფლება?

404
00:24:27,630 --> 00:24:33,060
ასე რომ, თუ ფლეშის 12 სურათი ბარათები at me
მეორე, მე დავინახე, თითოეული იმ სურათები

405
00:24:33,060 --> 00:24:35,950
როგორც საკუთარი მკაფიო ინდივიდუალური იმიჯი.

406
00:24:35,950 --> 00:24:39,690
ახლა კი, თუ ფლეშის მეტი
სურათები at me მეორე,

407
00:24:39,690 --> 00:24:42,140
მაშინ ჩემი თვალი დაიწყება
ბუნდოვანი მათ ერთად

408
00:24:42,140 --> 00:24:46,920
და მე აღქმული იქნება, როგორც მოძრაობის,
ნაცვლად ერთი მკაფიო გამოსახულება.

409
00:24:46,920 --> 00:24:51,930
ასე, მაგალითად, ფილმები და სატელევიზიო,
ისინი ფლეშის images თქვენ 24-ჯერ

410
00:24:51,930 --> 00:24:52,570
მეორე.

411
00:24:52,570 --> 00:24:55,110
ასე რომ, 24 კადრი წამში.

412
00:24:55,110 --> 00:25:00,136
კომპიუტერის ეკრანები, მეორეს მხრივ,
ხშირად 60 კადრი წამში.

413
00:25:00,136 --> 00:25:01,260
სწორედ მათი განახლება სიჩქარე.

414
00:25:01,260 --> 00:25:04,650
ეს არის ის, თუ როგორ ხშირად ისინი ამოცნობა
სურათი ეკრანზე.

415
00:25:04,650 --> 00:25:08,960
ასე რომ, ჩვენი სამიზნე იქნება 60
ფარგლებში წამში ჩვენი თამაშები.

416
00:25:08,960 --> 00:25:11,770

417
00:25:11,770 --> 00:25:13,710
>> ასე რომ, ვნახოთ, რომ კოდი.

418
00:25:13,710 --> 00:25:19,064
ამიტომ თითოეული ჩარჩო, ჩვენ პირველი
ვაპირებ გარკვევას ფანჯარა.

419
00:25:19,064 --> 00:25:20,230
ეს არის ზოგადი ნიმუში.

420
00:25:20,230 --> 00:25:22,450
თქვენ ყოველთვის გარკვევა
window თითოეული ჩარჩო, და შემდეგ

421
00:25:22,450 --> 00:25:25,210
ყველაფერი თქვენი ნახაზი
ოპერაციების, და მერე ბოლოს,

422
00:25:25,210 --> 00:25:29,610
არ RenderPresent უნდა ნახოთ
ყველაფერი ფარგლებში.

423
00:25:29,610 --> 00:25:33,910
და მაშინ თქვენ აპირებს
უნდა დაველოდოთ ბოლოს

424
00:25:33,910 --> 00:25:36,340
დაველოდოთ შემდეგი
ჩარჩო უნდა დაიწყოს.

425
00:25:36,340 --> 00:25:38,650
>> ასე რომ, თუ მე აკეთებდა ბევრი
რთული გამოთვლები აქ

426
00:25:38,650 --> 00:25:43,100
რომ აიღო 16-ზე მეტი მილიწამებში,
შეუძლებელი იქნება ჩემთვის

427
00:25:43,100 --> 00:25:46,890
უნდა, რომ გადაღების სიხშირე 60 რომ
მინდოდა, იმიტომ, რომ ყოველ ჩარჩო

428
00:25:46,890 --> 00:25:48,750
აღების დიდი ხნის გამოთვლაც.

429
00:25:48,750 --> 00:25:52,340
გარდა ამისა, ჩვენ ნამდვილად აკეთებს
ერთგვარი უმნიშვნელო რაოდენობით სამუშაო

430
00:25:52,340 --> 00:25:54,820
აქ, იმიტომ, რომ იქ მხოლოდ
ერთი რამ ჩვენ ხატვის.

431
00:25:54,820 --> 00:25:59,390
ასე რომ, მე უბრალოდ დაველოდოთ 1/60 ერთი
მეორე, რომელიც არის სიგრძეზე

432
00:25:59,390 --> 00:26:01,520
ჩარჩო შორის ფარგლებში.

433
00:26:01,520 --> 00:26:05,610
ასე რომ, მე ერთგვარი თითქოს აკეთებს
ყველა ჩემი მუშაობის იღებს ნულოვანი დრო.

434
00:26:05,610 --> 00:26:09,050
მაგრამ რეალური თამაში,
ნეტავ უნდა გამოვაკლოთ

435
00:26:09,050 --> 00:26:13,760
თანხის დრო დასჭირდა ამის გაკეთება
ყველა ამ სამუშაოს თქვენი დასვენების დრო.

436
00:26:13,760 --> 00:26:16,970
>> ასე რომ მაინც, რა ვარ მე
რეალურად აკეთებს ამ loop?

437
00:26:16,970 --> 00:26:19,070
მე გარკვევა ფანჯარა.

438
00:26:19,070 --> 00:26:27,470
I მითითებული dest.y, რომელიც არის int to
ჩემი ფაქტობრივი y პოზიცია მიცემული int.

439
00:26:27,470 --> 00:26:32,070
ახლა, მე მინდა ათწილადი გაფართოება
ჩემი y პოზიცია ჩემი თამაში,

440
00:26:32,070 --> 00:26:34,150
მაგრამ მაშინ რეალურად
შევაჩერო ეს გადატანა ეკრანზე,

441
00:26:34,150 --> 00:26:39,070
მას სჭირდება ints, იმიტომ, რომ ეს ერთეული
pixels, ისე, რომ ის, რაც მსახიობი არის.

442
00:26:39,070 --> 00:26:41,745
მე ვაპირებ შევაჩერო იმიჯი.

443
00:26:41,745 --> 00:26:45,180
ასე რომ, ეს არის წყარო მართკუთხედი.

444
00:26:45,180 --> 00:26:47,060
და ეს არის დანიშნულების მართკუთხედი.

445
00:26:47,060 --> 00:26:50,310
ასე რომ, მე გაიარა null for
წყარო მართკუთხედი

446
00:26:50,310 --> 00:26:53,426
ვთქვა, მინდა რომ ჩემი მთელი ტექსტურა.

447
00:26:53,426 --> 00:26:55,300
მაგრამ თუ ჰქონდა ბევრი
ტექსტურები თქვენი თამაში

448
00:26:55,300 --> 00:26:59,120
და ისინი ყველა ერთ დიდ ტექსტურა რუკა
რომ დატვირთულია SDL როგორც მხოლოდ ერთი

449
00:26:59,120 --> 00:27:02,850
ტექსტურა, თქვენ შეიძლება
გამოიყენოთ წყარო მართკუთხედი

450
00:27:02,850 --> 00:27:06,750
აირჩიოთ ერთი პატარა ტექსტურები,
ერთი პატარა sprites,

451
00:27:06,750 --> 00:27:09,450
გარეთ რომ დიდი ტექსტურა რუკა.

452
00:27:09,450 --> 00:27:14,740
>> ასე რომ კიდევ ერთხელ, მე გავლით ჩემი გაწევა, ჩემი
ტექსტურა, და ახლა დანიშნულების.

453
00:27:14,740 --> 00:27:18,320
ეს იქნება, სადაც
window ის აპირებს იყოს.

454
00:27:18,320 --> 00:27:21,390
და მაშინ, იმიტომ, რომ მე ანიმაციური
რაღაც, მე უნდა მოძრაობა,

455
00:27:21,390 --> 00:27:25,150
მე ვაპირებ განახლება
Sprite, პოზიცია თითოეული ჩარჩო.

456
00:27:25,150 --> 00:27:30,190
ასე რომ, მე ამ მუდმივი მოუწოდა გადახვევა
დააჩქაროს ერთეული პიქსელი წამში.

457
00:27:30,190 --> 00:27:34,320
ახლა, ყოველ ჯერზე ჩვენ გავაკეთებთ მოძრაობა,
ჩარჩო არის მხოლოდ 1/60 მეორე.

458
00:27:34,320 --> 00:27:36,740
ამიტომ, მე ვაპირებ, რომ გაყოფა, რომ 60.

459
00:27:36,740 --> 00:27:42,350
და შემდეგ, ვნახოთ, მე
გამოკლებით, რომ y პოზიცია.

460
00:27:42,350 --> 00:27:44,470
რატომ ვაკლებთ?

461
00:27:44,470 --> 00:27:46,169
ჩვენ კიდევ, რომ მეორე.

462
00:27:46,169 --> 00:27:48,460
ასე რომ მერე გაწმენდა ჩემი რესურსები
და პროგრამა დასრულდა.

463
00:27:48,460 --> 00:27:49,830
>> მოდით, რომ.

464
00:27:49,830 --> 00:27:52,450

465
00:27:52,450 --> 00:28:03,570
ასე რომ, მოდით წასვლას მიიღოს SRCS = Hello4
animation.c, ყველა უფლება?

466
00:28:03,570 --> 00:28:05,720
თამაშის.

467
00:28:05,720 --> 00:28:06,770
ესეც ასე.

468
00:28:06,770 --> 00:28:12,690
ასე რომ მე სენსორული მდე
ფანჯარა, რომელიც არის საკმაოდ სუფთა.

469
00:28:12,690 --> 00:28:17,110
მაგრამ გამართავს, მე გამოკლება
საწყისი y პოზიცია ყოველ ჯერზე.

470
00:28:17,110 --> 00:28:18,910
რა ხდება იქ?

471
00:28:18,910 --> 00:28:24,010
ისე, გამოდის, რომ ამ SDL და
სინამდვილეში, ყველაზე კომპიუტერული გრაფიკა,

472
00:28:24,010 --> 00:28:28,890
წარმოშობის საკოორდინატო სისტემა
არის ზედა მარცხენა ფანჯარა.

473
00:28:28,890 --> 00:28:34,960
>> ასე რომ, დადებითი x მიმართულებით მიდის
მთელს თქვენს window უფლება.

474
00:28:34,960 --> 00:28:38,110
და დადებითი y მიმართულებით
რეალურად მიდის ქვემოთ.

475
00:28:38,110 --> 00:28:40,470
ასე რომ კიდევ ერთხელ, წარმოშობის ს
ზედა მარცხენა ფანჯარა,

476
00:28:40,470 --> 00:28:46,190
დადებითი y მიმართულებით ქვემოთ,
და დადებითი x არის სწორი.

477
00:28:46,190 --> 00:28:48,770
ასე რომ, როცა სხვაობა
შ პოზიცია, რომ

478
00:28:48,770 --> 00:28:52,640
ვაპირებთ, რათა ის წასვლა უარყოფითი
y მიმართულებით, რომელიც არის up ფანჯარა.

479
00:28:52,640 --> 00:28:55,500
ასე რომ, რა ხდება იქ.

480
00:28:55,500 --> 00:28:56,510
ზემოთ.

481
00:28:56,510 --> 00:28:59,240
>> მოდით შევხედოთ შემდეგი ფაილი.

482
00:28:59,240 --> 00:29:05,700
აქ არის ნაწილი
შოუ, სადაც ჩვენ საბოლოოდ

483
00:29:05,700 --> 00:29:08,920
მიიღოს, რომ X კუთხეში ფანჯარა
რომ უნდა დახუროთ ფანჯარა

484
00:29:08,920 --> 00:29:10,660
მუშაობა.

485
00:29:10,660 --> 00:29:12,800
რა ხდება?

486
00:29:12,800 --> 00:29:17,520
ჩვენ ინიციალიზაცია SDL, შექმნა ფანჯარა,
შექმნა renderer, ჩატვირთვა გამოსახულება,

487
00:29:17,520 --> 00:29:19,770
შექმნა ტექსტურა
როგორც ჩვენ ვნახეთ ადრე.

488
00:29:19,770 --> 00:29:26,850
ჩვენ გვყავს იგივე დანიშნულების მართკუთხედი
როგორც ადრე, იგივე ზარი შეკითხვის ტექსტურა.

489
00:29:26,850 --> 00:29:29,780
მაგრამ ამ დროს, ჩვენ მაშინ
ვაპირებთ, რომ დაყოფის სიგანე

490
00:29:29,780 --> 00:29:33,110
და სიმაღლე ჩვენი დანიშნულების 4.

491
00:29:33,110 --> 00:29:36,430
ეს მხოლოდ აქვს ეფექტი
სკალირების ჩვენი იმიჯი, როდესაც

492
00:29:36,430 --> 00:29:39,884
არიან ეს ფანჯარა ოთხი.

493
00:29:39,884 --> 00:29:40,800
ასე რომ, საკმაოდ სუფთა.

494
00:29:40,800 --> 00:29:42,770
ჩვენ შეგვიძლია მხოლოდ მასშტაბის, ისევე, როგორც, რომ.

495
00:29:42,770 --> 00:29:45,970
ჩვენ ვაპირებთ, რომ დაიწყოს Sprite,
ცენტრში ეკრანზე.

496
00:29:45,970 --> 00:29:49,410
და ახლა ჩვენ გვაქვს x და y სიჩქარე და
ისინი ორივე აპირებს დაიწყოს ნულოვანი.

497
00:29:49,410 --> 00:29:53,740

498
00:29:53,740 --> 00:29:55,880
>> ეს არის არასწორი ფაილი.

499
00:29:55,880 --> 00:29:56,380
ბოდიში.

500
00:29:56,380 --> 00:29:57,960
ასე რომ, ყველა ჭეშმარიტი.

501
00:29:57,960 --> 00:30:00,170
ეს ყველაფერი ჯერ კიდევ ამ ფაილის.

502
00:30:00,170 --> 00:30:03,210
ჩვენ გვაქვს გაყოფილი 4 და ყველაფერი.

503
00:30:03,210 --> 00:30:07,830
ასე რომ, აქ ჩვენ გვაქვს ჩვენი x და y პოზიცია
ცენტრში ფანჯარა.

504
00:30:07,830 --> 00:30:12,480
და ვაძლევთ მას საწყისი სიჩქარე
ამ მუდმივი სიჩქარით, რომელიც

505
00:30:12,480 --> 00:30:15,180
მე მჯერა, არის 300 პიქსელი წამში.

506
00:30:15,180 --> 00:30:19,850
ახლა, ჩვენ გვაქვს ეს int შეიძლება უბრალოდ ისევე
იყოს ლოგიკური უწოდა ახლოს მოითხოვა.

507
00:30:19,850 --> 00:30:23,970
და ნაცვლად აკეთებს
უსასრულო ციკლი ტაიმერი აქ,

508
00:30:23,970 --> 00:30:29,180
ჩვენ ვაპირებთ, რომ იყოს ანიმაციური, როგორც
სანამ ახლოს არ არის მოთხოვნილი.

509
00:30:29,180 --> 00:30:30,960
>> ასე რომ, თუ ჩვენ შევძლებთ მოვლენები?

510
00:30:30,960 --> 00:30:35,600
ისე, SDL რიგები up მოვლენების
ლიტერატურული მდგომ კულისებში.

511
00:30:35,600 --> 00:30:38,860
და მაშინ თითოეული ჩარჩო,
ჩვენ შეგვიძლია dequeue მოვლენები

512
00:30:38,860 --> 00:30:43,900
რომ მდგომ გამოყენებით
ეს მოწოდება SDL_PullEvent.

513
00:30:43,900 --> 00:30:46,730
ისევ და ისევ, აუცილებლად წაიკითხავს
ამ დოკუმენტაცია.

514
00:30:46,730 --> 00:30:50,450
არსებობს უამრავი უფრო დეტალურად და ბევრი
მეტი ფუნქციები შეგიძლიათ გამოიყენოთ ეს.

515
00:30:50,450 --> 00:30:54,750
ჩვენ გაიაროს ეს მისამართი
ამ რამ, SDL_Event

516
00:30:54,750 --> 00:30:56,990
რომ ჩვენ გვაქვს აქ Stack.

517
00:30:56,990 --> 00:30:58,840
>> ახლა, რა არის SDL_event?

518
00:30:58,840 --> 00:31:02,356
იმის გამო, რომ SDL, თუ გადავხედავთ
documentation-- მოდით

519
00:31:02,356 --> 00:31:07,580
ვხედავ, API კატეგორიის მიხედვით, input
მოვლენები, ღონისძიების გატარება,

520
00:31:07,580 --> 00:31:15,150
ჩვენ შეგვიძლია შევხედოთ ნომერი
სხვადასხვა მოვლენების აქ

521
00:31:15,150 --> 00:31:18,600
და ჩვენ ვხედავთ, რომ იქ
მთელი ტონა მათ.

522
00:31:18,600 --> 00:31:22,150
რა არის ეს SDL_Event რამ?

523
00:31:22,150 --> 00:31:28,190

524
00:31:28,190 --> 00:31:31,107
SDL_Event არის კავშირი.

525
00:31:31,107 --> 00:31:31,940
Wow, რა კავშირი?

526
00:31:31,940 --> 00:31:33,910
თქვენ ალბათ არასოდეს
გამიგია, რომ ადრე.

527
00:31:33,910 --> 00:31:35,610
და რომ კარგადაა.

528
00:31:35,610 --> 00:31:39,420
>> კავშირი არის სახის მოსწონს
struct, გარდა struct

529
00:31:39,420 --> 00:31:41,960
აქვს ფართი ყველა
მისი სფეროებში და მეხსიერება,

530
00:31:41,960 --> 00:31:45,060
ხოლო კავშირი მხოლოდ
საკმარისი სივრცე, რათა შეწყობოდა უდიდესი

531
00:31:45,060 --> 00:31:49,660
მისი ერთ-ერთი სფეროებში, რაც იმას ნიშნავს,
შესაძლებელია მხოლოდ შესანახად მისი ერთ-ერთი სფეროებში

532
00:31:49,660 --> 00:31:52,830
იმ დროს, რომელიც სახის
აზრი მოვლენები, არა?

533
00:31:52,830 --> 00:31:55,810
ჩვენ შეგვიძლია კლავიატურის
მოვლენის ან window ღონისძიება,

534
00:31:55,810 --> 00:31:59,750
მაგრამ ერთი ღონისძიება არ შეიძლება იყოს, როგორც
კლავიატურის ღონისძიება და window ღონისძიება,

535
00:31:59,750 --> 00:32:05,450
ამიტომ მინდა იყოს სულელური ჰქონდეს ფართი
ორივე შიგნით ჩვენი ღონისძიება კავშირი.

536
00:32:05,450 --> 00:32:07,770
ასე რომ, თუ თქვენ სურდა
შექმნათ თქვენი საკუთარი კავშირი,

537
00:32:07,770 --> 00:32:10,020
ეს გამოიყურება ზუსტად იგივე
შექმნის struct,

538
00:32:10,020 --> 00:32:14,140
გარდა იმისა, რომ ჩვენ ვიყენებთ კავშირის სიტყვით
ნაცვლად struct სიტყვით.

539
00:32:14,140 --> 00:32:17,490
და მახსოვს, რომ ყველა
რამ შიგნით თქვენი კავშირი,

540
00:32:17,490 --> 00:32:22,020
ფაქტობრივი ცვლადი, რომელიც არის კავშირი
შეიძლება ჰქონდეს მხოლოდ ერთი იმ ფასეულობებს

541
00:32:22,020 --> 00:32:24,780
დროულად.

542
00:32:24,780 --> 00:32:29,940
>> მაშ, როგორ შეგვიძლია გითხრათ, თუ რა სახის ღონისძიება
ჩვენ უბრალოდ გამოჩნდა off ამ მდგომ?

543
00:32:29,940 --> 00:32:33,370
ისე, ჩვენ შეგვიძლია შევამოწმოთ event.type.

544
00:32:33,370 --> 00:32:35,792
და თუ ეს უდრის
რომ SDL_Quit, ჩვენ ვიცით,

545
00:32:35,792 --> 00:32:37,500
ეს არის ღონისძიება, რომელიც
გენერირებული როდესაც ჩვენ

546
00:32:37,500 --> 00:32:39,510
მოხვდა, რომ X კუთხეში ფანჯარა.

547
00:32:39,510 --> 00:32:44,270
და ჩვენ შეგვიძლია მითითებული ახლოს მოითხოვა უდრის 1.

548
00:32:44,270 --> 00:32:47,230
დანარჩენი არის მხოლოდ გარკვეული ანიმაცია
რომ ვნახე ადრე.

549
00:32:47,230 --> 00:32:52,802
მოდით, წავიდეთ წინ და
ამ და ვნახოთ რამდენად კარგად მუშაობს.

550
00:32:52,802 --> 00:32:55,135
ამიტომ, მე ვაპირებ აკრიფოთ მიიღოს და
მაშინ SRCS = hello5_events.c.

551
00:32:55,135 --> 00:33:03,760

552
00:33:03,760 --> 00:33:04,770
იქ ჩვენ წავიდეთ.

553
00:33:04,770 --> 00:33:05,780
თამაშები.

554
00:33:05,780 --> 00:33:08,920
>> ახლა, ჩვენ ვხედავთ, რომ ეს იყო
მართლაც მასშტაბური ქვემოთ ოთხი.

555
00:33:08,920 --> 00:33:10,360
და ახლა ის bouncing გარშემო.

556
00:33:10,360 --> 00:33:14,630
მაქვს რამდენიმე შეჯახების აღმოჩენისა
მიმდინარეობს მხარეს window

557
00:33:14,630 --> 00:33:16,840
რომ ჩვენ შეგვიძლია შევხედოთ.

558
00:33:16,840 --> 00:33:21,190
და რა ხდება, როდესაც მე წასვლა დახურვა?

559
00:33:21,190 --> 00:33:22,120
ეს იხურება.

560
00:33:22,120 --> 00:33:22,740
Fantastic.

561
00:33:22,740 --> 00:33:24,290
ჩვენ მივიღეთ, რომ ღონისძიება.

562
00:33:24,290 --> 00:33:26,630
ჩვენ სიფრთხილით იგი.

563
00:33:26,630 --> 00:33:30,730
>> მოდით ვიხსენებთ კოდი.

564
00:33:30,730 --> 00:33:33,020
ასე რომ, როგორ მივიღებ
bouncing გარშემო, რომ?

565
00:33:33,020 --> 00:33:37,200
დამახსოვრება I მითითებული ორივე x და
y თავდაპირველად სიჩქარეზე.

566
00:33:37,200 --> 00:33:39,260
და სიჩქარე არის დადებითი
მუდმივი, ისე, რომ

567
00:33:39,260 --> 00:33:42,680
აპირებს მიიღოს ეს დაწყებული გარეთ
მიდის ქვემოთ და მარჯვნივ.

568
00:33:42,680 --> 00:33:45,680

569
00:33:45,680 --> 00:33:50,310
>> ახლა, ყოველ ფარგლებში, გარდა გატარება
რაიმე მოვლენების, რომელიც არ უნდა მომხდარიყო,

570
00:33:50,310 --> 00:33:57,520
მე ვაპირებ აღმოაჩინოს თუ არა ჩემი Sprite,
ცდილობს გარეთ ფანჯარა.

571
00:33:57,520 --> 00:34:03,610
ასე რომ, ჩვენ შეგვიძლია გავაკეთოთ, რომ მხოლოდ შემოწმების
x_pos 0, y_pos 0, და მაშინ

572
00:34:03,610 --> 00:34:07,370
ასევე x_pos და y_pos ერთად
window სიგანე და window სიმაღლეზე.

573
00:34:07,370 --> 00:34:11,010
ყურადღება მიაქციეთ, მე გამოაკლდა
სიგანე Sprite.

574
00:34:11,010 --> 00:34:14,090
და ეს იმიტომ, რომ თუ არ
სხვაობა სიგანე Sprite,

575
00:34:14,090 --> 00:34:17,760
ეს მხოლოდ შეამოწმოს, რომ
წარმოშობის Sprite,

576
00:34:17,760 --> 00:34:19,690
არ წავიდეთ გარეთ ფანჯარა.

577
00:34:19,690 --> 00:34:21,480
მაგრამ ჩვენ გვინდა, რომ მთელი
სიგანე Sprite,

578
00:34:21,480 --> 00:34:24,030
ყოველთვის იქნება შიგნით ფანჯარა და
მთელ სიმაღლეზე Sprite,

579
00:34:24,030 --> 00:34:25,321
ყოველთვის იქნება შიგნით ფანჯარა.

580
00:34:25,321 --> 00:34:27,429
ასე რომ, რა გამოკლება არის.

581
00:34:27,429 --> 00:34:30,080
ბევრი გეომეტრია აქ შეგიძლიათ
სასარგებლო იქნება დაგეხატა

582
00:34:30,080 --> 00:34:33,929
ქაღალდზე კოორდინირებული
სისტემა, თუ რა ხდება.

583
00:34:33,929 --> 00:34:38,090
>> ასე რომ, თუ დაეჯახება, მე მხოლოდ
უბრალოდ აღადგინოთ პოზიცია

584
00:34:38,090 --> 00:34:41,400
ისე, რომ იგი არ აპირებს
გარეთ ეკრანზე.

585
00:34:41,400 --> 00:34:47,179
და მე ვაპირებ, თუ იგი ხტება
ერთი sidewalls,

586
00:34:47,179 --> 00:34:51,469
მე ვაპირებ უარყოფს
x სიჩქარე ისე, რომ იგი

587
00:34:51,469 --> 00:34:53,210
იწყება bouncing სხვა მიმართულებით.

588
00:34:53,210 --> 00:34:56,210
და ანალოგიურად, თუ იგი ჰიტები
ზედა და ქვედა,

589
00:34:56,210 --> 00:34:59,820
მე ვაპირებ მითითებული y სიჩქარე
ტოლი უარყოფითი y სიჩქარე,

590
00:34:59,820 --> 00:35:01,690
ისე, რომ ახსნას.

591
00:35:01,690 --> 00:35:03,860
ასე რომ, მხოლოდ, როგორ მივიღეთ ეს აქ.

592
00:35:03,860 --> 00:35:07,560
>> და განახლება თანამდებობებზე
ისევე, როგორც ჩვენ ვნახეთ ადრე,

593
00:35:07,560 --> 00:35:12,510
გავყოთ 60, იმიტომ, რომ ჩვენ
მხოლოდ გატარება 1/60 მეორე.

594
00:35:12,510 --> 00:35:15,750
და მაშინ გაწევის,
ზუსტად ისევე, როგორც ადრე.

595
00:35:15,750 --> 00:35:19,810
და ისე, რომ ყველაფერი
რომ ხდებოდა ეს ფაილი.

596
00:35:19,810 --> 00:35:22,490
ასე რომ, თუ როგორ გავაკეთოთ მოვლენები.

597
00:35:22,490 --> 00:35:29,260
მთავარია, რომ წართმევას აქ
ეს არის SDL_PullEvent ფუნქცია.

598
00:35:29,260 --> 00:35:33,020
და თქვენ უნდა აუცილებლად წაიკითხეთ
დოკუმენტაცია უფრო მეტი SDL_Event

599
00:35:33,020 --> 00:35:38,630
კავშირი, იმიტომ, რომ ეს მონაცემები ტიპის
ძალიან, ძალიან მნიშვნელოვანია, იმიტომ, რომ ჩვენ ვიყენებთ

600
00:35:38,630 --> 00:35:40,690
ყველა სახის ღონისძიებები.

601
00:35:40,690 --> 00:35:46,539
>> მაგალითად, ჩვენ ვიყენებთ მას კლავიატურის
მოვლენები, რაც ეს ფაილი.

602
00:35:46,539 --> 00:35:47,330
ასე რომ, რა გვაქვს?

603
00:35:47,330 --> 00:35:50,180
ჩვენ გვყავს იგივე რამ, როგორც ადრე,
ინიციალიზაცია SDL, შექმნა ფანჯარა,

604
00:35:50,180 --> 00:35:55,260
შექმნა renderer, ჩატვირთვა გამოსახულება
მეხსიერებაში, შექმნა ტექსტურა.

605
00:35:55,260 --> 00:36:00,530
კიდევ ერთხელ, ჩვენ ვაპირებთ
აქვს ამ dest მართკუთხედი,

606
00:36:00,530 --> 00:36:04,890
ჩვენ ვაპირებთ, რომ მასშტაბის იმიჯი
ოთხი, რათა ის ცოტა პატარა.

607
00:36:04,890 --> 00:36:08,000
ახლა, ჩვენ ვაპირებთ, რომ დაიწყოს
Sprite-ცენტრში ეკრანზე.

608
00:36:08,000 --> 00:36:12,090
მაგრამ ამ დროს, ჩვენ ვაპირებთ, რომ მითითებული
საწყის x და y სიჩქარეების ნულოვანი,

609
00:36:12,090 --> 00:36:15,140
იმიტომ, რომ კლავიატურაზე
აპირებს გაკონტროლება იმ.

610
00:36:15,140 --> 00:36:18,900
და უფრო მეტიც, ჩვენ ვაპირებთ
ტრეკზე ამ ცვლადის

611
00:36:18,900 --> 00:36:20,450
up, down, მარცხენა და მარჯვენა.

612
00:36:20,450 --> 00:36:23,090
და რომ აპირებს შენარჩუნება
ტრეკზე თუ არა ჩვენ

613
00:36:23,090 --> 00:36:27,370
დაპრესილი კლავიატურის ღილაკების, რომ
შეესაბამება up, down, მარცხენა,

614
00:36:27,370 --> 00:36:28,460
და მარჯვენა.

615
00:36:28,460 --> 00:36:32,440
>> ახლა, ეს არის ერთგვარი ლამაზი
იმიტომ, რომ ჩვენ შეგვიძლია გამოვიყენოთ W, A, S,

616
00:36:32,440 --> 00:36:35,480
D აქ, ან ფაქტობრივი ისრიანი ღილაკები.

617
00:36:35,480 --> 00:36:38,590
ჩვენ დავინახავთ, რომ მხოლოდ მეორე.

618
00:36:38,590 --> 00:36:41,140
ამიტომ, ჩვენ ვაპირებთ, რომ გადაამუშავებს
იმ შემთხვევაში, ისევე, როგორც ადრე.

619
00:36:41,140 --> 00:36:42,530
ჩვენ გაიყვანოს ღონისძიება.

620
00:36:42,530 --> 00:36:45,840
მაგრამ ახლა ჩვენ ვაპირებთ
ჩართვის ღონისძიება ტიპის.

621
00:36:45,840 --> 00:36:47,710
თუ ეს SDL_Quit, ჩვენ
შექმნას აპირებს ახლოს

622
00:36:47,710 --> 00:36:49,990
მოითხოვა ერთი, ისევე როგორც ადრე.

623
00:36:49,990 --> 00:36:52,315
რომელიც ახორციელებს x in
კუთხეში ფანჯარა,

624
00:36:52,315 --> 00:36:55,050
ასე რომ, ჩვენი ფანჯარა რეალურად ხურავს.

625
00:36:55,050 --> 00:37:00,110
>> წინააღმდეგ შემთხვევაში, თუ მივიღებთ SDL გასაღები ქვემოთ
ღონისძიება, რაც იმას ნიშნავს, დაპრესილი გასაღები,

626
00:37:00,110 --> 00:37:04,470
შემდეგ, რაც ჩვენ ვაპირებთ გავაკეთოთ არის, რომ ჩვენ
ვაპირებ გადახვიდეთ ამ რამ აქ,

627
00:37:04,470 --> 00:37:11,370
რომელიც ნიშნავს, ასე რომ event.key
იმას ნიშნავს, მკურნალობა ჩვენი ღონისძიება კავშირის,

628
00:37:11,370 --> 00:37:15,490
წავიდეთ და მიიღოს გასაღები
ღონისძიების სტრუქტურა მას.

629
00:37:15,490 --> 00:37:18,810
გამოდის, რომ ეს
კავშირი არის მნიშვნელოვანი მოვლენა, სტრუქტურა.

630
00:37:18,810 --> 00:37:22,820
და მერე გასაღები
ღონისძიების სტრუქტურა თავის სფეროში

631
00:37:22,820 --> 00:37:26,140
მოუწოდა keysym და შემდეგ scancode.

632
00:37:26,140 --> 00:37:29,480
ისევ და ისევ, აუცილებლად წაიკითხონ
დოკუმენტაცია შესახებ.

633
00:37:29,480 --> 00:37:31,220
საკვანძო საშუალებებით საკმაოდ საინტერესო.

634
00:37:31,220 --> 00:37:34,020
თქვენ შეგიძლიათ სკანირების კოდები და გასაღები კოდები.

635
00:37:34,020 --> 00:37:38,590
და ეს ცოტა დახვეწილი, მაგრამ
დოკუმენტაცია საკმაოდ კარგი.

636
00:37:38,590 --> 00:37:43,380
>> ასე რომ, თუ ჩვენ ვხედავთ სკანირების კოდი
ჩვენი ძირითადი პრესაში უკვე W ან,

637
00:37:43,380 --> 00:37:45,450
ჩვენ ვაპირებთ, რომ შეიქმნას თანაბარი 1.

638
00:37:45,450 --> 00:37:47,240
და მაშინ ჩვენ შესვენება გარეთ რომ შეცვლა.

639
00:37:47,240 --> 00:37:52,980
თუ ის ან მარცხენა, ჩვენ მითითებული დარჩა 1, და
cetera, et cetera, ქვევით და მარჯვენა.

640
00:37:52,980 --> 00:37:57,080
ახლა, ამ გარე switch,
თუ ჩვენ ვხედავთ საკვანძო ღონისძიება,

641
00:37:57,080 --> 00:38:00,730
ეს ნიშნავს, რომ ჩვენ გაავრცელა გასაღები
და ჩვენ აღარ დაჭერით იგი.

642
00:38:00,730 --> 00:38:05,380
ამიტომ, მე ვაპირებ ვთქვა უდრის 0,
მარცხენა უდრის 0, ქვემოთ უდრის 0, მარჯვენა

643
00:38:05,380 --> 00:38:08,260
უდრის 0, et cetera.

644
00:38:08,260 --> 00:38:12,070
>> და შენიშნავს, ჩვენ თითოეული ამ
ორ შემთხვევაში მას უფლება შემდეგი ერთმანეთს

645
00:38:12,070 --> 00:38:14,490
არ ცალკე კოდი
პირველი საქმე, რომელიც

646
00:38:14,490 --> 00:38:18,180
იმას ნიშნავს, რომ თუ არა ეს
S ან ქვემოთ აქ,

647
00:38:18,180 --> 00:38:20,520
ის აპირებს შეასრულოს ეს კოდი.

648
00:38:20,520 --> 00:38:22,090
ასე რომ, საკმაოდ მოსახერხებელია.

649
00:38:22,090 --> 00:38:24,830
ეს ხელს უშლის ჩვენს რომელსაც ამის გაკეთება უფრო
პირობები და IFS და რამ

650
00:38:24,830 --> 00:38:26,980
ეგრე.

651
00:38:26,980 --> 00:38:29,420
>> ასე რომ, ჩვენ ვაპირებთ
დადგინდეს, სიჩქარე.

652
00:38:29,420 --> 00:38:31,020
ჩვენ მითითებული სიჩქარე 0.

653
00:38:31,020 --> 00:38:33,910
მაშინ, თუ up დაჭერის
და არა ქვემოთ, მაშინ ჩვენ

654
00:38:33,910 --> 00:38:37,450
მითითებული y სიჩქარე უარყოფითი სიჩქარე.

655
00:38:37,450 --> 00:38:42,930
დამახსოვრება უარყოფითი, რადგან
უარყოფითი y მიმართულებით არის.

656
00:38:42,930 --> 00:38:45,540
და დადებითი y მიმართულებით ქვემოთ.

657
00:38:45,540 --> 00:38:47,510
თუ ქვემოთ არის დაპრესილი
და არა, მაშინ ჩვენ

658
00:38:47,510 --> 00:38:53,860
შექმნას აპირებს, რომ ეს დადებითი სიჩქარე,
რაც იმას ნიშნავს, აპირებს ქვემოთ ეკრანზე.

659
00:38:53,860 --> 00:38:55,460
იგივე მარცხენა და მარჯვენა.

660
00:38:55,460 --> 00:38:58,200
>> და მაშინ ჩვენ ვაპირებთ განაახლოს
იმ პოზიციებზე, ისევე როგორც ადრე.

661
00:38:58,200 --> 00:39:00,740
ჩვენ ვაპირებთ, რომ შეჯახება
გამოვლენის საზღვრები,

662
00:39:00,740 --> 00:39:04,290
მაგრამ ჩვენ არ ვაპირებთ, რომ აღადგინოთ
სიჩქარე, რადგან სიჩქარე არის მხოლოდ

663
00:39:04,290 --> 00:39:06,780
აკონტროლებს კლავიატურაზე.

664
00:39:06,780 --> 00:39:11,230
მაგრამ ჩვენ ვაპირებთ, რომ აღადგინოთ
პოზიციების შენარჩუნება ეს ფანჯარა.

665
00:39:11,230 --> 00:39:14,400
და ჩვენ ვაპირებთ, რომ მითითებული
თანამდებობებზე struct

666
00:39:14,400 --> 00:39:17,400
და ამის შემდეგ ყველაფერი
გაწევის პერსონალის წინაშე.

667
00:39:17,400 --> 00:39:20,750
მოდით ვნახოთ, თუ რას აკეთებს.

668
00:39:20,750 --> 00:39:25,460
ასე რომ SRCS-- ვნახოთ,
ეს არის hello6_keyboard.c.

669
00:39:25,460 --> 00:39:38,140

670
00:39:38,140 --> 00:39:38,820
>> ო არა.

671
00:39:38,820 --> 00:39:40,150
ასე რომ, ჩვენ რაღაც გაფრთხილება აქ.

672
00:39:40,150 --> 00:39:43,840
და ეს უბრალოდ ვამბობ, ჩვენ არ
შეამოწმეთ თითოეული შესაძლო სახის

673
00:39:43,840 --> 00:39:45,610
ღონისძიება.

674
00:39:45,610 --> 00:39:49,470
ეს კარგია, რადგან
იქ 236 მათგანი ან ასე.

675
00:39:49,470 --> 00:39:51,760
ამიტომ, მე ვაპირებ იგნორირება იმ გაფრთხილება.

676
00:39:51,760 --> 00:39:53,530
ეს ჯერ კიდევ შედგენილი ჯარიმა.

677
00:39:53,530 --> 00:39:56,100
ამიტომ, მე ვაპირებ, რომ ითამაშოს თამაში.

678
00:39:56,100 --> 00:39:57,590
ეს არ მოძრაობს.

679
00:39:57,590 --> 00:40:04,150
მაგრამ ახლა, როდესაც მე ბადაგი ჩემს კლავიატურაზე,
მე შემიძლია ამის გაკეთება რაღაც WASD გადაადგილება აქ,

680
00:40:04,150 --> 00:40:06,870
მე ჩემი arrow გასაღებები, ასევე.

681
00:40:06,870 --> 00:40:10,070
და შეამჩნია, მიუხედავად იმისა, რომ მე
დაჭერით მარჯვენა ახლა,

682
00:40:10,070 --> 00:40:13,804
ის არ აპირებს ფანჯრიდან,
იმიტომ, რომ მე აღადგინოთ ის ყოველ ჩარჩო.

683
00:40:13,804 --> 00:40:14,720
ასე რომ, საკმაოდ სუფთა.

684
00:40:14,720 --> 00:40:19,420
თქვენ წარმოიდგინეთ, მოძრაობდნენ Mario ერთად
ზოგიერთი ისრიანი ღილაკები ან რამე მაგდაგვარს.

685
00:40:19,420 --> 00:40:22,880
დიახ, X არ იმუშავებს.

686
00:40:22,880 --> 00:40:26,900
>> ასე რომ, საბოლოო ფაილის ჩვენ ვაპირებთ
შევხედოთ, hellow7_mouse.

687
00:40:26,900 --> 00:40:29,600
ეს არის დაახლოებით მიღების მაუსის შეყვანა.

688
00:40:29,600 --> 00:40:34,790
ასე რომ, ამ ერთი, ჩვენ
იმპორტი მათემატიკის header,

689
00:40:34,790 --> 00:40:38,100
იმიტომ, რომ ჩვენ ვაპირებთ აქვს
ცოტა მათემატიკა აქ.

690
00:40:38,100 --> 00:40:45,260
იმავე წლის, იმავე წლის პერსონალი, დანიშნულების,
იმავე წლის, ჩანს, რომ ადრე.

691
00:40:45,260 --> 00:40:46,910
ისე, ეს არის საინტერესო.

692
00:40:46,910 --> 00:40:51,730
ასე რომ, ჩვენ უკან მხოლოდ შემოწმების
იმ SDL დატოვა ღონისძიება.

693
00:40:51,730 --> 00:40:52,460
ეს რატომ?

694
00:40:52,460 --> 00:40:55,110
ასე რომ თქვენ შეგიძლიათ მაუსის შეტანის მოვლენები.

695
00:40:55,110 --> 00:40:57,670
ასე, როდესაც მაუსი გადავიდა,
თქვენ ღონისძიება, რომ.

696
00:40:57,670 --> 00:41:00,520
როდესაც მაუსის ღილაკზე დაჭერის,
თქვენ შეგიძლიათ მიიღოთ ღონისძიება, რომ.

697
00:41:00,520 --> 00:41:05,760
>> მაგრამ არსებობს კიდევ ერთი, ოდნავ მარტივი
ალბათ, API მისაღებად მაუსის შეყვანა.

698
00:41:05,760 --> 00:41:09,500
და ეს უბრალოდ SDL მისაღებად მაუსის სახელმწიფო.

699
00:41:09,500 --> 00:41:14,370
ასე რომ, მე int x და
y კურსორი პოზიცია.

700
00:41:14,370 --> 00:41:18,910
გაივლის მას SDL_GetMouseState,
რომელიც ადგენს ამ.

701
00:41:18,910 --> 00:41:22,200
და ეს არის პოზიცია
საკოორდინატო სისტემაში ფანჯარა.

702
00:41:22,200 --> 00:41:25,520
ასე რომ, თუ მასა ზედა მარცხენა
ფანჯარა, რომ 0, 0.

703
00:41:25,520 --> 00:41:28,040

704
00:41:28,040 --> 00:41:33,380
>> ახლა, რა მე ვაპირებ ამის გაკეთებას, მე ვაპირებ
უნდა გავაკეთოთ ცოტა ვექტორი მათემატიკის.

705
00:41:33,380 --> 00:41:36,910
მე დადებს თქვენ ეგონა, თქვენ არ
ვხედავ, რომ CS50, მაგრამ აქ არის.

706
00:41:36,910 --> 00:41:40,720
მე ვაპირებ დაკავდით ვექტორი
მათემატიკის მისაღებად ვექტორი

707
00:41:40,720 --> 00:41:43,840
იმიჯი კურსორი.

708
00:41:43,840 --> 00:41:53,280
ასე რომ, რატომ მაქვს
ეს გამოკლება აქ?

709
00:41:53,280 --> 00:42:01,350
ისე, თუ უბრალოდ გამოიყენება dest .-- ასე
მე უნდა თარგმნოს მაუსის x

710
00:42:01,350 --> 00:42:05,166
და y ნახევარი სიგანე და
სიმაღლე იმიჯი,

711
00:42:05,166 --> 00:42:08,040
იმიტომ, რომ მინდა ცენტრში
იმიჯი უნდა სვლას მაუსი,

712
00:42:08,040 --> 00:42:10,160
წარმოშობის იმიჯი.

713
00:42:10,160 --> 00:42:15,650
>> ასე რომ, უბრალოდ დარწმუნდით, მე ვსაუბრობ
შესახებ ცენტრში იმიჯი აქ.

714
00:42:15,650 --> 00:42:19,510
ამის შემდეგ მივიღებთ დელტა x და y, რომელიც
არის განსხვავება სამიზნე

715
00:42:19,510 --> 00:42:23,430
ფაქტობრივი პოზიცია იმიჯი.

716
00:42:23,430 --> 00:42:25,690
და მაშინ ჩვენ შეგვიძლია მისაღებად
დისტანცირება აქ,

717
00:42:25,690 --> 00:42:29,140
იქნება პითაგორას
თეორემა, კვადრატული ფესვი x

718
00:42:29,140 --> 00:42:32,720
x + y ჯერ y.

719
00:42:32,720 --> 00:42:38,400
>> ახლა თავიდან ასაცილებლად დაზიანებული, და მე შემიძლია,
თქვენ რა ეს იმას, თუ არ გააკეთებს,

720
00:42:38,400 --> 00:42:45,830
თუ მანძილი კურსორი და
image ცენტრი ხუთზე ნაკლებია,

721
00:42:45,830 --> 00:42:48,730
მე უბრალოდ არ აპირებს გადავიდეს გამოსახულება.

722
00:42:48,730 --> 00:42:52,900
წინააღმდეგ შემთხვევაში, ჩვენ მითითებული სიჩქარე.

723
00:42:52,900 --> 00:42:55,960
და ჩვენ დავსახეთ ისე, რომ
სიჩქარე ყოველთვის იქნება მუდმივი.

724
00:42:55,960 --> 00:42:58,770
და წმინდა შედეგად ყველა
მათემატიკის არის, რომ გამოსახულება

725
00:42:58,770 --> 00:43:01,660
აპირებს სვლა კურსორი.

726
00:43:01,660 --> 00:43:08,470
>> ახლა ირკვევა, რომ
SDL_GetMouseState,

727
00:43:08,470 --> 00:43:14,490
გარდა იმისა, რომ შექმნის
x და y არგუმენტები აქ,

728
00:43:14,490 --> 00:43:21,340
მას ასევე ბრუნდება int, რომელიც შეესაბამება
სახელმწიფო მაუსის ღილაკების.

729
00:43:21,340 --> 00:43:24,600
ამიტომ, ჩვენ ვერ წავიკითხე, რომ
პირდაპირ, მაგრამ შეგვიძლია

730
00:43:24,600 --> 00:43:29,090
გამოიყენოთ ეს macros, ერთი
bitwise ოპერატორი, არ არის, რომ საშინელი,

731
00:43:29,090 --> 00:43:30,650
უბრალოდ bitwise და.

732
00:43:30,650 --> 00:43:38,320
ამიტომ ჩვენ ვამბობთ, ღილაკები, რომელიც არის შედეგი
ჩვენი SDL_GetMouseState, თუ ეს

733
00:43:38,320 --> 00:43:43,990
და bitwise და ამ მაკრო
აქ, SDL_BUTTON_LEFT.

734
00:43:43,990 --> 00:43:47,680
>> ასე რომ, ეს უბრალოდ გადავწყვიტოთ
რომ bitmap, რომელიც შეესაბამება

735
00:43:47,680 --> 00:43:51,090
მარცხენა ღილაკს მიმდინარეობს ზეწოლა.

736
00:43:51,090 --> 00:43:55,470
ასე რომ, თუ bitwise
და ხდება და ეს

737
00:43:55,470 --> 00:43:59,340
ნულოვანი, რაც იმას ნიშნავს,
მარცხენა ღილაკს დაპრესილი,

738
00:43:59,340 --> 00:44:04,320
მაშინ ჩვენ რეალურად აპირებს უარყოფს
ორივე x და y სიჩქარეები,

739
00:44:04,320 --> 00:44:06,700
რომელიც მხოლოდ იმიჯის გაქცეული.

740
00:44:06,700 --> 00:44:07,980
განახლების პოზიციებზე.

741
00:44:07,980 --> 00:44:10,920
შეჯახება გამოვლენის, ჩანს, რომ
ყველა ადრე, გაწევის, ყველა უფლება.

742
00:44:10,920 --> 00:44:11,510
მოდით ეს.

743
00:44:11,510 --> 00:44:14,200

744
00:44:14,200 --> 00:44:16,050
ასე რომ, შენ, რათა SRCS = hello7_mouse.c.

745
00:44:16,050 --> 00:44:21,720

746
00:44:21,720 --> 00:44:22,220
შესანიშნავი.

747
00:44:22,220 --> 00:44:23,490
შეცდომები.

748
00:44:23,490 --> 00:44:24,900
და თამაში.

749
00:44:24,900 --> 00:44:26,440
>> ასე რომ, აქ მაქვს ჩემი მაუსი.

750
00:44:26,440 --> 00:44:29,000
და იმიჯი მართლაც
გატანა ჩემი მაუსი.

751
00:44:29,000 --> 00:44:33,140
ახლა კი, თამაში თქვენ, შესაძლოა,
ეს არის, როგორც მტრის დევნა

752
00:44:33,140 --> 00:44:35,240
თქვენი პატარა ხასიათი ან რასაც.

753
00:44:35,240 --> 00:44:37,440
მაგრამ აქ ჩვენ გვაქვს
სურათი გატანა მაუსის.

754
00:44:37,440 --> 00:44:41,000
და როდესაც მე დააჭირეთ მაუსის
იწყება დევნა იმიჯი

755
00:44:41,000 --> 00:44:42,860
და სურათი არის
გარბიან მაუსი.

756
00:44:42,860 --> 00:44:43,810
ასე რომ, საკმაოდ გრილი.

757
00:44:43,810 --> 00:44:47,770
და შეამჩნია, რომ მიუხედავად
კიდევ შეჯახების აღმოჩენის აქ.

758
00:44:47,770 --> 00:44:53,930
>> ასე რომ, საბოლოო პატარა
დემო მე არ შეიქმნას აქ.

759
00:44:53,930 --> 00:44:58,870
და მოდით შევხედოთ კიდევ ერთი რამ.

760
00:44:58,870 --> 00:45:02,970
ასე რომ, უკან აქ, ვთქვი ეს დაზიანებული.

761
00:45:02,970 --> 00:45:05,000
კარგი.

762
00:45:05,000 --> 00:45:12,890
ასე რომ, თუ მანძილი ნაკლებია, ვიდრე ხუთი პიქსელი,
მე შექმნის x და y სიჩქარე ნულის ტოლია.

763
00:45:12,890 --> 00:45:15,960
რა მოხდება, თუ ჩვენ დავაღწიოთ რომ?

764
00:45:15,960 --> 00:45:19,070
ამიტომ, მე ვაპირებ, რომ მხოლოდ ამის გაკეთება.

765
00:45:19,070 --> 00:45:23,820

766
00:45:23,820 --> 00:45:30,150
გთხოვთ ამართლებს ამ საშინელი სტილი,
მაგრამ ჩვენ კომენტარს out სწორი კოდი.

767
00:45:30,150 --> 00:45:38,080
ამიტომ, მე ვაპირებ გადარჩენა, და გავაკეთოთ
იგივე ბრძანება სანამ, რათა ის.

768
00:45:38,080 --> 00:45:38,785
>> კარგი.

769
00:45:38,785 --> 00:45:39,660
და ახლა რა ხდება?

770
00:45:39,660 --> 00:45:43,260

771
00:45:43,260 --> 00:45:43,760
კარგი.

772
00:45:43,760 --> 00:45:45,801
ჩვენ ჯერ კიდევ შემდეგ
მაუსი, ისევე, როგორც ადრე,

773
00:45:45,801 --> 00:45:49,310
მაგრამ, როდესაც ჩვენ ვიღებთ მაუსი,
ჩვენ მივიღეთ ეს მთლიანი დაზიანებული.

774
00:45:49,310 --> 00:45:50,320
რა ხდება იქ?

775
00:45:50,320 --> 00:45:52,600
ისე, ჩვენი ვექტორი
მათემატიკის, უნდა გვახსოვდეს, რომ იყო

776
00:45:52,600 --> 00:45:57,540
აღების შორის მანძილი
კურსორი და ცენტრში იმიჯი?

777
00:45:57,540 --> 00:46:00,710
ისე, როგორც, რომ უახლოვდება
0, ჩვენ ვიწყებთ მისაღებად

778
00:46:00,710 --> 00:46:06,280
ამ სახის გიჟები ქცევა
სადაც იმიჯი არის ერთგვარი

779
00:46:06,280 --> 00:46:08,910
როგორიცაა მოძრავი გარშემო კურსორი.

780
00:46:08,910 --> 00:46:12,000
და ეს ქმნის ამ დაზიანებული.

781
00:46:12,000 --> 00:46:13,020
და ეს მართლაც მახინჯი.

782
00:46:13,020 --> 00:46:15,103
და თქვენ ალბათ არ
გსურთ თქვენი თამაშები აკეთებს, რომ,

783
00:46:15,103 --> 00:46:17,350
თუ იგი არ არის გარკვეული სპეციალური ეფექტი.

784
00:46:17,350 --> 00:46:21,960
>> ასე რომ, რატომ ჩვენ
მხოლოდ ამ თვითნებურ

785
00:46:21,960 --> 00:46:27,150
შეწყვიტა ხუთ პიქსელი, სადაც ჩვენ ვამბობთ
თუ ის ხუთ პიქსელი, ჩვენ კარგი.

786
00:46:27,150 --> 00:46:29,560
ჩვენ არ უნდა გადავიდეს გამოსახულება აღარ.

787
00:46:29,560 --> 00:46:32,260
ასე რომ, რა ხდება იქ.

788
00:46:32,260 --> 00:46:37,390

789
00:46:37,390 --> 00:46:40,870
>> ასე რომ, საკმაოდ ბევრი იყო.

790
00:46:40,870 --> 00:46:44,390
თქვენ ახლა უკვე იცის თუ როგორ უნდა შექმნათ
ფანჯარა, ჩატვირთვა გამოსახულება,

791
00:46:44,390 --> 00:46:49,330
მიაპყროს გამოსახულების ფანჯარაში, მიიღოს
კლავიატურის შეყვანის, მიიღოს მაუსის შეტანის,

792
00:46:49,330 --> 00:46:52,190
აქ არის რამოდენიმე სხვა
input, რომ თქვენ არ

793
00:46:52,190 --> 00:46:56,070
ვიცი, როგორ უნდა თუ უბრალოდ გაატარონ
რამდენიმე წუთის ეძებს დოკუმენტაცია.

794
00:46:56,070 --> 00:46:59,670
ასე, რომ თქვენ რეალურად საკმაოდ
რამდენიმე ინსტრუმენტები თქვენს განკარგულებაშია ახლა

795
00:46:59,670 --> 00:47:01,650
დაწერა სრულფასოვანი თამაში.

796
00:47:01,650 --> 00:47:05,030
>> ახლა, ყოველ თამაში საჭიროებს აუდიო,
მაგრამ აუდიო დოკუმენტაცია

797
00:47:05,030 --> 00:47:06,460
ასევე საკმაოდ კარგი.

798
00:47:06,460 --> 00:47:09,200
და მე ვარ სურვილი, რომ დადებს, რომ თუ
თქვენ იცით, ყველა რამ,

799
00:47:09,200 --> 00:47:14,560
ჩვენ ვისაუბრეთ დღეს
სურათები, და ზედაპირზე,

800
00:47:14,560 --> 00:47:18,370
ფანჯრები, და ყველაფერი, მაშინ
მჭიდროდაა out აუდიო API არ არის

801
00:47:18,370 --> 00:47:21,170
იქნება, რომ ცუდია.

802
00:47:21,170 --> 00:47:27,420
ასე რომ, მე მჯერა, რომ ხედავს
ის, რაც თქვენ შექმნათ SDL.

803
00:47:27,420 --> 00:47:31,595