โธมัส LIVELY สิทธิทั้งหมด
สวัสดีทุกคน.
ฉันโทมัสมีชีวิตชีวา
งานสัมมนาครั้งนี้เป็นไปได้ การเขียนเกม 2D ใน C ใช้ SDL
ดังนั้นผมจึงรู้ว่าคุณกำลังทั้งหมด ถามว่าใช่ฉันจริงๆ
ต้องการที่จะเล่นเกมและทำให้เกม แต่สิ่งที่เป็นธุรกิจนี้ SDL?
ดังนั้น SDL เป็นห้องสมุด C
มันหมายถึงง่าย DirectMedia ชั้น
และมันเป็นข้ามแพลตฟอร์ม ห้องสมุดพัฒนาเกม
มันทำงานบน Windows, Mac, ลินุกซ์แม้ iOS และ Android
สามารถจัดการกับสิ่งที่ชอบ การเข้าถึงระบบเสียง
สำหรับเครื่องคอมพิวเตอร์แป้นพิมพ์และ เมาส์จอยสติ๊กถ้าพวกเขากำลังแนบ
ในมือถือก็ยังสามารถทำ สัมผัสการป้อนข้อมูลและทุกที่
และแน่นอนที่จะจัดการกับกราฟิก การวาดภาพสิ่งที่หน้าจอ
>> ดังนั้นจึงใช้กันอย่างแพร่หลายมากแม้ว่า คุณอาจไม่เคยได้ยินมาก่อน
มันสร้างขึ้นในยกตัวอย่างเช่น เครื่องยนต์แหล่งวาล์ว
ซึ่งเกมอำนาจเช่น Portal และ Team Fortress 2
มันยังอยู่ในจำนวนมาก ของเกมอินดี้ที่ออกมา
ดังนั้นฉันตื่นเต้นที่จะได้เห็นสิ่งที่คุณ ทั้งหมดจะทำกับมัน
>> เป้าหมายการสัมมนาจะได้รับคุณ ออกไปได้รับการพัฒนาด้วย SDL
เรากำลังจะไปเรียนรู้วิธีการ เพื่อสร้างหน้าต่างเกม
เรากำลังจะสร้างสไปรท์, ซึ่งเป็นภาพในเกมของคุณ
ที่สามารถย้ายไปรอบ ๆ
เรากำลังจะไปเรียนรู้วิธีการ และสไปรท์เคลื่อนไหวที่
เพื่อย้ายไปรอบ ๆ ให้ พวกเขาเปลี่ยนแปลงตลอดเวลา
และเรากำลังจะไปเรียนรู้วิธีการ ในการจับภาพแป้นพิมพ์และเมาส์
ข้อมูลจากคอมพิวเตอร์
สิ่งที่เราจะไม่ได้รับการพูดคุย เกี่ยวกับวันนี้เป็นกราฟิก 3D
เพราะเห็นว่าเป็นความซับซ้อนมาก เรื่องที่เราไม่ได้มีเวลาสำหรับ
เราจะไม่เรียนรู้วิธีการ เล่นเสียงในเกมของเรา
และเราจะไม่ได้รับการสร้าง แต่สำหรับสิ่งที่ลินุกซ์
>> ตอนนี้ caveats มีว่า หวังว่าภายในสิ้นการสัมมนา
คุณจะสะดวกสบายกับ เอกสาร SDL,
ดังนั้นคุณจะสามารถที่จะไปคิดออก วิธีการเล่นเสียงสำหรับตัวคุณเอง
นอกจากนี้ยังมีอาคารสำหรับ Mac หรือ PC ควรจะทำงาน เหมือนกับอาคารสำหรับลินุกซ์
แต่การติดตั้งเป็นไป จะแตกต่างกันเล็กน้อย
ดังนั้นคุณควรจะสามารถที่จะคิด วิธีการที่จะทำสิ่งเหล่านี้
ในตอนท้ายของการสัมมนาในวันนี้
>> ดังนั้นสำหรับการตั้งค่าที่เรากำลังจะ ที่จะใช้เครื่องเสมือน
เราจะใช้ IDE CS50 เพราะ เราเพียงแค่จะต้องเขียนใน C.
แต่เนื่องจาก IDE ไม่ได้เป็นเบราว์เซอร์ที่เรา ไม่สามารถสร้างหน้าต่างใหม่หรือการแสดงผล
กราฟิกในนั้น
ดังนั้นเราจึงจำเป็นต้องใช้เครื่องเสมือน
เพื่อให้คุณสามารถปฏิบัติตามคำแนะนำ ที่นี่ที่ manual.CS50.net/appliance/15
การติดตั้งเครื่อง CS50 อย่างเป็นทางการ ซึ่งเป็นเพียงเสมือนลินุกซ์
เครื่อง
>> และจากนั้นเมื่อคุณมี ที่ตั้งทั้งหมด up-- มัน
อาจใช้เวลาสักครู่เพราะ download-- ขนาดใหญ่มากที่คุณจะ
การทำงานใน VM ปรับปรุง sudo apt-get
และที่จะจริงๆ ในการปรับปรุงซอฟต์แวร์ทั้งหมด
แพคเกจในเครื่องเสมือนของคุณ
>> หลังจากนั้นคุณกำลังจะไปทำงาน sudo apt-get ติดตั้ง libsdl2-2.0-0,
libsdl2-DBG, libsdl2-dev และ นอกจากนี้ libsdl2-ภาพ 2.0-0,
libsdl2 ภาพ-DBG, และ libsdl2 ภาพ-dev
ดังนั้นสิ่งที่จะทำอย่างไร
นั่นเป็นเพียงการแก้ปัญหาการติดตั้ง ข้อมูลเอกสารส่วนหัว
และไบนารีสำหรับสองห้องสมุด
ปกติเก่า SDL 2.0 และห้องสมุดอีก
เรียกว่าภาพ SDL ซึ่ง เราจะต้องใช้
ในการโหลดไฟล์ภาพในเกมของเรา
>> ดังนั้นเมื่อคุณมีที่ยัง ที่เพียงแค่เมื่อมันถามว่า
คุณเพียงแค่พิมพ์ใช่กด Enter การติดตั้งแพคเกจเหล่านั้น
แล้วคุณควรจะดีไป
เพื่อที่จะได้รับรหัสการกระจายคุณ can-- โอ้รักนี้จะไม่มีการปรับปรุง
ถ้าคุณมี GitHub account-- ถ้าคุณมีบัญชี GitHub,
คุณสามารถทำ Git นี้ คำสั่งโคลนที่จะซื้อคืน
และที่จะดาวน์โหลด Git repo กับทุกรหัสในนั้น
เพื่อที่คุณจะมีรหัส
>> หากคุณไม่ได้มี GitHub บัญชีสิ่งที่คุณควรทำคือการพิมพ์
wgithttps: //github.com/tlively/sdl seminar-- และนี่ก็เป็น different--
/archive/master.zip
ดังนั้นอีกครั้งที่เดียวกันแน่นอน URL, ยกเว้นว่ามันจะเป็นไปได้
tlively / SDL_seminar / master.zip และ คุณกำลังใช้ wgit ดาวน์โหลดที่
และจากนั้นคุณสามารถเพียง เปิดเครื่องรูดเก็บที่
แล้วคุณจะมี ทุกรหัสแหล่งที่มา
ดังนั้นขออภัยเกี่ยวกับที่
และแล้วรหัสนอกจากนี้ยังจะเป็นเจ้าภาพที่ หน้าเว็บสัมมนา CS50 ในคู่
วัน
>> ทั้งหมดขวา
ดังนั้นวิธีที่เราจะเริ่มต้น การเขียนเกมของเราเอง?
ดีสิ่งแรก เรากำลังจะต้องการที่จะทำ
จะดูเอกสาร SDL
ดังนั้นนี่คือที่ VM
และนี่คือหน้าเว็บ
ผมเคยสำรวจจะมีชีวิตอยู่ libsdl.org
สิ่งที่ฉันจะทำนี่คือไปกว่า แถบด้านข้างภายใต้เอกสาร
และคลิกที่วิกิพีเดีย
นี้จะนำฉันไปที่วิกิพีเดียที่ว่า มีมากที่สุดของเอกสารสำหรับ SDL
กว่าในแถบด้านข้างที่นี่เรา ไปคลิก API ตามหมวดหมู่
เพราะเป็นไปเพื่อให้ เรามีมุมมองที่ดีเด็ดขาด
ของทั้ง API สำหรับการ SDL
>> ดังนั้นสำหรับตัวอย่างเช่นเรามี การเริ่มต้นขั้นพื้นฐาน
และปิดทั้งหมดการเรียงลำดับของ สิ่งที่ใช้ในการบริหารสำหรับ SDL,
และแล้วเราก็มีส่วนในการ แสดงสิ่งที่หน้าจอ
นั่นเป็นวิดีโอ
เหตุการณ์การป้อนข้อมูลที่ได้รับ การป้อนข้อมูลจากแป้นพิมพ์
ได้รับข้อมูลจากเมาส์และ จอยสติ๊กถ้าคุณมีมันมาก
มีข้อเสนอแนะที่มีผลบังคับใช้สำหรับสิ่งที่ เช่นตัวควบคุมเกมซึ่ง
เราจะไม่พูดคุยเกี่ยวกับ
และนี่คือเสียง
แล้วมีพวงของอื่น ๆ สิ่งที่ SDL สามารถทำเพื่อคุณ
>> แต่วันนี้เรากำลังจะมุ่งเน้น ในการเริ่มต้นที่นี่
การแสดงภาพในวิดีโอ ส่วนเหตุการณ์ที่เกิดขึ้นและการจัดการการป้อนข้อมูล
ดังนั้นเหล่านี้เป็นหลัก ในส่วนของเอกสาร
ที่คุณควรจะกังวลเกี่ยวกับ
เพียงเพื่อความสนุกสนานถ้าเราไปมากกว่า ที่นี่และคลิกที่ API โดยใช้ชื่อ
เราสามารถมองเห็นรายชื่อของทุกคน สิ่งเดียวในห้องสมุด SDL
ดังนั้นฟังก์ชั่นเหล่านี้ enumerations, โครงสร้างเป็นจำนวนเงินที่บ้าของสิ่งที่
เลขอนุกรม
และเห็นได้ชัดจน คุณรู้ว่าคุณกำลังทำ
นี้จะไม่ให้เป็นประโยชน์มากเกินไป ซึ่งเป็นเหตุผลที่เราทำ API ตามหมวดหมู่
>> ดังนั้นขอเริ่มต้น
หวังว่าคุณได้อยู่แล้ว ดาวน์โหลดรหัสกระจาย
และเพื่อให้สิ่งที่คุณสามารถทำได้คือขวา ที่นี่ในเครื่อง CS50,
เพียงแค่เปิดสถานี
ไปเลย.
ดังนั้นผมจึงได้ดาวน์โหลดแล้ว รหัสการกระจายการใช้ซิป
วิธี.
และฉันได้ซิปมัน
ดังนั้นที่นี่มันมีอยู่ในการสัมมนาหลัก SDL
ดังนั้นฉันจะไปลงในไดเรกทอรีที่
และสิ่งที่เราเห็นที่นี่เป็น ที่เรามีเจ็ดไฟล์ C
และนี่เป็นไปรหัส เรากำลังจะได้รับการมองหาที่ในวันนี้
เรามี Makefile
และเรามีไดเรกทอรีทรัพยากร ซึ่งก็มีภาพ
ที่คุณจะได้เห็นเร็วพอ
>> ดังนั้นขอเปิดไฟล์เหล่านี้ โดยใช้โปรแกรมแก้ไข G-แก้ไข
ดังนั้นผมจึงต้องการที่จะเปิดแฟ้มทั้งหมดที่ เริ่มต้นด้วยการทักทายและจบด้วย .c
ไปเลย.
เพื่อให้เป็นหน้าต่างเล็ก ๆ ดังนั้นเรา จะพยายามที่จะทำให้มันมีขนาดใหญ่กว่า
ไม่มีก็กลับออกไป
>> ทั้งหมดขวา
ดังนั้นที่นี่เป็นครั้งแรก ไฟล์ที่เรากำลังจะไปดูที่
มันเรียกว่า hello1_sdl.c
และทั้งหมดนี้ก็คือเริ่มต้น SDL ห้องสมุดเพื่อให้เราสามารถเริ่มใช้มัน
วิธีที่คุณจะได้รู้ว่าจะมา ขึ้นด้วยรหัสคุณหรือไม่
ดีถ้าเรามองข้าม ที่เอกสาร
และเราไปสู่​​การเริ่มต้น และปิดส่วน
ก็จะบอกให้เราทราบ เกี่ยวกับวิธีการเริ่มต้น SDL
ดังนั้นแน่นอนอ่านบางเวลาอื่น ๆ
มันจะบอกคุณทั้งหมด เกี่ยวกับสิ่งที่เกิดขึ้นที่นี่
แต่ปมหลักของเรื่องคือ เราจำเป็นต้องเรียก SDL ฟังก์ชันนี้ในนั้น
และผ่านมันสิ่งที่ชนิดของสิ่งที่ เราต้องการให้ห้องสมุดในการเริ่มต้น
ดังนั้นในกรณีที่เรากำลังจะ ในการเริ่มต้นวิดีโอสำหรับตอนนี้
เพื่อให้เราสามารถเริ่มต้นการแสดงภาพ
>> มากกว่าที่นี่คุณสามารถดูว่า เราคลิกที่ SDL ในมันเรา
จะได้รับข้อมูลมากยิ่งขึ้น รวมทั้งค่าตอบแทน
ดังนั้นเราจึงเห็นว่า returnes ศูนย์ความสำเร็จ
ดังนั้นในรหัสของเราที่เรากำลังจะไป ดูว่ามันจะไม่กลับมาเป็นศูนย์
และถ้ามันไม่ได้กลับ ศูนย์ดังนั้นมันก็ไม่ประสบความสำเร็จ
แล้วเรากำลังจะไปเพียงแค่พิมพ์ ข้อผิดพลาดนี้โดยใช้ฟังก์ชั่นอื่น ๆ
SDL ได้รับข้อผิดพลาดที่ส่งกลับสตริง อธิบายข้อผิดพลาดที่เกิดขึ้น
เรากำลังจะไปพิมพ์ที่ ข้อผิดพลาดแล้วเราเพียงแค่
จะออกจากโปรแกรม ด้วยรหัสข้อผิดพลาด
>> แล้วสิ่งที่เราต้องการอีก ที่จะทำคือก่อนที่จะออกจากโปรแกรม
ถ้าเราเริ่มต้นได้ประสบความสำเร็จใน SDL, เราก็ต้องเรียกว่า SDL เลิก
และที่จะจัดการกับการทำความสะอาด ทั้งหมดของทรัพยากรภายใน SDL สำหรับเรา
ดังนั้นเอกสารอีกครั้ง there--, ที่นี่เราอยู่ในการเริ่มต้น
และปิดส่วน ของเอกสาร
คุณก็สามารถคลิกที่ ฟังก์ชั่นที่นี่ SDL เลิก
และคุณสามารถอ่านข้อมูลเกี่ยวกับการที่ดี
และจำนวนมากของฟังก์ชั่นเหล่านี้ หน้าเอกสาร
มีรหัสตัวอย่างดังนั้นนี้ เป็นทรัพยากรที่ดีมาก
แน่นอนใช้เวลาบางส่วน อ่านส่วนของวิกิพีเดียนี้
ถ้าคุณกำลังจะทำ นี้สำหรับโครงการ
>> ทั้งหมดขวา
เพื่อให้เป็นโปรแกรมทั้งหมดของเรา
สิ่งที่เราสามารถทำได้ตอนนี้ is-- ฉัน จะเปิด Makefile ที่นี่
ดังนั้นฉันจะใช้เวลา ดูที่วิธีการที่ทำงาน
และมันเป็น makefile ที่ง่ายมาก คล้ายกับสิ่งที่คุณเคยเห็นมาก่อน
หนึ่งในความแตกต่างหลัก คือว่านี่นี้
เป็นไปแทรกผลมาจากการทำงาน คำสั่งนี้ที่คุณได้อยู่แล้ว
การติดตั้งถ้าคุณได้ติดตั้ง SDL
และนี่คือคำสั่ง ที่เกิดขึ้นในการสร้าง
บางธงพิเศษสำหรับคอมไพเลอร์
>> นอกจากนั้นเราจะให้มัน ทุกคำสั่งตามปกติเช่นเดียวกับ
ทั้งสองคำสั่ง
ดังนั้น -lsdl2 จับภาพ การเชื่อมโยงในห้องสมุดภาพ SDL
และ -lm จริงจัดการการเชื่อมโยง ในมาตรฐานห้องสมุดคณิตศาสตร์ C
ดังนั้นเราจะไม่ได้ไปต้อง เหล่านั้นสำหรับทุกไฟล์ C ของเรา
แต่เราเพียงแค่ใส่ไว้ในเพื่อที่เราจะสามารถทำได้ ใช้ Makefile เดียวกันสำหรับทุกอย่าง
โดยไม่ต้องแก้ไข
>> กว่าที่นี่ในแหล่งที่มา นี่คือที่ที่คุณต้องการ
ใส่ไฟล์ที่คุณกำลังจะ เพื่อรวบรวมสำหรับโครงการของคุณ
แต่เนื่องจากทุกคนของฉัน C ไฟล์ที่นี่มีฟังก์ชั่นหลัก
ก็จะได้รับสับสน ถ้าเราใส่พวกเขาทั้งหมดใน
ดังนั้นฉันจะเพียงแค่พูดว่า สำหรับตอนนี้ hello1_sdl.c,
ซึ่งเป็นหนึ่งในที่เราเพียงแค่มองไปที่
ดังนั้นถ้าผมกลับไปมากกว่า ที่นี่ผมไม่สามารถทำให้
และสิ่งที่มันไม่ได้เป็นเพียง ที่รวบรวมไฟล์แรก
และจากนั้นเราสามารถพิมพ์ ./game เพราะ มันเป็นปฏิบัติการมันผลิต
และทั้งหมดก็ไม่ได้พิมพ์ เริ่มต้นที่ประสบความสำเร็จ
ดังนั้นเราทำสิ่งที่ถูกต้อง
แต่นั่นก็เป็นชนิดของน่าเบื่อ เพราะเราไม่เห็นหน้าต่าง
ไม่มีอะไรย้ายไปรอบ ๆ
>> ดังนั้นที่ดีที่เราได้เริ่มต้น SDL
ตอนนี้ขอย้ายไปยังบางสิ่งบางอย่าง เล็ก ๆ น้อย ๆ ที่น่าสนใจมากขึ้น
ดังนั้นที่นี่เรามี hello2_window.c และ นี้เป็นไปได้มากขึ้นเล็กน้อย
โปรแกรม C ที่ซับซ้อนที่ เริ่มต้น SDL เช่นเดียวกับก่อน
ยกเว้นตอนนี้เรายังจะ ในการเริ่มต้นจับเวลา SDL
และสิ่งนี้เป็นไปเพื่อให้เรา เข้าถึงจับเวลาภายใน
ฟังก์ชั่นการใช้งานและที่เกี่ยวกับเวลา
>> และจากนั้นให้ดูที่นี่
สิ่งที่เราทำคือเรามีตัวชี้นี้ ไปยัง struct หน้าต่าง SDL ซึ่ง
กำลังจะถูกสร้างขึ้นโดยสายนี้ ฟังก์ชั่นที่ SDL สร้างหน้าต่าง
ตอนนี้จะใช้เวลามากของการขัดแย้งที่ จึงขอไปดูเอกสาร
ดังนั้นอีกครั้งฉันจะ API ตามประเภทฉัน
จะลงไปวิดีโอที่นี่และครั้งแรก ส่วนการจัดการการแสดงหน้าต่าง
ดังนั้นส่วนนี้มี ตันของสิ่งที่อยู่ในมัน
แต่ถ้าคุณมองผ่าน ฟังก์ชั่นเหล่านี้คุณจะ
เห็นว่าน่าจะเป็นที่หนึ่งที่เรา ต้องการที่จะเรียกว่า SDL สร้างหน้าต่าง
ที่เกิดขึ้นจะเป็นสิทธิที่ด้านบน
>> ดังนั้นนี่คือ เอกสารสำหรับฟังก์ชั่นนี้
หน้าต่างจะมีชื่อเรื่อง เอ็กซ์วายและตำแหน่งบนหน้าจอ
มันจะมีความกว้างความสูงที่ และจากนั้นก็จะใช้เวลาบางธง
ตอนนี้เราไม่ได้เป็นผู้ดูแลเกี่ยวกับ ใด ๆ ของธงเหล่านี้ได้ในขณะนี้
แต่ถ้าคุณอยากจะทำอะไร เช่นทำให้หน้าต่างแบบเต็มหน้าจอ
คุณสามารถดูที่ว่า
สำหรับตอนนี้เรากำลังจะ ที่จะใช้ค่าพิเศษเหล่านี้
หน้าต่าง SDL บวกศูนย์กลาง สำหรับ x และ y ในการสั่งซื้อ
เพียงแค่สร้างหน้าต่าง ในใจกลางของหน้าจอของเรา
>> เพื่อให้เป็นสิ่งที่ทำ
และถ้าหน้าต่างที่จะเกิดขึ้น null หมายถึงมีข้อผิดพลาด
แล้วอีกครั้งที่เรากำลังจะ พิมพ์ข้อผิดพลาดโดยใช้ข้อผิดพลาดได้รับ SDL
และจากนั้นก็เพราะเราเริ่มต้นได้ SDL ตอนนี้เราจำเป็นที่จะต้องปิด
ดังนั้นเราจึงเรียก SDL ลาออกก่อน กลับหนึ่งสำหรับหลัก
>> ดังนั้นเราจึงมีการเปิดหน้าต่างนี้หวังว่า
และสิ่งที่เรากำลังจะไป ทำคือการที่เรากำลังจะ
ที่จะเรียก SDL 5,000 มิลลิวินาที ซึ่งเป็นเช่นเดียวกับห้าวินาที
และเมื่อเรากำลังทำกับที่ มันจะทำลายหน้าต่าง
ทำความสะอาดห้​​องสมุด SDL, และออกจากโปรแกรม
ถ้าอย่างนั้นเราไปข้างหน้าและให้ที่ยิง
>> ดังนั้นตอนนี้แทนการเปลี่ยนแปลง Makefile ทุกครั้ง
ฉันก็ไม่สามารถทำและ จากนั้นในบรรทัดคำสั่ง
บอกแหล่งที่มาเท่ากับแล้ว ไฟล์ที่เรากำลังรวบรวม
ดังนั้นจึงเป็น hello2_window.c
ที่ยอดเยี่ยม
ไม่มี erros
ตอนนี้ถ้าเราทำงานที่ปฏิบัติการของเรา เราจะเห็นหน้าต่างนี้
ขณะนี้มีไม่กี่ ปัญหาเกี่ยวกับหน้าต่าง
เราสามารถย้ายไปรอบ ๆ แต่มันก็มี ขยะพื้นหลังนี้ภายในของมัน
ดังนั้นเราจึงยังไม่ได้วาด อะไรและดังนั้นจึงเป็นเรื่อง
เพียงเต็มไปด้วยขยะซึ่ง สวยมากสิ่งที่เราคาดหวัง
>> นอกจากนี้เราไม่สามารถปิดหน้าต่าง
ฉันกดปุ่ม X ที่นี้ และมุมที่เกิดขึ้นไม่มีอะไร
ดังนั้นเราจะเห็นว่าในการแก้ไขปัญหา ว่าในนิด ๆ หน่อย ๆ
ดังนั้นขอแก้ไขส่วนที่ หน้าต่างที่เต็มไปด้วยขยะแรก
ดังนั้นถ้าเราไปมากกว่าที่จะ hello3_image.c สิ่งที่ เราสามารถมองเห็นคือการที่เราได้เพิ่มไม่กี่
สิ่งที่เพิ่มเติมได้ที่นี่
เราได้เพิ่มหัวใหม่นี้ แฟ้มที่จะได้รับฟังก์ชั่นจับเวลา
ผมคิดว่าเราไม่ว่าในที่ผ่านมา อย่างใดอย่างหนึ่งมากเกินไปและผมไม่ได้พูดถึงมัน
แต่ตอนนี้เพราะเรา การทำงานร่วมกับภาพ
เราต้องรวม SDL ไฟล์ส่วนหัวภาพได้เป็นอย่างดี
ดังนั้นจึงเป็นสิ่งเดียวกับที่ ก่อนที่จะเริ่มต้น SDL นี่
ข้อตกลงเดียวกันกับการสร้างหน้าต่าง
เราได้เห็นว่าก่อนหน้านี้
>> ตอนนี้เราต้องสร้างสิ่งที่เรียกว่า โหมดแสดงภาพซึ่งการจัดเรียงของไปพร้อม
กับหน้าต่าง
แต่มันก็เรียงลำดับของ วัตถุที่เป็นนามธรรม
ในค่าใช้จ่ายในการดำเนินการทั้งหมดเหล่านี้ การวาดภาพการดำเนินงานไปที่หน้าต่าง
และเป็นจริงสอดคล้อง โปรแกรมโหลด
ลงในฮาร์ดแวร์กราฟิกในของคุณ คอมพิวเตอร์หรือโทรศัพท์ของคุณหรืออะไรก็ตาม
ดังนั้นธงที่เราต้องการที่จะผ่าน it-- และคุณสามารถดูเอกสาร
ที่จะได้รับรายละเอียด here-- จะ จะได้รับการเรนเดเร่ง SDL ซึ่ง
หมายความว่ามันเป็นไปได้ โดยใช้ฮาร์ดแวร์กราฟิก
และเทิดทูนไม่เพียงแค่ในซอฟแวร์
>> และเรากำลังจะใช้ SDL renderer PRESENTVSYNC
VSync เป็นสิ่งที่เพียงแค่ทำให้ กราฟิกของคุณดูดีขึ้นและป้องกัน
สิ่งที่เรียกว่าหน้าจอ ความหวาดกลัวที่ครึ่งหนึ่ง
ของกรอบและครึ่งหนึ่งของต่อไป ได้รับการวาดกรอบในเวลาเดียวกัน
และมันก็ดูน่ากลัว
แต่อีกครั้งคุณสามารถไปอ่าน เกี่ยวกับการที่ตัวคุณเอง
>> ดังนั้นเราจึงมีธงบางอย่างที่นี่
และเพื่อให้เราเพียงแค่จะเรียก SDL ฟังก์ชันนี้สร้าง renderer
เรากำลังจะให้หน้าต่าง เพื่อเชื่อมโยงกับที่แสดงผล
หนึ่งในเชิงลบหมายความว่าเราไม่สนใจสิ่งที่ ไดรเวอร์กราฟิกที่เรากำลังจะใช้
ดังนั้นควรที่สวยมาก มักจะเป็นหนึ่งในเชิงลบ
จนกว่าคุณจะรู้เกี่ยวกับโปรแกรมควบคุมกราฟิก
และจากนั้นเรากำลังจะ ที่จะผ่านมันธงของเรา
ดังนั้นหากที่ส่งกลับโมฆะแล้วเรา จะพิมพ์ข้อผิดพลาดตามปกติ
แต่แล้วเรายังจะ ที่จะทำลายหน้าต่าง
ในการทำความสะอาดทรัพยากรเหล่านั้นก่อน เรียก SDL เลิกและกลับ
>> ตอนนี้ส่วนที่น่าสนใจที่นี่ เป็นที่ที่เราโหลดภาพของเรา
โดยใช้ฟังก์ชั่นนี้ IMG_load
นี้เป็นฟังก์ชั่นเดียวที่เรากำลังจะไป ที่จะใช้จากห้องสมุดภาพ SDL
มันเป็นเพียงคนเดียวที่เราต้องการ
มันเป็นฟังก์ชั่นที่ใช้เวลาสตริง ที่เป็นเส้นทางของทรัพยากรภาพใด ๆ
และจะสามารถ .png เป็น GIF, บิตแมปใด ๆ ของสิ่งเหล่านี้
และนั่นเป็นเหตุผลที่ฟังก์ชั่นนี้เป็นสิ่งที่ดีดังนั้น
มันสามารถจัดการสวยมากรูปแบบใด ๆ
โหลดลงในหน่วยความจำและเก็บไว้ เป็นสิ่งที่เรียกว่าผิว SDL
>> ตอนนี้พื้นผิว SDL เป็นเพียง struct ที่แสดงถึงข้อมูลภาพในความทรงจำ
เพื่อให้คุณสามารถอ่านเพิ่มเติมเกี่ยวกับ ว่าในเอกสารที่สอง
และถ้าข้อผิดพลาดนี้แล้วเรา จะทำสิ่งที่ทั้งที่
เราพิมพ์ข้อผิดพลาดของเราปิด ทรัพยากรและจากนั้นออกจากโปรแกรม
ตอนนี้สิ่งที่น่าสนใจคือก่อน เราสามารถวาดภาพนี้ไปที่หน้าต่าง
เราต้องทำให้มันเป็นจริงเนื้อ
ตอนนี้เนื้อสอดคล้อง เพื่อโหลดข้อมูลภาพ
ในหน่วยความจำกราฟิกของฮาร์ดแวร์ของ
>> ดังนั้นพื้นผิวที่อยู่ในหลัก หน่วยความจำหน่วยความจำปกติ
ที่เราได้รับการใช้ภาคการศึกษาทั้งหมด และพื้นผิวที่อยู่ในนี้แยกต่างหาก VRAM
หน่วยความจำที่ควบคุมกราฟิกการ์ด
ดังนั้นเราจึงเรียกใช้ฟังก์ชันนี้ SDL_CreateTextureFromSurface
เราจะให้มันแสดงผลและพื้นผิวของเรา
และจากนั้นเรากำลังจริง ทำกับพื้นผิว
ดังนั้นเราก็จะเป็นอิสระ
เราไม่จำเป็นอีกต่อไป
และแล้วดังนั้นถ้าสายนี้ errored และกลับโมฆะ
แล้วเรากำลังจะทำทั้ง สิ่งที่รายงานข้อผิดพลาดอีกครั้ง
>> ทั้งหมดขวา
ที่นี่เราจะได้เป็นบางส่วน ฟังก์ชั่นการแสดงผลที่เกิดขึ้นจริง
ดังนั้นการเรียก SDL_RenderClear และผ่านมัน
แสดงผลที่เกี่ยวข้องกับหน้าต่างของเรา ก็ทำให้หน้าต่างสีดำ
ดังนั้นจึงเอาว่าขยะที่เราเห็นใน หน้าต่างของเราก่อนและทำให้มันเป็นสีดำ
และจากนั้นเรากำลังจะ ที่จะเรียก SDL_RenderCopy,
ให้แสดงผลของเราเนื้อของเรา
และเราจะพูดคุยเกี่ยวกับสิ่งที่ เขตข้อมูลเหล่านี้อยู่ในบิต
แต่ที่เป็นไปได้ นำข้อมูลพื้นผิว
และคัดลอกลงบนของเรา หน้าต่างการวาดภาพ
ดังนั้นหลังจากที่เราได้ทำสำเนานี้ ข้อมูลบนหน้าต่างของเรา
เราจะต้องทำเช่นนี้ฟังก์ชั่นพิเศษ เรียกว่า SDL_RenderPresent
>> และนี่คือที่น่าสนใจ เพราะนี้ได้รับ
ในหัวข้อที่เรียกว่าบัฟเฟอร์คู่
ดังนั้นบัฟเฟอร์คู่เป็นเทคนิคที่ ทำให้กราฟิกของคุณดูดีขึ้นมาก
อีกครั้งก็จะช่วยป้องกันการฉีกขาดที่หน้าจอ ผมได้พูดคุยเกี่ยวกับก่อนหน้านี้ที่
คุณมีสองบัฟเฟอร์
มีบัฟเฟอร์กลับมาอยู่ในเรื่อง หน่วยความจำและกันชนด้านหน้า
บัฟเฟอร์ด้านหน้าเป็นอักษร สิ่งที่อยู่บนหน้าจอของคุณในขณะนี้
ดังนั้นเราจึงทำสิ่งเหล่านี้วาดรูปแบบ เช่น SDL ทำให้สำเนาหรือ SDL_RenderClear
กับกันชนหลัง
ดังนั้นพวกเขาจึงปรับเปลี่ยนสิ่งที่ ในบัฟเฟอร์กลับ
ที่นี่เราอาจจะมีการวาดภาพนี้ สี่เหลี่ยมสีเขียวกับกันชนหลัง
>> ดังนั้นแล้วเมื่อเราทำเสร็จแล้ว ทำให้การดำเนินงานของเราซึ่ง
อาจใช้เวลานานจริงๆ เวลาสิ่งที่เรากำลังจะทำ
มีการสลับบัฟเฟอร์
ดังนั้นมันอย่างแท้จริงเพียงแค่ใช้เวลา กันชนหน้าและกันชนหลัง
สวิทช์และพวกเขาดังนั้น ที่ทันที
ในการดำเนินการอย่างใดอย่างหนึ่งแทน อาจจะหลายร้อยหรือหลายพัน
ทั้งหมดของการแสดงผลใหม่ของเรา วัตถุที่อยู่บนหน้าจอ
และป้องกันไม่ให้สิ่งนี้ เช่นหน้าจอสดชื่น
เมื่อเราได้วาดเพียงครึ่งหนึ่ง ของวัตถุของเราสำหรับกรอบ
ดังนั้นที่ว่าทำไมเราต้องเรียก SDL_RenderPresent เช่นเดียว
เป็น SDL_RenderCopy
>> อีกครั้งที่เรากำลังจะ ที่จะรอห้าวินาที
แล้วเรากำลังจะไป ทำความสะอาดทรัพยากรของเรา
เรามีค่อนข้างน้อยมากขึ้นในเวลานี้
และจากนั้นเรากำลังจะ เพื่อออกจากโปรแกรม
ดังนั้นขอให้ทำอย่างนั้น
ฉันจะพิมพ์ให้แล้วแหล่งที่มา เท่ากับ hello-- นี้คือตอนนี้ 3image.c
สิทธิทั้งหมดที่รวบรวมไม่มีข้อผิดพลาด
และคุณสามารถดูที่นี่ฉันได้ในขณะนี้ ดึงออกมาภาพของฉันสวัสดี CS50!
ไปที่หน้าต่างของเราที่ หายไปหลังจากห้าวินาที
>> ตอนนี้ยังมีปัญหาใช่มั้ย?
นี้ไม่ได้เป็นแอพลิเคชันที่ดี เพราะเมื่อฉันพยายามที่จะปิดหน้าต่าง
ไม่มีอะไรเกิดขึ้น.
ที่ x ยังไม่ตอบสนอง
ดังนั้นลองมาดูที่ที่ ไฟล์ต่อไป, hello4animation
ดังนั้นนี่คือไฟล์ ที่จะแนะนำ
การเคลื่อนย้ายและการเคลื่อนไหวไปที่ภาพของเรา
ดังนั้นเรากำลังจะทำ สิ่งเดียวกับก่อน
เริ่มต้น SDL สร้าง หน้าต่างสร้าง renderer ที่
โหลดภาพลงใน หน่วยความจำในการสร้างพื้นผิว
เราได้เห็นทุกที่ก่อน
ตอนนี้เป็นของใหม่
เรากำลังจะมีโครงสร้างที่เรียกว่า ดูแลรักษา SDL ซึ่งเป็นเพียงรูปสี่เหลี่ยมผืนผ้า
ถ้าเราไปมากกว่าที่นี่เราสามารถ จะค้นหาสำหรับดูแลรักษา SDL,
และคุณสามารถเห็นมันเป็น โครงสร้างที่เรียบง่ายมาก
มันมี x, y สำหรับ ตำแหน่งและมัน
มีความกว้างและความสูงสำหรับ ขนาดของสี่เหลี่ยม
>> ดังนั้นสิ่งที่เรากำลังจะทำคือเรา จะกำหนดปลายทางดูแลรักษา SDL นี้
สำหรับปลายทาง
และนี่เป็นสถานที่ที่ บนหน้าจอที่
เรากำลังจะได้รับการวาดภาพ ภาพของเราที่เหมาะสมดังนั้น
ถ้าเรากำลังจะได้รับ ภาพเคลื่อนไหวไปรอบ ๆ
แล้วปลายทางที่ เรากำลังจะวาดภาพ
จะต้องมีการย้ายไปรอบ ๆ
ดังนั้นเราจะเรียกสิ่งนี้ ฟังก์ชั่น SDL_QueryTexture
และแจ้งให้ทราบผมผ่านอยู่ ของ dest.w ซึ่งเป็นความกว้าง
และ dest.h ซึ่งเป็นความสูง
และเพื่อให้เป็นไป SDL_QueryTexture ในการจัดเก็บในเขตข้อมูลเหล่านั้นกว้าง
และความสูงของพื้นผิวของเรา
>> และแล้วสิ่งที่ฉันจะ ทำคือการที่ฉันจะ
การตั้ง dest.x จะเป็นหน้าต่าง ความกว้าง dest.w ลบซึ่งเป็น
ความกว้างของเทพดาหารด้วย 2
และนี้จะตั้งขึ้นเพื่อให้ ว่าภาพที่เป็นศูนย์กลางอย่างสมบูรณ์แบบ
ในหน้าต่างของเราทุกคนใช่มั้ย?
ดังนั้นตอนนี้ฉันมีตำแหน่ง Y
และนี้เป็นไปได้ เป็นตัวแปรที่เป็น
เปลี่ยนเพราะเรากำลังจะได้รับ ภาพเคลื่อนไหวในทิศทางการ y
และตอนนี้เรามีบางสิ่งบางอย่าง เรียกว่าห่วงการเคลื่อนไหว
>> ดังนั้นวิธีการทำงานของแอนิเมชั่ไม่?
ดีตาของมนุษย์สามารถตรวจสอบ 12 ที่แตกต่างกัน ภาพในทุกวินาทีทั้งหมดใช่มั้ย?
ดังนั้นถ้าคุณแฟลชการ์ด 12 ภาพที่ผม ในวินาทีที่ผมเห็นแต่ละภาพเหล่านั้น
เป็นของตัวเองที่แตกต่างกันภาพของแต่ละบุคคล
ตอนนี้ถ้าคุณแฟลชมากขึ้น ภาพที่ผมในครั้งที่สอง
แล้วตาของฉันจะเริ่มต้น จะเบลอพวกเขาร่วมกัน
และฉันอยากจะรับรู้ว่าการเคลื่อนไหว แทนหนึ่งภาพที่แตกต่างกัน
ดังนั้นสำหรับตัวอย่างเช่นภาพยนตร์และโทรทัศน์, พวกเขาแฟลชภาพที่คุณ 24 ครั้ง
วินาที.
ดังนั้นที่ 24 เฟรมต่อวินาที
หน้าจอคอมพิวเตอร์บนมืออื่น ๆ มักจะอยู่ที่ 60 เฟรมต่อวินาที
นั่นคือความเร็วในการฟื้นฟูของพวกเขา
นั่นเป็นวิธีที่พวกเขามักจะฟื้นฟู ภาพบนหน้าจอ
ดังนั้นเป้าหมายของเราเป็นไปได้ 60 เฟรมต่อวินาทีสำหรับเกมของเรา
>> ดังนั้นเรามาดูว่าในรหัส
ดังนั้นสำหรับแต่ละเฟรมเราเป็นครั้งแรก จะล้างหน้าต่าง
นี่คือรูปแบบทั่วไป
คุณมักจะล้าง หน้าต่างแต่ละเฟรมแล้ว
ทำทุกรูปวาดของคุณ การดำเนินงานและจากนั้นในตอนท้าย
ไม่ RenderPresent ที่จะแสดง ทุกอย่างอยู่ในกรอบ
แล้วคุณกำลังจะไป มีการรอคอยที่สิ้นสุด
รอจนกว่าจะถึงต่อไป กรอบควรเริ่มต้น
>> ดังนั้นถ้าผมทำจำนวนมาก การคำนวณที่ซับซ้อนที่นี่
ที่ใช้เวลากว่า 16 มิลลิวินาที มันจะเป็นไปไม่ได้สำหรับฉัน
ที่จะได้รับอัตราเฟรมที่ 60 ผมอยากเพราะแต่ละกรอบ
ใช้เวลานานเกินไปในการคำนวณ
นอกจากนี้เรากำลังทำจริงๆ การเรียงลำดับของจำนวนเงินที่สำคัญของการทำงาน
ที่นี่เพราะที่นั่นเท่านั้น สิ่งหนึ่งที่เรากำลังวาดภาพ
ดังนั้นผมจึงรอเพียง 1/60 ของ ที่สองซึ่งเป็นความยาว
ของกรอบในระหว่างเฟรม
ดังนั้นฉันเรียงลำดับของการแกล้งทำ การทำงานทั้งหมดของฉันต้องใช้เวลาเป็นศูนย์
แต่ในเกมจริง คุณจะต้องลบ
ระยะเวลาที่จะเอาไปทำ การทำงานทั้งหมดจากส่วนที่เหลือของคุณเวลานี้
>> ดังนั้นต่อไปสิ่งที่ฉัน ทำจริงในวงนี้หรือไม่?
ฉันจะล้างหน้าต่าง
ผมตั้ง dest.y ซึ่งเป็น int ไปยัง ตำแหน่ง y ที่เกิดขึ้นจริงของฉันโยนลงไปเป็น int
ตอนนี้ผมต้องการที่ลอยละเอียด สำหรับตำแหน่ง y ที่ของฉันในเกมของฉัน
แต่แล้วก็จริง วาดมันลงบนหน้าจอ
มันต้อง ints เพราะในหน่วยของ พิกเซลเพื่อให้เป็นสิ่งที่หล่อสำหรับ
ฉันจะวาดภาพ
ดังนั้นนี่คือสี่เหลี่ยมต้นฉบับ
และนี่คือสี่เหลี่ยมปลายทาง
ดังนั้นผมจึงผ่าน null สำหรับ สี่เหลี่ยมแหล่งที่มา
จะบอกว่าผมต้องการที่จะดึงพื้นผิวทั้งหมดของฉัน
แต่ถ้าคุณมีจำนวนมากของ พื้นผิวในเกมของคุณ
และพวกเขากำลังทั้งหมดในแผนที่พื้นผิวขนาดใหญ่ ที่ถูกโหลดลงใน SDL เป็นเพียงหนึ่ง
พื้นผิวที่คุณสามารถ ใช้รูปสี่เหลี่ยมผืนผ้าแหล่งที่มา
ที่จะเลือกหนึ่งของพื้นผิวที่มีขนาดเล็ก หนึ่งในสไปรท์ขนาดเล็ก
ออกจากที่แผนที่พื้นผิวขนาดใหญ่
>> ดังนั้นอีกครั้งฉันผ่านของฉันทำให้ฉัน เนื้อและตอนนี้ปลายทาง
นี้เป็นไปได้ที่ใน หน้าต่างก็จะได้รับการวาด
และจากนั้นก็เพราะฉันเคลื่อนไหว บางสิ่งบางอย่างที่ฉันต้องการการเคลื่อนไหว
ฉันจะได้รับการปรับปรุง ตำแหน่งเทพดาในแต่ละเฟรม
ดังนั้นผมจึงมีการเลื่อนนี้เรียกว่าค่าคงที่ ความเร็วในหน่วยพิกเซลต่อวินาที
ตอนนี้ทุกครั้งที่เราทำเคลื่อนไหว กรอบเป็นเพียง 1/60 ของวินาที
ดังนั้นฉันจะแบ่งที่ 60
แล้วเรามาดูผม ที่ลบจากตำแหน่ง Y
ฉันลบทำไม?
เราจะไปที่ในครั้งที่สอง
ดังนั้นแล้วฉันทำความสะอาดทรัพยากรของฉัน และโปรแกรมที่มากกว่า
>> ดังนั้นขอให้ที่
ดังนั้นขอให้ไปลงใน SRCS = hello4 animation.c ทั้งหมดใช่มั้ย?
เกม.
มีคุณไป
ดังนั้นผมจึงมีมันเลื่อนขึ้น หน้าต่างซึ่งเป็นระเบียบสวย
แต่ยึดมั่นในผมก็ลบ จากตำแหน่ง y ที่ทุกเวลา
สิ่งที่เกิดขึ้นที่นั่น?
ดีก็ปรากฎว่าใน SDL และ ในความเป็นจริงมากที่สุดในคอมพิวเตอร์กราฟิก
แหล่งที่มาสำหรับระบบการประสานงาน เป็นที่ด้านบนซ้ายของหน้าต่าง
>> ดังนั้นทิศทาง x บวกไป ข้ามหน้าต่างของคุณไปทางด้านขวา
และทิศทางบวก y จริงลงไป
ดังนั้นอีกครั้งในแหล่งกำเนิดของ ด้านบนซ้ายของหน้าต่างของคุณ
ทิศทางบวก y ลง และบวก x คือการที่เหมาะสม
ดังนั้นเมื่อผมลบออกจาก ตำแหน่ง Y ที่ว่า
จะทำให้มันไปในเชิงลบ ทิศทาง Y ซึ่งจะขึ้นหน้าต่าง
นั่นคือสิ่งที่เกิดขึ้นที่นั่น
เย็น.
>> ลองดูที่ไฟล์ต่อไป
นี่คือส่วนหนึ่งของการเป็น แสดงที่ในที่สุดเราก็
ได้รับที่ X ที่มุมของหน้าต่าง ที่ควรจะปิดหน้าต่าง
ไปทำงาน.
ดังนั้นสิ่งที่เกิดขึ้น?
เราเริ่มต้น SDL สร้างหน้าต่าง สร้าง renderer โหลดภาพ
สร้างเนื้อ เหมือนอย่างที่เราเคยเห็นมาก่อน
เรามีสี่เหลี่ยมปลายทางเดียวกัน เป็นก่อนที่จะสายเดียวกันในการค้นหาเนื้อ
แต่ครั้งนี้เราแล้ว จะแบ่งความกว้าง
และความสูงของปลายทางของเราโดยที่ 4
นี้จะมีผลกระทบของ การปรับภาพของเราลงเมื่อ
เราแสดงมันในหน้าต่างโดยสี่
เพื่อให้เป็นระเบียบสวย
เราก็สามารถปรับขนาดเช่นเดียวกับที่
เรากำลังจะเริ่มต้นเทพดา ในใจกลางของหน้าจอ
และตอนนี้เรามี x และความเร็ว Y และ ทั้งที่พวกเขากำลังจะไปเริ่มต้นที่ศูนย์
>> นี้เป็นไฟล์ผิด
ฉันขอโทษ.
เพื่อให้เป็นความจริงทุกประการ
ที่ยังคงทั้งหมดในแฟ้มนี้
เรามีแบ่ง 4 และทุกอย่าง
ดังนั้นที่นี่เรามี x และ y ที่ตำแหน่งของเรา สำหรับศูนย์ของหน้าต่าง
และเราให้มันความเร็วเริ่มต้น ความเร็วคงที่
ผมเชื่อว่าเป็น 300 พิกเซลต่อวินาที
ขณะนี้เรามี int นี้อาจก็เช่นกัน เป็นบูลที่เรียกว่าขอปิด
และแทนที่จะทำ วง จำกัด ในการจับเวลาที่นี่
เรากำลังจะได้เป็นแรงบันดาล ตราบใดที่ใกล้จะไม่ได้รับการร้องขอ
>> ดังนั้นวิธีที่เราดำเนินการเหตุการณ์ที่เกิดขึ้น?
ดี SDL คิวขึ้นในเหตุการณ์ที่เกิดขึ้น คิวที่แท้จริงอยู่เบื้องหลัง
และแล้วแต่ละเฟรม เราสามารถ dequeue เหตุการณ์
จากคิวที่ใช้ SDL_PullEvent สายนี้
และอีกครั้งแน่นอนไปอ่าน เกี่ยวกับเรื่องนี้ในเอกสารประกอบ
มีรายละเอียดมากขึ้นเป็นจำนวนมากและ ฟังก์ชั่นอื่น ๆ อีกมากมายที่คุณสามารถใช้กับเรื่องนี้
เราผ่านมันอยู่ ของสิ่งนี้ SDL_Event
ที่เรามีที่นี่ในกอง
>> ตอนนี้สิ่งที่เป็น SDL_event แล้ว?
เพราะ SDL ถ้าเรามองใน documentation-- ปล่อยให้ของ
เห็น API ตามหมวดหมู่การป้อนข้อมูล กิจกรรมการจัดการเหตุการณ์
เราสามารถมองไปที่จำนวน ของเหตุการณ์ที่แตกต่างกันที่นี่
และเราจะเห็นมี ตันทั้งหมดของพวกเขา
ดังนั้นสิ่งนี้คือสิ่งที่ SDL_Event?
SDL_Event เป็นสหภาพ
ว้าว, สิ่งที่ยูเนี่ยนหรือไม่?
คุณอาจจะไม่เคยได้ ได้ยินว่าก่อนที่
และที่ตกลง
>> สหภาพเป็นชนิดเช่น struct ยกเว้น struct
มีพื้นที่ทั้งหมดของ สาขาและหน่วยความจำ
ขณะที่สหภาพแรงงานมีเพียง พื้นที่เพียงพอที่จะพอดีกับที่ใหญ่ที่สุด
หนึ่งในสาขาของตนซึ่งหมายความว่า สามารถเก็บหนึ่งในสาขาของตน
ในช่วงเวลาที่ชนิดของ ทำให้รู้สึกสำหรับเหตุการณ์ที่เกิดขึ้นใช่มั้ย?
เราสามารถมีแป้นพิมพ์ เหตุการณ์หรือเหตุการณ์หน้าต่าง
แต่เหตุการณ์เดียวไม่สามารถเป็นทั้ง เหตุการณ์แป้นพิมพ์และเหตุการณ์หน้าต่าง
ดังนั้นมันจะโง่ที่จะมีที่ว่างสำหรับ ทั้งของผู้ที่อยู่ภายในสหภาพเหตุการณ์ของเรา
ดังนั้นหากคุณต้องการที่จะ สร้างสหภาพของคุณเอง
มันก็ดูตรงเดียวกัน การสร้างโครงสร้างที่
ยกเว้นว่าเราจะใช้คำหลักที่สหภาพ แทนการใช้คำหลักที่ struct
และจำไว้ว่าสำหรับทุก สิ่งที่อยู่ภายในสหภาพของคุณ
ตัวแปรที่เกิดขึ้นจริงที่เป็นสหภาพ สามารถมีหนึ่งในค่าเหล่านั้น
ขณะนั้น.
>> ดังนั้นวิธีที่เราสามารถบอกชนิดของเหตุการณ์ เราก็โผล่ออกจากคิวนี้?
ดีที่เราสามารถทดสอบ event.type
และถ้าเกิดว่ามีค่าเท่ากับ เพื่อ SDL_Quit เรารู้
มันเป็นกรณีที่ ถูกสร้างขึ้นเมื่อเรา
ตีว่า X ในมุมของหน้าต่าง
และเราสามารถตั้งค่าการร้องขอใกล้เท่ากับ 1
ส่วนที่เหลือเป็นเพียงการเคลื่อนไหวบางอย่าง ที่คุณเคยเห็นมาก่อน
ถ้าอย่างนั้นเราไปข้างหน้าและทำให้ นี้และดูว่าทำงานได้ดี
ดังนั้นฉันจะทำและพิมพ์ แล้ว SRCS = hello5_events.c
เราจะไปที่นั่น.
เกม.
>> ตอนนี้เราจะเห็นว่ามันเป็น ปรับลดลงแน่นอนโดยสี่
และตอนนี้ก็กำยำรอบ ๆ
ฉันต้องตรวจสอบการชนบาง ที่เกิดขึ้นกับด้านข้างของหน้าต่าง
ที่เราสามารถจะดูที่
และสิ่งที่เกิดขึ้นเมื่อฉันไปปิดหรือไม่
ปิด
ที่ยอดเยี่ยม
เราได้รับกรณีที่
และเราจัดการมัน
>> ดังนั้นลองมองกลับไปที่รหัส
ดังนั้นวิธีการที่ฉันได้รับมัน กำยำรอบเช่นนั้น?
จำได้ว่าผมตั้งค่าทั้ง x และ ปีแรกที่ความเร็ว
และความเร็วเป็นบวก อย่างต่อเนื่องเพื่อให้เป็น
จะได้รับมันเริ่มออก และจะลงไปทางด้านขวา
>> ตอนนี้แต่ละเฟรมที่นอกเหนือไปจากการจัดการ เหตุการณ์ใด ๆ ที่อาจเกิดขึ้น
ฉันจะตรวจสอบว่าผีของฉัน พยายามที่จะออกไปจากหน้าต่าง
ดังนั้นเราจึงสามารถทำได้โดยเพียงแค่การตรวจสอบ x_pos 0, y_pos 0 แล้ว
ยัง x_pos และ y_pos กับ ความกว้างและความสูงหน้าต่างหน้าต่าง
ขอให้สังเกตที่ผมเคยหัก ความกว้างของผีสาง
และนี่คือเพราะถ้าฉันไม่ได้ ลบความกว้างของสไปรต์,
มันจะตรวจสอบว่า ต้นกำเนิดของสไปรต์
ไม่ได้ไปนอกหน้าต่าง
แต่เราต้องการทั้งหมด ความกว้างของผีสาง
ที่มักจะต้องอยู่ภายในหน้าต่างและ ทั้งความสูงของสไปรต์
เสมอภายในหน้าต่าง
ดังนั้นสิ่งที่เป็นลบสำหรับ
จำนวนมากของรูปทรงเรขาคณิตที่นี่สามารถ จะเป็นประโยชน์ที่จะดึงมันออกมา
บนกระดาษที่มีการประสานงาน ระบบที่จะเห็นสิ่งที่เกิดขึ้น
>> ดังนั้นถ้าฉันไม่ชนกันผมก็ เพียงแค่ตั้งค่าตำแหน่ง
เพื่อที่จะไม่ได้ไป ออกจากหน้าจอ
และฉันจะไปถ้ามันตีกลับ ที่หนึ่งของผนังที่
ฉันจะคัดค้าน x ความเร็วเพื่อที่จะ
เริ่มตีกลับในทิศทางอื่น ๆ
และในทำนองเดียวกันถ้ามันฮิต ด้านบนหรือด้านล่าง
ฉันจะตั้งค่าความเร็วการ y เท่ากับความเร็ว y ที่เชิงลบ
เพื่อที่จะกลับมา
ดังนั้นนี่เป็นเพียงวิธีการที่เรามีที่นี่
>> และตำแหน่งการปรับปรุง เช่นเดียวกับที่เราเคยเห็นมาก่อน
หารด้วย 60 เพราะเรา จัดการเพียง 1/60 ของวินาที
และแล้วการแสดงผล เหมือนกับก่อน
และเพื่อให้ทุกอย่าง ที่เกิดขึ้นในไฟล์นี้
เพื่อให้เป็นวิธีที่เราทำเหตุการณ์
สิ่งสำคัญที่ต้องนำมาใช้ที่นี่ เป็นหน้าที่ SDL_PullEvent นี้
และแน่นอนคุณควรอ่าน เอกสารเพิ่มเติมเกี่ยวกับ SDL_Event
สหภาพเพราะชนิดของข้อมูลนี้ สำคัญมากเพราะเราใช้มัน
สำหรับทุกประเภทของกิจกรรม
>> ตัวอย่างเช่นเราใช้มันสำหรับแป้นพิมพ์ เหตุการณ์ที่เกิดขึ้นซึ่งเป็นสิ่งที่ไฟล์นี้เหมาะสำหรับ
ดังนั้นเราจึงทำในสิ่งที่มี?
เรามีสิ่งที่เหมือนกันเป็นมาก่อน เริ่มต้น SDL สร้างหน้าต่าง
สร้าง renderer โหลดภาพ ในหน่วยความจำสร้างเนื้อ
อีกครั้งที่เรากำลังจะไป มีรูปสี่เหลี่ยมผืนผ้าปลายทางนี้
เรากำลังจะปรับขนาดภาพ โดยสี่ทำให้มันเป็นบิตขนาดเล็ก
ตอนนี้เรากำลังจะเริ่มต้น เทพดาในใจกลางของหน้าจอ
แต่ครั้งนี้เราจะตั้งค่า x ความเร็วเริ่มต้นและ y ที่เป็นศูนย์
เพราะแป้นพิมพ์เป็น จะควบคุมเหล่านั้น
และนอกจากนี้เรากำลังจะไป ติดตามตัวแปรเหล่านี้
ขึ้นลงซ้ายและขวา
และที่จะเก็บ ติดตามเราได้ไม่ว่าจะเป็น
กดปุ่มแป้นพิมพ์ที่ สอดคล้องกับการขึ้นลงซ้าย
และขวา
>> ตอนนี้เป็นชนิดของแฟนซี เพราะเราสามารถใช้ W, A, S,
D ที่นี่หรือปุ่มลูกศรที่เกิดขึ้นจริง
เราจะเห็นว่าในเวลาเพียงสอง
ดังนั้นเรากำลังจะดำเนินการ เหตุการณ์เช่นเดียวกับก่อนที่จะ
เราดึงเหตุการณ์
แต่ตอนนี้เรากำลังจะไป สลับกับประเภทการแข่งขัน
ถ้ามัน SDL_Quit เรา จะตั้งอยู่ใกล้
ขอให้หนึ่งเช่นเดียวกับก่อนที่จะ
ที่จัดการ x ใน มุมของหน้าต่าง
เพื่อให้หน้าต่างของเราจริงปิด
>> มิฉะนั้นถ้าเราได้รับคีย์ SDL ลง เหตุการณ์ซึ่งหมายความว่าเรากดคีย์
แล้วสิ่งที่เรากำลังจะทำคือเรา จะเปิดสิ่งนี้ที่นี่
ซึ่ง means-- เพื่อ event.key หมายถึงการรักษาสหภาพเหตุการณ์ของเรา
ไปและได้รับที่สำคัญ โครงสร้างเหตุการณ์ในนั้น
ดังนั้นมันจะเปิดออกที่นี้ ยูเนี่ยนเป็นโครงสร้างเหตุการณ์ที่สำคัญ
แล้วไปที่สำคัญ โครงสร้างของเหตุการณ์สาขาของตน
เรียกว่า keysym แล้ว scancode
และอีกครั้งอ่านแน่นอน เอกสารเกี่ยวกับเรื่องนี้
คำที่ใช้ปัจจัยการผลิตที่ค่อนข้างน่าสนใจ
คุณจะได้รับการสแกนรหัสหรือรหัสที่สำคัญ
และมันก็เป็นเพียงเล็กน้อยบอบบาง แต่ เอกสารค่อนข้างดี
>> ดังนั้นถ้าเราเห็นโค้ดสแกน กดปุ่มของเราเป็น W หรือขึ้น
เรากำลังจะตั้งค่าเท่ากับ 1
และจากนั้นเราแยกออกจากสวิทช์ที่
ถ้ามันเป็น A หรือซ้ายเราตั้งทิ้งไว้ 1, et ฯลฯ และอื่น ๆ สำหรับการลงและขวา
ตอนนี้ออกมาในครั้งนี้สวิทช์ด้านนอก ถ้าเราดูที่สำคัญถึงเหตุการณ์
นั่นหมายความว่าเราได้เปิดตัวที่สำคัญ และเราไม่ได้กด
ดังนั้นฉันจะพูดขึ้นเท่ากับ 0, ซ้ายเท่ากับ 0 ลงเท่ากับ 0 ขวา
เท่ากับ 0, และอื่น ๆ
>> และแจ้งให้ทราบที่เรามีในแต่ละเหล่านี้ สองกรณีนำสิทธิติดกัน
ไม่มีรหัสแยกต่างหาก สำหรับกรณีแรกที่
หมายความว่าไม่ว่าจะเป็น เอหรือลงที่นี่
มันจะรันโค้ดนี้
เพื่อให้เป็นประโยชน์สวย
จะป้องกันไม่ให้เราต้องทำมากขึ้น เงื่อนไขและไอเอฟเอและกิจกรรม
เช่นนั้น.
>> ดังนั้นเรากำลังจะไป กำหนดความเร็ว
เราตั้งค่าความเร็วเป็น 0
แล้วถ้าขึ้นกด และไม่ได้ลงแล้วเรา
ตั้งค่าความเร็ว y ที่ความเร็วเชิงลบ
โปรดจำไว้ว่าในเชิงลบเนื่องจาก ทิศทาง y ที่เชิงลบขึ้น
และทิศทางบวก y จะลดลง
หากมีการกดลง และไม่ขึ้นแล้วเรา
จะตั้งค่าให้ความเร็วในเชิงบวก ซึ่งหมายถึงการไปลงหน้าจอ
สิ่งเดียวกันกับด้านซ้ายและขวา
>> และจากนั้นเรากำลังจะปรับปรุง ตำแหน่งเช่นเดียวกับก่อนที่จะ
เรากำลังจะทำการปะทะกัน การตรวจสอบที่มีขอบเขต
แต่เราไม่ได้ไปตั้งค่า ความเร็วความเร็วเพราะเป็นเพียง
ควบคุมโดยแป้นพิมพ์
แต่เราจะไปตั้งค่า ตำแหน่งที่จะเก็บมันไว้ในหน้าต่าง
และเรากำลังจะตั้งค่า ในตำแหน่งที่ struct
แล้วทำทุก การแสดงผลจากสิ่งที่มาก่อน
ดังนั้นเรามาดูสิ่งที่มันไม่
เพื่อให้ SRCS-- เรามาดู นี้ hello6_keyboard.c
>> ไม่นะ.
ดังนั้นเราจึงมีคำเตือนบางอย่างที่นี่
และที่บอกว่าเราก็ไม่ได้ ตรวจสอบชนิดที่เป็นไปได้ทุกเดียว
ของเหตุการณ์
ที่ตกลงเพราะ มี 2​​36 ของพวกเขาหรือเพื่อให้
ดังนั้นผมจะไม่สนใจคำเตือนเหล่านั้น
ก็ยังคงรวบรวมดี
ดังนั้นฉันจะไปเล่นเกม
มันไม่ได้ย้าย
แต่ตอนนี้เมื่อฉันบดบนแป้นพิมพ์ของฉัน ฉันสามารถทำอะไรบางอย่างเคลื่อนไหว WASD ที่นี่
ผมใช้ปุ่มลูกศรของฉันเช่นกัน
และแจ้งให้ทราบถึงแม้ว่าฉัน กดที่เหมาะสมในขณะนี้
มันจะไม่ออกมาจากหน้าต่าง เพราะผมตั้งค่าได้ในทุกกรอบ
เพื่อให้เป็นระเบียบสวย
คุณสามารถคิดย้ายไปรอบ ๆ มาริโอกับ บางปุ่มลูกศรหรือสิ่งที่ต้องการที่
และใช่เอ็กซ์ทำงาน
>> ไฟล์สุดท้ายดังนั้นเรากำลังจะ ที่จะมอง hellow7_mouse
นี้เป็นเรื่องเกี่ยวกับการป้อนข้อมูลของเมาส์
ดังนั้นในหนึ่งนี้เรา นำเข้าหัวคณิตศาสตร์
เพราะเรากำลังจะมี นิด ๆ หน่อย ๆ ของคณิตศาสตร์ที่นี่
เดิมสิ่งเดิมปลายทาง เดิมเห็นว่าก่อนที่จะ
อย่างนี้เป็นที่น่าสนใจ
ดังนั้นเราจะกลับไปตรวจสอบเท่านั้น สำหรับ SDL เลิกเหตุการณ์
ว่าเป็นเพราะเหตุใด
เพื่อให้คุณสามารถได้รับการป้อนข้อมูลของเมาส์จากเหตุการณ์ที่เกิดขึ้น
เช่นเดียวกับเมื่อเมาส์ย้าย คุณจะได้รับเหตุการณ์ว่า
เมื่อกดปุ่มเมาส์กด คุณจะได้รับเหตุการณ์ว่า
>> แต่มีผู้อื่นง่ายขึ้นเล็กน้อย บางที API สำหรับการป้อนข้อมูลของเมาส์
และนั่นก็เป็นเพียงแค่ได้รับรัฐเมาส์ SDL
ดังนั้นผมจึงมี int สำหรับ x และ y ที่ตำแหน่งเคอร์เซอร์
ผมผ่านไป SDL_GetMouseState, ซึ่งชุดเหล่านี้
และนี่คือตำแหน่งใน ระบบพิกัดของหน้าต่าง
ดังนั้นถ้ามวลเป็นในด้านบนซ้าย ของหน้าต่างที่จะ 0, 0
>> ตอนนี้สิ่งที่ผมจะทำคือการที่ฉันจะ ที่จะทำนิด ๆ หน่อย ๆ ของคณิตศาสตร์เวกเตอร์
ฉันเดิมพันที่คุณคิดว่าคุณจะไม่ เห็นว่าใน CS50 แต่ที่นี่มันเป็น
ฉันจะทำอะไรบางอย่างเวกเตอร์ คณิตศาสตร์ที่จะได้รับเวกเตอร์
จากภาพที่เคอร์เซอร์
ดังนั้นทำไมฉันมี ลบที่นี่?
ดีถ้าฉันเพียงแค่ใช้ปลายทางเพื่อ .-- ฉันจำเป็นต้องแปลเมาส์เอ็กซ์
และ Y โดยครึ่งหนึ่งความกว้างและ ความสูงของภาพที่
เพราะผมต้องการที่ศูนย์ของ ภาพที่จะมุ่งหน้าไปยังเมาส์
ไม่ได้ที่มาของภาพ
>> เพื่อให้เป็นเพียงเพื่อให้แน่ใจว่าผมกำลังพูดถึง เกี่ยวกับศูนย์ของภาพที่นี่
จากนั้นเราได้รับเดลต้า x และ y ซึ่ง คือความแตกต่างจากเป้าหมาย
ไปยังตำแหน่งที่แท้จริงของภาพ
และจากนั้นเราจะได้รับ ระยะทางที่นี่ซึ่ง
เป็นไปได้ที่พีทาโกรัส ทฤษฎีบท, รากที่สองของ x
ครั้ง x บวกครั้งวายวาย
>> ตอนนี้เพื่อป้องกันไม่ให้กระวนกระวายใจและฉันสามารถแสดง คุณว่านี้ไม่ถ้าฉันไม่ทำเช่นนี้
ถ้าระยะห่างระหว่างเคอร์เซอร์และ ศูนย์ภาพน้อยกว่าห้า
ฉันแค่ไม่ได้ไปเพื่อเลื่อนภาพ
มิฉะนั้นเราจะกำหนดความเร็ว
และเราตั้งไว้เพื่อให้ ความเร็วจะเป็นค่าคงที่
และผลกำไรของทุก คณิตศาสตร์นี้คือภาพ
จะไปย้ายไปทางเคอร์เซอร์
>> ตอนนี้ก็ปรากฎว่า SDL_GetMouseState,
นอกเหนือไปจากการตั้งค่า และข้อโต้แย้ง x y ที่นี่
มันก็จะส่งกลับ int ที่สอดคล้อง สถานะของปุ่มเมาส์
ดังนั้นเราจึงไม่สามารถอ่านว่า โดยตรง แต่ที่เราสามารถทำได้
ใช้แมโครเหล่านี้เป็นหนึ่งเดียว ผู้ประกอบการค่าที่เหมาะสมไม่ว่าน่ากลัว
เพียงค่าที่เหมาะสมและ
ดังนั้นเราจึงบอกว่าปุ่มซึ่งเป็นผลที่ได้ SDL_GetMouseState ของเราว่า
และค่าที่เหมาะสมและแมโครนี้ นี่ SDL_BUTTON_LEFT
>> ดังนั้นนี้เป็นไปได้เพียงแค่แก้ไข เพื่อบิตแมปที่สอดคล้อง
ปุ่มซ้ายของเมาส์ถูกกด
และดังนั้นหากค่าที่เหมาะสม และเกิดขึ้นและมัน
ไม่เป็นศูนย์ซึ่งหมายความว่า ปุ่มซ้ายถูกกด
แล้วเราจริงจะปฏิเสธ ทั้ง x และ y ที่ความเร็วที่
ซึ่งก็จะทำให้ภาพหนี
ตำแหน่งที่ปรับปรุง
การตรวจจับการชนเห็นมัน ทั้งหมดก่อนที่จะกระทำขวาทั้งหมด
ขอให้มัน
เพื่อให้คุณได้ทำให้ SRCS = hello7_mouse.c
ที่ดี
ไม่มีข้อผิดพลาด
และเกม
>> ดังนั้นที่นี่ฉันมีเมาส์ของฉัน
และภาพที่เป็นจริง ไล่เมาส์ของฉัน
ตอนนี้ในเกมที่คุณทำอาจจะ นี้เป็นเหมือนไล่ศัตรู
ตัวอักษรเล็ก ๆ น้อย ๆ ของคุณหรืออะไรก็ตาม
แต่ที่นี่เรามี ภาพไล่เมาส์
และเมื่อฉันคลิกเมาส์ เริ่มไล่ภาพ
และภาพที่เป็น วิ่งหนีจากเมาส์
เพื่อให้เป็นเย็นสวย
และแจ้งให้ทราบอีกครั้งมี ยังคงตรวจสอบการชนที่นี่
>> เพื่อให้เป็นเล็ก ๆ น้อย ๆ เป็นครั้งสุดท้าย สาธิตฉันได้ตั้งค่าที่นี่
และให้ดูที่สิ่งหนึ่งที่เพิ่มเติม
ดังนั้นกลับมาที่นี่ผมกล่าวถึงนี้กระวนกระวายใจ
ทั้งหมดขวา
ดังนั้นหากระยะทางน้อยกว่าห้าพิกเซล ผมได้รับการตั้งค่า x และ y ที่ความเร็วเป็นศูนย์
จะเกิดอะไรขึ้นถ้าเรากำจัดที่?
ดังนั้นฉันจะทำเช่นนี้เพียง
โปรดแก้ตัวรูปแบบนี้น่ากลัว แต่เราออกความเห็นรหัสที่ถูกต้อง
ดังนั้นฉันจะบันทึกและทำ คำสั่งเดียวกันจากก่อนที่จะให้มัน
>> ทั้งหมดขวา
และตอนนี้สิ่งที่เกิดขึ้น?
ดี.
เรายังคงดังต่อไปนี้ เมาส์เช่นเดียวกับก่อน
แต่เมื่อเราได้รับเมาส์ เราได้มีกระวนกระวายใจขั้นต้นนี้
สิ่งที่เกิดขึ้นที่นั่น?
ทั้งในเวกเตอร์ของเรา คณิตศาสตร์จำได้ว่าเราเป็น
ระยะห่างระหว่างการที่ เคอร์เซอร์และศูนย์ของภาพ?
ดีที่ว่าวิธีการ 0 เราเริ่มได้รับ
เช่นการจัดเรียงของพฤติกรรมบ้านี้ ที่ภาพจะเป็นประเภทของ
เช่นสั่นรอบเคอร์เซอร์
และที่สร้างความกระวนกระวายใจนี้
และที่น่าเกลียดจริงๆ
และคุณอาจไม่ ต้องการเกมของคุณทำแบบนั้น
เว้นแต่จะเรียงลำดับของผลพิเศษบางอย่าง
>> นั่นคือเหตุผลที่เรามี เพียงแค่นี้โดยพลการ
ตัดห้าพิกเซลที่เราพูด ถ้าเป็นภายในห้าพิกเซลเรากำลังดี
เราไม่จำเป็นต้องเลื่อนภาพอีกต่อไป
นั่นคือสิ่งที่เกิดขึ้นที่นั่น
>> เพื่อที่ว่ามันสวยมาก
ตอนนี้คุณรู้วิธีการสร้าง หน้าต่างโหลดภาพ
วาดภาพไปที่หน้าต่างที่ได้รับ ใส่แป้นพิมพ์ได้รับการป้อนข้อมูลของเมาส์,
มีพวงของอื่น ๆ การป้อนข้อมูลที่คุณจะไม่
รู้วิธีการที่จะได้รับถ้าคุณเพียงแค่ใช้จ่าย ไม่กี่นาทีมองไปที่เอกสาร
ดังนั้นคุณจะมีค่อนข้าง เครื่องมือไม่กี่ที่จำหน่ายของคุณในขณะนี้
ที่จะเขียนเป็นเกมที่เต็มเปี่ยม
>> ตอนนี้เกมทุกความต้องการเสียงบาง แต่เอกสารเสียง
นอกจากนี้ยังเป็นที่ดีงาม
และฉันยินดีที่จะเดิมพันว่าถ้า คุณเข้าใจทุกสิ่งที่
เราได้พูดคุยเกี่ยวกับในวันนี้ด้วย ภาพและพื้นผิว
หน้าต่างและทุกอย่างแล้ว หา API เสียงไม่ได้
จะเป็นไปได้ว่าไม่ดี
ดังนั้นผมจึงหวังเป็นอย่างยิ่งว่าจะได้เห็น สิ่งที่คุณสร้างขึ้นด้วย SDL