public void CleanUp()
{
foreach (var gameObject in m_gameObjectToDelete)
{
try
{
UnityEngine.Object.DestroyImmediate(gameObject, true);
}
catch (System.Exception)
{
}
}
foreach (var assetPath in m_assetToDelete)
{
try
{
AssetDatabase.DeleteAsset(assetPath);
}
catch (System.Exception)
{
}
}
VFXTestCommon.DeleteAllTemporaryGraph();
}
public IEnumerator Sanitize_Shape_To_TShape_And_Check_VFXParameter_State()
{
var kSourceAsset = "Assets/AllTests/Editor/Tests/VFXSanitizeTShape.vfx_";
var graph = VFXTestCommon.CopyTemporaryGraph(kSourceAsset);
yield return(null);
Assert.AreEqual(8, graph.children.OfType <VFXParameter>().Count());
Assert.AreEqual(11, graph.children.OfType <VFXParameter>().SelectMany(o => o.nodes).Count());
Assert.AreEqual(0, graph.children.OfType <VFXParameter>().SelectMany(o => o.nodes).Where(o => o.position == Vector2.zero).Count());
Assert.AreEqual(0, graph.children.OfType <VFXParameter>().SelectMany(o => o.nodes).Where(o => !o.linkedSlots.Any()).Count());
yield return(null);
var window = VFXViewWindow.GetWindow <VFXViewWindow>();
var resource = graph.GetResource();
window.LoadAsset(resource.asset, null);
yield return(null);
Assert.AreEqual(8, graph.children.OfType <VFXParameter>().Count());
Assert.AreEqual(11, graph.children.OfType <VFXParameter>().SelectMany(o => o.nodes).Count());
Assert.AreEqual(0, graph.children.OfType <VFXParameter>().SelectMany(o => o.nodes).Where(o => o.position == Vector2.zero).Count(), "Fail after window.LoadAsset");
foreach (var param in graph.children.OfType <VFXParameter>())
{
var nodes = param.nodes.Where(o => !o.linkedSlots.Any());
if (nodes.Any())
{
Assert.Fail(param.exposedName + " as an orphan node");
}
}
Assert.AreEqual(0, graph.children.OfType <VFXParameter>().SelectMany(o => o.nodes).Where(o => !o.linkedSlots.Any()).Count()); //Orphan link
}
public void DestroyTestAssets()
{
var window = EditorWindow.GetWindow <VFXViewWindow>();
window.Close();
VFXTestCommon.DeleteAllTemporaryGraph();
}
public void UniqueDefaultSystemNames()
{
VFXViewWindow window = EditorWindow.GetWindow <VFXViewWindow>();
VFXView view = window.graphView;
view.controller = m_ViewController;
const int count = 16;
var spawners = VFXTestCommon.CreateSpawners(view, m_ViewController, count);
var systemNames = view.controller.graph.systemNames;
var names = new List <string>();
foreach (var system in spawners)
{
names.Add(systemNames.GetUniqueSystemName(system));
}
Assert.IsTrue(names.Where(name => !string.IsNullOrEmpty(name)).Distinct().Count() == count, "Some spawners have the same name or are null or empty.");
var GPUSystems = VFXTestCommon.GetFieldValue <VFXView, List <VFXSystemBorder> >(view, "m_Systems");
VFXTestCommon.CreateSystems(view, m_ViewController, count, count);
var uniqueSystemNames = GPUSystems.Select(system => system.controller.title).Distinct();
Assert.IsTrue(uniqueSystemNames.Count() == count, "Some GPU systems have the same name or are null or empty.");
}
public void GraphUsingGPUConstant()
{
var graph = VFXTestCommon.MakeTemporaryGraph();
var updateContext = ScriptableObject.CreateInstance <VFXBasicUpdate>();
var blockSetVelocity = ScriptableObject.CreateInstance <SetAttribute>();
blockSetVelocity.SetSettingValue("attribute", "velocity");
var attributeParameter = ScriptableObject.CreateInstance <VFXAttributeParameter>();
attributeParameter.SetSettingValue("attribute", "color");
var add = ScriptableObject.CreateInstance <Operator.Add>();
var length = ScriptableObject.CreateInstance <Operator.Length>();
var float4 = VFXLibrary.GetParameters().First(o => o.name == "Vector4").CreateInstance();
graph.AddChild(updateContext);
updateContext.AddChild(blockSetVelocity);
graph.AddChild(attributeParameter);
graph.AddChild(add);
graph.AddChild(float4);
graph.AddChild(length);
graph.RecompileIfNeeded();
attributeParameter.outputSlots[0].Link(blockSetVelocity.inputSlots[0]);
graph.RecompileIfNeeded();
attributeParameter.outputSlots[0].Link(add.inputSlots[0]);
float4.outputSlots[0].Link(add.inputSlots[1]);
add.outputSlots[0].Link(length.inputSlots[0]);
length.outputSlots[0].Link(blockSetVelocity.inputSlots[0]);
graph.RecompileIfNeeded();
}
public IEnumerator Save_Then_Modify_Something_Check_The_Content_Isnt_Reverted()
{
string path = null;
uint baseValue = 100;
var graph = VFXTestCommon.MakeTemporaryGraph();
{
path = AssetDatabase.GetAssetPath(graph);
var unsigned = ScriptableObject.CreateInstance <VFXInlineOperator>();
unsigned.SetSettingValue("m_Type", (SerializableType)typeof(uint));
unsigned.inputSlots[0].value = baseValue;
graph.AddChild(unsigned);
AssetDatabase.ImportAsset(path);
}
yield return(null);
for (uint i = 0; i < 3; ++i)
{
var inlineOperator = graph.children.OfType <VFXInlineOperator>().FirstOrDefault();
Assert.IsNotNull(inlineOperator);
Assert.AreEqual(baseValue + i, (uint)inlineOperator.inputSlots[0].value, "Failing at iteration : " + i);
graph.GetResource().WriteAsset();
inlineOperator.inputSlots[0].value = baseValue + i + 1; //Update for next iteration
Assert.AreEqual(baseValue + i + 1, (uint)inlineOperator.inputSlots[0].value);
AssetDatabase.ImportAsset(path);
yield return(null);
}
}
public IEnumerable Verify_Orphan_Dependencies_Are_Correctly_Cleared()
{
string path = null;
{
var graph = VFXTestCommon.MakeTemporaryGraph();
path = AssetDatabase.GetAssetPath(graph);
var spawnerContext = ScriptableObject.CreateInstance <VFXBasicSpawner>();
var blockConstantRate = ScriptableObject.CreateInstance <VFXSpawnerConstantRate>();
var slotCount = blockConstantRate.GetInputSlot(0);
var basicInitialize = ScriptableObject.CreateInstance <VFXBasicInitialize>();
var quadOutput = ScriptableObject.CreateInstance <VFXPlanarPrimitiveOutput>();
quadOutput.SetSettingValue("blendMode", VFXAbstractParticleOutput.BlendMode.Additive);
var setPosition = ScriptableObject.CreateInstance <Block.SetAttribute>();
setPosition.SetSettingValue("attribute", "position");
setPosition.inputSlots[0].value = VFX.Position.defaultValue;
basicInitialize.AddChild(setPosition);
slotCount.value = 1.0f;
spawnerContext.AddChild(blockConstantRate);
graph.AddChild(spawnerContext);
graph.AddChild(basicInitialize);
graph.AddChild(quadOutput);
basicInitialize.LinkFrom(spawnerContext);
quadOutput.LinkFrom(basicInitialize);
}
var recordedSize = new List <long>();
for (uint i = 0; i < 16; ++i)
{
AssetDatabase.ImportAsset(path);
var asset = AssetDatabase.LoadAssetAtPath <VisualEffectAsset>(path);
var graph = asset.GetResource().GetOrCreateGraph();
graph.GetResource().WriteAsset();
recordedSize.Add(new FileInfo(path).Length);
var quadOutput = graph.children.OfType <VFXPlanarPrimitiveOutput>().FirstOrDefault();
quadOutput.UnlinkAll();
graph.RemoveChild(quadOutput);
var newQuadOutput = ScriptableObject.CreateInstance <VFXPlanarPrimitiveOutput>();
newQuadOutput.SetSettingValue("blendMode", VFXAbstractParticleOutput.BlendMode.Additive);
graph.AddChild(newQuadOutput);
var basicInitialize = graph.children.OfType <VFXBasicInitialize>().FirstOrDefault();
newQuadOutput.LinkFrom(basicInitialize);
}
Assert.AreEqual(1, recordedSize.GroupBy(o => o).Count());
Assert.AreNotEqual(0u, recordedSize[0]);
yield return(null);
}
public void CleanUp()
{
File.WriteAllText(s_Modify_SG_Property_VFX, m_Modify_SG_Property_VFX);
File.WriteAllText(s_Modify_SG_Property_SG_A, m_Modify_SG_Property_SG_A);
File.WriteAllText(s_Modify_SG_Property_SG_B, m_Modify_SG_Property_SG_B);
VFXTestCommon.DeleteAllTemporaryGraph();
}
public IEnumerator CreatePrefab_And_Disable_Root_Then_Modify_Exposed_Finally_Renable_Root()
{
//Cover case 1230230 : VFX parameters are not set when the gameobject is immediately deactivated and is not selected in the Hierarchy
var graph = VFXTestCommon.MakeTemporaryGraph();
var parametersUintDesc = VFXLibrary.GetParameters().Where(o => o.model.type == typeof(uint)).First();
var parameter = parametersUintDesc.CreateInstance();
parameter.SetSettingValue("m_ExposedName", m_Exposed_name_CreatePrefab_And_Disable_Root_Then_Modify_Exposed_Finally_Renable);
parameter.SetSettingValue("m_Exposed", true);
parameter.value = 123u;
graph.AddChild(parameter);
AssetDatabase.ImportAsset(AssetDatabase.GetAssetPath(graph));
var mainObject = new GameObject("CreatePrefab_And_Disable_Root_Then_Modify_Exposed_Finally_Renable", typeof(VisualEffect));
mainObject.GetComponent <VisualEffect>().visualEffectAsset = graph.visualEffectResource.asset;
GameObject newGameObject, prefabInstanceObject;
MakeTemporaryPrebab(mainObject, out newGameObject, out prefabInstanceObject);
GameObject.DestroyImmediate(mainObject);
m_Prefab_CreatePrefab_And_Disable_Root_Then_Modify_Exposed_Finally_Renable = prefabInstanceObject;
yield return(new EnterPlayMode());
var exposedExpectedValue = 43000u;
var exposedName = m_Exposed_name_CreatePrefab_And_Disable_Root_Then_Modify_Exposed_Finally_Renable;
var r = GameObject.Instantiate(m_Prefab_CreatePrefab_And_Disable_Root_Then_Modify_Exposed_Finally_Renable, Vector3.zero, Quaternion.identity);
var vfx = r.GetComponent <VisualEffect>();
Assert.IsTrue(vfx.HasUInt(exposedName));
Assert.AreNotEqual(exposedExpectedValue, vfx.GetUInt(exposedName));
vfx.SetUInt(exposedName, exposedExpectedValue);
r.SetActive(false);
for (int i = 0; i < 4; ++i)
{
yield return(null);
}
Assert.AreEqual(exposedExpectedValue, vfx.GetUInt(exposedName));
r.SetActive(true);
Assert.AreEqual(exposedExpectedValue, vfx.GetUInt(exposedName));
for (int i = 0; i < 4; ++i)
{
yield return(null);
}
Assert.AreEqual(exposedExpectedValue, vfx.GetUInt(exposedName));
yield return(new ExitPlayMode());
m_Prefab_CreatePrefab_And_Disable_Root_Then_Modify_Exposed_Finally_Renable = null;
}
public void CleanUp()
{
UnityEngine.VFX.VFXManager.fixedTimeStep = m_previousFixedTimeStep;
UnityEngine.VFX.VFXManager.maxDeltaTime = m_previousMaxDeltaTime;
VFXTestCommon.DeleteAllTemporaryGraph();
UnityEngine.Object.DestroyImmediate(m_gameObject);
UnityEngine.Object.DestroyImmediate(m_camera);
}
public IEnumerator Create_Prefab_And_Verify_Empty_Override()
{
var graph = VFXTestCommon.MakeTemporaryGraph();
const int systemCount = 3;
for (int i = 0; i < systemCount; ++i)
{
Add_Valid_System(graph);
}
AssetDatabase.ImportAsset(AssetDatabase.GetAssetPath(graph));
var mainObject = MakeTemporaryGameObject();
GameObject prefabInstanceObject;
{
var tempVFX = mainObject.AddComponent <VisualEffect>();
tempVFX.visualEffectAsset = graph.visualEffectResource.asset;
GameObject newGameObject;
MakeTemporaryPrebab(mainObject, out newGameObject, out prefabInstanceObject);
GameObject.DestroyImmediate(mainObject);
mainObject = PrefabUtility.InstantiatePrefab(prefabInstanceObject) as GameObject;
}
yield return(null);
Assert.IsNotNull(mainObject.GetComponent <VisualEffect>());
var properties = PrefabUtility.GetPropertyModifications(mainObject);
//Filter out transform properties & GameObject.m_Name
properties = properties.Where(o =>
{
if (o.target is UnityEngine.Transform)
{
return(false);
}
if (o.target is GameObject && o.propertyPath == "m_Name")
{
return(false);
}
return(true);
}).ToArray();
var logMessage = string.Empty;
if (properties.Any())
{
logMessage = properties.Select(o => string.Format("{0} at {1} : {2}", o.target, o.propertyPath, o.value))
.Aggregate((a, b) => a + "\n" + b);
}
Assert.AreEqual(0, properties.Length, logMessage);
}
public IEnumerator Create_Asset_And_Component_Check_Overflow_MaxDeltaTime([ValueSource("updateModes")] object updateMode)
{
var graph = VFXTestCommon.MakeTemporaryGraph();
graph.visualEffectResource.updateMode = (VFXUpdateMode)updateMode;
var spawnerContext = ScriptableObject.CreateInstance <VFXBasicSpawner>();
var constantRate = ScriptableObject.CreateInstance <VFXSpawnerConstantRate>();
var initContext = ScriptableObject.CreateInstance <VFXBasicInitialize>();
var outputContext = ScriptableObject.CreateInstance <VFXPointOutput>();
graph.AddChild(initContext);
graph.AddChild(outputContext);
spawnerContext.LinkTo(initContext);
initContext.LinkTo(outputContext);
spawnerContext.AddChild(constantRate);
graph.AddChild(spawnerContext);
AssetDatabase.ImportAsset(AssetDatabase.GetAssetPath(graph));
var vfxComponent = m_gameObject.AddComponent <VisualEffect>();
vfxComponent.visualEffectAsset = graph.visualEffectResource.asset;
float fixedTimeStep = 1.0f / 20.0f;
float maxTimeStep = 1.0f / 10.0f;
UnityEngine.VFX.VFXManager.fixedTimeStep = fixedTimeStep;
UnityEngine.VFX.VFXManager.maxDeltaTime = maxTimeStep;
/* waiting for culling (simulating big delay between each frame) */
int maxFrame = 512;
VFXSpawnerState spawnerState = VisualEffectUtility.GetSpawnerState(vfxComponent, 0u);
float sleepTimeInSeconds = maxTimeStep * 5.0f;
while (--maxFrame > 0 && spawnerState.deltaTime != maxTimeStep)
{
System.Threading.Thread.Sleep((int)(sleepTimeInSeconds * 1000.0f));
yield return(null);
spawnerState = VisualEffectUtility.GetSpawnerState(vfxComponent, 0u);
}
Assert.IsTrue(maxFrame > 0);
if (graph.visualEffectResource.updateMode == VFXUpdateMode.FixedDeltaTime)
{
Assert.AreEqual(maxTimeStep, spawnerState.deltaTime);
}
else
{
Assert.AreEqual(maxTimeStep, spawnerState.deltaTime); //< There is clamp even in delta time mode
//Assert.AreEqual((double)sleepTimeInSeconds, spawnerState.deltaTime, 0.01f);
}
yield return(null);
}
private static VFXViewController StartEditTestAsset()
{
var window = EditorWindow.GetWindow <VFXViewWindow>();
window.Show();
var graph = VFXTestCommon.MakeTemporaryGraph();
var viewController = VFXViewController.GetController(graph.GetResource(), true);
window.graphView.controller = viewController;
return(viewController);
}
public IEnumerator Create_Asset_And_Component_Check_Expected_TotalTime()
{
yield return(new EnterPlayMode());
var graph = VFXTestCommon.MakeTemporaryGraph();
var spawnerContext = ScriptableObject.CreateInstance <VFXBasicSpawner>();
var constantRate = ScriptableObject.CreateInstance <VFXSpawnerConstantRate>();
// Attach to a valid particle system so that spawner is compiled
var initContext = ScriptableObject.CreateInstance <VFXBasicInitialize>();
var outputContext = ScriptableObject.CreateInstance <VFXPointOutput>();
graph.AddChild(initContext);
graph.AddChild(outputContext);
spawnerContext.LinkTo(initContext);
initContext.LinkTo(outputContext);
var slotRate = constantRate.GetInputSlot(0);
var totalTime = GetTotalTimeOperator().CreateInstance();
slotRate.Link(totalTime.GetOutputSlot(0));
spawnerContext.AddChild(constantRate);
graph.AddChild(spawnerContext);
AssetDatabase.ImportAsset(AssetDatabase.GetAssetPath(graph));
var expressionIndex = graph.FindReducedExpressionIndexFromSlotCPU(slotRate);
while (m_gameObject.GetComponent <VisualEffect>() != null)
{
UnityEngine.Object.DestroyImmediate(m_gameObject.GetComponent <VisualEffect>());
}
var vfxComponent = m_gameObject.AddComponent <VisualEffect>();
vfxComponent.visualEffectAsset = graph.visualEffectResource.asset;
int maxFrame = 512;
while (vfxComponent.culled && --maxFrame > 0)
{
yield return(null);
}
Assert.IsTrue(maxFrame > 0);
maxFrame = 512;
while (!(VisualEffectUtility.GetExpressionFloat(vfxComponent, expressionIndex) > 0.01f) && --maxFrame > 0)
{
yield return(null);
}
Assert.IsTrue(maxFrame > 0);
yield return(new ExitPlayMode());
}
public void DestroyTestAssets()
{
VFXViewWindow window = EditorWindow.GetWindow <VFXViewWindow>();
window.Close();
for (int i = 0; i < testAssetCount; ++i)
{
DestroyTestAsset("GUITest" + i);
}
VFXTestCommon.DeleteAllTemporaryGraph();
}
public IEnumerator Verify_Playable_Migration()
{
//This asset contains old activation tracks & clip
var kSourceAsset = "Assets/AllTests/Editor/Tests/VFXOldTimelineActivation.playable_";
var expectedEnterName = new [] { "shoot", "once" };
var expectedExitName = new [] { "ceasefire", "" };
var timelineAsset = VFXTestCommon.CopyTemporaryTimeline(kSourceAsset);
yield return(null);
Assert.IsNotNull(timelineAsset);
//Skip the really first track (marker)
var allTracks = timelineAsset.GetOutputTracks().Skip(1).ToArray();
Assert.AreEqual(8, allTracks.Length);
foreach (var track in allTracks)
{
Assert.IsInstanceOf <VisualEffectControlTrack>(track);
Assert.IsNotEmpty(track.GetClips());
foreach (var clip in track.GetClips())
{
var vfxClip = clip.asset as VisualEffectControlClip;
Assert.IsNotNull(vfxClip);
Assert.IsFalse(vfxClip.scrubbing);
Assert.AreEqual(1, vfxClip.clipEvents.Count);
var clipEvent = vfxClip.clipEvents.First();
Assert.Contains((string)clipEvent.enter.name, expectedEnterName);
Assert.Contains((string)clipEvent.exit.name, expectedExitName);
Assert.AreEqual(1, clipEvent.enter.eventAttributes.content.Length);
var attribute = clipEvent.enter.eventAttributes.content.First() as EventAttributeColor;
Assert.IsNotNull(attribute);
Assert.AreEqual("color", (string)attribute.id);
var sqrLengthToWhite = (UnityEngine.Vector3.one - attribute.value).sqrMagnitude;
var sqrLengthToBlack = (UnityEngine.Vector3.one - attribute.value).sqrMagnitude;
Assert.Greater(sqrLengthToWhite, 0.01f);
Assert.Greater(sqrLengthToBlack, 0.01f);
}
}
}
public IEnumerator Create_Simple_Graph_Then_Remove_Edge_Between_Init_And_Update([ValueSource(nameof(Create_Simple_Graph_Then_Remove_Edget_Between_Init_And_Update_TestCase))] bool autoCompile)
{
var graph = VFXTestCommon.MakeTemporaryGraph();
var path = AssetDatabase.GetAssetPath(graph);
var spawner = ScriptableObject.CreateInstance <VFXBasicSpawner>();
var init = ScriptableObject.CreateInstance <VFXBasicInitialize>();
var update = ScriptableObject.CreateInstance <VFXBasicUpdate>();
var output = ScriptableObject.CreateInstance <VFXPlanarPrimitiveOutput>();
graph.AddChild(spawner);
graph.AddChild(init);
graph.AddChild(update);
graph.AddChild(output);
init.LinkFrom(spawner);
update.LinkFrom(init);
output.LinkFrom(update);
AssetDatabase.ImportAsset(path);
yield return(null);
//The issue is actually visible in VFXView
var window = EditorWindow.GetWindow <VFXViewWindow>();
window.Show();
var bckpAutoCompile = window.autoCompile;
window.autoCompile = autoCompile;
window.LoadAsset(graph.GetResource().asset, null);
//update.UnlinkFrom(init); //Doesn't reproduce the issue
var allFlowEdges = window.graphView.controller.allChildren.OfType <VFXFlowEdgeController>().ToArray();
var flowEdgeToDelete = allFlowEdges.Where(o => o.output.context.model.contextType == VFXContextType.Init && o.input.context.model.contextType == VFXContextType.Update).ToArray();
Assert.AreEqual(1u, flowEdgeToDelete.Length);
window.graphView.controller.Remove(flowEdgeToDelete);
window.graphView.controller.NotifyUpdate(); //<= This function will indirectly try to access system name before update (called by VFXView.Update
yield return(null);
window.autoCompile = bckpAutoCompile;
}
public void PasteSystems()
{
VFXViewWindow window = EditorWindow.GetWindow <VFXViewWindow>();
VFXView view = window.graphView;
view.controller = m_ViewController;
// Create a bunch of systems
const int spawnerCount = 4, GPUSystemsCount = 4;
var spawners = VFXTestCommon.CreateSpawners(view, m_ViewController, spawnerCount);
VFXTestCommon.CreateSystems(view, m_ViewController, GPUSystemsCount, 0);
// Copy paste them
view.ClearSelection();
foreach (var element in view.Query().OfType <GraphElement>().ToList().OfType <ISelectable>())
{
view.AddToSelection(element);
}
view.CopySelectionCallback();
view.PasteCallback();
// Query unique names
var systemNames = view.controller.graph.systemNames;
var uniqueNames = new List <string>();
foreach (var system in spawners)
{
uniqueNames.Add(systemNames.GetUniqueSystemName(system));
}
var GPUSystems = VFXTestCommon.GetFieldValue <VFXView, List <VFXSystemBorder> >(view, "m_Systems");
uniqueNames = uniqueNames.Concat(GPUSystems.Select(system => system.controller.title)).ToList();
// Remove null or empty names, and duplicates
uniqueNames = uniqueNames.Where(name => !string.IsNullOrEmpty(name)).Distinct().ToList();
// Assert all names are unique, and the expected number of elements was obtained
Assert.IsTrue(uniqueNames.Count() == spawnerCount + GPUSystemsCount, "Some systems have the same name or are null or empty.");
}
public void Sanitize_GetSpawnCount()
{
string kSourceAsset = "Assets/AllTests/Editor/Tests/VFXSerializationTests_GetSpawnCount.vfx_";
var graph = VFXTestCommon.CopyTemporaryGraph(kSourceAsset);
Assert.AreEqual(5, graph.children.OfType <VFXAttributeParameter>().Count());
Assert.AreEqual(5, graph.children.OfType <VFXInlineOperator>().Where(o => o.type == typeof(uint)).Count());
Assert.AreEqual(1, graph.children.OfType <VFXInlineOperator>().Where(o => o.type == typeof(float)).Count());
Assert.AreEqual(1, graph.children.OfType <Operator.Add>().Count());
Assert.AreEqual(1, graph.children.OfType <VFXInlineOperator>().Where(o => o.type == typeof(Color)).Count());
foreach (var attribute in graph.children.OfType <VFXAttributeParameter>())
{
Assert.IsTrue(attribute.outputSlots[0].HasLink());
}
foreach (var inlineUInt in graph.children.OfType <VFXInlineOperator>().Where(o => o.type == typeof(uint)))
{
Assert.IsTrue(inlineUInt.inputSlots[0].HasLink());
}
foreach (var inlineFloat in graph.children.OfType <VFXInlineOperator>().Where(o => o.type == typeof(float)))
{
Assert.IsTrue(inlineFloat.inputSlots[0].HasLink());
}
foreach (var inlineColor in graph.children.OfType <VFXInlineOperator>().Where(o => o.type == typeof(Color)))
{
Assert.IsTrue(inlineColor.inputSlots[0].HasLink());
}
foreach (var add in graph.children.OfType <Operator.Add>())
{
Assert.AreEqual(2, add.operandCount);
Assert.IsTrue(add.inputSlots[0].HasLink());
Assert.IsTrue(add.inputSlots[1].HasLink());
}
}
void GraphWithImplicitBehavior_Internal(VFXBlock[] initBlocks)
{
var graph = VFXTestCommon.MakeTemporaryGraph();
var spawnerContext = ScriptableObject.CreateInstance <VFXBasicSpawner>();
var initContext = ScriptableObject.CreateInstance <VFXBasicInitialize>();
var updateContext = ScriptableObject.CreateInstance <VFXBasicUpdate>();
var outputContext = ScriptableObject.CreateInstance <VFXPointOutput>();
graph.AddChild(spawnerContext);
graph.AddChild(initContext);
graph.AddChild(updateContext);
graph.AddChild(outputContext);
spawnerContext.LinkTo(initContext);
initContext.LinkTo(updateContext);
updateContext.LinkTo(outputContext);
foreach (var initBlock in initBlocks)
{
initContext.AddChild(initBlock);
}
graph.RecompileIfNeeded();
}
public void CheckName_Sharing_Between_Output_Event()
{
var graph = VFXTestCommon.MakeTemporaryGraph();
var gameObj = new GameObject("CheckData_Sharing_Between_Output_Event");
var vfxComponent = gameObj.AddComponent <VisualEffect>();
vfxComponent.visualEffectAsset = graph.visualEffectResource.asset;
var sourceSpawner = ScriptableObject.CreateInstance <VFXBasicSpawner>();
var eventOutput_A = ScriptableObject.CreateInstance <VFXOutputEvent>();
var eventOutput_B = ScriptableObject.CreateInstance <VFXOutputEvent>();
eventOutput_A.LinkFrom(sourceSpawner);
eventOutput_B.LinkFrom(sourceSpawner);
Assert.AreEqual(1u, eventOutput_A.inputContexts.Count());
Assert.AreEqual(1u, eventOutput_B.inputContexts.Count());
graph.AddChild(sourceSpawner);
graph.AddChild(eventOutput_A);
graph.AddChild(eventOutput_B);
var name_A = eventOutput_A.GetSetting("eventName").value as string;
var name_B = eventOutput_B.GetSetting("eventName").value as string;
//Equals names
Assert.AreEqual(name_A, name_B);
Assert.AreNotEqual(eventOutput_A.GetData(), eventOutput_B.GetData());
AssetDatabase.ImportAsset(AssetDatabase.GetAssetPath(graph));
var names = new List <string>();
vfxComponent.GetOutputEventNames(names);
Assert.AreEqual(1, names.Count);
Assert.AreEqual(name_A, names[0]);
var newName = "miaou";
eventOutput_A.SetSettingValue("eventName", newName);
name_A = eventOutput_A.GetSetting("eventName").value as string;
name_B = eventOutput_B.GetSetting("eventName").value as string;
//Now, different names
Assert.AreNotEqual(name_A, name_B);
Assert.AreNotEqual(eventOutput_A.GetData(), eventOutput_B.GetData());
Assert.AreEqual((eventOutput_A.GetData() as VFXDataOutputEvent).eventName, name_A);
Assert.AreEqual((eventOutput_B.GetData() as VFXDataOutputEvent).eventName, name_B);
AssetDatabase.ImportAsset(AssetDatabase.GetAssetPath(graph));
vfxComponent.GetOutputEventNames(names);
Assert.AreEqual(2, names.Count);
Assert.IsTrue(names.Contains(newName));
Assert.AreNotEqual(name_B, newName);
Assert.IsTrue(names.Contains(name_B));
//Back to equals names
eventOutput_B.SetSettingValue("eventName", newName);
name_A = eventOutput_A.GetSetting("eventName").value as string;
name_B = eventOutput_B.GetSetting("eventName").value as string;
Assert.AreEqual(name_A, name_B);
Assert.AreNotEqual(eventOutput_A.GetData(), eventOutput_B.GetData());
Assert.AreEqual((eventOutput_A.GetData() as VFXDataOutputEvent).eventName, name_A);
AssetDatabase.ImportAsset(AssetDatabase.GetAssetPath(graph));
vfxComponent.GetOutputEventNames(names);
Assert.AreEqual(1, names.Count);
Assert.AreEqual(newName, names[0]);
UnityEngine.Object.DestroyImmediate(gameObj);
}
public void TearDown()
{
VFXTestCommon.DeleteAllTemporaryGraph();
}
public void CleanUp()
{
VFXTestCommon.DeleteAllTemporaryGraph();
}
//[UnityTest] Not really a test but helper to profile the controller invalidation.
public IEnumerator ExperimentCreateAllBlocksTiming([ValueSource(nameof(kApplyChange))] bool applyChanges, [ValueSource(nameof(kApplyChange))] bool blocks)
{
var referenceBlock = VFXLibrary.GetBlocks().Where(t => t.model is Block.KillSphere).First();
var referenceOperator = VFXLibrary.GetOperators().Where(t => t.model is Operator.DistanceToSphere).First();
var referenceContext = VFXLibrary.GetContexts().Where(t => t.model is VFXBasicUpdate).First();
var param = new CreateAllBlockParam()
{
name = "Test",
destContext = referenceContext
};
var results = new List <(int, double)>();
int modelCount = 1;
while (modelCount < 512)
{
var watch = new System.Diagnostics.Stopwatch();
watch.Start();
if (modelCount >= 256)
{
modelCount += 128;
}
else
{
modelCount *= 2;
}
var controller = StartEditTestAsset();
if (blocks)
{
param.blocks = Enumerable.Repeat(referenceBlock, modelCount);
CreateAllBlocksExperiment(controller, param.destContext, param.blocks, applyChanges);
}
else
{
var operators = Enumerable.Repeat(referenceOperator, modelCount);
CreateAllOperatorsExperiment(controller, operators, applyChanges);
}
watch.Stop();
var stopwatchElapsed = watch.Elapsed;
results.Add((modelCount, stopwatchElapsed.TotalMilliseconds));
//Clean up for next experiment
System.GC.Collect();
var window = EditorWindow.GetWindow <VFXViewWindow>();
window.Close();
VFXTestCommon.DeleteAllTemporaryGraph();
for (int i = 0; i < 8; ++i)
{
yield return(null);
}
}
var report = new System.Text.StringBuilder();
report.AppendFormat("ApplyChange : {0} - {1}", applyChanges, blocks ? "Blocks" : "Operators");
report.AppendLine();
foreach (var result in results)
{
report.AppendFormat("{0};{1}", result.Item1, result.Item2);
report.AppendLine();
}
Debug.Log(report);
}
public IEnumerator Create_Prefab_Several_Override()
{
var graph = VFXTestCommon.MakeTemporaryGraph();
var parametersIntDesc = VFXLibrary.GetParameters().Where(o => o.model.type == typeof(int)).First();
Func <VisualEffect, string> dumpPropertySheetInteger = delegate(VisualEffect target)
{
var r = "{";
var editor = Editor.CreateEditor(target);
editor.serializedObject.Update();
var propertySheet = editor.serializedObject.FindProperty("m_PropertySheet");
var fieldName = VisualEffectSerializationUtility.GetTypeField(VFXExpression.TypeToType(VFXValueType.Int32)) + ".m_Array";
var vfxField = propertySheet.FindPropertyRelative(fieldName);
for (int i = 0; i < vfxField.arraySize; ++i)
{
var itField = vfxField.GetArrayElementAtIndex(i);
var name = itField.FindPropertyRelative("m_Name").stringValue;
var value = itField.FindPropertyRelative("m_Value").intValue;
var overridden = itField.FindPropertyRelative("m_Overridden").boolValue;
r += string.Format("({0}, {1}, {2})", name, value, overridden);
if (i != vfxField.arraySize - 1)
{
r += ", ";
}
}
GameObject.DestroyImmediate(editor);
r += "}";
return(r);
};
var log = string.Empty;
var exposedProperties = new[] { "a", "b", "c" };
for (var i = 0; i < exposedProperties.Length; ++i)
{
var parameter = parametersIntDesc.CreateInstance();
parameter.SetSettingValue("m_ExposedName", exposedProperties[i]);
parameter.SetSettingValue("m_Exposed", true);
parameter.value = i + 1;
graph.AddChild(parameter);
}
AssetDatabase.ImportAsset(AssetDatabase.GetAssetPath(graph));
var mainObject = MakeTemporaryGameObject();
var vfx = mainObject.AddComponent <VisualEffect>();
vfx.visualEffectAsset = graph.visualEffectResource.asset;
GameObject newGameObject, prefabInstanceObject;
MakeTemporaryPrebab(mainObject, out newGameObject, out prefabInstanceObject);
GameObject.DestroyImmediate(mainObject);
yield return(null);
var currentPrefabInstanceObject = PrefabUtility.InstantiatePrefab(prefabInstanceObject) as GameObject;
var overridenParametersInScene = new[] { new { name = "b", value = 666 }, new { name = "a", value = 444 } };
var overridenParametersInPrefab = new[] { new { name = "c", value = -123 } };
log += "Initial Sheet\n";
log += "Prefab : " + dumpPropertySheetInteger(prefabInstanceObject.GetComponent <VisualEffect>()) + "\n";
log += "Instance : " + dumpPropertySheetInteger(currentPrefabInstanceObject.GetComponent <VisualEffect>()) + "\n";
yield return(null);
foreach (var overridenParameter in overridenParametersInScene)
{
currentPrefabInstanceObject.GetComponent <VisualEffect>().SetInt(overridenParameter.name, overridenParameter.value);
}
log += "\nIntermediate Sheet\n";
log += "Prefab : " + dumpPropertySheetInteger(prefabInstanceObject.GetComponent <VisualEffect>()) + "\n";
log += "Instance : " + dumpPropertySheetInteger(currentPrefabInstanceObject.GetComponent <VisualEffect>()) + "\n";
yield return(null);
foreach (var overridenParameter in overridenParametersInPrefab)
{
prefabInstanceObject.GetComponent <VisualEffect>().SetInt(overridenParameter.name, overridenParameter.value);
}
yield return(null);
log += "\nEnd Sheet\n";
log += "Prefab : " + dumpPropertySheetInteger(prefabInstanceObject.GetComponent <VisualEffect>()) + "\n";
log += "Instance : " + dumpPropertySheetInteger(currentPrefabInstanceObject.GetComponent <VisualEffect>()) + "\n";
var stringFormat = @"({0} : {1}) ";
var expectedValues = string.Empty;
for (var i = 0; i < exposedProperties.Length; ++i)
{
var expectedValue = i;
var expectedName = exposedProperties[i];
var overrideInPrefab = overridenParametersInPrefab.FirstOrDefault(o => o.name == exposedProperties[i]);
var overrideInScene = overridenParametersInScene.FirstOrDefault(o => o.name == exposedProperties[i]);
if (overrideInPrefab != null)
{
expectedValue = overrideInPrefab.value;
}
if (overrideInScene != null)
{
expectedValue = overrideInScene.value;
}
expectedValues += string.Format(stringFormat, expectedName, expectedValue);
}
var actualValues = string.Empty;
for (var i = 0; i < exposedProperties.Length; ++i)
{
var expectedName = exposedProperties[i];
var actualValue = currentPrefabInstanceObject.GetComponent <VisualEffect>().GetInt(expectedName);
actualValues += string.Format(stringFormat, expectedName, actualValue);
}
if (k_HasFixed_Several_PrefabOverride)
{
Assert.AreEqual(expectedValues, actualValues, log);
}
else
{
Assert.AreNotEqual(expectedValues, actualValues, log); //Did you fixed it ? Should enable this test : k_HasFixed_Several_PrefabOverride
}
yield return(null);
}
public void Sanitize_Shape_To_TShape()
{
var kSourceAsset = "Assets/AllTests/Editor/Tests/VFXSanitizeTShape.vfx_";
var graph = VFXTestCommon.CopyTemporaryGraph(kSourceAsset);
//Sphere Volume
{
var volumes = graph.children.OfType <Operator.SphereVolume>().ToArray();
Assert.AreEqual(3, volumes.Count());
var volume_A = volumes.FirstOrDefault(o => !o.inputSlots[0].HasLink(true));
var volume_B = volumes.FirstOrDefault(o => o.inputSlots[0].HasLink(true) && o.inputSlots[0][1].LinkedSlots.First().owner is VFXParameter);
var volume_C = volumes.FirstOrDefault(o => o.inputSlots[0].HasLink(true) && o.inputSlots[0][1].LinkedSlots.First().owner is VFXInlineOperator);
Assert.IsNotNull(volume_A);
Assert.IsNotNull(volume_B);
Assert.IsNotNull(volume_C);
Assert.AreNotEqual(volume_A, volume_B);
Assert.AreNotEqual(volume_B, volume_C);
var tSphere = (TSphere)volume_A.inputSlots[0].value;
Assert.AreEqual(1.0f, tSphere.transform.position.x);
Assert.AreEqual(2.0f, tSphere.transform.position.y);
Assert.AreEqual(3.0f, tSphere.transform.position.z);
Assert.AreEqual(4.0f, tSphere.radius);
Assert.AreEqual(volume_B.inputSlots[0].space, volume_B.inputSlots[0][1].LinkedSlots.First().space);
Assert.IsTrue(volume_B.inputSlots[0][0][0].HasLink());
Assert.IsTrue(volume_B.inputSlots[0][1].HasLink());
Assert.IsTrue(volume_B.outputSlots[0].HasLink());
Assert.IsTrue(volume_C.inputSlots[0][0][0].HasLink());
Assert.IsTrue(volume_C.inputSlots[0][1].HasLink());
Assert.IsTrue(volume_C.outputSlots[0].HasLink());
}
//Cylinder & Cone Volume
{
var volumes = graph.children.OfType <Operator.ConeVolume>().ToArray();
Assert.AreEqual(6, volumes.Count());
var volume_cyl_A = volumes.FirstOrDefault(o => !o.inputSlots[0].HasLink(true) && ((float)o.inputSlots[0][0][0][1].value) == -0.5f);
var volume_cone_A = volumes.FirstOrDefault(o => !o.inputSlots[0].HasLink(true) && ((float)o.inputSlots[0][0][0][1].value) != -0.5f);
var tCone_cyl = (TCone)volume_cyl_A.inputSlots[0].value;
Assert.AreEqual(1.0f, tCone_cyl.transform.position.x);
Assert.AreEqual(-0.5f, tCone_cyl.transform.position.y); //has been corrected by half height
Assert.AreEqual(3.0f, tCone_cyl.transform.position.z);
Assert.AreEqual(4.0f, tCone_cyl.baseRadius);
Assert.AreEqual(4.0f, tCone_cyl.topRadius);
Assert.AreEqual(5.0f, tCone_cyl.height);
var tCone_cone = (TCone)volume_cone_A.inputSlots[0].value;
Assert.AreEqual(1.0f, tCone_cone.transform.position.x);
Assert.AreEqual(2.0f, tCone_cone.transform.position.y);
Assert.AreEqual(3.0f, tCone_cone.transform.position.z);
Assert.AreEqual(4.0f, tCone_cone.baseRadius);
Assert.AreEqual(5.0f, tCone_cone.topRadius);
Assert.AreEqual(6.0f, tCone_cone.height);
//It isn't obvious to make difference between old cylinder & old cone, basic check on other operators
foreach (var volume in volumes)
{
if (volume == volume_cyl_A || volume == volume_cone_A)
{
continue;
}
foreach (var subslot in volume.inputSlots[0].children)
{
if (subslot.property.type == typeof(Transform))
{
Assert.IsTrue(subslot[0].HasLink());
Assert.IsFalse(subslot[1].HasLink());
Assert.IsFalse(subslot[2].HasLink());
}
else
{
Assert.IsTrue(subslot.HasLink());
}
}
}
}
//Circle Area
{
var volumes = graph.children.OfType <Operator.CircleArea>().ToArray();
Assert.AreEqual(3, volumes.Count());
var volume_A = volumes.FirstOrDefault(o => !o.inputSlots[0].HasLink(true));
var volume_B = volumes.FirstOrDefault(o => o.inputSlots[0].HasLink(true) && o.inputSlots[0][1].LinkedSlots.First().owner is VFXParameter);
var volume_C = volumes.FirstOrDefault(o => o.inputSlots[0].HasLink(true) && o.inputSlots[0][1].LinkedSlots.First().owner is VFXInlineOperator);
Assert.IsNotNull(volume_A);
Assert.IsNotNull(volume_B);
Assert.IsNotNull(volume_C);
Assert.AreNotEqual(volume_A, volume_B);
Assert.AreNotEqual(volume_B, volume_C);
var tCircle = (TCircle)volume_A.inputSlots[0].value;
Assert.AreEqual(1.0f, tCircle.transform.position.x);
Assert.AreEqual(2.0f, tCircle.transform.position.y);
Assert.AreEqual(3.0f, tCircle.transform.position.z);
Assert.AreEqual(4.0f, tCircle.radius);
Assert.AreEqual(volume_B.inputSlots[0].space, volume_B.inputSlots[0][1].LinkedSlots.First().space);
Assert.IsTrue(volume_B.inputSlots[0][0][0].HasLink());
Assert.IsTrue(volume_B.inputSlots[0][1].HasLink());
Assert.IsTrue(volume_B.outputSlots[0].HasLink());
Assert.IsTrue(volume_C.inputSlots[0][0][0].HasLink());
Assert.IsTrue(volume_C.inputSlots[0][1].HasLink());
Assert.IsTrue(volume_C.outputSlots[0].HasLink());
}
//Torus Volume
{
var volumes = graph.children.OfType <Operator.TorusVolume>().ToArray();
Assert.AreEqual(3, volumes.Count());
var volume_A = volumes.FirstOrDefault(o => !o.inputSlots[0].HasLink(true));
var volume_B = volumes.FirstOrDefault(o => o.inputSlots[0].HasLink(true) && o.inputSlots[0][1].LinkedSlots.First().owner is VFXParameter);
var volume_C = volumes.FirstOrDefault(o => o.inputSlots[0].HasLink(true) && o.inputSlots[0][1].LinkedSlots.First().owner is VFXInlineOperator);
Assert.IsNotNull(volume_A);
Assert.IsNotNull(volume_B);
Assert.IsNotNull(volume_C);
Assert.AreNotEqual(volume_A, volume_B);
Assert.AreNotEqual(volume_B, volume_C);
var tTorus = (TTorus)volume_A.inputSlots[0].value;
Assert.AreEqual(1.0f, tTorus.transform.position.x);
Assert.AreEqual(2.0f, tTorus.transform.position.y);
Assert.AreEqual(3.0f, tTorus.transform.position.z);
Assert.AreEqual(4.0f, tTorus.majorRadius);
Assert.AreEqual(5.0f, tTorus.minorRadius);
Assert.AreEqual(volume_B.inputSlots[0].space, volume_B.inputSlots[0][1].LinkedSlots.First().space);
Assert.IsTrue(volume_B.inputSlots[0][0][0].HasLink());
Assert.IsTrue(volume_B.inputSlots[0][1].HasLink());
Assert.IsTrue(volume_B.inputSlots[0][2].HasLink());
Assert.IsTrue(volume_B.outputSlots[0].HasLink());
Assert.IsTrue(volume_C.inputSlots[0][0][0].HasLink());
Assert.IsTrue(volume_C.inputSlots[0][1].HasLink());
Assert.IsTrue(volume_C.inputSlots[0][2].HasLink());
Assert.IsTrue(volume_C.outputSlots[0].HasLink());
}
//Position Sphere
{
var initialize = graph.children.OfType <VFXBasicInitialize>().FirstOrDefault(o => o.label == "position_sphere");
Assert.IsNotNull(initialize);
var sphereBlocks = initialize.children.OfType <Block.PositionSphere>().ToArray();
Assert.AreEqual(4, sphereBlocks.Length);
foreach (var block in sphereBlocks)
{
Assert.AreEqual(3, block.inputSlots.Count);
if (block != sphereBlocks.Last())
{
Assert.IsTrue(block.inputSlots[0][0][0][0].HasLink()); //center
Assert.IsTrue(block.inputSlots[0][0][1].HasLink()); //radius
if (block == sphereBlocks.First())
{
Assert.IsTrue(block.inputSlots[0][1]); //arc
}
}
else
{
var tArcSphere = (TArcSphere)block.inputSlots[0].value;
Assert.AreEqual(1.0f, tArcSphere.sphere.transform.position.x);
Assert.AreEqual(2.0f, tArcSphere.sphere.transform.position.y);
Assert.AreEqual(3.0f, tArcSphere.sphere.transform.position.z);
Assert.AreEqual(4.0f, tArcSphere.sphere.radius);
Assert.AreEqual(5.0f, tArcSphere.arc);
}
Assert.AreEqual(6.0f, block.inputSlots[1].value);
Assert.AreEqual(0.7f, block.inputSlots[2].value);
}
}
//Position Circle
{
var initialize = graph.children.OfType <VFXBasicInitialize>().FirstOrDefault(o => o.label == "position_circle");
Assert.IsNotNull(initialize);
var circleBlock = initialize.children.OfType <Block.PositionCircle>().ToArray();
Assert.AreEqual(4, circleBlock.Length);
foreach (var block in circleBlock)
{
Assert.AreEqual(3, block.inputSlots.Count);
if (block != circleBlock.Last())
{
Assert.IsTrue(block.inputSlots[0][0][0][0].HasLink()); //center
Assert.IsTrue(block.inputSlots[0][0][1].HasLink()); //radius
if (block == circleBlock.First())
{
Assert.IsTrue(block.inputSlots[0][1]); //arc
}
}
else
{
var tArcCircle = (TArcCircle)block.inputSlots[0].value;
Assert.AreEqual(1.0f, tArcCircle.circle.transform.position.x);
Assert.AreEqual(2.0f, tArcCircle.circle.transform.position.y);
Assert.AreEqual(3.0f, tArcCircle.circle.transform.position.z);
Assert.AreEqual(4.0f, tArcCircle.circle.radius);
Assert.AreEqual(5.0f, tArcCircle.arc);
}
Assert.AreEqual(6.0f, block.inputSlots[1].value);
Assert.AreEqual(0.7f, block.inputSlots[2].value);
}
}
//Position Cone
{
var initialize = graph.children.OfType <VFXBasicInitialize>().FirstOrDefault(o => o.label == "position_cone");
Assert.IsNotNull(initialize);
var coneBlocks = initialize.children.OfType <Block.PositionCone>().ToArray();
Assert.AreEqual(3, coneBlocks.Length);
foreach (var block in coneBlocks)
{
Assert.AreEqual(4, block.inputSlots.Count);
if (block != coneBlocks.Last())
{
Assert.IsTrue(block.inputSlots[0][0][0][0].HasLink()); //center
Assert.IsTrue(block.inputSlots[0][0][1].HasLink()); //baseradius
Assert.IsTrue(block.inputSlots[0][0][2].HasLink()); //topRadius
Assert.IsTrue(block.inputSlots[0][0][3].HasLink()); //height
if (block == coneBlocks.First())
{
Assert.IsTrue(block.inputSlots[0][1]); //arc
}
}
else
{
var tArcCone = (TArcCone)block.inputSlots[0].value;
Assert.AreEqual(1.0f, tArcCone.cone.transform.position.x);
Assert.AreEqual(2.0f, tArcCone.cone.transform.position.y);
Assert.AreEqual(3.0f, tArcCone.cone.transform.position.z);
Assert.AreEqual(4.0f, tArcCone.cone.baseRadius);
Assert.AreEqual(5.0f, tArcCone.cone.topRadius);
Assert.AreEqual(6.0f, tArcCone.cone.height);
Assert.AreEqual(0.7f, tArcCone.arc);
}
Assert.AreEqual(8.0f, block.inputSlots[1].value);
Assert.AreEqual(0.9f, block.inputSlots[2].value);
Assert.AreEqual(1.0f, block.inputSlots[3].value);
}
}
//Position Torus
{
var initialize = graph.children.OfType <VFXBasicInitialize>().FirstOrDefault(o => o.label == "position_torus");
Assert.IsNotNull(initialize);
var torusBlocks = initialize.children.OfType <Block.PositionTorus>().ToArray();
Assert.AreEqual(3, torusBlocks.Length);
foreach (var block in torusBlocks)
{
Assert.AreEqual(3, block.inputSlots.Count);
if (block != torusBlocks.Last())
{
Assert.IsTrue(block.inputSlots[0][0][0][0].HasLink()); //center
Assert.IsTrue(block.inputSlots[0][0][1].HasLink()); //majorRadius
Assert.IsTrue(block.inputSlots[0][0][2].HasLink()); //minorRadius
if (block == torusBlocks.First())
{
Assert.IsTrue(block.inputSlots[0][1]); //arc
}
}
else
{
var tArcTorus = (TArcTorus)block.inputSlots[0].value;
Assert.AreEqual(1.0f, tArcTorus.torus.transform.position.x);
Assert.AreEqual(2.0f, tArcTorus.torus.transform.position.y);
Assert.AreEqual(3.0f, tArcTorus.torus.transform.position.z);
Assert.AreEqual(4.0f, tArcTorus.torus.majorRadius);
Assert.AreEqual(5.0f, tArcTorus.torus.minorRadius);
Assert.AreEqual(0.6f, tArcTorus.arc);
}
Assert.AreEqual(7.0f, block.inputSlots[1].value);
Assert.AreEqual(0.8f, block.inputSlots[2].value);
}
}
//Kill Sphere
{
var initialize = graph.children.OfType <VFXBasicUpdate>().FirstOrDefault(o => o.label == "kill_sphere");
Assert.IsNotNull(initialize);
var sphereBlocks = initialize.children.OfType <Block.KillSphere>().ToArray();
Assert.AreEqual(3, sphereBlocks.Length);
foreach (var block in sphereBlocks)
{
Assert.AreEqual(1, block.inputSlots.Count);
if (block != sphereBlocks.Last())
{
Assert.IsTrue(block.inputSlots[0][0][0].HasLink()); //center
Assert.IsTrue(block.inputSlots[0][1].HasLink()); //radius
}
else
{
var tSphere = (TSphere)block.inputSlots[0].value;
Assert.AreEqual(1.0f, tSphere.transform.position.x);
Assert.AreEqual(2.0f, tSphere.transform.position.y);
Assert.AreEqual(3.0f, tSphere.transform.position.z);
Assert.AreEqual(4.0f, tSphere.radius);
}
}
}
//Collide Sphere
{
var initialize = graph.children.OfType <VFXBasicUpdate>().FirstOrDefault(o => o.label == "collision_sphere");
Assert.IsNotNull(initialize);
var sphereBlocks = initialize.children.OfType <Block.CollisionSphere>().ToArray();
Assert.AreEqual(3, sphereBlocks.Length);
foreach (var block in sphereBlocks)
{
Assert.AreEqual(6, block.inputSlots.Count);
if (block != sphereBlocks.Last())
{
Assert.IsTrue(block.inputSlots[0][0][0].HasLink()); //center
Assert.IsTrue(block.inputSlots[0][1].HasLink()); //radius
}
else
{
var tSphere = (TSphere)block.inputSlots[0].value;
Assert.AreEqual(1.0f, tSphere.transform.position.x);
Assert.AreEqual(2.0f, tSphere.transform.position.y);
Assert.AreEqual(3.0f, tSphere.transform.position.z);
Assert.AreEqual(4.0f, tSphere.radius);
}
Assert.AreEqual(0.2f, block.inputSlots[1].value);
Assert.AreEqual(0.3f, block.inputSlots[2].value);
Assert.AreEqual(0.4f, block.inputSlots[3].value);
Assert.AreEqual(0.5f, block.inputSlots[4].value);
Assert.AreEqual(0.6f, block.inputSlots[5].value);
}
}
//Collide Cylinder (migration to cone)
{
var initialize = graph.children.OfType <VFXBasicUpdate>().FirstOrDefault(o => o.label == "collision_cylinder");
Assert.IsNotNull(initialize);
var coneBlocks = initialize.children.OfType <Block.CollisionCone>().ToArray();
Assert.AreEqual(3, coneBlocks.Length);
foreach (var block in coneBlocks)
{
Assert.AreEqual(6, block.inputSlots.Count);
if (block != coneBlocks.Last())
{
Assert.IsTrue(block.inputSlots[0][0][0].HasLink()); //center
Assert.IsTrue(block.inputSlots[0][1].HasLink()); //baseradius
Assert.IsTrue(block.inputSlots[0][2].HasLink()); //topRadius
Assert.IsTrue(block.inputSlots[0][3].HasLink()); //height
}
else
{
var tCone = (TCone)block.inputSlots[0].value;
Assert.AreEqual(1.0f, tCone.transform.position.x);
Assert.AreEqual(-0.5f, tCone.transform.position.y);
Assert.AreEqual(3.0f, tCone.transform.position.z);
Assert.AreEqual(4.0f, tCone.baseRadius); //<= That is the trick of cylinder migration
Assert.AreEqual(4.0f, tCone.topRadius);
Assert.AreEqual(5.0f, tCone.height);
}
Assert.AreEqual(0.2f, block.inputSlots[1].value);
Assert.AreEqual(0.3f, block.inputSlots[2].value);
Assert.AreEqual(0.4f, block.inputSlots[3].value);
Assert.AreEqual(0.5f, block.inputSlots[4].value);
Assert.AreEqual(0.6f, block.inputSlots[5].value);
}
}
}
public IEnumerator Create_Prefab_Modify_And_Expect_No_Override()
{
var graph = VFXTestCommon.MakeTemporaryGraph();
var parametersVector3Desc = VFXLibrary.GetParameters().Where(o => o.model.type == typeof(Vector3)).First();
var exposedName = "ghjkl";
var parameter = parametersVector3Desc.CreateInstance();
parameter.SetSettingValue("m_ExposedName", exposedName);
parameter.SetSettingValue("m_Exposed", true);
parameter.value = new Vector3(0, 0, 0);
graph.AddChild(parameter);
AssetDatabase.ImportAsset(AssetDatabase.GetAssetPath(graph));
var mainObject = MakeTemporaryGameObject();
var vfx = mainObject.AddComponent <VisualEffect>();
vfx.visualEffectAsset = graph.visualEffectResource.asset;
Assert.IsTrue(vfx.HasVector3(exposedName));
vfx.SetVector3(exposedName, new Vector3(1, 2, 3));
GameObject newGameObject, prefabInstanceObject;
MakeTemporaryPrebab(mainObject, out newGameObject, out prefabInstanceObject);
GameObject.DestroyImmediate(mainObject);
var currentPrefabInstanceObject = PrefabUtility.InstantiatePrefab(prefabInstanceObject) as GameObject;
yield return(null);
var vfxInPrefab = prefabInstanceObject.GetComponent <VisualEffect>();
var expectedNewValue = new Vector3(4, 5, 6);
if (k_HasFixed_DisabledState)
{
Assert.IsTrue(vfxInPrefab.HasVector3(exposedName));
vfxInPrefab.SetVector3(exposedName, expectedNewValue);
}
else
{
/* modifying prefab using serialized property */
var editor = Editor.CreateEditor(vfxInPrefab);
editor.serializedObject.Update();
var propertySheet = editor.serializedObject.FindProperty("m_PropertySheet");
var fieldName = VisualEffectSerializationUtility.GetTypeField(VFXExpression.TypeToType(VFXValueType.Float3)) + ".m_Array";
var vfxField = propertySheet.FindPropertyRelative(fieldName);
Assert.AreEqual(1, vfxField.arraySize);
var property = vfxField.GetArrayElementAtIndex(0);
property = property.FindPropertyRelative("m_Value");
property.vector3Value = expectedNewValue;
editor.serializedObject.ApplyModifiedPropertiesWithoutUndo();
GameObject.DestroyImmediate(editor);
EditorUtility.SetDirty(prefabInstanceObject);
}
//AssetDatabase.SaveAssets(); //Helps debug but not necessary
PrefabUtility.SavePrefabAsset(prefabInstanceObject);
yield return(null);
var currentVFXInstanciedFromPrefab = currentPrefabInstanceObject.GetComponent <VisualEffect>();
Assert.IsTrue(currentVFXInstanciedFromPrefab.HasVector3(exposedName));
var refExposedValue = currentVFXInstanciedFromPrefab.GetVector3(exposedName);
var newInstanciedFromPrefab = PrefabUtility.InstantiatePrefab(prefabInstanceObject) as GameObject;
var newVFXInstanciedFromPrefab = newInstanciedFromPrefab.GetComponent <VisualEffect>();
Assert.IsTrue(newVFXInstanciedFromPrefab.HasVector3(exposedName));
var newExposedValue = newVFXInstanciedFromPrefab.GetVector3(exposedName);
var overrides = PrefabUtility.GetObjectOverrides(currentPrefabInstanceObject);
Assert.AreEqual(newExposedValue.x, expectedNewValue.x); Assert.AreEqual(newExposedValue.y, expectedNewValue.y); Assert.AreEqual(newExposedValue.z, expectedNewValue.z); //< Expected to work
if (k_HasFixed_PrefabOverride)
{
//Known issue : Failing due to fogbugz 1117103
Assert.AreEqual(refExposedValue.x, expectedNewValue.x); Assert.AreEqual(refExposedValue.y, expectedNewValue.y); Assert.AreEqual(refExposedValue.z, expectedNewValue.z);
Assert.IsEmpty(overrides);
}
}
public IEnumerator CreateAssetAndComponent_Space_Bounds([ValueSource("available_Space")] object systemSpace, [ValueSource("available_Space")] object boundSpace)
{
var objectPosition = new Vector3(0.123f, 0.0f, 0.0f);
var boundPosition = new Vector3(0.0f, 0.0987f, 0.0f);
yield return(new EnterPlayMode());
var graph = VFXTestCommon.MakeTemporaryGraph();
var spawnerContext = ScriptableObject.CreateInstance <VFXBasicSpawner>();
var blockConstantRate = ScriptableObject.CreateInstance <VFXSpawnerConstantRate>();
var basicInitialize = ScriptableObject.CreateInstance <VFXBasicInitialize>();
var basicUpdate = ScriptableObject.CreateInstance <VFXBasicUpdate>();
var quadOutput = ScriptableObject.CreateInstance <VFXPlanarPrimitiveOutput>();
quadOutput.SetSettingValue("blendMode", VFXAbstractParticleOutput.BlendMode.Additive);
var setLifetime = ScriptableObject.CreateInstance <SetAttribute>(); //only needed to allocate a minimal attributeBuffer
setLifetime.SetSettingValue("attribute", "lifetime");
setLifetime.inputSlots[0].value = 1.0f;
basicInitialize.AddChild(setLifetime);
spawnerContext.AddChild(blockConstantRate);
graph.AddChild(spawnerContext);
graph.AddChild(basicInitialize);
graph.AddChild(basicUpdate);
graph.AddChild(quadOutput);
basicInitialize.LinkFrom(spawnerContext);
basicUpdate.LinkFrom(basicInitialize);
quadOutput.LinkFrom(basicUpdate);
basicInitialize.space = (VFXCoordinateSpace)systemSpace;
basicInitialize.inputSlots[0].space = (VFXCoordinateSpace)boundSpace;
basicInitialize.inputSlots[0][0].value = boundPosition;
basicInitialize.inputSlots[0][1].value = Vector3.one * 5.0f;
AssetDatabase.ImportAsset(AssetDatabase.GetAssetPath(graph));
var gameObj = new GameObject("CreateAssetAndComponentToCheckBound");
gameObj.transform.position = objectPosition;
var vfxComponent = gameObj.AddComponent <VisualEffect>();
vfxComponent.visualEffectAsset = graph.visualEffectResource.asset;
var cameraObj = new GameObject("CreateAssetAndComponentToCheckBound_Camera");
var camera = cameraObj.AddComponent <Camera>();
camera.transform.localPosition = Vector3.one;
camera.transform.LookAt(vfxComponent.transform);
int maxFrame = 512;
while (vfxComponent.culled && --maxFrame > 0)
{
yield return(null);
}
Assert.IsTrue(maxFrame > 0);
yield return(null); //wait for exactly one more update if visible
var renderer = vfxComponent.GetComponent <VFXRenderer>();
var parentFromCenter = VFXSpacePropagationTest.CollectParentExpression(basicInitialize.inputSlots[0][0].GetExpression()).ToArray();
if ((VFXCoordinateSpace)systemSpace == VFXCoordinateSpace.Local && (VFXCoordinateSpace)boundSpace == VFXCoordinateSpace.Local)
{
Assert.IsFalse(parentFromCenter.Any(o => o.operation == VFXExpressionOperation.LocalToWorld || o.operation == VFXExpressionOperation.WorldToLocal));
Assert.AreEqual(boundPosition.x + objectPosition.x, renderer.bounds.center.x, 0.0001);
Assert.AreEqual(boundPosition.y + objectPosition.y, renderer.bounds.center.y, 0.0001);
Assert.AreEqual(boundPosition.z + objectPosition.z, renderer.bounds.center.z, 0.0001);
}
else if ((VFXCoordinateSpace)systemSpace == VFXCoordinateSpace.World && (VFXCoordinateSpace)boundSpace == VFXCoordinateSpace.Local)
{
Assert.IsFalse(parentFromCenter.Any(o => o.operation == VFXExpressionOperation.LocalToWorld || o.operation == VFXExpressionOperation.WorldToLocal));
Assert.AreEqual(boundPosition.x + objectPosition.x, renderer.bounds.center.x, 0.0001);
Assert.AreEqual(boundPosition.y + objectPosition.y, renderer.bounds.center.y, 0.0001);
Assert.AreEqual(boundPosition.z + objectPosition.z, renderer.bounds.center.z, 0.0001);
}
else if ((VFXCoordinateSpace)systemSpace == VFXCoordinateSpace.World && (VFXCoordinateSpace)boundSpace == VFXCoordinateSpace.World)
{
Assert.IsTrue(parentFromCenter.Count(o => o.operation == VFXExpressionOperation.WorldToLocal) == 1);
//object position has no influence in that case
Assert.AreEqual(boundPosition.x, renderer.bounds.center.x, 0.0001);
Assert.AreEqual(boundPosition.y, renderer.bounds.center.y, 0.0001);
Assert.AreEqual(boundPosition.z, renderer.bounds.center.z, 0.0001);
}
else if ((VFXCoordinateSpace)systemSpace == VFXCoordinateSpace.Local && (VFXCoordinateSpace)boundSpace == VFXCoordinateSpace.World)
{
Assert.IsTrue(parentFromCenter.Count(o => o.operation == VFXExpressionOperation.WorldToLocal) == 1);
//object position has no influence in that case
Assert.AreEqual(boundPosition.x, renderer.bounds.center.x, 0.0001);
Assert.AreEqual(boundPosition.y, renderer.bounds.center.y, 0.0001);
Assert.AreEqual(boundPosition.z, renderer.bounds.center.z, 0.0001);
}
else
{
//Unknown case, should not happen
Assert.IsFalse(true);
}
yield return(new ExitPlayMode());
}
public IEnumerator Create_Prefab_Switch_To_Empty_VisualEffectAsset()
{
var graph = VFXTestCommon.MakeTemporaryGraph();
const int systemCount = 3;
for (int i = 0; i < systemCount; ++i)
{
Add_Valid_System(graph);
}
AssetDatabase.ImportAsset(AssetDatabase.GetAssetPath(graph));
var mainObject = MakeTemporaryGameObject();
GameObject prefabInstanceObject;
{
var tempVFX = mainObject.AddComponent <VisualEffect>();
tempVFX.visualEffectAsset = graph.visualEffectResource.asset;
GameObject newGameObject;
MakeTemporaryPrebab(mainObject, out newGameObject, out prefabInstanceObject);
GameObject.DestroyImmediate(mainObject);
mainObject = PrefabUtility.InstantiatePrefab(prefabInstanceObject) as GameObject;
}
yield return(null);
var vfx = mainObject.GetComponent <VisualEffect>();
var vfxInPrefab = prefabInstanceObject.GetComponent <VisualEffect>();
var systemNames = new List <string>();
systemNames.Clear();
vfx.GetSystemNames(systemNames);
Assert.AreEqual(systemCount * 2, systemNames.Count);
systemNames.Clear();
vfxInPrefab.GetSystemNames(systemNames);
Assert.AreEqual(systemCount * 2, systemNames.Count);
while (!vfx.isActiveAndEnabled)
{
yield return(null);
}
yield return(null);
{
//vfxInPrefab.visualEffectAsset = null; //Doesn't cover awake from load beahavior which is the most common
//modifying prefab using serialized property
var editor = Editor.CreateEditor(vfxInPrefab);
editor.serializedObject.Update();
var assetProperty = editor.serializedObject.FindProperty("m_Asset");
assetProperty.objectReferenceValue = null;
editor.serializedObject.ApplyModifiedPropertiesWithoutUndo();
GameObject.DestroyImmediate(editor);
EditorUtility.SetDirty(prefabInstanceObject);
}
PrefabUtility.SavePrefabAsset(prefabInstanceObject); //It will crash !
yield return(null);
systemNames.Clear();
vfx.GetSystemNames(systemNames);
Assert.AreEqual(0u, systemNames.Count);
systemNames.Clear();
vfxInPrefab.GetSystemNames(systemNames);
Assert.AreEqual(0u, systemNames.Count);
Assert.IsTrue(true); //Should not have crashed here
}
public IEnumerator TestBoundsHelperResults([ValueSource(nameof(availableSpaces))] object systemSpace)
{
string kSourceAsset = "Assets/AllTests/Editor/Tests/VFXBoundsHelperTest.vfx";
var graph = VFXTestCommon.CopyTemporaryGraph(kSourceAsset);
VFXCoordinateSpace space = (VFXCoordinateSpace)systemSpace;
graph.children.OfType <VFXBasicInitialize>().First().space = space;
var gameObj = new GameObject("GameObjectToCheck");
gameObj.transform.position = m_Translation;
gameObj.transform.rotation = m_Rotation;
gameObj.transform.localScale = m_Scale;
var vfxComponent = gameObj.AddComponent <VisualEffect>();
vfxComponent.visualEffectAsset = graph.visualEffectResource.asset;
VFXViewWindow window = EditorWindow.GetWindow <VFXViewWindow>();
VFXView view = window.graphView;
VFXViewController controller = VFXViewController.GetController(vfxComponent.visualEffectAsset.GetResource(), true);
view.controller = controller;
view.attachedComponent = vfxComponent;
VFXBoundsRecorder boundsRecorder = new VFXBoundsRecorder(vfxComponent, view);
boundsRecorder.ToggleRecording();
vfxComponent.Simulate(1.0f / 60.0f);
const int maxFrameTimeout = 100;
for (int i = 0; i < maxFrameTimeout; i++)
{
boundsRecorder.UpdateBounds();
if (boundsRecorder.bounds.Count > 0)
{
break;
}
yield return(null); //skip a frame.
}
boundsRecorder.ToggleRecording();
Bounds bounds = boundsRecorder.bounds.FirstOrDefault().Value;
boundsRecorder.CleanUp();
Vector3 expectedCenter = Vector3.zero;
Vector3 expectedExtent = new Vector3(2.0f, 2.0f, 2.0f);
expectedExtent += 0.5f * m_ParticleSize * (space == VFXCoordinateSpace.Local
? Mathf.Sqrt(3.0f)
: Mathf.Sqrt(1.0f / Mathf.Pow(m_Scale.x, 2) + 1.0f / Mathf.Pow(m_Scale.y, 2) + 1.0f / Mathf.Pow(m_Scale.z, 2)));
Assert.AreEqual(expectedCenter.x, bounds.center.x, .002);
Assert.AreEqual(expectedCenter.y, bounds.center.y, .002);
Assert.AreEqual(expectedCenter.z, bounds.center.z, .002);
Assert.AreEqual(expectedExtent.x, bounds.extents.x, .005);
Assert.AreEqual(expectedExtent.y, bounds.extents.y, .005);
Assert.AreEqual(expectedExtent.z, bounds.extents.z, .005);
view.attachedComponent = null;
window.Close();
yield return(null);
}
