public void CopySceneCacheToStreamingAssets()
{
//Initial setup
const string DEST_PREFAB_PATH = "Assets/TestSceneCache.prefab";
const string ASSETS_FOLDER = "Assets/TestSceneCacheAssets";
string destFolder = Path.Combine(Application.streamingAssetsPath, "TestRunner");
string streamingAssetsPath = Path.Combine(destFolder, "Copied.sc");
bool prefabCreated = SceneCachePlayerEditorUtility.CreateSceneCachePlayerAndPrefab(
Path.GetFullPath(MeshSyncTestEditorConstants.CUBE_TEST_DATA_PATH), DEST_PREFAB_PATH, ASSETS_FOLDER,
out SceneCachePlayer player, out GameObject prefab
);
Assert.IsTrue(prefabCreated);
//Copy
Directory.CreateDirectory(destFolder);
File.Copy(player.GetSceneCacheFilePath(), streamingAssetsPath);
Assert.IsTrue(File.Exists(streamingAssetsPath));
AssetDatabase.Refresh();
SceneCachePlayerEditorUtility.ChangeSceneCacheFile(player, streamingAssetsPath);
string convertedPath = streamingAssetsPath.Replace('\\', '/');
Assert.AreEqual(convertedPath, player.GetSceneCacheFilePath());
//Cleanup
Object.DestroyImmediate(player.gameObject);
DeleteSceneCachePlayerPrefab(prefab);
AssetDatabase.DeleteAsset(AssetUtility.NormalizeAssetPath(streamingAssetsPath));
AssetDatabase.DeleteAsset(AssetUtility.NormalizeAssetPath(destFolder));
AssetDatabase.Refresh();
}
public void ChangeSceneCacheOnInstancedPrefab()
{
//Initial setup
const string DEST_PREFAB_PATH = "Assets/TestSceneCache.prefab";
const string ASSETS_FOLDER = "Assets/TestSceneCacheAssets";
bool prefabCreated = SceneCachePlayerEditorUtility.CreateSceneCachePlayerAndPrefab(
Path.GetFullPath(MeshSyncTestEditorConstants.CUBE_TEST_DATA_PATH), DEST_PREFAB_PATH, ASSETS_FOLDER,
out SceneCachePlayer player, out GameObject prefab
);
Assert.IsTrue(prefabCreated);
//Check the instanced prefab
Assert.IsNotNull(player);
Assert.IsTrue(player.gameObject.IsPrefabInstance());
//Change
string newSceneCacheFilePath = Path.GetFullPath(MeshSyncTestEditorConstants.SPHERE_TEST_DATA_PATH);
SceneCachePlayerEditorUtility.ChangeSceneCacheFile(player, newSceneCacheFilePath);
string convertedPath = newSceneCacheFilePath.Replace('\\', '/');
Assert.IsTrue(player.IsSceneCacheOpened());
Assert.AreEqual(convertedPath, player.GetSceneCacheFilePath());
//Cleanup
Object.DestroyImmediate(player.gameObject);
DeleteSceneCachePlayerPrefab(prefab);
}
//----------------------------------------------------------------------------------------------------------------------
private void CreateAndDeleteSceneCachePlayerPrefab(string sceneCachePath)
{
Assert.IsTrue(File.Exists(sceneCachePath));
const string DEST_PREFAB_PATH = "Assets/TestSceneCache.prefab";
const string ASSETS_FOLDER = "Assets/TestSceneCacheAssets";
bool prefabCreated = SceneCachePlayerEditorUtility.CreateSceneCachePlayerAndPrefab(
Path.GetFullPath(sceneCachePath), DEST_PREFAB_PATH, ASSETS_FOLDER,
out SceneCachePlayer player, out GameObject prefab
);
Assert.IsTrue(prefabCreated);
//Check player
Assert.IsNotNull(player);
Assert.IsTrue(player.IsSceneCacheOpened());
Assert.IsTrue(player.gameObject.IsPrefabInstance());
//Check the prefab
Assert.IsNotNull(prefab);
string prefabPath = AssetDatabase.GetAssetPath(prefab);
Assert.IsFalse(string.IsNullOrEmpty(prefabPath));
Assert.AreEqual(DEST_PREFAB_PATH, prefabPath);
DeleteSceneCachePlayerPrefab(prefab);
}
public void ChangeSceneCacheOnDirectPrefab()
{
//Initial setup
const string DEST_PREFAB_PATH = "Assets/TestSceneCache.prefab";
const string ASSETS_FOLDER = "Assets/TestSceneCacheAssets";
bool prefabCreated = SceneCachePlayerEditorUtility.CreateSceneCachePlayerAndPrefab(
Path.GetFullPath(MeshSyncTestEditorConstants.CUBE_TEST_DATA_PATH), DEST_PREFAB_PATH, ASSETS_FOLDER,
out SceneCachePlayer player, out GameObject prefab
);
Assert.IsTrue(prefabCreated);
//Check the prefab
Assert.IsFalse(prefab.IsPrefabInstance());
Assert.IsTrue(prefab.IsPrefab());
SceneCachePlayer prefabPlayer = prefab.GetComponent <SceneCachePlayer>();
Assert.IsNotNull(prefabPlayer);
Camera cam0 = prefabPlayer.GetComponentInChildren <Camera>();
Light light0 = prefabPlayer.GetComponentInChildren <Light>();
//Change
TestDataComponents comps = ChangeSceneCacheFileAndVerify(prefabPlayer,
Path.GetFullPath(MeshSyncTestEditorConstants.SPHERE_TEST_DATA_PATH)
);
Assert.AreEqual(cam0, comps.cam);
Assert.AreEqual(light0, comps.light);
//Cleanup
Object.DestroyImmediate(player.gameObject);
DeleteSceneCachePlayerPrefab(prefab);
}
public void ChangeSceneCacheOnGameObject()
{
//Initial setup
SceneCachePlayer player = new GameObject("SceneCache").AddComponent <SceneCachePlayer>();
Assert.IsFalse(player.IsSceneCacheOpened());
//Change
SceneCachePlayerEditorUtility.ChangeSceneCacheFile(player, Path.GetFullPath(MeshSyncTestEditorConstants.CUBE_TEST_DATA_PATH));
Assert.IsTrue(player.IsSceneCacheOpened());
Camera cam0 = player.GetComponentInChildren <Camera>();
Light light0 = player.GetComponentInChildren <Light>();
SceneCachePlayerEditorUtility.ChangeSceneCacheFile(player, Path.GetFullPath(MeshSyncTestEditorConstants.SPHERE_TEST_DATA_PATH));
Assert.IsTrue(player.IsSceneCacheOpened());
Camera cam1 = player.GetComponentInChildren <Camera>();
Light light1 = player.GetComponentInChildren <Light>();
Assert.IsNotNull(cam0);
Assert.IsNotNull(light0);
Assert.AreEqual(cam0, cam1);
Assert.AreEqual(light0, light1);
Object.DestroyImmediate(player.gameObject); //Cleanup
}
private static SceneCachePlayer CreateTestSceneCachePlayer()
{
GameObject sceneCacheGo = new GameObject();
SceneCachePlayer sceneCachePlayer = sceneCacheGo.AddComponent <SceneCachePlayer>();
SceneCachePlayerEditorUtility.ChangeSceneCacheFile(sceneCachePlayer, Path.GetFullPath(MeshSyncTestEditorConstants.CUBE_TEST_DATA_PATH));
return(sceneCachePlayer);
}
public IEnumerator CreatePlayableAsset()
{
EditorSceneManager.NewScene(NewSceneSetup.DefaultGameObjects);
//Add director
GameObject directorGo = new GameObject("Director");
PlayableDirector director = directorGo.AddComponent <PlayableDirector>();
//Setup scene cache
GameObject sceneCacheGo = new GameObject();
SceneCachePlayer sceneCachePlayer = sceneCacheGo.AddComponent <SceneCachePlayer>();
Assert.IsFalse(sceneCachePlayer.IsSceneCacheOpened());
SceneCachePlayerEditorUtility.ChangeSceneCacheFile(sceneCachePlayer, Path.GetFullPath(MeshSyncTestEditorConstants.CUBE_TEST_DATA_PATH));
//Create timeline asset
TimelineAsset asset = ScriptableObject.CreateInstance <TimelineAsset>();
director.playableAsset = asset;
//Create PlayableAsset/Track/ etc
SceneCachePlayableAsset playableAsset = ScriptableObject.CreateInstance <SceneCachePlayableAsset>();
SceneCacheTrack sceneCacheTrack = asset.CreateTrack <SceneCacheTrack>(null, "TestSceneCacheTrack");
TimelineClip clip = sceneCacheTrack.CreateDefaultClip();
clip.asset = playableAsset;
director.SetReferenceValue(playableAsset.GetSceneCachePlayerRef().exposedName, sceneCachePlayer);
//Select gameObject and open Timeline Window. This will trigger the TimelineWindow's update etc.
EditorApplication.ExecuteMenuItem("Window/Sequencing/Timeline");
Selection.activeTransform = directorGo.transform;
yield return(null);
director.time = 0;
yield return(null);
Assert.AreEqual(0, sceneCachePlayer.GetRequestedNormalizedTime());
double timePerFrame = 1.0f / sceneCacheTrack.timelineAsset.editorSettings.fps;
double directorTime = clip.start + clip.duration - timePerFrame;
SetDirectorTime(director, directorTime);
yield return(null);
//Check clipData and curve
SceneCacheClipData clipData = playableAsset.GetBoundClipData();
Assert.IsNotNull(clipData);
AnimationCurve curve = clipData.GetAnimationCurve();
Assert.IsNotNull(curve);
float normalizedTime = curve.Evaluate((float)directorTime);
Assert.AreEqual(normalizedTime, sceneCachePlayer.GetRequestedNormalizedTime());
}
//----------------------------------------------------------------------------------------------------------------------
private static void InitTest(bool enableSceneCacheGo, out PlayableDirector director,
out SceneCachePlayer sceneCachePlayer, out TimelineClip clip)
{
EditorSceneManager.NewScene(NewSceneSetup.DefaultGameObjects);
director = CreateTestDirector();
sceneCachePlayer = CreateTestSceneCachePlayer();
sceneCachePlayer.gameObject.SetActive(enableSceneCacheGo);
clip = SceneCachePlayerEditorUtility.AddSceneCacheTrackAndClip(director, "TestSceneCacheTrack", sceneCachePlayer);
TimelineEditorUtility.SelectDirectorInTimelineWindow(director); //trigger the TimelineWindow's update etc.
TimelineEditorUtility.RefreshTimelineEditor();
}
public void ChangeSceneCacheOnInstancedPrefab()
{
//Initial setup
const string DEST_PREFAB_PATH = "Assets/TestSceneCache.prefab";
const string ASSETS_FOLDER = "Assets/TestSceneCacheAssets";
bool prefabCreated = SceneCachePlayerEditorUtility.CreateSceneCachePlayerAndPrefab(
Path.GetFullPath(MeshSyncTestEditorConstants.CUBE_TEST_DATA_PATH), DEST_PREFAB_PATH, ASSETS_FOLDER,
out SceneCachePlayer player, out GameObject prefab
);
Assert.IsTrue(prefabCreated);
//Check the instanced prefab
Assert.IsNotNull(player);
Assert.IsTrue(player.gameObject.IsPrefabInstance());
Camera cam0 = player.GetComponentInChildren <Camera>();
Light light0 = player.GetComponentInChildren <Light>();
MeshRenderer mr0 = player.GetComponentInChildren <MeshRenderer>();
Assert.IsNotNull(cam0);
Assert.IsNotNull(light0);
Assert.IsNotNull(mr0);
GameObject capsule = GameObject.CreatePrimitive(PrimitiveType.Capsule);
capsule.transform.SetParent(light0.transform);
GameObject cylinder = GameObject.CreatePrimitive(PrimitiveType.Cylinder);
cylinder.transform.SetParent(mr0.transform);
//Change
TestDataComponents comps = ChangeSceneCacheFileAndVerify(player, Path.GetFullPath(MeshSyncTestEditorConstants.SPHERE_TEST_DATA_PATH));
Assert.IsTrue(player.IsSceneCacheOpened());
Assert.AreEqual(cam0, comps.cam);
Assert.AreEqual(light0, comps.light);
Assert.AreNotEqual(mr0, comps.meshRenderer);
Assert.IsTrue(capsule != null);
Assert.IsFalse(capsule.IsPrefabInstance());
Assert.IsTrue(cylinder == null); //should have been deleted when changing sc
//Cleanup
Object.DestroyImmediate(player.gameObject);
DeleteSceneCachePlayerPrefab(prefab);
}
public void ChangeSceneCacheOnGameObject()
{
//Initial setup
GameObject go = new GameObject();
SceneCachePlayer player = go.AddComponent <SceneCachePlayer>();
Assert.IsFalse(player.IsSceneCacheOpened());
//Change
SceneCachePlayerEditorUtility.ChangeSceneCacheFile(player, Path.GetFullPath(MeshSyncTestEditorConstants.CUBE_TEST_DATA_PATH));
Assert.IsTrue(player.IsSceneCacheOpened());
SceneCachePlayerEditorUtility.ChangeSceneCacheFile(player, Path.GetFullPath(MeshSyncTestEditorConstants.SPHERE_TEST_DATA_PATH));
Assert.IsTrue(player.IsSceneCacheOpened());
//Cleanup
Object.DestroyImmediate(go);
}
public IEnumerator ReloadSceneCache()
{
SceneCachePlayer player = new GameObject("SceneCache").AddComponent <SceneCachePlayer>();
//Set and reload
SceneCachePlayerEditorUtility.ChangeSceneCacheFile(player, Path.GetFullPath(MeshSyncTestEditorConstants.CUBE_TEST_DATA_PATH));
Assert.IsTrue(player.IsSceneCacheOpened());
yield return(null);
SceneCachePlayerEditorUtility.ReloadSceneCacheFile(player);
Assert.IsTrue(player.transform.childCount > 0);
Assert.IsTrue(player.IsSceneCacheOpened());
yield return(null);
Object.DestroyImmediate(player.gameObject); //Cleanup
}
//----------------------------------------------------------------------------------------------------------------------
static TestDataComponents ChangeSceneCacheFileAndVerify(SceneCachePlayer player, string scPath)
{
SceneCachePlayerEditorUtility.ChangeSceneCacheFile(player, scPath);
string savedScFilePath = player.GetSceneCacheFilePath();
Assert.AreEqual(AssetEditorUtility.NormalizePath(scPath), savedScFilePath);
Assert.IsTrue(AssetEditorUtility.IsPathNormalized(savedScFilePath), $"{savedScFilePath} is not normalized");
Assert.IsTrue(player.transform.childCount > 0);
TestDataComponents ret = new TestDataComponents(
player.GetComponentInChildren <Camera>(),
player.GetComponentInChildren <Light>(),
player.GetComponentInChildren <MeshRenderer>()
);
Assert.IsNotNull(ret.cam);
Assert.IsNotNull(ret.light);
Assert.IsNotNull(ret.meshRenderer);
return(ret);
}
public IEnumerator CheckGameObjectActiveStateReferredInMultipleTracks()
{
InitTest(true, out PlayableDirector director, out SceneCachePlayer sceneCachePlayer, out TimelineClip clip0);
yield return(null);
TimelineClip clip1 = SceneCachePlayerEditorUtility.AddSceneCacheTrackAndClip(director, "TestSceneCacheTrack 1", sceneCachePlayer);
clip1.start = clip0.end;
TimelineEditorUtility.RefreshTimelineEditor(RefreshReason.ContentsAddedOrRemoved);
yield return(null);
GameObject scGameObject = sceneCachePlayer.gameObject;
SetDirectorTime(director, clip0.start);
yield return(null);
Assert.IsTrue(scGameObject.activeSelf);
SetDirectorTime(director, clip1.start + clip1.duration * 0.5f);
yield return(null);
Assert.IsTrue(scGameObject.activeSelf);
}
