unity3d
Transforms

वाक्य - विन्यास

• शून्य ट्रांसफ़ॉर्म। ट्रांसलेट (वैक्टर 3 अनुवाद, स्पेस रिलेटिव = स्पेस। सेल्फ)
• void Transform.Translate (फ्लोट x, फ्लोट y, फ्लोट z, स्पेस रिलेटिव = Space.Self)
• शून्य ट्रांसफ़ॉर्म। रोटेट (वेक्टर 3 यूलरएंगल्स, स्पेस रिलेटिव = स्पेस.फिल)
• शून्य ट्रांसफ़ॉर्म। रोटेट (फ़्लोट xAngle, फ़्लोट yAngle, फ़्लोट zAngle, स्पेस रिलेटिव = Space.Self)
• शून्य ट्रांसफ़ॉर्म। रोटेट (वेक्टर 3 अक्ष, फ्लोट एंगल, स्पेस रिलेटिव = स्पेस.सेल्फ)
• शून्य ट्रांसफ़ॉर्म। रोटेटएड (वेक्टर 3 पॉइंट, वेक्टर 3 एक्सिस, फ्लोट एंगल)
• शून्य ट्रांसफ़ॉर्म। लुकाट (ट्रांसफ़ॉर्म टारगेट, वैक्टर 3 वर्ल्डअप = वैक्टर 3.अप)
• शून्य ट्रांसफ़ॉर्म। लुकाट (वेक्टर 3 वर्ल्डपोजिशन, वेक्टर 3 वर्ल्ड यूपी = वेक्टर 3.अप)

अवलोकन

ट्रांसफ़ॉर्म डेटा के अधिकांश भाग को एकता में रखता है, जिसमें माता-पिता (बच्चे), बच्चे (बच्चे), स्थिति, रोटेशन और स्केल शामिल हैं। इसमें इन गुणों में से प्रत्येक को संशोधित करने के लिए कार्य भी हैं। हर GameObject में एक ट्रांसफॉर्म है।

किसी वस्तु का अनुवाद करना (बढ़ना)

// Move an object 10 units in the positive x direction
transform.Translate(10, 0, 0);

// translating with a vector3
vector3 distanceToMove = new Vector3(5, 2, 0);
transform.Translate(distanceToMove);

किसी वस्तु को घुमाना

// Rotate an object 45 degrees about the Y axis
transform.Rotate(0, 45, 0);

// Rotates an object about the axis passing through point (in world coordinates) by angle in degrees
transform.RotateAround(point, axis, angle);
// Rotates on it's place, on the Y axis, with 90 degrees per second
transform.RotateAround(Vector3.zero, Vector3.up, 90 * Time.deltaTime);

// Rotates an object to make it's forward vector point towards the other object
transform.LookAt(otherTransform);
// Rotates an object to make it's forward vector point towards the given position (in world coordinates)
transform.LookAt(new Vector3(10, 5, 0));

एकता प्रलेखन में अधिक जानकारी और उदाहरण देखे जा सकते हैं।

यह भी ध्यान दें कि यदि खेल कठोर निकायों का उपयोग कर रहा है, तो परिवर्तन को सीधे बातचीत नहीं करनी चाहिए (जब तक कि कठोर शरीर में isKinematic == true )। उन मामलों में सीधे शरीर पर कार्य करने के लिए AddForce या इसी तरह के अन्य तरीकों का उपयोग करें।

पेरेंटिंग और बच्चे

अपनी परियोजना को व्यवस्थित रखने के लिए एकता पदानुक्रम के साथ काम करती है। आप संपादक का उपयोग करके वस्तुओं को पदानुक्रम में जगह दे सकते हैं लेकिन आप कोड के माध्यम से भी ऐसा कर सकते हैं।

पेरेंटिंग

आप निम्न विधियों से किसी ऑब्जेक्ट के पैरेंट को सेट कर सकते हैं

var other = GetOtherGameObject();
other.transform.SetParent( transform );
other.transform.SetParent( transform, worldPositionStays );

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

आप यह भी देख सकते हैं कि वस्तु निम्नलिखित विधि के साथ किसी अन्य परिवर्तन का बच्चा है या नहीं

other.transform.IsChildOf( transform );

एक बच्चा हो रहा है

चूँकि वस्तुओं को एक दूसरे से जोड़ा जा सकता है, आप बच्चों को पदानुक्रम में भी पा सकते हैं। इसे करने का सबसे सरल तरीका निम्न विधि का उपयोग करना है

transform.Find( "other" );
transform.FindChild( "other" );

नोट: FindChild कॉल हुड के तहत खोजें

आप आगे पदानुक्रम के नीचे के बच्चों को भी खोज सकते हैं। आप एक "/" को जोड़कर ऐसा करते हैं कि एक स्तर गहरा जाने के लिए निर्दिष्ट करें।

transform.Find( "other/another" );
transform.FindChild( "other/another" );

एक बच्चे को लाने का दूसरा तरीका GetChild का उपयोग करना है

transform.GetChild( index );

GetChild को इंडेक्स के रूप में एक पूर्णांक की आवश्यकता होती है जो कि कुल चाइल्ड काउंट से छोटा होना चाहिए

int count = transform.childCount;

सिबलिंग इंडेक्स बदलना

आप एक GameObject के बच्चों के क्रम को बदल सकते हैं। आप यह बच्चों के ड्रॉ ऑर्डर को परिभाषित करने के लिए कर सकते हैं (यह मानते हुए कि वे समान Z स्तर और समान क्रमबद्ध क्रम पर हैं)।

other.transform.SetSiblingIndex( index );

आप निम्न विधियों का उपयोग करके या तो पहले या आखिरी में सिबलिंग इंडेक्स को जल्दी से सेट कर सकते हैं

other.transform.SetAsFirstSibling();
other.transform.SetAsLastSibling();

सभी बच्चों का पता लगा रहे हैं

यदि आप किसी परिवर्तन के सभी बच्चों को मुक्त करना चाहते हैं, तो आप यह कर सकते हैं:

foreach(Transform child in transform)
{
    child.parent = null;
}

इसके अलावा, एकता इस उद्देश्य के लिए एक विधि प्रदान करती है:

transform.DetachChildren();

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

(पहली-गहराई वाले बच्चे: वे परिवर्तन जो सीधे परिवर्तन के बच्चे हैं)