यूनिटी 3 डी: एक दृश्य में एक बिंदु की रोशनी की डिग्री का पता लगाने के लिए कैसे?

नमस्ते!

मुझे पता है, और दिल से आप जानते हैं कि आपके कार्ड गेम या थ्री-इन-वन गेम्स गायब हैं। चुपके सिस्टम!

और निश्चित रूप से, चुपके के किसी भी स्वाभिमानी खिलाड़ी को खिलाड़ी के चारों ओर के वातावरण की रोशनी को ध्यान में रखना चाहिए। मैं विषय को खोदने और असामान्य रूप से कम मात्रा में जानकारी प्राप्त करने के लिए चकित था। इसलिए, मैं फलों को साझा करने की जल्दबाजी करता हूं।

आज हम खिलाड़ी के लिए चुपके से एक पूर्ण विकसित प्रणाली विकसित नहीं करेंगे, हम प्रकाश के साथ विशुद्ध रूप से बातचीत पर विचार करेंगे।

विधि 1: कोलाइडर

एक सरल और बहुत संसाधन-गहन तरीका नहीं है।

हम प्रत्येक प्रकाश स्रोत में एक गोलाकार कोलाइडर जोड़ते हैं। हम इसे एक ट्रिगर बनाते हैं। हम प्रकाश के त्रिज्या के बराबर आयाम सेट करते हैं।

बाकी एक छाया की तरह स्पष्ट है। हम एक साधारण स्क्रिप्ट लिख रहे हैं, जहां OnTriggerEnter () में हम प्रकाश गणना की सक्रियता रखते हैं (ताकि खिलाड़ी पास न होने पर प्रकाश स्रोत "निष्क्रिय" काम न करें)।

रोशनी की गणना स्वयं अपडेट () में स्थित होगी। संक्षेप में, यह सामान्य भौतिकी है। राईकास्ट ()। यदि यह खिलाड़ी को हिट करता है, तो खिलाड़ी प्रकाश क्षेत्र में है। यदि यह नहीं गिरता है, तो इसका मतलब है कि खिलाड़ी बाधाओं के पीछे है और इसलिए, छाया में।

आप यहां खिलाड़ी और प्रकाश स्रोत के बीच की दूरी की गणना भी जोड़ सकते हैं। इस प्रकार, रोशनी को निर्धारित करने के लिए, हम एक साधारण फ्लोट का उपयोग करेंगे, जो प्रकाश स्रोतों से दूरी के आधार पर भिन्न होगा। और जहाँ भी आपकी दिल की इच्छा हो, आप उसका उपयोग कर सकते हैं


और वह सब नहीं है! आप विभिन्न "शैडो ज़ोन" में ट्रिगर कोलाइडर जोड़ सकते हैं जहाँ खिलाड़ी को छिपाना चाहिए। मैनहंट की सबसे अच्छी परंपराओं में। इसी तरह, आप उज्ज्वल क्षेत्र को कोलाडर के साथ चिह्नित कर सकते हैं, अनुकरण कर सकते हैं, उदाहरण के लिए, स्पॉटलाइट की रोशनी।

फायदे:

• प्वाइंट रोशनी को अनुकूलित करने के लिए आसान है।
• यदि आप प्रकाश के स्रोतों को स्पैम नहीं करते हैं, तो संसाधनों के संदर्भ में काफी किफायती।

नुकसान:

• स्पॉट लाइट और डायरेक्शनल लाइट को काफी ट्यून किया गया है। यदि पहली बार यह प्रकाश के क्षेत्र में कॉइलर को स्थिति में लाने के लिए पर्याप्त है (प्रवेश द्वार पर खिलाड़ी की दृश्यता बढ़ाने के लिए), तो दूसरा वास्तविक हॉरर है। आपको प्रत्येक छाया में (या प्रवेश द्वार पर खिलाड़ी की दृश्यता को कम करने के लिए) कोलाइडर को रखने की आवश्यकता होती है, या खिलाड़ी और "सूर्य" के बीच लगातार Physics.Raycast () के साथ जांच करें - यह किरणों या छाया में स्थित है।
• बड़ी संख्या में कोलाइडर दृश्य को अव्यवस्थित करते हैं, भौतिकी को जटिल करते हैं।
• प्रकाश स्रोतों को प्रतिच्छेदन के साथ देखभाल की जानी चाहिए।
• डायनामिक लाइट (चलती या बदलती तीव्रता) को स्क्रिप्ट के माध्यम से अलग से जोड़ने की आवश्यकता होती है।

विधि 2: रेंडरटेक्स्ट

हम यहां क्या कर रहे हैं? वास्तव में, हमें कैमरे से एक "स्क्रीनशॉट" मिलता है, और मुख्य कैमरा से जरूरी नहीं है। और फिर हम स्क्रीनशॉट के रंग का विश्लेषण करते हैं ताकि पता लगाया जा सके कि विषय पर कितना उज्ज्वल प्रकाश गिरता है।

शुरू करने के लिए, हमें एक वस्तु की आवश्यकता है जिससे हम प्रकाश को "पढ़ेंगे"। एक नियमित गोले या विमान का निर्माण करें, इसे छोटा करें (स्केल 0.1), इसे फर्श के करीब रखें, इसे सफेद बना दें, कोलाइडर हटा दें:


एक कैमरा जोड़ें (ऑडियो श्रोता को निकालना सुनिश्चित करें और जांच लें कि मेनकैमरा टैग इसके लायक नहीं है)। इसे हमारी वस्तु से बांधो। हम इसे थोड़ा अधिक डालते हैं, हम इसे नीचे निर्देशित करते हैं। हम मुख्य प्रदर्शन नहीं सेटिंग्स में उजागर करते हैं। यह करना ओर्थोग्राफिक आपके स्वाद के लिए है।

अंत में, हम इसे स्थिति में रखते हैं ताकि यह हमारी वस्तु पर और केवल उस पर दिखाई दे।


अंत में, प्राथमिक और द्वितीयक कैमरों के कुलिंग मास्क को कॉन्फ़िगर करें ताकि प्राथमिक हमारी "प्रकाश" वस्तुओं को प्रदर्शित न करें, जबकि माध्यमिक केवल उन्हें देखते हैं, बिना कुछ और अव्यवस्था के।

और यहीं से मस्ती शुरू होती है। हम स्क्रिप्ट को कैमरे से जोड़ते हैं:

public Camera cam; //   RenderTexture tex; Texture2D _tex; void Start () { //    "". // ,       -   . // Depth   0   -   . tex = new RenderTexture (1, 1, 8); // RenderTexture "" , //   ,    . _tex = new Texture2D (1, 1, TextureFormat.RGB24, false); } void Update () { //   ""  cam.targetTexture = tex; cam.Render (); //     RenderTexture.active = tex; //   Texture2D _tex.ReadPixels (new Rect (0, 0, 1, 1), 0, 0); _tex.Apply (); Color col = _tex.GetPixel (0, 0); float vis = (col.r + col.g + col.b) / 3; } 

आउटपुट पर, हमें एक फ्लोट विज़ मिलता है, जो संक्षेप में, हमारी वस्तु पर रोशनी की घटना के स्तर का एक संख्यात्मक प्रतिनिधित्व है। यदि स्रोत करीब है - वस्तु सफेद है - विज़ है 1. यदि यह अंधेरा है - ऑब्जेक्ट काला है - विज़ ~ ~ 0 है।

हमें उपरोक्त ऑपरेशन को हर फ्रेम में करने की आवश्यकता नहीं है, इसलिए हम एक छोटे से दूसरे टाइमर को एम्बेड करते हैं:

 float interval = 0; void Update () { interval += Time.deltaTime; if (interval < 1) return; interval = 0; //   } 

इसके बाद, हम अपने पूरे सिस्टम को प्लेयर पर बाँध देते हैं ताकि वह उसके साथ चले। और हमारा विज़ वेरिएबल स्वचालित रूप से खिलाड़ी के चारों ओर प्रकाश देता है!

इस प्रणाली का उपयोग न केवल खिलाड़ी के साथ संयोजन के रूप में किया जा सकता है। आप इसे कहीं भी रख सकते हैं और जैसे चाहें, एक तरह के लाइट सेंसर बना सकते हैं। एक नियम के रूप में, उन्हें लागू करने के लिए अधिक प्रभावी तरीके हैं, लेकिन क्या विकल्प रखना हमेशा अच्छा होता है?

फायदे स्पष्ट हैं, चलो नुकसान के बारे में बात करते हैं।

कमियों

• प्रत्येक "लाइट डिटेक्टर" (यदि एक से अधिक हैं) को एक अलग कैमरे की आवश्यकता होती है।
• Texture2D.ReadPixels () - ठीक है, बहुत धीमी। यहां तक ​​कि अगर आप इसे एक बार एक दूसरे को करते हैं, और हर फ्रेम नहीं, भले ही आप अलग-अलग फ्रेम में टेक्स्ट लिखने और पढ़ने के कार्यों को तोड़ते हैं, फिर भी 40-110ms पर लेआउट हैं।
• यह प्रणाली कुछ दुर्लभ मामलों को ध्यान में नहीं रखती है। उदाहरण के लिए, एक चरित्र पर एक टॉर्च चमकता है। चरित्र अच्छी तरह से जलाया जाता है, लेकिन प्रकाश उस पर और उसके पीछे पड़ता है, और नीचे नहीं, क्रमशः, हमारा प्रकाश डिटेक्टर निम्न स्तर का प्रकाश दिखाता है। आप समस्या को हल कर सकते हैं, उदाहरण के लिए, डिटेक्टर को फर्श पर नहीं रखकर, बल्कि चरित्र की छाती के स्तर पर। फिर आपको दोनों तरफ प्रकाश को पढ़ने के लिए दो तरफ विपरीत कैमरों को लगाने की आवश्यकता है। क्या सिस्टम को आधा करके धीमा कर देगा।