📈 🙌 🔽 गामेदेव में मठ सरल है। क्षेत्र और अभिन्न अंग 🤛🏾 👌 ☀️

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

वेक्टर गणित।

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

वेक्टर अंकगणित और उपयोगी कार्य

विश्लेषणात्मक सूत्र और अन्य विवरण Google के लिए आसान हैं, इसलिए हम इस पर समय बर्बाद नहीं करेंगे। संचालन खुद नीचे दिए गए जीआईएफ एनिमेशन द्वारा चित्रित किया जाएगा।

यह समझना महत्वपूर्ण है कि सार में कोई भी बिंदु एक वेक्टर है जो शून्य बिंदु पर शुरू होता है।

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

तीर वर्ग

using System.Collections; using System.Collections.Generic; using TMPro; using UnityEngine; public class VectorArrow : MonoBehaviour { [SerializeField] private Vector3 _VectorStart; [SerializeField] private Vector3 _VectorEnd; [SerializeField] private float TextOffsetY; [SerializeField] private TMP_Text _Label; [SerializeField] private Color _Color; [SerializeField] private LineRenderer _Line; [SerializeField] private float _CupLength; [SerializeField] private LineRenderer _Cup; private void OnValidate() { UpdateVector(); } private void UpdateVector() { if(_Line == null || _Cup == null) return; SetColor(_Color); _Line.positionCount = _Cup.positionCount = 2; _Line.SetPosition(0, _VectorStart); _Line.SetPosition(1, _VectorEnd - (_VectorEnd - _VectorStart).normalized * _CupLength); _Cup.SetPosition(0, _VectorEnd - (_VectorEnd - _VectorStart).normalized * _CupLength); _Cup.SetPosition(1, _VectorEnd ); if (_Label != null) { var dv = _VectorEnd - _VectorStart; var normal = new Vector3(-dv.y, dv.x).normalized; normal = normal.y > 0 ? normal : -normal; _Label.transform.localPosition = (_VectorEnd + _VectorStart) / 2 + normal * TextOffsetY; _Label.transform.up = normal; } } public void SetPositions(Vector3 start, Vector3 end) { _VectorStart = start; _VectorEnd = end; UpdateVector(); } public void SetLabel(string label) { _Label.text = label; } public void SetColor(Color color) { _Color = color; _Line.startColor = _Line.endColor = _Cup.startColor = _Cup.endColor = _Color; } }

चूंकि हम चाहते हैं कि वेक्टर एक निश्चित लंबाई का हो और हमारे द्वारा निर्दिष्ट बिंदुओं के अनुरूप हो, पंक्ति की लंबाई की गणना सूत्र द्वारा की जाती है:

 _VectorEnd - (_VectorEnd - _VectorStart).normalized * _CupLength

इस सूत्र में (_VectorEnd - _VectorStart) .normalized वेक्टर की दिशा है। इसे वैक्टर के अंतर के साथ एनीमेशन से समझा जा सकता है, यह मानते हुए कि _VectorEnd और _VectorStart एक शुरुआत (0,0,0) के साथ वैक्टर हैं।

इसके बाद, हम दो शेष मूल संचालन का विश्लेषण करते हैं:

गेम को विकसित करते समय सामान्य (लंब) और वेक्टर के मध्य को ढूंढना बहुत ही सामान्य कार्य हैं। आइए हम एक वेक्टर पर एक हस्ताक्षर रखने के उदाहरण द्वारा उनका विश्लेषण करते हैं।

 var dv = _VectorEnd - _VectorStart; var normal = new Vector3(-dv.y, dv.x).normalized; normal = normal.y > 0 ? normal : -normal; _Label.transform.localPosition = (_VectorEnd + _VectorStart) / 2 + normal * TextOffsetY; _Label.transform.up = normal;

वेक्टर के लिए पाठ को लंबवत रखने के लिए, हमें एक सामान्य चाहिए। 2 डी ग्राफिक्स में, सामान्य काफी सरल है।

 var dv = _VectorEnd - _VectorStart; var normal = new Vector3(-dv.y, dv.x).normalized;

इसलिए हम सेगमेंट में सामान्य हो गए।

normal = normal.y> 0? सामान्य: - असामान्य; - यह ऑपरेशन यह सुनिश्चित करने के लिए जिम्मेदार है कि पाठ हमेशा वेक्टर के ऊपर दिखाया गया है।

फिर इसे सदिश के बीच में रखने के लिए और इसे सामान्य से कुछ दूरी तक बढ़ाने के लिए रहता है जो सुंदर दिखाई देगा।

 _Label.transform.localPosition = (_VectorEnd + _VectorStart) / 2 + normal * TextOffsetY;

कोड स्थानीय स्थितियों का उपयोग करता है ताकि आप परिणामी तीर को स्थानांतरित कर सकें।

लेकिन यह 2 डी के बारे में था, लेकिन 3 डी के बारे में क्या?

3 डी में, प्लस या माइनस समान है। केवल सामान्य सूत्र भिन्न होता है, क्योंकि सामान्य पहले से ही खंड में नहीं लिया जाता है, लेकिन विमान तक।

कैमरे के लिए स्क्रिप्ट

 using System; using System.Collections; using System.Collections.Generic; using UnityEngine; public class SphereCameraController : MonoBehaviour { [SerializeField] private Camera _Camera; [SerializeField] private float _DistanceFromPlanet = 10; [SerializeField] private float _Offset = 5; private bool _IsMoving; public event Action<Vector3, Vector3, Vector3, float, float> OnMove; private void Update() { if (Input.GetMouseButtonDown(0) && !_IsMoving) { RaycastHit hit; Debug.Log("Click"); var ray = _Camera.ScreenPointToRay(Input.mousePosition); if(Physics.Raycast(ray, out hit)) { Debug.Log("hit"); var startPosition = _Camera.transform.position; var right = Vector3.Cross(hit.normal, Vector3.up).normalized; var endPosition = hit.point + hit.normal * _DistanceFromPlanet + right * _Offset; StartCoroutine(MoveCoroutine(startPosition, endPosition, hit.point + right * _Offset)); OnMove?.Invoke(startPosition, hit.point, hit.normal, _DistanceFromPlanet, _Offset); } } } private IEnumerator MoveCoroutine(Vector3 start, Vector3 end, Vector3 lookAt) { _IsMoving = true; var startForward = transform.forward; float timer = 0; while (timer < Scenario.AnimTime) { transform.position = Vector3.Slerp(start, end, timer / Scenario.AnimTime); transform.forward = Vector3.Slerp(startForward, (lookAt - transform.position).normalized, timer / Scenario.AnimTime); yield return null; timer += Time.deltaTime; } transform.position = end; transform.forward = (lookAt - transform.position).normalized; _IsMoving = false; } }

इस नियंत्रण उदाहरण में, विमान के सामान्य को प्रक्षेपवक्र के अंतिम बिंदु को दाईं ओर स्थानांतरित करने के लिए उपयोग किया जाता है ताकि इंटरफ़ेस ग्रह को अवरुद्ध न करे। 3 डी ग्राफिक्स में सामान्य दो वैक्टर का एक सामान्यीकृत वेक्टर उत्पाद है। जो सुविधाजनक है, एकता में ये दोनों ऑपरेशन हैं और हम एक सुंदर कॉम्पैक्ट रिकॉर्ड प्राप्त करते हैं:

 var right = Vector3.Cross(hit.normal, Vector3.up).normalized;

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

अभिन्न

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

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

अभिन्न क्या है?

वास्तव में, यह वक्र के नीचे का क्षेत्र है। लेकिन भौतिकी के संदर्भ में इसका क्या अर्थ है? मान लीजिए कि आपके पास समय के साथ गति वितरण है। इस मामले में, वक्र के नीचे का क्षेत्र वह पथ है जो ऑब्जेक्ट के माध्यम से जाएगा, और यह वही है जो हमें चाहिए।

थ्योरी से प्रैक्टिस की ओर बढ़ते हुए, एकता के पास एक बेहतरीन टूल है, जिसे एनिमेशन कर्व कहा जाता है। इसका उपयोग करते हुए, आप समय के साथ गति के वितरण को निर्दिष्ट कर सकते हैं। आइए ऐसी क्लास बनाएं।

कक्षा MoveObj

 using System.Collections; using UnityEngine; [RequireComponent(typeof(Rigidbody))] public class MoveObject : MonoBehaviour { [SerializeField] private Transform _Target; [SerializeField] private GraphData _Data; private Rigidbody _Rigidbody; private void Start() { _Rigidbody = GetComponent<Rigidbody>(); Move(2f, _Data.AnimationCurve); } public void Move(float time, AnimationCurve speedLaw) { StartCoroutine(MovingCoroutine(time, speedLaw)); } private IEnumerator MovingCoroutine(float time, AnimationCurve speedLaw) { float timer = 0; var dv = (_Target.position - transform.position); var distance = dv.magnitude; var direction = dv.normalized; var speedK = distance / (Utils.GetApproxSquareAnimCurve(speedLaw) * time); while (timer < time) { _Rigidbody.velocity = speedLaw.Evaluate(timer / time) * direction * speedK; yield return new WaitForFixedUpdate(); timer += Time.fixedDeltaTime; } _Rigidbody.isKinematic = true; } }

GetApproxSquareAnimCurve विधि हमारा एकीकरण है। हम इसे सबसे सरल संख्यात्मक विधि बनाते हैं, बस कार्यों के मूल्यों पर जाएं और उन्हें एक निश्चित संख्या में योग करें। मैं निष्ठा के लिए 1000 सेट करता हूं, सामान्य तौर पर, आप सबसे अच्छा चुन सकते हैं।

  private const int Iterations = 1000; public static float GetApproxSquareAnimCurve(AnimationCurve curve) { float square = 0; for (int i = 0; i <= Iterations; i++) { square += curve.Evaluate((float) i / Iterations); } return square / Iterations; }

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

आप देख सकते हैं कि ऑब्जेक्ट बिल्कुल मेल नहीं खाते हैं, यह एक फ्लोट त्रुटि के कारण है। सामान्य तौर पर, आप दशमलव में समान पुनर्गणना कर सकते हैं, और फिर अधिक सटीकता के लिए फ्लोट में आगे निकल सकते हैं।

दरअसल आज के लिए बस इतना ही। हमेशा की तरह, अंत में गिटहब परियोजना का एक लिंक है , जिसमें इस लेख के सभी स्रोत हैं। और आप उनके साथ खेल सकते हैं।

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

गामेदेव में मठ सरल है। क्षेत्र और अभिन्न अंग

More articles: