private static void FadeForward(Sprite entity, TransitionData data)
{
data.ElapsedTime += Time.Delta;
entity.Color = data.Colour.Start.Lerp(data.Colour.End, data.ElapsedTime / data.Duration);
if (data.ElapsedTime > data.Duration)
{
data.FadeReverted = true;
data.ElapsedTime = data.Duration;
entity.Material = data.ReplaceMaterialReverting;
}
entity.Set(data);
}
private static void FadeReverse(Sprite entity, TransitionData data)
{
data.ElapsedTime -= Time.Delta;
entity.Color = data.Colour.Start.Lerp(data.Colour.End, data.ElapsedTime / data.Duration);
if (data.ElapsedTime < 0)
{
data.FadeReverted = false;
data.ElapsedTime = 0;
data.FadeActive = false;
}
entity.Set(data);
}
/// <summary>
/// Creates a visual animation (transition) with the input parameters.
/// </summary>
/// <param name="target">The visual map to animation.</param>
/// <param name="property">The property of visual to animation.</param>
/// <param name="destinationValue">The destination value of property after animation.</param>
/// <param name="startTime">The start time of visual animation.</param>
/// <param name="endTime">The end time of visual animation.</param>
/// <param name="alphaFunction">The alpha function of visual animation.</param>
/// <param name="initialValue">The initial property value of visual animation.</param>
/// <returns>Animation instance</returns>
/// <since_tizen> 3 </since_tizen>
public Animation AnimateVisual(VisualMap target, string property, object destinationValue, int startTime, int endTime, AlphaFunction.BuiltinFunctions?alphaFunction = null, object initialValue = null)
{
string _alphaFunction = null;
if (alphaFunction != null)
{
switch (alphaFunction)
{
case Tizen.NUI.AlphaFunction.BuiltinFunctions.Linear:
{
_alphaFunction = "LINEAR";
break;
}
case Tizen.NUI.AlphaFunction.BuiltinFunctions.Reverse:
{
_alphaFunction = "REVERSE";
break;
}
case Tizen.NUI.AlphaFunction.BuiltinFunctions.EaseInSquare:
{
_alphaFunction = "EASE_IN_SQUARE";
break;
}
case Tizen.NUI.AlphaFunction.BuiltinFunctions.EaseOutSquare:
{
_alphaFunction = "EASE_OUT_SQUARE";
break;
}
case Tizen.NUI.AlphaFunction.BuiltinFunctions.EaseIn:
{
_alphaFunction = "EASE_IN";
break;
}
case Tizen.NUI.AlphaFunction.BuiltinFunctions.EaseOut:
{
_alphaFunction = "EASE_OUT";
break;
}
case Tizen.NUI.AlphaFunction.BuiltinFunctions.EaseInOut:
{
_alphaFunction = "EASE_IN_OUT";
break;
}
case Tizen.NUI.AlphaFunction.BuiltinFunctions.EaseInSine:
{
_alphaFunction = "EASE_IN_SINE";
break;
}
case Tizen.NUI.AlphaFunction.BuiltinFunctions.EaseOutSine:
{
_alphaFunction = "EASE_OUT_SINE";
break;
}
case Tizen.NUI.AlphaFunction.BuiltinFunctions.EaseInOutSine:
{
_alphaFunction = "EASE_IN_OUT_SINE";
break;
}
case Tizen.NUI.AlphaFunction.BuiltinFunctions.Bounce:
{
_alphaFunction = "BOUNCE";
break;
}
case Tizen.NUI.AlphaFunction.BuiltinFunctions.Sin:
{
_alphaFunction = "SIN";
break;
}
case Tizen.NUI.AlphaFunction.BuiltinFunctions.EaseOutBack:
{
_alphaFunction = "EASE_OUT_BACK";
break;
}
default:
{
_alphaFunction = "DEFAULT";
break;
}
}
}
foreach (var item in _visualDictionary.ToList())
{
if (item.Value.Name == target.Name)
{
PropertyMap _animator = new PropertyMap();
if (_alphaFunction != null)
{
_animator.Add("alphaFunction", new PropertyValue(_alphaFunction));
}
PropertyMap _timePeriod = new PropertyMap();
_timePeriod.Add("duration", new PropertyValue((endTime - startTime) / 1000.0f));
_timePeriod.Add("delay", new PropertyValue(startTime / 1000.0f));
_animator.Add("timePeriod", new PropertyValue(_timePeriod));
StringBuilder sb = new StringBuilder(property);
sb[0] = (char)(sb[0] | 0x20);
string _str = sb.ToString();
if (_str == "position")
{
_str = "offset";
}
PropertyValue destVal = PropertyValue.CreateFromObject(destinationValue);
PropertyMap _transition = new PropertyMap();
_transition.Add("target", new PropertyValue(target.Name));
_transition.Add("property", new PropertyValue(_str));
if (initialValue != null)
{
PropertyValue initVal = PropertyValue.CreateFromObject(initialValue);
_transition.Add("initialValue", new PropertyValue(initVal));
}
_transition.Add("targetValue", destVal);
_transition.Add("animator", new PropertyValue(_animator));
TransitionData _transitionData = new TransitionData(_transition);
return(this.CreateTransition(_transitionData));
}
}
return(null);
}
public TransitionData(TransitionData tr)
{
this.id = tr.id;
this.value = tr.value;
}
/* Use this constructor to pass multiple coroutines. */
public LoadingTransition(TransitionData d)
{
loadedTransition = d.LoadedTransitions;
}
/// <summary>
/// Creates an animation to animate the mixColor of the named visual.
/// </summary>
/// <since_tizen> 3 </since_tizen>
public Animation AnimateColor(string targetVisual, object destinationColor, int startTime, int endTime, AlphaFunction.BuiltinFunctions?alphaFunction = null, object initialColor = null)
{
Animation animation = null;
{
PropertyMap _animator = new PropertyMap();
if (alphaFunction != null)
{
_animator.Add("alphaFunction", new PropertyValue(AlphaFunction.BuiltinToPropertyKey(alphaFunction)));
}
PropertyMap _timePeriod = new PropertyMap();
_timePeriod.Add("duration", new PropertyValue((endTime - startTime) / 1000.0f));
_timePeriod.Add("delay", new PropertyValue(startTime / 1000.0f));
_animator.Add("timePeriod", new PropertyValue(_timePeriod));
PropertyMap _transition = new PropertyMap();
_transition.Add("animator", new PropertyValue(_animator));
_transition.Add("target", new PropertyValue(targetVisual));
_transition.Add("property", new PropertyValue("mixColor"));
if (initialColor != null)
{
PropertyValue initValue = PropertyValue.CreateFromObject(initialColor);
_transition.Add("initialValue", initValue);
}
PropertyValue destValue = PropertyValue.CreateFromObject(destinationColor);
_transition.Add("targetValue", destValue);
TransitionData _transitionData = new TransitionData(_transition);
animation = new Animation(Interop.View.View_CreateTransition(swigCPtr, TransitionData.getCPtr(_transitionData)), true);
if (NDalicPINVOKE.SWIGPendingException.Pending)
{
throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
}
return(animation);
}
private void Cleanup()
{
m_MenuIn = m_MenuOut = null;
m_CurrentTransitionData = null;
m_TransitionInTweener = m_TransitionOutTweener = null;
}
public const double DISPLAY_FILTER_PERCENT = 0.01; // filter peaks less than this percentage of maximum intensity
public ChromatogramLoadingStatus(string message) :
base(message)
{
Transitions = new TransitionData();
}
public static PlotModel CreateTransitionPlot(TransitionData transition, ExportFormat format = ExportFormat.PNG)
{
if (format == ExportFormat.NoImageExport)
{
return(null);
}
var plot = new OxyPlot.PlotModel()
{
TitlePadding = 0,
Title = transition.CompoundName,
LegendPosition = LegendPosition.RightTop,
LegendFontSize = 20,
LegendBorder = OxyColors.Black,
LegendBorderThickness = 1,
//LegendItemAlignment = HorizontalAlignment.Right,
LegendSymbolPlacement = LegendSymbolPlacement.Right,
};
var xMax = transition.StopTimeMinutes;
var xMin = transition.StartTimeMinutes;
var yMax = transition.MaxIntensity;
var yAxis = new LinearAxis
{
Position = AxisPosition.Left,
Title = "Intensity",
StringFormat = "#.#e00",
FontSize = 20,
Minimum = 0,
AbsoluteMinimum = 0,
};
var xAxis = new LinearAxis
{
Position = AxisPosition.Bottom,
Title = "Time (min)",
FontSize = 20,
Minimum = xMin,
AbsoluteMinimum = xMin,
Maximum = xMax,
AbsoluteMaximum = xMax,
};
plot.Axes.Add(yAxis);
plot.Axes.Add(xAxis);
var trackerFormatString = $"Scan: {{{nameof(TransitionData.DataPoint.Scan)}}}\nTime: {{{nameof(TransitionData.DataPoint.Time)}}}\nIntensity: {{{nameof(TransitionData.DataPoint.Intensity)}}}";
var pointMapper = new Func <object, DataPoint>(x => new DataPoint(((TransitionData.DataPoint)x).Time, ((TransitionData.DataPoint)x).Intensity));
var series = new LineSeries()
{
Title = $"{transition.ProductMz:F2}",
MarkerType = MarkerType.None,
ItemsSource = transition.Intensities,
Mapping = pointMapper,
TrackerFormatString = trackerFormatString,
};
plot.Series.Add(series);
return(plot);
}
public const float TIME_RESOLUTION = 0.2f; // 12 seconds
#endregion Fields
#region Constructors
public ChromatogramLoadingStatus(string message)
: base(message)
{
Transitions = new TransitionData();
}
public override bool Execute(TransitionData data)
{
messageBroker.SendMessage($"Executed {GetType().Name}");
return(OnTransition(data));
}
public virtual bool OnTransition(TransitionData data)
{
return(true);
}
private void Start()
{
if (TransitionData_ != null)
{
if (TransitionData_.State == State.Play)
TransferToPlay();
TransitionData_ = null;
}
}
public IEnumerator FadeInRoutine(string tag = DefaultTransitionTag, float timeMult = 1)
{
TransitionData data = IndexDatabase.Instance().Transitions.GetData(tag);
yield return(FadeRoutine(data.GetFadeIn(), true, timeMult));
}
public IEnumerator FadeOutRoutine(string tag = DefaultTransitionTag)
{
TransitionData data = IndexDatabase.Instance().Transitions.GetData(tag);
yield return(FadeRoutine(data.GetFadeOut()));
}
/// <summary>
/// Creates a transition effect on the control.
/// </summary>
/// <param name="transitionData">The transition data describing the effect to create.</param>
/// <returns>A handle to an animation defined with the given effect, or an empty handle if no properties match.</returns>
/// <since_tizen> 3 </since_tizen>
protected Animation CreateTransition(TransitionData transitionData)
{
return(viewWrapperImpl.CreateTransition(transitionData));
}
/// <summary>
/// Create an instance of TransitionData by copy constructor.
/// </summary>
/// <param name="handle">Handle to an object.</param>
/// <since_tizen> 3 </since_tizen>
public TransitionData(TransitionData handle) : this(Interop.TransitionData.new_TransitionData__SWIG_1(TransitionData.getCPtr(handle)), true)
{
if (NDalicPINVOKE.SWIGPendingException.Pending)
{
throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
}
private void LoadAudioFile(string scenarioUrl, string fileUrl)
{
if (fileUrl == "" || fileUrl == "-1")
{
return;
}
Debug.Log("LoadAudioFile " + fileUrl);
using (ZipFile scenario = ZipFile.Read(scenarioUrl))
{
if (Directory.Exists("extraction"))
{
Directory.Delete("extraction", true);
}
Directory.CreateDirectory("extraction");
scenario.ExtractSelectedEntries("name=" + fileUrl + " OR name =" + fileUrl + "_setup", null, "extraction");
scenario.Dispose();
}
if (!File.Exists("extraction\\" + fileUrl) || !File.Exists("extraction\\" + fileUrl + "_setup"))
{
Debug.LogError("LoadAudioFile raté : Fichiers " + fileUrl + " ou " + fileUrl + "_setup manquant.");
return;
}
string[] linesData = File.ReadAllLines("extraction\\" + fileUrl);
string[] infoData = linesData[0].Split('/');
string audioName = infoData[0];
int frequency = int.Parse(infoData[1]);
int channels = int.Parse(infoData[2]);
float length = float.Parse(infoData[3]);
int nbOfSamples = int.Parse(infoData[4]);
string[] linesSetup = File.ReadAllLines("extraction\\" + fileUrl + "_setup");
string[] infoSetup = linesSetup[0].Split('/');
int BPM = int.Parse(infoSetup[0]);
int BPB = int.Parse(infoSetup[1]);
float beginLoop = float.Parse(infoSetup[2]);
float endLoop = float.Parse(infoSetup[3]);
List <TransitionData> transitionsData = new List <TransitionData>();
int nextTransitionId = 0;
if (linesSetup.Length > 1)
{
string transitionSetup = linesSetup[1];
int index = transitionSetup.IndexOf(":");
string nextTransitionIdStr = transitionSetup.Substring(0, index);
nextTransitionId = int.Parse(nextTransitionIdStr);
transitionSetup = transitionSetup.Substring(index + 1, transitionSetup.Length - 1 - index);
int endIndex = 0;
int midIndex = 0;
while ((index = transitionSetup.IndexOf("(")) != -1)
{
midIndex = transitionSetup.IndexOf(";");
endIndex = transitionSetup.IndexOf(")");
TransitionData trData = new TransitionData(0, 0);
string transitionId = transitionSetup.Substring(index + 1, midIndex - index - 1);
string transitionValue = transitionSetup.Substring(midIndex + 1, endIndex - midIndex - 1);
Debug.Log("New Transition : " + transitionId + " / " + transitionValue);
trData.id = int.Parse(transitionId);
trData.value = float.Parse(transitionValue);
transitionsData.Add(trData);
transitionSetup = transitionSetup.Substring(endIndex + 1, transitionSetup.Length - 1 - endIndex);
}
}
float[] readSamples = new float[nbOfSamples * channels];
for (int i = 1; i < linesData.Length; i++)
{
if (linesData[i] != "")
{
readSamples[i - 1] = float.Parse(linesData[i]);
}
}
if (Directory.Exists("extraction"))
{
Directory.Delete("extraction", true);
}
int clipId = int.Parse(fileUrl);
resourcesManager.LoadResource(clipId, audioName, nbOfSamples, channels, frequency, readSamples, BPM, BPB, beginLoop, endLoop, transitionsData, nextTransitionId);
if (resourcesManager.GetResource(clipId).Clip.loadState == AudioDataLoadState.Loaded)
{
//UpdateSoundblockAudioLists();
}
else
{
Debug.LogError("Resource " + audioName + " / " + fileUrl + " didn't load properly");
return;
}
Debug.Log("Audio File Loaded : " + audioName + " / " + fileUrl);
}
private void Start()
{
if (TransitionData_ != null)
{
SetWorld(TransitionData_.World);
TransitionData_ = null;
}
SpawnLevels();
_easyButton.onClick.AddListener(() => OnDifficultySelected(Difficulty.Easy));
_hardButton.onClick.AddListener(() => OnDifficultySelected(Difficulty.Hard));
}
internal static global::System.Runtime.InteropServices.HandleRef getCPtr(TransitionData obj)
{
return((obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr);
}
private void Start()
{
int x = 0;
x = ButtonInterval/2;
foreach (var world in DB._.World)
{
var button = SpawnWorldButton(world.Type);
var buttonPos = button.transform.localPosition;
buttonPos.x = x;
button.transform.localPosition = buttonPos;
button.OnSelectedCallback += OnWorldSelected;
x += ButtonInterval;
}
var offsetX = _worldContent.offsetMax;
offsetX.x = x - ButtonInterval/2;
_worldContent.offsetMax = offsetX;
var contentPos = _worldContent.localPosition;
contentPos.x = SceneGlobalState.WorldScrollOffset;
_worldContent.localPosition = contentPos;
TransitionData_ = null;
}
/// <summary>
/// Creates an animation to animate the mixColor of the named visual.
/// </summary>
/// <since_tizen> 3 </since_tizen>
public Animation AnimateColor(string targetVisual, object destinationColor, int startTime, int endTime, AlphaFunction.BuiltinFunctions?alphaFunction = null, object initialColor = null)
{
Animation animation = null;
using (PropertyMap animator = new PropertyMap())
using (PropertyMap timePeriod = new PropertyMap())
using (PropertyValue pvDuration = new PropertyValue((endTime - startTime) / 1000.0f))
using (PropertyValue pvDelay = new PropertyValue(startTime / 1000.0f))
using (PropertyMap transition = new PropertyMap())
using (PropertyValue pvTarget = new PropertyValue(targetVisual))
using (PropertyValue pvProperty = new PropertyValue("mixColor"))
using (PropertyValue destValue = PropertyValue.CreateFromObject(destinationColor))
{
if (alphaFunction != null)
{
using (PropertyValue pvAlpha = new PropertyValue(AlphaFunction.BuiltinToPropertyKey(alphaFunction)))
{
animator.Add("alphaFunction", pvAlpha);
}
}
timePeriod.Add("duration", pvDuration);
timePeriod.Add("delay", pvDelay);
using (PropertyValue pvTimePeriod = new PropertyValue(timePeriod))
{
animator.Add("timePeriod", pvTimePeriod);
}
using (PropertyValue pvAnimator = new PropertyValue(animator))
{
transition.Add("animator", pvAnimator);
}
transition.Add("target", pvTarget);
transition.Add("property", pvProperty);
if (initialColor != null)
{
using (PropertyValue initValue = PropertyValue.CreateFromObject(initialColor))
{
transition.Add("initialValue", initValue);
}
}
transition.Add("targetValue", destValue);
using (TransitionData transitionData = new TransitionData(transition))
{
animation = new Animation(Interop.View.CreateTransition(SwigCPtr, TransitionData.getCPtr(transitionData)), true);
}
if (NDalicPINVOKE.SWIGPendingException.Pending)
{
throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
}
return(animation);
}
public void SyncGameState(GameState state, Dictionary <string, object> newParms)
{
currentState = UpdateGameState(state, newParms);
}
public State(int initialState, TransitionData[] transitions)
{
int i;
int j;
UiExceptionHelper.CheckNotNull(transitions, "transitions");
UiExceptionHelper.CheckTrue(
transitions.Length == 8,
"expecting transitions.Length to be 8",
"transitions");
for (i = 0; i < transitions.Length; ++i)
for (j = 0; j < transitions.Length; ++j)
{
if (j == i)
continue;
if (transitions[j].Transition == transitions[i].Transition)
UiExceptionHelper.CheckTrue(false,
String.Format("transition '{0}' already present", transitions[j].Transition),
"transitions");
}
InitialState = initialState;
Transitions = transitions;
return;
}
private void Setup()
{
var nodes = StateGraph.nodes.Select(x => (BaseNode)x).ToArray();
var clips = new List <AnimationClip>();
states = new NativeArray <StateData>(nodes.Length, Allocator.Persistent);
for (int i = 0; i < nodes.Length; i++)
{
var node = nodes[i];
if (node.NodeType == NodeType.Any)
{
anyStateIndex = i;
}
if (node.Clip != null)
{
clips.Add(node.Clip);
}
states[i] = new StateData
{
index = i,
nodeType = node.NodeType,
clip = Mathf.Max(clips.Count - 1, 0),
duration = node.Duration > 0 ? node.Duration : 0,
wrapMode = node.WrapMode,
frames = node.Frames > 0 ? node.Frames : 0
};
}
List <TransitionData> tempTransitions = new List <TransitionData>();
foreach (var node in nodes)
{
foreach (var port in node.Outputs)
{
foreach (var connection in port.Connections)
{
var from = (BaseNode)connection.fromNode;
var to = (BaseNode)connection.toNode;
var fromState = states[Array.IndexOf(nodes, from)];
var toState = states[Array.IndexOf(nodes, to)];
var trans = new TransitionData
{
fromState = fromState,
toState = toState,
qualifier = Qualifier.None,
};
if (connection.rules.Count > 0)
{
foreach (var rule in connection.rules)
{
int intValue = 0;
float floatValue = 0;
int isTrigger = 0;
int isFloat = 0;
switch (rule.Variable.VariableType)
{
case VariableType.Boolean:
intValue = rule.QualifierBoolVal ? 1 : 0;
break;
case VariableType.Float:
isFloat = 1;
floatValue = rule.QualifierFloatVal;
break;
case VariableType.Integer:
intValue = rule.QualifierIntVal;
break;
case VariableType.Trigger:
isTrigger = 1;
intValue = 1;
break;
}
trans.variable = StateGraph.variables.IndexOf(rule.Variable);
trans.isFloat = isFloat;
trans.qualifier = rule.Qualifier;
trans.intValue = intValue;
trans.floatValue = floatValue;
trans.isTrigger = isTrigger;
tempTransitions.Add(trans);
}
}
else
{
tempTransitions.Add(trans);
}
}
}
}
tempTransitions.Add(new TransitionData {
fromState = states[0], toState = states[1], qualifier = Qualifier.None
});
transitions = new NativeMultiHashMap <int, TransitionData>(tempTransitions.Count, Allocator.Persistent);
foreach (var trans in tempTransitions)
{
transitions.Add(trans.fromState.index, trans);
// Debug.Log("====================================");
// Debug.Log(trans.fromState.index);
// Debug.Log(trans.toState.index);
// Debug.Log(JsonUtility.ToJson(trans));
}
frameStart = new NativeArray <float>(states.Length, Allocator.Persistent);
float totalFrames = 1;
float previousFrames = 0;
for (int i = 0; i < states.Length; i++)
{
frameStart[i] = totalFrames + previousFrames;
totalFrames = frameStart[i];
previousFrames = states[i].frames;
}
HasSetup = true;
}
