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