คำถามติดแท็ก rendering

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

24 textures  rendering  transparency  alpha 

ฉันกำลังมองหาสูตรในการพล็อต (หน้าจอโลก>) และตัวเลือกเมาส์ (หน้าจอโลก>) กระเบื้องสามมิติในโลกรูปเพชร สิ่งที่ฉันพยายามทำอยู่เสมอเป็นไปได้ วิธีปกติ / ถูกต้องในการทำเช่นนี้คืออะไร?

23 rendering  tiles  isometric  mouse 

ฉันกำลังเขียนเกมโดยใช้ C ++ และ OpenGL 2.1 ฉันคิดว่าฉันจะแยกข้อมูล / ตรรกะออกจากการแสดงผลได้อย่างไร ในขณะนี้ฉันใช้คลาสพื้นฐาน 'Renderable' ที่ให้วิธีเสมือนจริงเพื่อนำมาใช้วาดภาพ แต่วัตถุทุกชิ้นมีรหัสพิเศษเฉพาะวัตถุเท่านั้นที่รู้วิธีการตั้งค่าเครื่องแบบ shader อย่างถูกต้องและจัดระเบียบข้อมูลบัฟเฟอร์อาร์เรย์จุดสุดยอด ฉันลงเอยด้วยฟังก์ชัน gl * จำนวนมากโทรไปทั่วรหัสของฉัน มีวิธีการทั่วไปในการวาดวัตถุหรือไม่?

21 c++  opengl  rendering  logic  data 

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

21 rendering 

ในช่วงเวลาเดียวกันในหนึ่งฉากมีเกมที่ทันสมัย ฉันรู้ว่ามีการใช้เฉดสีหลายแบบโดยมีเกมสลับระหว่างพวกเขาในแต่ละเฟรมและเป็นเรื่องธรรมดาที่จะวาดวัตถุผ่าน shader: วาดวัตถุทั้งหมดด้วย shader หนึ่ง เปลี่ยนจาก shader หนึ่งเป็น shader สอง วาดวัตถุทั้งหมดด้วย shader สอง ถึงกระนั้นฉันก็รู้ว่ามันไม่ง่ายโดยเฉพาะอย่างยิ่งกับเอฟเฟ็กต์เช่นเอฟเฟ็กต์แสงสำหรับฉากทั้งหมดการเรนเดอร์ไปสู่พื้นผิว ฯลฯ แต่ฉันคิดว่าเราสามารถสันนิษฐานได้ว่า วิธีการ "กลุ่มโดย shader" เป็นสิ่งที่ดีเพราะการเปลี่ยนเฉดสีเป็นการดำเนินการที่มีราคาแพง จากด้านหนึ่งคุณไม่สามารถมีเฉดสีมากเกินไปเพราะคุณต้องการทำให้ฉากนั้นรวดเร็ว ในทางกลับกันคุณจำเป็นต้องมีเฉดสีที่แตกต่างกันมากมาย (หรือ uber-shader ที่มีกิ่ง - คล้ายกันมาก) สำหรับผิวหนังโลหะน้ำ ฯลฯ เกมประเภทนักสืบสามมิติ (และอันใด) ที่แตกต่างกันทางทฤษฎีเกมสมัยใหม่นักสืบสามมิติสำหรับพีซี (DirectX 11 ถ้ามีความสำคัญ) จะใช้งานอย่างไร มันจะเป็น 5, 20 หรือมากกว่าเช่น 100 shaders ที่ใช้งานอยู่นับเฉพาะการใช้งานที่บางเฟรม ""? ฉันรู้ว่ามันไม่ใช่หมายเลขหนึ่ง แต่ฉันสงสัยว่าขนาดและปัจจัยใดที่มีความสำคัญในการพิจารณาสำหรับเกมพีซี ในเกมตัวอย่างของฉันฉันจะใช้ประมาณ 9-11 ต่อเฟรม …

20 shaders  directx  rendering  directx11 

สิ่งที่จะเป็นวิธีการที่ดีในการพัฒนาระบบการแสดงผลสำหรับ Oldschool พิมพ์เกมที่ใช้หลอกทัศนียภาพ 3 มิติอย่างเช่นการแข่งรถวิ่งเร็วกว่าหรือโลตัส Esprit ท้าทายเทอร์โบ ? มีถนนที่เลื่อนได้ไม่สิ้นสุดและกราฟิกทิวทัศน์จะถูกวางไว้เช่นรายการป้ายโฆษณา ฯลฯ ฉันคิดว่าคุณเข้าใจ สิ่งเหล่านี้ได้รับการพัฒนาในลักษณะที่คล้ายกันเช่นMode7หรือมีเทคนิคต่าง ๆ อยู่เบื้องหลังหรือไม่? เทคนิคมีชื่อเฉพาะที่ฉันสามารถค้นหาบนเว็บได้หรือไม่? ฉันต้องพัฒนาบางอย่างเช่นนั้นใน Flash

20 3d  rendering  racing 

จากคำถามเกี่ยวกับอัตราส่วนภาพฉันสนใจที่จะได้ยินว่าคนอื่นกำลังใช้อะไรเมื่อทำงานกับระบบ 2D UI (น่าจะเป็นโซลูชันที่ปลูกเองในบ้าน) โดยเฉพาะวิธีการทำคุณจัดการกับระบบพิกัด ในใจของฉันมีสามตัวเลือก: ยากรหัสพิกัด (เช่น: 0 -> 720, 0 -> 576) พิกัดปกติ (0.0 -> 1.0 0.0 -> 1.0), แมปลงในพิกัดจริงก่อนการแสดงผล พิกัดเสมือน (เช่น: 0 -> 1600 0 -> 1000), แมปลงในพิกัดจริงก่อนการแสดงผล รหัสตายตัวจะมีประโยชน์เฉพาะเมื่อคุณอยู่บนแพลตฟอร์มคงที่และรู้ว่าพิกัดพื้นที่หน้าจอของคุณล่วงหน้าหรือว่าคุณพร้อมที่จะเขียนเค้าโครงหน้าจอสำหรับทุกขนาดของหน้าจอที่เป็นไปได้ พิกัดปกติเป็นสิ่งที่ดี แต่ประสบความคลุมเครือเมื่ออัตราส่วนของหน้าจอไม่ได้รับการแก้ไข (เช่น 0.75 แผนที่ไปยังพิกัดทางกายภาพที่แตกต่างกันเมื่อทำงานในจอไวด์สกรีนมากกว่าที่ทำใน 4: 3) นอกจากนี้สำหรับผู้แต่งมันเป็นเรื่องธรรมดาที่จะประกาศองค์ประกอบ UI ให้เป็น (0.2 x 0.2) เพียงเพื่อจะพบว่ามันไม่ได้เป็นรูปสี่เหลี่ยมจัตุรัสจริง ๆ เมื่อแสดงผล พิกัดเสมือนไม่มีความกำกวม แต่ประสบปัญหาเดียวกับพิกัดปกติที่ขั้นตอนการแมปใหม่ความคลาดเคลื่อนเลขฐานสิบเล็กน้อยอาจส่งผลให้เกิดข้อผิดพลาดแบบทีละหนึ่งหมายความว่าองค์ประกอบ …

20 rendering  gui 

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

19 3d  rendering  terrain-rendering  water 

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

19 opengl  rendering  testing  unit-testing  test-driven-development 

ฉันมีเอ็นจิ้นเกม 2D ที่ดึงแผ่นกระเบื้องโดยการวาดแผ่นจากภาพชุดไพ่ เนื่องจากตามค่าเริ่มต้นแล้ว OpenGL สามารถห่อทั้งพื้นผิว ( GL_REPEAT) และไม่ได้เป็นส่วนหนึ่งของมันเท่านั้นไทล์แต่ละอันจึงแยกออกเป็นพื้นผิวแยกต่างหาก จากนั้นพื้นที่ของไทล์เดียวกันจะแสดงผลติดกัน นี่คือสิ่งที่ดูเหมือนว่าเมื่อทำงานตามที่ตั้งใจไว้: อย่างไรก็ตามทันทีที่คุณแนะนำการปรับสัดส่วนแบบตะเข็บปรากฏ: ทำไมสิ่งนี้ถึงเกิดขึ้น ฉันคิดว่าเป็นเพราะการกรองเชิงเส้นเป็นการผสมผสานเส้นขอบของคณะสี่คน แต่มันก็ยังคงเกิดขึ้นกับการกรองแบบจุด วิธีแก้ปัญหาเดียวที่ฉันพบคือการรับประกันว่าการวางตำแหน่งและการปรับขนาดทั้งหมดจะเกิดขึ้นที่ค่าจำนวนเต็มและใช้การกรองแบบจุดเท่านั้น สิ่งนี้สามารถลดคุณภาพการมองเห็นของเกม (โดยเฉพาะการวางตำแหน่งพิกเซลย่อยไม่ทำงานอีกต่อไปดังนั้นการเคลื่อนไหวจะไม่ราบรื่น) สิ่งที่ฉันได้ลอง / พิจารณา: การลดรอยหยักจะลด แต่ไม่ได้กำจัดรอยตะเข็บทั้งหมด การปิดการทำแผนที่ไม่มีผล เรนเดอร์แต่ละแผ่นแยกกันและขับขอบ 1px - แต่นี่เป็นการลดประสิทธิภาพเนื่องจากมันไม่สามารถแสดงพื้นที่ของกระเบื้องได้ในคราวเดียวและสร้างสิ่งประดิษฐ์อื่น ๆ ตามขอบของพื้นที่โปร่งใส เพิ่มเส้นขอบ 1px รอบ ๆ รูปภาพต้นทางและทำซ้ำพิกเซลสุดท้าย - แต่จากนั้นจะไม่มีกำลังไฟสองอีกต่อไปทำให้เกิดปัญหาความเข้ากันได้กับระบบที่ไม่มีการสนับสนุน NPOT การเขียน shader ที่กำหนดเองเพื่อจัดการกับภาพที่มีการเรียงต่อกัน - แต่แล้วคุณจะทำอะไรที่แตกต่างออกไป? GL_REPEATควรจับพิกเซลจากด้านตรงข้ามของภาพที่ขอบและไม่เลือกความโปร่งใส เรขาคณิตอยู่ติดกันอย่างแน่นอนไม่มีข้อผิดพลาดในการปัดเศษจุดลอยตัว ถ้า Shader ส่วนจะเขียนยากที่จะกลับมามีสีเดียวกันตะเข็บหายไป ถ้าพื้นผิวมีการกำหนดให้GL_CLAMPแทนGL_REPEAT, ตะเข็บหายไป …

18 opengl  2d  rendering  tiles  tilemap 

ฉันกำลังสร้างเกมตัวต่อแบบสองมิติใน XNA ปัจจุบันฟ้าผ่าของฉันดูเหมือนว่านี้ ฉันจะทำให้มันเป็นแบบนี้ได้อย่างไร แทนที่จะบล็อกแต่ละบล็อกมีสีของตัวเอง แต่ก็มีการซ้อนทับที่ราบรื่น ฉันสมมติว่ามี shader อยู่บ้างและส่งค่าแสงสำหรับกระเบื้องโดยรอบไปยัง shader แต่ฉันเป็นมือใหม่ที่มีร่มเงาดังนั้นฉันไม่แน่ใจ แสงปัจจุบันของฉันคำนวณแสงจากนั้นส่งผ่านไปยัง a SpriteBatchและวาดด้วยพารามิเตอร์ tint แผ่นกระเบื้องแต่ละอันนั้นมีการColorคำนวณก่อนที่จะวาดในอัลกอริทึมการส่องสว่างของฉันซึ่งใช้สำหรับโทนสี นี่คือตัวอย่างเกี่ยวกับวิธีที่ฉันคำนวณแสงในปัจจุบัน (ฉันทำสิ่งนี้จากซ้ายขวาและล่างเช่นกัน แต่ฉันเหนื่อยมากที่ทำเฟรมนี้เป็นเฟรม ... ) ที่จริงแล้วการได้รับและวาดแสงจนถึงตอนนี้ก็ไม่มีปัญหา ! ฉันได้เห็นบทเรียนมากมายเกี่ยวกับหมอกแห่งสงครามและการใช้การซ้อนทับแบบวงกลมลาดเพื่อสร้างสายฟ้าที่ราบรื่น แต่ฉันมีวิธีที่ดีในการกำหนดค่าสายฟ้าผ่าให้กับกระเบื้องแต่ละอันแล้ว ดังนั้นเพื่อทบทวน คำนวณแสงสว่าง (เสร็จสิ้น) วาดไทล์ (เสร็จแล้วฉันรู้ว่าฉันจะต้องแก้ไขมันสำหรับ shader) Shade tiles (วิธีการผ่านค่าและใช้ "การไล่ระดับสี)

18 xna  c#  shaders  rendering  lighting 

ปิด. คำถามนี้เป็นคำถามปิดหัวข้อ ไม่ยอมรับคำตอบในขณะนี้ ต้องการปรับปรุงคำถามนี้หรือไม่ อัปเดตคำถามเพื่อให้เป็นหัวข้อสำหรับ Game Exchange Stack Exchange ปิดให้บริการใน2 ปีที่ผ่านมา ฉันกำลังจะหยิบคอมพิวเตอร์กราฟิกขึ้นมาอีกครั้งสำหรับโครงการมหาวิทยาลัย สำหรับโครงการก่อนหน้านี้ฉันใช้ห้องสมุดที่เรียกว่าFTGLซึ่งไม่ทำให้ฉันพึงพอใจเพราะรู้สึกหนัก (ฉันลองเทคนิคการเรนเดอร์จำนวนมาก คำถามของฉันคือมีห้องสมุดที่ดีและมีประสิทธิภาพสำหรับเรื่องนี้? ถ้าไม่เช่นนั้นจะมีวิธีใดที่จะใช้ข้อความที่รวดเร็ว แต่ดูดี? การใช้งานบางอย่างที่ตั้งใจคือ: ฉลากวัตถุ / ตัวละครลอย การหารือ เมนู ฮัด แก้ไข: ยิ่งสามารถโหลดแบบอักษรได้

17 textures  rendering  performance  fonts  text 

ปิด คำถามนี้จะต้องมีมากขึ้นมุ่งเน้น ไม่ยอมรับคำตอบในขณะนี้ ต้องการปรับปรุงคำถามนี้หรือไม่ อัปเดตคำถามเพื่อให้มุ่งเน้นที่ปัญหาเดียวโดยแก้ไขโพสต์นี้ ปิดให้บริการใน6 ปีที่ผ่านมา ฉันเป็นนักเขียนโปรแกรมกราฟิกมือใหม่และฉันเพิ่งสงสัยว่าเมื่อเร็ว ๆ นี้ - โมเดลข้อมูล (ตาข่ายและวัสดุ) ไหลจากแอปพลิเคชัน (หน่วยความจำ CPU) ไปยังการ์ดกราฟิก (หน่วยความจำ GPU) อย่างไร? บอกว่าฉันมีรูปแบบคงที่ (เช่นสิ่งปลูกสร้าง) ที่ฉันโหลดและตั้งค่าหนึ่งครั้งและไม่เปลี่ยนแปลงตลอดอายุการใช้งานของแอป ข้อมูลส่งไปยังหน่วยความจำ GPU เพียงครั้งเดียวและนั่งอยู่ที่นั่นตลอดไปหรือไม่? เมื่อแบบจำลองได้รับการแสดงผลจริงในแต่ละเฟรมแล้วตัวประมวลผล GPU ต้องดึงข้อมูลทุกครั้งจากหน่วยความจำ GPU หรือไม่ สิ่งที่ฉันหมายถึงคือ - ถ้าฉันมี 2 แบบจำลองที่แสดงหลายครั้งในแต่ละครั้ง - มันจะสำคัญไหมถ้าฉันแสดงครั้งแรกทีละหลายครั้งและอีกอันที่สองหลายครั้งหรือถ้าฉันแสดงครั้งแรกเพียงครั้งเดียว interleaving มันแบบนั้นเหรอ? ฉันสามารถเรียกคำถามนี้ว่า "การไหลของข้อมูล GPU ภายใน" ในแง่นี้ เห็นได้ชัดว่าการ์ดกราฟิกมี RAM จำกัด - เมื่อมันไม่สามารถเก็บข้อมูลโมเดลทั้งหมดที่จำเป็นสำหรับการเรนเดอร์ …

16 rendering  gpu  memory  dataflow 

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

16 rendering  multithreading  logic  synchronization 

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

16 c++  rendering