void CopyValueToParameter(VFXParameter parameter)
{
var value = controller.model.value;
object convertedValue = null;
if (VFXConverter.TryConvertTo(value, parameter.type, out convertedValue))
{
parameter.value = convertedValue;
}
}
void BuildValue(VFXSlot slot)
{
foreach (var field in slot.property.type.GetFields())
{
VFXSlot subSlot = slot.children.FirstOrDefault <VFXSlot>(t => t.name == field.Name);
if (subSlot != null)
{
object result = null;
if (subSlot.HasLink(true) && m_Controller.viewController.CanGetEvaluatedContent(subSlot) && (result = m_Controller.viewController.GetEvaluatedContent(subSlot)) != null)
{
m_ValueBuilder.Add(o => o.Add(m_Controller.viewController.GetEvaluatedContent(subSlot)));
}
else if (subSlot.HasLink(false) && VFXTypeUtility.GetComponentCount(subSlot) != 0) // replace by is VFXType
{
m_Indeterminate = true;
return;
}
else
{
m_ValueBuilder.Add(o => o.Add(subSlot.value));
BuildValue(subSlot);
if (m_Indeterminate)
{
return;
}
}
m_ValueBuilder.Add(o =>
{
var newValue = o[o.Count - 1];
var target = o[o.Count - 2];
if (newValue != null && field.FieldType != newValue.GetType())
{
object convertedValue;
if (!VFXConverter.TryConvertTo(newValue, field.FieldType, out convertedValue))
{
throw new InvalidOperationException(string.Format("VFXDataAnchorGizmo is failing to convert from {0} to {1}", newValue.GetType(), field.FieldType));
}
newValue = convertedValue;
}
field.SetValue(target, newValue);
});
m_ValueBuilder.Add(o => o.RemoveAt(o.Count - 1));
}
}
}
public void MatrixToTransformTest()
{
Matrix4x4 value = Matrix4x4.TRS(new Vector3(1, 2, 3), Quaternion.Euler(10, 20, 30), new Vector3(4, 5, 6));
Transform transform = VFXConverter.ConvertTo <Transform>(value);
float epsilon = 0.00001f;
Assert.AreEqual(transform.position.x, 1, epsilon);
Assert.AreEqual(transform.position.y, 2, epsilon);
Assert.AreEqual(transform.position.z, 3, epsilon);
Assert.AreEqual(transform.angles.x, 10, epsilon);
Assert.AreEqual(transform.angles.y, 20, epsilon);
Assert.AreEqual(transform.angles.z, 30, epsilon);
Assert.AreEqual(transform.scale.x, 4, epsilon);
Assert.AreEqual(transform.scale.y, 5, epsilon);
Assert.AreEqual(transform.scale.z, 6, epsilon);
}
void ConvertContext(VFXNodeProvider.Descriptor d, Vector2 mPos)
{
VFXView view = GetFirstAncestorOfType <VFXView>();
VFXViewController viewController = controller.viewController;
if (view == null)
{
return;
}
mPos = view.contentViewContainer.ChangeCoordinatesTo(view, controller.position);
var newNodeController = view.AddNode(d, mPos);
var newContextController = newNodeController as VFXContextController;
//transfer blocks
foreach (var block in controller.model.children.ToArray()) // To array needed as the IEnumerable content will change
{
newContextController.AddBlock(-1, block);
}
//transfer settings
var contextType = controller.model.GetType();
foreach (var setting in newContextController.model.GetSettings(true))
{
if (newContextController.model is VFXPlanarPrimitiveOutput && setting.field.Name == "primitiveType")
{
continue;
}
if (!setting.valid || setting.field.GetCustomAttributes(typeof(VFXSettingAttribute), true).Length == 0)
{
continue;
}
object value;
if (VFXConverter.TryConvertTo(setting.value, setting.field.FieldType, out value))
{
newContextController.model.SetSettingValue(setting.field.Name, value);
}
}
//transfer flow edges
if (controller.flowInputAnchors.Count == 1)
{
foreach (var output in controller.flowInputAnchors[0].connections.Select(t => t.output).ToArray())
{
newContextController.model.LinkFrom(output.context.model, output.slotIndex);
}
}
// Apply the slot changes that can be the result of settings changes
newContextController.ApplyChanges();
VFXSlot firstTextureSlot = null;
//transfer master slot values
foreach (var slot in newContextController.model.inputSlots)
{
VFXSlot mySlot = controller.model.inputSlots.FirstOrDefault(t => t.name == slot.name);
if (mySlot == null)
{
if (slot.valueType == VFXValueType.Texture2D && firstTextureSlot == null)
{
firstTextureSlot = slot;
}
continue;
}
object value;
if (VFXConverter.TryConvertTo(mySlot.value, slot.property.type, out value))
{
slot.value = value;
}
}
//Hack to copy the first texture in the first texture slot if not found by name
if (firstTextureSlot != null)
{
VFXSlot mySlot = controller.model.inputSlots.FirstOrDefault(t => t.valueType == VFXValueType.Texture2D);
if (mySlot != null)
{
firstTextureSlot.value = mySlot.value;
}
}
foreach (var anchor in newContextController.inputPorts)
{
string path = anchor.path;
var myAnchor = controller.inputPorts.FirstOrDefault(t => t.path == path);
if (myAnchor == null || !myAnchor.HasLink())
{
continue;
}
//There should be only one
var output = myAnchor.connections.First().output;
viewController.CreateLink(anchor, output);
}
// Apply the change so that it won't unlink the blocks links
controller.ApplyChanges();
viewController.RemoveElement(controller);
}
void AddLinkedNode(VFXNodeProvider.Descriptor d, Vector2 mPos)
{
var mySlot = controller.model;
VFXView view = GetFirstAncestorOfType <VFXView>();
VFXViewController viewController = controller.viewController;
if (view == null)
{
return;
}
var newNodeController = view.AddNode(d, mPos);
if (newNodeController == null)
{
return;
}
IEnumerable <Type> validTypes = null;
var op = controller.sourceNode.model as VFXOperatorNumericCascadedUnified;
if (mySlot == null && op != null)
{
validTypes = op.validTypes;
}
// If linking to a new parameter, copy the slot value and space
if (direction == Direction.Input && controller.model != null) //model will be null for upcomming which won't have a value
{
if (newNodeController is VFXOperatorController)
{
var inlineOperator = (newNodeController as VFXOperatorController).model as VFXInlineOperator;
if (inlineOperator != null)
{
var value = controller.model.value;
object convertedValue = null;
if (VFXConverter.TryConvertTo(value, inlineOperator.type, out convertedValue))
{
inlineOperator.inputSlots[0].value = convertedValue;
}
if (inlineOperator.inputSlots[0].spaceable && controller.model.spaceable)
{
inlineOperator.inputSlots[0].space = controller.model.space;
}
}
}
}
var ports = direction == Direction.Input ? newNodeController.outputPorts : newNodeController.inputPorts;
int count = ports.Count();
for (int i = 0; i < count; ++i)
{
var port = ports[i];
if (mySlot != null)
{
if (viewController.CreateLink(direction == Direction.Input ? controller : port, direction == Direction.Input ? port : controller))
{
AlignNodeToLinkedPort(view, port, newNodeController);
break;
}
}
else if (validTypes != null)
{
if (validTypes.Contains(port.model.property.type))
{
if (viewController.CreateLink(controller, port))
{
break;
}
}
}
}
}
DropdownMenuAction.Status OnValidatePasteValue(DropdownMenuAction a)
{
return(s_Clipboard != null && controller.editable && VFXConverter.CanConvertTo(s_Clipboard.GetType(), portType) ? DropdownMenuAction.Status.Normal : DropdownMenuAction.Status.Disabled);
}
void OnPasteValue(DropdownMenuAction a)
{
controller.value = VFXConverter.ConvertTo(s_Clipboard, portType);
}
void ConvertContext(VFXNodeProvider.Descriptor d, Vector2 mPos)
{
VFXView view = GetFirstAncestorOfType <VFXView>();
VFXViewController viewController = controller.viewController;
if (view == null)
{
return;
}
mPos = view.contentViewContainer.ChangeCoordinatesTo(view, controller.position);
var newNodeController = view.AddNode(d, mPos);
var newContextController = newNodeController as VFXContextController;
//transfer blocks
foreach (var block in controller.model.children.ToArray()) // To array needed as the IEnumerable content will change
{
newContextController.AddBlock(-1, block);
}
//transfer settings
var contextType = controller.model.GetType();
foreach (var setting in newContextController.model.GetSettings(true))
{
FieldInfo myField = contextType.GetField(setting.Name, BindingFlags.Instance | BindingFlags.FlattenHierarchy | BindingFlags.Public | BindingFlags.NonPublic);
if (myField == null || myField.GetCustomAttributes(typeof(VFXSettingAttribute), true).Length == 0)
{
continue;
}
object value;
if (VFXConverter.TryConvertTo(myField.GetValue(controller.model), setting.FieldType, out value))
{
newContextController.model.SetSettingValue(setting.Name, value);
}
}
//transfer flow edges
if (controller.flowInputAnchors.Count == 1)
{
foreach (var output in controller.flowInputAnchors[0].connections.Select(t => t.output).ToArray())
{
newContextController.model.LinkFrom(output.context.model, output.slotIndex);
}
}
// Apply the slot changes that can be the result of settings changes
newContextController.ApplyChanges();
//transfer master slot values
foreach (var slot in newContextController.model.inputSlots)
{
VFXSlot mySlot = controller.model.inputSlots.FirstOrDefault(t => t.name == slot.name);
if (mySlot == null)
{
continue;
}
object value;
if (VFXConverter.TryConvertTo(mySlot.value, slot.property.type, out value))
{
slot.value = value;
}
}
foreach (var anchor in newContextController.inputPorts)
{
string path = anchor.path;
var myAnchor = controller.inputPorts.FirstOrDefault(t => t.path == path);
if (myAnchor == null || !myAnchor.HasLink())
{
continue;
}
//There should be only one
var output = myAnchor.connections.First().output;
viewController.CreateLink(anchor, output);
}
// Apply the change so that it won't unlink the blocks links
controller.ApplyChanges();
viewController.RemoveElement(controller);
}
public void FailingConvertTest([ValueSource("failingConversions")] Conversion conversion)
{
LogAssert.Expect(LogType.Error, string.Format("Cannot cast from {0} to {1}", conversion.value.GetType(), conversion.targetType));
Assert.IsNull(VFXConverter.ConvertTo(conversion.value, conversion.targetType));
}
public void SimpleConvertTest([ValueSource("conversions")] Conversion conversion)
{
Assert.AreEqual(conversion.expectedResult, VFXConverter.ConvertTo(conversion.value, conversion.targetType));
}
