//private float[] mFadeParams;
public void Apply(AMCameraSwitcherKey camSwitcher, int frameRate, AMITarget itarget, Camera[] allCameras, bool backwards)
{
if (mCamSwitcher != camSwitcher)
{
mCamSwitcher = camSwitcher;
float[] fadeParams = mCamSwitcher.cameraFadeParameters.ToArray();
mIsReversed = AMUtil.isTransitionReversed(mCamSwitcher.type, fadeParams);
mCam = mCamSwitcher.getCamera(itarget);
mCamEnd = mCamSwitcher.getCameraEnd(itarget);
mAllCams = allCameras;
if (mCamSwitcher.cameraFadeType == (int)Fade.None)
{
mCamSwitcher.CameraFadeNoneTargets(mCamSwitcher.typeEnd, mCamSwitcher.colorEnd, mCamEnd, mAllCams);
mCamSwitcher.CameraEnd(mIsReversed, mCam, mCamEnd, mAllCams);
}
else
{
mCamSwitcher.CameraGenerateFadeTargets(mIsReversed, mCam, mCamEnd, mAllCams, fadeParams);
}
}
mBackwards = backwards;
}
public cfTuple getCameraFadeTupleForFrame(AMITarget itarget, int frame)
{
if (keys == null || keys.Count <= 0)
{
return(new cfTuple(0, 0, 0, null, null, false));
}
for (int i = 0; i < keys.Count; i++)
{
AMCameraSwitcherKey key = keys[i] as AMCameraSwitcherKey;
// compact
if (frame < key.frame)
{
break;
}
else if (frame < key.endFrame)
{
if (!key.still || key.cameraFadeType == (int)AMCameraSwitcherKey.Fade.None || key.targetsAreEqual(itarget))
{
break;
}
bool isReversed = key.isReversed();
if (isReversed)
{
return(new cfTuple(key.endFrame, key.typeEnd, key.type, key.getCameraEnd(itarget), key.getCamera(itarget), isReversed));
}
else
{
return(new cfTuple(key.frame, key.type, key.typeEnd, key.getCamera(itarget), key.getCameraEnd(itarget), isReversed));
}
//return new cfTuple((isReversed ? (cache[i] as AMCameraSwitcherAction).endFrame : (cache[i] as AMCameraSwitcherAction).startFrame),(cache[i] as AMCameraSwitcherAction).startCamera,(cache[i] as AMCameraSwitcherAction).endCamera,isReversed);
}
}
return(new cfTuple(0, 0, 0, null, null, false));
}
public override void updateCache(AMITarget itarget)
{
base.updateCache(itarget);
for (int i = 0; i < keys.Count; i++)
{
AMCameraSwitcherKey key = keys[i] as AMCameraSwitcherKey;
key.version = version;
if (keys.Count > i + 1)
{
AMCameraSwitcherKey nextKey = keys[i + 1] as AMCameraSwitcherKey;
key.endFrame = nextKey.frame;
key.typeEnd = nextKey.type;
if (key.typeEnd == 0)
{
key.setCameraEnd(nextKey);
}
else
{
key.colorEnd = nextKey.color;
}
}
else
{
key.endFrame = -1;
}
}
_cachedAllCameras = getAllCameras(itarget);
}
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)
{
Utility.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 = Utility.EaseCustom(0.0f, 1.0f, t, action.easeCurve);
}
else
{
var ease = Utility.GetEasingFunction((Ease)action.easeType);
percentage = ease(t, 1.0f, action.amplitude, action.period);
}
cf.value = 1.0f - percentage;
cf.percent = percentage;
}
public override void CopyTo(AMKey key)
{
AMCameraSwitcherKey a = key as AMCameraSwitcherKey;
a.type = type;
a._camera = _camera;
a._cameraPath = _cameraPath;
a.color = color;
a.cameraFadeType = cameraFadeType;
a.cameraFadeParameters = new List <float>(cameraFadeParameters);
a.irisShape = irisShape;
a.still = still;
}
// 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)
{
Utility.SetTopCamera(firstCamera, GetCachedCameras(itarget));
}
}
else
{
if (secondTargetType == 0)
{
Utility.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;
}
}
}
}
// add a new key
public void addKey(AMITarget itarget, OnAddKey addCall, int _frame, Camera camera = null, /*int? type = null, Camera camera = null, Color? color = null,*/ AMCameraSwitcherKey keyToClone = null)
{
foreach (AMCameraSwitcherKey key in keys)
{
// if key exists on frame, update key
if (key.frame == _frame)
{
if (camera != null)
{
key.setCamera(itarget, camera);
key.type = 0;
updateCache(itarget);
}
return;
}
}
AMCameraSwitcherKey a = addCall(gameObject, typeof(AMCameraSwitcherKey)) as AMCameraSwitcherKey;
if (keyToClone)
{
keyToClone.CopyTo(a);
}
else
{
a.type = 0;
a.still = !AMTakeData.isProLicense;
a.easeType = (int)Ease.OutSine;
}
a.frame = _frame;
if (camera != null)
{
a.setCamera(itarget, camera);
a.type = 0;
}
// add a new key
keys.Add(a);
// update cache
updateCache(itarget);
}
public void setCameraEnd(AMCameraSwitcherKey nextKey)
{
_cameraEnd = nextKey._camera;
_cameraEndPath = nextKey._cameraPath;
}
private void setColors(AMCameraFade cf, int firstTargetType, int secondTargetType, bool isReversed, AMCameraSwitcherKey action)
{
//if(firstTargetType != 1 && secondTargetType != 1) return;
Color firstColor = (isReversed ? action.colorEnd : action.color);
Color secondColor = (isReversed ? action.color : action.colorEnd);
if (firstTargetType == 1)
{
cf.colorTex = firstColor;
cf.hasColorTex = true;
}
else
{
cf.hasColorTex = false;
}
if (secondTargetType == 1)
{
cf.colorBG = secondColor;
cf.hasColorBG = true;
}
else
{
cf.hasColorBG = false;
}
// send event to game view to repaint OnGUI
if (!Application.isPlaying && (firstTargetType == 1 || secondTargetType == 1))
{
cf.transform.position = new Vector3(cf.transform.position.x, cf.transform.position.y, cf.transform.position.z);
}
}
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)
{
Utility.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)
{
Utility.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)
{
Utility.SetTopCamera(key.getCamera(itarget), GetCachedCameras(itarget));
}
else
{
showColor(key.color);
}
}
else
{
AMCameraFade.clearRenderTexture();
previewCameraFade(itarget, frame, key);
}
return;
}
}
