การพัฒนาเกม

มีเทคนิคมาตรฐานในการจัดการอินพุตในเกมขนาดใหญ่หรือไม่ ขณะนี้ในโครงการของฉันการจัดการอินพุตทั้งหมดเสร็จในลูปเกมดังนี้: while(SDL_PollEvent(&event)){ switch(event.type){ case SDL_QUIT: exit = 1; break; case SDL_KEYDOWN: switch(event.key.keysym.sym){ case SDLK_c: //do stuff break; } break; case SDL_MOUSEBUTTONDOWN: switch(event.button.button){ case SDL_BUTTON_MIDDLE: //do stuff break; } } break; } (ฉันใช้ SDL แต่ฉันคาดหวังว่าหลักปฏิบัติจะใช้กับไลบรารีและกรอบงานด้วย) สำหรับโครงการขนาดใหญ่ดูเหมือนจะไม่ใช่ทางออกที่ดีที่สุด ฉันอาจมีวัตถุหลายอย่างที่อยากรู้ว่าผู้ใช้กดอะไรดังนั้นจึงเหมาะสมสำหรับวัตถุเหล่านั้นในการจัดการอินพุต อย่างไรก็ตามพวกเขาไม่สามารถจัดการอินพุตได้หลังจากที่ใครคนหนึ่งได้รับเหตุการณ์มันจะถูกผลักออกจากบัฟเฟอร์เหตุการณ์ดังนั้นวัตถุอื่นจะไม่ได้รับอินพุตนั้น วิธีใดที่ใช้กันมากที่สุดในการต่อต้านสิ่งนี้?

16 c++  sdl  input  standards 

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

16 algorithm  path-finding  maps 

รัฐของศิลปะในแง่ของการแสดงเงาคืออะไร? เป้าหมายของฉันคือ OpenGL 3.2 โดยใช้ไปป์ไลน์การแสดงผลที่เลื่อนออกไปหากมีความสำคัญ เป็นเวลาหลายปีแล้วที่ฉันได้ดูการเรนเดอร์เงาและในเวลานั้นมีเทคนิคมากมายตั้งแต่ stencils ไปจนถึงวิธีการแมปเงาต่างๆ ในเวลานั้นเงาการเรนเดอร์ต้องผ่านการเรนเดอร์แยกต่างหากซึ่งควบคุมโดย CPU แต่เมื่อเร็ว ๆ นี้ฉันเห็นการสาธิตว่ามีการแสดงฉากทั้งหมดบน GPU รวมถึงเงา ฉันไม่รู้ว่ามันจะสำเร็จได้อย่างไรหรือถ้ามันเป็นสิ่งที่สมเหตุสมผลที่ต้องทำ (นอกเหนือจากการสาธิตเทคโนโลยี) ด้วยข้อมูลเก่าจำนวนมากบนอินเทอร์เน็ตฉันต้องการที่จะเรียนรู้ว่าผู้คนใช้วิธีการใดในยุคนี้และสามารถผลักไปที่ GPU ได้มากแค่ไหน (สมมุติว่า OpenGL รุ่นเป้าหมายของฉันรองรับ)

16 opengl  shadows 

คำถามของฉันคืออะไรจะเป็นวิธีที่ดีที่สุดในการค้นพบบนพื้นผิวดาวเคราะห์ที่ไม่เรียบ? ข้อมูลพื้นฐาน ฉันสร้างดาวเคราะห์ขึ้นจากการแมปการเคลื่อนที่ 6 ระนาบที่คาดการณ์ไว้ ตอนแรกเครื่องบินก่อตัวเป็นลูกบาศก์ก่อนที่จะถูกฉายเป็นรูปร่างทรงกลม ฉันสงสัยว่าเป็นไปได้หรือไม่ที่จะใช้ "ใบหน้าลูกบาศก์ใบหน้ากลม" เป็นกริดและใช้อัลกอริธึม A * แบบง่าย ๆ เพื่อค้นหาเส้นทางที่ดีที่สุดที่เป็นไปได้ฉันต้องการให้นำความสูงของการกระจัดกระจายมาพิจารณาด้วย ภูเขาอื่น ๆ (ฉันคิดว่านี่จะเป็นเพียงการแก้ปัญหาด้วยอัลกอริทึม A *) ข้อพิจารณาอีกอย่างหนึ่งคือฉันได้บรรลุการเคลื่อนที่ของดาวเคราะห์โดยใช้ประโยชน์จากกลไกทางฟิสิกส์ของ Unity3d ใช้แรงโน้มถ่วงเข้าหาศูนย์กลางของดาวเคราะห์ วิธีแก้ปัญหาที่เสนอของฉันจะต้องใช้การเคลื่อนไหวของตัวแทนเพื่อควบคุมฟิสิกส์แรงโน้มถ่วงโดยอิสระหรือไม่ เพื่อช่วยให้ชัดเจนขึ้นคำถามของฉันนี่คือร่างกายดาวเคราะห์ปัจจุบันของฉัน:

16 unity  physics  movement  path-finding  planet 

ดังนั้นฉันจึงคิดที่จะสร้างเกม 2D ที่คุณสามารถเคลื่อนที่ไปตามแกน Z ได้โดยการเปลี่ยนเลเยอร์ที่คุณเป็น ฉันต้องการไต่ 2D สไปรต์ของฉันขึ้นอยู่กับความลึก ครั้งหนึ่งมีคนแสดงตัวอย่างให้ฉันฟังซึ่งเขามีสไปรต์ 2 มิติจำนวนมากและการเลื่อนเขาสามารถเปลี่ยนความลึกของกล้องได้ ดังนั้นเมื่อซูมเข้าวัตถุจะเข้าใกล้เครื่องเล่นมากขึ้นและดูใหญ่ขึ้น จากนั้นฉันก็สงสัยว่าวัตถุควรใหญ่กว่านี้เมื่อมันเข้าใกล้ 1 หน่วย คุณจะคำนวณมันอย่างไร ดังนั้นชายคนนั้นบอกฉันว่า: มีกฎพื้นฐานข้อหนึ่งที่ฉันใช้อยู่: "วัตถุสองเท่าใกล้เคียงปรากฏใหญ่ขึ้นสองเท่า" ตอนนี้โดยการทดสอบด้วยตนเองฉันรู้ว่ากฎไม่ได้ใช้ในโลกแห่งความเป็นจริง;) แต่มีค่าคงที่ที่ใช้ในการคำนวณโลกแห่งความจริงสำหรับมุมมองหรืออะไร? หรือสูตร ฉันรู้ว่านี่อาจไม่ใช่สถานที่ที่ดีที่สุดในการถามคำถาม แต่เนื่องจากเป็นเว็บไซต์เดียวที่ฉันใช้สำหรับคำถามที่เกี่ยวข้องกับเกมและบริบทของฉันเป็นเกมฉันคิดว่าฉันจะลองดู นอกจากนี้ฉันคาดหวังว่าจะมีคนที่นี่ที่รู้ทุกอย่างเกี่ยวกับมุมมอง 3 มิติและเมทริกซ์หรือบางสิ่งบางอย่างเนื่องจากอาจเกี่ยวข้องกับเกม 3 มิติ;) TL; DR: "วัตถุสองเท่าใกล้ปรากฏใหญ่เป็นสองเท่า" นั่นไม่จริงในโลกแห่งความจริง แต่ค่าคงที่หรือสูตรใดที่ถูกต้อง

16 perspective  objects 

ฉันต้องการใช้แผนที่พื้นผิวของ 2048 x 2048 ในเกมของฉันและฉันต้องการเตือนผู้ใช้ด้วยอุปกรณ์ที่ "ต่ำเกินไป" เพื่อไม่ให้ดาวน์โหลดเกม ด้วยรูปแบบพื้นผิวของขนาดนี้ฉันต้องพูดอะไรกับ ANDROID? ภาพนี้ (ที่มา: /programming/10392027/recommended-limit-for-memory-management-in-cocos2d ) แสดงความต้องการสำหรับ IPHONE สิ่งที่เกี่ยวกับแอนดรอยด์: ขั้นต่ำ 512Mo กับ 1GHz เป็น ข้อกำหนดที่ถูกต้อง? ขอบคุณสำหรับคำตอบ

16 android  textures  texture-atlas 

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

16 unity  lighting  lightmap 

ฉันได้ค้นคว้าคำถามนี้จากหลาย ๆ แหล่งและยังไม่พบคำตอบที่แน่นอนที่บอกว่า "ใช่นั่นคือการคิดที่ถูกต้อง" หรือ "ไม่นี่คือวิธีที่ทำ" ฉันพยายามรับประกันความเป็นอิสระในการแก้ปัญหาด้วยการเรนเดอร์ OpenGL วิธีที่ฉันคิดว่าฉันควรทำคือการสร้างการฉายภาพโดยใช้glOrthoทุกสิ่งที่ฉันต้องการให้พิกัดโลกเป็น ตัวอย่างเช่นglOrtho(-50.0, 50.0, -50.0, 50.0, 1.0, -1.0). ถัดไปตั้งค่าวิวพอร์ตไปยังความละเอียดหน้าจอคือ glViewport(0, 0, 800, 600)- ในที่สุดเมื่อใดก็ตามที่หน้าต่างมีขนาดใหม่ให้ทำการโทรglViewportด้วยความละเอียดหน้าจอที่อัปเดต นี่จะเป็นการเพิ่มขนาดของคุณ นี่เป็นวิธีที่ถูกต้องหรือไม่ที่จะทำให้แน่ใจว่ารุ่นต่างๆมีสัดส่วนพื้นที่หน้าจอเท่ากันตามความละเอียดที่แตกต่างกันหรือไม่? ฉันควรใช้การฉายภาพที่มีความละเอียดเท่ากับหรือไม่ ฉันพบคำตอบบางคำที่บอกว่าglOrthoควรใช้ความละเอียดของหน้าต่างของคุณในขณะที่คนอื่นบอกว่าควรจะ / อาจแตกต่างกัน คิด?

16 opengl  java  lwjgl  resolution 

ตามที่เป็นอยู่ในปัจจุบันคำถามนี้ไม่เหมาะสำหรับรูปแบบคำถาม & คำตอบของเรา เราคาดหวังคำตอบที่จะได้รับการสนับสนุนจากข้อเท็จจริงการอ้างอิงหรือความเชี่ยวชาญ แต่คำถามนี้อาจเรียกร้องให้มีการถกเถียงโต้แย้งโต้แย้งหรือการอภิปรายเพิ่มเติม หากคุณรู้สึกว่าคำถามนี้สามารถปรับปรุงและเปิดใหม่ได้โปรดไปที่ศูนย์ช่วยเหลือเพื่อขอคำแนะนำ ปิดให้บริการใน6 ปีที่ผ่านมา ฉันกำลังมองหาพจนานุกรมทั่วไปของคำศัพท์ (คล้ายกับรูปแบบการออกแบบมีภาษาทั่วไปสำหรับสิ่งที่โต้ตอบ) ที่เฉพาะเจาะจงกับเกม ตัวอย่างเช่นถ้าฉันสร้างเกมปิงปองที่มีความซับซ้อนในระดับสูงฉันต้องการตั้งชื่อให้เหมาะสม ฉันได้เห็นวัตถุที่เป็นภาพซึ่งผู้ใช้สามารถโต้ตอบด้วยเรียกว่าวิดเจ็ตบางรายการที่ไม่โต้ตอบเรียกว่าdoodad (ย้อนกลับไปเมื่อฉันเล่นกับตัวแก้ไขแผนที่ starcraft ต่อไป) มีชื่อที่ถูกต้องสำหรับนาฬิกาอัตราเฟรมหรือไม่? มีชื่อที่เหมาะสมสำหรับนาฬิกาของเกม (นาฬิกาที่เกี่ยวกับการเคลื่อนที่ของวัตถุในโลก แต่ไม่ใช่การวาดภาพ) ฉันแค่ต้องการพจนานุกรมเพื่อให้ฉันสามารถพูดภาษาเดียวกันและไม่ได้ทำสิ่งต่าง ๆ ตามที่ฉันไป ฉันเป็นห่วงฉันจะสร้างสิ่งต่าง ๆ ที่ชื่อ doodads, whosits, whatsists และ flim-flams ... และฉันไม่ต้องการทำเช่นนั้น

16 architecture  design-patterns 

คำถามของฉันคือ: ฉันจะจัดการกับสถานะของเกมในระบบเอนทิตีของฉันได้อย่างไรโดยไม่หันไปใช้การเก็บวัตถุสแต็คของเกมไว้รอบ ๆ ดังนั้นการออกแบบระบบเอนทิตีของฉันหมายความว่าเมื่อเอนทิตีต้องลงทะเบียนสำหรับเหตุการณ์อินพุทเช่นอินพุทคอมโพเนนต์จะเรียกระบบอินพุตและพูดว่า "ลงทะเบียนเอนทิตีนี้สำหรับอินพุตนี้" ทั้งหมดนี้เป็นสิ่งที่ดีและดีอย่างไรก็ตามหากคุณเพิ่มแนวคิดเรื่องสถานะเกม (กล่าวว่าหน้าจอหยุดชั่วคราว) มันจะกลายเป็นปัญหาในการทำงานถ้าเอนทิตีอยู่ในสถานะปัจจุบันและควรได้รับอินพุต ฉันสามารถเพิ่มองค์ประกอบอินพุต / ระบบเพื่อให้มันบอกว่า "ลงทะเบียนเอนทิตีนี้สำหรับอินพุตนี้ในขณะที่อยู่ในสถานะเกม" แต่สิ่งนี้ต้องการให้ทุกเอนทิตีรู้ว่าต้องใช้เอนทิตี้แบบใดและอาจไม่ชัดเจน นอกจากนี้การรักษารายการเกมรอบตัวต่ออินพุตที่ลงทะเบียนไว้ (และระบบอื่น ๆ ที่ใช้การโทรกลับ) นั้นไม่ได้มีประสิทธิภาพมากเกินไป ความคิดอื่นที่ฉันมีคือเนื่องจากจะมีเอนทิตีที่แสดงถึงสถานะของเกมทำเครื่องหมายว่าถูกปิดใช้งานจากนั้นเมื่อสร้างการตรวจสอบเหตุการณ์อินพุตให้แน่ใจว่าเอนทิตีไม่ใช่ทายาทของเอนทิตีของเกมที่ถูกปิดใช้งาน ดูเหมือนว่ามีราคาแพงในการทำงานจากผู้ปกครองสำหรับการโทรกลับทุกครั้ง อีกแนวคิดหนึ่งคือให้ระบบทั้งหมดเก็บข้อมูลของพวกเขากับสถานะปัจจุบันด้วยวิธีนี้เมื่อสร้างอินพุตข้อมูลเอนทิตีเป้าหมายจะไม่เป็นตัวเลือก อย่างไรก็ตามสิ่งนี้ทำให้ความสามารถในการสื่อสารระหว่างเอนทิตีในรัฐต่าง ๆ (ไม่เป็นปัญหามากนักสำหรับหน้าจอหยุดชั่วคราว แต่คิดว่าการเลือกล็อคในการหลงลืม / Skyrim) ความคิดอื่น ๆ ที่ฉันมีคือการให้ส่วนประกอบทั้งหมดจัดการกับเหตุการณ์การเปลี่ยนแปลงสถานะและสื่อสารกับระบบที่เกี่ยวข้องของพวกเขาเพื่อปิดการใช้งานสิ่งที่พวกเขาได้ลงทะเบียนไว้และเปิดใช้งานอีกครั้งเมื่อเปลี่ยนกลับเป็นสถานะนี้ ข้อที่สอง (ทำเครื่องหมายวัตถุว่าปิดใช้งาน) และไปข้างหน้า (ให้แต่ละองค์ประกอบจัดการกับการเปลี่ยนแปลงสถานะ) ดูเหมือนจะเป็นความคิดที่ดีที่สุดของฉัน แต่ไม่มีสิ่งใดที่กระโดดออกมาที่ฉันว่ายอดเยี่ยมเป็นพิเศษ ใครบ้างมีความคิดอื่น ๆ เกี่ยวกับวิธีการทำเช่นนี้? แก้ไขขณะที่ฉันพูดถึงอินพุตโดยเฉพาะในคำถามนี้อาจหมายถึงระบบใด ๆ ที่สามารถส่งข้อความ / กิจกรรมไปยังเอนทิตีเช่นการชนเหตุการณ์จับเวลา ฯลฯ ...

16 component-based  entity-system  input  state 

ฉันกำลังสร้างเกม RPG / RTS ใน Unity มีอักขระจำนวนมากและอาจมีสภาพแวดล้อมที่แตกต่างกันมาก ฉันค่อนข้างมั่นใจในส่วนการเข้ารหัส (ดังนั้นคำถามนี้ไม่ได้ผูกติดอยู่กับเอ็นจิ้นเกม) ฉันยังสร้างดนตรีด้วยตัวเอง (งานเดี่ยว, กลองสดแบบอิงแผ่นในวงดนตรี, ผสมเพื่อเพื่อน ฯลฯ ) ดังนั้นฉันคิดว่าฉันมีความเข้าใจที่ดีเกี่ยวกับเครื่องมือที่จำเป็นทั้งหมด อย่างไรก็ตามฉันไม่เคยสร้างการออกแบบเสียงสำหรับเกมและฉันไม่เข้าใจวิธีการทำเช่นนั้นจริงๆ คุณจะจัดระเบียบและใช้เอฟเฟกต์เสียงอย่างไร ตัวอย่างเช่นคุณมี 5 ประเภทตัวละครที่แตกต่างกันและ 3 พื้นที่ที่แตกต่างกัน - หญ้าโคลนและไม้ตัวอย่างเช่นคุณจะสร้างเสียงฝีเท้า 5 * 3 หรือไม่? การเพิ่มพิชช์แบบสุ่มสำหรับความหลากหลายเป็นตัวอย่างที่ดีหรือไม่ สิ่งที่เกี่ยวกับเสียงของสภาพแวดล้อม - คุณสร้างวงวนหลักที่คุณเพิ่งเปิดตัวบนพื้นหลังหรือคุณวางเสียงจริง (น้ำลมลมต้นไม้เห่าเคลื่อนที่) นกทั่วทั้งเกม? โดยรวมแล้วฉันมีคำถามสุ่มโง่ ๆ มากเกินไปเพราะฉันไม่ค่อยเข้าใจว่าระบบนี้ควรได้รับการออกแบบอย่างไร ฉันจะขอบคุณมากหากมีคนให้ลิงก์ไปยังคู่มือหรือบทความเกี่ยวกับเรื่องนั้น

16 architecture  sound  sound-effects 

ฉันกำลังสร้างเกม platformer 2d เช่น Super Meat Boy ที่มีความแม่นยำในการเคลื่อนไหวของตัวละครหลักของฉัน ฉันใช้ libgdx การควบคุมแป้นพิมพ์บนพีซีทำงานได้อย่างแม่นยำ แต่เมื่อพูดถึงการจัดการกับ accelerometer มันยากที่จะจัดการกับตัวละครอย่างแม่นยำ สิ่งนี้แย่ลงเป็นระยะ ๆ ด้วยเส้นทางที่ปลอดภัยที่แออัดเพื่อหลบหนี ฉันคิดถึงการนำลูกบอลอะนาล็อกบนหน้าจอมาใช้ในการจัดการอินพุต แต่อ่านผลกระทบที่เลวร้ายมากมายบนอินเทอร์เน็ต วิธีการป้อนข้อมูลที่ใช้งานง่าย แต่แม่นยำในการใช้สำหรับเกม platformer บนอุปกรณ์ระบบสัมผัสคืออะไร

16 2d  input  touch  multitouch 

ฉันยังไม่พบคำถามในบรรทัดเหล่านี้แก้ไขให้ฉันถ้าฉันผิด ต้นไม้ (และสัตว์โดยทั่วไป) เป็นเรื่องธรรมดาในเกม เนื่องจากลักษณะของพวกเขาพวกเขาเป็นผู้สมัครที่ดีสำหรับการสร้างขั้นตอน มีSpeedTreeแน่นอนถ้าคุณสามารถจ่ายได้; เท่าที่ฉันสามารถบอกได้มันไม่ได้ให้ความเป็นไปได้ในการสร้าง tree tree ของคุณในขณะทำงาน จากนั้นมีSnappyTreeเครื่องมือสร้างแผนภูมิออนไลน์ webgl based โดยใช้proctree.jsซึ่งมีจาวาสคริปต์ประมาณ 500 บรรทัด หนึ่งสามารถใช้อย่างใดอย่างหนึ่งดังกล่าวข้างต้น (หรือบางกำเนิดต้นไม้อื่น ๆ ที่ฉันไม่ได้สะดุด) เพื่อสร้างต้นไม้สองสามโหลตาข่ายล่วงหน้า - หรือรูปแบบพวกเขาตั้งแต่เริ่มต้นในแบบจำลอง 3 มิติ - แล้วสุ่มสะท้อน / ปรับพวกเขาสำหรับตัวแปรอีกไม่กี่ .. แต่ฉันอยากจะมีเครื่องกำเนิดตาข่ายต้นไม้ที่เชื่อมโยงได้ฟรี การแก้ปัญหาที่เป็นไปได้: พอร์ต proctree.js ไปยัง c ++ และจัดการกับใบอนุญาตโอเพนซอร์ซ (ดูเหมือนจะไม่ใช่ gpl ดังนั้นจึงสามารถทำได้ผู้เขียนอาจเต็มใจร่วมมือเพื่อทำให้ใบอนุญาตนั้นฟรีมากขึ้น) ม้วนตัวเองตามระบบ L อย่ากังวลเพียงใช้ต้นไม้ที่สร้างแบบออฟไลน์ ใช้วิธีอื่นที่ฉันยังไม่พบ อัปเดต 2015 : สิ้นสุดการย้ายพอร์ต proctree.js …

16 3d  procedural-generation  tree  mesh 

วิธีการเรียงลำดับชั้นจะใช้ชุดอัลฟาที่มีพื้นผิวขนาดใหญ่จัดเรียงขนานกับพื้นดินซึ่งตัดกันรูปทรงเรขาคณิตของพื้นที่ทั้งหมดเพื่อให้ภาพลวงตาของหมอกบนพื้นดินค่อนข้างมีประสิทธิภาพจากระดับสูงมองลง มองไปที่ขอบฟ้า (ดูภาพด้านล่าง) อีกวิธีหนึ่งวิธีการที่ยึดตามส่วนใหญ่จะคำนวณความหนาแน่นเป็นฟังก์ชั่นของระยะการมองเข้าไปในพื้นผิวหมอกและส่งออกค่าชิ้นส่วนตามที่ โดยไม่ต้องทดสอบประสิทธิภาพแต่ละวิธีด้วยตนเองฉันอยากจะฟังประสบการณ์ของผู้อื่นก่อน(ไม่ใช่การเก็งกำไร!) กับสิ่งที่มีผลต่อประสิทธิภาพของการเรียงตัวของอัลฟาที่น่าจะเป็น ฉันถามอย่างเฉพาะเจาะจงเนื่องจากผลกระทบที่เกิดขึ้นจากการถอนเงินเกินจริง (ไม่แน่ใจว่าอัตราการเติมจะผูกไว้กับระบบเดสก์ท็อปเฉลี่ยของคุณอย่างไร) รายชื่อเกมที่ใช้วิธีการนี้โดยเฉพาะเกมที่เก่ากว่าจะมีประโยชน์อย่างมากหากเป็นไปได้สำหรับฮาร์ดแวร์ DX9 / OpenGL2 ที่ใช้งานได้ล่วงหน้ามันมีแนวโน้มที่จะทำงานได้ดีสำหรับฉัน หนึ่งคำถามใหญ่คือเกี่ยวกับลักษณะพิเศษนี้: (เครดิตรูปภาพไปที่ Lume of lume.com) สังเกตว่าการไล่ระดับหมอกในแนวดิ่งนั้นราบรื่นหรือต่อเนื่อง OTOH โดยใช้เลเยอร์สี่ชั้นที่มีพื้นผิวฉันสามารถสรุปได้ว่าเลเยอร์จะเห็นได้ชัดมากเมื่อเดินผ่านพวกเขา - ยิ่งเบาบางยิ่งพวกเขาก็จะยิ่งชัดเจนมากขึ้นเท่านั้น นี่คือสิ่งที่ตรงกันข้ามกับที่ระนาบหมอกที่ถูกจัดแนวเพื่อเผชิญหน้ากับผู้เล่นทุกเฟรม

16 opengl  3d  textures  shaders 

ดังนั้นวิดีโอเกม 360 / ps3 ใช้เวลาไม่กี่เดือนถึงไม่กี่ปีที่จะทำให้ฉันคิดว่า ถ้าเป็นเช่นนั้นเงินที่จ่ายให้พนักงานและค่าใช้จ่ายของทุกอย่างที่จำเป็นในการสร้างเกมมาจากไหนในช่วงสองสามเดือนหรือสองสามปี

16 costs  pricing