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); } } } } }
private static string TypeFromNodeItem(ShaderFragmentNodeItem nodeItem) { if (nodeItem.ArchiveName != null && nodeItem.ArchiveName.Length != 0) { return(ShaderFragmentArchive.Archive.GetParameter(nodeItem.ArchiveName).Type); } return(nodeItem.Type); }
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); }
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); } } } } }
// // 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); }
private static string TypeFromNodeItem(ShaderFragmentNodeItem nodeItem) { if (nodeItem.ArchiveName != null && nodeItem.ArchiveName.Length != 0) { return ShaderFragmentArchive.Archive.GetParameter(nodeItem.ArchiveName).Type; } return nodeItem.Type; }