public void Write(SceneWriter writer, object component)
{
AnimationCurve curve = component as AnimationCurve;
if (curve == null)
{
throw new Exception(GetType() + " cannot export components of type " + component.GetType());
}
writer.WriteElement("PreLoop", ConvertLoopType(curve.preWrapMode));
writer.WriteElement("PostLoop", ConvertLoopType(curve.postWrapMode));
StringBuilder sb = new StringBuilder();
// NOTE: Keyframe.tangentMode might say something about if the tangetn is smooth or broken?
Keyframe[] normalizedKeys = new Keyframe[curve.keys.Length];
for (int i = 0; i < curve.keys.Length; i++)
{
Keyframe k = curve.keys[i];
normalizedKeys[i] = new Keyframe(k.time, k.value, k.inTangent, k.outTangent);
if (i > 0)
{
Keyframe j = curve.keys[i - 1];
normalizedKeys[i - 1].outTangent = DenormalizeTangent(j.time, k.time, j.outTangent);
normalizedKeys[i].inTangent = DenormalizeTangent(j.time, k.time, k.inTangent);
}
}
foreach (Keyframe item in normalizedKeys)
{
sb.AppendFormat("{0} {1} {2} {3} {4} ", item.time, item.value, item.inTangent, item.outTangent, "Smooth");
}
writer.WriteElement("Keys", sb.ToString().TrimEnd());
}
////////////////////// AnimationCurve ///////////////////////////////////////
// constructors
static bool AnimationCurve_AnimationCurve1(JSVCall vc, int argc)
{
int _this = JSApi.getObject((int)JSApi.GetType.Arg);
JSApi.attachFinalizerObject(_this);
--argc;
int len = argc;
if (len == 1)
{
UnityEngine.Keyframe[] arg0 = JSDataExchangeMgr.GetJSArg <UnityEngine.Keyframe[]>(() =>
{
int jsObjID = JSApi.getObject((int)JSApi.GetType.Arg);
int length = JSApi.getArrayLength(jsObjID);
var ret = new UnityEngine.Keyframe[length];
for (var i = 0; i < length; i++)
{
JSApi.getElement(jsObjID, i);
ret[i] = (UnityEngine.Keyframe)JSMgr.datax.getObject((int)JSApi.GetType.SaveAndRemove);
}
return(ret);
});
JSMgr.addJSCSRel(_this, new UnityEngine.AnimationCurve(arg0));
}
return(true);
}
static public int constructor(IntPtr l)
{
int argc = LuaDLL.lua_gettop(l);
UnityEngine.Keyframe o;
if (argc == 3)
{
System.Single a1;
checkType(l, 2, out a1);
System.Single a2;
checkType(l, 3, out a2);
o = new UnityEngine.Keyframe(a1, a2);
pushObject(l, o);
return(1);
}
else if (argc == 5)
{
System.Single a1;
checkType(l, 2, out a1);
System.Single a2;
checkType(l, 3, out a2);
System.Single a3;
checkType(l, 4, out a3);
System.Single a4;
checkType(l, 5, out a4);
o = new UnityEngine.Keyframe(a1, a2, a3, a4);
pushObject(l, o);
return(1);
}
LuaDLL.luaL_error(l, "New object failed.");
return(0);
}
static public int constructor(IntPtr l)
{
try {
int argc = LuaDLL.lua_gettop(l);
UnityEngine.Keyframe o;
if (argc == 3)
{
System.Single a1;
checkType(l, 2, out a1);
System.Single a2;
checkType(l, 3, out a2);
o = new UnityEngine.Keyframe(a1, a2);
pushValue(l, o);
return(1);
}
else if (argc == 5)
{
System.Single a1;
checkType(l, 2, out a1);
System.Single a2;
checkType(l, 3, out a2);
System.Single a3;
checkType(l, 4, out a3);
System.Single a4;
checkType(l, 5, out a4);
o = new UnityEngine.Keyframe(a1, a2, a3, a4);
pushValue(l, o);
return(1);
}
return(error(l, "New object failed."));
}
catch (Exception e) {
return(error(l, e));
}
}
public ResourceObject Parse(ByteBuffer bb)
{
UnityEngine.AnimationClip clip = new UnityEngine.AnimationClip();
Schema.AnimationClip _clip = Schema.AnimationClip.GetRootAsAnimationClip(bb);
clip.frameRate = _clip.FrameRate;
clip.wrapMode = (UnityEngine.WrapMode)_clip.WrapMode;
clip.legacy = true;
for (int i = 0; i < _clip.BindingsLength; i++)
{
Schema.CurveBinding bind = _clip.GetBindings(i);
Schema.AnimationCurve _curve = bind.Curve;
UnityEngine.AnimationCurve curve = new UnityEngine.AnimationCurve();
for (int j = 0; j < _curve.KeyFramesLength; j++)
{
Schema.KeyFrame _kf = _curve.GetKeyFrames(j);
UnityEngine.Keyframe kf = new UnityEngine.Keyframe(_kf.Time, _kf.Value, _kf.InTangent, _kf.OutTangent);
kf.tangentMode = _kf.TangentMode;
curve.AddKey(kf);
}
curve.preWrapMode = (UnityEngine.WrapMode)_curve.PreWrapMode;
curve.postWrapMode = (UnityEngine.WrapMode)_curve.PostWrapMode;
var assembly = Assembly.Load("UnityEngine");
Type type = assembly.GetType(bind.Type);
clip.SetCurve(bind.Path, type, bind.PropertyName, curve);
}
return(new ResourceObjectSingle(clip));
}
public void AddKeyframe(float t, float val)
{
// Simplify keys
if (ReduceKeyframes && keyframes.Count >= 2) {
var keyStart = keyframes[keyframes.Count-2];
var keyEnd = keyframes[keyframes.Count-1];
// UseReductionThreshold: be wary, traveler. works "ok" but is not a sophisticated keyframe reduction technique
if (UseReductionThreshold) {
float deltaStart = Mathf.Abs (keyStart.value - val);
float deltaEnd = Mathf.Abs (keyEnd.value - val);
if ( deltaStart < ReductionThreshold
&& deltaEnd < ReductionThreshold) {
keyEnd.time = t;
keyEnd.value = val;
return;
}
} else {
if ( Mathf.Approximately (keyStart.value, val)
&& Mathf.Approximately (keyEnd.value, val)) {
keyEnd.time = t;
return;
}
}
}
var k = new Keyframe(t, val);
keyframes.Add (k);
}
public void EqualSource()
{
Assert.AreEqual(originClip.frameRate, clip.FrameRate);
Assert.AreEqual(originClip.wrapMode, (UnityEngine.WrapMode)clip.WrapMode);
EditorCurveBinding[] bindings = AnimationUtility.GetCurveBindings(originClip);
Assert.AreEqual(clip.BindingsLength, bindings.Length);
for (int i = 0; i < bindings.Length; i++)
{
Schema.CurveBinding bind = clip.GetBindings(i);
Assert.AreEqual(bind.PropertyName, bindings[i].propertyName);
Assert.AreEqual(bind.Path, bindings[i].path);
Assert.AreEqual(bind.Type, bindings[i].type.FullName);
Schema.AnimationCurve curv = bind.GetCurve(new Schema.AnimationCurve());
UnityEngine.AnimationCurve originCurve = AnimationUtility.GetEditorCurve(originClip, bindings[i]);
Assert.AreEqual(curv.PreWrapMode, (Schema.WrapMode)originCurve.preWrapMode);
Assert.AreEqual(curv.PostWrapMode, (Schema.WrapMode)originCurve.postWrapMode);
Assert.AreEqual(curv.KeyFramesLength, originCurve.keys.Length);
for (int j = 0; j < curv.KeyFramesLength; j++)
{
Schema.KeyFrame keyFrame = curv.GetKeyFrames(j);
UnityEngine.Keyframe originKeyframe = originCurve.keys[j];
Assert.AreEqual(keyFrame.InTangent, originKeyframe.inTangent);
Assert.AreEqual(keyFrame.OutTangent, originKeyframe.outTangent);
Assert.AreEqual(keyFrame.TangentMode, originKeyframe.tangentMode);
Assert.AreEqual(keyFrame.Time, originKeyframe.time);
Assert.AreEqual(keyFrame.Value, originKeyframe.value);
}
}
}
// fields
// properties
static void AnimationCurve_keys(JSVCall vc)
{
if (vc.bGet)
{
UnityEngine.AnimationCurve _this = (UnityEngine.AnimationCurve)vc.csObj;
var result = _this.keys;
var arrRet = result;
for (int i = 0; arrRet != null && i < arrRet.Length; i++)
{
JSMgr.datax.setObject((int)JSApi.SetType.SaveAndTempTrace, arrRet[i]);
JSApi.moveSaveID2Arr(i);
}
JSApi.setArrayS((int)JSApi.SetType.Rval, (arrRet != null ? arrRet.Length : 0), true);
}
else
{
UnityEngine.Keyframe[] arg0 = JSDataExchangeMgr.GetJSArg <UnityEngine.Keyframe[]>(() =>
{
int jsObjID = JSApi.getObject((int)JSApi.GetType.Arg);
int length = JSApi.getArrayLength(jsObjID);
var ret = new UnityEngine.Keyframe[length];
for (var i = 0; i < length; i++)
{
JSApi.getElement(jsObjID, i);
ret[i] = (UnityEngine.Keyframe)JSMgr.datax.getObject((int)JSApi.GetType.SaveAndRemove);
}
return(ret);
});
UnityEngine.AnimationCurve _this = (UnityEngine.AnimationCurve)vc.csObj;
_this.keys = arg0;
}
}
public AnimationCurve GetAnimcurve()
{
if (ac == null)
{
;
ac = AnimationCurve.Linear(0, 0, 1, 1);
}
if (skey > bkey)
{
int acl = ac.length;
for (int i = 0; i < acl; i++)
{
ac.RemoveKey(0);
}
UnityEngine.Keyframe [] kc = new UnityEngine.Keyframe[xkeys.Length];
for (int i = 0; i < xkeys.Length; i++)
{
kc [i].tangentMode = tkeys [i];
kc [i].inTangent = tikeys [i];
kc [i].outTangent = tokeys [i];
kc [i].time = xkeys [i];
kc [i].value = ykeys [i];
ac.AddKey(kc [i]);
}
bkey = skey;
}
return(ac);
}
public TreeGroup()
{
Keyframe[] keys = new Keyframe[] { new Keyframe(0f, 1f), new Keyframe(1f, 1f) };
this.distributionCurve = new AnimationCurve(keys);
this.distributionNodes = 5;
this.distributionTwirl = 0f;
this.distributionPitch = 0f;
Keyframe[] keyframeArray2 = new Keyframe[] { new Keyframe(0f, 1f), new Keyframe(1f, 1f) };
this.distributionPitchCurve = new AnimationCurve(keyframeArray2);
this.distributionScale = 1f;
Keyframe[] keyframeArray3 = new Keyframe[] { new Keyframe(0f, 1f), new Keyframe(1f, 0.3f) };
this.distributionScaleCurve = new AnimationCurve(keyframeArray3);
this.showAnimationProps = true;
this.animationPrimary = 0.5f;
this.animationSecondary = 0.5f;
this.animationEdge = 1f;
this.visible = true;
this.lockFlags = 0;
this.nodeIDs = new int[0];
this.parentGroupID = -1;
this.childGroupIDs = new int[0];
this.nodes = new List<TreeNode>();
this.parentGroup = null;
this.childGroups = new List<TreeGroup>();
}
public static void AddKeyIfChanged(this AnimationCurve curve, Keyframe keyframe)
{
var keys = curve.keys;
//If this is the first key on this curve, always add
//NOTE: Add TWO copies of the first frame, then we adjust the last frame as we move along
//This guarantees a minimum of two keys in each curve
if (keys.Length == 0)
{
curve.AddKey(keyframe);
keyframe.time += float.Epsilon;
curve.AddKey(keyframe);
}
else
{
//TODO: This method of keyframe reduction causes artifacts in animations that are supposed to deliberately pause
//Find the last keyframe
Keyframe lastKey = keys[keys.Length - 1];
if (lastKey.time >= keyframe.time)
Debug.LogError("Keyframes not supplied in consecutive order!!!");
//Grab 2 frames ago
var last2Key = keys[keys.Length - 2];
//If the previous 2 frames were different, add a new frame
if (lastKey.value != last2Key.value)
{
curve.AddKey(keyframe);
}
//The previous frame is redundant - just move it
else
{
curve.MoveKey(keys.Length - 1, keyframe);
}
}
}
static public int ctor__Single__Single__Single__Single__Single__Single_s(IntPtr l)
{
try {
UnityEngine.Keyframe o;
System.Single a1;
checkType(l, 1, out a1);
System.Single a2;
checkType(l, 2, out a2);
System.Single a3;
checkType(l, 3, out a3);
System.Single a4;
checkType(l, 4, out a4);
System.Single a5;
checkType(l, 5, out a5);
System.Single a6;
checkType(l, 6, out a6);
o = new UnityEngine.Keyframe(a1, a2, a3, a4, a5, a6);
pushValue(l, true);
pushValue(l, o);
return(2);
}
catch (Exception e) {
return(error(l, e));
}
}
public object SetObjectData(object obj, SerializationInfo info, StreamingContext context, ISurrogateSelector selector)
{
Keyframe[] keyframes;
AnimationCurve curve=new AnimationCurve();
// curve.preWrapMode=(WrapMode)info.GetValue("preWrapMode",typeof(WrapMode));
// curve.postWrapMode=(WrapMode)info.GetValue("postWrapMode",typeof(WrapMode));
int numKeys=info.GetInt32("keysn");
keyframes=new Keyframe[numKeys];
Keyframe keyframeCurrent;
for (int i=0; i<numKeys; i++) {
keyframeCurrent=keyframes[i]=new Keyframe(info.GetSingle("keyt"+i),
info.GetSingle("keyv"+i));
keyframeCurrent.tangentMode=info.GetInt32("keymod"+i);
keyframeCurrent.inTangent=info.GetSingle("keyin"+i);
keyframeCurrent.outTangent=info.GetSingle("keyout"+i);
}
curve.keys = keyframes;
// don't know how to make connection between AnimaitonCurver and Keyframes surrogate
// AnimationCurve surrogate keys are constructed before thoose in Keyframe surrogate resulting in 0,0 Keyframes
//return new AnimationCurve((Keyframe[])info.GetValue ("keys", typeof(Keyframe[])));
return curve;
}
static public int constructor(IntPtr l)
{
LuaDLL.lua_remove(l, 1);
UnityEngine.Keyframe o;
if (matchType(l, 1, typeof(System.Single), typeof(System.Single)))
{
System.Single a1;
checkType(l, 1, out a1);
System.Single a2;
checkType(l, 2, out a2);
o = new UnityEngine.Keyframe(a1, a2);
pushObject(l, o);
return(1);
}
else if (matchType(l, 1, typeof(System.Single), typeof(System.Single), typeof(System.Single), typeof(System.Single)))
{
System.Single a1;
checkType(l, 1, out a1);
System.Single a2;
checkType(l, 2, out a2);
System.Single a3;
checkType(l, 3, out a3);
System.Single a4;
checkType(l, 4, out a4);
o = new UnityEngine.Keyframe(a1, a2, a3, a4);
pushObject(l, o);
return(1);
}
LuaDLL.luaL_error(l, "New object failed.");
return(0);
}
public static int constructor(IntPtr l)
{
try {
int argc = LuaDLL.lua_gettop(l);
UnityEngine.Keyframe o;
if(argc==3){
System.Single a1;
checkType(l,2,out a1);
System.Single a2;
checkType(l,3,out a2);
o=new UnityEngine.Keyframe(a1,a2);
pushValue(l,o);
return 1;
}
else if(argc==5){
System.Single a1;
checkType(l,2,out a1);
System.Single a2;
checkType(l,3,out a2);
System.Single a3;
checkType(l,4,out a3);
System.Single a4;
checkType(l,5,out a4);
o=new UnityEngine.Keyframe(a1,a2,a3,a4);
pushValue(l,o);
return 1;
}
LuaDLL.luaL_error(l,"New object failed.");
return 0;
}
catch(Exception e) {
LuaDLL.luaL_error(l, e.ToString());
return 0;
}
}
/// <summary>
/// Read the data using the reader.
/// </summary>
/// <param name="reader">Reader.</param>
public override object Read(ISaveGameReader reader)
{
UnityEngine.Keyframe keyframe = new UnityEngine.Keyframe();
foreach (string property in reader.Properties)
{
switch (property)
{
case "time":
keyframe.time = reader.ReadProperty <System.Single>();
break;
case "value":
keyframe.value = reader.ReadProperty <System.Single>();
break;
case "inTangent":
keyframe.inTangent = reader.ReadProperty <System.Single>();
break;
case "outTangent":
keyframe.outTangent = reader.ReadProperty <System.Single>();
break;
case "tangentMode": // Obsolote
reader.ReadProperty <System.Int32>();
break;
}
}
return(keyframe);
}
public void FromKeyframe(Keyframe k)
{
this.inTangent = k.inTangent;
this.outTangent = k.outTangent;
this.time = k.time;
this.value = k.value;
}
static int AddKey(IntPtr L)
{
try
{
int count = LuaDLL.lua_gettop(L);
if (count == 2)
{
UnityEngine.AnimationCurve obj = (UnityEngine.AnimationCurve)ToLua.CheckObject(L, 1, typeof(UnityEngine.AnimationCurve));
UnityEngine.Keyframe arg0 = StackTraits <UnityEngine.Keyframe> .Check(L, 2);
int o = obj.AddKey(arg0);
LuaDLL.lua_pushinteger(L, o);
return(1);
}
else if (count == 3)
{
UnityEngine.AnimationCurve obj = (UnityEngine.AnimationCurve)ToLua.CheckObject(L, 1, typeof(UnityEngine.AnimationCurve));
float arg0 = (float)LuaDLL.luaL_checknumber(L, 2);
float arg1 = (float)LuaDLL.luaL_checknumber(L, 3);
int o = obj.AddKey(arg0, arg1);
LuaDLL.lua_pushinteger(L, o);
return(1);
}
else
{
return(LuaDLL.luaL_throw(L, "invalid arguments to method: UnityEngine.AnimationCurve.AddKey"));
}
}
catch (Exception e)
{
return(LuaDLL.toluaL_exception(L, e));
}
}
public static SerializableKeyframe[] FromKeyframeArray(Keyframe[] ks)
{
SerializableKeyframe[] keys = new SerializableKeyframe[ks.Length];
for(int i = 0; i < keys.Length; i++)
keys[i] = new SerializableKeyframe(ks[i]);
return keys;
}
public static Keyframe[] ToKeyframeArray(SerializableKeyframe[] sks)
{
Keyframe[] keys = new Keyframe[sks.Length];
for(int i = 0; i < keys.Length; i++)
keys[i] = sks[i].ToKeyframe();
return keys;
}
public static AnimationCurve JSONtoAnimationCurve(this tfxJSONArray json_data)
{
AnimationCurve anim_curve = new AnimationCurve();
anim_curve.keys = new Keyframe[0];
UnityEngine.Keyframe keyframe;
int frameIndex = 0;
foreach (tfxJSONValue frame_data in json_data)
{
keyframe = new UnityEngine.Keyframe()
{
inTangent = (float)frame_data.Obj["inTangent"].Number,
outTangent = (float)frame_data.Obj["outTangent"].Number,
#if !UNITY_2018_1_OR_NEWER
tangentMode = (int)frame_data.Obj["tangentMode"].Number,
#endif
time = (float)frame_data.Obj["time"].Number,
value = (float)frame_data.Obj["value"].Number
};
#if UNITY_2018_1_OR_NEWER && UNITY_EDITOR
AnimationUtility.SetKeyLeftTangentMode(anim_curve, frameIndex, (AnimationUtility.TangentMode)((int)frame_data.Obj["tangentModeLeft"].Number));
AnimationUtility.SetKeyRightTangentMode(anim_curve, frameIndex, (AnimationUtility.TangentMode)((int)frame_data.Obj["tangentModeRight"].Number));
#endif
anim_curve.AddKey(keyframe);
frameIndex++;
}
return(anim_curve);
}
/// <summary>
/// Creates a new Animationcurve that an interpolation between two other curves. Thanks to Oliver for creating this
/// </summary>
/// <param name="CurveA"></param>
/// <param name="CurveB"></param>
/// <param name="step"></param>
/// <returns>The new interpolated animation curve</returns>
public static AnimationCurve Interpolate(AnimationCurve CurveA, AnimationCurve CurveB, float step)
{
int I = CurveA.length < CurveB.length ? CurveB.length : CurveA.length;
var keys = new Keyframe[I];
for (int i = 0; i < I; ++i)
{
var a = GetKey(CurveA, i, I);
var b = GetKey(CurveB, i, I);
var time = Mathf.SmoothStep(a.time, b.time, step);
var value = Mathf.SmoothStep(a.value, b.value, step);
var inTangent = Mathf.SmoothStep(a.inTangent, b.inTangent, step);
var outTangent = Mathf.SmoothStep(a.outTangent, b.outTangent, step);
var c = new Keyframe(time, value, inTangent, outTangent);
keys[i] = c;
}
return new AnimationCurve(keys);
}
public TreeGroupBranch()
{
Keyframe[] keys = new Keyframe[] { new Keyframe(0f, 1f, -1f, -1f), new Keyframe(1f, 0f, -1f, -1f) };
this.radiusCurve = new AnimationCurve(keys);
this.radiusMode = true;
this.capSmoothing = 0f;
this.crinklyness = 0.1f;
Keyframe[] keyframeArray2 = new Keyframe[] { new Keyframe(0f, 1f), new Keyframe(1f, 1f) };
this.crinkCurve = new AnimationCurve(keyframeArray2);
this.seekBlend = 0f;
Keyframe[] keyframeArray3 = new Keyframe[] { new Keyframe(0f, 1f), new Keyframe(1f, 1f) };
this.seekCurve = new AnimationCurve(keyframeArray3);
this.noise = 0.1f;
Keyframe[] keyframeArray4 = new Keyframe[] { new Keyframe(0f, 1f), new Keyframe(1f, 1f) };
this.noiseCurve = new AnimationCurve(keyframeArray4);
this.noiseScaleU = 0.2f;
this.noiseScaleV = 0.1f;
this.flareSize = 0f;
this.flareHeight = 0.1f;
this.flareNoise = 0.3f;
this.weldHeight = 0.1f;
this.weldSpreadTop = 0f;
this.weldSpreadBottom = 0f;
this.breakingChance = 0f;
this.breakingSpot = new Vector2(0.4f, 0.6f);
this.frondCount = 1;
this.frondWidth = 1f;
Keyframe[] keyframeArray5 = new Keyframe[] { new Keyframe(0f, 1f), new Keyframe(1f, 1f) };
this.frondCurve = new AnimationCurve(keyframeArray5);
this.frondRange = new Vector2(0.1f, 1f);
this.frondRotation = 0f;
this.frondCrease = 0f;
}
public KFProxy(Keyframe _val)
{
inTangent = _val.inTangent;
outTangent = _val.outTangent;
tangentMode = _val.tangentMode;
time = _val.time;
value = _val.value;
}
public KeyFrameCopy(int idx, int selectionIdx, Keyframe source)
{
this.idx = idx;
this.selectionIdx = selectionIdx;
this.time = source.time;
this.value = source.value;
this.inTangent = source.inTangent;
this.outTangent = source.outTangent;
}
/// <summary>
/// Write the specified value using the writer.
/// </summary>
/// <param name="value">Value.</param>
/// <param name="writer">Writer.</param>
public override void Write(object value, ISaveGameWriter writer)
{
UnityEngine.Keyframe keyframe = (UnityEngine.Keyframe)value;
writer.WriteProperty("time", keyframe.time);
writer.WriteProperty("value", keyframe.value);
writer.WriteProperty("inTangent", keyframe.inTangent);
writer.WriteProperty("outTangent", keyframe.outTangent);
//writer.WriteProperty ( "tangentMode", keyframe.tangentMode );
}
public AnimationWindowKeyframe(AnimationWindowCurve curve, Keyframe key)
{
this.time = key.time;
this.value = key.value;
this.curve = curve;
this.m_InTangent = key.inTangent;
this.m_OutTangent = key.outTangent;
this.m_TangentMode = key.tangentMode;
}
private float GetAverageKeyValue(Keyframe[] keyFrames)
{
float num = 0f;
foreach (Keyframe keyframe in keyFrames)
{
num += keyframe.value;
}
return (num / ((float) keyFrames.Length));
}
static Keyframe KeyframeConversion(UnityEngine.Keyframe inKey)
{
return(new Keyframe
{
InTangent = inKey.inTangent,
OutTangent = inKey.outTangent,
Value = inKey.value,
Time = inKey.time
});
}
public static Boomlagoon.JSON.JSONValue ExportData(this UnityEngine.Keyframe frame)
{
Boomlagoon.JSON.JSONObject json_data = new Boomlagoon.JSON.JSONObject();
json_data["inTangent"] = frame.inTangent;
json_data["outTangent"] = frame.outTangent;
json_data["tangentMode"] = frame.tangentMode;
json_data["time"] = frame.time;
json_data["value"] = frame.value;
return(new Boomlagoon.JSON.JSONValue(json_data));
}
public KeyframeEx(UnityEngine.Keyframe keyframe)
{
this.m_Time = keyframe.time;
this.m_Value = keyframe.value;
this.m_InTangent = keyframe.inTangent;
this.m_OutTangent = keyframe.outTangent;
this.m_WeightedMode = (int)keyframe.weightedMode;
this.m_InWeight = keyframe.inWeight;
this.m_OutWeight = keyframe.outWeight;
}
// UnityEditor.CurveUtility.cs (c) Unity Technologies
public static TangentMode GetKeyTangentMode(Keyframe keyframe, int leftRight)
{
Type t = typeof( UnityEngine.Keyframe );
FieldInfo field = t.GetField( "m_TangentMode", BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance );
int tangentMode = (int)field.GetValue(keyframe);
if (leftRight == 0)
return (TangentMode) ((tangentMode & 6) >> 1);
else
return (TangentMode) ((tangentMode & 24) >> 3);
}
static public int set_inTangent(IntPtr l)
{
UnityEngine.Keyframe o = (UnityEngine.Keyframe)checkSelf(l);
float v;
checkType(l, 2, out v);
o.inTangent = v;
setBack(l, o);
return(0);
}
static public int set_tangentMode(IntPtr l)
{
UnityEngine.Keyframe o = (UnityEngine.Keyframe)checkSelf(l);
int v;
checkType(l, 2, out v);
o.tangentMode = v;
setBack(l, o);
return(0);
}
public void AddCurve()
{
SerializedProperty property = this.Get("curves");
if ((property != null) && property.isArray)
{
property.InsertArrayElementAtIndex(property.arraySize);
property.GetArrayElementAtIndex(property.arraySize - 1).FindPropertyRelative("name").stringValue = "Curve";
Keyframe[] keys = new Keyframe[] { new Keyframe(0f, 0f), new Keyframe(1f, 0f) };
property.GetArrayElementAtIndex(property.arraySize - 1).FindPropertyRelative("curve").animationCurveValue = new AnimationCurve(keys);
}
}
public static AnimationCurve ToAnimationCurve(this string curve_data)
{
AnimationCurve curve = new AnimationCurve();
string[] key_frame_data_parts = curve_data.Split('#');
if (key_frame_data_parts.Length % 5 != 0)
{
return(curve);
}
int idx = 0;
UnityEngine.Keyframe key_frame = new UnityEngine.Keyframe();
for (idx = 0; idx < key_frame_data_parts.Length; idx++)
{
if (idx % 5 == 0)
{
if (idx > 0)
{
curve.AddKey(key_frame);
}
key_frame = new Keyframe();
key_frame.time = float.Parse(key_frame_data_parts[idx]);
}
if (idx % 5 == 1)
{
key_frame.value = float.Parse(key_frame_data_parts[idx]);
}
if (idx % 5 == 2)
{
key_frame.inTangent = float.Parse(key_frame_data_parts[idx]);
}
if (idx % 5 == 3)
{
key_frame.outTangent = float.Parse(key_frame_data_parts[idx]);
}
#if !UNITY_2018_1_OR_NEWER
if (idx % 5 == 4)
{
key_frame.tangentMode = int.Parse(key_frame_data_parts[idx]);
}
#endif
}
if (idx > 0)
{
curve.AddKey(key_frame);
}
return(curve);
}
public object SetObjectData(object obj, SerializationInfo info, StreamingContext context, ISurrogateSelector selector)
{
float single = info.GetSingle("time");
float single2 = info.GetSingle("value");
int @int = info.GetInt32("tangentMode");
float single3 = info.GetSingle("inTangent");
float single4 = info.GetSingle("outTangent");
Keyframe keyframe = new Keyframe(single, single2, single3, single4);
keyframe.tangentMode = @int;
return keyframe;
}
static bool AnimationCurve_AddKey__Keyframe(JSVCall vc, int argc)
{
int len = argc;
if (len == 1)
{
UnityEngine.Keyframe arg0 = (UnityEngine.Keyframe)JSMgr.datax.getObject((int)JSApi.GetType.Arg);
JSApi.setInt32((int)JSApi.SetType.Rval, (System.Int32)(((UnityEngine.AnimationCurve)vc.csObj).AddKey(arg0)));
}
return(true);
}
public static float CalculateSmoothTangent(Keyframe key)
{
if (key.inTangent == float.PositiveInfinity)
{
key.inTangent = 0f;
}
if (key.outTangent == float.PositiveInfinity)
{
key.outTangent = 0f;
}
return ((key.outTangent + key.inTangent) * 0.5f);
}
public static AnimationCurve Clamp(this AnimationCurve curve, float minTime, float maxTime, float minValue, float maxValue) {
for (int i = 0; i < curve.keys.Length; i++) {
Keyframe key = curve.keys[i];
if (key.time < minTime || key.time > maxTime || key.value < minValue || key.value > maxValue) {
var newKey = new Keyframe(Mathf.Clamp(key.time, minTime, maxTime), Mathf.Clamp(key.value, minValue, maxValue));
newKey.inTangent = key.inTangent;
newKey.outTangent = key.outTangent;
curve.MoveKey(i, newKey);
}
}
return curve;
}
static int _CreateUnityEngine_Keyframe(IntPtr L)
{
try
{
int count = LuaDLL.lua_gettop(L);
if (count == 2)
{
float arg0 = (float)LuaDLL.luaL_checknumber(L, 1);
float arg1 = (float)LuaDLL.luaL_checknumber(L, 2);
UnityEngine.Keyframe obj = new UnityEngine.Keyframe(arg0, arg1);
ToLua.PushValue(L, obj);
return(1);
}
else if (count == 4)
{
float arg0 = (float)LuaDLL.luaL_checknumber(L, 1);
float arg1 = (float)LuaDLL.luaL_checknumber(L, 2);
float arg2 = (float)LuaDLL.luaL_checknumber(L, 3);
float arg3 = (float)LuaDLL.luaL_checknumber(L, 4);
UnityEngine.Keyframe obj = new UnityEngine.Keyframe(arg0, arg1, arg2, arg3);
ToLua.PushValue(L, obj);
return(1);
}
else if (count == 6)
{
float arg0 = (float)LuaDLL.luaL_checknumber(L, 1);
float arg1 = (float)LuaDLL.luaL_checknumber(L, 2);
float arg2 = (float)LuaDLL.luaL_checknumber(L, 3);
float arg3 = (float)LuaDLL.luaL_checknumber(L, 4);
float arg4 = (float)LuaDLL.luaL_checknumber(L, 5);
float arg5 = (float)LuaDLL.luaL_checknumber(L, 6);
UnityEngine.Keyframe obj = new UnityEngine.Keyframe(arg0, arg1, arg2, arg3, arg4, arg5);
ToLua.PushValue(L, obj);
return(1);
}
else if (count == 0)
{
UnityEngine.Keyframe obj = new UnityEngine.Keyframe();
ToLua.PushValue(L, obj);
return(1);
}
else
{
return(LuaDLL.luaL_throw(L, "invalid arguments to ctor method: UnityEngine.Keyframe.New"));
}
}
catch (Exception e)
{
return(LuaDLL.toluaL_exception(L, e));
}
}
static public int ctor_s(IntPtr l)
{
try {
UnityEngine.Keyframe o;
o = new UnityEngine.Keyframe();
pushValue(l, true);
pushValue(l, o);
return(2);
}
catch (Exception e) {
return(error(l, e));
}
}
public static Keyframe GetNew(float time, float value, TangentMode left, TangentMode right){
object boxed = new Keyframe(time,value); // cant use struct in reflection
SetKeyBroken(boxed, true);
SetKeyTangentMode(boxed, 0, left);
SetKeyTangentMode(boxed, 1, right);
Keyframe keyframe = (Keyframe)boxed;
if (left == TangentMode.Stepped )
keyframe.inTangent = float.PositiveInfinity;
if (right == TangentMode.Stepped )
keyframe.outTangent = float.PositiveInfinity;
return keyframe;
}
public static tfxJSONValue ExportData(this UnityEngine.Keyframe frame, AnimationCurve curve, int keyIndex)
{
tfxJSONObject json_data = new tfxJSONObject();
json_data["inTangent"] = frame.inTangent;
json_data["outTangent"] = frame.outTangent;
#if UNITY_2018_1_OR_NEWER && UNITY_EDITOR
json_data["leftTangentMode"] = (int)AnimationUtility.GetKeyLeftTangentMode(curve, keyIndex);
json_data["rightTangentMode"] = (int)AnimationUtility.GetKeyRightTangentMode(curve, keyIndex);
#elif !UNITY_2018_1_OR_NEWER
json_data["tangentMode"] = frame.tangentMode;
#endif
json_data["time"] = frame.time;
json_data["value"] = frame.value;
return(new tfxJSONValue(json_data));
}
static void Keyframe_tangentMode(JSVCall vc)
{
if (vc.bGet)
{
UnityEngine.Keyframe _this = (UnityEngine.Keyframe)vc.csObj;
var result = _this.tangentMode;
JSApi.setInt32((int)JSApi.SetType.Rval, (System.Int32)(result));
}
else
{
System.Int32 arg0 = (System.Int32)JSApi.getInt32((int)JSApi.GetType.Arg);
UnityEngine.Keyframe _this = (UnityEngine.Keyframe)vc.csObj;
_this.tangentMode = arg0;
JSMgr.changeJSObj(vc.jsObjID, _this);
}
}
static int _get_this(IntPtr L)
{
try
{
ToLua.CheckArgsCount(L, 2);
UnityEngine.AnimationCurve obj = (UnityEngine.AnimationCurve)ToLua.CheckObject(L, 1, typeof(UnityEngine.AnimationCurve));
int arg0 = (int)LuaDLL.luaL_checknumber(L, 2);
UnityEngine.Keyframe o = obj[arg0];
ToLua.PushValue(L, o);
return(1);
}
catch (Exception e)
{
return(LuaDLL.toluaL_exception(L, e));
}
}
static void Keyframe_value(JSVCall vc)
{
if (vc.bGet)
{
UnityEngine.Keyframe _this = (UnityEngine.Keyframe)vc.csObj;
var result = _this.value;
JSApi.setSingle((int)JSApi.SetType.Rval, (System.Single)(result));
}
else
{
System.Single arg0 = (System.Single)JSApi.getSingle((int)JSApi.GetType.Arg);
UnityEngine.Keyframe _this = (UnityEngine.Keyframe)vc.csObj;
_this.value = arg0;
JSMgr.changeJSObj(vc.jsObjID, _this);
}
}
public static AnimationWindowKeyframe AddKeyframeToCurve(AnimationWindowCurve curve, object value, System.Type type, AnimationKeyTime time)
{
AnimationWindowKeyframe keyframe = curve.FindKeyAtTime(time);
if (keyframe != null)
{
keyframe.value = value;
return keyframe;
}
AnimationWindowKeyframe key = new AnimationWindowKeyframe {
time = time.time
};
if (curve.isPPtrCurve)
{
key.value = value;
key.curve = curve;
curve.AddKeyframe(key, time);
return key;
}
if ((type == typeof(bool)) || (type == typeof(float)))
{
AnimationCurve curve2 = curve.ToAnimationCurve();
Keyframe keyframe3 = new Keyframe(time.time, (float) value);
if (type == typeof(bool))
{
CurveUtility.SetKeyTangentMode(ref keyframe3, 0, TangentMode.Stepped);
CurveUtility.SetKeyTangentMode(ref keyframe3, 1, TangentMode.Stepped);
CurveUtility.SetKeyBroken(ref keyframe3, true);
key.m_TangentMode = keyframe3.tangentMode;
key.m_InTangent = float.PositiveInfinity;
key.m_OutTangent = float.PositiveInfinity;
}
else
{
int keyIndex = curve2.AddKey(keyframe3);
if (keyIndex != -1)
{
CurveUtility.SetKeyModeFromContext(curve2, keyIndex);
Keyframe keyframe4 = curve2[keyIndex];
key.m_TangentMode = keyframe4.tangentMode;
}
}
key.value = value;
key.curve = curve;
curve.AddKeyframe(key, time);
}
return key;
}
static public int ctor__Single__Single_s(IntPtr l)
{
try {
UnityEngine.Keyframe o;
System.Single a1;
checkType(l, 1, out a1);
System.Single a2;
checkType(l, 2, out a2);
o = new UnityEngine.Keyframe(a1, a2);
pushValue(l, true);
pushValue(l, o);
return(2);
}
catch (Exception e) {
return(error(l, e));
}
}
public override object ConvertFrom(ITypeDescriptorContext context, CultureInfo culture, object value)
{
char[] separator = new char[] { '\n' };
string[] strArray = ((string) value).Split(separator);
Keyframe[] keys = new Keyframe[strArray.Length - 2];
for (int i = 0; i < keys.Length; i++)
{
char[] chArray2 = new char[] { ',' };
string[] keyvals = strArray[i + 2].Split(chArray2);
keys[i] = new Keyframe(ParseKeyVal(keyvals, Val.Time), ParseKeyVal(keyvals, Val.Value), ParseKeyVal(keyvals, Val.InTangent), ParseKeyVal(keyvals, Val.OutTangent));
}
AnimationCurve curve = new AnimationCurve(keys);
EnumConverter converter = new EnumConverter(typeof(WrapMode));
curve.postWrapMode = (WrapMode) converter.ConvertFromString(strArray[0]);
curve.preWrapMode = (WrapMode) converter.ConvertFromString(strArray[1]);
return curve;
}
static int MoveKey(IntPtr L)
{
try
{
ToLua.CheckArgsCount(L, 3);
UnityEngine.AnimationCurve obj = (UnityEngine.AnimationCurve)ToLua.CheckObject(L, 1, typeof(UnityEngine.AnimationCurve));
int arg0 = (int)LuaDLL.luaL_checknumber(L, 2);
UnityEngine.Keyframe arg1 = (UnityEngine.Keyframe)ToLua.CheckObject(L, 3, typeof(UnityEngine.Keyframe));
int o = obj.MoveKey(arg0, arg1);
LuaDLL.lua_pushinteger(L, o);
return(1);
}
catch (Exception e)
{
return(LuaDLL.toluaL_exception(L, e));
}
}
static int get_tangentMode(IntPtr L)
{
object o = null;
try
{
o = ToLua.ToObject(L, 1);
UnityEngine.Keyframe obj = (UnityEngine.Keyframe)o;
int ret = obj.tangentMode;
LuaDLL.lua_pushinteger(L, ret);
return(1);
}
catch (Exception e)
{
return(LuaDLL.toluaL_exception(L, e, o, "attempt to index tangentMode on a nil value"));
}
}
static int get_value(IntPtr L)
{
object o = null;
try
{
o = ToLua.ToObject(L, 1);
UnityEngine.Keyframe obj = (UnityEngine.Keyframe)o;
float ret = obj.value;
LuaDLL.lua_pushnumber(L, ret);
return(1);
}
catch (Exception e)
{
return(LuaDLL.toluaL_exception(L, e, o, "attempt to index value on a nil value"));
}
}
public float CalculateLinearTangent(Keyframe from, Keyframe to, int component)
{
float t = 0.01f;
Vector3 eulerCurvesDirectly1 = this.EvaluateEulerCurvesDirectly(to.time);
Vector3 eulerCurvesDirectly2 = this.EvaluateEulerCurvesDirectly(from.time);
Vector3 eulerFromQuaternion = QuaternionCurveTangentCalculation.GetEulerFromQuaternion(Quaternion.Slerp(Quaternion.Euler(eulerCurvesDirectly1), Quaternion.Euler(eulerCurvesDirectly2), t), eulerCurvesDirectly1);
switch (component)
{
case 0:
return (float) (((double) eulerFromQuaternion.x - (double) eulerCurvesDirectly1.x) / (double) t / -((double) to.time - (double) from.time));
case 1:
return (float) (((double) eulerFromQuaternion.y - (double) eulerCurvesDirectly1.y) / (double) t / -((double) to.time - (double) from.time));
case 2:
return (float) (((double) eulerFromQuaternion.z - (double) eulerCurvesDirectly1.z) / (double) t / -((double) to.time - (double) from.time));
default:
return 0.0f;
}
}
void Start()
{
// TODO these values and animation itself are affected by other camera scripts (e.g. MouseOrbit)
// Create 'S' shaped curve to adjust pitch
// Varies from 0 (looking forward) at 0, to 90 (looking straight down) at 1
_pitchCurve = AnimationCurve.EaseInOut(0.0f, 0.0f, 1.0f, 90.0f);
// Create exponential shaped curve to adjust distance
// So zoom control will be more accurate at closer distances, and more coarse further away
Keyframe[] ks = new Keyframe[2];
// At zoom=0, offset by 2 units
ks[0] = new Keyframe(0, 2f);
ks[0].outTangent = 0;
// At zoom=1, offset by Distance units
ks[1] = new Keyframe(1, Distance);
ks[1].inTangent = 90;
_distanceCurve = new AnimationCurve(ks);
}
private float GetMaxKeyValue(Keyframe[] keyFrames)
{
float negativeInfinity = float.NegativeInfinity;
float positiveInfinity = float.PositiveInfinity;
foreach (Keyframe keyframe in keyFrames)
{
if (keyframe.value > negativeInfinity)
{
negativeInfinity = keyframe.value;
}
if (keyframe.value < positiveInfinity)
{
positiveInfinity = keyframe.value;
}
}
if (Mathf.Abs(positiveInfinity) > negativeInfinity)
{
return positiveInfinity;
}
return negativeInfinity;
}
public float CalculateLinearTangent(Keyframe from, Keyframe to, int component)
{
float t = 0.01f;
Vector3 euler = this.EvaluateEulerCurvesDirectly(to.time);
Vector3 vector2 = this.EvaluateEulerCurvesDirectly(from.time);
Quaternion a = Quaternion.Euler(euler);
Quaternion b = Quaternion.Euler(vector2);
Vector3 eulerFromQuaternion = GetEulerFromQuaternion(Quaternion.Slerp(a, b, t), euler);
switch (component)
{
case 0:
return (((eulerFromQuaternion.x - euler.x) / t) / -(to.time - from.time));
case 1:
return (((eulerFromQuaternion.y - euler.y) / t) / -(to.time - from.time));
case 2:
return (((eulerFromQuaternion.z - euler.z) / t) / -(to.time - from.time));
}
return 0f;
}
public float CalculateLinearTangent(Keyframe from, Keyframe to, int component)
{
float num = 0.01f;
Vector3 vector = this.EvaluateEulerCurvesDirectly(to.time);
Vector3 euler = this.EvaluateEulerCurvesDirectly(from.time);
Quaternion from2 = Quaternion.Euler(vector);
Quaternion to2 = Quaternion.Euler(euler);
Quaternion q = Quaternion.Slerp(from2, to2, num);
Vector3 eulerFromQuaternion = QuaternionCurveTangentCalculation.GetEulerFromQuaternion(q, vector);
switch (component)
{
case 0:
return (eulerFromQuaternion.x - vector.x) / num / -(to.time - from.time);
case 1:
return (eulerFromQuaternion.y - vector.y) / num / -(to.time - from.time);
case 2:
return (eulerFromQuaternion.z - vector.z) / num / -(to.time - from.time);
default:
return 0f;
}
}
public AnimationCurve loadAnimationCurve(string[] curveData)
{
char[] cParams = new char[] { ' ', ',', ';', '\t' };
AnimationCurve animationCurve = new AnimationCurve();
try
{
for (int i = 0; i < curveData.Length; i++)
{
string[] keyTmp = curveData[i].Split(cParams, StringSplitOptions.RemoveEmptyEntries);
if (keyTmp.Length == 4)
{
print("*RSS* " + keyTmp[0] + " " + keyTmp[1] + " " + keyTmp[2] + " " + keyTmp[3]);
Keyframe key = new Keyframe();
key.time = float.Parse(keyTmp[0]);
key.value = float.Parse(keyTmp[1]);
key.inTangent = float.Parse(keyTmp[2]);
key.outTangent = float.Parse(keyTmp[3]);
animationCurve.AddKey(key);
}
else if (keyTmp.Length == 2)
{
print("*RSS* " + keyTmp[0] + " " + keyTmp[1]);
Keyframe key = new Keyframe();
key.time = float.Parse(keyTmp[0]);
key.value = float.Parse(keyTmp[1]);
animationCurve.AddKey(key);
}
else
{
MonoBehaviour.print("*RSS* Invalid animationCurve data: animationCurve data must have exactly two or four parameters!");
}
}
return animationCurve;
}
catch (Exception e)
{
print("Caught exception while parsing animationcurve: " + e.Message);
return null;
}
}
/// <summary>
/// Adds the keyframe to curve.
/// </summary>
/// <param name="animationCurve">Animation curve.</param>
/// <param name="animatedClip">Animated clip.</param>
/// <param name="binding">Binding.</param>
/// <param name="value">Value.</param>
/// <param name="type">Type.</param>
/// <param name="time">Time.</param>
public static void AddKeyframeToCurve(AnimationCurve animationCurve, AnimationClip animatedClip, EditorCurveBinding binding, float value, Type type, float time)
{
//frame comparing (frame=(int)(time*animatedClip.frameRate)
int keyframeIndex = Array.FindIndex (animationCurve.keys, (itm) => (int)(itm.time * animatedClip.frameRate) == (int)(time * animatedClip.frameRate));
Keyframe key = default(Keyframe);
if (keyframeIndex < 0) {
if (type == typeof(bool) || type == typeof(float)) {
key = new Keyframe (time, value);
if (type == typeof(bool)) {
//CurveUtility.SetKeyTangentMode (ref key, 0, TangentMode.Stepped);
//CurveUtility.SetKeyTangentMode (ref key, 1, TangentMode.Stepped);
//CurveUtility.SetKeyBroken (ref key, true);
key.SetKeyTangentMode (0, TangentMode.Stepped);
key.SetKeyTangentMode (1, TangentMode.Stepped);
key.SetKeyBroken (true);
} else {
int num = animationCurve.AddKey (key);
if (num != -1) {
animationCurve.SetKeyModeFromContext (num);
}
}
}
} else {
//??? maybe I should add new time too
//animationCurve.keys[keyframeIndex].value=value;
key = animationCurve.keys [keyframeIndex];
key.value = value;
animationCurve.MoveKey (keyframeIndex, key);
}
//Save changes
SaveCurve (animationCurve, animatedClip, binding);
}