public float GetFrameValue(KeyFrameMode mode, int index, bool linear, bool loop)
{
KeyframeEntry entry, root = _keyRoots[(int)mode & 0xF];
if (index >= root._prev._index)
{
//if (!loop || root._prev == root._next)
return(root._prev._value);
}
//else
// return root._prev.Interpolate2(_frameCount - index + root._next._index, _linearRot || linear, _frameCount);
if (index <= root._next._index)
{
//if (!loop || root._prev == root._next)
return(root._next._value);
}
//else
// return root._prev.Interpolate2(_frameCount - root._prev._index + index, _linearRot || linear, _frameCount);
for (entry = root._next;
(entry != root) &&
(entry._index < index);
entry = entry._next)
{
if (entry._index == index)
{
return(entry._value);
}
}
return(entry._prev.Interpolate(index - entry._prev._index, _linearRot || linear));
}
public float GetFrameValue(KeyFrameMode mode, int index)
{
KeyframeEntry entry, root = _keyRoots[(int)mode & 0xF];
if (index >= root._prev._index)
{
return(root._prev._value);
}
if (index <= root._next._index)
{
return(root._next._value);
}
for (entry = root._next; (entry != root) && (entry._index < index); entry = entry._next)
{
;
}
if (entry._index == index)
{
return(entry._value);
}
return(entry._prev.Interpolate(index - entry._prev._index, _linearRot));
}
public float GetFrameValue(KeyFrameMode mode, int index)
{
KeyframeEntry entry, root = _keyRoots[(int)mode & 0xF];
if (index >= root._prev._index)
{
return(root._prev._value);
}
if (index <= root._next._index)
{
return(root._next._value);
}
//Find the entry just before the specified index
for (entry = root._next; //Get the first entry
(entry != root) && //Make sure it's not the root
(entry._index < index); //Its index must be less than the current index
entry = entry._next) //Get the next entry
{
if (entry._index == index) //The index is a keyframe
{
return(entry._value); //Return the value of the keyframe.
}
}
//There was no keyframe... interpolate!
return(entry._prev.Interpolate(index - entry._prev._index, _linearRot));
}
public KeyframeEntry SetFrameValue(KeyFrameMode mode, int index, float value)
{
KeyframeEntry entry = null, root;
for (int x = (int)mode & 0xF, y = x + ((int)mode >> 4); x < y; x++)
{
root = _keyRoots[x];
if ((root._prev == root) || (root._prev._index < index))
{
entry = root;
}
else
{
for (entry = root._next; (entry != root) && (entry._index <= index); entry = entry._next)
{
;
}
}
entry = entry._prev;
if (entry._index != index)
{
_keyCounts[x]++;
entry.InsertAfter(entry = new KeyframeEntry(index, value));
}
else
{
entry._value = value;
}
}
return(entry);
}
public KeyframeEntry Remove(KeyFrameMode mode, int index)
{
KeyframeEntry entry = null, root;
for (int x = (int)mode & 0xF, y = x + ((int)mode >> 4); x < y; x++)
{
root = _keyRoots[x];
for (entry = root._next; (entry != root) && (entry._index < index); entry = entry._next)
{
;
}
if (entry._index == index)
{
entry.Remove();
_keyCounts[x]--;
}
else
{
entry = null;
}
}
return(entry);
}
public DialogResult ShowDialog(IWin32Window owner, KeyFrameMode type, CHR0EntryNode target)
{
_target = target;
_type = type;
comboBox1.Items.Add("Add");
comboBox1.Items.Add("Subtract");
comboBox1.SelectedIndex = 0;
return(base.ShowDialog(owner));
}
public void SetKeyframe(KeyFrameMode mode, int index, float value)
{
KeyframeEntry k = Keyframes.SetFrameValue(mode, index, value);
k.GenerateTangent();
k._prev.GenerateTangent();
k._next.GenerateTangent();
SignalPropertyChange();
}
public void RemoveKeyframe(KeyFrameMode mode, int index)
{
KeyframeEntry k = Keyframes.Remove(mode, index);
if (k != null && _generateTangents)
{
k.GenerateTangent();
k._prev.GenerateTangent();
k._next.GenerateTangent();
}
}
public void RemoveKeyframe(KeyFrameMode mode, int index)
{
KeyframeEntry k = Keyframes.Remove(mode, index);
if (k != null)
{
k._prev.GenerateTangent();
k._next.GenerateTangent();
SignalPropertyChange();
}
}
public static void Serialize(CHR0Node node, bool bake, string output)
{
using (StreamWriter file = new StreamWriter(output))
{
file.WriteLine("animVersion 1.1;");
file.WriteLine("mayaVersion 2014 x64;");
file.WriteLine("timeUnit ntsc;");
file.WriteLine("linearUnit cm;");
file.WriteLine("angularUnit deg;");
file.WriteLine("startTime 1;");
file.WriteLine(String.Format("endTime {0};", node.FrameCount));
foreach (CHR0EntryNode e in node.Children)
{
KeyframeCollection c = e.Keyframes;
for (int index = 0; index < 9; index++)
{
KeyFrameMode m = (KeyFrameMode)(index + 0x10);
if (c[m] <= 0)
{
continue;
}
file.WriteLine(String.Format("anim {0}.{0}{1} {0}{1} {2} {3} {4} {5}", types[index / 3], axes[index % 3], e.Name, e.Index, index / 3, index % 3));
file.WriteLine("animData {");
file.WriteLine(" input time;");
file.WriteLine(String.Format(" output {0};", index > 2 && index < 6 ? "angular" : "linear"));
file.WriteLine(" weighted 1;");
file.WriteLine(" preInfinity constant;");
file.WriteLine(" postInfinity constant;");
file.WriteLine(" keys {");
for (KeyframeEntry entry = c._keyRoots[index]._next; (entry != c._keyRoots[index]); entry = entry._next)
{
float angle = (float)Math.Atan(entry._tangent) * Maths._rad2degf;
file.WriteLine(String.Format(" {0} {1} {2} {3} {4} {5} {6} {7} {8} {9} {10};",
entry._index + 1,
entry._value.ToString(CultureInfo.InvariantCulture.NumberFormat),
"fixed",
"fixed",
"1",
"1",
"0",
angle.ToString(CultureInfo.InvariantCulture.NumberFormat),
(Math.Abs(entry._tangent) + 1).ToString(CultureInfo.InvariantCulture.NumberFormat),
angle.ToString(CultureInfo.InvariantCulture.NumberFormat),
(Math.Abs(entry._tangent) + 1).ToString(CultureInfo.InvariantCulture.NumberFormat)));
}
file.WriteLine(" }");
file.WriteLine("}");
}
}
}
}
public KeyframeEntry GetKeyframe(KeyFrameMode mode, int index)
{
KeyframeEntry entry, root = _keyRoots[(int)mode & 0xF];
for (entry = root._next; (entry != root) && (entry._index < index); entry = entry._next)
{
;
}
if (entry._index == index)
{
return(entry);
}
return(null);
}
public KeyframeEntry SetKeyframe(KeyFrameMode mode, int index, float value, bool forceNoGenTans)
{
KeyframeEntry k = Keyframes.SetFrameValue(mode, index, value);
if (_generateTangents && !forceNoGenTans)
{
k.GenerateTangent();
k._prev.GenerateTangent();
k._next.GenerateTangent();
}
SignalPropertyChange();
return(k);
}
private static void DecodeSRT0Frames(KeyframeCollection kf, void *dataAddr, KeyFrameMode mode)
{
int fCount;
I12Header *header = (I12Header *)dataAddr;
fCount = header->_numFrames;
I12Entry *entry = header->Data;
for (int i = 0; i < fCount; i++, entry++)
{
kf.SetFrameValue(mode, (int)entry->_index, entry->_value)._tangent = entry->_tangent;
}
}
public void Delete(KeyFrameMode mode, int index)
{
KeyframeEntry entry = null, root;
for (int x = (int)mode & 0xF, y = x + ((int)mode >> 4); x < y; x++)
{
root = _keyRoots[x];
for (entry = root._prev; (entry != root) && (entry._index >= index); entry = entry._prev)
{
if ((entry._index == index) || (--entry._index < 0))
{
entry = entry._next;
entry._prev.Remove();
_keyCounts[x]--;
}
}
}
}
public void Insert(KeyFrameMode mode, int index)
{
KeyframeEntry entry = null, root;
for (int x = (int)mode & 0xF, y = x + ((int)mode >> 4); x < y; x++)
{
root = _keyRoots[x];
for (entry = root._prev; (entry != root) && (entry._index >= index); entry = entry._prev)
{
if (++entry._index >= _frameLimit)
{
entry = entry._next;
entry._prev.Remove();
_keyCounts[x]--;
}
}
}
}
public KeyframeEntry SetKeyframe(KeyFrameMode mode, int index, float value)
{
bool exists = Keyframes.GetKeyframe(mode, index) != null;
KeyframeEntry k = Keyframes.SetFrameValue(mode, index, value);
if (!exists && !_generateTangents)
{
k.GenerateTangent();
}
if (_generateTangents)
{
k.GenerateTangent();
k._prev.GenerateTangent();
k._next.GenerateTangent();
}
SignalPropertyChange();
return(k);
}
private static int EncodeEntry(int index, AnimDataFormat format, KeyframeCollection kf, VoidPtr addr)
{
int numFrames = kf._frameCount;
KeyframeEntry frame, root = kf._keyRoots[index];
bfloat * pVal = (bfloat *)addr;
float val, frameScale = numFrames <= 1 ? 1 : 1.0f / (numFrames - 1);
float min, max, stride, step;
int span, i;
int keyCount = kf._keyCounts[index];
KeyFrameMode mode = KeyFrameMode.ScaleX + index;
if (format == AnimDataFormat.L4)
{
//Use all frames, just in case not all frames are key.
for (i = 0; i < numFrames; i++)
{
*pVal++ = kf[mode, i];
}
return(numFrames * 4);
}
if (format == AnimDataFormat.I12)
{
I12Header *header = (I12Header *)addr;
* header = new I12Header(keyCount, frameScale);
I12Entry *entry = header->Data;
for (frame = root._next; frame._index != -1; frame = frame._next)
{
*entry++ = new I12Entry(frame._index, frame._value, frame._tangent);
}
return(keyCount * 12 + 8);
}
//Get floor/ceil/stride
min = float.MaxValue; max = float.MinValue;
for (frame = root._next; frame != root; frame = frame._next)
{
val = frame._value;
if (val > max)
{
max = val;
}
if (val < min)
{
min = val;
}
}
stride = max - min;
if (format == AnimDataFormat.L1)
{
//Find best span
span = EvalSpan(255, 32, min, stride, root, true, kf._linearRot);
step = stride / span;
L1Header *header = (L1Header *)addr;
* header = new L1Header(step, min);
byte *dPtr = header->Data;
for (i = 0; i < numFrames; i++)
{
*dPtr++ = (byte)((kf[mode, i] - min) / step + 0.5f);
}
//Fill remaining bytes
while ((i++ & 3) != 0)
{
*dPtr++ = 0;
}
return((8 + numFrames).Align(4));
}
if (format == AnimDataFormat.I4)
{
//Find best span
span = EvalSpan(4095, 32, min, stride, root, false, false);
step = stride / span;
I4Header *header = (I4Header *)addr;
* header = new I4Header(keyCount, frameScale, step, min);
I4Entry *entry = header->Data;
for (frame = root._next; frame._index != -1; frame = frame._next)
{
val = (frame._value - min) / step;
val += (val < 0 ? -0.5f : 0.5f);
*entry++ = new I4Entry(frame._index, (int)val, frame._tangent);
}
return(keyCount * 4 + 16);
}
if (format == AnimDataFormat.I6)
{
//Find best span
span = EvalSpan(65535, 32, min, stride, root, false, false);
step = stride / span;
I6Header *header = (I6Header *)addr;
* header = new I6Header(keyCount, frameScale, step, min);
I6Entry *entry = header->Data;
for (frame = root._next; frame._index != -1; frame = frame._next)
{
val = ((frame._value - min) / step);
val += (val < 0 ? -0.5f : 0.5f);
*entry++ = new I6Entry(frame._index, (int)val, frame._tangent);
}
//Fill remaining bytes
if ((keyCount & 1) != 0)
{
entry->_data = 0;
}
return(((keyCount * 6) + 16).Align(4));
}
return(0);
}
public float GetFrameValue(KeyFrameMode mode, int index)
{
return(Keyframes.GetFrameValue(mode, index));
}
public float GetFrameValue(KeyFrameMode mode, int index, bool linear, bool loop)
{
return(Keyframes.GetFrameValue(mode, index, linear, loop));
}
public static CHR0Node Read(string input)
{
CHR0Node node = new CHR0Node()
{
_name = Path.GetFileNameWithoutExtension(input)
};
using (StreamReader file = new StreamReader(input))
{
float start = 0.0f;
float end = 0.0f;
string line = "";
while (true)
{
line = file.ReadLine();
int i = line.IndexOf(' ');
string tag = line.Substring(0, i);
if (tag == "anim")
{
break;
}
string val = line.Substring(i + 1, line.IndexOf(';') - i - 1);
switch (tag)
{
case "startTime":
case "startUnitless":
float.TryParse(val, out start);
break;
case "endTime":
case "endUnitless":
float.TryParse(val, out end);
break;
case "animVersion":
case "mayaVersion":
case "timeUnit":
case "linearUnit":
case "angularUnit":
default:
break;
}
}
int frameCount = (int)(end - start + 1.5f);
node.FrameCount = frameCount;
while (true)
{
if (line == null)
{
break;
}
string[] anim = line.Split(' ');
if (anim.Length != 7)
{
while ((line = file.ReadLine()) != null && !line.StartsWith("anim "))
{
;
}
continue;
}
string t = anim[2];
string bone = anim[3];
KeyFrameMode mode = KeyFrameMode.All;
if (t.StartsWith("scale"))
{
if (t.EndsWith("X"))
{
mode = KeyFrameMode.ScaleX;
}
else if (t.EndsWith("Y"))
{
mode = KeyFrameMode.ScaleY;
}
else if (t.EndsWith("Z"))
{
mode = KeyFrameMode.ScaleZ;
}
}
else if (t.StartsWith("rotate"))
{
if (t.EndsWith("X"))
{
mode = KeyFrameMode.RotX;
}
else if (t.EndsWith("Y"))
{
mode = KeyFrameMode.RotY;
}
else if (t.EndsWith("Z"))
{
mode = KeyFrameMode.RotZ;
}
}
else if (t.StartsWith("translate"))
{
if (t.EndsWith("X"))
{
mode = KeyFrameMode.TransX;
}
else if (t.EndsWith("Y"))
{
mode = KeyFrameMode.TransY;
}
else if (t.EndsWith("Z"))
{
mode = KeyFrameMode.TransZ;
}
}
if (mode == KeyFrameMode.All)
{
while ((line = file.ReadLine()) != null && !line.StartsWith("anim "))
{
;
}
continue;
}
line = file.ReadLine();
if (line.StartsWith("animData"))
{
CHR0EntryNode e;
if ((e = node.FindChild(bone, false) as CHR0EntryNode) == null)
{
e = new CHR0EntryNode()
{
_name = bone, _numFrames = frameCount
};
node.AddChild(e);
}
while (true)
{
line = file.ReadLine().TrimStart();
int i = line.IndexOf(' ');
if (i < 0)
{
break;
}
string tag = line.Substring(0, i);
if (tag == "keys")
{
List <KeyframeEntry> l = new List <KeyframeEntry>();
while (true)
{
line = file.ReadLine().TrimStart();
if (line == "}")
{
break;
}
string[] s = line.Split(' ');
float inVal, outVal;
float.TryParse(s[0], NumberStyles.Number, CultureInfo.InvariantCulture, out inVal);
float.TryParse(s[1], NumberStyles.Number, CultureInfo.InvariantCulture, out outVal);
float finalTan = 0;
float weight1 = 0;
float weight2 = 0;
float angle1 = 0;
float angle2 = 0;
bool firstFixed = false;
bool secondFixed = false;
switch (s[2])
{
case "linear":
case "spline":
case "auto":
break;
case "fixed":
firstFixed = true;
float.TryParse(s[7], NumberStyles.Number, CultureInfo.InvariantCulture, out angle1);
float.TryParse(s[8], NumberStyles.Number, CultureInfo.InvariantCulture, out weight1);
break;
}
switch (s[3])
{
case "linear":
case "spline":
case "auto":
break;
case "fixed":
secondFixed = true;
if (firstFixed)
{
float.TryParse(s[9], NumberStyles.Number, CultureInfo.InvariantCulture, out angle2);
float.TryParse(s[10], NumberStyles.Number, CultureInfo.InvariantCulture, out weight2);
}
else
{
float.TryParse(s[7], NumberStyles.Number, CultureInfo.InvariantCulture, out angle2);
float.TryParse(s[8], NumberStyles.Number, CultureInfo.InvariantCulture, out weight2);
}
break;
}
bool anyFixed = (secondFixed || firstFixed);
bool bothFixed = (secondFixed && firstFixed);
KeyframeEntry x = e.SetKeyframe(mode, (int)(inVal - 0.5f), outVal, true);
if (!anyFixed)
{
l.Add(x);
}
else
{
if (bothFixed)
{
finalTan = (float)Math.Tan(((angle1 + angle2) / 2) * Maths._deg2radf) * ((weight1 + weight2) / 2);
}
else if (firstFixed)
{
finalTan = (float)Math.Tan(angle1 * Maths._deg2radf) * weight1;
}
else
{
finalTan = (float)Math.Tan(angle2 * Maths._deg2radf) * weight2;
}
x._tangent = finalTan;
}
}
foreach (KeyframeEntry w in l)
{
w.GenerateTangent();
}
}
else
{
int z = line.IndexOf(';') - i - 1;
if (z < 0)
{
continue;
}
string val = line.Substring(i + 1, z);
switch (tag)
{
case "input":
break;
case "output":
break;
case "weighted":
break;
case "inputUnit":
break;
case "outputUnit":
break;
case "preInfinity":
case "postInfinity":
default:
break;
}
}
}
}
line = file.ReadLine();
}
}
return(node);
}
public KeyframeEntry Remove(KeyFrameMode mode, int index)
{
KeyframeEntry entry = null, root;
for (int x = (int)mode & 0xF, y = x + ((int)mode >> 4); x < y; x++)
{
root = _keyRoots[x];
for (entry = root._next; (entry != root) && (entry._index < index); entry = entry._next) ;
if (entry._index == index)
{
entry.Remove();
_keyCounts[x]--;
}
else
entry = null;
}
return entry;
}
public KeyframeEntry SetFrameValue(KeyFrameMode mode, int index, float value)
{
KeyframeEntry entry = null, root;
for (int x = (int)mode & 0xF, y = x + ((int)mode >> 4); x < y; x++)
{
root = _keyRoots[x];
if ((root._prev == root) || (root._prev._index < index))
entry = root;
else
for (entry = root._next; (entry != root) && (entry._index <= index); entry = entry._next) ;
entry = entry._prev;
if (entry._index != index)
{
_keyCounts[x]++;
entry.InsertAfter(entry = new KeyframeEntry(index, value));
}
else
entry._value = value;
}
return entry;
}
public float GetFrameValue(KeyFrameMode mode, int index)
{
return(GetFrameValue(mode, index, false, false));
}
private static void DecodeSRT0Frames(KeyframeCollection kf, void* dataAddr, KeyFrameMode mode)
{
int fCount;
I12Header* header = (I12Header*)dataAddr;
fCount = header->_numFrames;
I12Entry* entry = header->Data;
for (int i = 0; i < fCount; i++, entry++)
kf.SetFrameValue(mode, (int)entry->_index, entry->_value)._tangent = entry->_tangent;
}
public KeyframeEntry SetKeyframe(KeyFrameMode mode, int index, float value, bool forceNoGenTans)
{
KeyframeEntry k = Keyframes.SetFrameValue(mode, index, value);
if (_generateTangents && !forceNoGenTans)
{
k.GenerateTangent();
k._prev.GenerateTangent();
k._next.GenerateTangent();
}
SignalPropertyChange();
return k;
}
public void RemoveKeyframe(KeyFrameMode mode, int index)
{
KeyframeEntry k = Keyframes.Remove(mode, index);
if (k != null && _generateTangents)
{
k._prev.GenerateTangent();
k._next.GenerateTangent();
SignalPropertyChange();
}
}
public float GetFrameValue(KeyFrameMode mode, int index, bool linear, bool loop)
{
return Keyframes.GetFrameValue(mode, index, linear, loop);
}
private static void DecodeCHR0Frames(KeyframeCollection kf, void *dataAddr, AnimDataFormat format, KeyFrameMode mode)
{
int fCount;
float vStep, vBase;
switch (format)
{
case AnimDataFormat.I4:
{
I4Header *header = (I4Header *)dataAddr;
fCount = header->_entries;
vStep = header->_step;
vBase = header->_base;
I4Entry *entry = header->Data;
for (int i = 0; i < fCount; i++, entry++)
{
kf.SetFrameValue(mode, entry->FrameIndex, vBase + (entry->Step * vStep))._tangent = entry->Tangent;
}
break;
}
case AnimDataFormat.I6:
{
I6Header *header = (I6Header *)dataAddr;
fCount = header->_numFrames;
vStep = header->_step;
vBase = header->_base;
I6Entry *entry = header->Data;
for (int i = 0; i < fCount; i++, entry++)
{
kf.SetFrameValue(mode, entry->FrameIndex, vBase + (entry->_step * vStep))._tangent = entry->Tangent;
}
break;
}
case AnimDataFormat.I12:
{
I12Header *header = (I12Header *)dataAddr;
fCount = header->_numFrames;
I12Entry *entry = header->Data;
for (int i = 0; i < fCount; i++, entry++)
{
kf.SetFrameValue(mode, (int)entry->_index, entry->_value)._tangent = entry->_tangent;
}
break;
}
case AnimDataFormat.L1:
{
L1Header *header = (L1Header *)dataAddr;
vStep = header->_step;
vBase = header->_base;
byte *sPtr = header->Data;
for (int i = 0; i < kf.FrameCount; i++)
{
kf[mode, i] = vBase + (*sPtr++ *vStep);
}
KeyframeEntry root = kf._keyRoots[(int)mode & 0xF];
for (KeyframeEntry entry = root._next; entry != root; entry = entry._next)
{
entry.GenerateTangent();
}
break;
}
case AnimDataFormat.L2:
{
L1Header *header = (L1Header *)dataAddr;
vStep = header->_step;
vBase = header->_base;
bushort *sPtr = (bushort *)header->Data;
for (int i = 0; i < kf.FrameCount; i++)
{
kf[mode, i] = vBase + (*sPtr++ *vStep);
}
KeyframeEntry root = kf._keyRoots[(int)mode & 0xF];
for (KeyframeEntry entry = root._next; entry != root; entry = entry._next)
{
entry.GenerateTangent();
}
break;
}
case AnimDataFormat.L4:
{
bfloat *sPtr = (bfloat *)dataAddr;
for (int i = 0; i < kf.FrameCount; i++)
{
kf[mode, i] = *sPtr++;
}
KeyframeEntry root = kf._keyRoots[(int)mode & 0xF];
for (KeyframeEntry entry = root._next; entry != root; entry = entry._next)
{
entry.GenerateTangent();
}
break;
}
}
}
public int this[KeyFrameMode mode] {
get { return(_keyCounts[(int)mode]); }
}
public float this[KeyFrameMode mode, int index]
{
get { return(GetFrameValue(mode, index)); }
set { SetFrameValue(mode, index, value); }
}
public int this[KeyFrameMode mode]
{
get { return _keyCounts[(int)mode - 0x10]; }
}
public float GetFrameValue(KeyFrameMode mode, int index)
{
return Keyframes.GetFrameValue(mode, index);
}
public float this[KeyFrameMode mode, int index]
{
get { return GetFrameValue(mode, index); }
set { SetFrameValue(mode, index, value); }
}
public KeyframeEntry GetKeyframe(KeyFrameMode mode, int index)
{
return Keyframes.GetKeyframe(mode, index);
}
public float GetFrameValue(KeyFrameMode mode, int index)
{
return GetFrameValue(mode, index, false, false);
}
public KeyframeEntry SetKeyframe(KeyFrameMode mode, int index, float value)
{
bool exists = Keyframes.GetKeyframe(mode, index) != null;
KeyframeEntry k = Keyframes.SetFrameValue(mode, index, value);
if (!exists && !_generateTangents)
k.GenerateTangent();
if (_generateTangents)
{
k.GenerateTangent();
k._prev.GenerateTangent();
k._next.GenerateTangent();
}
SignalPropertyChange();
return k;
}
public float GetFrameValue(KeyFrameMode mode, int index, bool linear, bool loop)
{
KeyframeEntry entry, root = _keyRoots[(int)mode & 0xF];
if (index >= root._prev._index)
//if (!loop || root._prev == root._next)
return root._prev._value;
//else
// return root._prev.Interpolate2(_frameCount - index + root._next._index, _linearRot || linear, _frameCount);
if (index <= root._next._index)
//if (!loop || root._prev == root._next)
return root._next._value;
//else
// return root._prev.Interpolate2(_frameCount - root._prev._index + index, _linearRot || linear, _frameCount);
for (entry = root._next;
(entry != root) &&
(entry._index < index);
entry = entry._next)
if (entry._index == index)
return entry._value;
return entry._prev.Interpolate(index - entry._prev._index, _linearRot || linear);
}
public KeyframeEntry GetKeyframe(KeyFrameMode mode, int index)
{
return(Keyframes.GetKeyframe(mode, index));
}
public KeyframeEntry GetKeyframe(KeyFrameMode mode, int index)
{
KeyframeEntry entry, root = _keyRoots[(int)mode & 0xF];
for (entry = root._next; (entry != root) && (entry._index < index); entry = entry._next) ;
if (entry._index == index)
return entry;
return null;
}
public void Insert(KeyFrameMode mode, int index)
{
KeyframeEntry entry = null, root;
for (int x = (int)mode & 0xF, y = x + ((int)mode >> 4); x < y; x++)
{
root = _keyRoots[x];
for (entry = root._prev; (entry != root) && (entry._index >= index); entry = entry._prev)
if (++entry._index >= _frameCount)
{
entry = entry._next;
entry._prev.Remove();
_keyCounts[x]--;
}
}
}
private static void DecodeCHR0Frames(KeyframeCollection kf, void* dataAddr, AnimDataFormat format, KeyFrameMode mode)
{
int fCount;
float vStep, vBase;
switch (format)
{
case AnimDataFormat.I4:
{
I4Header* header = (I4Header*)dataAddr;
fCount = header->_entries;
vStep = header->_step;
vBase = header->_base;
I4Entry* entry = header->Data;
for (int i = 0; i < fCount; i++, entry++)
kf.SetFrameValue(mode, entry->FrameIndex, vBase + (entry->Step * vStep))._tangent = entry->Tangent;
break;
}
case AnimDataFormat.I6:
{
I6Header* header = (I6Header*)dataAddr;
fCount = header->_numFrames;
vStep = header->_step;
vBase = header->_base;
I6Entry* entry = header->Data;
for (int i = 0; i < fCount; i++, entry++)
kf.SetFrameValue(mode, entry->FrameIndex, vBase + (entry->_step * vStep))._tangent = entry->Tangent;
break;
}
case AnimDataFormat.I12:
{
I12Header* header = (I12Header*)dataAddr;
fCount = header->_numFrames;
I12Entry* entry = header->Data;
for (int i = 0; i < fCount; i++, entry++)
kf.SetFrameValue(mode, (int)entry->_index, entry->_value)._tangent = entry->_tangent;
break;
}
case AnimDataFormat.L1:
{
L1Header* header = (L1Header*)dataAddr;
vStep = header->_step;
vBase = header->_base;
byte* sPtr = header->Data;
for (int i = 0; i < kf.FrameCount; i++)
kf[mode, i] = vBase + (*sPtr++ * vStep);
KeyframeEntry root = kf._keyRoots[(int)mode & 0xF];
for (KeyframeEntry entry = root._next; entry != root; entry = entry._next)
entry.GenerateTangent();
break;
}
case AnimDataFormat.L2:
{
L1Header* header = (L1Header*)dataAddr;
vStep = header->_step;
vBase = header->_base;
bushort* sPtr = (bushort*)header->Data;
for (int i = 0; i < kf.FrameCount; i++)
kf[mode, i] = vBase + (*sPtr++ * vStep);
KeyframeEntry root = kf._keyRoots[(int)mode & 0xF];
for (KeyframeEntry entry = root._next; entry != root; entry = entry._next)
entry.GenerateTangent();
break;
}
case AnimDataFormat.L4:
{
bfloat* sPtr = (bfloat*)dataAddr;
for (int i = 0; i < kf.FrameCount; i++)
kf[mode, i] = *sPtr++;
KeyframeEntry root = kf._keyRoots[(int)mode & 0xF];
for (KeyframeEntry entry = root._next; entry != root; entry = entry._next)
entry.GenerateTangent();
break;
}
}
}
