// 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;
if (!t)
{
return;
}
if (keys == null || keys.Count <= 0)
{
return;
}
// if before or equal to first frame, or is the only frame
AMRotationEulerKey firstKey = keys[0] as AMRotationEulerKey;
if (firstKey.endFrame == -1 || (frame <= (float)firstKey.frame && !firstKey.canTween))
{
ApplyRot(t, firstKey.rotation);
return;
}
// if lies on rotation action
for (int i = 0; i < keys.Count; i++)
{
AMRotationEulerKey key = keys[i] as AMRotationEulerKey;
AMRotationEulerKey keyNext = i + 1 < keys.Count ? keys[i + 1] as AMRotationEulerKey : null;
if (frame >= (float)key.endFrame && keyNext != null && (!keyNext.canTween || keyNext.endFrame != -1))
{
continue;
}
// if no ease
if (!key.canTween || keyNext == null)
{
ApplyRot(t, key.rotation);
return;
}
// else easing function
float numFrames = (float)key.getNumberOfFrames(frameRate);
float framePositionInAction = Mathf.Clamp(frame - (float)key.frame, 0f, numFrames);
Vector3 qStart = key.rotation;
Vector3 qEnd = keyNext.rotation;
if (key.hasCustomEase())
{
ApplyRot(t, Vector3.Lerp(qStart, qEnd, AMUtil.EaseCustom(0.0f, 1.0f, framePositionInAction / numFrames, key.easeCurve)));
}
else
{
var ease = AMUtil.GetEasingFunction((Ease)key.easeType);
ApplyRot(t, Vector3.Lerp(qStart, qEnd, ease(framePositionInAction, numFrames, key.amplitude, key.period)));
}
return;
}
}
private void previewCameraFade(AMITarget itarget, float frame, AMCameraSwitcherKey action)
{
// if transition is None, show end camera / color
if (action.cameraFadeType == (int)AMCameraSwitcherKey.Fade.None)
{
// reset camera fade if visible
// camera
if (action.typeEnd == 0)
{
Camera endCam = action.getCameraEnd(itarget);
if (endCam)
{
AMUtil.SetTopCamera(endCam, GetCachedCameras(itarget));
}
AMCameraFade.reset();
}
else
{
showColor(action.colorEnd);
}
return;
}
// Get camerafade
AMCameraFade cf = AMCameraFade.getCameraFade();
cf.isReset = false;
bool isReversed = action.isReversed();
int firstTargetType = (isReversed ? action.typeEnd : action.type);
int secondTargetType = (isReversed ? action.type : action.typeEnd);
// Set render texture or colors if render texture is used
setRenderTexture(itarget, cf, frame, firstTargetType, secondTargetType, isReversed, action);
setColors(cf, firstTargetType, secondTargetType, isReversed, action);
if (cf.irisShape != action.irisShape)
{
cf.irisShape = action.irisShape;
}
cf.mode = action.cameraFadeType;
cf.setupMaterials();
cf.r = action.cameraFadeParameters.ToArray();
float t = (float)(frame - action.frame) / (float)(action.endFrame - action.frame);
float percentage;
if (action.hasCustomEase())
{
percentage = AMUtil.EaseCustom(0.0f, 1.0f, t, action.easeCurve);
}
else
{
var ease = AMUtil.GetEasingFunction((Ease)action.easeType);
percentage = ease(t, 1.0f, action.amplitude, action.period);
}
cf.value = 1.0f - percentage;
cf.percent = percentage;
}
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);
}
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));
}
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 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;
}
}
}
