लाइन रेंडरर की रेखाएँ सपाट कैसे रहें?

Question

मैंने देखा है कि जैसे ही मैं एक लाइन रेंडरर लाइन में अधिक शीर्ष जोड़ देता हूं, लाइन मुड़ जाती है और एक चिकनी रेखा बन जाती है।

.गिफ़ यहाँ: http://i.imgur.com/hRAhCXM.gif

सभी पंक्तियाँ समान z स्तर पर हैं, भले ही मैं उन सामग्रियों को हटा दूं जो रेखाएँ अभी भी मुड़ती दिख रही हैं।

मुझे नहीं पता कि यह ऐसा क्यों करता है, या इसे हल करने के बारे में कैसे जाना जाता है, कोई सुझाव? सी #

Comments

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

— DMGregory

अद्यतन: यूनिटी के बाद के संस्करणों (5 5+) ने लाइनरेंडर एल्गोरिथ्म में सुधार किया है , इसलिए लाइनरेंडर का उपयोग करने पर विचार करने वाले उपयोगकर्ता इन दिनों आउट-ऑफ-द-बॉक्स परिणाम काफी बेहतर हो सकते हैं।

— DMGregory

Answer 1

समस्या मूल रूप से यह है:

लाइनरेंडर लाल बिंदुओं को जोड़ने की कोशिश कर रहा है। यह एक जाली बनाने के लिए हरे रंग के कोने का निर्माण कर रहा है। तो शीर्ष पंक्ति खंड बहुत अच्छा लग रहा है। लेकिन फिर लाइनरेंडर किफायती होने की कोशिश करता है, यह दूसरी पंक्ति के खंड के अंत में एक पंक्ति खंड के अंत से कोने का पुन: उपयोग करता है। जब कोई तीव्र कोण होता है, तो आपको वह समस्या दिखाई देती है जो आप देख रहे हैं। दूसरी पंक्ति के खंड को चौराहे पर पिन किया गया है क्योंकि इसकी 'एंड कैप' इसकी अन्य 'एंड कैप' के साथ लंबवत नहीं है।

समाधान यह है कि आप अपनी स्वयं की लाइन रेंडरर बनाएं, न कि इसे इतना किफायती बनाएं। आप एक गतिशील जाल उत्पन्न करके ऐसा कर सकते हैं । मेष में पतली क्वाड्स की एक श्रृंखला शामिल होगी। प्रत्येक पंक्ति खंड के लिए, आप पंक्ति के सामान्य और एक निर्दिष्ट लाइन चौड़ाई की गणना करके क्वाड के चार कोनों की गणना कर सकते हैं:

Vector3 normal = Vector3.Cross(start, end);
Vector3 side = Vector3.Cross(normal, end-start);
side.Normalize();
Vector3 a = start + side * (lineWidth / 2);
Vector3 b = start + side * (lineWidth / -2);
Vector3 c = end + side * (lineWidth / 2);
Vector3 d = end + side * (lineWidth / -2);

इधर, a, b, cऔर dऊपर एक लाइन खंड के चारों कोनों बनाने के लिए, बस ऊपर छवि में हरी डॉट्स की तरह। ये कोने जाल में जोड़ दिए जाएंगे, और आप चार कोणों को दो त्रिकोणों में बनाने के लिए सूचक भी जोड़ देंगे (इसलिए, छह सूचक जोड़े जाएंगे, abc और bdc)।

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

Comments

आप शायद एकता लाइन रेंडरर का उपयोग करने और एक छोटा सा मैटर बनाने के लिए अतिरिक्त अंक डालने के साथ भी दूर हो सकते हैं। बस एक बिंदु को पिछले बिंदु से अगले बिंदु की ओर थोड़ा सा रास्ता दें।

— एमकेलिंगन

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

— डगलस गास्केल

Answer 2

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

Vector3[] Generate_Points(Vector3[] keyPoints, int segments=100){
    Vector3[] Points = new Vector3[(keyPoints.Length - 1) * segments + keyPoints.Length];
    for(int i = 1; i < keyPoints.Length;i++){
        Points [(i - 1) * segments + i - 1] = new Vector3(keyPoints [i-1].x,keyPoints [i-1].y,0);
        for (int j = 1;j<=segments;j++){
            float x = keyPoints [i - 1].x;
            float y = keyPoints [i - 1].y;
            float z = 0;//keyPoints [i - 1].z;
            float dx = (keyPoints [i].x - keyPoints [i - 1].x)/segments;
            float dy = (keyPoints [i].y - keyPoints [i - 1].y)/segments;
            Points [(i - 1) * segments + j + i - 1] = new Vector3 (x+dx*j,y+dy*j,z);
        }
    }
    Points [(keyPoints.Length - 1) * segments + keyPoints.Length - 1] = new Vector3(keyPoints [keyPoints.Length-1].x,keyPoints [keyPoints.Length-1].y,0);
    return Points;
}

Comments

यह अब मूट हो सकता है - यूनिटी ने लाइनरेंडर को 5.5 संस्करण में तय किया है, इसलिए यह पुराने कोनों की तरह तेज कोनों में नहीं रह गया है।

— DMGregory

Answer 3

अपारदर्शी लाइनों के लिए इसे हल करने का एक तरीका प्रत्येक संयुक्त पर एक चक्र प्रदान करना है। सर्कल को लाइन की चौड़ाई के बराबर व्यास का होना चाहिए। इसके लिए कुछ अतिरिक्त कोने प्रस्तुत करने की आवश्यकता होती है, लेकिन वास्तव में अच्छा लगता है। फिर आप जोड़ों के बीच साझा मानदंडों से भी छुटकारा पा सकते हैं।

इसके लिए यह आवश्यक है कि आप यूनिटी लाइन रेंडरर का उपयोग करने के बजाय अपना रेंडरिंग कोड लिखें।

मैंने एक संपत्ति बनाई जो http://u3d.as/nFE पर बस यही करती है

Answer 4

जिस तरह से मैं इससे बचता हूं वह यह है कि मैं हमेशा लाइनरेंडरर.सेपशन () पद्धति में z स्थिति को 0 पर सेट करता हूं। इसलिए लिखने के बजाय

LineRenderer.SetPosition(i, myVector3);

मैंने लिखा

LineRenderer.SetPosition(i, new Vector3(myVector3.x, myVector3.y, 0));

लेकिन यह सबसे अच्छा समाधान नहीं है क्योंकि आप अभी भी उन अजीब लाइनों को प्राप्त करेंगे। सबसे अच्छा समाधान जो मैं सोच सकता था कि अलग लाइनें बना रहा था। मेरे लिए यह पूरी तरह से काम किया। आशा है कि यह आपकी मदद करता है।