public unsafe void ResetBox(int index)
{
if (index == 2 || index == 4 || index == 5 || index == 8)
{
return;
}
NumericInputBox box = _transBoxes[index];
MDL0MaterialRefNode mr = TargetTexRef;
SRT0TextureNode entry;
if (TargetTexRef != null)
{
if ((SelectedAnimation != null) && (CurrentFrame > 0) && ((entry = SelectedAnimation.FindChild(mr.Parent.Name + "/Texture" + mr.Index, true) as SRT0TextureNode) != null))
{
KeyframeEntry e = entry.Keyframes.GetKeyframe((KeyFrameMode)index + 0x10, CurrentFrame - 1);
if (e == null)
{
box.Value = entry.Keyframes[KeyFrameMode.ScaleX + index, CurrentFrame - 1];
box.BackColor = Color.White;
}
else
{
box.Value = e._value;
box.BackColor = Color.Yellow;
}
}
else
{
FrameState state = mr._bindState;
box.Value = ((float *)&state)[index];
box.BackColor = Color.White;
}
}
}
public unsafe void ResetBox()
{
MDL0VertexNode vSet = VertexSet;
SHP0EntryNode entry;
SHP0VertexSetNode v;
if (VertexSet == null || SelectedDestination == null)
{
return;
}
if ((SelectedAnimation != null) && (CurrentFrame > 0) &&
((entry = SelectedAnimation.FindChild(vSet.Name, false) as SHP0EntryNode) != null) &&
(v = entry.FindChild(SelectedDestination.Name, false) as SHP0VertexSetNode) != null)
{
KeyframeEntry e = v.Keyframes.GetKeyframe(CurrentFrame - 1);
if (e == null)
{
textBox1.Value = v.Keyframes[CurrentFrame - 1] * 100.0f;
textBox1.BackColor = Color.White;
}
else
{
textBox1.Value = e._value * 100.0f;
textBox1.BackColor = Color.Yellow;
}
}
else
{
textBox1.Value = 0;
textBox1.BackColor = Color.White;
}
updating = true;
trackBar1.Value = ((int)(textBox1.Value * 10.0f)).Clamp(trackBar1.Minimum, trackBar1.Maximum);
updating = false;
}
public void AverageKeys(string baseName, string morphName)
{
SHP0EntryNode w = FindChild(baseName, false) as SHP0EntryNode;
if (w == null)
{
return;
}
SHP0VertexSetNode t = w.FindChild(morphName, false) as SHP0VertexSetNode;
if (t == null)
{
return;
}
if (t.Keyframes._keyCount > 1)
{
KeyframeEntry root = t.Keyframes._keyRoot;
if (root._next != root && root._prev != root && root._prev != root._next)
{
float tan = (root._next._tangent + root._prev._tangent) / 2.0f;
float val = (root._next._value + root._prev._value) / 2.0f;
root._next._tangent = tan;
root._prev._tangent = tan;
root._next._value = val;
root._prev._value = val;
}
}
SignalPropertyChange();
}
public void AverageKeys(string boneName)
{
CHR0EntryNode w = FindChild(boneName, false) as CHR0EntryNode;
if (w == null)
{
return;
}
for (int i = 0; i < 9; i++)
{
if (w.Keyframes._keyArrays[i]._keyCount > 1)
{
KeyframeEntry root = w.Keyframes._keyArrays[i]._keyRoot;
if (root._next != root && root._prev != root && root._prev != root._next)
{
float tan = (root._next._tangent + root._prev._tangent) / 2.0f;
float val = (root._next._value + root._prev._value) / 2.0f;
root._next._tangent = tan;
root._prev._tangent = tan;
root._next._value = val;
root._prev._value = val;
}
}
}
SignalPropertyChange();
}
private void comboBox1_SelectedIndexChanged(object sender, EventArgs e)
{
if (_updating)
{
return;
}
RootChanged();
if (SelectedKeyframe != null && interpolationViewer.KeyRoot != null)
{
KeyframeEntry prev = SelectedKeyframe;
for (KeyframeEntry entry = interpolationViewer.KeyRoot._next; (entry != interpolationViewer.KeyRoot); entry = entry._next)
{
if (entry._index == SelectedKeyframe._index)
{
SelectedKeyframe = entry;
break;
}
}
if (SelectedKeyframe == prev)
{
SelectedKeyframe = null;
}
}
}
private void UpdateTarget()
{
KeyframeEntry kfe = null;
listKeyframes.BeginUpdate();
listKeyframes.Items.Clear();
if (_target != null)
{
if (_target.FrameCount > 0)
{
for (int x = 0; x < _target.FrameCount; x++)
{
if ((kfe = _target.GetKeyframe(x)) != null)
{
listKeyframes.Items.Add(new FloatKeyframe(kfe));
}
}
_numFrames = _target.FrameCount;
_currentPage = 0;
numFrame.Value = 1;
numFrame.Maximum = _numFrames;
lblFrameCount.Text = String.Format("/ {0}", _numFrames);
}
else
{
numFrame.Value = 1;
}
}
listKeyframes.EndUpdate();
RefreshPage();
}
public void AverageKeys()
{
foreach (CHR0EntryNode w in Children)
{
for (int i = 0; i < 9; i++)
{
if (w.Keyframes._keyArrays[i]._keyCount > 1)
{
KeyframeEntry root = w.Keyframes._keyArrays[i]._keyRoot;
if (root._next != root && root._prev != root && root._prev != root._next)
{
float tan = (root._next._tangent + root._prev._tangent) / 2.0f;
float val = (root._next._value + root._prev._value) / 2.0f;
root._next._tangent = tan;
root._prev._tangent = tan;
root._next._value = val;
root._prev._value = val;
}
}
}
}
SignalPropertyChange();
}
public float GetFrameValue(float index)
{
KeyframeEntry entry, root = _keyRoot;
if (_keyRoot == null)
{
return(0);
}
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 - (float)entry._prev._index, _linear));
}
public void AverageKeys()
{
foreach (SHP0EntryNode u in Children)
{
foreach (SHP0VertexSetNode w in u.Children)
{
if (w.Keyframes._keyCount > 1)
{
KeyframeEntry root = w.Keyframes._keyRoot;
if (root._next != root && root._prev != root && root._prev != root._next)
{
float tan = (root._next._tangent + root._prev._tangent) / 2.0f;
float val = (root._next._value + root._prev._value) / 2.0f;
root._next._tangent = tan;
root._prev._tangent = tan;
root._next._value = val;
root._prev._value = val;
}
}
}
}
SignalPropertyChange();
}
private void numOutTan_ValueChanged(object sender, EventArgs e)
{
if (_updating || interpolationViewer.SelectedKeyframe == null)
{
return;
}
KeyframeEntry kf = interpolationViewer.SelectedKeyframe;
if (kf.Second != null && kf._next._index == kf._index)
{
kf = kf._next;
}
kf._tangent = numOutTan.Value;
interpolationViewer.Invalidate();
((ResourceNode)_targetNode).SignalPropertyChange();
if (chkSyncStartEnd.Checked)
{
if (SelectedKeyframe._prev._index == -1 && SelectedKeyframe._prev._prev != SelectedKeyframe)
{
SelectedKeyframe._prev._prev._tangent = SelectedKeyframe._tangent;
SelectedKeyframe._prev._prev._value = SelectedKeyframe._value;
}
if (SelectedKeyframe._next._index == -1 && SelectedKeyframe._next._next != SelectedKeyframe)
{
SelectedKeyframe._next._next._tangent = SelectedKeyframe._tangent;
SelectedKeyframe._next._next._value = SelectedKeyframe._value;
}
}
}
/// <summary>
/// Stretches or compresses all frames of the animation to fit a new frame count.
/// </summary>
public void Resize(int newFrameCount)
{
KeyframeEntry kfe = null;
float ratio = (float)newFrameCount / (float)FrameCount;
foreach (SRT0EntryNode n in Children)
{
foreach (SRT0TextureNode e in n.Children)
{
KeyframeCollection newCollection = new KeyframeCollection(5, newFrameCount + (Loop ? 1 : 0), 1, 1);
for (int x = 0; x < FrameCount; x++)
{
int newFrame = (int)((float)x * ratio + 0.5f);
float frameRatio = newFrame == 0 ? 0 : (float)x / (float)newFrame;
for (int i = 0; i < 5; i++)
{
if ((kfe = e.GetKeyframe(i, x)) != null)
{
newCollection.SetFrameValue(i, newFrame, kfe._value)._tangent = kfe._tangent * (float.IsNaN(frameRatio) ? 1 : frameRatio);
}
}
}
e._keyframes = newCollection;
}
}
FrameCount = newFrameCount;
}
private unsafe void ResetBox(int index)
{
NumericInputBox box = _transBoxes[index];
if (_transformObject is MDL0BoneNode)
{
MDL0BoneNode bone = _transformObject as MDL0BoneNode;
CHR0EntryNode entry;
if ((_selectedAnim != null) && (_animFrame > 0) && ((entry = _selectedAnim.FindChild(bone.Name, false) as CHR0EntryNode) != null))
{
KeyframeEntry e = entry.Keyframes.GetKeyframe((KeyFrameMode)index + 0x10, _animFrame - 1);
if (e == null)
{
box.Value = entry.Keyframes[KeyFrameMode.ScaleX + index, _animFrame - 1];
box.BackColor = Color.White;
}
else
{
box.Value = e._value;
box.BackColor = Color.Yellow;
}
}
else
{
FrameState state = bone._bindState;
box.Value = ((float *)&state)[index];
box.BackColor = Color.White;
}
}
else
{
box.Value = 0;
box.BackColor = Color.White;
}
}
private void DrawTangent(KeyframeEntry e, float xMin)
{
int xVal = e._index;
float yVal = e._value;
float tan = e._tangent;
float i1 = -(_tanLen / 2);
float i2 = (_tanLen / 2);
float p = (float)Math.Sqrt(_precision / 4.0f);
Vector2 one = new Vector2((xVal + i1 * p - xMin) * _xScale, (yVal - _minVal + tan * i1 * p) * _yScale);
Vector2 two = new Vector2((xVal + i2 * p - xMin) * _xScale, (yVal - _minVal + tan * i2 * p) * _yScale);
if (e == _selKey)
{
GL.Color4(Color.Purple);
GL.Begin(BeginMode.Points);
GL.Vertex2(one._x, one._y);
GL.Vertex2(two._x, two._y);
GL.End();
}
else
{
GL.Color4(Color.Green);
float angle = (float)Math.Atan((tan * _yScale) / _xScale) * Maths._rad2degf;
GL.PushMatrix();
GL.Translate(one._x, one._y, 0.0f);
GL.Rotate(angle - 180.0f, 0, 0, 1);
GL.Begin(BeginMode.LineStrip);
GL.Vertex2(-7.0f, 3.5f);
GL.Vertex2(0.0f, 0.0f);
GL.Vertex2(-7.0f, -3.5f);
GL.End();
GL.PopMatrix();
GL.PushMatrix();
GL.Translate(two._x, two._y, 0.0f);
GL.Rotate(angle, 0, 0, 1);
GL.Begin(BeginMode.LineStrip);
GL.Vertex2(-7.0f, 3.5f);
GL.Vertex2(0.0f, 0.0f);
GL.Vertex2(-7.0f, -3.5f);
GL.End();
GL.PopMatrix();
}
GL.Begin(BeginMode.LineStrip);
GL.Vertex2(one._x, one._y);
GL.Vertex2(two._x, two._y);
GL.End();
}
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();
}
/// <summary>
/// Returns true if two has a value
/// </summary>
/// <param name="index">Float value of current frame. Not normalized [0,1]</param>
/// <returns></returns>
private bool GetFrameValue(float index, out float one, out float two)
{
KeyframeEntry entry, root = _keyRoot;
one = 0;
two = 0;
if (_keyRoot == null)
{
return(false);
}
if (index > root._prev._index)
{
float span = FrameLimit - _keyRoot._prev._index.Clamp(0, FrameLimit) + _keyRoot._next._index.Clamp(0, FrameLimit);
float offset =
index > _keyRoot._prev._index && index < FrameLimit ? index - _keyRoot._prev._index :
FrameLimit - _keyRoot._prev._index + index;
one = _keyRoot._prev.Interpolate(offset, span, _keyRoot._next);
return(false);
}
if (index < root._next._index)
{
float span = FrameLimit - _keyRoot._prev._index.Clamp(0, FrameLimit) + _keyRoot._next._index.Clamp(0, FrameLimit);
float offset =
index > _keyRoot._prev._index.Clamp(0, FrameLimit) && index < FrameLimit ? index - _keyRoot._prev._index.Clamp(0, FrameLimit) :
FrameLimit - _keyRoot._prev._index.Clamp(0, FrameLimit) + index;
one = _keyRoot._prev.Interpolate(offset, span, _keyRoot._next);
return(false);
}
for (entry = root._next; (entry != root) && (entry._index <= index); entry = entry._next)
{
if (entry._index == index)
{
if (entry._next._index == entry._index)
{
one = entry._value;
two = entry._next._value;
return(true);
}
else
{
one = entry._value;
return(false);
}
}
}
one = entry._prev.Interpolate(index - (float)entry._prev._index, false);
return(false);
}
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(int arrayIndex, int index)
{
KeyframeEntry k = Keyframes.Remove(arrayIndex, index);
if (k != null && _generateTangents)
{
k.GenerateTangent();
k._prev.GenerateTangent();
k._next.GenerateTangent();
}
}
internal void RemoveKeyframe(CameraKeyframeMode keyFrameMode, int index)
{
KeyframeEntry k = Keyframes[(int)keyFrameMode].Remove(index);
if (k != null && _generateTangents)
{
k._prev.GenerateTangent();
k._next.GenerateTangent();
SignalPropertyChange();
}
}
internal void RemoveKeyframe(int keyFrameMode, int index)
{
KeyframeEntry k = GetKeys(keyFrameMode).Remove(index);
if (k != null && _generateTangents)
{
k._prev.GenerateTangent();
k._next.GenerateTangent();
SignalPropertyChange();
}
}
public void RemoveKeyframe(int keyFrameMode, int index)
{
KeyframeEntry k = KeyArrays[keyFrameMode].Remove(index);
if (k != null && _generateTangents)
{
k._prev.GenerateTangent();
k._next.GenerateTangent();
SignalPropertyChange();
}
}
public void RemoveKeyframe(KeyFrameMode mode, int index)
{
KeyframeEntry k = Keyframes.Remove(mode, index);
if (k != null)
{
k._prev.GenerateTangent();
k._next.GenerateTangent();
SignalPropertyChange();
}
}
public void RemoveKeyframe(int arrayIndex, int index)
{
KeyframeEntry k = Keyframes.Remove(arrayIndex, index);
if (k != null && _generateTangents &&
_alterAdjTangents && _alterAdjTangents_KeyFrame_Del)
{
k._prev.GenerateTangent();
k._next.GenerateTangent();
SignalPropertyChange();
}
}
private bool Has3PlusVals()
{
float val1 = 0, val2 = 0;
if (AllKeyframes)
{
bool v1Set = false, v2Set = false;
for (KeyframeEntry entry = _keyRoot._next; (entry != _keyRoot); entry = entry._next)
{
if (!v1Set)
{
val1 = entry._value;
v1Set = true;
}
else if (!v2Set)
{
if (entry._value != val1)
{
val2 = entry._value;
v2Set = true;
}
}
else if (entry._value != val1 && entry._value != val2)
{
return(true);
}
}
}
else
{
if (SelectedKeyframe._prev._index != -1)
{
val1 = SelectedKeyframe._prev._value;
}
if (SelectedKeyframe._value != val1)
{
val2 = SelectedKeyframe._value;
}
else
{
return(false);
}
if (SelectedKeyframe._next._index != -1 && SelectedKeyframe._next._value != val1 && SelectedKeyframe._next._value != val2)
{
return(true);
}
}
return(false);
}
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 override void OnRebuild(VoidPtr address, int length, bool force)
{
SHP0KeyframeEntries *header = (SHP0KeyframeEntries *)address;
header->_numEntries = (short)Keyframes._keyCount;
header->_unk1 = 0;
BVec3 * entry = header->Entries;
KeyframeEntry frame, root = Keyframes._keyRoot;
for (frame = root._next; frame._index != -1; frame = frame._next)
{
*entry++ = new Vector3(frame._tangent, frame._index, frame._value);
}
}
public static void EncodeFrames(KeyframeArray kf, ref VoidPtr dataAddr)
{
SCN0KeyframesHeader *header = (SCN0KeyframesHeader *)dataAddr;
*header = new SCN0KeyframesHeader(kf._keyCount);
KeyframeEntry frame, root = kf._keyRoot;
SCN0KeyframeStruct *entry = header->Data;
for (frame = root._next; frame._index != -1; frame = frame._next)
{
*entry++ = new SCN0KeyframeStruct(frame._tangent, frame._index, frame._value);
}
*(bint *)entry = 0;
dataAddr = ((VoidPtr)entry) + 4;
}
public KeyframeEntry SetKeyframe(int arrayIndex, int index, float value, bool forceNoGenTans)
{
KeyframeEntry k = Keyframes.SetFrameValue(arrayIndex, index, value);
if (_generateTangents && !forceNoGenTans)
{
k.GenerateTangent();
if (_alterAdjTangents && _alterAdjTangents_KeyFrame_Set)
{
k._prev.GenerateTangent();
k._next.GenerateTangent();
}
}
SignalPropertyChange();
return(k);
}
private void numInValue_ValueChanged(object sender, EventArgs e)
{
if (_updating || interpolationViewer.SelectedKeyframe == null)
{
return;
}
KeyframeEntry kf = interpolationViewer.SelectedKeyframe;
if (kf.Second != null && kf._prev._index == kf._index)
{
kf = kf._prev;
}
kf._value = numInValue.Value;
interpolationViewer.Invalidate();
((ResourceNode)_targetNode).SignalPropertyChange();
if (_mainWindow != null)
{
_mainWindow.KeyframePanel.UpdateKeyframe(interpolationViewer.SelectedKeyframe._index);
}
if (chkSyncStartEnd.Checked)
{
if (SelectedKeyframe._prev._index == -1 && SelectedKeyframe._prev._prev != SelectedKeyframe)
{
SelectedKeyframe._prev._prev._tangent = SelectedKeyframe._tangent;
SelectedKeyframe._prev._prev._value = SelectedKeyframe._value;
}
if (SelectedKeyframe._next._index == -1 && SelectedKeyframe._next._next != SelectedKeyframe)
{
SelectedKeyframe._next._next._tangent = SelectedKeyframe._tangent;
SelectedKeyframe._next._next._value = SelectedKeyframe._value;
}
}
if (_mainWindow != null)
{
_mainWindow.UpdateModel();
_mainWindow.UpdatePropDisplay();
}
}
public void SetKeyframe(int index, float value)
{
bool exists = Keyframes.GetKeyframe(index) != null;
KeyframeEntry k = Keyframes.SetFrameValue(index, value);
if (!exists && !_generateTangents)
{
k.GenerateTangent();
}
if (_generateTangents)
{
k.GenerateTangent();
k._prev.GenerateTangent();
k._next.GenerateTangent();
}
SignalPropertyChange();
}
protected override void OnMouseDown(MouseEventArgs e)
{
bool t = _selKey != _hiKey;
if (AllKeyframes)
{
_dragging = (_selKey = _hiKey) != null || Cursor == Cursors.VSplit || _slopePoint != null;
}
else
{
if (_hiKey != null)
{
_selKey = _hiKey;
}
_dragging = _selKey != null && (_slopePoint != null || Cursor == Cursors.Hand);
}
if (_selKey != null)
{
if (_slopePoint == null)
{
int min = GetKeyframeMinIndex();
_prevX = _selKey._index - min;
_prevY = _selKey._value;
}
_frame = _selKey._index;
if ((_dragging && !Has3PlusVals()) || _slopePoint != null)
{
_lockIncs = true;
}
}
if (t)
{
Invalidate();
if (SelectedKeyframeChanged != null)
{
SelectedKeyframeChanged(this, null);
}
}
}
