示例#1
0
    protected virtual void gui()
    {
        SkeletonRenderer component = (SkeletonRenderer)target;

        EditorGUILayout.BeginHorizontal();
        EditorGUILayout.PropertyField(skeletonDataAsset);
        float reloadWidth = GUI.skin.label.CalcSize(new GUIContent("Reload")).x + 20;

        if (GUILayout.Button("Reload", GUILayout.Width(reloadWidth)))
        {
            if (component.skeletonDataAsset != null)
            {
                component.skeletonDataAsset.Reset();
            }
            component.Reset();
        }
        EditorGUILayout.EndHorizontal();

        if (!component.valid)
        {
            component.Reset();
            component.LateUpdate();
            if (!component.valid)
            {
                return;
            }
        }


        // Initial skin name.
        {
            String[] skins     = new String[component.skeleton.Data.Skins.Count];
            int      skinIndex = 0;
            for (int i = 0; i < skins.Length; i++)
            {
                String name = component.skeleton.Data.Skins[i].Name;
                skins[i] = name;
                if (name == initialSkinName.stringValue)
                {
                    skinIndex = i;
                }
            }

            EditorGUILayout.BeginHorizontal();
            EditorGUILayout.LabelField("Initial Skin", GUILayout.Width(EditorGUIUtility.labelWidth));
            skinIndex = EditorGUILayout.Popup(skinIndex, skins);
            EditorGUILayout.EndHorizontal();

            initialSkinName.stringValue = skins[skinIndex];
        }

        EditorGUILayout.PropertyField(meshes,
                                      new GUIContent("Render Meshes", "Disable to optimize rendering for skeletons that don't use meshes"));
        EditorGUILayout.PropertyField(immutableTriangles,
                                      new GUIContent("Immutable Triangles", "Enable to optimize rendering for skeletons that never change attachment visbility"));
        EditorGUILayout.PropertyField(normals);
        EditorGUILayout.PropertyField(tangents);
    }
示例#2
0
    public void HandleReset(SkeletonRenderer renderer)
    {
        if (slotName == null || slotName == "")
        {
            return;
        }

        hasReset = true;

        ClearColliders();
        colliderTable.Clear();

        if (skeletonRenderer.skeleton == null)
        {
            skeletonRenderer.OnReset -= HandleReset;
            skeletonRenderer.Reset();
            skeletonRenderer.OnReset += HandleReset;
        }


        var skeleton = skeletonRenderer.skeleton;

        slot = skeleton.FindSlot(slotName);
        int slotIndex = skeleton.FindSlotIndex(slotName);

        foreach (var skin in skeleton.Data.Skins)
        {
            List <string> attachmentNames = new List <string>();
            skin.FindNamesForSlot(slotIndex, attachmentNames);

            foreach (var name in attachmentNames)
            {
                var attachment = skin.GetAttachment(slotIndex, name);
                if (attachment is BoundingBoxAttachment)
                {
                    var collider = SkeletonUtility.AddBoundingBoxAsComponent((BoundingBoxAttachment)attachment, gameObject, true);
                    collider.enabled   = false;
                    collider.hideFlags = HideFlags.HideInInspector;
                    colliderTable.Add((BoundingBoxAttachment)attachment, collider);
                    attachmentNameTable.Add((BoundingBoxAttachment)attachment, name);
                }
            }
        }

        if (colliderTable.Count == 0)
        {
            valid = false;
        }
        else
        {
            valid = true;
        }

        if (!valid)
        {
            Debug.LogWarning("Bounding Box Follower not valid! Slot [" + slotName + "] does not contain any Bounding Box Attachments!");
        }
    }
    override public void OnInspectorGUI()
    {
        serializedObject.Update();
        SkeletonRenderer component = (SkeletonRenderer)target;

        EditorGUILayout.PropertyField(skeletonDataAsset);

        if (component.skeleton != null)
        {
            // Initial skin name.
            String[] skins     = new String[component.skeleton.Data.Skins.Count];
            int      skinIndex = 0;
            for (int i = 0; i < skins.Length; i++)
            {
                String name = component.skeleton.Data.Skins[i].Name;
                skins[i] = name;
                if (name == initialSkinName.stringValue)
                {
                    skinIndex = i;
                }
            }

            EditorGUILayout.BeginHorizontal();
            EditorGUILayout.LabelField("Initial Skin");
            EditorGUIUtility.LookLikeControls();
            skinIndex = EditorGUILayout.Popup(skinIndex, skins);
            EditorGUILayout.EndHorizontal();

            initialSkinName.stringValue = skins[skinIndex];
        }

        EditorGUILayout.PropertyField(timeScale);
        EditorGUILayout.PropertyField(normals);
        EditorGUILayout.PropertyField(tangents);

        if (serializedObject.ApplyModifiedProperties() ||
            (Event.current.type == EventType.ValidateCommand && Event.current.commandName == "UndoRedoPerformed")
            )
        {
            if (!Application.isPlaying)
            {
                component.Reset();
            }
        }
    }
	void OnEnable () {
		skeletonUtility = (SkeletonUtility)target;
		skeletonRenderer = skeletonUtility.GetComponent<SkeletonRenderer>();
		skeleton = skeletonRenderer.skeleton;
		transform = skeletonRenderer.transform;

		if (skeleton == null) {
			skeletonRenderer.Reset();
			skeletonRenderer.LateUpdate();

			skeleton = skeletonRenderer.skeleton;
		}

		UpdateAttachments();

		if (PrefabUtility.GetPrefabType(this.target) == PrefabType.Prefab)
			isPrefab = true;

	}
示例#5
0
    void OnEnable()
    {
        skeletonUtility  = (SkeletonUtility)target;
        skeletonRenderer = skeletonUtility.GetComponent <SkeletonRenderer>();
        skeleton         = skeletonRenderer.skeleton;
        transform        = skeletonRenderer.transform;

        if (skeleton == null)
        {
            skeletonRenderer.Reset();
            skeletonRenderer.LateUpdate();

            skeleton = skeletonRenderer.skeleton;
        }

        UpdateAttachments();

        if (PrefabUtility.GetPrefabType(this.target) == PrefabType.Prefab)
        {
            isPrefab = true;
        }
    }
    protected virtual void gui()
    {
        SkeletonRenderer component = (SkeletonRenderer)target;

        EditorGUILayout.BeginHorizontal();
        EditorGUILayout.PropertyField(skeletonDataAsset);
        float reloadWidth = GUI.skin.label.CalcSize(new GUIContent("Reload")).x + 20;

        if (GUILayout.Button("Reload", GUILayout.Width(reloadWidth)))
        {
            if (component.skeletonDataAsset != null)
            {
                foreach (AtlasAsset aa in component.skeletonDataAsset.atlasAssets)
                {
                    if (aa != null)
                    {
                        aa.Reset();
                    }
                }

                component.skeletonDataAsset.Reset();
            }
            component.Reset();
        }
        EditorGUILayout.EndHorizontal();

        if (!component.valid)
        {
            component.Reset();
            component.LateUpdate();
            if (!component.valid)
            {
                return;
            }
        }

        // Initial skin name.
        {
            String[] skins     = new String[component.skeleton.Data.Skins.Count];
            int      skinIndex = 0;
            for (int i = 0; i < skins.Length; i++)
            {
                String name = component.skeleton.Data.Skins.Items[i].Name;
                skins[i] = name;
                if (name == initialSkinName.stringValue)
                {
                    skinIndex = i;
                }
            }

            skinIndex = EditorGUILayout.Popup("Initial Skin", skinIndex, skins);
            initialSkinName.stringValue = skins[skinIndex];
        }

        EditorGUILayout.Space();

        // Sorting Layers
        {
            var renderer = component.GetComponent <Renderer>();
            if (renderer != null)
            {
                EditorGUI.BeginChangeCheck();

                if (EditorGUILayoutSortingLayerField != null && sortingLayerIDProperty != null)
                {
                    EditorGUILayoutSortingLayerField.Invoke(null, new object[] { new GUIContent("Sorting Layer"), sortingLayerIDProperty, EditorStyles.popup });
                }
                else
                {
                    renderer.sortingLayerID = EditorGUILayout.IntField("Sorting Layer ID", renderer.sortingLayerID);
                }

                renderer.sortingOrder = EditorGUILayout.IntField("Order in Layer", renderer.sortingOrder);

                if (EditorGUI.EndChangeCheck())
                {
                    rendererSerializedObject.ApplyModifiedProperties();
                    EditorUtility.SetDirty(renderer);
                }
            }
        }

        // More Render Options...
        {
            advancedFoldout = EditorGUILayout.Foldout(advancedFoldout, "Advanced");
            if (advancedFoldout)
            {
                EditorGUI.indentLevel++;
                EditorGUILayout.PropertyField(meshes,
                                              new GUIContent("Render Meshes", "Disable to optimize rendering for skeletons that don't use meshes"));
                EditorGUILayout.PropertyField(immutableTriangles,
                                              new GUIContent("Immutable Triangles", "Enable to optimize rendering for skeletons that never change attachment visbility"));
                EditorGUILayout.PropertyField(normals);
                EditorGUILayout.PropertyField(tangents);
                EditorGUILayout.PropertyField(front);
                EditorGUILayout.PropertyField(submeshSeparators, true);
                EditorGUI.indentLevel--;
            }
        }
    }