コード例 #1
0
    public override void OnInspectorGUI()
    {
        LE_Event_And cam = target as LE_Event_And;

        GUILayout.Label(new GUIContent("The Serialize No.:" + cam.SerializeNo));

        serializedObject.Update();

        NGUIEditorTools.BeginContents(true);
        DrawDefaultInspector();
        NGUIEditorTools.EndContents();

        SerializedProperty list = serializedObject.FindProperty("ActionList");

        if (NGUIEditorTools.DrawMinimalisticHeader("ActionList"))
        {
            NGUIEditorTools.BeginContents(true);

            SerializedProperty size = list.FindPropertyRelative("Array.size");
            EditorGUILayout.PropertyField(size);

            EditorGUI.indentLevel += 1;
            for (int i = 0; i < list.arraySize; i++)
            {
                EditorGUILayout.BeginHorizontal();
                EditorGUILayout.PropertyField(list.GetArrayElementAtIndex(i));
                EditorGUILayout.EndHorizontal();
            }

            EditorGUI.indentLevel -= 1;

            NGUIEditorTools.EndContents();
        }
        serializedObject.ApplyModifiedProperties();
    }
コード例 #2
0
    static void ShowList(SerializedProperty list)
    {
        if (!list.isArray)
        {
            return;
        }

        if (NGUIEditorTools.DrawMinimalisticHeader("SchemeList"))
        {
            NGUIEditorTools.BeginContents(true);
            SerializedProperty size = list.FindPropertyRelative("Array.size");
            EditorGUILayout.PropertyField(size);

            EditorGUI.indentLevel += 1;
            for (int i = 0; i < list.arraySize; i++)
            {
                if (NGUIEditorTools.DrawMinimalisticHeader("Scheme" + i))
                {
                    EditorGUILayout.BeginHorizontal();
                    EditorGUILayout.PropertyField(list.GetArrayElementAtIndex(i).FindPropertyRelative("type"));
                    EditorGUILayout.EndHorizontal();

                    EditorGUILayout.BeginHorizontal();
                    EditorGUILayout.PropertyField(list.GetArrayElementAtIndex(i).FindPropertyRelative("target"));
                    EditorGUILayout.EndHorizontal();
                }
            }
            EditorGUI.indentLevel -= 1;
            NGUIEditorTools.EndContents();
        }
    }
コード例 #3
0
ファイル: UIToggleInspector.cs プロジェクト: Brons040/Moons
    public override void OnInspectorGUI()
    {
        serializedObject.Update();

        NGUIEditorTools.SetLabelWidth(100f);
        UIToggle toggle = target as UIToggle;

        GUILayout.Space(6f);
        GUI.changed = false;

        GUILayout.BeginHorizontal();
        SerializedProperty sp = NGUIEditorTools.DrawProperty("Group", serializedObject, "group", GUILayout.Width(120f));

        GUILayout.Label(" - zero means 'none'");
        GUILayout.EndHorizontal();

        EditorGUI.BeginDisabledGroup(sp.intValue == 0);
        NGUIEditorTools.DrawProperty("  State of 'None'", serializedObject, "optionCanBeNone");
        EditorGUI.EndDisabledGroup();

        NGUIEditorTools.DrawProperty("Starting State", serializedObject, "startsActive");
        NGUIEditorTools.SetLabelWidth(80f);

        if (NGUIEditorTools.DrawMinimalisticHeader("State Transition"))
        {
            NGUIEditorTools.BeginContents(true);
            NGUIEditorTools.DrawProperty("Sprite", serializedObject, "activeSprite");
            NGUIEditorTools.DrawProperty("Animation", serializedObject, "activeAnimation");

            if (serializedObject.isEditingMultipleObjects)
            {
                NGUIEditorTools.DrawProperty("Instant", serializedObject, "instantTween");
            }
            else
            {
                GUI.changed = false;
                Transition tr = toggle.instantTween ? Transition.Instant : Transition.Smooth;
                GUILayout.BeginHorizontal();
                tr = (Transition)EditorGUILayout.EnumPopup("Transition", tr);
                NGUIEditorTools.DrawPadding();
                GUILayout.EndHorizontal();

                if (GUI.changed)
                {
                    NGUIEditorTools.RegisterUndo("Toggle Change", toggle);
                    toggle.instantTween = (tr == Transition.Instant);
                    NGUITools.SetDirty(toggle);
                }
            }
            NGUIEditorTools.EndContents();
        }

        NGUIEditorTools.DrawEvents("On Value Change", toggle, toggle.onChange);
        serializedObject.ApplyModifiedProperties();
    }
コード例 #4
0
    static void ShowList(SerializedProperty list)
    {
        if (!list.isArray)
        {
            return;
        }

        if (NGUIEditorTools.DrawMinimalisticHeader("List"))
        {
            NGUIEditorTools.BeginContents(true);
            SerializedProperty size = list.FindPropertyRelative("Array.size");
            EditorGUILayout.PropertyField(size);
            EditorGUI.indentLevel += 1;
            for (int i = 0; i < list.arraySize; i++)
            {
                if (NGUIEditorTools.DrawMinimalisticHeader("Element" + i))
                {
                    EditorGUILayout.BeginHorizontal();
                    EditorGUILayout.PropertyField(list.GetArrayElementAtIndex(i).FindPropertyRelative("gateType"));
                    EditorGUILayout.EndHorizontal();



                    switch (list.GetArrayElementAtIndex(i).FindPropertyRelative("gateType").intValue)
                    {
                    case (int)GateOpResult.ENGateType.specifiedGate:
                    {
                        EditorGUILayout.BeginHorizontal();
                        EditorGUILayout.PropertyField(list.GetArrayElementAtIndex(i).FindPropertyRelative("targetGateObj"));
                        EditorGUILayout.EndHorizontal();
                        break;
                    }

                    case (int)GateOpResult.ENGateType.CustomBlackboardStr:
                    {
                        EditorGUILayout.BeginHorizontal();
                        EditorGUILayout.PropertyField(list.GetArrayElementAtIndex(i).FindPropertyRelative("gateBlackboardStr"));
                        EditorGUILayout.EndHorizontal();
                        break;
                    }
                    }


                    EditorGUILayout.BeginHorizontal();
                    EditorGUILayout.PropertyField(list.GetArrayElementAtIndex(i).FindPropertyRelative("actionType"));
                    EditorGUILayout.EndHorizontal();
                }
            }
            EditorGUI.indentLevel -= 1;
            NGUIEditorTools.EndContents();
        }
    }
コード例 #5
0
    static void ShowList(SerializedProperty list)
    {
        if (!list.isArray)
        {
            return;
        }
        // EditorGUI.indentLevel += 1;

        if (NGUIEditorTools.DrawMinimalisticHeader("Npc List"))
        {
            NGUIEditorTools.BeginContents(true);

            SerializedProperty size = list.FindPropertyRelative("Array.size");
            EditorGUILayout.PropertyField(size);

            EditorGUI.indentLevel += 1;
            for (int i = 0; i < list.arraySize; i++)
            {
                if (NGUIEditorTools.DrawMinimalisticHeader("Npc" + i))
                {
                    EditorGUILayout.BeginHorizontal();
                    EditorGUILayout.PropertyField(list.GetArrayElementAtIndex(i).FindPropertyRelative("npcType"));
                    EditorGUILayout.EndHorizontal();



                    if (list.GetArrayElementAtIndex(i).FindPropertyRelative("npcType").intValue == (int)DeadEvent.ENDeadActorType.enSpicalNpc)
                    {
                        EditorGUILayout.PropertyField(list.GetArrayElementAtIndex(i).FindPropertyRelative("targetNpc"));
                    }

                    EditorGUILayout.BeginHorizontal();
                    EditorGUILayout.PropertyField(list.GetArrayElementAtIndex(i).FindPropertyRelative("blackboardActorName"));
                    EditorGUILayout.EndHorizontal();

                    EditorGUILayout.BeginHorizontal();
                    EditorGUILayout.PropertyField(list.GetArrayElementAtIndex(i).FindPropertyRelative("hpValType"));
                    EditorGUILayout.EndHorizontal();

                    EditorGUILayout.BeginHorizontal();
                    EditorGUILayout.PropertyField(list.GetArrayElementAtIndex(i).FindPropertyRelative("hpValue"));
                    EditorGUILayout.EndHorizontal();
                }
            }

            EditorGUI.indentLevel -= 1;

            NGUIEditorTools.EndContents();
        }
    }
コード例 #6
0
    static void ShowList(SerializedProperty list)
    {
        if (!list.isArray)
        {
            return;
        }

        if (NGUIEditorTools.DrawMinimalisticHeader("List"))
        {
            NGUIEditorTools.BeginContents(true);
            SerializedProperty size = list.FindPropertyRelative("Array.size");
            EditorGUILayout.PropertyField(size);
            EditorGUI.indentLevel += 1;
            for (int i = 0; i < list.arraySize; i++)
            {
                if (NGUIEditorTools.DrawMinimalisticHeader("Element" + i))
                {
                    EditorGUILayout.BeginHorizontal();
                    EditorGUILayout.PropertyField(list.GetArrayElementAtIndex(i).FindPropertyRelative("type"));
                    EditorGUILayout.EndHorizontal();



                    switch (list.GetArrayElementAtIndex(i).FindPropertyRelative("type").intValue)
                    {
                    case (int)DropItemResult.ID.key:
                    {
                        EditorGUILayout.BeginHorizontal();
                        EditorGUILayout.PropertyField(list.GetArrayElementAtIndex(i).FindPropertyRelative("keyId"));
                        EditorGUILayout.EndHorizontal();
                        break;
                    }
                    }
                }
            }
            EditorGUI.indentLevel -= 1;
            NGUIEditorTools.EndContents();
        }
    }
コード例 #7
0
    public override void OnInspectorGUI()
    {
        serializedObject.Update();

        NGUIEditorTools.SetLabelWidth(100f);
        UIToggle toggle = target as UIToggle;

        GUILayout.Space(6f);
        GUI.changed = false;

        GUILayout.BeginHorizontal();
        SerializedProperty sp = NGUIEditorTools.DrawProperty("分组唯一标识", serializedObject, "group", GUILayout.Width(230f));

        GUILayout.Label("留空表示不分组");
        GUILayout.EndHorizontal();

        EditorGUI.BeginDisabledGroup(sp.stringValue == "");
        NGUIEditorTools.DrawProperty("是否允许空选", serializedObject, "optionCanBeNone");
        EditorGUI.EndDisabledGroup();

        NGUIEditorTools.DrawProperty("是否默认选中", serializedObject, "startsActive");
        NGUIEditorTools.SetLabelWidth(80f);

        if (NGUIEditorTools.DrawMinimalisticHeader("State Transition"))
        {
            NGUIEditorTools.BeginContents(true);

            SerializedProperty sprite    = serializedObject.FindProperty("activeSprite");
            SerializedProperty animator  = serializedObject.FindProperty("animator");
            SerializedProperty animation = serializedObject.FindProperty("activeAnimation");
            SerializedProperty tween     = serializedObject.FindProperty("tween");

            if (sprite.objectReferenceValue != null)
            {
                NGUIEditorTools.DrawProperty("Sprite", sprite, false);
            }
            else if (animator.objectReferenceValue != null)
            {
                NGUIEditorTools.DrawProperty("Animator", animator, false);
            }
            else if (animation.objectReferenceValue != null)
            {
                NGUIEditorTools.DrawProperty("Animation", animation, false);
            }
            else if (tween.objectReferenceValue != null)
            {
                NGUIEditorTools.DrawProperty("Tween", tween, false);
            }
            else
            {
                NGUIEditorTools.DrawProperty("Sprite", serializedObject, "activeSprite");
                NGUIEditorTools.DrawProperty("Animator", animator, false);
                NGUIEditorTools.DrawProperty("Animation", animation, false);
                NGUIEditorTools.DrawProperty("Tween", tween, false);
            }

            if (serializedObject.isEditingMultipleObjects)
            {
                NGUIEditorTools.DrawProperty("Instant", serializedObject, "instantTween");
            }
            else
            {
                GUI.changed = false;
                Transition tr = toggle.instantTween ? Transition.Instant : Transition.Smooth;
                GUILayout.BeginHorizontal();
                tr = (Transition)EditorGUILayout.EnumPopup("Transition", tr);
                NGUIEditorTools.DrawPadding();
                GUILayout.EndHorizontal();

                if (GUI.changed)
                {
                    NGUIEditorTools.RegisterUndo("Toggle Change", toggle);
                    toggle.instantTween = (tr == Transition.Instant);
                    NGUITools.SetDirty(toggle);
                }
            }
            NGUIEditorTools.EndContents();
        }

        //NGUIEditorTools.DrawEvents("On Value Change", toggle, toggle.onChange);
        serializedObject.ApplyModifiedProperties();
    }
コード例 #8
0
    protected override bool OnSearchGUI()
    {
        if (!mAtlas)
        {
            mAtlas = NGUISettings.atlas;
        }
        ComponentSelector.Draw <UIAtlas>("Atlas", mAtlas, obj => {
            if (mAtlas != obj)
            {
                mAtlas = obj as UIAtlas;
            }
        }, true, GUILayout.MinWidth(80f));

        if (!mAtlas)
        {
            mSprites = new string[0];
            return(false);
        }

        GUILayout.BeginHorizontal();
        GUILayout.Space(5F);
        EditorGUILayout.BeginVertical();
        if (NGUIEditorTools.DrawMinimalisticHeader("Sprites"))
        {
            EditorGUILayout.BeginHorizontal();
            GUILayout.Space(15F);
            EditorGUILayout.BeginVertical();
            GUILayout.Space(2F);

            int newLength = EditorGUILayout.IntField("Size", mSprites.Length);
            int oldLength = mSprites.Length;
            if (newLength != oldLength)
            {
                int      minLength = Mathf.Min(newLength, oldLength);
                string[] sprites   = new string[newLength];
                for (int i = 0; i < minLength; i++)
                {
                    sprites[i] = mSprites[i];
                }
                mSprites = sprites;
            }
            for (int i = 0; i < mSprites.Length; i++)
            {
                int index = i;
                NGUIEditorTools.DrawAdvancedSpriteField(mAtlas, mSprites[index], spriteName =>
                {
                    mSprites[index] = spriteName;
                    Repaint();
                }, false);
            }

            GUILayout.Space(2F);
            EditorGUILayout.EndVertical();
            GUILayout.Space(3F);
            EditorGUILayout.EndHorizontal();
        }
        GUILayout.EndVertical();
        GUILayout.EndHorizontal();
        GUILayout.Space(10F);

        GUILayout.BeginHorizontal();
        GUILayout.Space(10F);
        bool search = GUILayout.Button("Search");

        GUILayout.Space(10F);
        GUILayout.EndHorizontal();

        return(search);
    }
コード例 #9
0
    static void ShowList(SerializedProperty list)
    {
        if (!list.isArray)
        {
            return;
        }

        if (NGUIEditorTools.DrawMinimalisticHeader("List"))
        {
            NGUIEditorTools.BeginContents(true);
            SerializedProperty size = list.FindPropertyRelative("Array.size");
            EditorGUILayout.PropertyField(size);
            EditorGUI.indentLevel += 1;
            for (int i = 0; i < list.arraySize; i++)
            {
                if (NGUIEditorTools.DrawMinimalisticHeader("Element" + i))
                {
                    EditorGUILayout.BeginHorizontal();
                    EditorGUILayout.PropertyField(list.GetArrayElementAtIndex(i).FindPropertyRelative("actorType"));
                    EditorGUILayout.EndHorizontal();



                    switch (list.GetArrayElementAtIndex(i).FindPropertyRelative("actorType").intValue)
                    {
                    case (int)LE_Action_AddBuffInfo.Type.specifiedNPC:
                    {
                        EditorGUILayout.BeginHorizontal();
                        EditorGUILayout.PropertyField(list.GetArrayElementAtIndex(i).FindPropertyRelative("targetObj"));
                        EditorGUILayout.EndHorizontal();
                        break;
                    }

                    case (int)LE_Action_AddBuffInfo.Type.CustomBlackboardStr:
                    {
                        EditorGUILayout.BeginHorizontal();
                        EditorGUILayout.PropertyField(list.GetArrayElementAtIndex(i).FindPropertyRelative("buffBlackboardStr"));
                        EditorGUILayout.EndHorizontal();
                        break;
                    }
                    }


                    EditorGUILayout.BeginHorizontal();
                    EditorGUILayout.PropertyField(list.GetArrayElementAtIndex(i).FindPropertyRelative("actionType"));
                    EditorGUILayout.EndHorizontal();
                    // EditorGUI.indentLevel += 1;
                    if (NGUIEditorTools.DrawHeader("BuffList" + i))
                    {
                        SerializedProperty size1 = list.GetArrayElementAtIndex(i).FindPropertyRelative("buffList").FindPropertyRelative("Array.size");
                        EditorGUILayout.PropertyField(size1);

                        NGUIEditorTools.BeginContents(true);
                        for (int j = 0; j < list.GetArrayElementAtIndex(i).FindPropertyRelative("buffList").arraySize; j++)
                        {
                            EditorGUILayout.BeginHorizontal();
                            EditorGUILayout.PropertyField(list.GetArrayElementAtIndex(i).FindPropertyRelative("buffList").GetArrayElementAtIndex(j));
                            EditorGUILayout.EndHorizontal();
                        }
                        NGUIEditorTools.EndContents();
                    }

                    //EditorGUI.indentLevel -= 1;
                }
            }
            EditorGUI.indentLevel -= 1;
            NGUIEditorTools.EndContents();
        }
    }
コード例 #10
0
    static void ShowList(SerializedProperty list)
    {
        if (!list.isArray)
        {
            return;
        }
        EditorGUI.indentLevel += 1;
        if (NGUIEditorTools.DrawMinimalisticHeader("Spawn Npc List"))
        {
            //NGUIEditorTools.BeginContents();
            EditorGUI.indentLevel += 1;
            SerializedProperty size = list.FindPropertyRelative("Array.size");
            EditorGUILayout.PropertyField(size);

            for (int i = 0; i < list.arraySize; i++)
            {
                if (NGUIEditorTools.DrawMinimalisticHeader("Element" + i))
                {
                    EditorGUILayout.BeginHorizontal();
                    EditorGUILayout.PropertyField(list.GetArrayElementAtIndex(i).FindPropertyRelative("targetNpc"));
                    EditorGUILayout.EndHorizontal();

                    EditorGUILayout.BeginHorizontal();
                    EditorGUILayout.PropertyField(list.GetArrayElementAtIndex(i).FindPropertyRelative("spawnPosition"));
                    EditorGUILayout.EndHorizontal();

                    switch (list.GetArrayElementAtIndex(i).FindPropertyRelative("spawnPosition").intValue)
                    {
                    case (int)RefreshMonsterResult.ENSwapPosType.enLocationPosition:
                    {
                        break;
                    }

                    case (int)RefreshMonsterResult.ENSwapPosType.PlayerPositionOffset:
                    case (int)RefreshMonsterResult.ENSwapPosType.CustomBlackboardStr:
                    case (int)RefreshMonsterResult.ENSwapPosType.AffectedGate:
                    case (int)RefreshMonsterResult.ENSwapPosType.TriggeringGate:
                    case (int)RefreshMonsterResult.ENSwapPosType.TriggeringTrap:
                    case (int)RefreshMonsterResult.ENSwapPosType.TargetPositionOfSkillBeingCast:
                    case (int)RefreshMonsterResult.ENSwapPosType.TargetActorOfTriggeringActor:
                    case (int)RefreshMonsterResult.ENSwapPosType.DeadActor:
                    case (int)RefreshMonsterResult.ENSwapPosType.CastingActor:
                    case (int)RefreshMonsterResult.ENSwapPosType.LastCreatedActor:
                    case (int)RefreshMonsterResult.ENSwapPosType.TargetActorOfSkill:
                    case (int)RefreshMonsterResult.ENSwapPosType.RebornActor:
                    case (int)RefreshMonsterResult.ENSwapPosType.AttackedActor:
                    case (int)RefreshMonsterResult.ENSwapPosType.TransportingActor:
                    case (int)RefreshMonsterResult.ENSwapPosType.TriggerEventTrap:
                    case (int)RefreshMonsterResult.ENSwapPosType.triggerPositionOffset:
                    {
                        EditorGUILayout.BeginHorizontal();
                        Vector2 soft = EditorGUILayout.Vector2Field("Off Set", list.GetArrayElementAtIndex(i).FindPropertyRelative("offset").vector2Value, GUILayout.MinWidth(30f));
                        EditorGUILayout.EndHorizontal();

                        list.GetArrayElementAtIndex(i).FindPropertyRelative("offset").vector2Value = soft;
                        break;
                    }

                    case (int)RefreshMonsterResult.ENSwapPosType.ObjectPositionOffset:
                    {
                        EditorGUILayout.BeginHorizontal();
                        Vector2 soft = EditorGUILayout.Vector2Field("Off Set", list.GetArrayElementAtIndex(i).FindPropertyRelative("offset").vector2Value, GUILayout.MinWidth(30f));
                        EditorGUILayout.EndHorizontal();

                        list.GetArrayElementAtIndex(i).FindPropertyRelative("offset").vector2Value = soft;
                        EditorGUILayout.BeginHorizontal();
                        EditorGUILayout.PropertyField(list.GetArrayElementAtIndex(i).FindPropertyRelative("targetObject"));
                        EditorGUILayout.EndHorizontal();
                        break;
                    }
                    }


                    EditorGUILayout.BeginHorizontal();
                    EditorGUILayout.PropertyField(list.GetArrayElementAtIndex(i).FindPropertyRelative("blackboardStr"));
                    EditorGUILayout.EndHorizontal();
                }
            }
            EditorGUI.indentLevel -= 1;
            EditorGUI.indentLevel -= 1;
        }
    }
コード例 #11
0
    private void OnGUI()
    {
        GUILayout.Space(10F);

        if (!m_atlas)
        {
            m_atlas = NGUISettings.atlas;
        }
        ComponentSelector.Draw <UIAtlas>("Atlas", m_atlas, obj => {
            if (m_atlas != obj)
            {
                m_atlas = obj as UIAtlas;
            }
        }, true, GUILayout.MinWidth(80f));

        if (m_atlas != null)
        {
            GUILayout.BeginHorizontal();
            GUILayout.Space(10f);
            if (GUILayout.Button("Search"))
            {
                m_spriteNames.Clear();

                Object[] uiSprites = Selection.GetFiltered(typeof(UISprite), SelectionMode.Deep);
                Object[] uiLabels  = Selection.GetFiltered(typeof(UILabel), SelectionMode.Deep);
                foreach (UISpriteData spriteData in m_atlas.spriteList)
                {
                    bool found = false;
                    foreach (UISprite uiSprite in uiSprites)
                    {
                        if (uiSprite.atlas == m_atlas && string.Equals(uiSprite.spriteName, spriteData.name))
                        {
                            found = true;
                            break;
                        }
                    }
                    if (!found)
                    {
                        foreach (UILabel uiLabel in uiLabels)
                        {
                            if (uiLabel.bitmapFont)
                            {
                                foreach (BMSymbol symbol in uiLabel.bitmapFont.symbols)
                                {
                                    if (string.Equals(symbol.spriteName, spriteData.name))
                                    {
                                        found = true;
                                        break;
                                    }
                                }
                                if (found)
                                {
                                    break;
                                }
                            }
                        }
                    }
                    if (!found)
                    {
                        m_spriteNames.Add(spriteData.name);
                    }
                }
            }
            GUILayout.Space(10f);
            GUILayout.EndHorizontal();
            GUILayout.Space(10f);

            GUILayout.BeginHorizontal();
            GUILayout.Space(5F);
            EditorGUILayout.BeginVertical();
            if (NGUIEditorTools.DrawMinimalisticHeader("Sprites"))
            {
                EditorGUILayout.BeginHorizontal();
                GUILayout.Space(15f);
                EditorGUILayout.BeginVertical();
                mScroll = EditorGUILayout.BeginScrollView(mScroll);
                GUILayout.Space(2f);

                int oldLength = m_spriteNames.Count;
                int newLength = EditorGUILayout.IntField("Size", oldLength);
                if (newLength != oldLength)
                {
                    int      minLength = Mathf.Min(newLength, oldLength);
                    string[] sprites   = new string[newLength];
                    for (int i = 0; i < minLength; i++)
                    {
                        sprites[i] = m_spriteNames[i];
                    }
                    m_spriteNames = new List <string>(sprites);
                }
                for (int i = 0; i < newLength; i++)
                {
                    int index = i;
                    NGUIEditorTools.DrawAdvancedSpriteField(m_atlas, m_spriteNames[index], spriteName => {
                        m_spriteNames[index] = spriteName;
                        Repaint();
                    }, false);
                }

                GUILayout.Space(2f);
                GUILayout.EndScrollView();
                EditorGUILayout.EndVertical();
                GUILayout.Space(3f);
                EditorGUILayout.EndHorizontal();
            }
            GUILayout.EndVertical();
            GUILayout.EndHorizontal();
            GUILayout.Space(10f);
        }
    }
コード例 #12
0
    private void OnGUI()
    {
        if (!mAtlas)
        {
            mAtlas = NGUISettings.atlas;
        }
        ComponentSelector.Draw <UIAtlas>("Atlas", mAtlas, obj => {
            if (mAtlas != obj)
            {
                mAtlas = obj as UIAtlas;
            }
        }, true, GUILayout.MinWidth(80f));

        if (!mAtlas)
        {
            mSprites = new string[0];
        }
        else
        {
            GUILayout.BeginHorizontal();
            GUILayout.Space(5F);
            EditorGUILayout.BeginVertical();
            if (NGUIEditorTools.DrawMinimalisticHeader("Sprites"))
            {
                EditorGUILayout.BeginHorizontal();
                GUILayout.Space(15F);
                EditorGUILayout.BeginVertical();
                GUILayout.Space(2F);

                int newLength = EditorGUILayout.IntField("Size", mSprites.Length);
                int oldLength = mSprites.Length;
                if (newLength != oldLength)
                {
                    int      minLength = Mathf.Min(newLength, oldLength);
                    string[] sprites   = new string[newLength];
                    for (int i = 0; i < minLength; i++)
                    {
                        sprites[i] = mSprites[i];
                    }
                    mSprites = sprites;
                }
                for (int i = 0; i < mSprites.Length; i++)
                {
                    int index = i;
                    NGUIEditorTools.DrawAdvancedSpriteField(mAtlas, mSprites[index], spriteName =>
                    {
                        mSprites[index] = spriteName;
                        Repaint();
                    }, false);
                }

                GUILayout.Space(2F);
                EditorGUILayout.EndVertical();
                GUILayout.Space(3F);
                EditorGUILayout.EndHorizontal();
            }
            GUILayout.EndVertical();
            GUILayout.EndHorizontal();
            GUILayout.Space(10F);
        }

        GUILayout.BeginHorizontal();
        GUILayout.Space(10F);
        bool start = GUILayout.Button("Create/Update Materials");

        GUILayout.Space(10F);
        GUILayout.EndHorizontal();

        if (start && mAtlas && mSprites.Length > 0)
        {
            string        atlasPath = AssetDatabase.GetAssetPath(mAtlas);
            string        dirPath   = atlasPath.Replace("/UIAtlas/", "/Materials/").Replace(".prefab", "/");
            DirectoryInfo dir       = new DirectoryInfo(dirPath);
            if (!dir.Exists)
            {
                dir.Create();
            }
            bool           anyAssetsChanged = false;
            UISpriteData[] spriteDatas      = new UISpriteData[mSprites.Length];
            for (int index = 0; index < mSprites.Length; index++)
            {
                string spriteName = mSprites[index];
                if (!string.IsNullOrEmpty(spriteName))
                {
                    UISpriteData spriteData = mAtlas.GetSprite(spriteName);
                    if (spriteData != null)
                    {
                        string   path    = dirPath + spriteName + ".mat";
                        bool     exist   = File.Exists(path);
                        Material mat     = exist ? AssetDatabase.LoadAssetAtPath <Material>(path) : new Material(mAtlas.spriteMaterial);
                        float    scaleX  = (float)spriteData.width / mAtlas.width;
                        float    scaleY  = (float)spriteData.height / mAtlas.height;
                        float    offsetX = (float)spriteData.x / mAtlas.width;
                        float    offsetY = (float)(mAtlas.height - spriteData.y - spriteData.height) / mAtlas.height;
                        mat.SetTextureScale("_MainTex", new Vector2(scaleX, scaleY));
                        mat.SetTextureOffset("_MainTex", new Vector2(offsetX, offsetY));
                        if (exist)
                        {
                            anyAssetsChanged = true;
                        }
                        else
                        {
                            AssetDatabase.CreateAsset(mat, path);
                        }
                    }
                }
            }
            if (anyAssetsChanged)
            {
                AssetDatabase.SaveAssets();
            }
        }
    }
コード例 #13
0
    /// <summary>
    /// Draw the atlas and sprite selection fields.
    /// </summary>

    protected override bool ShouldDrawProperties()
    {
        GUILayout.BeginHorizontal();
        if (NGUIEditorTools.DrawPrefixButton("Atlas"))
        {
            ComponentSelector.Show <UIAtlas>(OnSelectAtlas);
        }
        SerializedProperty atlas = NGUIEditorTools.DrawProperty("", serializedObject, "mAtlas", GUILayout.MinWidth(20f));

        if (GUILayout.Button("Edit", GUILayout.Width(40f)))
        {
            if (atlas != null)
            {
                UIAtlas atl = atlas.objectReferenceValue as UIAtlas;
                NGUISettings.atlas = atl;
                if (atl != null)
                {
                    NGUIEditorTools.Select(atl.gameObject);
                }
            }
        }
        GUILayout.EndHorizontal();

        SerializedProperty sp = serializedObject.FindProperty("mSpriteName");

        NGUIEditorTools.DrawAdvancedSpriteField(atlas.objectReferenceValue as UIAtlas, sp.stringValue, SelectSprite, false);

        UIPolygonSprite sprite = target as UIPolygonSprite;

        GUILayout.BeginHorizontal();
        SerializedProperty fill = serializedObject.FindProperty("mFillCenter");

        fill.boolValue = EditorGUILayout.Toggle("Fill", fill.boolValue, GUILayout.Width(95f));
        if (!fill.boolValue)
        {
            SerializedProperty thickness = serializedObject.FindProperty("mThickness");
            thickness.intValue = EditorGUILayout.IntSlider("Thickness", thickness.intValue, 1, sprite.width / 2);
        }
        GUILayout.EndHorizontal();

        SerializedProperty test = serializedObject.FindProperty("mTest");

        test.boolValue = EditorGUILayout.Toggle("SliceTest", test.boolValue, GUILayout.Width(95f));

        SerializedProperty spSide = serializedObject.FindProperty("mSideSpriteName");

        NGUIEditorTools.DrawAdvancedSpriteField(atlas.objectReferenceValue as UIAtlas, spSide.stringValue, SelectSideSprite, false);

        SerializedProperty sides = serializedObject.FindProperty("mPolygonSides");

        sides.intValue = EditorGUILayout.IntSlider("Sides", sides.intValue, 3, 360);

        SerializedProperty verticesDistance = serializedObject.FindProperty("mVerticesDistances");
        SerializedProperty spriteSides      = serializedObject.FindProperty("mSpriteSides");

        if (verticesDistance.arraySize != sides.intValue + 1)
        {
            verticesDistance.ClearArray();
            verticesDistance.arraySize = sides.intValue + 1;
            for (int i = 0; i < sides.intValue; i++)
            {
                verticesDistance.GetArrayElementAtIndex(i).floatValue = 1f;
            }

            if (test.boolValue)
            {
                for (int i = 0; i < spriteSides.arraySize; ++i)
                {
                    UISprite spriteSide = spriteSides.GetArrayElementAtIndex(i).objectReferenceValue as UISprite;
                    if (spriteSide != null)
                    {
                        NGUITools.Destroy(spriteSide.gameObject);
                        spriteSide = null;
                    }
                }

                spriteSides.ClearArray();
                spriteSides.arraySize = sides.intValue;

                for (int i = 0; i < sides.intValue; ++i)
                {
                    if (spSide.stringValue.Length > 0)
                    {
                        UISprite spriteSide = NGUITools.AddSprite(sprite.gameObject, sprite.atlas, spSide.stringValue, sprite.depth + 1);
                        spriteSide.MakePixelPerfect();

                        spriteSides.GetArrayElementAtIndex(i).objectReferenceValue = spriteSide;
                    }
                }
            }
        }

        if (NGUIEditorTools.DrawMinimalisticHeader("Distance"))
        {
            NGUIEditorTools.BeginContents(true);

            for (int i = 0; i < sides.intValue; i++)
            {
                verticesDistance.GetArrayElementAtIndex(i).floatValue = EditorGUILayout.Slider("Distances " + i, verticesDistance.GetArrayElementAtIndex(i).floatValue, 0, 1);
                if (test.boolValue)
                {
                    if (sprite.width * verticesDistance.GetArrayElementAtIndex(i).floatValue < sprite.minWidth)
                    {
                        verticesDistance.GetArrayElementAtIndex(i).floatValue = sprite.minWidth / (float)sprite.width;
                    }
                }
            }

            NGUIEditorTools.EndContents();
        }

        // last vertex is also the first!
        verticesDistance.GetArrayElementAtIndex(sides.intValue).floatValue = verticesDistance.GetArrayElementAtIndex(0).floatValue;

        return(true);
    }