การเรนเดอร์ซอฟต์แวร์ทำได้อย่างไร?

ฉันต้องการสำรวจแบบเรียลไทม์โดยใช้ซอฟต์แวร์แบบแรสเตอร์ ฉันรู้ว่าทุกอย่างกำลังมุ่งสู่ GPU ในทุกวันนี้ แต่มีบางเกมที่มันยังคงสมเหตุสมผลที่จะใช้ตัวแสดงซอฟต์แวร์

ตัวอย่างเช่น: Voxeltron

Voxatron เป็นเกมยิงที่เกิดขึ้นในโลกที่ทำจาก voxels (ก้อนเล็ก ๆ ชนิดหนึ่ง) ทุกอย่างในเกมนั้นจะแสดงในรูปแบบเสมือน 128x128x64 voxel รวมถึงเมนูและรายการเล่นของผู้เล่น หากคุณมองอย่างใกล้ชิดบางครั้งคุณสามารถเห็นสินค้าคงคลัง (คะแนน / ชีวิต / กระสุน) หล่อเงาบนวัตถุบางอย่างบนพื้น

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

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

เกมจะเกิดขึ้นในชุดเล็ก ๆ โดยสิ้นเชิง บางห้องมีห้องที่มีฉากแอ็คชั่นอยู่ระหว่าง Knightlore และ Smash TV นี่คือบางส่วนของการออกแบบตามการผจญภัยดั้งเดิมแอบกลับมาและข้อแก้ตัวในการสร้างสภาพแวดล้อมเฉพาะเรื่อง

คุณสมบัติ:

• การแสดงซอฟต์แวร์ที่กำหนดเองด้วยเงานุ่ม
• เครื่องสังเคราะห์เสียงและเพลงในตัว (ใช้เพื่อสร้างเพลงตัวอย่าง)
• การเล่นและการบันทึกเกมหลัง

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

สถาปัตยกรรมโปรแกรมเกม

• ครอบคลุมโดยย่อของพีชคณิตเชิงเส้นพื้นฐาน แต่ครอบคลุมทุกสิ่งที่คุณจำเป็นต้องรู้ หนังสือเล่มนี้มีค่าสำหรับเหตุผลอื่น ๆ อีกมากมายเช่นกัน

การแสดงผลตามเวลาจริง

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

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

นี่คือรายละเอียดเพิ่มเติมในบทความเหล่านี้:

บทช่วยสอน - ความรู้เบื้องต้นเกี่ยวกับการแสดงผลด้วยซอฟต์แวร์: สามเหลี่ยมแรสเตอร์ไรเซชัน

ซอฟต์แวร์ Rendering School: Part I

และเพื่อความสนุกลองดูบทความต่อไปนี้:

Quake 2 Source Code Review 3/4 (ตัวแสดงซอฟต์แวร์)

นี่เป็นหัวข้อที่ค่อนข้างกว้าง มีอยู่สองส่วนพื้นฐาน: ทฤษฎีที่แท้จริงของการแปลงกราฟิกและท่อส่งแรสเตอร์และบิตการใช้งานจริงที่ช่วยให้คุณระเบิดพิกเซลบนหน้าจอถึงที่คุณเลือก ยิ่งไปกว่านั้นยังมีการปรับให้เหมาะสม (โดยเฉพาะอย่างยิ่งบิตหลัง)

ส่วนแรกโชคดีเช่นเดียวกับทฤษฎีที่ใช้สำหรับท่อกราฟิกที่เปิดเผยโดยฮาร์ดแวร์ที่ทันสมัยและ API ถ้าคุณรู้สิ่งนี้อยู่แล้วคุณก็พร้อมแล้ว ถ้าคุณทำไม่ได้ฉันขอแนะนำหนังสือดี ๆ อันนี้ค่อนข้างดี

มีตัวเลือกมากมายสำหรับส่วนที่สอง มันขึ้นอยู่กับระบบปฏิบัติการและตัวเลือก toolchain ของคุณเป็นอย่างมาก หากคุณใช้ C หรือ C ++ บน Windows คุณสามารถพล็อตพิกเซลโดยตรงไปยังบิตแมป GDI ( SetPixelง่าย แต่เจ็บปวดช้าไร้ประโยชน์ - CreateDIBSectionให้จำนวนไบต์ดิบที่คุณสามารถจัดการได้ในอัตราที่เร็วกว่ามาก)

คุณยังสามารถรับพื้นผิว DirectDraw และเขียนลงไปหรือเขียนไปยัง Direct3D หรือพื้นผิว OpenGL ในกรณีหลังนี้คุณจะยังคงใช้ฮาร์ดแวร์อยู่ แต่ตราบใดที่คุณทำองค์ประกอบทั้งหมดของอิมเมจสุดท้ายบน CPU ด้วยตัวเองและใช้ API ฮาร์ดแวร์เพื่อคัดลอกผลลัพธ์ไปยังหน้าจอมันยังคงนับอยู่ บนพีซีสมัยใหม่คุณไม่สามารถเข้าถึง VRAM ดิบหรืออะไรก็ได้โดยตรง

หากคุณต้องการทราบข้อมูลเพิ่มเติมคุณควรสร้างคำถามที่เจาะจงมากขึ้น ฉันหรือคนอื่นยินดีที่จะตอบคำถามเหล่านี้

ตกลงฉันจะเข้าหาคำถามนี้จากพื้นฐานมาก อะไรก็ตามที่นอกเหนือจากนั้นเป็นวิธีที่กว้างสำหรับ QA ง่ายๆ คุณจำเป็นต้องซื้อหนังสือในเรื่อง

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

ตัวอย่างเช่นลองนึกถึงสิ่งที่คุณเป็นโปรแกรมเมอร์ต้องทำเพื่อแสดงสามเหลี่ยมสามมิติบนหน้าจอ ด้วย GPU คุณเพียงแค่บอกฮาร์ดแวร์ว่าพิกัด X, Y, Z ของจุดยอดนั้นเป็นเท่าใดและวิดีโอการ์ดจะเติมเต็มพิกเซลทั้งหมดบนหน้าจอที่ประกอบด้วยภาพของรูปสามเหลี่ยม คุณอาจใช้ shader เพื่อบอก GPU ให้เปลี่ยนสีของทุกพิกเซลตามพื้นผิวหรือบางอย่าง แต่ในที่สุดมันก็ยังลงมาที่ GPU โดยอัตโนมัติเติมพิกเซลทั้งหมดให้คุณ

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