Example #1
0
        private void ApplyNodeProperty(INodeProperty property, Identifier identifier)
        {
            var node = _nodes[identifier];

            property.Apply(node,
                           _debuggerOperations, identifier);
        }
        public void FromINodeProperty(INodeProperty property)
        {
            if (!(property is LabelNodeProperty))
            {
                return;
            }

            FromAbstractLabelProperty((LabelNodeProperty)property);
        }
Example #3
0
 public void FromINodeProperty(INodeProperty property)
 {
     if (!(property is LineWidthNodeProperty lineWidthNodeProperty))
     {
         return;
     }
     CheckBox.IsChecked = true;
     TextBox.Text       = $"{lineWidthNodeProperty.LineWidth:0.00}";
 }
 public void FromINodeProperty(INodeProperty property)
 {
     if (!(property is FillColorNodeProperty fillColorNodeProperty))
     {
         return;
     }
     CheckBox.IsChecked = true;
     SetColor(fillColorNodeProperty.Color);
 }
        public void FromINodeProperty(INodeProperty property)
        {
            if (!(property is StyleNodeProperty))
            {
                return;
            }

            FromProperty(() => ((StyleNodeProperty)property).Style);
        }
        public void AddShaderProperty(INodeProperty property)
        {
            if (property == null)
            {
                return;
            }

            if (m_Properties.Contains(property))
            {
                return;
            }

            m_Properties.Add(property);
            m_PropertyDictionary.Add(property.guid, property);
            m_AddedProperties.Add(property);
        }
Example #7
0
        public void FromINodeProperty(INodeProperty property)
        {
            if (!(property is ShapeNodeProperty))
            {
                return;
            }

            var shapeProperty = (ShapeNodeProperty)property;
            var shapeName     = ShapesToMsaglTypes.FirstOrDefault(x => x.Value == shapeProperty.Shape).Key;

            if (shapeName == null)
            {
                return;
            }

            CheckBox.IsChecked = true;
            _shapeRadioButtons.Where(r => (string)r.Content == shapeName).ToList().ForEach(r => r.IsChecked = true);
        }
        void AddProperty(INodeProperty property, bool create = false, int index = -1)
        {
            if (m_PropertyRows.ContainsKey(property.guid))
            {
                return;
            }

            if (create)
            {
                property.displayName = m_Graph.SanitizePropertyName(property.displayName);
            }

            var field = new BlackboardField(m_ExposedIcon, property.displayName, property.propertyType.ToString())
            {
                userData = property
            };
            var row = new BlackboardRow(field, new BlackboardFieldPropertyView(m_Graph, property));

            row.userData = property;
            if (index < 0)
            {
                index = m_PropertyRows.Count;
            }
            if (index == m_PropertyRows.Count)
            {
                m_Section.Add(row);
            }
            else
            {
                m_Section.Insert(index, row);
            }
            m_PropertyRows[property.guid] = row;

            if (create)
            {
                row.expanded = true;
                m_Graph.owner.RegisterCompleteObjectUndo("Create Property");
                m_Graph.AddShaderProperty(property);
                field.OpenTextEditor();
            }
        }
Example #9
0
        void CreateNode(object obj, Vector2 nodePosition)
        {
            var blackboardField = obj as BlackboardField;

            if (blackboardField != null)
            {
                INodeProperty property = blackboardField.userData as INodeProperty;
                if (property != null)
                {
                    graph.owner.RegisterCompleteObjectUndo("Drag Property");
                    var node = new PropertyNode();

                    var drawState = node.drawState;
                    drawState.position = new Rect(nodePosition, drawState.position.size);
                    node.drawState     = drawState;
                    graph.AddNode(node);

                    node.propertyGuid = property.guid;
                }
            }
        }
        public void MoveShaderProperty(INodeProperty property, int newIndex)
        {
            if (newIndex > m_Properties.Count || newIndex < 0)
            {
                throw new ArgumentException("New index is not within properties list.");
            }
            var currentIndex = m_Properties.IndexOf(property);

            if (currentIndex == -1)
            {
                throw new ArgumentException("Property is not in graph.");
            }
            if (newIndex == currentIndex)
            {
                return;
            }
            m_Properties.RemoveAt(currentIndex);
            if (newIndex > currentIndex)
            {
                newIndex--;
            }
            var isLast = newIndex == m_Properties.Count;

            if (isLast)
            {
                m_Properties.Add(property);
            }
            else
            {
                m_Properties.Insert(newIndex, property);
            }
            if (!m_MovedProperties.Contains(property))
            {
                m_MovedProperties.Add(property);
            }
        }
        public BlackboardFieldPropertyView(AbstractNodeGraph graph, INodeProperty property)
        {
            styleSheets.Add(Resources.Load <StyleSheet>("Styles/NodeGraphBlackboard"));
            m_Graph = graph;

            m_Reference = new TextField();
            m_Reference.RegisterValueChangedCallback(evt =>
            {
                property.reference = evt.newValue;
                DirtyNodes(ModificationScope.Graph);
            });
            m_Reference.value = property.reference;
            AddRow("Reference", m_Reference);

            if (property is ValueProperty <float> )
            {
                var        floatProperty = (ValueProperty <float>)property;
                FloatField floatField    = new FloatField {
                    value = floatProperty.value
                };
                floatField.RegisterValueChangedCallback(evt =>
                {
                    floatProperty.value = (float)evt.newValue;
                    DirtyNodes();
                });
                AddRow("Default", floatField);

                /*if (floatProperty.floatType == FloatType.Slider)
                 * {
                 *  var minField = new FloatField { value = floatProperty.rangeValues.x };
                 *  minField.OnValueChanged(minEvt =>
                 *      {
                 *          floatProperty.rangeValues = new Vector2((float)minEvt.newValue, floatProperty.rangeValues.y);
                 *          floatProperty.value = Mathf.Max(Mathf.Min(floatProperty.value, floatProperty.rangeValues.y), floatProperty.rangeValues.x);
                 *          floatField.value = floatProperty.value;
                 *          DirtyNodes();
                 *      });
                 *  minRow = AddRow("Min", minField);
                 *  var maxField = new FloatField { value = floatProperty.rangeValues.y };
                 *  maxField.OnValueChanged(maxEvt =>
                 *      {
                 *          floatProperty.rangeValues = new Vector2(floatProperty.rangeValues.x, (float)maxEvt.newValue);
                 *          floatProperty.value = Mathf.Max(Mathf.Min(floatProperty.value, floatProperty.rangeValues.y), floatProperty.rangeValues.x);
                 *          floatField.value = floatProperty.value;
                 *          DirtyNodes();
                 *      });
                 *  maxRow = AddRow("Max", maxField);
                 * }*/
            }
            else if (property is ValueProperty <int> )
            {
                var intProperty = (ValueProperty <int>)property;

                var field = new IntegerField {
                    value = intProperty.value
                };
                field.RegisterValueChangedCallback(intEvt =>
                {
                    intProperty.value = intEvt.newValue;
                    DirtyNodes();
                });
                AddRow("Default", field);
            }
            else if (property is ValueProperty <Vector2> )
            {
                var vectorProperty = (ValueProperty <Vector2>)property;
                var field          = new Vector2Field {
                    value = vectorProperty.value
                };
                field.RegisterValueChangedCallback(evt =>
                {
                    vectorProperty.value = evt.newValue;
                    DirtyNodes();
                });
                AddRow("Default", field);
            }
            else if (property is ValueProperty <Vector3> )
            {
                var vectorProperty = (ValueProperty <Vector3>)property;
                var field          = new Vector3Field {
                    value = vectorProperty.value
                };
                field.RegisterValueChangedCallback(evt =>
                {
                    vectorProperty.value = evt.newValue;
                    DirtyNodes();
                });
                AddRow("Default", field);
            }
            else if (property is ValueProperty <Vector4> )
            {
                var vectorProperty = (ValueProperty <Vector4>)property;
                var field          = new Vector4Field {
                    value = vectorProperty.value
                };
                field.RegisterValueChangedCallback(evt =>
                {
                    vectorProperty.value = evt.newValue;
                    DirtyNodes();
                });
                AddRow("Default", field);
            }
            else if (property is ValueProperty <Color> )
            {
                var colorProperty = (ValueProperty <Color>)property;
                //todo add HDR
                var colorField = new ColorField {
                    value = (Color)property.defaultValue, showEyeDropper = false
                };
                colorField.RegisterValueChangedCallback(evt =>
                {
                    colorProperty.value = evt.newValue;
                    DirtyNodes();
                });
                AddRow("Default", colorField);
            }
            else if (property is ValueProperty <Texture2D> )
            {
                var textureProperty = (ValueProperty <Texture2D>)property;
                var field           = new ObjectField {
                    value = textureProperty.value, objectType = typeof(Texture2D)
                };
                field.RegisterValueChangedCallback(evt =>
                {
                    textureProperty.value = (Texture2D)evt.newValue;
                    DirtyNodes();
                });
                AddRow("Default", field);
            }
            else if (property is ValueProperty <Cubemap> )
            {
                var cubemapProperty = (ValueProperty <Cubemap>)property;
                var field           = new ObjectField {
                    value = cubemapProperty.value, objectType = typeof(Cubemap)
                };
                field.RegisterValueChangedCallback(evt =>
                {
                    cubemapProperty.value = (Cubemap)evt.newValue;
                    DirtyNodes();
                });
                AddRow("Default", field);
            }
            else if (property is ValueProperty <bool> )
            {
                var booleanProperty = (ValueProperty <bool>)property;
                EventCallback <ChangeEvent <bool> > onBooleanChanged = evt =>
                {
                    booleanProperty.value = evt.newValue;
                    DirtyNodes();
                };
                var field = new Toggle();
                field.RegisterValueChangedCallback(onBooleanChanged);
                field.value = booleanProperty.value;
                AddRow("Default", field);
            }
//            AddRow("Type", new TextField());
//            AddRow("Exposed", new Toggle(null));
//            AddRow("Range", new Toggle(null));
//            AddRow("Default", new TextField());
//            AddRow("Tooltip", new TextField());


            AddToClassList("sgblackboardFieldPropertyView");
        }
Example #12
0
        internal static void InsertCopyPasteGraph(this NodeGraphView graphView, CopyPasteGraph copyGraph)
        {
            if (copyGraph == null)
            {
                return;
            }

            // Make new properties from the copied graph
            foreach (INodeProperty property in copyGraph.properties)
            {
                string        propertyName   = graphView.graph.SanitizePropertyName(property.displayName);
                INodeProperty copiedProperty = property.Copy();
                copiedProperty.displayName = propertyName;
                graphView.graph.AddShaderProperty(copiedProperty);

                // Update the property nodes that depends on the copied node
                var dependentPropertyNodes = copyGraph.GetNodes <PropertyNode>().Where(x => x.propertyGuid == property.guid);
                foreach (var node in dependentPropertyNodes)
                {
                    node.SetOwner(graphView.graph);
                    node.propertyGuid = copiedProperty.guid;
                }
            }

            using (var remappedNodesDisposable = ListPool <INode> .GetDisposable())
            {
                using (var remappedEdgesDisposable = ListPool <IEdge> .GetDisposable())
                {
                    var remappedNodes = remappedNodesDisposable.value;
                    var remappedEdges = remappedEdgesDisposable.value;
                    graphView.graph.PasteGraph(copyGraph, remappedNodes, remappedEdges);

                    if (graphView.graph.guid != copyGraph.sourceGraphGuid)
                    {
                        // Compute the mean of the copied nodes.
                        Vector2 centroid = Vector2.zero;
                        var     count    = 1;
                        foreach (var node in remappedNodes)
                        {
                            var position = node.drawState.position.position;
                            centroid = centroid + (position - centroid) / count;
                            ++count;
                        }

                        // Get the center of the current view
                        var viewCenter = graphView.contentViewContainer.WorldToLocal(graphView.layout.center);

                        foreach (var node in remappedNodes)
                        {
                            var drawState    = node.drawState;
                            var positionRect = drawState.position;
                            var position     = positionRect.position;
                            position += viewCenter - centroid;
                            positionRect.position = position;
                            drawState.position    = positionRect;
                            node.drawState        = drawState;
                        }
                    }

                    // Add new elements to selection
                    graphView.ClearSelection();
                    graphView.graphElements.ForEach(element =>
                    {
                        var edge = element as UnityEditor.Experimental.UIElements.GraphView.Edge;
                        if (edge != null && remappedEdges.Contains(edge.userData as IEdge))
                        {
                            graphView.AddToSelection(edge);
                        }

                        var nodeView = element as NodeView;
                        if (nodeView != null && remappedNodes.Contains(nodeView.node))
                        {
                            graphView.AddToSelection(nodeView);
                        }
                    });
                }
            }
        }
 public int GetShaderPropertyIndex(INodeProperty property)
 {
     return(m_Properties.IndexOf(property));
 }
Example #14
0
 public void AddMetaProperty(INodeProperty metaProperty)
 {
     m_MetaProperties.Add(metaProperty);
 }
Example #15
0
 public void AddProperty(INodeProperty property)
 {
     m_Properties.Add(property);
 }