protected override void OnInvalidate(VFXModel model, InvalidationCause cause)
{
if (cause == InvalidationCause.kSettingChanged || cause == InvalidationCause.kExpressionInvalidated)
{
if (cause == InvalidationCause.kSettingChanged)
{
if (m_Subgraph != null)
{
var graph = GetGraph();
if (graph != null) // that case it will be checked in OnAdded
{
var otherGraph = m_Subgraph.GetResource().GetOrCreateGraph();
if (otherGraph == graph || otherGraph.subgraphDependencies.Contains(graph.GetResource().visualEffectObject))
{
m_Subgraph = null; // prevent cyclic dependencies.
}
}
}
if (m_Subgraph != null || object.ReferenceEquals(m_Subgraph, null) || m_UsedSubgraph == null || m_UsedSubgraph != m_Subgraph.GetResource().GetOrCreateGraph()) // do not recreate subchildren if the subgraph is not available but is not null
{
RecreateCopy();
}
}
base.OnInvalidate(model, cause);
PatchInputExpressions();
}
else
{
base.OnInvalidate(model, cause);
}
}
private void CheckAsset(VisualEffectAsset asset)
{
VisualEffectResource resource = asset.GetResource();
var graph = resource.GetOrCreateGraph();
Assert.AreEqual(6, graph.GetNbChildren());
Assert.AreEqual(1, graph[0].GetNbChildren());
Assert.AreEqual(1, graph[1].GetNbChildren());
Assert.AreEqual(1, graph[2].GetNbChildren());
Assert.AreEqual(0, graph[3].GetNbChildren());
Assert.AreEqual(0, graph[4].GetNbChildren());
Assert.AreEqual(0, graph[5].GetNbChildren());
Assert.IsNotNull((graph[0])[0]);
Assert.IsNotNull((graph[1])[0]);
Assert.IsNotNull((graph[2])[0]);
Assert.AreEqual(VFXContextType.Init, ((VFXContext)(graph[0])).contextType);
Assert.AreEqual(VFXContextType.Update, ((VFXContext)(graph[1])).contextType);
Assert.AreEqual(VFXContextType.Output, ((VFXContext)(graph[2])).contextType);
Assert.AreEqual(VFXContextType.Init, ((VFXContext)(graph[3])).contextType);
Assert.AreEqual(VFXContextType.Output, ((VFXContext)(graph[4])).contextType);
Assert.IsNotNull(graph[5] as Operator.Add);
}
public override void OnInspectorGUI()
{
AssetField();
bool reinit = SeedField();
var component = (VisualEffect)target;
//Display properties only if all the VisualEffects share the same graph
VisualEffectAsset asset = component.visualEffectAsset;
if (targets.Length > 1)
{
foreach (VisualEffect effect in targets)
{
if (effect.visualEffectAsset != asset)
{
return;
}
}
}
EditorModeInspectorButton();
DrawRendererProperties();
DrawParameters();
serializedObject.ApplyModifiedProperties();
if (reinit)
{
component.Reinit();
}
GUI.enabled = true;
}
VFXEffectTypeData RegisterImpactType(VisualEffectAsset template)
{
if (template == null)
{
throw new System.Exception("VFX Template is null");
}
if (mEffectTypeData.ContainsKey(template))
{
throw new System.Exception("mEffectTypeData Contains template");
}
GameObject go = new GameObject(template.name);
go.transform.parent = m_RootGameObject.transform;
go.transform.position = Vector3.zero;
go.transform.rotation = Quaternion.identity;
go.transform.localScale = Vector3.one;
var vfx = go.AddComponent <VisualEffect>();
vfx.visualEffectAsset = template;
vfx.Reinit();
vfx.Stop();
var data = new VFXEffectTypeData
{
Effect = vfx,
EventAttribute = vfx.CreateVFXEventAttribute(),
};
mEffectTypeData.Add(template, data);
return(data);
}
EffectTypeData RegisterImpactType(VisualEffectAsset template)
{
GameDebug.Assert(!m_EffectTypeData.ContainsKey(template));
GameDebug.Assert(!template != null);
GameObject go = new GameObject(template.name);
go.transform.parent = m_rootGameObject.transform;
go.transform.position = Vector3.zero;
go.transform.rotation = Quaternion.identity;
go.transform.localScale = Vector3.one;
var vfx = go.AddComponent <VisualEffect>();
vfx.visualEffectAsset = template;
vfx.Reinit();
vfx.Stop();
var data = new EffectTypeData
{
visualEffect = vfx,
eventAttribute = vfx.CreateVFXEventAttribute(),
};
m_EffectTypeData.Add(template, data);
return(data);
}
private void InnerSaveAndReloadTest(string suffixname, Action<VisualEffectAsset> write, Action<VisualEffectAsset> read)
{
var kTempAssetPathA = string.Format("{0}/Temp_{1}_A.vfx", kTestAssetDir, suffixname);
var kTempAssetPathB = string.Format("{0}/Temp_{1}_B.vfx", kTestAssetDir, suffixname);
AssetDatabase.DeleteAsset(kTempAssetPathA);
AssetDatabase.DeleteAsset(kTempAssetPathB);
int hashCodeAsset = 0; //check reference are different between load & reload
{
var asset = CreateAssetAtPath(kTempAssetPathA);
hashCodeAsset = asset.GetHashCode();
write(asset);
asset.GetResource().UpdateSubAssets();
AssetDatabase.SaveAssets();
asset = null;
EditorUtility.UnloadUnusedAssetsImmediate();
AssetDatabase.CopyAsset(kTempAssetPathA, kTempAssetPathB);
if (asset != null)
AssetDatabase.RemoveObjectFromAsset(asset);
}
AssetDatabase.Refresh(ImportAssetOptions.ForceUpdate);
EditorUtility.UnloadUnusedAssetsImmediate();
{
VisualEffectAsset asset = AssetDatabase.LoadAssetAtPath<VisualEffectAsset>(kTempAssetPathB);
Assert.AreNotEqual(hashCodeAsset, asset.GetHashCode());
read(asset);
}
AssetDatabase.DeleteAsset(kTempAssetPathA);
AssetDatabase.DeleteAsset(kTempAssetPathB);
}
public void SpawnPointEffect(VisualEffectAsset asset, float3 position, float3 normal)
{
m_pointEffectRequests.Add(new PointEffectRequest
{
asset = asset,
position = position,
normal = normal,
});
}
public void SpawnLineEffect(VisualEffectAsset asset, float3 start, float3 end)
{
m_lineEffectRequests.Add(new LineEffectRequest
{
asset = asset,
start = start,
end = end,
});
}
public void SpawnVFX(Vector3 position, VisualEffectAsset effectToSpawn)
{
if (visualEffect = null)
{
visualEffect = gameObject.AddComponent <VisualEffect>();
}
visualEffect.visualEffectAsset = effectToSpawn;
Destroy(visualEffect, 1f);
}
public void UpdateEffect(VisualEffectAsset newEffect)
{
Debug.Log("Update Effect");
effect.visualEffectAsset = newEffect;
effect.SetTexture("PositionMap", positionMap);
effect.SetTexture("ColorMap", colorMap);
effect.Reinit();
}
public static VisualEffect SpawnOneShot(GameObject visualEffectGraphPrefab, VisualEffectAsset visualAsset, Vector3 posistion, Quaternion rotation, Transform parent = null)
{
VisualEffect vfx = ObjectPool.Instantiate(visualEffectGraphPrefab, posistion, rotation, parent).GetComponent <VisualEffect>();
vfx.visualEffectAsset = visualAsset;
_instance.StartCoroutine(PlayParticleOneShot(vfx));
return(vfx);
}
public void SpawnPointEffect(VisualEffectAsset asset, float3 position, float3 direction)
{
m_pointEffectRequests.Add(new PointEffectRequest
{
asset = asset,
position = position,
direction = direction,
});
}
void GraphParameterChanged(VFXGraph graph)
{
VisualEffectAsset asset = graph != null && graph.GetResource() != null?graph.GetResource().asset : null;
if (m_Subgraph == asset && GetParent() != null)
{
RecreateCopy();
}
}
public void OneTimeSetUpAttribute()
{
string[] guids = AssetDatabase.FindAssets(kTestAssetName, new string[] { kTestAssetDir });
// If the asset does not exist, create it
if (guids.Length == 0)
{
VisualEffectAsset asset = CreateAssetAtPath(kTestAssetPath);
InitAsset(asset);
}
}
GameObject SpawnEffectOnPlayer(VisualEffectAsset template)
{
GameObject effect = new GameObject(template.name);
effect.transform.position = character.gameObject.transform.position;
effect.transform.rotation = character.gameObject.transform.rotation;
effect.transform.parent = character.gameObject.transform;
var vfx = effect.AddComponent <VisualEffect>();
vfx.visualEffectAsset = template;
return(effect);
}
void RefreshSubgraphObject()
{
if (m_Subgraph == null && !object.ReferenceEquals(m_Subgraph, null))
{
string assetPath = AssetDatabase.GetAssetPath(m_Subgraph.GetInstanceID());
var newSubgraph = AssetDatabase.LoadAssetAtPath <VisualEffectAsset>(assetPath);
if (newSubgraph != null)
{
m_Subgraph = newSubgraph;
}
}
}
public void LoadAsset(VisualEffectAsset asset, VisualEffect effectToAttach)
{
string assetPath = AssetDatabase.GetAssetPath(asset);
VisualEffectResource resource = VisualEffectResource.GetResourceAtPath(assetPath);
//Transitionning code
if (resource == null)
{
resource = new VisualEffectResource();
resource.SetAssetPath(AssetDatabase.GetAssetPath(asset));
}
LoadResource(resource, effectToAttach);
}
public static VisualEffectResource GetResource(this VisualEffectAsset asset)
{
VisualEffectResource resource = VisualEffectResource.GetResourceAtPath(AssetDatabase.GetAssetPath(asset));
if (resource == null)
{
string assetPath = AssetDatabase.GetAssetPath(asset);
resource = VisualEffectResource.GetResourceAtPath(assetPath);
if (resource == null)
{
resource = new VisualEffectResource();
resource.SetAssetPath(assetPath);
}
}
return(resource);
}
void SpawnPointEffect(VisualEffectAsset asset, Vector3 position, Vector3 normal)
{
VFXEffectTypeData effectData;
if (!mEffectTypeData.TryGetValue(asset, out effectData))
{
effectData = RegisterImpactType(asset);
}
effectData.Effect.SetVector3(startPositionId, position);
Quaternion Rotation = Quaternion.FromToRotation(Vector3.back, normal);
Vector3 rot = Rotation.eulerAngles;
effectData.Effect.SetVector3("Direction", rot);
effectData.Effect.Play(effectData.EventAttribute);
effectData.Effect.pause = false;
}
protected override void OnAdded()
{
base.OnAdded();
if (m_Subgraph != null)
{
var graph = GetGraph();
if (graph != null)
{
var otherGraph = m_Subgraph.GetResource().GetOrCreateGraph();
if (otherGraph == graph || otherGraph.subgraphDependencies.Contains(graph.GetResource().visualEffectObject))
{
m_Subgraph = null; // prevent cyclic dependencies.
}
}
}
}
VFXGraph MakeTemporaryGraph()
{
m_Asset = VisualEffectResource.CreateNewAsset(tempFilePath);
VisualEffectResource resource = m_Asset.GetResource(); // force resource creation
VFXGraph graph = ScriptableObject.CreateInstance<VFXGraph>();
graph.visualEffectResource = resource;
var window = EditorWindow.GetWindow<VFXViewWindow>();
window.Close();
window = EditorWindow.GetWindow<VFXViewWindow>();
m_ViewController = VFXViewController.GetController(m_Asset.GetResource(), true);
m_View = window.graphView;
m_View.controller = m_ViewController;
return graph;
}
public static void RebuildVisualEffectAsset(VisualEffectAsset vfx)
{
//We are in Assembly-CSharp-Editor, we don't want to be friend of this namespace
var visualEffectAssetExt = AppDomain.CurrentDomain.GetAssemblies().Select(o => o.GetType("UnityEditor.VFX.VisualEffectAssetExtensions"))
.Where(o => o != null)
.FirstOrDefault();
var fnGetResource = visualEffectAssetExt.GetMethod("GetResource");
fnGetResource = fnGetResource.MakeGenericMethod(new Type[] { typeof(VisualEffectAsset) });
var resource = fnGetResource.Invoke(null, new object[] { vfx });
var fnGetOrCreate = visualEffectAssetExt.GetMethod("GetOrCreateGraph");
var graph = fnGetOrCreate.Invoke(null, new object[] { resource });
var fnRecompileIfNeeded = graph.GetType().GetMethod("RecompileIfNeeded");
fnRecompileIfNeeded.Invoke(graph, new object[] { false, false });
}
public void CreateTestAsset(string name)
{
var filePath = string.Format(testAssetName, name);
var directoryPath = Path.GetDirectoryName(filePath);
if (!Directory.Exists(directoryPath))
{
Directory.CreateDirectory(directoryPath);
}
m_Asset = VisualEffectResource.CreateNewAsset(filePath);
VFXViewWindow window = EditorWindow.GetWindow <VFXViewWindow>();
window.Close();
window = EditorWindow.GetWindow <VFXViewWindow>();
m_ViewController = VFXViewController.GetController(m_Asset.GetResource(), true);
window.graphView.controller = m_ViewController;
}
public static void MigrateComponentsCurrentScnene()
{
HashSet <GameObject> prefabs = new HashSet <GameObject>();
FileVFXComponents components = FindComponentsInScene(prefabs);
List <FileVFXComponents> prefabsInfos = new List <FileVFXComponents>();
foreach (var prefab in prefabs)
{
prefabsInfos.Add(FindComponentsInPrefab(prefab));
Debug.Log("Found prefab : " + AssetDatabase.GetAssetPath(prefab));
}
foreach (var path in components.componentPaths.Values.Union(prefabsInfos.SelectMany(t => t.componentPaths.Values)).Distinct())
{
VisualEffectAsset asset = AssetDatabase.LoadAssetAtPath <VisualEffectAsset>(path.assetPath);
if (asset == null)
{
AssetDatabase.ImportAsset(path.assetPath);
asset = AssetDatabase.LoadAssetAtPath <VisualEffectAsset>(path.assetPath);
}
if (asset != null)
{
var resource = asset.GetResource();
resource.ValidateAsset();
try
{
var graph = resource.GetOrCreateGraph();
graph.RecompileIfNeeded();
EditorUtility.SetDirty(graph);
}
catch (System.Exception e)
{
Debug.LogError("Couldn't resave vfx" + path.assetPath + " " + e.Message);
}
}
}
SetComponentsInScene(components);
EditorSceneManager.SaveScene(EditorSceneManager.GetSceneByPath(components.path));
}
public void CreateTestAsset()
{
var directoryPath = Path.GetDirectoryName(testAssetName);
if (!Directory.Exists(directoryPath))
{
Directory.CreateDirectory(directoryPath);
}
if (File.Exists(testAssetName))
{
AssetDatabase.DeleteAsset(testAssetName);
}
VisualEffectAsset asset = VisualEffectResource.CreateNewAsset(testAssetName);
VisualEffectResource resource = asset.GetResource(); // force resource creation
m_ViewController = VFXViewController.GetController(resource);
m_ViewController.useCount++;
m_StartUndoGroupId = Undo.GetCurrentGroup();
}
public override void Action(int instanceId, string pathName, string resourceFile)
{
try
{
var templateString = System.IO.File.ReadAllText(templatePath + templateAssetName);
System.IO.File.WriteAllText(pathName, templateString);
}
catch (FileNotFoundException)
{
CreateNewAsset(pathName);
}
AssetDatabase.ImportAsset(pathName);
VisualEffectAsset vfxAsset = AssetDatabase.LoadAssetAtPath <VisualEffectAsset>(pathName);
var graph = vfxAsset.GetResource().GetOrCreateGraph();
graph.SetExpressionGraphDirty();
graph.RecompileIfNeeded();
ProjectWindowUtil.FrameObjectInProjectWindow(vfxAsset.GetInstanceID());
}
private void InitAsset(VisualEffectAsset asset)
{
VisualEffectResource resource = asset.GetResource();
var graph = resource.GetOrCreateGraph();
graph.RemoveAllChildren();
var init0 = ScriptableObject.CreateInstance <VFXBasicInitialize>();
var update0 = ScriptableObject.CreateInstance <VFXBasicUpdate>();
var output0 = ScriptableObject.CreateInstance <VFXPointOutput>();
graph.AddChild(init0);
graph.AddChild(update0);
graph.AddChild(output0);
init0.LinkTo(update0);
update0.LinkTo(output0);
var init1 = ScriptableObject.CreateInstance <VFXBasicInitialize>();
var output1 = ScriptableObject.CreateInstance <VFXPointOutput>();
init1.LinkTo(output1);
graph.AddChild(init1);
graph.AddChild(output1);
// Add some block
var block0 = ScriptableObject.CreateInstance <InitBlockTest>();
var block1 = ScriptableObject.CreateInstance <UpdateBlockTest>();
var block2 = ScriptableObject.CreateInstance <OutputBlockTest>();
// Add some operator
VFXOperator add = ScriptableObject.CreateInstance <Operator.Add>();
init0.AddChild(block0);
update0.AddChild(block1);
output0.AddChild(block2);
graph.AddChild(add);
}
static void ResaveFolder(string dirPath)
{
foreach (var path in Directory.GetFiles(dirPath))
{
if (Path.GetExtension(path) == ".vfx")
{
VisualEffectAsset asset = AssetDatabase.LoadAssetAtPath <VisualEffectAsset>(path);
if (asset == null)
{
AssetDatabase.ImportAsset(path);
asset = AssetDatabase.LoadAssetAtPath <VisualEffectAsset>(path);
}
if (asset == null)
{
Debug.LogError("Couldn't Import vfx" + path);
}
var resource = asset.GetResource();
if (resource != null)
{
resource.ValidateAsset();
try
{
var graph = resource.GetOrCreateGraph();
graph.RecompileIfNeeded();
EditorUtility.SetDirty(graph);
}
catch (System.Exception e)
{
Debug.LogError("Couldn't resave vfx" + path + " " + e.Message);
}
}
}
}
foreach (var path in Directory.GetDirectories(dirPath))
{
ResaveFolder(path);
}
}
public void Initial_Space_Supposed_To_Be_Same_As_Context()
{
//Cover also case 1163442, this behavior only exists in controller
var directoryPath = Path.GetDirectoryName(testAssetName);
if (!Directory.Exists(directoryPath))
{
Directory.CreateDirectory(directoryPath);
}
if (File.Exists(testAssetName))
{
AssetDatabase.DeleteAsset(testAssetName);
}
VisualEffectAsset asset = VisualEffectAssetEditorUtility.CreateNewAsset(testAssetName);
var resource = asset.GetResource(); // force resource creation
var viewController = VFXViewController.GetController(resource);
viewController.useCount++;
var startUndoGroupId = Undo.GetCurrentGroup();
var updateContext = ScriptableObject.CreateInstance <VFXBasicUpdate>();
updateContext.space = VFXCoordinateSpace.World;
viewController.AddVFXModel(Vector2.zero, updateContext);
viewController.ApplyChanges();
viewController.ForceReload();
var collision = ScriptableObject.CreateInstance <CollisionSphere>();
var contextController = viewController.allChildren.OfType <VFXContextController>().First();
contextController.AddBlock(0, collision, true);
Assert.IsTrue(collision.inputSlots.Where(o => o.spaceable).All(o => o.space == VFXCoordinateSpace.World));
viewController.useCount--;
Undo.RevertAllDownToGroup(startUndoGroupId);
AssetDatabase.DeleteAsset(testAssetName);
}
private void ReadBasicOperators(VisualEffectAsset asset, bool spawnAbs, bool linkAbs)
{
VisualEffectResource resource = asset.GetResource();
var graph = resource.GetOrCreateGraph();
Assert.AreEqual(spawnAbs ? 2 : 1, graph.GetNbChildren());
Assert.IsNotNull((Operator.Add)graph[0]);
var add = (Operator.Add)graph[0];
CheckIsolatedOperatorAdd(add);
if (spawnAbs)
{
Assert.IsNotNull((Operator.Absolute)graph[1]);
var abs = (Operator.Absolute)graph[1];
CheckIsolatedOperatorAbs(abs);
Assert.AreEqual(abs.position.x, 64.0f);
Assert.AreEqual(abs.position.y, 64.0f);
if (linkAbs)
{
CheckConnectedAbs(abs);
}
}
}
