private bool TryGetValueObject(out object result)
{
result = null;
SerializableObjectContainer container = null;
// For Get and Set variable nodes, reach into the actual value of the linked variable
if (_udonNodeData.fullName.Contains("et_Variable"))
{
container = _udonNodeData.nodeValues[1];
}
else
{
container = _udonNodeData.nodeValues[_nodeValueIndex];
}
if (container == null)
{
return(false);
}
result = container.Deserialize();
if (result == null)
{
return(false);
}
return(true);
}
public void CreateNode(UdonNodeDefinition udonNodeDefinition, Vector2?position = null)
{
UdonNodeData nodeData = null;
if (!TrySetupNode(udonNodeDefinition, position, out UdonNode node, ref nodeData))
{
return;
}
PopulateDefaultValues();
LayoutSlots(udonNodeDefinition, node, 0);
ReSerializeData();
AddNode(node);
void PopulateDefaultValues()
{
if (udonNodeDefinition.defaultValues == null)
{
return;
}
nodeData.nodeValues = new SerializableObjectContainer[udonNodeDefinition.defaultValues.Count];
nodeData.nodeUIDs = new string[udonNodeDefinition.defaultValues.Count];
for (int i = 0; i < udonNodeDefinition.defaultValues.Count; i++)
{
object defaultValue = udonNodeDefinition.defaultValues[i];
if (defaultValue != null)
{
nodeData.nodeValues[i] = SerializableObjectContainer.Serialize(defaultValue);
}
}
}
}
private bool TryGetValueObject(out object result, Type type = null)
{
// Initialize out object
result = null;
// get container from node values
SerializableObjectContainer container = _udonNodeData.nodeValues[_nodeValueIndex];
// Null check, failure
if (container == null)
{
return(false);
}
// Deserialize into result, return failure on null
result = container.Deserialize();
// Strings will deserialize as null, that's ok
if (type == null || type == typeof(string))
{
return(true);
}
// any other type is not ok to be null
else if (result == null)
{
return(false);
}
// Success - return true
return(type.IsInstanceOfType(result));
}
public UdonParameterField(UdonGraph udonGraph, UdonNodeData nodeData)
{
this.udonGraph = udonGraph;
this.nodeData = nodeData;
// Get Definition or exit early
UdonNodeDefinition definition = UdonEditorManager.Instance.GetNodeDefinition(nodeData.fullName);
if (definition == null)
{
UnityEngine.Debug.LogWarning($"Couldn't create Parameter Field for {nodeData.fullName}");
return;
}
this.text = (string)nodeData.nodeValues[(int)UdonParameterProperty.ValueIndices.name].Deserialize();
this.typeText = UdonGraphExtensions.PrettyString(definition.name).FriendlyNameify();
this.AddManipulator(new ContextualMenuManipulator(BuildContextualMenu));
this.Q("icon").AddToClassList("parameter-" + definition.type);
this.Q("icon").visible = true;
var textField = (TextField)this.Q("textField");
textField.isDelayed = true;
textField.OnValueChanged((e) => {
UnityEditor.Undo.RecordObject(udonGraph.graphProgramAsset, "Rename Variable");
// Sanitize value for variable name
string newVariableName = e.newValue.SanitizeVariableName();
text = newVariableName;
nodeData.nodeValues[(int)UdonParameterProperty.ValueIndices.name] = SerializableObjectContainer.Serialize(newVariableName);
});
}
private void SetNewValue(object newValue)
{
_udonNodeData.nodeValues[_nodeValueIndex] = SerializableObjectContainer.Serialize(newValue, portType);
if (!_waitToReserialize)
{
SendReserializeEvent();
}
}
private static SerializableObjectContainer[] GetDefaultNodeValues()
{
return(new[]
{
SerializableObjectContainer.Serialize("", typeof(string)),
SerializableObjectContainer.Serialize("newVariableName", typeof(string)),
SerializableObjectContainer.Serialize(false, typeof(bool)),
SerializableObjectContainer.Serialize(false, typeof(bool)),
SerializableObjectContainer.Serialize("none", typeof(string))
});
}
private bool TryGetValueObject(out object result)
{
result = null;
SerializableObjectContainer container = null;
// For Get and Set variable nodes, reach into the actual value of the linked variable
if (_udonNodeData.fullName.Contains("et_Variable"))
{
string targetVariableUid = (string)_udonNodeData.nodeValues[0].Deserialize();
if (targetVariableUid == null)
{
return(false);
}
var data = _udonNodeData.GetGraph().FindNode(targetVariableUid);
if (data == null)
{
return(false);
}
container = data.nodeValues[0];
}
else
{
container = _udonNodeData.nodeValues[_nodeValueIndex];
}
if (container == null)
{
return(false);
}
result = container.Deserialize();
if (result == null)
{
return(false);
}
return(true);
}
private bool TryGetValueObject(out object result)
{
// Initialize out object
result = null;
// get container from node values
SerializableObjectContainer container = _udonNodeData.nodeValues[_nodeValueIndex];
// Null check, failure
if (container == null)
{
return(false);
}
// Deserialize into result, return failure on null
result = container.Deserialize();
if (result == null)
{
return(false);
}
// Success - return true
return(true);
}
public UdonNode CreateNode(UdonNodeData nodeData)
{
UdonNodeDefinition udonNodeDefinition;
try
{
udonNodeDefinition = UdonEditorManager.Instance.GetNodeDefinition(nodeData.fullName);
}
catch
{
Debug.LogError($"Skipping missing node: {nodeData.fullName}");
return(null);
}
if (!TrySetupNode(udonNodeDefinition, nodeData.position, out UdonNode node, ref nodeData))
{
return(null);
}
int connectedFlowCount = nodeData.flowUIDs.Count(f => !string.IsNullOrEmpty(f));
ValidateNodeData();
LayoutSlots(udonNodeDefinition, node, connectedFlowCount);
AddNode(node);
return(node);
void ValidateNodeData()
{
bool modifiedData = false;
for (int i = 0; i < nodeData.nodeValues.Length; i++)
{
if (udonNodeDefinition.Inputs.Count <= i)
{
continue;
}
Type expectedType = udonNodeDefinition.Inputs[i].type;
if (nodeData.nodeValues[i] == null)
{
continue;
}
object value = nodeData.nodeValues[i].Deserialize();
if (value == null)
{
continue;
}
if (!expectedType.IsInstanceOfType(value))
{
nodeData.nodeValues[i] = SerializableObjectContainer.Serialize(null, expectedType);
modifiedData = true;
}
}
if (modifiedData)
{
ReSerializeData();
}
}
}
private void SetNewValue(object newValue, ValueIndices index)
{
nodeData.nodeValues[(int)index] = SerializableObjectContainer.Serialize(newValue);
graph.ReSerializeData();
graph.SaveGraphToDisk();
}
private void SetNewValue(object newValue)
{
_udonNodeData.nodeValues[_nodeValueIndex] = SerializableObjectContainer.Serialize(newValue, portType);
}
private void SetNewValue(object newValue, ValueIndices index)
{
nodeData.nodeValues[(int)index] = SerializableObjectContainer.Serialize(newValue);
}
public void CreateNode(UdonNodeDefinition udonNodeDefinition, Vector2?position = null)
{
//Awful hack to fix regression in unity graph property type conversion
{
var prop = typeof(TypeConverter).GetField(
"useCompatibleTypeConversion",
System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Static
);
prop.SetValue(this, true);
}
UdonNode node = CreateInstance <UdonNode>();
node.name = udonNodeDefinition.fullName;
node.title = PrettyString(udonNodeDefinition.name).FriendlyNameify();
node.position = position == null ? new Rect(Vector2.zero, Vector2.zero) : new Rect(position.Value, Vector2.zero);
if (node.name.StartsWith("Event_") && node.name != "Event_Custom")
{
if (nodes.Any(n => n.name == node.name))
{
Debug.LogWarning($"Can't create more than one {node.name} node, try managing your flow with a Block node instead!");
return;
}
}
if (node.title == "Const_VRCUdonCommonInterfacesIUdonEventReceiver")
{
node.title = "UdonBehaviour";
}
UdonNodeData nodeData = data.AddNode(udonNodeDefinition.fullName);
if (udonNodeDefinition.flow)
{
if (!udonNodeDefinition.fullName.StartsWith("Event_"))
{
node.AddInputSlot("");
}
node.AddOutputSlot("");
if (_specialFlows.Contains(udonNodeDefinition.fullName))
{
node.AddOutputSlot("");
}
}
foreach (Type input in udonNodeDefinition.inputs)
{
node.AddInputSlot(FriendlyTypeName(input), SlotTypeConverter(input, udonNodeDefinition.fullName));
}
foreach (Type output in udonNodeDefinition.outputs)
{
node.AddOutputSlot(FriendlyTypeName(output), SlotTypeConverter(output, udonNodeDefinition.fullName));
}
if (udonNodeDefinition.defaultValues != null)
{
nodeData.nodeValues = new SerializableObjectContainer[udonNodeDefinition.defaultValues.Length];
nodeData.nodeUIDs = new string[udonNodeDefinition.defaultValues.Length];
for (int i = 0; i < udonNodeDefinition.defaultValues.Length; i++)
{
object defaultValue = udonNodeDefinition.defaultValues[i];
if (defaultValue != null)
{
nodeData.nodeValues[i] = SerializableObjectContainer.Serialize(defaultValue);
}
}
}
node.uid = nodeData.uid;
ReSerializeData();
AddNode(node);
}
public UdonNode CreateNode(UdonNodeData nodeData)
{
//Awful hack to fix regression in unity graph property type conversion
{
var prop = typeof(TypeConverter).GetField(
"useCompatibleTypeConversion",
System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Static
);
prop.SetValue(this, true);
}
UdonNodeDefinition udonNodeDefinition = null;
try
{
udonNodeDefinition = UdonEditorManager.Instance.GetNodeDefinition(nodeData.fullName);
}
catch
{
Debug.LogError($"Skipping missing node: {nodeData.fullName}");
return(null);
}
UdonNode node = CreateInstance <UdonNode>();
node.name = udonNodeDefinition.fullName;
node.title = PrettyString(udonNodeDefinition.name).FriendlyNameify();
if (node.name.StartsWith("Event_") && node.name != "Event_Custom")
{
if (nodes.Any(n => n.name == node.name))
{
Debug.LogWarning($"Can't create more than one {node.name} node, try managing your flow with a Block node instead!");
return(null);
}
}
if (node.title == "Const_VRCUdonCommonInterfacesIUdonEventReceiver")
{
node.title = "UdonBehaviour";
}
node.uid = nodeData.uid;
node.position = new Rect(nodeData.position, Vector2.zero);
if (udonNodeDefinition.flow)
{
if (!udonNodeDefinition.fullName.StartsWith("Event_"))
{
node.AddInputSlot("");
}
node.AddOutputSlot("");
if (_specialFlows.Contains(udonNodeDefinition.fullName))
{
node.AddOutputSlot("");
}
if (udonNodeDefinition.fullName == "Block")
{
int connectedFlows = nodeData.flowUIDs.Count(f => !string.IsNullOrEmpty(f));
if (connectedFlows > 1)
{
for (int i = 0; i < connectedFlows - 1; i++)
{
node.AddOutputSlot("");
}
}
}
}
if (udonNodeDefinition.fullName == "SubGraph")
{
if (nodeData.nodeValues.Length > 0 && nodeData.nodeValues[0] != null)
{
IUdonGraphDataProvider graphDataProvider = (IUdonGraphDataProvider)nodeData.nodeValues[0].Deserialize();
if (graphDataProvider != null)
{
UdonGraphData subGraphData = graphDataProvider.GetGraphData();
bool doExit = false;
foreach (UdonNodeData eventNode in subGraphData.EventNodes)
{
if (eventNode.fullName != "Event_Custom")
{
continue;
}
string customEventName = "customEvent";
if (eventNode.nodeValues.Length > 0 && eventNode.nodeValues[0] != null)
{
string eventName = (string)eventNode.nodeValues[0].Deserialize();
if (!string.IsNullOrEmpty(eventName))
{
customEventName = eventName;
}
}
node.AddInputSlot(customEventName);
doExit = true;
break; //TODO: support more than one custom event in a subgraph
}
if (doExit)
{
node.AddOutputSlot("Exit");
}
}
}
}
// Data Validation //
bool modifiedData = false;
for (int i = 0; i < nodeData.nodeValues.Length; i++)
{
if (udonNodeDefinition.inputs.Length <= i)
{
continue;
}
Type expectedType = udonNodeDefinition.inputs[i];
if (nodeData.nodeValues[i] == null)
{
continue;
}
object value = nodeData.nodeValues[i].Deserialize();
if (value == null)
{
continue;
}
if (!expectedType.IsInstanceOfType(value))
{
nodeData.nodeValues[i] = SerializableObjectContainer.Serialize(null, expectedType);
modifiedData = true;
}
}
if (modifiedData)
{
ReSerializeData();
}
////////////////////
foreach (Type input in udonNodeDefinition.inputs)
{
node.AddInputSlot(FriendlyTypeName(input), SlotTypeConverter(input, udonNodeDefinition.fullName));
}
foreach (Type output in udonNodeDefinition.outputs)
{
node.AddOutputSlot(FriendlyTypeName(output), SlotTypeConverter(output, udonNodeDefinition.fullName));
}
AddNode(node);
return(node);
}
