Beispiel #1
0
        private void DrawAssetSelection()
        {
            CurrentPackage = (ProjectImport)EditorGUILayout.ObjectField(CurrentPackage, typeof(ProjectImport), true);
            if (CurrentPackage != null)
            {
                var explorer = CurrentPackage.Explorer;

                foreach (var resource in explorer.Resources)
                {
                    if (!resource.Name.EndsWith(".bhvr"))
                    {
                        continue;
                    }

                    if (GUILayout.Button(resource.ToString()))
                    {
                        CurrentResource = resource;
                        JObject editorTarget;
                        using (var editorTargetData = CurrentResource.LoadStream())
                            using (var sr = new StreamReader(editorTargetData))
                                using (var reader = new JsonTextReader(sr))
                                {
                                    editorTarget = JObject.Load(reader);
                                }

                        var nodes = NodeManifest.Construct(new Type[] { typeof(AddNode), typeof(RollNode), typeof(OutputValueNode) });
                        var types = TypeManifest.ConstructBaseTypes();

                        var manifest = new BehaviourManifest()
                        {
                            Nodes = nodes,
                            Types = types,
                        };
                        Debug.Log(editorTarget);
                        var graphEditor = new EditorSession(manifest, editorTarget, "SerializedGraph", Serializer);

                        View.BeginSession(graphEditor);
                    }
                }
            }
        }
Beispiel #2
0
        private void DrawAssetSelection()
        {
            CurrentPackage = (ProjectImport)EditorGUILayout.ObjectField(CurrentPackage, typeof(ProjectImport), true,
                                                                        GUILayout.Width(180));
            if (CurrentPackage == null)
            {
                return;
            }

            var explorer = CurrentPackage.Explorer;

            foreach (var resource in explorer.Resources)
            {
                if (!resource.Name.EndsWith(".bhvr"))
                {
                    continue;
                }

                if (GUILayout.Button(resource.ToString()))
                {
                    CurrentResource = resource;
                    JObject editorTarget;
                    using (var editorTargetData = CurrentResource.LoadStream())
                        using (var sr = new StreamReader(editorTargetData))
                            using (var reader = new JsonTextReader(sr))
                            {
                                editorTarget = JObject.Load(reader);
                            }

                    var nodes = NodeManifest.Construct(new Type[] {
                        typeof(AddNode),
                        typeof(RollNode),
                        typeof(OutputValueNode),
                        typeof(ItemInputNode),
                        typeof(ActivatableItemNode),
                        typeof(IterateNode),
                        typeof(GetStatNode),
                    });
                    var types = TypeManifest.Construct(
                        new Type[]
                    {
                        typeof(bool),
                        typeof(string),
                        typeof(int),
                        typeof(byte),
                        typeof(long),
                        typeof(short),
                        typeof(uint),
                        typeof(ulong),
                        typeof(ushort),
                        typeof(sbyte),
                        typeof(char),
                        typeof(float),
                        typeof(double),
                        typeof(decimal),
                        typeof(InputSocket),
                        typeof(LocalId),
                    },
                        new Type[]
                    {
                        typeof(SerializedGraph),
                        typeof(SerializedNode),
                        typeof(PackageNodeEditor),
                        typeof(PackageNodePosition),
                        typeof(ExtraData)
                    }
                        );

                    var manifest = new BehaviourManifest()
                    {
                        Nodes = nodes,
                        Types = types,
                    };
                    Debug.Log(editorTarget);
                    var graphEditor = new EditorSession(manifest, editorTarget, "SerializedGraph", Serializer);

                    View.BeginSession(graphEditor, graphEditor.Root);
                }
            }
        }
Beispiel #3
0
        public void OnGUI()
        {
            screenRect = new Rect(0, EditorGUIUtility.singleLineHeight + 1,
                                  position.width, position.height - (EditorGUIUtility.singleLineHeight + 1));

            currentEvent = Event.current;

            // HandleDragAndDrop (screenRect);


            DrawBackground(screenRect, dragging_Position);
            DrawTopBar();


            CurrentPackage = (ProjectImport)EditorGUILayout.ObjectField(CurrentPackage, typeof(ProjectImport), true);

            var explorer = CurrentPackage.Explorer;

            foreach (var resource in explorer.Resources)
            {
                if (!resource.Name.EndsWith(".bhvr"))
                {
                    continue;
                }

                if (GUILayout.Button(resource.ToString()))
                {
                    CurrentResource    = resource;
                    HasCurrentResource = true;
                    HasEditor          = false;
                }
            }

            if (HasCurrentResource && CurrentResource != null)
            {
                if (HasEditor == false)
                {
                    Debug.Log(CurrentResource);

                    var editorTargetData = CurrentResource.LoadStream();

                    using (var sr = new StreamReader(editorTargetData))
                        using (var reader = new JsonTextReader(sr))
                        {
                            editorTarget = JObject.Load(reader);
                            // editorTarget = serializer.Deserialize(reader);
                        }

                    var nodes = NodeManifest.Construct(new Type[] { typeof(AddNode), typeof(RollNode) });
                    var types = TypeManifest.ConstructBaseTypes();

                    var manifest = new BehaviourManifest()
                    {
                        Nodes = nodes,
                        Types = types,
                    };
                    Debug.Log(editorTarget);
                    graphEditor = new EditorSession(manifest, editorTarget, "SerializedGraph");
                    HasEditor   = true;
                }

                if (GUILayout.Button("Save"))
                {
                    using (var file = CurrentResource.WriteStream())
                    {
                        serializer.Serialize(new JsonTextWriter(file)
                        {
                            Formatting = Formatting.Indented
                        }, editorTarget);
                    }
                }

                foreach (var node in graphEditor.Root["Nodes"])
                {
                    var nodeEditor         = node["Editor"];
                    var nodeEditorPosition = nodeEditor["Position"];

                    var nodeRect = new Rect(
                        dragging_Position.x + nodeEditorPosition["x"].GetValue <int>(),
                        dragging_Position.y + nodeEditorPosition["y"].GetValue <int>(),
                        200,
                        160
                        );

                    bool startDrag = false;
                    if (Event.current.type == EventType.Repaint)
                    {
                        BehaviourGraphResources.Instance.NodeStyle.Draw(nodeRect,
                                                                        false, node.Name == selectedNode, false, false);
                    }

                    GUILayout.BeginArea(nodeRect);

                    var nodeData = node.Json["Data"];
                    var nodeType = node["Type"];

                    object fieldObject;
                    if (!node.ViewBag.TryGetValue("Generic", out fieldObject))
                    {
                        var fieldInformation = new FieldInformation();
                        fieldInformation.Type = nodeType.Json.ToObject <string>();

                        fieldObject = new EditorField(graphEditor, nodeData, node.Name,
                                                      fieldInformation);

                        node.ViewBag["Generic"] = fieldObject;
                    }
                    var field = (EditorField)fieldObject;


                    foreach (var childField in field)
                    {
                        DrawField(childField);
                    }

                    GUILayout.EndArea();

                    if (Event.current.type == EventType.MouseDown)
                    {
                        if (nodeRect.Contains(Event.current.mousePosition))
                        {
                            selectedNode          = node.Name;
                            dragging_IsDragging   = true;
                            dragging_NodeDragging = true;

                            GUI.UnfocusWindow();
                            GUI.FocusControl("");

                            Event.current.Use();
                        }
                    }
                }

                foreach (var node in graphEditor.Root["Nodes"])
                {
                    var nodeEditor         = node["Editor"];
                    var nodeEditorPosition = nodeEditor["Position"];

                    var nodePositionX = nodeEditorPosition["x"].GetValue <int>() + dragging_Position.x;
                    var nodePositionY = nodeEditorPosition["y"].GetValue <int>() + dragging_Position.y;

                    var nodeData = node.Json["Data"];
                    var nodeType = node["Type"];

                    object fieldObject;
                    if (!node.ViewBag.TryGetValue("Generic", out fieldObject))
                    {
                        var fieldInformation = new FieldInformation();
                        fieldInformation.Type = nodeType.Json.ToObject <string>();

                        fieldObject = new EditorField(graphEditor, nodeData, node.Name,
                                                      fieldInformation);

                        node.ViewBag["Generic"] = fieldObject;
                    }
                    var field = (EditorField)fieldObject;


                    foreach (var childField in field)
                    {
                        if (childField.Field.Type == "InputSocket")
                        {
                            object renderPosObject;
                            var    renderPos = new Rect();;
                            if (childField.ViewBag.TryGetValue("Position", out renderPosObject))
                            {
                                renderPos = (Rect)renderPosObject;
                            }
                            else
                            {
                                Debug.LogError(childField.Name + " has no position");
                            }

                            renderPos.x += nodePositionX;
                            renderPos.y += nodePositionY;

                            // EditorGUI.DrawRect(renderPos, Color.red);

                            Vector3 start    = new Vector3(renderPos.x, renderPos.y);
                            Vector3 end      = new Vector3(renderPos.x - 100, renderPos.y - 100);
                            Vector3 startDir = new Vector3(-1, 0);
                            Vector3 endDir   = new Vector3(1, 0);

                            DrawConnection(start, end, startDir, endDir);
                        }
                    }
                }
            }

            HandleInput();
        }