3 डी खेल ज्यामिति

Question

मैं एक सरल खेल एक 3 डी ग्रिड प्रतिनिधित्व का उपयोग करता है, कुछ की तरह:

double x,y,z, dx,dy,dz; 

:

Blocks grid[10][10][10]; 

खेल में व्यक्ति एक बिंदु और एक दृष्टि वेक्टर का प्रतिनिधित्व करती है मैं छोरों के लिए नेस्ट 3 के साथ ग्रिड आकर्षित:

for(...) for(...) for(...) 
    draw(grid[i][j][k]); 

जब ग्रिड के आकार हुन भीतर बढ़ता है इस के साथ स्पष्ट समस्या है ड्रेड्स, एफपीएस नाटकीय रूप से ड्रॉप। कुछ अंतर्ज्ञान के साथ, मुझे एहसास हुआ कि:

• ब्लाकों कि ग्रिड में अन्य ब्लॉक से छिपी हुई हैं भी करने की आवश्यकता नहीं है प्रदान करने की
• ब्लाकों उस व्यक्ति की दृष्टि क्षेत्र के भीतर नहीं थे की जरूरत नहीं है गाया (यानी। ब्लॉकों उस व्यक्ति के पीछे थे)

मेरा प्रश्न दिया जाता है, एक grid[][][], एक व्यक्ति की x,y,z, और एक दृष्टि वेक्टर dx,dy,dz, मैं कैसे यह पता लगाने सकता है जो ब्लॉकों प्रदान करने की जरूरत है और जो डॉन ' टी?

Answer 1

मैंने थोड़ी देर पहले एक 3 डी गेम इंजन JMonkeyEngine का उपयोग करने में देखा और उनके द्वारा नियोजित कुछ तकनीकों को देखा। जो मुझे याद है, वे कूलिंग नामक कुछ का उपयोग करते हैं। वे 'दुनिया' में मौजूद सभी चीजों की वृक्ष संरचना का निर्माण करते हैं। विचार यह है कि आपके पास इस पेड़ का सबसेट है जो किसी भी समय दृश्यमान वस्तुओं का प्रतिनिधित्व करता है। दूसरे शब्दों में, ये वे चीजें हैं जिन्हें प्रस्तुत करने की आवश्यकता है। तो, उदाहरण के लिए कहें कि मेरे पास कमरे में वस्तुओं के साथ एक कमरा है। कमरा पेड़ पर है और कमरे में वस्तुओं पेड़ के बच्चे हैं। अगर मैं कमरे के बाहर हूं, तो मैं पेड़ की इस शाखा को हटा देता हूं (हटा देता हूं) जिसका मतलब है कि मैं इसे प्रस्तुत नहीं करता हूं। कारण यह इतना अच्छा काम करता है कि मुझे यह देखने के लिए दुनिया में हर वस्तु का मूल्यांकन करने की ज़रूरत नहीं है कि इसे प्रस्तुत किया जाना चाहिए, लेकिन इसके बजाय मैं जल्दी से दुनिया के पूरे हिस्सों को छीनता हूं जो मुझे पता नहीं होना चाहिए।

इससे भी बेहतर, फिर जब मैं कमरे के अंदर कदम रखता हूं, तो मैं दुनिया के बाकी हिस्सों को पेड़ से ट्रिम करता हूं और फिर केवल कमरे और उसके सभी वंश को प्रस्तुत करता हूं।

मुझे लगता है कि जेमोनकीइंजिन टीम ने डिजाइन किए गए कई निर्णय डेविड एबरली की पुस्तक 3D Game Engine Design में चीजों पर आधारित थे। मुझे इस तरह के दृष्टिकोण को कार्यान्वित करने के तकनीकी विवरणों को नहीं पता, लेकिन मुझे यकीन है कि यह पुस्तक आपके लिए एक महान प्रारंभिक बिंदु होगी।

यहाँ एक दिलचस्प article कुछ अलग culling एल्गोरिदम पर है:

• देखें छिन्नक मुर्गियों को मारने
• वापस चेहरा मुर्गियों को मारने
• सेल आधारित रोड़ा
• को मारने पी वी एस आधारित मनमाना ज्यामिति रोड़ा मारने
• अन्य

Answer 2

सबसे पहले आपको एक स्थानिक विभाजन संरचना की आवश्यकता है, यदि आप समान ब्लॉक आकार का उपयोग कर रहे हैं, तो शायद सबसे प्रभावी संरचना octree होगी। फिर आपको एक एल्गोरिदम लिखना होगा जो गणना कर सकता है कि कोई बॉक्स किसी विमान के किसी विशेष पक्ष (या छेड़छाड़) पर है या नहीं।एक बार जब आप यह कर लें कि आप काम कर सकते हैं कि ऑक्टेट के कौन से पत्ते नोड्स आपके दृश्य के छः किनारों के अंदर हैं - यह को खींचने के लिए देखें। ऑक्टेट्री का उपयोग करके आप यह निर्धारित कर सकते हैं कि कौन से ब्लॉक दूसरों को गुमराह करते हैं (कभी-कभी फ्रस्टम मास्किंग) कहा जाता है, लेकिन पहले भाग को पहले काम करें।

Answer 3

ऐसा लगता है जैसे आप एक Minecraft-y प्रकार की चीज़ के लिए जा रहे हैं। this android minecraft level renderer पर एक नज़र डालें। नोट करने के लिए अंक हैं:

• आपको केवल पारदर्शी ब्लॉक के साथ साझा किए गए ब्लॉक के चेहरे को आकर्षित करना होगा। उदाहरण: दो अपारदर्शी ब्लॉक के बीच चेहरों को चित्रित करने से परेशान न करें - खिलाड़ी उन्हें कभी नहीं देख पाएगा।
• आप शायद अपनी दृश्यमान ब्लॉक ज्यामिति को चंकलेट में बैच करना चाहते हैं (और इसे एक वीबीओ में चिपकाएं) और प्रति-चंकलेट आधार पर दृश्यता निर्धारित करें। ढूँढना ठीक है जो ब्लॉक देखे जा सकते हैं शायद जीपीयू पर वीबीओ को घुमाने और ओवरड्रा स्वीकार करने से अधिक समय लगेगा।
• बाढ़ भरने के लिए यह निर्धारित करने के लिए बहुत अच्छी तरह से काम करता है कि कौन से चंकलेट दिखाई दे रहे हैं - दृश्य को देखते हुए भरें सीमित करें, दिशा देखें (यदि आप + x x दिशा में सामना कर रहे हैं, तो दिशा में बाढ़ न करें) , और चंकलेट डेटा के सरल विश्लेषण (उदाहरण: यदि एक चंकलेट का पूरा चेहरा अपारदर्शी है, तो उस चेहरे से बाढ़ न करें)