unity3d
संपादक का विस्तार

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

• [MenuItem (स्ट्रिंग आइटम नाम)]
• [MenuItem (स्ट्रिंग आइटमनाम, बूल isValidateFunction)]
• [MenuItem (स्ट्रिंग आइटम नाम, बूल isValidateFunction, int प्राथमिकता)]
• [प्रसंगनामु (स्ट्रिंग नाम)]
• [प्रसंगमेनुइतेम (स्ट्रिंग नाम, स्ट्रिंग फ़ंक्शन)]
• [DrawGizmo (GizmoType gizmo)]
• [DrawGizmo (GizmoType परिकल्पित, प्रकार खींचा गया GizmoType)]

पैरामीटर

कस्टम इंस्पेक्टर

एक कस्टम इंस्पेक्टर का उपयोग करने से आप इंस्पेक्टर में एक स्क्रिप्ट तैयार करने के तरीके को बदल सकते हैं। कभी-कभी आप अपनी स्क्रिप्ट के लिए निरीक्षक में अतिरिक्त जानकारी जोड़ना चाहते हैं जो कस्टम प्रॉपर्टी दराज के साथ करना संभव नहीं है।

नीचे एक कस्टम ऑब्जेक्ट का एक सरल उदाहरण है कि कस्टम इंस्पेक्टर का उपयोग करने के साथ अधिक उपयोगी जानकारी दिखा सकते हैं।

using UnityEngine;
#if UNITY_EDITOR
using UnityEditor;
#endif

public class InspectorExample : MonoBehaviour {

    public int Level;
    public float BaseDamage;

    public float DamageBonus {
        get {
            return Level / 100f * 50;
        }
    }

    public float ActualDamage {
        get {
            return BaseDamage + DamageBonus;
        }
    }
}

#if UNITY_EDITOR
[CustomEditor( typeof( InspectorExample ) )]
public class CustomInspector : Editor {

    public override void OnInspectorGUI() {
        base.OnInspectorGUI();

        var ie = (InspectorExample)target;

        EditorGUILayout.LabelField( "Damage Bonus", ie.DamageBonus.ToString() );
        EditorGUILayout.LabelField( "Actual Damage", ie.ActualDamage.ToString() );
    }
}
#endif

पहले हम कुछ क्षेत्रों के साथ अपने कस्टम व्यवहार को परिभाषित करते हैं

public class InspectorExample : MonoBehaviour {
    public int Level;
    public float BaseDamage;
}

जब आप इंस्पेक्टर विंडो में स्क्रिप्ट देख रहे हों तो ऊपर दिखाए गए फ़ील्ड स्वचालित रूप से (कस्टम इंस्पेक्टर के बिना) खींचे जाते हैं।

public float DamageBonus {
    get {
        return Level / 100f * 50;
    }
}

public float ActualDamage {
    get {
        return BaseDamage + DamageBonus;
    }
}

ये गुण यूनिटी द्वारा स्वचालित रूप से तैयार नहीं किए गए हैं। इंस्पेक्टर दृश्य में इन गुणों को दिखाने के लिए हमें अपने कस्टम इंस्पेक्टर का उपयोग करना होगा।

हमें पहले अपने कस्टम इंस्पेक्टर को इस तरह परिभाषित करना होगा

[CustomEditor( typeof( InspectorExample ) )]
public class CustomInspector : Editor {

कस्टम निरीक्षक को संपादक से प्राप्त करना होता है और उसे CustomEditor विशेषता की आवश्यकता होती है। विशेषता का पैरामीटर उस वस्तु का प्रकार है जिसके लिए कस्टम निरीक्षक का उपयोग किया जाना चाहिए।

अगला अप OnInspectorGUI विधि है। इंस्पेक्टर विंडो में जब भी स्क्रिप्ट दिखाई जाती है तो यह विधि कहलाती है।

public override void OnInspectorGUI() {
    base.OnInspectorGUI();
}

हम आधार को कॉल करते हैं। InInspectorGUI () स्क्रिप्ट में अन्य फ़ील्ड्स को संभालने के लिए एकता को संभालने के लिए। यदि हम इसे नहीं कहते हैं तो हमें स्वयं अधिक कार्य करना होगा।

अगले हमारे कस्टम गुण हैं जिन्हें हम दिखाना चाहते हैं

var ie = (InspectorExample)target;

EditorGUILayout.LabelField( "Damage Bonus", ie.DamageBonus.ToString() );
EditorGUILayout.LabelField( "Actual Damage", ie.ActualDamage.ToString() );

हमें एक अस्थायी वैरिएबल बनाना होगा जो हमारे कस्टम प्रकार पर लक्षित लक्ष्य रखता है (लक्ष्य उपलब्ध है क्योंकि हम संपादक से प्राप्त करते हैं)।

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

परिणाम

इससे पहले

उपरांत

कस्टम संपत्ति दराज

कभी-कभी आपके पास कस्टम ऑब्जेक्ट होते हैं जिनमें डेटा होता है, लेकिन मोनोबीहेवियर से प्राप्त नहीं होता है। इन वस्तुओं को एक वर्ग के एक क्षेत्र के रूप में जोड़ना जो मोनोबेहवियर है, जब तक आप ऑब्जेक्ट के प्रकार के लिए अपनी खुद की कस्टम संपत्ति दराज नहीं लिखते तब तक कोई दृश्य प्रभाव नहीं होगा।

नीचे एक कस्टम ऑब्जेक्ट का एक सरल उदाहरण है, जो MonoBehaviour में जोड़ा गया है, और कस्टम ऑब्जेक्ट के लिए एक कस्टम गुण दराज है।

public enum Gender {
    Male,
    Female,
    Other
}

// Needs the Serializable attribute otherwise the CustomPropertyDrawer wont be used
[Serializable]
public class UserInfo {
    public string Name;
    public int Age;
    public Gender Gender;
}

// The class that you can attach to a GameObject
public class PropertyDrawerExample : MonoBehaviour {
    public UserInfo UInfo;
}

[CustomPropertyDrawer( typeof( UserInfo ) )]
public class UserInfoDrawer : PropertyDrawer {

    public override float GetPropertyHeight( SerializedProperty property, GUIContent label ) {
        // The 6 comes from extra spacing between the fields (2px each)
        return EditorGUIUtility.singleLineHeight * 4 + 6;
    }

    public override void OnGUI( Rect position, SerializedProperty property, GUIContent label ) {
        EditorGUI.BeginProperty( position, label, property );

        EditorGUI.LabelField( position, label );

        var nameRect = new Rect( position.x, position.y + 18, position.width, 16 );
        var ageRect = new Rect( position.x, position.y + 36, position.width, 16 );
        var genderRect = new Rect( position.x, position.y + 54, position.width, 16 );

        EditorGUI.indentLevel++;

        EditorGUI.PropertyField( nameRect, property.FindPropertyRelative( "Name" ) );
        EditorGUI.PropertyField( ageRect, property.FindPropertyRelative( "Age" ) );
        EditorGUI.PropertyField( genderRect, property.FindPropertyRelative( "Gender" ) );

        EditorGUI.indentLevel--;

        EditorGUI.EndProperty();
    }
}

सबसे पहले हम कस्टम ऑब्जेक्ट को सभी आवश्यकताओं के साथ परिभाषित करते हैं। उपयोगकर्ता का वर्णन करने वाला एक साधारण वर्ग। इस क्लास का उपयोग हमारे PropertyDrawerExample वर्ग में किया जाता है जिसे हम गेमऑब्जेक्ट में जोड़ सकते हैं।

public enum Gender {
    Male,
    Female,
    Other
}

[Serializable]
public class UserInfo {
    public string Name;
    public int Age;
    public Gender Gender;
}

public class PropertyDrawerExample : MonoBehaviour {
    public UserInfo UInfo;
}

कस्टम वर्ग को Serializable विशेषता की आवश्यकता होती है अन्यथा CustomPropertyDrawer का उपयोग नहीं किया जाएगा

अगला ऊपर CustomPropertyDrawer है

पहले हमें एक वर्ग को परिभाषित करना होगा जो कि प्रॉपर्टीवेर से प्राप्त होता है। वर्ग परिभाषा को CustomPropertyDrawer विशेषता की भी आवश्यकता है। पारित पैरामीटर उस ऑब्जेक्ट का प्रकार है जिसे आप चाहते हैं कि इस ड्रॉअर का उपयोग किया जाए।

[CustomPropertyDrawer( typeof( UserInfo ) )]
public class UserInfoDrawer : PropertyDrawer {

अगला हम GetPropertyHeight फ़ंक्शन को ओवरराइड करते हैं। यह हमें अपनी संपत्ति के लिए एक कस्टम ऊंचाई को परिभाषित करने की अनुमति देता है। इस मामले में हम जानते हैं कि हमारी संपत्ति के चार भाग होंगे: लेबल, नाम, आयु और लिंग। इसलिए हम EditorGUIUtility.singleLineHeight * 4 का उपयोग करते हैं, हम एक और 6 पिक्सेल जोड़ते हैं क्योंकि हम प्रत्येक फ़ील्ड को बीच में दो पिक्सेल के साथ रखना चाहते हैं।

public override float GetPropertyHeight( SerializedProperty property, GUIContent label ) {
    return EditorGUIUtility.singleLineHeight * 4 + 6;
}

अगला वास्तविक OnGUI विधि है। हम इसे EditorGUI.BeginProperty ([...]) से शुरू करते हैं और EditorGUI.EndProperty () के साथ फ़ंक्शन को समाप्त करते हैं। हम ऐसा इसलिए करते हैं ताकि अगर यह संपत्ति किसी प्रीफैब का हिस्सा होगी, तो वास्तविक प्रीफैब ओवरराइडिंग लॉजिक उन दो तरीकों के बीच हर चीज के लिए काम करेगा।

public override void OnGUI( Rect position, SerializedProperty property, GUIContent label ) {
    EditorGUI.BeginProperty( position, label, property );

उसके बाद हम एक लेबल दिखाते हैं जिसमें फ़ील्ड का नाम होता है और हम अपने खेतों के लिए पहले से ही आयतों को परिभाषित करते हैं।

EditorGUI.LabelField( position, label );

var nameRect = new Rect( position.x, position.y + 18, position.width, 16 );
var ageRect = new Rect( position.x, position.y + 36, position.width, 16 );
var genderRect = new Rect( position.x, position.y + 54, position.width, 16 );

हर क्षेत्र में 16 + 2 पिक्सेल होते हैं और ऊंचाई 16 है (जो EditorGUIUtility.singleLineHeight के समान है)

इसके बाद हम बिट एनआईसी लेआउट के लिए एक टैब के साथ यूआई को इंडेंट करते हैं, गुण प्रदर्शित करते हैं, जीयूआई को इंडेंट करते हैं, और EditorGUI.EndProperty के साथ समाप्त होते हैं ।

EditorGUI.indentLevel++;

EditorGUI.PropertyField( nameRect, property.FindPropertyRelative( "Name" ) );
EditorGUI.PropertyField( ageRect, property.FindPropertyRelative( "Age" ) );
EditorGUI.PropertyField( genderRect, property.FindPropertyRelative( "Gender" ) );

EditorGUI.indentLevel--;

EditorGUI.EndProperty();

हम EditorGUI.PropertyField का उपयोग करके फ़ील्ड प्रदर्शित करते हैं जिसके लिए स्थिति के लिए एक आयत और संपत्ति दिखाने के लिए एक SerializedProperty की आवश्यकता होती है। हम OnGUI फ़ंक्शन में पारित संपत्ति पर FindPropertyRelative ("...") को कॉल करके संपत्ति का अधिग्रहण करते हैं। ध्यान दें कि ये केस-संवेदी हैं और गैर-सार्वजनिक गुण नहीं पाए जा सकते हैं!

इस उदाहरण के लिए मैं संपत्ति से लौटने वाले गुणों को नहीं बचा रहा हूं। FindPropertyRelative ("...")। अनावश्यक कॉल को रोकने के लिए आपको कक्षा में निजी क्षेत्रों में सहेजना चाहिए

परिणाम

इससे पहले

उपरांत

विकल्प सूची की चीज़ें

मेनू आइटम संपादक में कस्टम क्रियाओं को जोड़ने का एक शानदार तरीका है। आप मेनू बार में मेनू आइटम जोड़ सकते हैं, उन्हें विशिष्ट घटकों पर संदर्भ-क्लिक के रूप में, या यहां तक कि आपकी लिपियों में फ़ील्ड पर संदर्भ-क्लिक के रूप में भी रख सकते हैं।

नीचे एक उदाहरण है कि आप मेनू आइटम कैसे लागू कर सकते हैं।

public class MenuItemsExample : MonoBehaviour {

    [MenuItem( "Example/DoSomething %#&d" )]
    private static void DoSomething() {
        // Execute some code
    }

    [MenuItem( "Example/DoAnotherThing", true )]
    private static bool DoAnotherThingValidator() {
        return Selection.gameObjects.Length > 0;
    }

    [MenuItem( "Example/DoAnotherThing _PGUP", false )]
    private static void DoAnotherThing() {
        // Execute some code
    }

    [MenuItem( "Example/DoOne %a", false, 1 )]
    private static void DoOne() {
        // Execute some code
    }

    [MenuItem( "Example/DoTwo #b", false, 2 )]
    private static void DoTwo() {
        // Execute some code
    }

    [MenuItem( "Example/DoFurther &c", false, 13 )]
    private static void DoFurther() {
        // Execute some code
    }

    [MenuItem( "CONTEXT/Camera/DoCameraThing" )]
    private static void DoCameraThing( MenuCommand cmd ) {
        // Execute some code
    }

    [ContextMenu( "ContextSomething" )]
    private void ContentSomething() {
        // Execute some code
    }

    [ContextMenuItem( "Reset", "ResetDate" )]
    [ContextMenuItem( "Set to Now", "SetDateToNow" )]
    public string Date = "";

    public void ResetDate() {
        Date = "";
    }

    public void SetDateToNow() {
        Date = DateTime.Now.ToString();
    }
}

जो इस तरह दिखता है

आइए मूल मेनू आइटम पर जाएं। जैसा कि आप नीचे देख सकते हैं कि आपको MenuItem विशेषता के साथ एक स्थिर फ़ंक्शन को परिभाषित करने की आवश्यकता है, जिसे आप मेनू आइटम के शीर्षक के रूप में पास करते हैं। आप अपने मेनू आइटम को नाम में / जोड़कर कई स्तरों को गहरा रख सकते हैं।

[MenuItem( "Example/DoSomething %#&d" )]
private static void DoSomething() {
    // Execute some code
}

आपके पास शीर्ष-स्तर पर मेनू आइटम नहीं हो सकता है। आपके मेनू आइटम को एक सबमेनू में होना चाहिए!

MenuItem के नाम के अंत में विशेष अक्षर शॉर्टकट कुंजियों के लिए हैं, ये कोई आवश्यकता नहीं हैं।

कुछ विशेष वर्ण हैं जो आप अपनी शॉर्टकट कुंजियों के लिए उपयोग कर सकते हैं, ये हैं:

• % - विंडोज पर Ctrl, OS X पर Cmd
• # - खिसक जाना
• & - Alt

इसका मतलब है कि शॉर्टकट % # & d का अर्थ है विंडोज़ पर ctrl + Shift + alt + D, और OS X पर cmd + Shift + alt + D।

यदि आप किसी विशेष कुंजी के बिना शॉर्टकट का उपयोग करना चाहते हैं, तो उदाहरण के लिए सिर्फ 'डी' कुंजी, आप _ (अंडरस्कोर) चरित्र को उस शॉर्टकट कुंजी से पूर्व-निर्धारित कर सकते हैं जिसे आप उपयोग करना चाहते हैं।

कुछ अन्य विशेष कुंजी हैं जो समर्थित हैं, जो हैं:

• तीर कुंजी के लिए बाएँ, दाएँ, ऊपर, नीचे
• F1..F12 - फ़ंक्शन कुंजियों के लिए
• नेविगेशन कुंजियों के लिए HOME, END, PGUP, PGDN -

शॉर्टकट कुंजियों को किसी अन्य पाठ से एक स्थान से अलग करने की आवश्यकता होती है

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

[MenuItem( "Example/DoAnotherThing", true )]
private static bool DoAnotherThingValidator() {
    return Selection.gameObjects.Length > 0;
}

[MenuItem( "Example/DoAnotherThing _PGUP", false )]
private static void DoAnotherThing() {
    // Execute some code
}

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

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

[MenuItem( "Example/DoOne %a", false, 1 )]
private static void DoOne() {
    // Execute some code
}

[MenuItem( "Example/DoTwo #b", false, 2 )]
private static void DoTwo() {
    // Execute some code
}

[MenuItem( "Example/DoFurther &c", false, 13 )]
private static void DoFurther() {
    // Execute some code
}

यदि आपके पास एक मेनू सूची है जिसमें प्राथमिकता और गैर-प्राथमिकता वाले आइटम का संयोजन है, तो गैर-प्राथमिकता वाले को प्राथमिकता वाली वस्तुओं से अलग किया जाएगा।

अगला एक मेनू आइटम को पहले से मौजूद घटक के संदर्भ मेनू में जोड़ रहा है। आपको मेनूइट का नाम CONTEXT (केस सेंसिटिव) के साथ शुरू करना होगा, और अपने फ़ंक्शन को मेनूकोमैंड पैरामीटर में लेना होगा।

निम्नलिखित स्निपेट कैमरा घटक में एक संदर्भ मेनू आइटम जोड़ देगा।

[MenuItem( "CONTEXT/Camera/DoCameraThing" )]
private static void DoCameraThing( MenuCommand cmd ) {
    // Execute some code
}

जो इस तरह दिखता है

MenuCommand पैरामीटर आपको घटक मान और इसके साथ भेजने वाले किसी भी उपयोगकर्ता के लिए पहुँच प्रदान करता है।

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

[ContextMenu( "ContextSomething" )]
private void ContentSomething() {
    // Execute some code
}

जो इस तरह दिखता है

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

[ContextMenuItem( "Reset", "ResetDate" )]
[ContextMenuItem( "Set to Now", "SetDateToNow" )]
public string Date = "";

public void ResetDate() {
    Date = "";
}

public void SetDateToNow() {
    Date = DateTime.Now.ToString();
}

जो इस तरह दिखता है

गिज़्मोस

गिजमो का उपयोग दृश्य दृश्य में आकृतियाँ बनाने के लिए किया जाता है। आप अपने GameObjects के बारे में अतिरिक्त जानकारी प्राप्त करने के लिए इन आकृतियों का उपयोग कर सकते हैं, उदाहरण के लिए उनके पास मौजूद निराशा या पता लगाने की सीमा।

ऐसा करने के लिए नीचे दो उदाहरण दिए गए हैं

उदाहरण एक

यह उदाहरण OnDrawGizmos और OnDrawGizmosSelected (मैजिक) विधियों का उपयोग करता है।

public class GizmoExample : MonoBehaviour {

    public float GetDetectionRadius() {
        return 12.5f;
    }

    public float GetFOV() {
        return 25f;
    }

    public float GetMaxRange() {
        return 6.5f;
    }

    public float GetMinRange() {
        return 0;
    }

    public float GetAspect() {
        return 2.5f;
    }

    public void OnDrawGizmos() {
        var gizmoMatrix = Gizmos.matrix;
        var gizmoColor = Gizmos.color;

        Gizmos.matrix = Matrix4x4.TRS( transform.position, transform.rotation, transform.lossyScale );
        Gizmos.color = Color.red;
        Gizmos.DrawFrustum( Vector3.zero, GetFOV(), GetMaxRange(), GetMinRange(), GetAspect() );

        Gizmos.matrix = gizmoMatrix;
        Gizmos.color = gizmoColor;
    }

    public void OnDrawGizmosSelected() {
        Handles.DrawWireDisc( transform.position, Vector3.up, GetDetectionRadius() );
    }
}

इस उदाहरण में हमारे पास gizmos को आरेखित करने की दो विधियाँ हैं, एक वह जो तब खींचती है जब ऑब्जेक्ट सक्रिय होता है (OnDrawGizmos) और एक जब ऑब्जेक्ट को पदानुक्रम में चुना जाता है (OnDrawGizmosSeemed)।

public void OnDrawGizmos() {
    var gizmoMatrix = Gizmos.matrix;
    var gizmoColor = Gizmos.color;

    Gizmos.matrix = Matrix4x4.TRS( transform.position, transform.rotation, transform.lossyScale );
    Gizmos.color = Color.red;
    Gizmos.DrawFrustum( Vector3.zero, GetFOV(), GetMaxRange(), GetMinRange(), GetAspect() );

    Gizmos.matrix = gizmoMatrix;
    Gizmos.color = gizmoColor;
}

पहले हम इनवॉइस मैट्रिक्स और रंग को बचाते हैं क्योंकि हम इसे बदलने जा रहे हैं और इसे वापस करना चाहते हैं जब हम किसी भी अन्य ड्राइंग को प्रभावित नहीं करने के लिए किए जाते हैं।

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

जब हमें ड्रॉ किया जाता है तो हम क्या आकर्षित करना चाहते हैं, हम गिजमॉस के मैट्रिक्स और रंग को रीसेट करते हैं।

public void OnDrawGizmosSelected() {
    Handles.DrawWireDisc( transform.position, Vector3.up, GetDetectionRadius() );
}

जब हम अपने GameObject का चयन करते हैं तो हम एक डिटेक्शन रेंज भी बनाना चाहते हैं। यह हैंडल क्लास के माध्यम से किया जाता है क्योंकि Gizmos वर्ग में डिस्क के लिए कोई विधि नहीं है।

नीचे दिए गए आउटपुट में gizmos के ड्राइंग के इस रूप का उपयोग करने का परिणाम है।

उदाहरण दो

यह उदाहरण DrawGizmo विशेषता का उपयोग करता है।

public class GizmoDrawerExample {

    [DrawGizmo( GizmoType.Selected | GizmoType.NonSelected, typeof( GizmoExample ) )]
    public static void DrawGizmo( GizmoExample obj, GizmoType type ) {
        var gizmoMatrix = Gizmos.matrix;
        var gizmoColor = Gizmos.color;

        Gizmos.matrix = Matrix4x4.TRS( obj.transform.position, obj.transform.rotation, obj.transform.lossyScale );
        Gizmos.color = Color.red;
        Gizmos.DrawFrustum( Vector3.zero, obj.GetFOV(), obj.GetMaxRange(), obj.GetMinRange(), obj.GetAspect() );

        Gizmos.matrix = gizmoMatrix;
        Gizmos.color = gizmoColor;

        if ( ( type & GizmoType.Selected ) == GizmoType.Selected ) {
            Handles.DrawWireDisc( obj.transform.position, Vector3.up, obj.GetDetectionRadius() );
        }
    }
}

इस तरह से आप अपने स्क्रिप्ट से कॉल को अलग कर सकते हैं। इसमें से अधिकांश दो चीजों को छोड़कर अन्य उदाहरण के समान कोड का उपयोग करता है।

[DrawGizmo( GizmoType.Selected | GizmoType.NonSelected, typeof( GizmoExample ) )]
public static void DrawGizmo( GizmoExample obj, GizmoType type ) {

आपको ड्रागैमिक्स विशेषता का उपयोग करने की आवश्यकता है जो पहले पैरामीटर के रूप में Enum GizmoType और दूसरे पैरामीटर के रूप में टाइप करती है। वह प्रकार होना चाहिए, जिस प्रकार का आप आरेखण के लिए उपयोग करना चाहते हैं।

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

if ( ( type & GizmoType.Selected ) == GizmoType.Selected ) {
    Handles.DrawWireDisc( obj.transform.position, Vector3.up, obj.GetDetectionRadius() );
}

दूसरा अंतर यह है कि ऑब्जेक्ट के GizmoType की जाँच करने के लिए, आपको पैरामीटर और उस प्रकार की जांच करनी होगी जो आप चाहते हैं।

परिणाम

नहीं चुने गए

चयनित

संपादक विंडो

संपादक विंडो क्यों?

जैसा कि आपने देखा होगा, आप एक कस्टम इंस्पेक्टर में बहुत सारी चीजें कर सकते हैं (यदि आप नहीं जानते कि एक कस्टम इंस्पेक्टर क्या है, तो यहां उदाहरण देखें : http://www.riptutorial.com/unity3d/topic/2506 / विस्तार-से-संपादक । लेकिन एक बिंदु पर आप एक कॉन्फ़िगरेशन पैनल, या एक अनुकूलित परिसंपत्ति पैलेट को लागू करना चाह सकते हैं। उन मामलों में आप एक EditorWindow का उपयोग करने जा रहे हैं। यूनिटी UI स्वयं संपादक विंडोज से बना है; आप उन्हें खोल सकते हैं। (आमतौर पर शीर्ष पट्टी के माध्यम से), उन्हें टैब, आदि।

एक बुनियादी EditorWindow बनाएँ

सरल उदाहरण

एक कस्टम संपादक विंडो बनाना काफी सरल है। आपको केवल EditorWindow क्लास का विस्तार करना है और Init () और OnGUI () विधियों का उपयोग करना है। ये रहा एक सरल उदाहरण :

using UnityEngine;
using UnityEditor;

public class CustomWindow : EditorWindow
{
    // Add menu named "Custom Window" to the Window menu
    [MenuItem("Window/Custom Window")]
    static void Init()
    {
        // Get existing open window or if none, make a new one:
        CustomWindow window = (CustomWindow) EditorWindow.GetWindow(typeof(CustomWindow));
        window.Show();
    }

    void OnGUI()
    {
        GUILayout.Label("This is a custom Editor Window", EditorStyles.boldLabel);
    }
}

3 महत्वपूर्ण बिंदु हैं:

1. EditorWindow का विस्तार करना न भूलें
2. उदाहरण में दिए गए अनुसार Init () का उपयोग करें। अगर कोई CustomWindow पहले से बना है, तो EditorWindow.GetWindow जाँच कर रहा है। यदि नहीं, तो यह एक नया उदाहरण बनाएगा। इसका उपयोग करके आप यह सुनिश्चित करते हैं कि आपके पास एक ही समय में आपकी विंडो के कई उदाहरण नहीं हैं
3. अपनी विंडो में जानकारी प्रदर्शित करने के लिए हमेशा की तरह OnGUI () का उपयोग करें

अंतिम परिणाम इस तरह दिखेगा:

गहराई तक जा रहे हैं

बेशक आप शायद इस EditorWindow का उपयोग करके कुछ संपत्तियों को प्रबंधित या संशोधित करना चाहते हैं। यहाँ एक चयन वर्ग (सक्रिय चयन प्राप्त करने के लिए) और SerializedObject और SerializedProperty के माध्यम से चयनित संपत्ति गुणों को संशोधित करने का एक उदाहरण है।

    using System.Linq;
    using UnityEngine;
    using UnityEditor;
    
    public class CustomWindow : EditorWindow
    {
        private AnimationClip _animationClip;
        private SerializedObject _serializedClip;
        private SerializedProperty _events;
    
        private string _text = "Hello World";
    
        // Add menu named "Custom Window" to the Window menu
        [MenuItem("Window/Custom Window")]
        static void Init()
        {
            // Get existing open window or if none, make a new one:
            CustomWindow window = (CustomWindow) EditorWindow.GetWindow(typeof(CustomWindow));
            window.Show();
        }
    
        void OnGUI()
        {
            GUILayout.Label("This is a custom Editor Window", EditorStyles.boldLabel);
    
            // You can use EditorGUI, EditorGUILayout and GUILayout classes to display anything you want
            // A TextField example
            _text = EditorGUILayout.TextField("Text Field", _text);
    
            // Note that you can modify an asset or a gameobject using an EditorWindow. Here is a quick example with an AnimationClip asset
            // The _animationClip, _serializedClip and _events are set in OnSelectionChange()
    
            if (_animationClip == null || _serializedClip == null || _events == null) return;
    
            // We can modify our serializedClip like we would do in a Custom Inspector. For example we can grab its events and display their information
    
            GUILayout.Label(_animationClip.name, EditorStyles.boldLabel);
    
            for (var i = 0; i < _events.arraySize; i++)
            {
                EditorGUILayout.BeginVertical();
    
                EditorGUILayout.LabelField(
                    "Event : " + _events.GetArrayElementAtIndex(i).FindPropertyRelative("functionName").stringValue,
                    EditorStyles.boldLabel);
                EditorGUILayout.PropertyField(_events.GetArrayElementAtIndex(i).FindPropertyRelative("time"), true,
                    GUILayout.ExpandWidth(true));
                EditorGUILayout.PropertyField(_events.GetArrayElementAtIndex(i).FindPropertyRelative("functionName"),
                    true, GUILayout.ExpandWidth(true));
                EditorGUILayout.PropertyField(_events.GetArrayElementAtIndex(i).FindPropertyRelative("floatParameter"),
                    true, GUILayout.ExpandWidth(true));
                EditorGUILayout.PropertyField(_events.GetArrayElementAtIndex(i).FindPropertyRelative("intParameter"),
                    true, GUILayout.ExpandWidth(true));
                EditorGUILayout.PropertyField(
                    _events.GetArrayElementAtIndex(i).FindPropertyRelative("objectReferenceParameter"), true,
                    GUILayout.ExpandWidth(true));
    
                EditorGUILayout.Separator();
                EditorGUILayout.EndVertical();
            }
    
            // Of course we need to Apply the modified properties. We don't our changes won't be saved
            _serializedClip.ApplyModifiedProperties();
        }
    
        /// This Message is triggered when the user selection in the editor changes. That's when we should tell our Window to Repaint() if the user selected another AnimationClip
        private void OnSelectionChange()
        {
            _animationClip =
                Selection.GetFiltered(typeof(AnimationClip), SelectionMode.Assets).FirstOrDefault() as AnimationClip;
            if (_animationClip == null) return;
    
            _serializedClip = new SerializedObject(_animationClip);
            _events = _serializedClip.FindProperty("m_Events");
            Repaint();
        }
    }

यहाँ परिणाम है:

उन्नत विषय

आप संपादक में कुछ वास्तव में उन्नत चीजें कर सकते हैं, और EditorWindow वर्ग बड़ी मात्रा में जानकारी प्रदर्शित करने के लिए एकदम सही है। यूनिटी एसेट स्टोर (जैसे NodeCanvas या PlayMaker) पर अधिकांश उन्नत संपत्ति कस्टम दृश्यों के लिए प्रदर्शित करने के लिए EditorWindow का उपयोग करती हैं।

दृश्य में ड्राइंग

EditorWindow के साथ एक दिलचस्प बात यह है कि सीधे अपने दृश्य में जानकारी प्रदर्शित करें। इस तरह से आप एक पूरी तरह से अनुकूलित नक्शा / विश्व संपादक बना सकते हैं, उदाहरण के लिए, अपने कस्टम संपादक का उपयोग करके एक परिसंपत्ति पैलेट के रूप में और नई वस्तुओं को तुरंत देखने के लिए दृश्य में क्लिक सुनने के लिए। यहाँ एक उदाहरण है :

using UnityEngine;
using System;
using UnityEditor;

public class CustomWindow : EditorWindow {

    private enum Mode {
        View = 0,
        Paint = 1,
        Erase = 2
    }

    private Mode CurrentMode = Mode.View;

    [MenuItem ("Window/Custom Window")]
    static void Init () {
        // Get existing open window or if none, make a new one:
        CustomWindow window = (CustomWindow)EditorWindow.GetWindow (typeof (CustomWindow));
        window.Show();
    }

    void OnGUI () {
        GUILayout.Label ("This is a custom Editor Window", EditorStyles.boldLabel);
    }

    void OnEnable() {
        SceneView.onSceneGUIDelegate = SceneViewGUI;
        if (SceneView.lastActiveSceneView) SceneView.lastActiveSceneView.Repaint();
    }

    void SceneViewGUI(SceneView sceneView) {
        Handles.BeginGUI();
        // We define the toolbars' rects here
        var ToolBarRect = new Rect((SceneView.lastActiveSceneView.camera.pixelRect.width / 6), 10, (SceneView.lastActiveSceneView.camera.pixelRect.width * 4 / 6) , SceneView.lastActiveSceneView.camera.pixelRect.height / 5);
        GUILayout.BeginArea(ToolBarRect);
        GUILayout.BeginHorizontal();
        GUILayout.FlexibleSpace();
         CurrentMode = (Mode) GUILayout.Toolbar(
            (int) CurrentMode,
            Enum.GetNames(typeof(Mode)),
            GUILayout.Height(ToolBarRect.height));
        GUILayout.FlexibleSpace();
        GUILayout.EndHorizontal();
        GUILayout.EndArea();
        Handles.EndGUI();
    }
}

यह सीधे आपके दृश्य में एक टूलबार प्रदर्शित करेगा

यहाँ एक त्वरित झलक है कि आप कितनी दूर जा सकते हैं: