// preview a frame in the scene view
public override void previewFrame(AMITarget target, float frame, int frameRate, bool play, float playSpeed)
{
GameObject go = GetTarget(target) as GameObject;
if (!go || keys.Count == 0)
{
return;
}
Animation anim = go.GetComponent <Animation>();
if (frame < keys[0].frame)
{
AMAnimationKey amKey = keys[0] as AMAnimationKey;
if (amKey.amClip)
{
AMUtil.SampleAnimation(anim, amKey.amClip.name, amKey.wrapMode, amKey.crossfade ? 0.0f : 1.0f, 0.0f);
}
return;
}
for (int i = keys.Count - 1; i >= 0; i--)
{
if (keys[i].frame <= frame)
{
AMAnimationKey amKey = keys[i] as AMAnimationKey;
if (amKey.amClip)
{
float t = (frame - (float)amKey.frame) / (float)frameRate;
if (amKey.crossfade)
{
if (i > 0)
{
AMAnimationKey amPrevKey = keys[i - 1] as AMAnimationKey;
if (amPrevKey.amClip)
{
float prevT = (frame - (float)amPrevKey.frame) / (float)frameRate;
AMUtil.SampleAnimationCrossFade(anim, amKey.crossfadeTime, amPrevKey.amClip.name, amPrevKey.wrapMode, prevT, amKey.amClip.name, amKey.wrapMode, t);
}
}
else
{
AMUtil.SampleAnimationFadeIn(anim, amKey.amClip.name, amKey.wrapMode, amKey.crossfadeTime, t);
}
}
else
{
AMUtil.SampleAnimation(anim, amKey.amClip.name, amKey.wrapMode, 1.0f, t);
}
}
break;
}
}
}
public string GetTargetPath(AMITarget target)
{
if (target.isMeta)
{
return(_targetPath);
}
else
{
return(AMUtil.GetPath(target.root, GetSerializeObject(null)));
}
}
public void SetTarget(AMITarget itarget, Transform t)
{
if (itarget.isMeta)
{
target = null;
targetPath = AMUtil.GetPath(itarget.root, t);
itarget.SetCache(targetPath, t);
}
else
{
target = t;
targetPath = "";
}
}
void CameraFadeNoneTargets(int typeEnd, Color colorEnd, Camera camEnd, Camera[] allCams)
{
if (typeEnd == 0)
{
if (camEnd)
{
AMUtil.SetTopCamera(camEnd, allCams);
}
}
else
{
ShowColor(colorEnd);
}
}
// set render texture or colors if render texture is used (stills handled in AMTake)
private void setRenderTexture(AMITarget itarget, AMCameraFade cf, float frame, int firstTargetType, int secondTargetType, bool isReversed,
AMCameraSwitcherKey action)
{
Camera firstCamera = (isReversed ? action.getCameraEnd(itarget) : action.getCamera(itarget));
Camera secondCamera = (isReversed ? action.getCamera(itarget) : action.getCameraEnd(itarget));
if (isReversed && frame == action.frame)
{
if (firstTargetType == 0)
{
AMUtil.SetTopCamera(firstCamera, GetCachedCameras(itarget));
}
}
else
{
if (secondTargetType == 0)
{
AMUtil.SetTopCamera(secondCamera, GetCachedCameras(itarget));
}
}
if (action.still || (firstTargetType != 0 && secondTargetType != 0))
{
return;
}
bool isPro = AMTakeData.isProLicense;
// first target is camera, set render texture
if (firstTargetType == 0)
{
// if should update render texture
if (/*!cf.tex ||*/ cf.shouldUpdateRenderTexture || (isPro && (!firstCamera.targetTexture || !cf.isRenderTextureSetupFor(firstCamera) /*|| firstCamera.targetTexture != cf.tex*/)))
{
if (isPro)
{
cf.setupRenderTexture(firstCamera);
}
else
{
cf.useRenderTexture = false;
// show place-holder if non-pro
cf.colorTex = Color.white;
cf.hasColorTex = false;
cf.clearScreenTex();
cf.placeholder = true;
}
}
}
}
public void SetTarget(AMITarget target, Transform item)
{
if (target.isMeta && item)
{
_targetPath = AMUtil.GetPath(target.root, item);
target.SetCache(_targetPath, item);
SetSerializeObject(GetSerializeObject(item.gameObject));
}
else
{
_targetPath = "";
SetSerializeObject(item ? GetSerializeObject(item.gameObject) : null);
}
}
void CameraEnd(bool isReversed, Camera cam, Camera camEnd, Camera[] allCams)
{
if (isReversed)
{
//set camEnd to top
if (camEnd)
{
AMUtil.SetTopCamera(cam, allCams);
}
}
if (typeEnd == 0)
{
AMCameraFade.reset();
}
else
{
AMCameraFade cf = AMCameraFade.getCameraFade();
cf.keepAliveColor = true;
cf.hasColorTex = true;
cf.hasColorBG = false;
cf.colorTex = colorEnd;
cf.mode = 0;
cf.value = 1.0f;
}
if (!still)
{
if (cam)
{
cam.targetTexture = null;
}
if (camEnd)
{
camEnd.targetTexture = null;
}
}
if (AMCameraFade.hasInstance())
{
AMCameraFade cf = AMCameraFade.getCameraFade();
cf.clearScreenTex();
cf.clearTexture();
if (cf.keepAlives > 0)
{
cf.keepAlives--;
}
}
}
void AMITarget.MaintainTargetCache(AMTrack track)
{
if ((this as AMITarget).isMeta && mCache.ContainsKey(track.targetPath))
{
UnityEngine.Object obj = track.GetTarget(this);
if (obj)
{
string objPath = AMUtil.GetPath(transform, obj);
if (objPath != track.targetPath)
{
mCache.Remove(track.targetPath);
}
}
}
}
Quaternion getRotationAtFrame(int frame, int frameRate)
{
// if before or equal to first frame, or is the only frame
AMRotationKey firstKey = keys[0] as AMRotationKey;
if (firstKey.endFrame == -1 || (frame <= (float)firstKey.frame && !firstKey.canTween))
{
return(firstKey.rotation);
}
// if lies on rotation action
for (int i = 0; i < keys.Count; i++)
{
AMRotationKey key = keys[i] as AMRotationKey;
AMRotationKey keyNext = i + 1 < keys.Count ? keys[i + 1] as AMRotationKey : null;
if (frame >= (float)key.endFrame && keyNext != null && (!keyNext.canTween || keyNext.endFrame != -1))
{
continue;
}
// if no ease
if (!key.canTween || keyNext == null)
{
return(key.rotation);
}
// else find Quaternion using easing function
float numFrames = (float)key.getNumberOfFrames(frameRate);
float framePositionInAction = Mathf.Clamp(frame - (float)key.frame, 0f, numFrames);
Quaternion qStart = key.rotation;
Quaternion qEnd = keyNext.rotation;
if (key.hasCustomEase())
{
return(Quaternion.LerpUnclamped(qStart, qEnd, AMUtil.EaseCustom(0.0f, 1.0f, framePositionInAction / numFrames, key.easeCurve)));
}
else
{
var ease = AMUtil.GetEasingFunction((Ease)key.easeType);
return(Quaternion.LerpUnclamped(qStart, qEnd, ease(framePositionInAction, numFrames, key.amplitude, key.period)));
}
}
Debug.LogError("Animator: Could not get rotation at frame '" + frame + "'");
return(Quaternion.identity);
}
/// <summary>
/// attempt to generate the missing targets
/// </summary>
void AMITarget.GenerateMissingTargets(string[] missingPaths)
{
if (missingPaths != null && missingPaths.Length > 0)
{
for (int i = 0; i < missingPaths.Length; i++)
{
AMUtil.CreateTarget(transform, missingPaths[i]);
}
//fill necessary components per track and key
foreach (AMTakeData take in _takes)
{
foreach (AMTrack track in take.trackValues)
{
Transform t = AMUtil.GetTarget(transform, track.targetPath);
System.Type compType = track.GetRequiredComponent();
if (compType != null)
{
Component comp = t.gameObject.GetComponent(compType);
if (comp == null)
{
t.gameObject.AddComponent(compType);
}
}
foreach (AMKey key in track.keys)
{
compType = key.GetRequiredComponent();
if (compType != null)
{
Component comp = t.gameObject.GetComponent(compType);
if (comp == null)
{
t.gameObject.AddComponent(compType);
}
}
}
}
}
if (mCache != null)
{
mCache.Clear();
}
}
}
public virtual void maintainTrack(AMITarget itarget)
{
Object obj = null;
//fix the target info
if (itarget.isMeta)
{
if (string.IsNullOrEmpty(_targetPath))
{
obj = GetSerializeObject(null);
if (obj)
{
_targetPath = AMUtil.GetPath(itarget.root, obj);
itarget.SetCache(_targetPath, AMUtil.GetTransform(obj));
}
}
SetSerializeObject(null);
}
else
{
obj = GetSerializeObject(null);
if (obj == null)
{
if (!string.IsNullOrEmpty(_targetPath))
{
Transform tgt = itarget.GetCache(_targetPath);
if (tgt == null)
{
tgt = AMUtil.GetTarget(itarget.root, _targetPath);
}
if (tgt)
{
obj = GetSerializeObject(tgt.gameObject);
}
SetSerializeObject(obj);
}
}
_targetPath = "";
}
//maintain keys
foreach (AMKey key in keys)
{
key.maintainKey(itarget, obj);
}
}
public Transform GetTarget(AMITarget itarget)
{
Transform ret = null;
if (itarget.isMeta)
{
if (!string.IsNullOrEmpty(targetPath))
{
ret = itarget.GetCache(targetPath);
if (ret == null)
{
ret = AMUtil.GetTarget(itarget.root, targetPath);
itarget.SetCache(targetPath, ret);
}
}
}
else
{
ret = target;
}
return(ret);
}
void Update()
{
percent += 0.003f * speedValues[selectedSpeedIndex];
if (percent > 1f + waitPercent)
{
percent = waitPercent * -1f;
}
float x_pos_start = 50f;
float x_pos_end = position.width - 50f - 80f - 200f;
if (percent <= 1f)
{
if (isCustomEase)
{
x_pos = AMUtil.EaseCustom(x_pos_start, x_pos_end - x_pos_start, percent < 0f ? 0f : percent, curve);
}
else
{
var ease = AMUtil.GetEasingFunction((Ease)AMTimeline.GetEaseIndex(getSelectedEaseIndex(category, selectedIndex)));
x_pos = x_pos_start + (x_pos_end - x_pos_start) * ease(percent < 0f ? 0f : percent, 1.0f, 0.0f, 0.0f);
}
}
this.Repaint();
}
public Quaternion getQuaternionAtPercent(Transform obj, Transform tgt, Transform tgte, float percentage)
{
if (tgt == tgte || !canTween)
{
return(Quaternion.LookRotation(tgt.position - obj.position));
}
Quaternion s = Quaternion.LookRotation(tgt.position - obj.position);
Quaternion e = Quaternion.LookRotation(tgte.position - obj.position);
float time = 0.0f;
if (hasCustomEase())
{
time = AMUtil.EaseCustom(0.0f, 1.0f, percentage, easeCurve);
}
else
{
var ease = AMUtil.GetEasingFunction((Ease)easeType);
time = ease(percentage, 1.0f, amplitude, period);
}
return(Quaternion.LerpUnclamped(s, e, time));
}
public override void previewFrame(AMITarget itarget, float frame, int frameRate, bool play, float playSpeed)
{
if (keys == null || keys.Count <= 0)
{
return;
}
AMCameraFade.getCameraFade();
// if before or equal to first frame, or is the only frame
AMCameraSwitcherKey firstKey = keys[0] as AMCameraSwitcherKey;
if (firstKey.endFrame == -1 || (frame <= (float)firstKey.frame && !firstKey.canTween))
{
AMCameraFade.reset();
if (!firstKey.hasStartTarget(itarget))
{
return;
}
if (firstKey.type == 0)
{
AMUtil.SetTopCamera(firstKey.getCamera(itarget), GetCachedCameras(itarget));
}
else
{
showColor(firstKey.color);
}
return;
}
for (int i = 0; i < keys.Count; i++)
{
AMCameraSwitcherKey key = keys[i] as AMCameraSwitcherKey;
AMCameraSwitcherKey keyNext = i + 1 < keys.Count ? keys[i + 1] as AMCameraSwitcherKey : null;
if (frame >= (float)key.endFrame && keyNext != null && (!keyNext.canTween || keyNext.endFrame != -1))
{
continue;
}
// if no ease
if (!key.canTween || keyNext == null)
{
AMCameraFade.reset();
if (!key.hasStartTarget(itarget))
{
return;
}
if (key.type == 0)
{
AMUtil.SetTopCamera(key.getCamera(itarget), GetCachedCameras(itarget));
}
else
{
showColor(key.color);
}
return;
}
// else find t using easing function
if (!key.hasStartTarget(itarget) || !key.hasEndTarget(itarget))
{
return;
}
//targets are equal
if (key.targetsAreEqual(itarget))
{
AMCameraFade.reset();
if (key.type == 0)
{
AMUtil.SetTopCamera(key.getCamera(itarget), GetCachedCameras(itarget));
}
else
{
showColor(key.color);
}
}
else
{
AMCameraFade.clearRenderTexture();
previewCameraFade(itarget, frame, key);
}
return;
}
}
private void renderCameraSwitcherStill(AMITarget itarget, float _frame)
{
if (!cameraSwitcher)
{
return;
}
AMCameraSwitcherTrack.cfTuple tuple = cameraSwitcher.getCameraFadeTupleForFrame(itarget, (int)_frame);
if (tuple.frame != 0)
{
AMCameraFade cf = AMCameraFade.getCameraFade();
cf.isReset = false;
// create render texture still
//bool isPro = PlayerSettings.advancedLicense;
bool isPro = isProLicense;
if (!cf.screenTex || cf.shouldUpdateStill || (isPro && cf.cachedStillFrame != tuple.frame))
{
if (isPro)
{
int firstTargetType = (tuple.isReversed ? tuple.type2 : tuple.type1);
int secondTargetType = (tuple.isReversed ? tuple.type1 : tuple.type2);
if (firstTargetType == 0)
{
if (cf.screenTex)
{
Object.DestroyImmediate(cf.screenTex);
}
previewFrame(itarget, tuple.frame, false, false);
// set top camera
//bool isReversed = tuple.isReversed;
Camera firstCamera = (tuple.isReversed ? tuple.camera2 : tuple.camera1);
AMUtil.SetTopCamera(firstCamera, cameraSwitcher.getAllCameras(itarget));
// set cached frame to 0 if bad frame
if (cf.width <= 0 || cf.height <= 0)
{
if (Application.isPlaying)
{
cf.width = Screen.width;
cf.height = Screen.height;
}
else
{
cf.width = 200;
cf.height = 100;
cf.shouldUpdateStill = true;
}
}
else
{
cf.shouldUpdateStill = false;
}
cf.refreshScreenTex(firstCamera);
cf.cachedStillFrame = tuple.frame;
cf.placeholder = false;
if (secondTargetType == 0)
{
Camera secondCamera = (tuple.isReversed ? tuple.camera1 : tuple.camera2);
AMUtil.SetTopCamera(secondCamera, cameraSwitcher.getAllCameras(itarget));
}
}
}
else
{
cf.clearScreenTex();
cf.placeholder = true;
}
}
cf.useRenderTexture = false;
}
}
void CameraGenerateFadeTargets(bool isReversed, Camera cam, Camera camEnd, Camera[] allCams, float[] parameters)
{
AMCameraFade cf = AMCameraFade.getCameraFade();
cf.incrementKeepAlives(true);
if (cf.keepAliveColor)
{
cf.keepAliveColor = false;
}
cf.isReset = false;
Camera firstCamera = null;
Camera secondCamera = null;
Color? firstColor = null;
Color? secondColor = null;
if (isReversed)
{
if (camEnd)
{
firstCamera = camEnd;
}
else if (typeEnd == 1)
{
firstColor = colorEnd;
}
if (cam)
{
secondCamera = cam;
}
else if (type == 1)
{
secondColor = color;
}
}
else
{
if (cam)
{
firstCamera = cam;
}
else if (type == 1)
{
firstColor = color;
}
if (camEnd)
{
secondCamera = camEnd;
}
else if (typeEnd == 1)
{
secondColor = colorEnd;
}
}
// setup first target
if (firstCamera)
{
// camera
if (!still)
{
cf.setupRenderTexture(firstCamera);
}
else
{
AMUtil.SetTopCamera(firstCamera, allCams);
firstCamera.Render();
cf.refreshScreenTex();
cf.useRenderTexture = false;
cf.hasColorTex = false;
}
}
else
{
// color
cf.colorTex = (Color)firstColor;
cf.hasColorTex = true;
}
// setup second target
if (secondCamera)
{
// camera
AMUtil.SetTopCamera(secondCamera, allCams);
cf.hasColorBG = false;
}
else
{
// color
cf.colorBG = (Color)secondColor;
cf.hasColorBG = true;
}
// iris shape
if (irisShape)
{
cf.irisShape = irisShape;
//cf.setupMaterials();
}
cf.mode = cameraFadeType;
// setup camera fade
cf.setupMaterials();
cf.r = parameters;
cf.value = 1f;
cf.percent = 0f;
}
public bool isReversed()
{
return(AMUtil.isTransitionReversed(cameraFadeType, cameraFadeParameters.ToArray()));
}
public Vector3 getPositionAtFrame(Transform t, int frame, int frameRate, bool forceWorld)
{
int keyCount = keys.Count;
if (keyCount <= 0)
{
return(GetPosition(t));
}
AMTranslationKey firstKey = keys[0] as AMTranslationKey;
//check if behind first key
if (frame <= firstKey.frame && (!firstKey.canTween || firstKey.path.Length == 1))
{
return(convertPosition(t, firstKey.position, forceWorld));
}
AMTranslationKey lastKey = keyCount == 1 ? firstKey : keys[keyCount - 1] as AMTranslationKey;
//check if past last key
if (frame >= lastKey.endFrame && !lastKey.canTween)
{
return(convertPosition(t, lastKey.position, forceWorld));
}
//check in-between
for (int i = 0; i < keyCount; i++)
{
AMTranslationKey key = keys[i] as AMTranslationKey;
AMTranslationKey keyNext = i < keyCount - 1 ? keys[i + 1] as AMTranslationKey : null;
if (frame >= key.endFrame && keyNext != null && (!keyNext.canTween || keyNext.path.Length > 1))
{
continue;
}
if (!key.canTween || key.path.Length == 1)
{
return(convertPosition(t, key.position, forceWorld));
}
else if (key.path.Length == 0)
{
continue;
}
float fNumFrames = (float)key.getNumberOfFrames(frameRate);
float _value;
float framePositionInPath = Mathf.Clamp(frame - (float)key.frame, 0f, fNumFrames);
if (key.hasCustomEase())
{
_value = AMUtil.EaseCustom(0.0f, 1.0f, framePositionInPath / fNumFrames, key.easeCurve);
}
else
{
var ease = AMUtil.GetEasingFunction((Ease)key.easeType);
_value = ease(framePositionInPath, fNumFrames, key.amplitude, key.period);
if (float.IsNaN(_value)) //this really shouldn't happen...
{
break;
}
}
return(convertPosition(t, key.GetPoint(Mathf.Clamp01(_value)), forceWorld));
}
Debug.LogError("Animator: Could not get " + t.name + " position at frame '" + frame + "'");
return(GetPosition(t));
}
// preview a frame in the scene view
public override void previewFrame(AMITarget itarget, float frame, int frameRate, bool play, float playSpeed)
{
Transform t = GetTarget(itarget) as Transform;
if (!t)
{
return;
}
int keyCount = keys.Count;
if (keys == null || keyCount <= 0)
{
return;
}
int iFrame = Mathf.RoundToInt(frame);
AMTranslationKey firstKey = keys[0] as AMTranslationKey;
//check if behind first key
if (iFrame <= firstKey.frame && (!firstKey.canTween || firstKey.path.Length == 1))
{
SetPosition(t, firstKey.position);
return;
}
AMTranslationKey lastKey = keyCount == 1 ? firstKey : keys[keyCount - 1] as AMTranslationKey;
//check if past last key
if (iFrame >= lastKey.endFrame && !lastKey.canTween)
{
SetPosition(t, lastKey.position);
return;
}
//check in-between
for (int i = 0; i < keyCount; i++)
{
AMTranslationKey key = keys[i] as AMTranslationKey;
if (iFrame >= key.endFrame && i < keyCount - 1)
{
continue;
}
if (!key.canTween || key.path.Length == 1)
{
SetPosition(t, key.position);
return;
}
else if (key.path.Length == 0)
{
continue;
}
float fNumFrames = (float)key.getNumberOfFrames(frameRate);
float _value;
float framePositionInPath = Mathf.Clamp(frame - (float)key.frame, 0f, fNumFrames);
if (key.hasCustomEase())
{
_value = AMUtil.EaseCustom(0.0f, 1.0f, framePositionInPath / fNumFrames, key.easeCurve);
}
else
{
var ease = AMUtil.GetEasingFunction((Ease)key.easeType);
_value = ease(framePositionInPath, fNumFrames, key.amplitude, key.period);
if (float.IsNaN(_value)) //this really shouldn't happen...
{
return;
}
}
SetPosition(t, key.GetPoint(Mathf.Clamp01(_value)));
return;
}
}
public override void previewFrame(AMITarget target, float frame, int frameRate, bool play, float playSpeed)
{
if (keys == null || keys.Count <= 0)
{
return;
}
GameObject go = GetTarget(target) as GameObject;
Component comp = GetTargetComp(target);
if (!comp || !go)
{
return;
}
if (!isCached)
{
RefreshData(comp);
}
// if before or equal to first frame, or is the only frame
AMPropertyKey firstKey = keys[0] as AMPropertyKey;
if (firstKey.endFrame == -1 || (frame <= (float)firstKey.frame && !firstKey.canTween))
{
//go.rotation = (cache[0] as AMPropertyAction).getStartQuaternion();
setComponentValueFromCachedInfo(comp, firstKey.getValue(valueType));
refreshTransform(go);
return;
}
// if lies on property action
for (int i = 0; i < keys.Count; i++)
{
AMPropertyKey key = keys[i] as AMPropertyKey;
AMPropertyKey keyNext = i + 1 < keys.Count ? keys[i + 1] as AMPropertyKey : null;
if (frame >= (float)key.endFrame && keyNext != null && (!keyNext.canTween || keyNext.endFrame != -1))
{
continue;
}
// if no ease
if (!key.canTween || keyNext == null)
{
setComponentValueFromCachedInfo(comp, key.getValue(valueType));
refreshTransform(go);
return;
}
// else find value using easing function
float numFrames = (float)key.getNumberOfFrames(frameRate);
float framePositionInAction = Mathf.Clamp(frame - (float)key.frame, 0f, numFrames);
float t;
if (key.hasCustomEase())
{
t = AMUtil.EaseCustom(0.0f, 1.0f, framePositionInAction / key.getNumberOfFrames(frameRate), key.easeCurve);
}
else
{
var ease = AMUtil.GetEasingFunction((Ease)key.easeType);
t = ease(framePositionInAction, key.getNumberOfFrames(frameRate), key.amplitude, key.period);
}
//qCurrent.x = ease(qStart.x,qEnd.x,percentage);
switch ((ValueType)valueType)
{
case ValueType.Integer:
setComponentValueFromCachedInfo(comp, keyNext ? Mathf.RoundToInt(Mathf.Lerp(Convert.ToSingle(key.val), Convert.ToSingle(keyNext.val), t)) : Convert.ToInt32(key.val));
break;
case ValueType.Long:
setComponentValueFromCachedInfo(comp, keyNext ? (long)Mathf.RoundToInt(Mathf.Lerp(Convert.ToSingle(key.val), Convert.ToSingle(keyNext.val), t)) : Convert.ToInt64(key.val));
break;
case ValueType.Float:
setComponentValueFromCachedInfo(comp, keyNext ? Mathf.Lerp(Convert.ToSingle(key.val), Convert.ToSingle(keyNext.val), t) : Convert.ToSingle(key.val));
break;
case ValueType.Double:
setComponentValueFromCachedInfo(comp, keyNext ? key.val + ((double)t) * (keyNext.val - key.val) : key.val);
break;
case ValueType.Vector2:
setComponentValueFromCachedInfo(comp, keyNext ? Vector2.Lerp(key.vect2, keyNext.vect2, t) : key.vect2);
break;
case ValueType.Vector3:
setComponentValueFromCachedInfo(comp, keyNext ? Vector3.Lerp(key.vect3, keyNext.vect3, t) : key.vect3);
break;
case ValueType.Color:
setComponentValueFromCachedInfo(comp, keyNext ? Color.Lerp(key.color, keyNext.color, t) : key.color);
break;
case ValueType.Rect:
if (keyNext)
{
Rect vStartRect = key.rect;
Rect vEndRect = keyNext.rect;
Rect vCurrentRect = new Rect();
vCurrentRect.x = Mathf.Lerp(vStartRect.x, vEndRect.x, t);
vCurrentRect.y = Mathf.Lerp(vStartRect.y, vEndRect.y, t);
vCurrentRect.width = Mathf.Lerp(vStartRect.width, vEndRect.width, t);
vCurrentRect.height = Mathf.Lerp(vStartRect.height, vEndRect.height, t);
setComponentValueFromCachedInfo(comp, vCurrentRect);
}
else
{
setComponentValueFromCachedInfo(comp, key.rect);
}
break;
case ValueType.Vector4:
setComponentValueFromCachedInfo(comp, keyNext ? Vector4.Lerp(key.vect4, keyNext.vect4, t) : key.vect4);
break;
case ValueType.Quaternion:
setComponentValueFromCachedInfo(comp, keyNext ? Quaternion.Slerp(key.quat, keyNext.quat, t) : key.quat);
break;
default:
Debug.LogError("Animator: Invalid ValueType " + valueType.ToString());
break;
}
refreshTransform(go);
return;
}
}
public override void previewFrame(AMITarget target, float frame, int frameRate, bool play, float playSpeed)
{
if (keys == null || keys.Count <= 0)
{
return;
}
//TODO: figure out how to preview frame during edit
if (Application.isPlaying)
{
if (!mIsInit)
{
Init(target);
}
// if before or equal to first frame, or is the only frame
AMMaterialKey firstKey = keys[0] as AMMaterialKey;
if (firstKey.endFrame == -1 || (frame <= (float)firstKey.frame && !firstKey.canTween))
{
firstKey.ApplyValue(_propertyType, _property, mPropId, mMatInstance);
return;
}
// if lies on property action
for (int i = 0; i < keys.Count; i++)
{
AMMaterialKey key = keys[i] as AMMaterialKey;
AMMaterialKey keyNext = i + 1 < keys.Count ? keys[i + 1] as AMMaterialKey : null;
if (frame >= (float)key.endFrame && keyNext != null && (!keyNext.canTween || keyNext.endFrame != -1))
{
continue;
}
// if no ease
if (!key.canTween || keyNext == null)
{
key.ApplyValue(_propertyType, _property, mPropId, mMatInstance);
return;
}
// else find value using easing function
float numFrames = (float)key.getNumberOfFrames(frameRate);
float framePositionInAction = Mathf.Clamp(frame - (float)key.frame, 0f, numFrames);
float t;
if (key.hasCustomEase())
{
t = AMUtil.EaseCustom(0.0f, 1.0f, framePositionInAction / key.getNumberOfFrames(frameRate), key.easeCurve);
}
else
{
var ease = AMUtil.GetEasingFunction((Ease)key.easeType);
t = ease(framePositionInAction, key.getNumberOfFrames(frameRate), key.amplitude, key.period);
}
AMMaterialKey.ApplyValueLerp(_propertyType, _property, mPropId, mMatInstance, key, keyNext, t);
return;
}
}
}
// preview a frame in the scene view
public override void previewFrame(AMITarget target, float frame, int frameRate, bool play, float playSpeed)
{
Transform t = GetTarget(target) as Transform;
int keyCount = keys.Count;
if (!t)
{
return;
}
if (keys == null || keyCount <= 0)
{
return;
}
// if before or equal to first frame, or is the only frame
AMRotationKey firstKey = keys[0] as AMRotationKey;
if (firstKey.endFrame == -1 || (frame <= (float)firstKey.frame && !firstKey.canTween))
{
t.localRotation = firstKey.rotation;
return;
}
// if lies on rotation action
for (int i = 0; i < keys.Count; i++)
{
AMRotationKey key = keys[i] as AMRotationKey;
AMRotationKey keyNext = i + 1 < keys.Count ? keys[i + 1] as AMRotationKey : null;
if (frame >= (float)key.endFrame && keyNext != null && (!keyNext.canTween || keyNext.endFrame != -1))
{
continue;
}
// if no ease
if (!key.canTween || keyNext == null)
{
t.localRotation = key.rotation;
return;
}
// else find Quaternion using easing function
float numFrames = (float)key.getNumberOfFrames(frameRate);
float framePositionInAction = Mathf.Clamp(frame - (float)key.frame, 0f, numFrames);
Quaternion qStart = key.rotation;
Quaternion qEnd = keyNext.rotation;
if (key.hasCustomEase())
{
t.localRotation = Quaternion.LerpUnclamped(qStart, qEnd, AMUtil.EaseCustom(0.0f, 1.0f, framePositionInAction / numFrames, key.easeCurve));
}
else
{
var ease = AMUtil.GetEasingFunction((Ease)key.easeType);
t.localRotation = Quaternion.LerpUnclamped(qStart, qEnd, ease(framePositionInAction, numFrames, key.amplitude, key.period));
}
return;
}
}
//trans = the transform where path is relative to, null if path is already in world position
private static void DrawPathHelper(Transform trans, Vector3[] path, Color color, string method)
{
//Line Draw:
Vector3 prevPt = trans != null?trans.localToWorldMatrix.MultiplyPoint(AMUtil.Interp(path, 0)) : AMUtil.Interp(path, 0);
Gizmos.color = color;
int SmoothAmount = path.Length * 20;
for (int i = 1; i <= SmoothAmount; i++)
{
float pm = (float)i / SmoothAmount;
Vector3 currPt = AMUtil.Interp(path, pm);
if (trans != null)
{
currPt = trans.localToWorldMatrix.MultiplyPoint(currPt);
}
if (method == "gizmos")
{
Gizmos.DrawLine(currPt, prevPt);
}
else if (method == "handles")
{
Debug.LogError("AMTween Error: Drawing a path with Handles is temporarily disabled because of compatability issues with Unity 2.6!");
//UnityEditor.Handles.DrawLine(currPt, prevPt);
}
prevPt = currPt;
}
}
