OpenGL, SFML และ SDL มีข้อได้เปรียบอะไรบ้างในการแสดงผลซอฟต์แวร์

ฉันเริ่มดูกระแส Handmade Heroที่ซึ่ง Casey Muratori สร้างเอ็นจิ้นเกมโดยไม่ต้องใช้เฟรมเวิร์กหรืออย่างนั้น เมื่อวานฉันไปถึงส่วนที่เขาแสดงให้เห็นว่าภาพวาดลงบนหน้าจออย่างไร เท่าที่ฉันเข้าใจเขาได้จัดสรรหน่วยความจำบางส่วนให้ใหญ่เท่ากับขนาดหน้าจอที่เขาต้องการวาด จากนั้นเขาสร้างบิตแมปที่เขาส่งไปยังหน่วยความจำบัฟเฟอร์ที่เขาจัดสรรและดึงมันไปที่หน้าจอโดยใช้ฟังก์ชั่นเฉพาะของระบบปฏิบัติการ

นี่ดูเหมือนจะค่อนข้างตรงไปตรงมา ฉันใช้ GameMaker เปลี่ยนเป็น Love2D ทำงานเล็กน้อยกับ Sprite Kit แต่ฉันสงสัยอยู่เสมอว่าเกิดอะไรขึ้นภายใต้เลเยอร์นี้บางครั้งทำให้สับสน

ระบุว่าทำไมแม้แต่ต้องใช้ห้องสมุดกราฟิก (OpenGL, SFML, SDL, ... ) เมื่อสิ่งที่คุณต้องทำคือเพียงจัดสรรบัฟเฟอร์บางส่วนผ่านบิตแมปและวาดลงบนหน้าจอ

หากคุณต้องการวาดสิ่งที่แตกต่างให้กับหน้าจอคุณเพียงแค่เขียนลงในบิตแมปของคุณซึ่งจะถูกส่งผ่านไปยังบัฟเฟอร์ ฉันค่อนข้างใหม่กับการเขียนโปรแกรม แต่ดูเหมือนจะง่ายสำหรับฉัน โปรดแก้ไขฉันหากฉันผิด

มันไม่ได้เป็นเพียงแค่ความเร็วในการประหารชีวิต แต่ยังเกี่ยวกับความเรียบง่าย แม้ว่าการเรนเดอร์ซอฟต์แวร์ที่ใช้ในตัวอย่างนี้จะช้ากว่าการใช้การเร่งความเร็วฮาร์ดแวร์ (เช่น GPU) การวาดบิตแมปบนหน้าจอเป็นงานเล็กน้อยที่คุณจะไม่สังเกตเห็นว่าประสิทธิภาพลดลง

อย่างไรก็ตามกิจกรรมระดับต่ำเช่นแรสเตอร์สามเหลี่ยมการจัดเรียงเชิงลึกและไลค์นั้นเป็นแนวคิดที่เข้าใจกันดีว่า GPU สามารถจัดการโดยปริยายด้วยคำสั่งไม่กี่คำ การนำสิ่งที่อยู่ในโหมดซอฟต์แวร์กลับมาใช้ใหม่เป็นการปรับโครงสร้างล้อใหม่ นี่เป็นเรื่องปกติถ้าคุณต้องการความเข้าใจในระดับต่ำเกี่ยวกับวิธีการเรนเดอร์ฉันเขียนโปรแกรมแสดงภาพ 3 มิติเพื่อสำรวจมันเล็กน้อย แต่สำหรับสถานการณ์ส่วนใหญ่มันเป็นการเสียเวลาที่ OpenGL สามารถทำได้เร็วกว่า กล่อง.

ตัวอย่างที่คุณให้มานั้นฟังดูธรรมดามากเพียงแค่วาดภาพเดียวบนหน้าจอดังนั้นการติดตั้งจึงง่าย เมื่อคุณเริ่มเรียนรู้เรื่องความซับซ้อนคุณจะพบว่ามันซับซ้อนขึ้นเรื่อย ๆ เพื่อให้การแสดงผลทุกอย่างถูกต้อง สิ่งที่ผู้คนต้องทำในช่วง Quake days ของการเรนเดอร์ซอฟต์แวร์ 3 มิตินั้นบ้า แต่ฉันขอขอบคุณที่คุณไม่ได้ไปไกลขนาดนั้น (ยัง)

คำถามของฉันคือ: ทำไมถึงต้องใช้บางสิ่งบางอย่างเช่น open gl, sfml, sdl เมื่อสิ่งที่คุณต้องทำก็แค่จัดสรรบัฟเฟอร์แล้วส่งบิตแมปและวาดลงบนหน้าจอ

สั้น: เพราะเร็ว (OpenGL, DirectX)

ยาว:

คุณอาจคิดว่าคุณสามารถทำสิ่งนี้ได้ด้วยตัวเอง วาดพิกเซลไปที่หน้าจอ คุณอาจเขียนห้องสมุดขนาดเล็กเพื่อวาดรูปร่างเช่นสี่คนหรือสามเหลี่ยม จะใช้งานได้แน่นอน มีห้องสมุดจำนวนมากที่ทำสิ่งนี้ บางคนใช้ OpenGL-spec (ดังนั้นจึงเป็นเหมือนซอฟต์แวร์สำหรับ OpenGL) ซึ่งจะทำสิ่งที่ Casey Muratori ทำ พวกเขาคำนวณทุกอย่างทางด้านซอฟต์แวร์ตั้งค่าพิกเซลทางด้านซอฟต์แวร์และเขียนผลลัพธ์ไปที่หน้าจอ

อย่างไรก็ตามเรื่องนี้เป็นอย่างช้า ซีพียูที่จะดำเนินการสิ่งเหล่านี้ในที่สุดไม่ได้ทำสำหรับสถานการณ์นี้ นั่นคือสิ่งที่ GPUs มีไว้สำหรับ สิ่งที่ OpenGL ทำ (ยกเว้นว่าเป็นการใช้งานซอฟต์แวร์อย่างแน่นอน) จะนำทุกสิ่งที่คุณบอกให้ทำและผลักดันข้อมูลทั้งหมดการโทรออกทั้งหมดเกือบทุกอย่างไปยังกราฟิกการ์ดและบอกGPUให้ทำงานได้ GPU ทำขึ้นเป็นพิเศษสำหรับงานประเภทนี้ การคูณจำนวนจุดลอยตัว (นั่นคือสิ่งที่คุณทำมากเมื่อวาดฉาก 3 มิติ) และเรียกใช้เฉดสี และสิ่งนี้ในแบบคู่ขนาน เพื่อให้คุณรับรู้ว่า GPU มีความรวดเร็วเพียงใดให้คิดเกี่ยวกับฉากที่เรียบง่ายในแบบ 3 มิติในแบบเต็มหน้าจอขนาด 1920x1080 พิกเซล เหล่านี้คือคูณด้วย 2,073,600 พิกเซลเพื่อวาด สำหรับทุกคนพิกเซล GPU จะเรียกใช้ส่วนย่อยอย่างน้อยหนึ่งครั้งส่วนใหญ่มากกว่าหนึ่งครั้ง ตอนนี้สมมติว่าเราทำงานที่ 60 เฟรมต่อวินาที วิธีนี้ GPU ทำงานส่วน Shader-2073600 * 60 = 124,416,000 ครั้งต่อวินาที คุณคิดว่าคุณสามารถทำสิ่งนี้บน CPU ของคุณหรือไม่? (นั่นเป็นคำอธิบายที่ค่อนข้างง่ายมีหลายสิ่งที่ต้องพิจารณาเช่นจำนวนพิกเซลที่คุณใช้โดยวัตถุที่ใกล้กว่าจำนวน MSAA ที่คุณใช้และอื่น ๆ อย่างไรก็ตามจำนวน124,416,000 ครั้งต่อวินาทีน่าจะต่ำที่สุดที่คุณจะได้รับและคุณ จะมีมากกว่า 60fps ด้วยฉากง่าย ๆ )

นั่นคือสิ่งที่ OpenGL และ Direct3D ทำสำหรับสิ่งที่เอ็นจิ้นเห็น @Uri Popovs ตอบ

สิ่งที่เขาทำเรียกว่าการเรนเดอร์ซอฟต์แวร์สิ่งที่ OpenGL เรียกว่าการเรนเดอร์ GPU

ความแตกต่างระหว่างพวกเขาคืออะไร ความเร็วและความจำ

Rasterization (การกรอกสามเหลี่ยมบนหน้าจอ) ใช้เวลาพอสมควร ถ้าคุณทำมันบน CPU คุณต้องใช้เวลาส่วนนั้นออกไปจากตรรกะของเกมโดยเฉพาะถ้ามันไม่ได้รับการปรับให้เหมาะสม

และไม่สำคัญว่าภาพมีขนาดเล็กเพียงใดเขาต้องจัดสรรหน่วยความจำในจำนวนที่แน่นอน GPUs มีหน่วยความจำวิดีโอสำหรับสิ่งนี้

ในขณะที่คำตอบจากคนอื่นนั้นถูกต้องมากกว่าคำตอบใด ๆ ที่ฉันให้ฉันต้องการชี้ให้เห็นถึงความเข้าใจผิดขั้นพื้นฐานเกี่ยวกับวิธีการพัฒนาซอฟต์แวร์ที่ฉันคิดว่าเป็นไปตามคำถามของคุณ ในขณะที่เป็นไปได้เสมอที่จะทำสิ่งต่าง ๆ "ด้วยตัวเอง" โดยไม่มีกรอบและมักจะได้รับประโยชน์ทางการศึกษาอย่างมากจากการทำเช่นนั้นความเป็นจริงไม่ใช่การสร้างซอฟต์แวร์ที่ทันสมัย

ใครบางคนสร้างฮาร์ดแวร์และภาษาเครื่องที่ทำงานบนมัน บางคนสร้างภาษาและคอมไพเลอร์ระดับสูงขึ้นไดรเวอร์และระบบปฏิบัติการไลบรารีกราฟิกและบนและบน เราแต่ละคนสร้างผลงานของบรรพบุรุษของเรา นั่นไม่เพียง "โอเค" แต่เป็นข้อกำหนด

คุณกำลังวาดเส้นของสิ่งที่ "ยอมรับได้" หรือไม่อยู่ที่จุดใดจุดหนึ่งใน toolchain คุณสามารถพูดง่ายๆว่า "ทำไมต้องใช้ C ++ เมื่อคุณสามารถทำสิ่งเดียวกันในการประกอบ?" หรือ "ทำไมต้องอาศัยไดรเวอร์แป้นพิมพ์เมื่อคุณสามารถอ่านแรงดันไฟฟ้าที่หลุดออกมาจากสายและคำนวณด้วยตัวเองได้อย่างง่ายดาย" ในแต่ละวันมีเวลาไม่มากพอหรือหลายปีในชีวิตที่ทุกคนสามารถทำได้ทุกอย่างด้วยตนเอง

สิ่งนี้ไม่ได้ใช้เฉพาะกับการพัฒนาซอฟต์แวร์ แต่ใช้กับชีวิตสมัยใหม่โดยทั่วไป คุณเคยได้ยินคนที่สร้างเครื่องปิ้งขนมปังตัวเองตั้งแต่เริ่มต้นหรือไม่? http://www.thomasthwaites.com/the-toaster-project/ มันใช้เวลานานมากและพยายามอย่างมาก สำหรับเครื่องปิ้งขนมปัง ลองสร้างทุกสิ่งที่จำเป็นในการสร้างวิดีโอเกมจากอีเธอร์ด้วยตัวคุณเอง!

เอ็นจิ้นทำได้มากขึ้นกว่าเดิมเพียงแค่วาดภาพไปที่หน้าจอ พวกมันจัดการกับแสงเงาการป้อนข้อมูลการตรวจจับการชนกันของภาพ แม้แต่ส่วนของการเรนเดอร์ก็มีความซับซ้อนมากกว่าแค่การบัฟเฟอร์ลงบนหน้าจอ สำหรับฉาก 3 มิติโดยเฉพาะคุณจำเป็นต้องทำการคำนวณจำนวนมากบนข้อมูลที่ซับซ้อนกว่าบิตแมป ผมขอให้คุณเปรียบเทียบรถ: สิ่งที่คุณอธิบายง่าย ๆ คือไอเสียของรถ คุณเพียงแค่สร้างท่อที่มีขนาดที่ถูกต้องจากนั้นคุณผลักก๊าซจากปลายด้านหนึ่งไปยังอีกด้านหนึ่ง อย่างไรก็ตามสิ่งนี้อยู่ไกลจากสิ่งเดียวที่เกิดขึ้นในกลไกของรถ

คำตอบข้างต้นนั้นยอดเยี่ยม แต่ก็ไม่มีเหตุผลใดที่เหนือกว่าเหตุผลที่สำคัญที่สุดว่าทำไมถึงเลือกใช้ OpenGL และสิ่งเหล่านี้ เหตุผลหลักคือเพื่อให้การใช้ฮาร์ดแวร์เฉพาะที่ออกแบบมาโดยเฉพาะอย่างยิ่งในการทำงานกับสิ่งที่ต้องการการแสดงผลนับล้านพิกเซลบนหน้าจอที่GPU

ด้วยการเรนเดอร์ซอฟต์แวร์โดยใช้ CPU ตัวเรนเดอร์จะวนลูปทีละพิกเซลบนบิตแมปทั้งหมดและออกคำสั่งให้แสดงแต่ละอันบนหน้าจอ ดังนั้นหากคุณกำลังแสดงภาพขนาด 1,000x1000 นั่นคือ 1,000,000 ลูปสำหรับซีพียูของคุณมากกว่า พวกเขาถูกออกแบบด้วยการควบคุมในใจหลังจากทั้งหมด หากมีเงื่อนไขมากมายให้กระโดดจากชุดคำสั่งหนึ่งไปอีกชุดหนึ่งและทิศทางที่เข้มงวดของการควบคุม อย่างไรก็ตาม GPU ได้รับการออกแบบโดยมีความรู้ว่ามันจะทำการวนซ้ำที่คล้ายกันมากกว่าพิกเซลบนหน้าจอGPU จะทำการวนซ้ำด้วยการวนซ้ำ 1000000 ครั้งและแบ่งการทำงานของคอร์จำนวนมากเพื่อให้แต่ละอันทำงาน ** ในแบบขนานและเป็นอิสระจากกัน ** ซึ่งแตกต่างจากซีพียูทุกครั้งที่ GPU เจอเงื่อนไข if-else มันจะจัดการทั้งรหัสสาขาไปที่สองคอร์ของตัวเองและจากนั้นในตอนท้ายสุดมันจะดูว่าสภาพประเมินและทิ้ง ผลที่ได้จากสาขาที่ไม่จำเป็น (นั่นเป็นเหตุผลว่าทำไมต้องมีเงื่อนไขอื่น ๆ อีกมากมายใน GPU shaders ที่ขมวดคิ้วอยู่พวกเขารับผิดชอบเรื่องเสียเสมอ)

ดังนั้นใช่ GPUs ที่ถูกสร้างขึ้นรอบ ๆขนาน ที่ทำให้พิกเซลทำงานได้เร็วขึ้นมากเมื่อเทียบกับซีพียู

ดูฉันจำเป็นต้องใช้ API กราฟิกหรือไม่

แน่นอนว่าคุณสามารถขอบัฟเฟอร์ตั้งค่าบิตในนั้นและเขียนไปยังหน้าจอ นั่นเป็นวิธีเดียวที่จะทำการเขียนโปรแกรมกราฟิกบนพีซีจนกว่าความพร้อมของตัวเร่งความเร็วกราฟิกในช่วงกลาง 90s จาก 3DFX แม้แต่ใน Windows DirectX ยังได้รับการพัฒนาเพื่อให้เข้าถึงหน่วยความจำวิดีโอโดยตรง

แต่สำหรับฮาร์ดแวร์ที่ไม่ใช่พีซีซึ่งเป็นเครื่องเกมเฉพาะมักมีเทคนิคในการเร่งกราฟิกด้วยการถ่ายงานจากโปรเซสเซอร์ แม้แต่อาตาริ 2600 ก็มี "ฮาร์ดแวร์สไปรต์" ส่วนหนึ่งเป็นเพราะมันมี RAM ไม่เพียงพอสำหรับ framebuffer

ต่อมา (กลาง 80s) เกมคอนโซลได้รับการปรับให้เหมาะกับเกมแพลตฟอร์ม อีกครั้งไม่มี framebuffer; โปรแกรมเมอร์สามารถระบุกริดของกระเบื้องแทน :

ฮาร์ดแวร์กราฟิกของ Genesis ประกอบด้วยระนาบเลื่อนได้ 2 อัน เครื่องบินแต่ละลำประกอบด้วยกระเบื้อง ไทล์แต่ละอันคือสี่เหลี่ยมจัตุรัสขนาด 8x8 พิกเซลซึ่งมี 4 บิตต่อพิกเซล แต่ละพิกเซลสามารถมี 16 สี แต่ละกระเบื้องสามารถใช้ 1 ใน 4 ตารางสีดังนั้นบนหน้าจอคุณสามารถได้ 64 สีในคราวเดียว แต่มีเพียง 16 ในกระเบื้องที่ระบุ ไทล์จำเป็นต้องมี 32 ไบต์ มีหน่วยความจำกราฟิก 64K การทำเช่นนี้จะอนุญาตให้มีไทล์ที่ไม่ซ้ำกัน 2048 รายการหากใช้หน่วยความจำเพื่อสิ่งอื่น

ซีพียูสมัยใหม่นั้นเร็วพอที่จะทำเกม 2d ในซอฟต์แวร์ดังนั้นสำหรับกราฟิก 2 มิติ OpenGL / DirectX จะไม่มีข้อได้เปรียบนอกเหนือจากการเพิ่มการพึ่งพาและความซับซ้อนในโครงการของคุณเช่นการตั้งค่าเมทริกซ์ภาพสามมิติเพื่อวาดพวง สไปรต์และอัปโหลดข้อมูลไปยัง GPU

OpenGL จะบังคับให้คุณบรรจุ sprite ทั้งหมดของคุณภายในพื้นผิว 512x512 (สิ่งประดิษฐ์ของคอนโซลเก่าเช่น PSX, การบรรจุกราฟิกลงในหน้าหน่วยความจำวิดีโอ) ทำให้คุณต้องเขียนรหัส sprite ที่ค่อนข้างซับซ้อน

ในทางกลับกันถ้าคุณทำแบบ 3 มิติแสดงสามเหลี่ยมเป็นล้านด้วยการแรเงาที่ซับซ้อนแสดงว่า GPU ไม่สามารถหลีกเลี่ยงได้ นานมาแล้วมี Direct3d รุ่น 2d ที่เรียบง่ายกว่าเท่านั้นเรียกว่า DirectDraw ซึ่ง GPU เร่งการวาดรูปสไปรท์ แต่ตอนนี้ Microsoft ไม่รองรับอีกต่อไปอาจเป็นเพราะ CPU นั้นเร็วพอที่จะทำ 2d โดยไม่เร่งความเร็วหากคุณไม่สนใจเรื่องการประหยัดพลังงาน .