public override void Perform (LayerStatus [] statuses, Dictionary<int, StateInfo> stateInfos) {
LayerStatus status = statuses [layer];
if (status.State.Current == stateId) {
// seems awkward but null check first costs almost no performance, but a dictionary lookup does
if (OnActive != null || OnEnter != null || OnStay != null) {
StateInfo currentInfo = GetStateInfo (status.State.Current, stateInfos);
if (currentInfo != null) {
if (status.State.HasChanged) {
if (OnEnter != null) {
// fire once after a state change
OnEnter (currentInfo, status);
}
} else if (OnStay != null) {
// OnStay starts firing the 2nd time we are in this state
OnStay (currentInfo, status);
}
if (OnActive != null) {
// fire always
OnActive (currentInfo, status);
}
}
}
} else if (status.State.Previous == stateId && status.State.HasChanged) {
StateInfo previousInfo = GetStateInfo (status.State.Previous, stateInfos);
if (OnExit != null) {
OnExit (previousInfo, status);
}
}
}
public override void Perform (LayerStatus [] statuses, Dictionary<int, StateInfo> stateInfos) {
if (performAction != null) {
performAction (stateInfos, statuses);
} else {
Debug.LogWarning ("No performAction supplied!");
}
}
public Layer(bool loop = false, int octave = 5)
{
pos = 0;
status = LayerStatus.NotStarted;
this.loop = loop;
baseOctave = octave;
Sequence = new List <Note>();
}
public override void Perform (LayerStatus[] statuses, Dictionary<int, TransitionInfo> transitionInfos) {
if (layer == -1) {
foreach (LayerStatus status in statuses) {
CheckTransitionStatus (status, transitionInfos);
}
} else {
CheckTransitionStatus (statuses [layer], transitionInfos);
}
}
// Use this for initialization
IEnumerator Start()
{
status = LayerStatus.Start;
canvas = GetComponentInChildren <Canvas>();
yield return(StartCoroutine(LayerStart()));
status = LayerStatus.Update;
}
public void Initialise (Animator animator, BaseAnimatorAccess animatorAccess) {
LayerCount = animator.layerCount;
LayerStatuses = new LayerStatus [LayerCount];
for (int i = 0; i < LayerCount; i++) {
LayerStatuses [i] = new LayerStatus (i, 0, 0);
}
// callback to overriden method in generated class to initialise state and transition infos
animatorAccess.InitialiseEventManager ();
}
public virtual IEnumerator DestroyLayer()
{
status = LayerStatus.End;
ClearLayerInfoFromParent();
yield return(StartCoroutine(LayerEnd()));
Destroy(gameObject);
yield return(null);
}
internal static string ToJson(LayerStatus layerstatus)
{
string json = "{";
json += string.Format("\"type\":\"UGC\",");
json += string.Format("\"name\":\"{0}\",", layerstatus.LayerName);
json += string.Format("\"visible\":{0},", layerstatus.IsVisible.ToString(System.Globalization.CultureInfo.InvariantCulture).ToLower());
if (!string.IsNullOrEmpty(layerstatus.DisplayFilter))
{
json += string.Format("\"displayFilter\":\"{0}\"", layerstatus.DisplayFilter.ToString());
}
json += "}";
return json;
}
//Layer的其他属性等有需求再加；
internal static string ToJson(LayerStatus param)
{
if (param == null)
{
return null;
}
string json = "{";
json += string.Format("\"visible\":{0},", param.Visible.ToString().ToLower());
json += string.Format("\"displayFilter\":\"{0}\",", param.DisplayFilter);
json += string.Format("\"name\":\"{0}\"", param.LayerName);
json += "}";
return json;
}
public async Task UpdateStatus(string workspaceId, string layerId, LayerStatus status)
{
TableOperation retrieveOperation = TableOperation.Retrieve <StatusEntity>(workspaceId, layerId);
TableResult retrievedResult = await _table.ExecuteAsync(retrieveOperation);
if (retrievedResult.Result != null)
{
var queue = (StatusEntity)retrievedResult.Result;
queue.Status = status.ToString();
await _table.ExecuteAsync(TableOperation.Replace(queue));
}
else
{
await _table.ExecuteAsync(TableOperation.Insert(new StatusEntity(workspaceId, layerId)));
}
}
void CheckTransitionStatus (LayerStatus status, Dictionary<int, TransitionInfo> transitionInfos) {
if (status.Transition.HasChanged) {
int currentTransitionId = status.Transition.Current;
if (currentTransitionId != 0 && OnStarted != null) {
TransitionInfo currentInfo = GetTransitionInfo (currentTransitionId, transitionInfos);
if (currentInfo != null) {
OnStarted (currentInfo, status);
}
}
int previousTransitionId = status.Transition.Previous;
if (previousTransitionId != 0 && OnFinished != null) {
TransitionInfo previousInfo = GetTransitionInfo (previousTransitionId, transitionInfos);
if (previousInfo != null) {
OnFinished (previousInfo, status);
}
}
}
}
public void Shift(OutputDevice outputDevice)
{
if (Sequence == null || Sequence.Count == 0 || status == LayerStatus.Finished)
{
return;
}
if (status == LayerStatus.NotStarted)
{
status = LayerStatus.Playing;
StartNote(pos, outputDevice);
length = 1;
return;
}
var note = Sequence[pos];
if (length < note.Length)
{
length++;
return;
}
StopNote(pos, outputDevice);
pos++;
if (pos == Sequence.Count)
{
if (!loop)
{
status = LayerStatus.Finished;
return;
}
pos = 0;
}
StartNote(pos, outputDevice);
length = 1;
}
public async Task UpdateStatus(string workspaceId, string layerId, LayerStatus status)
{
var currentStatus = await GetStatus(workspaceId, layerId);
string msg;
if (!currentStatus.HasValue)
{
// create one if status doesn't exist
msg = "INSERT INTO Statuses (Id, WorkspaceId, Status) VALUES($Id, $WorkspaceId, $Status)";
}
else
{
// update it if it exists
msg = "UPDATE Statuses SET Status = $Status WHERE Id = $Id and WorkspaceId = $WorkspaceId";
}
var cmd = new SqliteCommand(msg, _queueDatabase);
cmd.Parameters.AddWithValue("$Status", status.ToString());
cmd.Parameters.AddWithValue("$Id", layerId);
cmd.Parameters.AddWithValue("$WorkspaceId", workspaceId);
cmd.ExecuteScalar();
}
public override void Perform (LayerStatus[] statuses, Dictionary<int, TransitionInfo> transitionInfos) {
LayerStatus status = statuses [layer];
if (status.Transition.HasChanged) {
if (OnStarted != null) {
TransitionInfo currentInfo = GetTransitionInfo (status.Transition.Current, transitionInfos);
if (currentInfo != null && GetObservedState (currentInfo) == stateId) {
OnStarted (currentInfo, status);
}
}
if (OnFinished != null) {
TransitionInfo previousInfo = GetTransitionInfo (status.Transition.Previous, transitionInfos);
if (previousInfo != null && GetObservedState (previousInfo) == stateId) {
OnFinished (previousInfo, status);
}
}
}
if (OnActive != null) {
TransitionInfo currentInfo = GetTransitionInfo (status.Transition.Current, transitionInfos);
if (currentInfo != null && GetObservedState (currentInfo) == stateId) {
OnActive (currentInfo, status);
}
}
}
public override void Perform (LayerStatus[] statuses, Dictionary<int, TransitionInfo> transitionInfos)
{
LayerStatus status = statuses [layer];
int currentTransitionId = status.Transition.Current;
if (status.Transition.HasChanged) {
if (currentTransitionId == transitionId && OnStarted != null) {
TransitionInfo currentInfo = GetTransitionInfo (currentTransitionId, transitionInfos);
if (currentInfo != null) {
OnStarted (currentInfo, status);
}
}
int previousTransitionId = status.Transition.Previous;
if (OnFinished != null && previousTransitionId == transitionId) {
TransitionInfo previousInfo = GetTransitionInfo (previousTransitionId, transitionInfos);
if (previousInfo != null) {
OnFinished (previousInfo, status);
}
}
} else if (OnStay != null && currentTransitionId == transitionId) {
// OnStay starts firing one cycle after OnStarted
TransitionInfo info = GetTransitionInfo (currentTransitionId, transitionInfos);
OnStay (info, status);
}
}
public virtual void Perform (LayerStatus[] statuses, Dictionary<int, TransitionInfo> transitionInfos) {
}
public abstract void Perform (LayerStatus [] statuses, Dictionary<int, StateInfo> stateInfos);
public void SetLayer(int i, IBGLayer lay)
{
layers[i] = new LayerStatus();
layers[i].layer=lay;
}
public GlobeLayerInfo()
{
// Treat empty layers as complete by default
status = LayerStatus.Complete;
}
public void SetLayer(int i, IBGLayer lay)
{
layers[i] = new LayerStatus();
layers[i].layer = lay;
}
