public void AnimCurve_Create_AllZero()
{
// given:
var ac = new AnimCurve("");
FbxTime time;
double value;
// when:
time = new FbxTime(0);
value = ac.Evaluate(time);
// then:
Assert.AreEqual(0.0, value);
// when:
time = new FbxTime(100);
value = ac.Evaluate(time);
// then:
Assert.AreEqual(0.0, value);
// when:
time = new FbxTime(-100);
value = ac.Evaluate(time);
// then:
Assert.AreEqual(0.0, value);
// when:
time = new FbxTime(10000000L);
value = ac.Evaluate(time);
// then:
Assert.AreEqual(0.0, value);
}
public void AnimCurveNodeTest_ConnectToChannel_AddsSrcConnection()
{
// given:
var acn = new AnimCurveNode("acn");
var ac = new AnimCurve("ac");
acn.AddChannel <float>("channel1", 0.0f);
// require:
Assert.AreEqual(2, CountProperties(acn));
Assert.AreEqual(1, acn.GetChannelsCount());
Assert.AreEqual(0, acn.GetCurveCount(0));
// when:
acn.ConnectToChannel(ac, 0U);
// then:
Assert.AreEqual(2, CountProperties(acn));
Assert.AreEqual(1, acn.GetChannelsCount());
Assert.AreEqual(1, acn.GetCurveCount(0));
Assert.AreEqual(1, ac.GetDstPropertyCount());
Assert.AreEqual("channel1", ac.GetDstProperty(0).GetName());
var prop = acn.GetFirstProperty();
Assert.True(prop.IsValid());
prop = acn.GetNextProperty(prop);
Assert.True(prop.IsValid());
Assert.AreEqual(1, prop.GetSrcObjectCount());
Assert.AreSame(ac, prop.GetSrcObject(0));
}
public static CurveAnimStruct FromCurve(AnimCurve curve,
string target, bool useDegrees)
{
var convCurve = new CurveAnimStruct();
convCurve.KeyFrames = new Dictionary<float, object>();
convCurve.Target = target;
convCurve.Scale = curve.Scale;
convCurve.Offset = curve.Offset;
convCurve.WrapMode = $"{curve.PreWrap}, {curve.PostWrap}";
convCurve.Interpolation = curve.CurveType;
convCurve.FrameType = curve.FrameType;
convCurve.KeyType = curve.KeyType;
float valueScale = curve.Scale > 0 ? curve.Scale : 1;
for (int i = 0; i < curve.Frames.Length; i++)
{
var frame = curve.Frames[i];
switch (curve.CurveType)
{
case AnimCurveType.Cubic:
{
var coef0 = curve.Keys[i, 0] * valueScale + curve.Offset;
var slopes = CurveConvert.GetSlopes(curve, i);
if (useDegrees)
{
coef0 *= CurveConvert.Rad2Deg;
slopes[0] *= CurveConvert.Rad2Deg;
slopes[1] *= CurveConvert.Rad2Deg;
}
convCurve.KeyFrames.Add(frame, new HermiteKey()
{
Value = coef0,
In = slopes[0],
Out = slopes[1],
});
}
break;
case AnimCurveType.StepBool:
convCurve.KeyFrames.Add(frame, new BooleanKey()
{
Value = curve.KeyStepBoolData[i],
});
break;
case AnimCurveType.StepInt:
convCurve.KeyFrames.Add(frame, new KeyFrame()
{
Value = (int)curve.Keys[i, 0] + (int)curve.Offset
});
break;
default:
var value = curve.Keys[i, 0] * valueScale + curve.Offset;
convCurve.KeyFrames.Add(frame, new KeyFrame() {
Value = value
});
break;
}
}
return convCurve;
}
public void AnimCurve_SingleKey_AllResultsSame()
{
// given:
var ac = new AnimCurve("");
FbxTime time;
time = new FbxTime(100);
var key = new AnimCurveKey(time, 1.5f);
ac.KeyAdd(time, key);
double value;
// when:
time = new FbxTime(0);
value = ac.Evaluate(time);
// then:
Assert.AreEqual(1.5, value);
// when:
time = new FbxTime(100);
value = ac.Evaluate(time);
// then:
Assert.AreEqual(1.5, value);
// when:
time = new FbxTime(200);
value = ac.Evaluate(time);
// then:
Assert.AreEqual(1.5, value);
}
public static BooleanKeyGroup CreateBooleanTrack(AnimCurve animCurve)
{
BooleanKeyGroup track = new BooleanKeyGroup();
track.AnimDataOffset = animCurve.AnimDataOffset;
track.Scale = animCurve.Scale;
track.Offset = animCurve.Offset;
track.StartFrame = animCurve.StartFrame;
track.EndFrame = animCurve.EndFrame;
track.Delta = animCurve.Delta;
for (int i = 0; i < (ushort)animCurve.Frames.Length; i++)
{
switch (animCurve.CurveType)
{
case AnimCurveType.StepBool: //1 element are stored for step
track.Keys.Add(new BooleanKeyFrame()
{
IsKeyed = true,
InterType = InterpolationType.STEPBOOL,
Frame = (int)animCurve.Frames[i],
Visible = animCurve.KeyStepBoolData[i],
});
break;
default:
throw new Exception("Unsupported anim type!");
}
}
return(track);
}
public void AnimCurve_ThreeKeyVaryInValue_EvaluationsAreCorrect()
{
// given:
var ac = new AnimCurve("");
FbxTime time;
AnimCurveKey key;
time = new FbxTime(0);
key = new AnimCurveKey(time, -0.23f);
ac.KeyAdd(time, key);
time = new FbxTime(1000);
key = new AnimCurveKey(time, 1.6724f);
ac.KeyAdd(time, key);
time = new FbxTime(2000);
key = new AnimCurveKey(time, 1.11645f);
ac.KeyAdd(time, key);
// then:
time = new FbxTime(-200);
Assert.AreEqual(-0.230000f, ac.Evaluate(time), 0.000001);
time = new FbxTime(-150);
Assert.AreEqual(-0.230000f, ac.Evaluate(time), 0.000001);
time = new FbxTime(-100);
Assert.AreEqual(-0.230000f, ac.Evaluate(time), 0.000001);
time = new FbxTime(0);
Assert.AreEqual(-0.230000f, ac.Evaluate(time), 0.000001);
time = new FbxTime(100);
Assert.AreEqual(-0.028697f, ac.Evaluate(time), 0.000001);
time = new FbxTime(200);
Assert.AreEqual(0.189814f, ac.Evaluate(time), 0.000001);
time = new FbxTime(333);
Assert.AreEqual(0.494413f, ac.Evaluate(time), 0.000001);
time = new FbxTime(500);
Assert.AreEqual(0.874847f, ac.Evaluate(time), 0.000001);
time = new FbxTime(666);
Assert.AreEqual(1.219098f, ac.Evaluate(time), 0.000001);
time = new FbxTime(900);
Assert.AreEqual(1.581723f, ac.Evaluate(time), 0.000001);
time = new FbxTime(1000);
Assert.AreEqual(1.672400f, ac.Evaluate(time), 0.000001);
time = new FbxTime(1100);
Assert.AreEqual(1.716368f, ac.Evaluate(time), 0.000001);
time = new FbxTime(1200);
Assert.AreEqual(1.718544f, ac.Evaluate(time), 0.000001);
time = new FbxTime(1333);
Assert.AreEqual(1.669369f, ac.Evaluate(time), 0.000001);
time = new FbxTime(1654);
Assert.AreEqual(1.405046f, ac.Evaluate(time), 0.000001);
time = new FbxTime(1800);
Assert.AreEqual(1.266974f, ac.Evaluate(time), 0.000001);
time = new FbxTime(1900);
Assert.AreEqual(1.183107f, ac.Evaluate(time), 0.000001);
time = new FbxTime(2000);
Assert.AreEqual(1.116450f, ac.Evaluate(time), 0.000001);
time = new FbxTime(2100);
Assert.AreEqual(1.116450f, ac.Evaluate(time), 0.000001);
time = new FbxTime(2300);
Assert.AreEqual(1.116450f, ac.Evaluate(time), 0.000001);
}
public void AnimCurve_ThreeKeyVaryInTime_EvaluationsAreCorrect()
{
// given:
var ac = new AnimCurve("");
FbxTime time;
AnimCurveKey key;
time = new FbxTime(-150);
key = new AnimCurveKey(time, 0.0f);
ac.KeyAdd(time, key);
time = new FbxTime(1100);
key = new AnimCurveKey(time, 1.0f);
ac.KeyAdd(time, key);
time = new FbxTime(1900);
key = new AnimCurveKey(time, 2.0f);
ac.KeyAdd(time, key);
// then:
time = new FbxTime(-200);
Assert.AreEqual(0.000000f, ac.Evaluate(time), 0.000001);
time = new FbxTime(-150);
Assert.AreEqual(0.000000f, ac.Evaluate(time), 0.000001);
time = new FbxTime(-100);
Assert.AreEqual(0.039663f, ac.Evaluate(time), 0.000001);
time = new FbxTime(0);
Assert.AreEqual(0.117218f, ac.Evaluate(time), 0.000001);
time = new FbxTime(100);
Assert.AreEqual(0.192976f, ac.Evaluate(time), 0.000001);
time = new FbxTime(200);
Assert.AreEqual(0.267609f, ac.Evaluate(time), 0.000001);
time = new FbxTime(333);
Assert.AreEqual(0.366290f, ac.Evaluate(time), 0.000001);
time = new FbxTime(500);
Assert.AreEqual(0.491509f, ac.Evaluate(time), 0.000001);
time = new FbxTime(666);
Assert.AreEqual(0.620321f, ac.Evaluate(time), 0.000001);
time = new FbxTime(900);
Assert.AreEqual(0.815218f, ac.Evaluate(time), 0.000001);
time = new FbxTime(1000);
Assert.AreEqual(0.905136f, ac.Evaluate(time), 0.000001);
time = new FbxTime(1100);
Assert.AreEqual(1.000000f, ac.Evaluate(time), 0.000001);
time = new FbxTime(1200);
Assert.AreEqual(1.103992f, ac.Evaluate(time), 0.000001);
time = new FbxTime(1333);
Assert.AreEqual(1.259135f, ac.Evaluate(time), 0.000001);
time = new FbxTime(1654);
Assert.AreEqual(1.678126f, ac.Evaluate(time), 0.000001);
time = new FbxTime(1800);
Assert.AreEqual(1.871999f, ac.Evaluate(time), 0.000001);
time = new FbxTime(1900);
Assert.AreEqual(2.000000f, ac.Evaluate(time), 0.000001);
time = new FbxTime(2000);
Assert.AreEqual(2.000000f, ac.Evaluate(time), 0.000001);
time = new FbxTime(2100);
Assert.AreEqual(2.000000f, ac.Evaluate(time), 0.000001);
time = new FbxTime(2300);
Assert.AreEqual(2.000000f, ac.Evaluate(time), 0.000001);
}
public void FbxAnimCurve_Create_HasNamespacePrefix()
{
// given:
var obj = new AnimCurve("asdf");
// then:
Assert.AreEqual("AnimCurve::", obj.GetNameSpacePrefix());
}
public void AnimCurve_TwoKeyVaryInTime_EvaluationsAreCorrect()
{
// given:
var ac = new AnimCurve("");
FbxTime time;
AnimCurveKey key;
time = new FbxTime(100);
key = new AnimCurveKey(time, 0.0f);
ac.KeyAdd(time, key);
time = new FbxTime(1300);
key = new AnimCurveKey(time, 1.0f);
ac.KeyAdd(time, key);
// then:
time = new FbxTime(-200);
Assert.AreEqual(0.0f, ac.Evaluate(time), 0.000001);
time = new FbxTime(-100);
Assert.AreEqual(0.0f, ac.Evaluate(time), 0.000001);
time = new FbxTime(0);
Assert.AreEqual(0.0f, ac.Evaluate(time), 0.000001);
time = new FbxTime(100);
Assert.AreEqual(0.0f, ac.Evaluate(time), 0.000001);
time = new FbxTime(200);
Assert.AreEqual(0.0833333f, ac.Evaluate(time), 0.000001);
time = new FbxTime(250);
Assert.AreEqual(0.125f, ac.Evaluate(time), 0.000001);
time = new FbxTime(300);
Assert.AreEqual(0.166667, ac.Evaluate(time), 0.000001);
time = new FbxTime(333);
Assert.AreEqual(0.194167f, ac.Evaluate(time), 0.000001);
time = new FbxTime(400);
Assert.AreEqual(0.25f, ac.Evaluate(time), 0.000001);
time = new FbxTime(500);
Assert.AreEqual(0.333333f, ac.Evaluate(time), 0.000001);
time = new FbxTime(600);
Assert.AreEqual(0.416667f, ac.Evaluate(time), 0.000001);
time = new FbxTime(666);
Assert.AreEqual(0.471667f, ac.Evaluate(time), 0.000001);
time = new FbxTime(700);
Assert.AreEqual(0.5f, ac.Evaluate(time), 0.000001);
time = new FbxTime(750);
Assert.AreEqual(0.541667, ac.Evaluate(time), 0.000001);
time = new FbxTime(800);
Assert.AreEqual(0.583333f, ac.Evaluate(time), 0.000001);
time = new FbxTime(900);
Assert.AreEqual(0.666667f, ac.Evaluate(time), 0.000001);
time = new FbxTime(1000);
Assert.AreEqual(0.75f, ac.Evaluate(time), 0.000001);
time = new FbxTime(1100);
Assert.AreEqual(0.833333f, ac.Evaluate(time), 0.000001);
time = new FbxTime(1200);
Assert.AreEqual(0.916667f, ac.Evaluate(time), 0.000001);
time = new FbxTime(1300);
Assert.AreEqual(1.0f, ac.Evaluate(time), 0.000001);
time = new FbxTime(1400);
Assert.AreEqual(1.0f, ac.Evaluate(time), 0.000001);
}
public void AnimCurve_TwoKeyVaryInValue_EvaluationsAreCorrect()
{
// given:
var ac = new AnimCurve("");
FbxTime time;
AnimCurveKey key;
time = new FbxTime(0);
key = new AnimCurveKey(time, -0.1f);
ac.KeyAdd(time, key);
time = new FbxTime(1000);
key = new AnimCurveKey(time, 2.3f);
ac.KeyAdd(time, key);
// then:
time = new FbxTime(-200);
Assert.AreEqual(-0.1f, ac.Evaluate(time), 0.000001);
time = new FbxTime(-100);
Assert.AreEqual(-0.1f, ac.Evaluate(time), 0.000001);
time = new FbxTime(0);
Assert.AreEqual(-0.1f, ac.Evaluate(time), 0.000001);
time = new FbxTime(100);
Assert.AreEqual(0.14f, ac.Evaluate(time), 0.00001);
time = new FbxTime(200);
Assert.AreEqual(0.38f, ac.Evaluate(time), 0.00001);
time = new FbxTime(250);
Assert.AreEqual(0.5f, ac.Evaluate(time), 0.00001);
time = new FbxTime(300);
Assert.AreEqual(0.62f, ac.Evaluate(time), 0.00001);
time = new FbxTime(333);
Assert.AreEqual(0.6992f, ac.Evaluate(time), 0.00000001);
time = new FbxTime(400);
Assert.AreEqual(0.86f, ac.Evaluate(time), 0.00001);
time = new FbxTime(500);
Assert.AreEqual(1.1f, ac.Evaluate(time), 0.00001);
time = new FbxTime(600);
Assert.AreEqual(1.34f, ac.Evaluate(time), 0.00001);
time = new FbxTime(666);
Assert.AreEqual(1.4984f, ac.Evaluate(time), 0.00001);
time = new FbxTime(700);
Assert.AreEqual(1.58f, ac.Evaluate(time), 0.00001);
time = new FbxTime(750);
Assert.AreEqual(1.7, ac.Evaluate(time), 0.00001);
time = new FbxTime(800);
Assert.AreEqual(1.82f, ac.Evaluate(time), 0.00001);
time = new FbxTime(900);
Assert.AreEqual(2.06, ac.Evaluate(time), 0.00001);
time = new FbxTime(1000);
Assert.AreEqual(2.3f, ac.Evaluate(time), 0.000001);
time = new FbxTime(1100);
Assert.AreEqual(2.3f, ac.Evaluate(time), 0.000001);
time = new FbxTime(1200);
Assert.AreEqual(2.3f, ac.Evaluate(time), 0.000001);
}
public void AnimCurve_TwoKeyBasic_EvaluationsAreCorrect()
{
// given:
var ac = new AnimCurve("");
FbxTime time;
AnimCurveKey key;
time = new FbxTime(0);
key = new AnimCurveKey(time, 0.0f);
ac.KeyAdd(time, key);
time = new FbxTime(1000);
key = new AnimCurveKey(time, 1.0f);
ac.KeyAdd(time, key);
// then:
time = new FbxTime(-200);
Assert.AreEqual(0.0f, ac.Evaluate(time), 0.000001);
time = new FbxTime(-100);
Assert.AreEqual(0.0f, ac.Evaluate(time), 0.000001);
time = new FbxTime(0);
Assert.AreEqual(0.0f, ac.Evaluate(time), 0.000001);
time = new FbxTime(100);
Assert.AreEqual(0.1f, ac.Evaluate(time), 0.00001);
time = new FbxTime(200);
Assert.AreEqual(0.2f, ac.Evaluate(time), 0.00001);
time = new FbxTime(250);
Assert.AreEqual(0.25, ac.Evaluate(time), 0.00001);
time = new FbxTime(300);
Assert.AreEqual(0.3f, ac.Evaluate(time), 0.00001);
time = new FbxTime(333);
Assert.AreEqual(0.333f, ac.Evaluate(time), 0.00001);
time = new FbxTime(400);
Assert.AreEqual(0.4f, ac.Evaluate(time), 0.00001);
time = new FbxTime(500);
Assert.AreEqual(0.5f, ac.Evaluate(time), 0.00001);
time = new FbxTime(600);
Assert.AreEqual(0.6f, ac.Evaluate(time), 0.00001);
time = new FbxTime(666);
Assert.AreEqual(0.666f, ac.Evaluate(time), 0.00001);
time = new FbxTime(700);
Assert.AreEqual(0.7f, ac.Evaluate(time), 0.00001);
time = new FbxTime(750);
Assert.AreEqual(0.75f, ac.Evaluate(time), 0.000001);
time = new FbxTime(800);
Assert.AreEqual(0.8f, ac.Evaluate(time), 0.000001);
time = new FbxTime(900);
Assert.AreEqual(0.9f, ac.Evaluate(time), 0.000001);
time = new FbxTime(1000);
Assert.AreEqual(1.0f, ac.Evaluate(time), 0.000001);
time = new FbxTime(1100);
Assert.AreEqual(1.0f, ac.Evaluate(time), 0.000001);
time = new FbxTime(1200);
Assert.AreEqual(1.0f, ac.Evaluate(time), 0.000001);
}
public AnimationTrack(AnimationPlayableOutput apo, AnimationMixerPlayable amp, AnimationClipPlayable acp, AnimationClip c, GameObject objToAnimate)
{
animationPlayableOutput = apo;
animMixerPlayable = amp;
animClipPlayable = acp;
animCurve = new AnimCurve();
animCurve.animTrack = this;
animatedObject = objToAnimate.AddComponent <AnimatedObject>();
clip = c;
}
public void AnimCurve_ThreeKeyBasic_EvaluationsAreCorrect()
{
// given:
var ac = new AnimCurve("");
FbxTime time;
AnimCurveKey key;
time = new FbxTime(0);
key = new AnimCurveKey(time, 0.0f);
ac.KeyAdd(time, key);
time = new FbxTime(1000);
key = new AnimCurveKey(time, 1.0f);
ac.KeyAdd(time, key);
time = new FbxTime(2000);
key = new AnimCurveKey(time, 2.0f);
ac.KeyAdd(time, key);
// then:
time = new FbxTime(-200);
Assert.AreEqual(0.000000f, ac.Evaluate(time), 0.000001);
time = new FbxTime(-100);
Assert.AreEqual(0.000000f, ac.Evaluate(time), 0.000001);
time = new FbxTime(0);
Assert.AreEqual(0.000000f, ac.Evaluate(time), 0.000001);
time = new FbxTime(100);
Assert.AreEqual(0.100000f, ac.Evaluate(time), 0.000001);
time = new FbxTime(200);
Assert.AreEqual(0.200000f, ac.Evaluate(time), 0.000001);
time = new FbxTime(333);
Assert.AreEqual(0.333000f, ac.Evaluate(time), 0.000001);
time = new FbxTime(500);
Assert.AreEqual(0.500000f, ac.Evaluate(time), 0.000001);
time = new FbxTime(666);
Assert.AreEqual(0.666000f, ac.Evaluate(time), 0.000001);
time = new FbxTime(900);
Assert.AreEqual(0.900000f, ac.Evaluate(time), 0.000001);
time = new FbxTime(1000);
Assert.AreEqual(1.000000f, ac.Evaluate(time), 0.000001);
time = new FbxTime(1100);
Assert.AreEqual(1.100000f, ac.Evaluate(time), 0.000001);
time = new FbxTime(1333);
Assert.AreEqual(1.333000f, ac.Evaluate(time), 0.000001);
time = new FbxTime(1654);
Assert.AreEqual(1.654000f, ac.Evaluate(time), 0.000001);
time = new FbxTime(1900);
Assert.AreEqual(1.900000f, ac.Evaluate(time), 0.000001);
time = new FbxTime(2000);
Assert.AreEqual(2.000000f, ac.Evaluate(time), 0.000001);
time = new FbxTime(2100);
Assert.AreEqual(2.000000f, ac.Evaluate(time), 0.000001);
time = new FbxTime(2300);
Assert.AreEqual(2.000000f, ac.Evaluate(time), 0.000001);
}
public CameraAnimCurve(AnimCurve curve)
{
KeyFrames = new Dictionary <int, float>();
Type = ((CameraOffsetType)curve.AnimDataOffset).ToString();
for (int f = 0; f < curve.Frames.Length; f++)
{
int frame = (int)curve.Frames[f];
float Value = curve.Offset + curve.Keys[f, 0] * curve.Scale;
KeyFrames.Add(frame, Value);
}
}
private static AnimCurve SetAnimationCurve(Animation.KeyGroup keyGroup)
{
AnimCurve curve = new AnimCurve();
curve.Frames = new float[(int)keyGroup.Keys.Count];
curve.FrameType = AnimCurveFrameType.Single;
curve.KeyType = AnimCurveKeyType.Single;
curve.EndFrame = keyGroup.FrameCount;
curve.AnimDataOffset = 0;
curve.Delta = 0;
curve.Scale = 1;
curve.StartFrame = 0;
curve.Offset = 0;
var frame = keyGroup.GetKeyFrame(0);
int valuesLength = 1;
if (frame.InterType == Animation.InterpolationType.HERMITE)
{
curve.CurveType = AnimCurveType.Cubic;
curve.Keys = new float[keyGroup.Keys.Count, 4];
for (int k = 0; k < keyGroup.Keys.Count; k++)
{
float value = keyGroup.GetValue(keyGroup.Keys[k].Frame);
curve.Keys[k, 0] = value;
curve.Keys[k, 1] = 0;
curve.Keys[k, 2] = 0;
curve.Keys[k, 3] = 0;
curve.Frames[k] = keyGroup.Keys[k].Frame;
}
}
if (frame.InterType == Animation.InterpolationType.LINEAR)
{
curve.CurveType = AnimCurveType.Linear;
curve.Keys = new float[keyGroup.Keys.Count, 2];
}
if (frame.InterType == Animation.InterpolationType.STEP)
{
curve.CurveType = AnimCurveType.StepInt;
curve.Keys = new float[keyGroup.Keys.Count, 1];
}
if (frame.InterType == Animation.InterpolationType.STEPBOOL)
{
curve.CurveType = AnimCurveType.StepBool;
curve.Keys = new float[keyGroup.Keys.Count, 1];
}
return(curve);
}
public override void Generate(TileData data, StopToken stop)
{
if (stop != null && stop.stop)
{
return;
}
MatrixWorld src = data.products.ReadInlet(srcIn);
MatrixWorld mask = data.products.ReadInlet(maskIn);
if (src == null)
{
return;
}
if (!enabled)
{
data.products[this] = src; return;
}
//preparing output
if (stop != null && stop.stop)
{
return;
}
MatrixWorld dst = new MatrixWorld(src);
//curve
if (stop != null && stop.stop)
{
return;
}
AnimCurve c = new AnimCurve(curve);
for (int i = 0; i < dst.arr.Length; i++)
{
dst.arr[i] = c.Evaluate(dst.arr[i]);
}
//mask
if (stop != null && stop.stop)
{
return;
}
if (mask != null)
{
dst.InvMix(src, mask);
}
data.products[this] = dst;
}
// may need to use when opening a saved file / track that is an asset
private void RenderKeyframesPerTrack(AnimationTrack track)
{
AnimCurve curvesToCheck = track.animCurve;
Keyframe[] xKeys = curvesToCheck.curveX.keys;
Keyframe[] yKeys = curvesToCheck.curveY.keys;
Keyframe[] zKeys = curvesToCheck.curveZ.keys;
Keyframe[] rotationXkeys = curvesToCheck.rotationXcurve.keys;
Keyframe[] rotationYkeys = curvesToCheck.rotationYcurve.keys;
Keyframe[] rotationZkeys = curvesToCheck.rotationZcurve.keys;
List <float> times = new List <float>();
// how to check which keyframes are on the same time?
// return an array of times per keyframe curves?
// generate a list of keyframe UIs that you can use
// store on animation track?
// we just need at least 2 keyframe that have the same time to avoid other keyframe UIs overriding
// a keyframe checker? ---> keyframe performance data structures / algorithims
// it first checks the xkey time and reads all other keyframes
// for loop on first curve?
// before checking business logic, make sure that this time is not inside the Times List
// if it is, break and go to next time
// if not, add the time onto both list of times
// and generate a keyframe UI, which references the INDEX in the xcurve that the keyframeUI for the x curve
// for loop on second curve?
// for loop on third curve?
// for loop on forth curve?
// for loop on fifth curve?
// if the same time is found for at least one array ==> go to the next time in curveX.
// make sure that there isnt the same in the list of times
// when creating keyframeUI, make sure there is a reference to which CURVES the keyframe is referencing
}
private static List <AnimCurve> CopyCurves(GameObjectNode rNewNode, List <AnimCurve> rCurves)
{
List <AnimCurve> rNewCurves = new List <AnimCurve>();
var rNewCurveBindings = new List <EditorCurveBinding>(AnimationUtility.GetAnimatableBindings(rNewNode.NodeGo, rNewNode.NodeGo.transform.root.gameObject));
for (int i = 0; i < rCurves.Count; i++)
{
var rOldCurveBinding = rCurves[i].CurveBinding;
var rNewCurveBinding = rNewCurveBindings.Find((rItem) => { return(rItem.propertyName.Equals(rOldCurveBinding.propertyName)); });
AnimCurve rNewCurve = new AnimCurve()
{
Curve = rCurves[i].Curve, CurveBinding = rNewCurveBinding
};
rNewCurves.Add(rNewCurve);
}
return(rNewCurves);
}
public static float[] GetSlopes(AnimCurve curve, float index)
{
float[] slopes = new float[2];
if (curve.CurveType == AnimCurveType.Cubic)
{
float InSlope = 0;
float OutSlope = 0;
for (int i = 0; i < curve.Frames.Length; i++)
{
var coef0 = curve.Keys[i, 0] * curve.Scale + curve.Offset;
var coef1 = curve.Keys[i, 1] * curve.Scale;
var coef2 = curve.Keys[i, 2] * curve.Scale;
var coef3 = curve.Keys[i, 3] * curve.Scale;
float time = 0;
float delta = 0;
float invTime = 1;
if (i < curve.Frames.Length - 1)
{
var nextValue = curve.Keys[i + 1, 0] * curve.Scale + curve.Offset;
delta = nextValue - coef0;
time = curve.Frames[i + 1] - curve.Frames[i];
invTime = 1f / time;
}
float p0 = coef0;
float p1 = coef0 + (coef1 + coef3) / 3f;
float p2 = coef0 + (coef1 + coef1 + coef2) / 3f;
float p3 = coef0 + delta;
if (index == i)
{
OutSlope = (p1 - p0) * 3f * invTime;
return(new float[2] {
InSlope, OutSlope
});
}
InSlope = (p3 - p2) * 3f * invTime;
}
}
return(slopes);
}
//Method to extract the slopes from a cubic curve
//Need to get the time, delta, out and next in slope values
public static float[] GetSlopes(AnimCurve curve, float index)
{
float[] slopes = new float[2];
if (curve.CurveType == AnimCurveType.Cubic)
{
float InSlope = 0;
float OutSlope = 0;
for (int i = 0; i < curve.Frames.Length; i++)
{
var coef0 = curve.Keys[i, 0] * curve.Scale + curve.Offset;
var coef1 = curve.Keys[i, 1] * curve.Scale;
var coef2 = curve.Keys[i, 2] * curve.Scale;
var coef3 = curve.Keys[i, 3] * curve.Scale;
float time = 0;
float delta = 0;
if (i < curve.Frames.Length - 1)
{
var nextValue = curve.Keys[i + 1, 0] * curve.Scale + curve.Offset;
delta = nextValue - coef0;
time = curve.Frames[i + 1] - curve.Frames[i];
}
var slopeData = GetCubicSlopes(time, delta,
new float[4] {
coef0, coef1, coef2, coef3,
});
if (index == i)
{
OutSlope = slopeData[1];
return(new float[2] {
InSlope, OutSlope
});
}
//The previous inslope is used
InSlope = slopeData[0];
}
}
return(slopes);
}
private AnimCurve CreateAnimCurve()
{
//Create empty curve
AnimCurve curve = new AnimCurve();
curve.Offset = 0;
curve.StartFrame = 0;
curve.EndFrame = MatAnimWrapper.FrameCount;
curve.CurveType = AnimCurveType.StepInt;
curve.AnimDataOffset = 0;
curve.Scale = 1;
//Start with sbyte. Increase only if index is > 255
curve.KeyType = AnimCurveKeyType.SByte;
//Set by frame count
curve.FrameType = CurveHelper.GetFrameType((uint)MatAnimWrapper.FrameCount);
return(curve);
}
public static AnimCurve CreateLinearCurve(float[] frames, float[] values, int offset)
{
var curve = new AnimCurve();
curve.AnimDataOffset = (uint)offset;
curve.CurveType = AnimCurveType.Linear;
curve.Frames = frames;
curve.Keys = new float[values.Length, 2];
curve.Offset = 0;
curve.Scale = 1;
curve.StartFrame = 0;
curve.EndFrame = frames.LastOrDefault();
curve.FrameType = AnimCurveFrameType.Single;
curve.PostWrap = WrapMode.Repeat;
curve.PreWrap = WrapMode.Repeat;
for (int i = 0; i < values.Length; i++)
{
curve.Keys[i, 0] = values[i];
}
return(curve);
}
public void Property_AttachCurveNode_IsAnimated()
{
// given:
var node = new Node("node");
var acn = new AnimCurveNode("acn");
var x = new AnimCurve("x");
var scene = new Scene("scene");
var layer = new AnimLayer("layer");
var stack = new AnimStack("stack");
var time = new FbxTime(0);
var key = new AnimCurveKey(time, 1.0f);
x.KeyAdd(time, key);
scene.ConnectSrcObject(node);
scene.ConnectSrcObject(acn);
scene.ConnectSrcObject(x);
scene.ConnectSrcObject(layer);
scene.ConnectSrcObject(stack);
layer.ConnectSrcObject(acn);
stack.ConnectSrcObject(layer);
acn.AddChannel <double>("x", 1.0);
acn.ConnectToChannel(x, 0U);
// require:
Assert.False(node.LclTranslation.IsAnimated());
// when:
node.LclTranslation.ConnectSrcObject(acn);
// then:
Assert.True(node.LclTranslation.IsAnimated());
}
private void SaveParamInfos(MaterialAnimData data, Material mat, int ParamCurveIndex)
{
foreach (var param in mat.Params)
{
//Set our begin curve index
bool SetBeginCurve = false;
if (!SetBeginCurve)
{
data.ShaderParamCurveIndex += ParamCurveIndex;
data.BeginVisalConstantIndex += 0; //This is usually 0 so set it
SetBeginCurve = true;
}
foreach (var value in param.Values)
{
if (value.Constant)
{
AnimConstant animConstant = new AnimConstant();
animConstant.AnimDataOffset = 0;
animConstant.Value = value.GetValue(0); //Set our constant value
data.Constants.Add(animConstant);
}
else if (value.Keys.Count > 0) //Else create curves for each param value
{
//If constant, create a constant instance with the first value set
AnimCurve curve = new AnimCurve();
curve.AnimDataOffset = value.AnimDataOffset;
curve.Scale = value.Scale;
curve.Offset = value.Offset;
data.Curves.Add(curve);
}
}
}
}
public void SetUpTrackProperties(AnimatedObject aObj, Vector3 trackPosition, Timeline t, int i, Material unselectedCol, Material selectedCol)
{
animatedObject = aObj;
timeline = t;
aObj.beizerPathGroup.beizerPathData.animTrack = this;
transform.parent = timeline.transform;
transform.localPosition = trackPosition;
clip = new AnimationClip();
clip.name = $"FunClip {i}";
clip.wrapMode = WrapMode.Loop;
Debug.Log("wrapMode " + clip.wrapMode);
unselectedColor = unselectedCol;
selectedColor = selectedCol;
AnimationClipSettings tSettings = AnimationUtility.GetAnimationClipSettings(clip);
Debug.Log(tSettings.loopTime);
tSettings.loopTime = true;
Debug.Log(tSettings.loopTime);
AnimationUtility.SetAnimationClipSettings(clip, tSettings);
AssetDatabase.CreateAsset(clip, $"Assets/clip_{i}.anim");
animCurve = ScriptableObject.CreateInstance <AnimCurve>();
animCurve.clip = clip;
animCurve.animTrack = this;
animCurve.SetupAnimationCurves();
timeline.trackSectionData.ConnectTracksToPlayableGraph(clip, animatedObject.GetComponent <Animator>());
SubscribeToAnimationEvents();
Debug.Log(animCurve);
}
private void SavePatternInfos(MaterialAnimData data, Material mat, int TexturePatternCurveIndex)
{
bool SetBeginCurve = false;
foreach (var sampler in mat.Samplers)
{
//If constant, create a constant instance with the first value set
if (sampler.Constant)
{
AnimConstant animConstant = new AnimConstant();
animConstant.AnimDataOffset = 0;
animConstant.Value = sampler.GetValue(0);
data.Constants.Add(animConstant);
}
else if (sampler.Keys.Count > 0)
{
//If a sampler is not constant and uses curve data, then we need to set our begin curve index
if (!SetBeginCurve)
{
data.TexturePatternCurveIndex += TexturePatternCurveIndex;
data.BeginVisalConstantIndex += 0; //This is usually 0 so set it
SetBeginCurve = true;
}
//Create a curve to store all the index data in for each frame
AnimCurve curve = new AnimCurve();
curve.AnimDataOffset = 0;
//Set our data types. Pattern and visibilty are always the same type
if (AnimType == AnimationType.TexturePattern)
{
curve.CurveType = AnimCurveType.StepInt;
}
else if (AnimType == AnimationType.Visibilty)
{
curve.CurveType = AnimCurveType.StepBool;
}
else
{
if (sampler.InterpolationType == InterpolationType.HERMITE)
{
curve.CurveType = AnimCurveType.Cubic;
}
if (sampler.InterpolationType == InterpolationType.LINEAR)
{
curve.CurveType = AnimCurveType.Linear;
}
if (sampler.InterpolationType == InterpolationType.STEP)
{
curve.CurveType = AnimCurveType.StepInt;
}
if (sampler.InterpolationType == InterpolationType.STEPBOOL)
{
curve.CurveType = AnimCurveType.StepBool;
}
}
curve.Delta = 0;
curve.EndFrame = FrameCount;
curve.StartFrame = 0;
curve.FrameType = AnimCurveFrameType.Byte;
curve.Scale = 1;
curve.Offset = 0;
List <float> Frames = new List <float>();
List <float> Keys = new List <float>();
for (int frame = 0; frame < sampler.Keys.Count; frame++)
{
float currentIndex = sampler.GetValue(frame);
if (frame > 0)
{
float previousIndex = sampler.GetValue(frame - 1);
if (currentIndex != previousIndex)
{
//Add key frame if texture not loaded previously
Frames.Add(frame);
Keys.Add(currentIndex);
}
}
else
{
//Add the first key frame value. We would add base values here but switch has none
Frames.Add(frame);
Keys.Add(currentIndex);
}
}
for (int i = 0; i < Keys.Count; i++)
{
curve.Keys[i, 0] = Keys[i];
}
curve.Frames = Frames.ToArray();
TexturePatternCurveIndex += 1;
}
}
}
public static Animation.KeyGroup CreateTrack(AnimCurve animCurve)
{
Animation.KeyGroup track = new Animation.KeyGroup();
track.AnimDataOffset = animCurve.AnimDataOffset;
track.Scale = animCurve.Scale;
track.Offset = animCurve.Offset;
track.StartFrame = animCurve.StartFrame;
track.EndFrame = animCurve.EndFrame;
track.Delta = animCurve.Delta;
float tanscale = animCurve.Delta;
if (tanscale == 0)
{
tanscale = 1;
}
if (animCurve.Scale == 0)
{
animCurve.Scale = 1;
}
for (int i = 0; i < (ushort)animCurve.Frames.Length; i++)
{
switch (animCurve.CurveType)
{
case AnimCurveType.Cubic: //4 elements are stored for cubic
track.InterpolationType = InterpolationType.HERMITE;
track.Keys.Add(new Animation.KeyFrame()
{
IsKeyed = true,
InterType = InterpolationType.HERMITE,
Frame = (int)animCurve.Frames[i],
Value = animCurve.Offset + (animCurve.Keys[i, 0] * animCurve.Scale),
Value1 = animCurve.Offset + (animCurve.Keys[i, 0] * animCurve.Scale),
Slope1 = animCurve.Offset + (animCurve.Keys[i, 1] * animCurve.Scale),
Slope2 = animCurve.Offset + (animCurve.Keys[i, 2] * animCurve.Scale),
Delta = animCurve.Offset + (animCurve.Keys[i, 3] * animCurve.Scale),
});
break;
case AnimCurveType.Linear: //2 elements are stored for linear
track.InterpolationType = InterpolationType.LINEAR;
track.Keys.Add(new Animation.KeyFrame()
{
IsKeyed = true,
InterType = InterpolationType.LINEAR,
Frame = (int)animCurve.Frames[i],
Value = animCurve.Offset + (animCurve.Keys[i, 0] * animCurve.Scale),
Value1 = animCurve.Offset + (animCurve.Keys[i, 0] * animCurve.Scale),
Delta = animCurve.Offset + (animCurve.Keys[i, 1] * animCurve.Scale),
});
break;
case AnimCurveType.StepInt: //1 element are stored for step
track.InterpolationType = InterpolationType.STEP;
track.Keys.Add(new Animation.KeyFrame()
{
IsKeyed = true,
InterType = InterpolationType.STEP,
Frame = (int)animCurve.Frames[i],
Value = (int)animCurve.Offset + (int)animCurve.Keys[i, 0] * animCurve.Scale,
Value1 = (int)animCurve.Offset + (int)animCurve.Keys[i, 0] * animCurve.Scale,
});
break;
default:
throw new Exception("Unsupported anim type!");
}
}
return(track);
}
public void Property_MultipleStacks_GetCurveNodeOnlyGetsCurvesOnTheCurrentStack()
{
// given:
var node = new Node("node");
var scene = new Scene("scene");
var acn1 = new AnimCurveNode("acn1");
var ac1 = new AnimCurve("ac1");
var layer1 = new AnimLayer("layer1");
var stack1 = new AnimStack("stack1");
var acn2 = new AnimCurveNode("acn2");
var ac2 = new AnimCurve("ac2");
var layer2 = new AnimLayer("layer2");
var stack2 = new AnimStack("stack2");
var time = new FbxTime(0);
var key = new AnimCurveKey(time, 1.0f);
ac1.KeyAdd(time, key);
var time2 = new FbxTime(0);
var key2 = new AnimCurveKey(time2, 1.0f);
ac2.KeyAdd(time2, key2);
scene.ConnectSrcObject(node);
scene.ConnectSrcObject(acn1);
scene.ConnectSrcObject(ac1);
scene.ConnectSrcObject(layer1);
scene.ConnectSrcObject(stack1);
scene.ConnectSrcObject(acn2);
scene.ConnectSrcObject(ac2);
scene.ConnectSrcObject(layer2);
scene.ConnectSrcObject(stack2);
acn1.AddChannel <double>("x", 1.0);
acn1.ConnectToChannel(ac1, 0U);
layer1.ConnectSrcObject(acn1);
stack1.ConnectSrcObject(layer1);
acn2.AddChannel <double>("y", -1.0);
acn2.ConnectToChannel(ac2, 0U);
layer2.ConnectSrcObject(acn2);
stack2.ConnectSrcObject(layer2);
scene.SetCurrentAnimationStack(stack1);
node.LclTranslation.ConnectSrcObject(acn1);
node.LclRotation.ConnectSrcObject(acn2);
// require:
Assert.AreSame(stack1, scene.GetCurrentAnimationStack());
Assert.AreSame(acn1, node.LclTranslation.GetCurveNode());
Assert.Null(node.LclRotation.GetCurveNode());
// when:
scene.SetCurrentAnimationStack(stack2);
// then:
Assert.Null(node.LclTranslation.GetCurveNode());
Assert.AreSame(acn2, node.LclRotation.GetCurveNode());
}
private static AnimCurve SetAnimationCurve(Animation.KeyGroup keyGroup, uint DataOffset)
{
if (keyGroup.Keys.Count <= 1)
{
return(null);
}
AnimCurve curve = new AnimCurve();
curve.Frames = new float[(int)keyGroup.Keys.Count];
curve.FrameType = AnimCurveFrameType.Single;
curve.KeyType = AnimCurveKeyType.Single;
curve.AnimDataOffset = DataOffset;
curve.Scale = 1;
curve.StartFrame = 0;
curve.Offset = 0;
var keyFrame = keyGroup.GetKeyFrame(0);
if (keyFrame.InterType == InterpolationType.HERMITE)
{
curve.CurveType = AnimCurveType.Cubic;
curve.Keys = new float[keyGroup.Keys.Count, 4];
curve.Frames = new float[keyGroup.Keys.Count];
for (int k = 0; k < keyGroup.Keys.Count; k++)
{
float Delta = 0;
float frame = keyGroup.Keys[k].Frame;
if (k < keyGroup.Keys.Count - 1)
{
Delta = keyGroup.GetValue(k + 1) - keyGroup.GetValue(k);
}
float value = keyGroup.GetValue(frame);
curve.Keys[k, 0] = value;
curve.Keys[k, 1] = 0;
curve.Keys[k, 2] = 0;
curve.Keys[k, 3] = Delta;
curve.Frames[k] = keyGroup.Keys[k].Frame;
}
}
else if (keyFrame.InterType == InterpolationType.LINEAR)
{
curve.CurveType = AnimCurveType.Linear;
curve.Keys = new float[keyGroup.Keys.Count, 2];
curve.Frames = new float[keyGroup.Keys.Count];
for (int k = 0; k < keyGroup.Keys.Count; k++)
{
float frame = keyGroup.Keys[k].Frame;
float Delta = 0;
if (k < keyGroup.Keys.Count - 1)
{
Delta = keyGroup.GetValue(k + 1) - keyGroup.GetValue(k);
}
curve.Keys[k, 0] = keyGroup.GetValue(frame);
curve.Keys[k, 1] = Delta;
curve.Frames[k] = frame;
}
}
else if (keyFrame.InterType == InterpolationType.STEPBOOL)
{
curve.CurveType = AnimCurveType.StepBool;
curve.Keys = new float[keyGroup.Keys.Count, 1];
}
else
{
curve.CurveType = AnimCurveType.StepInt;
curve.Keys = new float[keyGroup.Keys.Count, 1];
curve.Frames = new float[keyGroup.Keys.Count];
for (int k = 0; k < keyGroup.Keys.Count; k++)
{
float frame = keyGroup.Keys[k].Frame;
curve.Keys[k, 0] = keyGroup.GetValue(frame);
curve.Frames[k] = frame;
}
}
//Difference of last and first key value
if (curve.Keys.Length > 0)
{
curve.Delta = curve.Keys[keyGroup.Keys.Count - 1, 0] - curve.Keys[0, 0];
}
curve.EndFrame = curve.Frames.Max();
QuantizeCurveData(curve);
return(curve);
}
private static void QuantizeCurveData(AnimCurve curve)
{
float MaxFrame = 0;
float MaxValues = 0;
List <bool> IntegerValues = new List <bool>();
for (int frame = 0; frame < curve.Frames.Length; frame++)
{
MaxFrame = Math.Max(MaxFrame, curve.Frames[frame]);
if (curve.CurveType == AnimCurveType.Linear)
{
MaxValues = Math.Max(MaxValues, curve.Keys[frame, 0]);
MaxValues = Math.Max(MaxValues, curve.Keys[frame, 1]);
IntegerValues.Add(IsInt(curve.Keys[frame, 0]));
IntegerValues.Add(IsInt(curve.Keys[frame, 1]));
}
else if (curve.CurveType == AnimCurveType.Cubic)
{
MaxValues = Math.Max(MaxValues, curve.Keys[frame, 0]);
MaxValues = Math.Max(MaxValues, curve.Keys[frame, 1]);
MaxValues = Math.Max(MaxValues, curve.Keys[frame, 2]);
MaxValues = Math.Max(MaxValues, curve.Keys[frame, 3]);
IntegerValues.Add(IsInt(curve.Keys[frame, 0]));
IntegerValues.Add(IsInt(curve.Keys[frame, 1]));
IntegerValues.Add(IsInt(curve.Keys[frame, 2]));
IntegerValues.Add(IsInt(curve.Keys[frame, 3]));
}
else
{
MaxValues = Math.Max(MaxValues, curve.Keys[frame, 0]);
IntegerValues.Add(IsInt(curve.Keys[frame, 0]));
}
int ConvertedInt = Convert.ToInt32(MaxValues);
}
if (MaxFrame < Byte.MaxValue)
{
curve.FrameType = AnimCurveFrameType.Byte;
}
else if (MaxFrame < Int16.MaxValue)
{
curve.FrameType = AnimCurveFrameType.Decimal10x5;
}
else
{
curve.FrameType = AnimCurveFrameType.Single;
}
if (IntegerValues.Any(x => x == false))
{
curve.KeyType = AnimCurveKeyType.Single;
}
else
{
if (MaxValues < Byte.MaxValue)
{
curve.KeyType = AnimCurveKeyType.SByte;
}
else if (MaxFrame < Int16.MaxValue)
{
curve.KeyType = AnimCurveKeyType.Int16;
}
else
{
curve.KeyType = AnimCurveKeyType.Single;
}
}
}
