यूनिटी 3 डी टैंक ट्यूटोरियल: चेसिस (पाठ 1. वाहन यांत्रिकी के बुनियादी ढांचे)

प्रविष्टि

इसलिए आप यूनिटी के लिए नए नहीं हैं, आप एक दृश्य बना सकते हैं, एक मंच पर वस्तुओं को व्यवस्थित कर सकते हैं, इलाके बना सकते हैं, प्रीफ़ेब बना सकते हैं, आदि ... और सबसे महत्वपूर्ण बात, स्क्रिप्ट के साथ काम करना, या आपने पहले से ही लेखों का अध्ययन किया है: शुरुआती 1 के लिए यूनिटी 3 डी - ट्यूटोरियल 1 और यूनिटी 3 डी स्क्रिप्ट बेसिक्स । यह सब ज्ञान आपके लिए उपयोगी होगा क्योंकि इस पाठ में हम बहुत आगे बढ़ेंगे।

अर्थात्: इस पाठ के पहले भाग में, आप सीखेंगे कि व्हील कोलाइडर क्या है, वाहन चलाने के लिए इसका उपयोग कैसे करें और यथार्थवादी कार निलंबन व्यवहार बनाएं, पाठ के दूसरे भाग में, इस सब के आधार पर, मैं दिखाऊंगा कि संबंधित भौतिकी और नियंत्रकों के साथ टैंक की चेसिस कैसे बनाई जाए। ।

दरअसल, आप ऊपर की छवि में जो देखते हैं (यह इस पाठ का परिणाम होगा) आप ब्राउज़र में "लाइव" सही कोशिश कर सकते हैं। खुद करना चाहते हैं? फिर kat में आपका स्वागत है

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

लेकिन अगर आप पहले से ही जानते हैं कि व्हील कोलाइडर क्या है और इसके साथ क्या खाया जाता है, तो आप इस पाठ को छोड़ सकते हैं।

1. एक "कार" बनाएँ

शुरू करने के लिए, मानक प्रक्रियाओं का पालन करें, एक दृश्य बनाएं, एक इलाका बनाएं, या तैयार किए गए लोगों का उपयोग करें, फिर एक खाली गेम ऑब्जेक्ट (GO), (GameObject-> क्रिएट एम्प्टी) बनाएं, चलो इसे कार की तरह कुछ मूल कहें।

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


शरीर के अलावा, कार में पहिए होने चाहिए, अब एक सिलेंडर बनाएं (GameObject-> Create Other -> Cylinder), उसी स्केल का उपयोग करें, इसे व्हील का रूप दें, फिर इसे Z अक्ष 90 डिग्री पर घुमाएं (महत्वपूर्ण! केवल Z अक्ष के साथ! )।

व्हील फॉरवर्ड लेफ्ट में हमारे नए बनाए गए सिलेंडर का नाम बदलें, पहिया को उसके स्थान पर सेट करें, अर्थात, हमारे घन के सामने और बाएं (मैं दोहराता हूं, Z अक्ष का सकारात्मक भाग एकता में सबसे आगे माना जाता है)।

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




तो, हमारा सुपरकार लगभग तैयार है! इसे इलाके की सतह से थोड़ा ऊपर उठाएं और प्ले दबाएं, कार जमीन पर गिर जाएगी और एक दांव के साथ एक पहिया पर खड़ा होगा, वह केवल एक नरम निलंबन का सपना देख सकता है, प्ले मोड से बाहर निकल सकता है। जैसा कि आप देख सकते हैं, हमारे पहियों में कैप्सूल कोलाइडर , और बॉक्स कोलाइडर बॉडी नामक एक घटक है, मैं इस पाठ में नहीं बताऊंगा कि टकराव क्या हैं और उनके आधार पर अंतरिक्ष में किसी वस्तु की स्थिति की गणना कैसे करें, मैं और अधिक सरलता से समझाऊंगा: यदि कोई वस्तु किसी भी साधारण कोलाइडर (बॉक्स, कैप्सूल, मेश, ...) तब यह ऑब्जेक्ट अन्य वस्तुओं के साथ बातचीत कर सकता है, जिसमें एक रिगिडबॉडी और एक या एक से अधिक कोलाइडर होते हैं, बदले में, रिगिडॉडी वाली एक वस्तु सभी कोलाइडर के टकराव के आधार पर इसकी स्थिति की गणना करेगी। और उनके शारीरिक एम aterialov।

यदि आप ऊपर से कुछ भी नहीं समझते हैं, तो परेशान न हों, समझ अभ्यास के साथ आएगी।

इस बीच, हमारे प्रत्येक पहिये का चयन करें और उनके कैप्सूल कोलाइडर को हटा दें (उस पर राइट-क्लिक करें और घटक निकालें)। प्ले पर क्लिक करें, अब कार पहियों पर नहीं है, वे इलाके से गुजर चुके हैं और अब केवल शरीर सतह के साथ बातचीत करता है।

2. व्हील कोलाइडर जोड़ें

तो यह रहस्यमय व्हील कोलाइडर क्या है? चलो ठीक है। एक खाली गेमऑबजेक्ट बनाएं, इसे WCollider फॉरवर्ड लेफ्ट नाम दें, अब इसमें व्हील कोलाइडर घटक (घटक -> भौतिकी -> व्हील कोलाइडर) जोड़ें, यह अंदर एक सेगमेंट के साथ एक सर्कल की तरह दिखता है, यह आपके व्हील की तुलना में बहुत बड़ा या छोटा हो सकता है, सभी इस बात पर निर्भर करता है कि आप कितने पैमाने पर उपयोग कर रहे हैं। सौभाग्य से, उसके पास एक रेडियस पैरामीटर है, इस पैरामीटर को बदलते हुए, उसे अपने पहिये की त्रिज्या में फिट करें, फिर एक नया प्रीफ़ैब बनाएं (एसेट्स -> क्रिएट -> प्रीफ़ैब) इसे WCollider नाम दें और फिर WCollider फॉरवर्ड लेफ्ट को प्रीफ़ैब पर खींचें। हमने सुविधा के लिए एक प्रीफैब बनाया, क्योंकि हमारे पास पहिए के रूप में उतने ही कोलाइडर होंगे, और प्रत्येक के मापदंडों को बदलने के लिए नहीं, हम प्रीफैब के मापदंडों को बदल देंगे, बाकी सभी कोलाइडर इसके गुणों को प्राप्त करेंगे। अब हम मानक प्रक्रिया करते हैं, कार ऑब्जेक्ट पर WCollider Forward Left को खींचें और इसे सामने वाले बाएं पहिये के केंद्र में रखें, इसे 3 बार डुप्लिकेट करें, इसका नाम बदलें और इसे अन्य पहियों के अनुसार आगे बढ़ाएं।




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

तो, गेम मोड से बाहर निकलें, हमारे WCollider prefab का चयन करें, चलिए व्हील कोलाइडर घटक के गुणों को बदलते हैं:

1. सस्पेंशन डाइस्टेस - वास्तव में, यह हमारे निलंबन के वसंत की लंबाई है, 0.15 सेट
2. सस्पेंशन स्प्रिंग -> स्प्रिंग - निलंबन कठोरता, हमारे रिगिडो का वजन जितना अधिक होगा, उतनी ही कठोरता होनी चाहिए, 9000
3. सस्पेंशन स्प्रिंग -> डैम्पर - सस्पेंशन सॉफ़्नर, एक बड़ा मूल्य स्प्रिंग मूव को धीमा बनाता है, 100 को सेट करता है
4. मास - पहिया का द्रव्यमान, 1 छोड़ दें
5. फॉरवर्ड घर्षण - "फ्रंट" व्हील घर्षण बल, जैसा है वैसा ही छोड़ दें
6. बग़ल में घर्षण - "पार्श्व" पहिया घर्षण बल, उपयोगी अगर हम कार बहाव को लागू करना चाहते हैं, तो इसे छोड़ दें

कुल मिला:
(त्रिज्या को न देखें, आपके पास एक अलग हो सकता है, मुख्य बात यह है कि सर्कल आपके पहिया के साथ मेल खाता है)


तो, अब प्ले पर क्लिक करें, देखो, हमारी कार अब पूरी तरह से अलग तरीके से व्यवहार करती है, अब यह इलाके की सतह से झरती है, और यदि आप इसे एक पहाड़ी की ढलान पर डालते हैं, तो यह इससे लुढ़क जाएगा, यह है कि व्हील कोलाइडर्स हमारे लिए कैसे काम करते हैं।

लेकिन यह सब नहीं है कि वे सक्षम हैं, चलो पता करें कि कार चलाने के लिए उनका उपयोग कैसे करें और हमारे पहियों को स्पिन करें और इलाके के धक्कों का जवाब दें। हम स्क्रिप्ट के लिए शुरू करते हैं!

3. व्हील कोलाइडर्स प्रबंधित करें

इस ट्यूटोरियल में, मैं C # में स्क्रिप्ट लिखूंगा, मुझे JavaScript के लिए क्षमा करें, मैं इससे अधिक परिचित हूं, मुझे लगता है कि आप इसे समझ लेंगे।

एक नई C # स्क्रिप्ट बनाएं (एसेट्स -> क्रिएट -> C शार्प स्क्रिप्ट), इसे CarController कहें, इसे खोलें और इसे लिखें:

using UnityEngine; using System.Collections; public class CarController : MonoBehaviour { //1 public WheelCollider[] WColForward; //2 public WheelCollider[] WColBack; //3 // Use this for initialization void Start () { //4 } void FixedUpdate () { //5 } } 

1. स्क्रिप्ट के मुख्य वर्ग को स्क्रिप्ट फ़ाइल के समान कहा जाना चाहिए, अन्यथा कंपाइलर एक त्रुटि फेंक देगा।
2. सामने टकराने वालों का ऐरे।
3. पीछे के कोलियर की सरणी।
4. हम प्रारंभ () फ़ंक्शन का उपयोग आरंभ करने के लिए करेंगे।
5. जैसा कि मैंने यूनिटी 3 डी स्क्रिप्ट बेसिक्स ट्यूटोरियल में कहा था, अपडेट () फ़ंक्शन की तुलना में ऑब्जेक्ट के साथ भौतिक इंटरैक्शन के लिए फिक्स्डयूडेट () फ़ंक्शन का उपयोग करना बेहतर है।

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


अगला हम अपने साथियों के साथ काम करते हैं, हम स्क्रिप्ट के पूरक हैं:

 using UnityEngine; using System.Collections; public class CarController : MonoBehaviour { public WheelCollider[] WColForward; public WheelCollider[] WColBack; public float maxSteer = 30; //1 public float maxAccel = 25; //2 public float maxBrake = 50; //3 // Use this for initialization void Start () { } void FixedUpdate () { float accel = 0; float steer = 0; accel = Input.GetAxis("Vertical"); //4 steer = Input.GetAxis("Horizontal"); //4 CarMove(accel,steer); //5 } private void CarMove(float accel,float steer){ //5 foreach(WheelCollider col in WColForward){ //6 col.steerAngle = steer*maxSteer; //6 } if(accel == 0){ //7 foreach(WheelCollider col in WColBack){ //7 col.brakeTorque = maxBrake; //7 } }else{ //8 foreach(WheelCollider col in WColBack){ //8 col.brakeTorque = 0; //8 col.motorTorque = accel*maxAccel; //8 } } } } 

अब आप Play, और W, S बटन या फॉरवर्ड-बैकवर्ड एरो का उपयोग करके, हमारे "फॉर्मूला वन" को मूव कर सकते हैं, और दाईं ओर मुड़ने के लिए A, D बटन या लेफ्ट एरो का उपयोग कर सकते हैं।

आइए देखें कि यह स्क्रिप्ट क्या करती है:

1. पहियों के रोटेशन का अधिकतम कोण।
2. पहिया को प्रेषित अधिकतम टोक़।
3. अधिकतम ब्रेकिंग टॉर्क।
4. इनपुट क्लास का गेटएक्सिस () फ़ंक्शन एक ऐसी घटना की प्रतीक्षा करता है जो तब होता है जब हम कंट्रोलर पर मूवमेंट कीज़ दबाते हैं, या जॉयस्टिक की स्टिक को हिलाते हैं, फंक्शन वर्चुअल ऐक्सिस की दिशा लेता है (उदाहरण के लिए, "वर्टीकल W है, S कीज़ या जोस्टिक आगे-पीछे चलता है) और -1 से 1 तक एक नंबर देता है, जहां -1 या तो बाईं ओर एक पिछड़ा आंदोलन है, (एस कुंजी "ऊर्ध्वाधर" अक्ष में है, डी "क्षैतिज" में है) 0 - अक्ष सक्रिय नहीं हैं और 1 आगे की गति है, या दाईं ओर (डब्ल्यू कुंजी है) ऊर्ध्वाधर "अक्ष, A से" क्षैतिज ", या जॉयस्टिक की छड़ी को बाएं - दाएं घुमाते हुए)।
5. हम वर्चुअल कुल्हाड़ियों से कार्मोव () फ़ंक्शन के लिए प्राप्त परिणाम पास करते हैं।
6. WColForward सरणी में स्थित प्रत्येक व्हील कोलाइडर के लिए, हम स्टीयरएंगल चर (पहिया के रोटेशन के कोण) को क्षैतिज अक्ष से प्राप्त मूल्य से गुणा करके बदलते हैं।
7. यदि ऊर्ध्वाधर अक्ष आराम पर है (अर्थात, यदि हम डब्ल्यू या एस कुंजी दबाते नहीं हैं), तो हम ब्रेकटॉर्क कोलेर वैरिएबल को बदलते हैं, जो ब्रेकिंग बल के लिए ज़िम्मेदार है, यह आवश्यक है ताकि अगर हम आंदोलन की चाबियाँ नहीं दबाते हैं तो कार जड़ता से नहीं चलती है।
8. अन्य मामलों में, (यदि हम डब्ल्यू या एस कुंजी दबाते हैं), ब्रेकिंग बल शून्य है, और फिर हम ऊर्ध्वाधर अक्ष से प्राप्त मूल्य से गुणा करके मोटरटॉर्क चर (व्हील टॉर्क) को बदलते हैं, जिसके परिणामस्वरूप आपकी कार तेजी लाने लगती है।

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

चलो सब कुछ क्रम में बात करते हैं।

4. गुरुत्वाकर्षण का केंद्र

यह आश्चर्यजनक रूप से सरल सेट है, पहले हमें एक खाली GO बनाने की आवश्यकता है, इसे केंद्र का द्रव्यमान कहें, फिर इसे कार ऑब्जेक्ट पर खींचें, और इसे लगभग उस स्थान पर रखें जहां आपको लगता है कि यह होना चाहिए, उदाहरण के लिए, ताकि उच्च गति पर मुड़ने पर मेरी कार रोल न करें। मुझे इसे इस तरह बनाना था:





आप इसे एक अलग तरीके से रख सकते हैं, यह सब हमारे शरीर के बॉक्स कोलाइडर के ज्यामितीय आयामों पर निर्भर करता है, इसलिए गुरुत्वाकर्षण के केंद्र के साथ प्रयोग करें, लेकिन हमारी स्क्रिप्ट को जोड़ने के लिए:

1. एक वैरिएबल घोषित करें: सार्वजनिक रूपांतरण COM।
2. स्क्रिप्ट में COM फ़ील्ड में GO केंद्र को खींचें।
3. प्रारंभ () फ़ंक्शन के अंदर, निम्न पंक्ति लिखें: rigidbody.centerOfMass = COM.localPosition

अब आप Play पर क्लिक करें और परिणाम की जांच कर सकते हैं।

5. पहिया को "पुनर्जीवित" करें

खैर, हम फाइनल में पहुंच गए, मेरी राय में इस पाठ में सबसे दिलचस्प विषय और एक ही समय में एक जटिल विषय था।

पहिया को पुनर्जीवित करने के लिए, हमें प्रत्येक निश्चित फ्रेम में घूमने की स्थिति और कोण की गणना करने की आवश्यकता है, अद्भुत WheelCollider, इसकी GetGroundHit () विधि, जो WheelHit संरचना को वापस करने में सक्षम है, जिसमें बदले में कोलाइडर और इलाके का संपर्क बिंदु शामिल है, जो हमें फिर से मदद करेगा! चर बिंदु)। GetGroundHit () विधि के लिए धन्यवाद, हम निलंबन वसंत की गति के आधार पर पहिया की स्थिति की गणना कर सकते हैं। खैर, रोटेशन के कोण के रूप में - यह बहुत सरल है, व्हीलचेयर में एक फ्लोट चर आरपीएम है , यह प्रति मिनट रोटेशन का एक संक्षिप्त नाम है, इसके आधार पर हम पहिया के रोटेशन के कोण को निर्धारित कर सकते हैं।

हम स्क्रिप्ट को पास करते हैं, यह बड़ा हो गया है, मोटा हो गया है और अब इस तरह दिखता है:

 using UnityEngine; using System.Collections; public class CarController : MonoBehaviour { public WheelCollider[] WColForward; public WheelCollider[] WColBack; public Transform[] wheelsF; //1 public Transform[] wheelsB; //1 public float wheelOffset = 0.1f; //2 public float wheelRadius = 0.13f; //2 public float maxSteer = 30; public float maxAccel = 25; public float maxBrake = 50; public Transform COM; public class WheelData{ //3 public Transform wheelTransform; //4 public WheelCollider col; //5 public Vector3 wheelStartPos; //6 public float rotation = 0.0f; //7 } protected WheelData[] wheels; //8 // Use this for initialization void Start () { rigidbody.centerOfMass = COM.localPosition; wheels = new WheelData[WColForward.Length+WColBack.Length]; //8 for (int i = 0; i<WColForward.Length; i++){ //9 wheels[i] = SetupWheels(wheelsF[i],WColForward[i]); //9 } for (int i = 0; i<WColBack.Length; i++){ //9 wheels[i+WColForward.Length] = SetupWheels(wheelsB[i],WColBack[i]); //9 } } private WheelData SetupWheels(Transform wheel, WheelCollider col){ //10 WheelData result = new WheelData(); result.wheelTransform = wheel; //10 result.col = col; //10 result.wheelStartPos = wheel.transform.localPosition; //10 return result; //10 } void FixedUpdate () { float accel = 0; float steer = 0; accel = Input.GetAxis("Vertical"); steer = Input.GetAxis("Horizontal"); CarMove(accel,steer); UpdateWheels(); //11 } private void UpdateWheels(){ //11 float delta = Time.fixedDeltaTime; //12 foreach (WheelData w in wheels){ //13 WheelHit hit; //14 Vector3 lp = w.wheelTransform.localPosition; //15 if(w.col.GetGroundHit(out hit)){ //16 lp.y -= Vector3.Dot(w.wheelTransform.position - hit.point, transform.up) - wheelRadius; //17 }else{ //18 lp.y = w.wheelStartPos.y - wheelOffset; //18 } w.wheelTransform.localPosition = lp; //19 w.rotation = Mathf.Repeat(w.rotation + delta * w.col.rpm * 360.0f / 60.0f, 360.0f); //20 w.wheelTransform.localRotation = Quaternion.Euler(w.rotation, w.col.steerAngle, 90.0f); //21 } } private void CarMove(float accel,float steer){ foreach(WheelCollider col in WColForward){ col.steerAngle = steer*maxSteer; } if(accel == 0){ foreach(WheelCollider col in WColBack){ col.brakeTorque = maxBrake; } }else{ foreach(WheelCollider col in WColBack){ col.brakeTorque = 0; col.motorTorque = accel*maxAccel; } } } } 

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

तो एक चमत्कार होना चाहिए, आपके पहिये अब स्पिन होंगे और असली की तरह इलाके के धक्कों का जवाब देंगे।



यदि वे गलत दिशा में, या दूसरी दिशा में घूम रहे हैं, तो आपको चरण 1 को फिर से पढ़ना चाहिए जहां हमने कार बनाई थी, मैंने वहां कहा था कि पहियों को जेड अक्ष 90 डिग्री के साथ बिल्कुल मोड़ना महत्वपूर्ण है, मैं समझाऊंगा कि क्यों। आइए स्क्रिप्ट का विश्लेषण करें:

1. हम एरे बनाते हैं जो हमारे पहियों के ट्रांसफॉर्म को स्टोर करेगा।
2. ये चर हमारे लिए उपयोगी हैं, मैं नीचे बताऊंगा कि क्यों।
3. आइए एक ऐसा वर्ग बनाएं जिसमें हमारे प्रत्येक पहिए के बारे में आवश्यक जानकारी हो, अर्थात्:
4. पहियों को बदलना;
5. व्हील कोलाइडर व्हील्स;
6. पहिया की प्रारंभिक स्थिति;
7. पहिए के घूमने का कोण।
8. हम प्रकार के पहिए के साथ एक पहिया की घोषणा करते हैं WheelData।
9. हम पहियों सरणी के लिए आवश्यक डेटा पास करते हैं, इसके लिए मैंने SetupWheels () फ़ंक्शन लिखा था।
10. SetupWheels () फ़ंक्शन व्हील और उसके WheelCollider के ट्रांसफ़ॉर्म को स्वीकार करता है, आवश्यक डेटा को WheelData वर्ग में निहित चरों में पास करता है और इसे वापस करता है।
11. हम UpdateWheels () फ़ंक्शन लिखेंगे जिसमें हमारे पहियों के रोटेशन की स्थिति और कोण की गणना की जाएगी।
12. हमें याद है कि जिस टाइम क्लास की जरूरत है, उसे वेरिएबल फिक्सडेलटाइम की जरूरत है ताकि व्हील का रोटेशन समान रूप से स्ट्रेच हो जाए।
13. पहियों के प्रत्येक तत्व के लिए, निम्न ऑपरेशन करें:
14. एक वर्ग चर WheelHit बनाएं (मैंने इसके बारे में ऊपर बात की है);
15. हम पहिया की स्थानीय स्थिति को याद करते हैं (स्थानीय स्थिति माता-पिता के निर्देशांक के सापेक्ष स्थिति है, वैश्विक दुनिया के सापेक्ष है);
16. यदि व्हीलचेयर का पहिया टेरीनर (या कुछ और) की सतह से टकराता है;
17. फिर हम उस बिंदु पर शुरुआत के साथ वेक्टर के बीच पहिया के स्थानीय स्थिति के Y समन्वय से डॉट () को हटाते हैं, जहां कोलाडर इलाके की सतह (हिट.पॉइंट) के संपर्क में है और वर्तमान पहिया की स्थिति (wwheelTransform.position) पर और वेक्टर के बीच कार ऑब्जेक्ट के ऊपर की ओर इंगित करता है। (transform.up) और इस सब से हम व्हीलरेडियस वेरिएबल को भी घटाते हैं, ताकि व्हील सही जगह लगे। (यदि पूर्वगामी से आप एक शब्द नहीं समझते हैं, तो निराश मत होइए ज्यादातर लोग इसे पहली बार नहीं समझते हैं, इसके लिए आपको यह जानने की जरूरत है कि डॉट उत्पाद क्या है और यह उपरोक्त वैक्टर से कैसे संबंधित है, या बस यह जान लें कि पहिया की स्थिति की गणना उसी तरह की जानी चाहिए। );
18. अगर WheelCollider terrane की सतह को नहीं छूता है। तब हम पहिए की प्रारंभिक स्थानीय स्थिति के Y समन्वय से व्हीलऑफसेट को हटा देते हैं, इसके लिए धन्यवाद कि हमारे पहिए किसी अज्ञात दिशा में नहीं उड़ते हैं जब कार ऊंचाई से गिरती है या उसके "पीछे" स्थित होती है;
19. पहिया की परिवर्तित स्थिति को उसकी वर्तमान स्थिति पर लागू करें;
20. हम Mathf वर्ग के रिपीट () फ़ंक्शन का उपयोग करके पहिया के "रोटेशन" कोण की गणना करते हैं, यह फ़ंक्शन हमें कोण को 0 से 360 डिग्री तक रखने में मदद करता है, हम कोण की गणना स्वयं को करते हैं, न कि इतने परिष्कृत सूत्र (w.rotn + डेल्टा * w.col.rpm के लिए) * 360.0f / 60.0f) जहां हम वास्तव में प्रति मिनट घूर्णन की संख्या को कोलाडर में संग्रहीत वर्तमान रोटेशन कोण से गुणा करके 360/60 से गुणा करते हैं।
21. हम परिणामी परिणाम को वर्तमान स्थानीय रोटेशन कोणों पर लागू करते हैं, Quaternion वर्ग के Euler () फ़ंक्शन से हमें इसमें मदद मिलती है, जो Euler कोणों में quaternion लौटाता है (कोई फर्क नहीं पड़ता कि शब्द quaternion कितना डरावना है, मैं आपको स्थानीय और वैश्विक रोटेशन कोणों को संग्रहीत करने वाली संरचना के रूप में सार करने और इसका इलाज करने की सलाह देता हूं, हालांकि इसका मतलब है कि यह पूरी तरह से अलग है, यहाँ मैं आपको ठीक से नहीं बताऊँगा, यह समझना आसान होगा)। पहला तर्क (जो कि एक्स अक्ष के चारों ओर का कोण है) हम पहिया के "रोटेशन" के हमारे परिकलित कोण को स्थानांतरित करते हैं, दूसरा तर्क (वाई अक्ष के चारों ओर का कोण) हम कोलाइडर के रोटेशन के कोण को प्रसारित करते हैं, और तीसरा तर्क (जेड अक्ष के साथ कोण, अब आप समझते हैं कि यह पैराग्राफ 1 में क्यों महत्वपूर्ण था) Z अक्ष के चारों ओर बिल्कुल पहियों को चालू करें) हम निरंतर 90.0f को धोखा देते हैं।

निष्कर्ष

खैर, यह सब मैं आपको बता सकता हूं कि यूनिटी 3 डी पर एक नियमित कार के मैकेनिक्स का निर्माण कैसे करें, उपरोक्त सभी को पढ़ने और महसूस करने के बाद, आप तुरंत एक रेसिंग सिम्युलेटर बनाने के लिए सेट कर सकते हैं।

ठीक है, पाठ के अगले भाग में, जैसा कि मैंने वादा किया था, मैं बात करूँगा कि टैंक पटरियों के यांत्रिकी का निर्माण कैसे किया जाए, मैं इसे 3D संपादक में मॉडलिंग करने के तरीकों के बारे में भी बात करूँगा और इससे एक मॉडल निर्यात करने और इसे एकता में आयात करने के बारे में थोड़ा और स्वाभाविक रूप से, मैंने आपको इसे अनुकरण करने के लिए मजबूर नहीं किया आपने इस डेमो में क्या देखा, लेकिन मैं एक तैयार मॉडल प्रदान करूंगा। यूनिटी 3 डी सीखने में आपका ध्यान और शुभकामनाओं के लिए धन्यवाद।

>> पाठ 2