public void CreateSlide(string slideName)
{
CreateSlidesFolder();
GameObject s = new GameObject(slideName, typeof(PresentationSlide));
s.transform.SetParent(transform);
Undo.RegisterCreatedObjectUndo(s, "PresentationSlide Create");
AssetDatabase.CreateAsset(TimelineAsset.CreateInstance(typeof(TimelineAsset)), "Assets/SlidesTimeLine/" + slideName + ".playable");
if (!timelineDirector.GetComponent <Animator>())
{
timelineDirector.gameObject.AddComponent <Animator>();
}
timelineDirector.playableAsset = AssetDatabase.LoadAssetAtPath("Assets/SlidesTimeLine/" + slideName + ".playable", typeof(TimelineAsset)) as PlayableAsset;
// Add Animation Track
TrackAsset t = (timelineDirector.playableAsset as TimelineAsset).CreateTrack(typeof(AnimationTrack), null, "");
timelineDirector.SetGenericBinding(t, timelineDirector.GetComponent <Animator>());
// Fetch Slides
FindAllSlide();
// Add the new timeline to presentation manager
AddNewSlideTimeLine(timelineDirector.playableAsset);
}
public GameObject MakePlayableBaseObject(PlayableData playable, ref Context ctx, float start, float duration)
{
start += ctx.frameOffset / ctx.fps;
var hackyStart = Mathf.Max(0, start);
var clipIn = hackyStart - start;
start = hackyStart;
duration -= clipIn;
var playableObj = new GameObject(playable.displayName ?? "Layer");
playableObj.transform.parent = ctx.parentTransform;
playableObj.transform.localPosition = playable.transform.pos.V3;
playableObj.transform.localRotation = playable.transform.rot.Q;
playableObj.transform.localScale = playable.transform.scl.V3;
playableObj.SetActive(playable.isVisible);
var path = AnimationUtility.CalculateTransformPath(playableObj.transform, ctx.rootTransform);
var director = playableObj.AddComponent <PlayableDirector>();
var timelineAsset = TimelineAsset.CreateInstance <TimelineAsset>();
timelineAsset.name = path + "_Timeline";
timelineAsset.editorSettings.fps = stage.fps;
timelineAsset.durationMode = TimelineAsset.DurationMode.BasedOnClips;
timelineAsset.fixedDuration = start + duration;
ctx.ctx.AddObjectToAsset(timelineAsset.name, timelineAsset);
director.playableAsset = timelineAsset;
ctx.animator = playableObj.AddComponent <Animator>();
var controlTrack = ctx.parentTimeline.CreateTrack <AnimVR.Timeline.AnimControlTrack>(null, playableObj.name);
ctx.ctx.AddObjectToAsset(path + "_Control", controlTrack);
var controlClip = controlTrack.CreateDefaultClip();
controlClip.displayName = playableObj.name;
controlClip.start = start;
controlClip.duration = duration;
controlClip.clipIn = clipIn;
typeof(TimelineClip).GetProperty("preExtrapolationMode").SetValue(controlClip, TRIM_LOOP_MAPPING[playable.TrimLoopIn], null);
typeof(TimelineClip).GetProperty("postExtrapolationMode").SetValue(controlClip, TRIM_LOOP_MAPPING[playable.TrimLoopOut], null);
var controlAsset = controlClip.asset as AnimVR.Timeline.AnimControlPlayableAsset;
controlAsset.name = playable.name;
ctx.director.SetGenericBinding(controlAsset, playableObj);
ctx.ctx.AddObjectToAsset(path + "_ControlAsset", controlAsset);
ctx.parentTimeline = timelineAsset;
ctx.director = director;
ctx.parentTransform = playableObj.transform;
return(playableObj);
}
private void CreateSlide()
{
if (!presentationManager)
{
EditorUtility.DisplayDialog("Error", "please press setup button first", "OK");
return;
}
CreateSlidesFolder();
GameObject s = new GameObject(slideName, typeof(PresentationSlide));
s.transform.SetParent(presentationManager.transform);
Undo.RegisterCreatedObjectUndo(s, "PresentationSlide Create");
AssetDatabase.CreateAsset(TimelineAsset.CreateInstance(typeof(TimelineAsset)), "Assets/SlidesTimeLine/" + slideName + ".playable");
if (!playableDirector.GetComponent <Animator>())
{
playableDirector.gameObject.AddComponent <Animator>();
}
playableDirector.playableAsset = AssetDatabase.LoadAssetAtPath("Assets/SlidesTimeLine/" + slideName + ".playable", typeof(TimelineAsset)) as PlayableAsset;
// Add Animation Track
TrackAsset t = (playableDirector.playableAsset as TimelineAsset).CreateTrack(typeof(AnimationTrack), null, "");
playableDirector.SetGenericBinding(t, playableDirector.GetComponent <Animator>());
// Fetch Slides
presentationManager.FindAllSlide();
// Add the new timeline to presentation manager
presentationManager.AddNewSlideTimeLine(playableDirector.playableAsset);
}
static T Initialize <T>(string exportedFile)
where T : TimelineAsset
{
T type = AssetDatabase.LoadAssetAtPath <T>(exportedFile);
if (type == null)
{
type = TimelineAsset.CreateInstance <T>();
AssetDatabase.CreateAsset(type, exportedFile);
}
return(type);
}
public GameObject GenerateUnityObject(StageData stage, AssetImportContext ctx)
{
var stageObj = new GameObject(stage.name);
ctx.AddObjectToAsset(stage.name, stageObj, PreviewTexture);
ctx.SetMainObject(stageObj);
Context context = new Context();
context.fps = stage.fps;
context.parentTransform = context.rootTransform = stageObj.transform;
context.director = stageObj.AddComponent <PlayableDirector>();
context.director.extrapolationMode = Settings.DefaultWrapMode;
var timelineAsset = TimelineAsset.CreateInstance <TimelineAsset>();
timelineAsset.name = stage.name + "_Timeline";
timelineAsset.editorSettings.fps = stage.fps;
timelineAsset.durationMode = TimelineAsset.DurationMode.FixedLength;
timelineAsset.fixedDuration = stage.timelineLength * 1.0 / stage.fps;
ctx.AddObjectToAsset(timelineAsset.name, timelineAsset);
context.director.playableAsset = timelineAsset;
context.animator = stageObj.AddComponent <Animator>();
context.ctx = ctx;
context.parentTimeline = timelineAsset;
foreach (var symbol in stage.Symbols)
{
var symbolObj = GenerateUnityObject(symbol, context);
symbolObj.transform.SetParent(stageObj.transform, false);
if (Settings.ApplyStageTransform)
{
symbolObj.transform.localPosition += stage.transform.pos;
symbolObj.transform.localRotation *= stage.transform.rot;
var scl = symbolObj.transform.localScale;
var s = stage.transform.scl;
symbolObj.transform.localScale = new Vector3(scl.x * s.x, scl.y * s.y, scl.z * s.z);
}
}
//hacky fix cause fixed duration from code is broken
timelineAsset.fixedDuration = (stage.timelineLength - 1) * 1.0 / stage.fps;
return(stageObj);
}
static void CreateVLGameObject()
{
BMGMgrGo = GameObject.Find("BMGMgrGo");
if (BMGMgrGo == null)
{
BMGMgrGo = new GameObject("BMGMgrGo");
bgmPlayableDirector = BMGMgrGo.AddComponent <PlayableDirector>();
BMGMgrGo.AddComponent <AudioSource>();
}
else
{
bgmPlayableDirector = BMGMgrGo.GetComponent <PlayableDirector>();
}
if (!Directory.Exists(playableDir))
{
Directory.CreateDirectory(playableDir);
}
string playablePath = playableDir + playableName;
if (!File.Exists(playablePath))
{
var asset = TimelineAsset.CreateInstance <TimelineAsset>();
AssetDatabase.CreateAsset(asset, playablePath);
var track = asset.CreateTrack <AudioTrack>(null, "BgmTrack");
AssetDatabase.SaveAssets();
bgmPlayableDirector.playableAsset = asset;
}
else
{
TimelineAsset asset = AssetDatabase.LoadAssetAtPath <TimelineAsset>(playablePath);
bgmPlayableDirector.playableAsset = asset;
}
string json = File.ReadAllText(configFile);
config = JsonConvert.DeserializeObject <BGMConfig>(json);
BMGSwitchWindow _window = EditorWindow.GetWindow <BMGSwitchWindow>(); // 创建自定义窗体
_window.titleContent = new GUIContent("自动配乐"); // 窗口的标题
_window.minSize = new Vector2(250, 400);
_window.Show();
}
public static void CreatePlayableByJson(string jsonPath, string playablePath)
{
if (string.IsNullOrEmpty(jsonPath))
{
return;
}
if (string.IsNullOrEmpty(playablePath))
{
return;
}
var timelineData = SkillTimelineData.LoadFromFile(jsonPath);
if (timelineData != null)
{
var timelineAsset = TimelineAsset.CreateInstance <TimelineAsset>();
AssetDatabase.CreateAsset(timelineAsset, playablePath);
var playableInfo = timelineData.sequences[0];
foreach (var trackInfo in playableInfo.sequences)
{
var trackSequence = (SkillTimelineSequence)trackInfo;//
var timelineTrack = timelineAsset.CreateTrack <SkillTriggerPlayableTrack>(null, trackInfo.name);
foreach (var clipInfo in trackSequence.sequences)
{
var timelineClip = timelineTrack.CreateClip <SkillTriggerPlayableClip>();
var triggerClip = timelineClip.asset as SkillTriggerPlayableClip;
timelineClip.displayName = clipInfo.displayName;
triggerClip.type = clipInfo.type;
triggerClip.name = clipInfo.name;
triggerClip.args = clipInfo.args;
timelineClip.start = clipInfo.startTime;
timelineClip.duration = clipInfo.durationTime;
}
}
AssetDatabase.SaveAssets();
}
}
/// <summary>
/// Concludes recording and saves assets.
/// </summary>
protected void EndRecord()
{
if (!isRecording)
{
return;
}
Debug.Log("<color=white>■</color> Recording Complete");
// Dump the clip to the folder, which will be required for everything:
var clip = new AnimationClip();
if (recordingMethod == RecordType.LegacyAnimation)
{
clip.legacy = true;
}
recorder.SaveToClip(clip);
SaveToDisk(clip, "anim");
if (recordingMethod == RecordType.Timeline)
{
// Create the timeline asset:
var timelineAsset = TimelineAsset.CreateInstance <TimelineAsset>();
SaveToDisk(timelineAsset, "playable");
// (Asset needs to be saved to disk first or else changes won't propagate)
var track = timelineAsset.CreateTrack <AnimationTrack>();
track.CreateClip(clip);
}
else if (recordingMethod == RecordType.Animator)
{
// Create the animator (controller) asset:
var controller = AnimatorController.CreateAnimatorControllerAtPath("Assets/" + saveFolder + "/" + clip.name + "_controller.controller");
controller.AddMotion(clip, 0);
}
recorder = null;
isRecording = false;
}
public GameObject GenerateUnityObject(StageData stage, AssetImportContext ctx)
{
var stageObj = new GameObject(stage.name);
stageTransform = rootTransform = stageObj.transform;
director = stageObj.AddComponent <PlayableDirector>();
director.extrapolationMode = Settings.DefaultWrapMode;
var timelineAsset = TimelineAsset.CreateInstance <TimelineAsset>();
timelineAsset.name = stage.name + "_Timeline";
timelineAsset.editorSettings.fps = stage.fps;
timelineAsset.durationMode = TimelineAsset.DurationMode.FixedLength;
timelineAsset.fixedDuration = stage.timelineLength * 1.0 / stage.fps;
ctx.AddSubAsset(timelineAsset.name, timelineAsset);
director.playableAsset = timelineAsset;
animator = stageObj.AddComponent <Animator>();
foreach (var symbol in stage.Symbols)
{
var symbolObj = GenerateUnityObject(symbol, 0, ctx, timelineAsset, null, stageObj.transform);
symbolObj.transform.SetParent(stageObj.transform, false);
if (Settings.ApplyStageTransform)
{
symbolObj.transform.localPosition += stage.transform.pos;
symbolObj.transform.localRotation *= stage.transform.rot;
var scl = symbolObj.transform.localScale;
var s = stage.transform.scl;
symbolObj.transform.localScale = new Vector3(scl.x * s.x, scl.y * s.y, scl.z * s.z);
}
}
return(stageObj);
}
public GameObject MakePlayableBaseObject(PlayableData playable, ref Context ctx, float start, float duration)
{
start += ctx.frameOffset / ctx.fps;
var hackyStart = Mathf.Max(0, start);
var clipIn = hackyStart - start;
start = hackyStart;
var playableObj = new GameObject(playable.displayName ?? "Layer");
playableObj.transform.parent = ctx.parentTransform;
playableObj.transform.localPosition = playable.transform.pos.V3;
playableObj.transform.localRotation = playable.transform.rot.Q;
playableObj.transform.localScale = playable.transform.scl.V3;
playableObj.SetActive(playable.isVisible);
var path = AnimationUtility.CalculateTransformPath(playableObj.transform, ctx.rootTransform);
var director = playableObj.AddComponent <PlayableDirector>();
var timelineAsset = TimelineAsset.CreateInstance <TimelineAsset>();
timelineAsset.name = path + "_Timeline";
timelineAsset.editorSettings.fps = stage.fps;
timelineAsset.durationMode = TimelineAsset.DurationMode.FixedLength;
timelineAsset.fixedDuration = playable.TrimLoopOut == AnimVR.TrimLoopType.Infinity ? duration : 1000000;
ctx.ctx.AddObjectToAsset(timelineAsset.name, timelineAsset);
director.extrapolationMode = playable.TrimLoopOut == AnimVR.TrimLoopType.OneShot ? DirectorWrapMode.None :
playable.TrimLoopOut == AnimVR.TrimLoopType.Loop ? DirectorWrapMode.Loop :
playable.TrimLoopOut == AnimVR.TrimLoopType.Hold ? DirectorWrapMode.Hold :
DirectorWrapMode.Hold;
director.playableAsset = timelineAsset;
ctx.animator = playableObj.AddComponent <Animator>();
var controlTrack = ctx.parentTimeline.CreateTrack <AnimVR.Timeline.AnimControlTrack>(null, playableObj.name);
ctx.ctx.AddObjectToAsset(path + "_Control", controlTrack);
var controlClip = controlTrack.CreateDefaultClip();
controlClip.displayName = playableObj.name;
controlClip.start = start == 0 ? start : (start - 0.000001);
controlClip.duration = (start == 0 ? -0.000001 : 0) + duration - clipIn;
controlClip.clipIn = clipIn;
controlClip.blendInCurveMode = controlClip.blendOutCurveMode = TimelineClip.BlendCurveMode.Manual;
controlClip.mixInCurve = AnimationCurve.Linear(0, 0, 1, 1);
controlClip.mixOutCurve = AnimationCurve.Linear(0, 1, 1, 0);
controlClip.easeInDuration = playable.TrimLoopIn == AnimVR.TrimLoopType.Infinity || playable.FadeIn < 0.01f ? 0 : playable.FadeIn / ctx.fps;
controlClip.easeOutDuration = playable.TrimLoopOut == AnimVR.TrimLoopType.Infinity || playable.FadeOut < 0.01f ? 0 : playable.FadeOut / ctx.fps;
typeof(TimelineClip).GetProperty("preExtrapolationMode").SetValue(controlClip, TRIM_LOOP_MAPPING[playable.TrimLoopIn], null);
typeof(TimelineClip).GetProperty("postExtrapolationMode").SetValue(controlClip, TRIM_LOOP_MAPPING[playable.TrimLoopOut], null);
var controlAsset = controlClip.asset as AnimVR.Timeline.AnimControlPlayableAsset;
controlAsset.name = playable.name;
ctx.director.SetGenericBinding(controlAsset, playableObj);
ctx.ctx.AddObjectToAsset(path + "_ControlAsset", controlAsset);
ctx.parentTimeline = timelineAsset;
ctx.director = director;
ctx.parentTransform = playableObj.transform;
return(playableObj);
}
public GameObject GenerateUnityObject(SymbolData symbol, int frameOffset, AssetImportContext ctx, TimelineAsset parentTimeline, TrackAsset parentTrack, Transform parent)
{
var symbolObj = MakePlayableBaseObject(symbol, parent);
var path = AnimationUtility.CalculateTransformPath(symbolObj.transform, stageTransform);
var prevDirector = director;
var prevRootTransform = rootTransform;
var prevAnimator = animator;
// Top level symbol doesn't need to group stuff
if (parent != stageTransform)
{
int minPlayableStart = symbol.Playables.Min(p => p.AbsoluteTimeOffset);
int frameLength = symbol.Playables.Max(p => p.AbsoluteTimeOffset + p.GetFrameCount(stage.fps) - minPlayableStart);
int frameStart = symbol.AbsoluteTimeOffset + minPlayableStart;
director = symbolObj.AddComponent <PlayableDirector>();
var timelineAsset = TimelineAsset.CreateInstance <TimelineAsset>();
timelineAsset.name = path + "_Timeline";
timelineAsset.editorSettings.fps = stage.fps;
timelineAsset.durationMode = TimelineAsset.DurationMode.BasedOnClips;
timelineAsset.fixedDuration = frameLength / stage.fps;
ctx.AddSubAsset(timelineAsset.name, timelineAsset);
director.playableAsset = timelineAsset;
animator = symbolObj.AddComponent <Animator>();
var controlTrack = parentTimeline.CreateTrack <AnimVR.Timeline.AnimControlTrack>(null, symbolObj.name);
ctx.AddSubAsset(path + "_Control", controlTrack);
var controlClip = controlTrack.CreateDefaultClip();
controlClip.displayName = symbolObj.name;
controlClip.start = frameStart / stage.fps;
controlClip.duration = frameLength / stage.fps;
typeof(TimelineClip).GetProperty("preExtrapolationMode").SetValue(controlClip, LOOP_MAPPING[symbol.LoopIn], null);
typeof(TimelineClip).GetProperty("postExtrapolationMode").SetValue(controlClip, LOOP_MAPPING[symbol.LoopOut], null);
var controlAsset = controlClip.asset as AnimVR.Timeline.AnimControlPlayableAsset;
controlAsset.name = symbolObj.name;
prevDirector.SetGenericBinding(controlAsset, symbolObj);
ctx.AddSubAsset(path + "_ControlAsset", controlAsset);
parentTimeline = timelineAsset;
rootTransform = symbolObj.transform;
frameOffset = -minPlayableStart;
}
foreach (var playbale in symbol.Playables)
{
if (playbale.isVisible)
{
GenerateUnityObject(playbale, frameOffset, ctx, parentTimeline, null, symbolObj.transform);
}
}
director = prevDirector;
rootTransform = prevRootTransform;
animator = prevAnimator;
return(symbolObj);
}
static void CreateSequence()
{
// Choose folder for new sequence
string path = EditorUtility.SaveFilePanel("Create New Sequence", Application.dataPath + "/Sequences", "New Sequence", "unity");
if (string.IsNullOrEmpty(path))
{
return;
}
string sequenceName = Path.GetFileNameWithoutExtension(path);
string parentFolder = Path.GetDirectoryName(path);
string folder = Path.Combine(parentFolder, sequenceName);
if (Directory.Exists(path))
{
bool nonEmpty = Directory.EnumerateFileSystemEntries(path).Any();
if (nonEmpty)
{
string message = $"Directory {folder} exists is non-empty!";
EditorUtility.DisplayDialog("Error", message, "OK");
return;
}
}
else
{
Directory.CreateDirectory(folder);
}
// Create & open a new scene
Scene scene = EditorSceneManager.NewScene(NewSceneSetup.EmptyScene, NewSceneMode.Single);
// Populate scene
GameObject environmentPrefab = (GameObject)PrefabUtility.InstantiatePrefab(EnvironmentTemplate);
GameObject cameraPrefab = (GameObject)PrefabUtility.InstantiatePrefab(CameraTemplate);
GameObject timelinePrefab = (GameObject)PrefabUtility.InstantiatePrefab(TimelineTemplate);
PlayableDirector director = timelinePrefab.GetComponent <PlayableDirector>();
// Create timeline playable next to scene
Uri timelineFullPath = new Uri(Path.Combine(folder, $"{sequenceName}.playable"));
Uri assetPathRoot = new Uri(Application.dataPath);
string timelineAssetPath = UnityWebRequest.UnEscapeURL(assetPathRoot.MakeRelativeUri(timelineFullPath).ToString());
TimelineAsset timeline = TimelineAsset.CreateInstance <TimelineAsset>();
AssetDatabase.CreateAsset(timeline, timelineAssetPath);
director.playableAsset = timeline;
// Lighting Settings
RenderSettings.skybox = null;
RenderSettings.ambientMode = UnityEngine.Rendering.AmbientMode.Flat;
RenderSettings.ambientLight = Color.HSVToRGB(0, 0, 0.35f);
RefreshReferences();
ShowTimeline();
CreateDrone();
// Save scene asset
string scenePath = Path.Combine(folder, $"{sequenceName}.unity");
EditorSceneManager.SaveScene(scene, scenePath);
AssetDatabase.Refresh();
}
