コード例 #1
0
        private static void ParameterNodeTypeChanged(object sender, HyperGraph.Items.AcceptNodeSelectionChangedEventArgs args)
        {
            if (sender is HyperGraph.Items.NodeDropDownItem)
            {
                var item = (HyperGraph.Items.NodeDropDownItem)sender;
                var node = item.Node;

                var newType = AsSourceType(item.Items[args.Index]);

                //  We might have to change the input/output settings on this node
                bool isOutput = newType == ShaderFragmentArchive.Parameter.SourceType.Output;
                var  oldItems = new List <HyperGraph.NodeItem>(node.Items);
                foreach (var i in oldItems)
                {
                    if (i is ShaderFragmentNodeItem)
                    {
                        // if this is a node item with exactly 1 input/output
                        // and it is not in the correct direction, then we have to change it.
                        //  we can't change directly. We need to delete and recreate this node item.
                        var fragItem = (ShaderFragmentNodeItem)i;
                        if ((fragItem.Output.Enabled ^ fragItem.Input.Enabled) == true &&
                            (fragItem.Output.Enabled) != (isOutput == false))
                        {
                            var newItem = new ShaderFragmentNodeItem(
                                fragItem.Name, fragItem.Type, fragItem.ArchiveName,
                                isOutput ? true : false, isOutput ? false : true);
                            node.RemoveItem(fragItem);
                            node.AddItem(newItem);
                        }
                    }
                }
            }
        }
コード例 #2
0
ファイル: ModelConversion.cs プロジェクト: taknim/XLE
 private static string TypeFromNodeItem(ShaderFragmentNodeItem nodeItem)
 {
     if (nodeItem.ArchiveName != null && nodeItem.ArchiveName.Length != 0)
     {
         return(ShaderFragmentArchive.Archive.GetParameter(nodeItem.ArchiveName).Type);
     }
     return(nodeItem.Type);
 }
コード例 #3
0
        public static bool FillInMaterialParameters(ShaderDiagram.Document document, HyperGraph.GraphControl graphControl)
        {
            //
            //      Look for new or removed material parameters
            //      and update the material parameters dictionary
            //
            Dictionary <String, String> newMaterialParameters = new Dictionary <String, String>();

            foreach (Node n in graphControl.Nodes)
            {
                if (n.Tag is ShaderParameterNodeTag && n.Items.Count() > 0)
                {
                    // look for a drop down list element -- this will tell us the type
                    ShaderFragmentArchive.Parameter.SourceType type =
                        ShaderFragmentArchive.Parameter.SourceType.System;
                    foreach (var i in n.Items)
                    {
                        if (i is HyperGraph.Items.NodeDropDownItem)
                        {
                            var dropDown   = (HyperGraph.Items.NodeDropDownItem)i;
                            var stringForm = dropDown.Items[dropDown.SelectedIndex];
                            type = ShaderFragmentNodeCreator.AsSourceType(stringForm);
                            break;
                        }
                    }

                    if (type == ShaderFragmentArchive.Parameter.SourceType.Material)
                    {
                        foreach (var i in n.Items)
                        {
                            if (i is ShaderFragmentNodeItem)
                            {
                                ShaderFragmentNodeItem item = (ShaderFragmentNodeItem)i;
                                if (item.Output != null)
                                {
                                    if (!newMaterialParameters.ContainsKey(item.ArchiveName))
                                    {
                                        var param = ShaderFragmentArchive.Archive.GetParameter(item.ArchiveName);
                                        if (param != null)
                                        {
                                            newMaterialParameters.Add(item.ArchiveName, param.Type);
                                        }
                                        else
                                        {
                                            newMaterialParameters.Add(item.ArchiveName, "<<unknown>>");
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }

            bool          didSomething    = false;
            List <String> entriesToRemove = new List <String>();

            foreach (String s in document.PreviewMaterialState.Keys)
            {
                if (!newMaterialParameters.ContainsKey(s))
                {
                    entriesToRemove.Add(s);
                }
            }

            foreach (String s in entriesToRemove)
            {
                document.PreviewMaterialState.Remove(s);      // does this invalidate the iteration?
                didSomething = true;
            }

            foreach (KeyValuePair <String, String> s in newMaterialParameters)
            {
                if (!document.PreviewMaterialState.ContainsKey(s.Key))
                {
                    var           parameter = ShaderFragmentArchive.Archive.GetParameter(s.Key);
                    System.Object def       = null;
                    if (parameter != null && parameter.Default != null && parameter.Default.Length > 0)
                    {
                        def = ShaderPatcherLayer.TypeRules.CreateFromString(parameter.Default, parameter.Type);
                    }

                    var parameterName = s.Key;
                    if (parameter != null)
                    {
                        parameterName = parameter.Name;
                    }

                    if (def != null)
                    {
                        document.PreviewMaterialState.Add(parameterName, def);
                    }
                    else
                    {
                        document.PreviewMaterialState.Add(parameterName, ShaderPatcherLayer.TypeRules.CreateDefaultObject(s.Value));
                    }

                    didSomething = true;
                }
            }

            return(didSomething);
        }
コード例 #4
0
ファイル: ShaderFragmentNodes.cs プロジェクト: ldh9451/XLE
        private static void ParameterNodeTypeChanged(object sender, HyperGraph.Items.AcceptNodeSelectionChangedEventArgs args)
        {
            if (sender is HyperGraph.Items.NodeDropDownItem)
            {
                var item = (HyperGraph.Items.NodeDropDownItem)sender;
                var node = item.Node;

                var newType = AsSourceType(item.Items[args.Index]);

                    //  We might have to change the input/output settings on this node
                bool isOutput = newType == ShaderFragmentArchive.Parameter.SourceType.Output;
                var oldItems = new List<HyperGraph.NodeItem>(node.Items);
                foreach (var i in oldItems)
                {
                    if (i is ShaderFragmentNodeItem)
                    {
                                // if this is a node item with exactly 1 input/output
                                // and it is not in the correct direction, then we have to change it.
                                //  we can't change directly. We need to delete and recreate this node item.
                        var fragItem = (ShaderFragmentNodeItem)i;
                        if (    (fragItem.Output.Enabled ^ fragItem.Input.Enabled) == true &&
                                (fragItem.Output.Enabled) != (isOutput == false))
                        {
                            var newItem = new ShaderFragmentNodeItem(
                                fragItem.Name, fragItem.Type, fragItem.ArchiveName,
                                isOutput ? true : false, isOutput ? false : true);
                            node.RemoveItem(fragItem);
                            node.AddItem(newItem);
                        }
                    }
                }
            }
        }
コード例 #5
0
ファイル: ModelConversion.cs プロジェクト: taknim/XLE
        //
        //      Convert from the "ViewModel" to the "Model"
        //
        //      We don't maintain the ShaderPatcherLayer.NodeGraph representation
        //      permanently... But we need this for serialization and shader
        //      generation operations
        //
        //      So, let's just build it from the graph control object.
        //
        public static ShaderPatcherLayer.NodeGraph ToShaderPatcherLayer(HyperGraph.GraphControl graphControl)
        {
            ShaderPatcherLayer.NodeGraph nodeGraph          = new ShaderPatcherLayer.NodeGraph();
            Dictionary <Node, int>       nodeToVisualNodeId = new Dictionary <Node, int>();

            foreach (Node n in graphControl.Nodes)
            {
                if (n.Tag is ShaderFragmentNodeTag)
                {
                    ShaderFragmentNodeTag   nTag       = (ShaderFragmentNodeTag)n.Tag;
                    ShaderPatcherLayer.Node resultNode = new ShaderPatcherLayer.Node();
                    resultNode.FragmentArchiveName = nTag.ArchiveName;
                    resultNode.NodeId = nTag.Id;

                    if (n.Tag is ShaderParameterNodeTag)
                    {
                        //  This is a hack... But there should be a drop down list that
                        //  can tell us the type of this parameter struct box.
                        foreach (var i in n.Items)
                        {
                            if (i is HyperGraph.Items.NodeDropDownItem)
                            {
                                var dropDown        = (HyperGraph.Items.NodeDropDownItem)i;
                                var stringForm      = dropDown.Items[dropDown.SelectedIndex];
                                var parameterSource = ShaderFragmentNodeCreator.AsSourceType(stringForm);
                                resultNode.NodeType = AsNodeType(parameterSource);
                            }
                        }
                    }
                    else
                    {
                        resultNode.NodeType = ShaderPatcherLayer.Node.Type.Procedure;
                    }

                    {
                        if (nodeToVisualNodeId.ContainsKey(n))
                        {
                            resultNode.VisualNodeId = nodeToVisualNodeId[n];
                        }
                        else
                        {
                            resultNode.VisualNodeId = nodeGraph.VisualNodes.Count();
                            nodeToVisualNodeId.Add(n, resultNode.VisualNodeId);
                            var visualNode = new ShaderPatcherLayer.VisualNode();
                            visualNode.Location = n.Location;
                            if (n.Collapsed)
                            {
                                visualNode.State = ShaderPatcherLayer.VisualNode.StateType.Collapsed;
                            }
                            else
                            {
                                visualNode.State = ShaderPatcherLayer.VisualNode.StateType.Normal;
                            }
                            nodeGraph.VisualNodes.Add(visualNode);
                        }
                    }

                    nodeGraph.Nodes.Add(resultNode);

                    foreach (NodeConnection connection in n.Connections)
                    {
                        if (connection.From == null)
                        {
                            // this is a direct constant connection. It connects the value either to a constant value, or some named variable
                            if (connection.To != null)
                            {
                                Node destination = connection.To.Node;
                                if (destination.Tag is ShaderFragmentNodeTag)
                                {
                                    ShaderFragmentNodeTag dTag = (ShaderFragmentNodeTag)destination.Tag;
                                    ShaderPatcherLayer.NodeConstantConnection resultConnection = new ShaderPatcherLayer.NodeConstantConnection();
                                    resultConnection.Value        = connection.Name;
                                    resultConnection.OutputNodeID = dTag.Id;
                                    if (connection.To.Item is ShaderFragmentNodeItem)
                                    {
                                        ShaderFragmentNodeItem destinationItem = (ShaderFragmentNodeItem)connection.To.Item;
                                        resultConnection.OutputParameterName = destinationItem.Name;
                                    }

                                    nodeGraph.NodeConstantConnections.Add(resultConnection);
                                }
                            }
                        }
                        else if (connection.From.Node == n)
                        {
                            // This is an output to the next node
                            Node destination = connection.To.Node;
                            if (destination.Tag is ShaderFragmentNodeTag)
                            {
                                ShaderFragmentNodeTag             dTag             = (ShaderFragmentNodeTag)destination.Tag;
                                ShaderPatcherLayer.NodeConnection resultConnection = new ShaderPatcherLayer.NodeConnection();
                                resultConnection.InputNodeID  = nTag.Id;
                                resultConnection.OutputNodeID = dTag.Id;
                                if (connection.To.Item is ShaderFragmentNodeItem)
                                {
                                    ShaderFragmentNodeItem destinationItem = (ShaderFragmentNodeItem)connection.To.Item;
                                    resultConnection.OutputParameterName = destinationItem.Name;
                                    resultConnection.OutputType          = TypeFromNodeItem(destinationItem);
                                }
                                if (connection.From.Item is ShaderFragmentNodeItem)
                                {
                                    ShaderFragmentNodeItem sourceItem = (ShaderFragmentNodeItem)connection.From.Item;
                                    resultConnection.InputParameterName = sourceItem.Name;
                                    resultConnection.InputType          = TypeFromNodeItem(sourceItem);
                                }

                                nodeGraph.NodeConnections.Add(resultConnection);
                            }
                        }
                    }
                }
            }

            return(nodeGraph);
        }
コード例 #6
0
ファイル: ModelConversion.cs プロジェクト: ldh9451/XLE
 private static string TypeFromNodeItem(ShaderFragmentNodeItem nodeItem)
 {
     if (nodeItem.ArchiveName != null && nodeItem.ArchiveName.Length != 0)
     {
         return ShaderFragmentArchive.Archive.GetParameter(nodeItem.ArchiveName).Type;
     }
     return nodeItem.Type;
 }