public void SetKeys(int i, KeyframeArray value)
{
switch (i)
{
case 0: _startX = value; break;
case 1: _startY = value; break;
case 2: _startZ = value; break;
case 3: _endX = value; break;
case 4: _endY = value; break;
case 5: _endZ = value; break;
case 6: _refDist = value; break;
case 7: _refBright = value; break;
case 8: _spotCut = value; break;
case 9: _spotBright = value; break;
}
}
protected void CalcKeyLen(KeyframeArray keyframes)
{
if (keyframes._keyCount > 1)
{
_dataLengths[0] += SCN0KeyframesHeader.Size + keyframes._keyCount * SCN0KeyframeStruct.Size + 4;
}
}
public void SetKeys(int i, KeyframeArray value)
{
switch (i)
{
case 0: _posX = value; break;
case 1: _posY = value; break;
case 2: _posZ = value; break;
case 3: _aspect = value; break;
case 4: _nearZ = value; break;
case 5: _farZ = value; break;
case 6: _rotX = value; break;
case 7: _rotY = value; break;
case 8: _rotZ = value; break;
case 9: _aimX = value; break;
case 10: _aimY = value; break;
case 11: _aimZ = value; break;
case 12: _twist = value; break;
case 13: _fovY = value; break;
case 14: _height = value; break;
}
}
public FogAnimationFrame GetAnimFrame(float index)
{
FogAnimationFrame frame;
float * dPtr = (float *)&frame;
for (int x = 0; x < 2; x++)
{
KeyframeArray a = KeyArrays[x];
*dPtr++ = a.GetFrameValue(index);
frame.SetBools(x, a.GetKeyframe((int)index) != null);
frame.Index = index;
}
//Ignore alpha value; not used
if (ConstantColor)
{
frame.Color = (Vector3)_solidColor;
}
else
{
int colorIndex = (int)Math.Truncate(index);
Vector3 color = (Vector3)_colors[colorIndex];
if (colorIndex + 1 < _colors.Count)
{
float frac = index - colorIndex;
Vector3 interp = (Vector3)_colors[colorIndex + 1];
color += (interp - color) * frac;
}
frame.Color = color;
}
frame.Type = Type;
return(frame);
}
public void SetKeys(int i, KeyframeArray value)
{
switch (i)
{
case 0: _startKeys = value; break;
case 1: _endKeys = value; break;
}
}
/// <summary>
/// Reads keyframes at an address, starting with the keyframe array header.
/// </summary>
/// <param name="kf">The array to set decoded frames to.</param>
/// <param name="dataAddr">The address of the keyframe array header.</param>
public static void DecodeKeyframes(KeyframeArray kf, VoidPtr dataAddr)
{
SCN0KeyframesHeader *header = (SCN0KeyframesHeader *)dataAddr;
SCN0KeyframeStruct * entry = header->Data;
for (int i = 0; i < header->_numFrames; i++, entry++)
{
kf.SetFrameValue((int)entry->_index, entry->_value, true)._tangent = entry->_tangent;
}
}
/// <summary>
/// Reads keyframes from an address and sets them in the keyframe array provided.
/// </summary>
/// <param name="kf">The array to set decoded frames to.</param>
/// <param name="dataAddr">The address of the OFFSET to the data.</param>
/// <param name="flags">The flags used to determine if the value is constant.</param>
/// <param name="fixedBit">The bit located in the flags that determines if the value is constant.</param>
public void DecodeKeyframes(KeyframeArray kf, VoidPtr dataAddr, int flags, int fixedBit)
{
if ((flags & fixedBit) != 0)
{
kf[0] = *(bfloat *)dataAddr;
}
else
{
DecodeKeyframes(kf, dataAddr + *(bint *)dataAddr);
}
}
public static void DecodeFrames(KeyframeArray kf, VoidPtr offset, int flags, int fixedBit)
{
if ((flags & fixedBit) != 0)
{
kf[0] = *(bfloat *)offset;
}
else
{
DecodeFrames(kf, offset + *(bint *)offset);
}
}
public LightAnimationFrame GetAnimFrame(float index)
{
LightAnimationFrame frame;
float *dPtr = (float *)&frame;
for (int x = 0; x < Keyframes.ArrayCount; x++)
{
KeyframeArray a = Keyframes[x];
*dPtr++ = a.GetFrameValue(index);
frame.SetBools(x, a.GetKeyframe((int)index) != null);
frame.Index = index;
}
frame.Enabled = GetEnabled(index);
if (ConstantColor)
{
frame.Color = (Vector4)_solidColors[0];
}
else if (_lightColor.Count > 0)
{
int colorIndex = ((int)Math.Truncate(index)).Clamp(0, _lightColor.Count - 1);
Vector4 color = (Vector4)_lightColor[colorIndex];
if (colorIndex + 1 < _lightColor.Count)
{
float frac = index - colorIndex;
Vector4 interp = (Vector4)_lightColor[colorIndex + 1];
color += (interp - color) * frac;
}
frame.Color = color;
}
if (SpecularEnabled)
{
if (ConstantSpecular)
{
frame.SpecularColor = (Vector4)_solidColors[1];
}
else if (_specColor.Count > 0)
{
int specIndex = ((int)Math.Truncate(index)).Clamp(0, _specColor.Count - 1);
Vector4 specColor = (Vector4)_specColor[specIndex];
if (specIndex + 1 < _specColor.Count)
{
float frac = index - specIndex;
Vector4 interp = (Vector4)_specColor[specIndex + 1];
specColor += (interp - specColor) * frac;
}
frame.SpecularColor = specColor;
}
}
return(frame);
}
public static void EncodeFrames(KeyframeArray kf, ref VoidPtr dataAddr, VoidPtr offset, ref int flags, int fixedBit)
{
if (kf._keyCount > 1)
{
flags &= ~fixedBit;
EncodeFrames(kf, ref dataAddr, offset);
}
else
{
flags |= fixedBit;
*(bfloat *)offset = kf._keyRoot._next._value;
}
}
public override bool OnInitialize()
{
base.OnInitialize();
_colors = new List <ARGBPixel>();
_startKeys = new KeyframeArray(FrameCount + 1);
_endKeys = new KeyframeArray(FrameCount + 1);
flags = (SCN0FogFlags)Data->_flags;
type = Data->_type;
if (Name != "<null>")
{
if (flags.HasFlag(SCN0FogFlags.FixedStart))
{
_startKeys[0] = Data->_start;
}
else if (!_replaced)
{
DecodeFrames(_startKeys, Data->startKeyframes);
}
if (flags.HasFlag(SCN0FogFlags.FixedEnd))
{
_endKeys[0] = Data->_end;
}
else if (!_replaced)
{
DecodeFrames(_endKeys, Data->endKeyframes);
}
if (flags.HasFlag(SCN0FogFlags.FixedColor))
{
_constant = true;
_numEntries = 0;
_solidColor = (ARGBPixel)Data->_color;
}
else
{
_constant = false;
_numEntries = FrameCount + 1;
RGBAPixel *addr = Data->colorEntries;
for (int i = 0; i <= FrameCount; i++)
{
_colors.Add((ARGBPixel)(*addr++));
}
}
}
return(false);
}
public static int EncodeKeyframes(KeyframeArray kf, VoidPtr dataAddr, VoidPtr offset, ref int flags, int fixedBit)
{
if (kf._keyCount > 1)
{
flags &= ~fixedBit;
return(EncodeKeyframes(kf, dataAddr, offset));
}
else
{
flags |= fixedBit;
*(bfloat *)offset = kf._keyRoot._next._value;
return(0);
}
}
public CameraAnimationFrame GetAnimFrame(float index)
{
CameraAnimationFrame frame;
float *dPtr = (float *)&frame;
for (int x = 0; x < 15; x++)
{
KeyframeArray a = Keyframes[x];
*dPtr++ = a.GetFrameValue(index);
frame.SetBools(x, a.GetKeyframe((int)index) != null);
frame.Index = index;
}
return(frame);
}
internal FogAnimationFrame GetAnimFrame(int index)
{
FogAnimationFrame frame;
float * dPtr = (float *)&frame;
for (int x = 0; x < 2; x++)
{
KeyframeArray a = GetKeys(x);
*dPtr++ = a.GetFrameValue(index);
frame.SetBools(x, a.GetKeyframe(index) != null);
frame.Index = index;
}
return(frame);
}
public void RootChanged()
{
if (_targetNode == null || SelectedMode >= _targetNode.KeyArrays.Length || SelectedMode < 0)
{
return;
}
KeyframeArray array = _targetNode.KeyArrays[SelectedMode];
if (array != null)
{
interpolationViewer.FrameLimit = array.FrameLimit;
interpolationViewer.KeyRoot = array._keyRoot;
}
}
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;
}
internal void SetKeyframe(int keyFrameMode, int index, float value)
{
KeyframeArray keys = GetKeys(keyFrameMode);
bool exists = keys.GetKeyframe(index) != null;
KeyframeEntry k = keys.SetFrameValue(index, value);
if (!exists && !_generateTangents)
{
k.GenerateTangent();
}
if (_generateTangents)
{
k.GenerateTangent();
k._prev.GenerateTangent();
k._next.GenerateTangent();
}
SignalPropertyChange();
}
internal LightAnimationFrame GetAnimFrame(int index)
{
LightAnimationFrame frame;
float *dPtr = (float *)&frame;
for (int x = 0; x < 10; x++)
{
KeyframeArray a = GetKeys(x);
*dPtr++ = a.GetFrameValue(index);
frame.SetBools(x, a.GetKeyframe(index) != null);
frame.Index = index;
}
//if (((FixedFlags)_flags1).HasFlag(FixedFlags.EnabledConstant))
// frame.Enabled = UsageFlags.HasFlag(UsageFlags.Enabled);
//else
// frame.Enabled = index < _enabled.Count ? _enabled[index] : false;
return(frame);
}
/// <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 (SHP0EntryNode s in Children)
{
foreach (SHP0VertexSetNode e in s.Children)
{
KeyframeArray newArr = new KeyframeArray(newFrameCount);
for (int x = 0; x < FrameCount; x++)
{
if ((kfe = e.GetKeyframe(x)) != null)
{
int newFrame = (int)((float)x * ratio + 0.5f);
float frameRatio = newFrame == 0 ? 0 : (float)x / (float)newFrame;
newArr.SetFrameValue(newFrame, kfe._value)._tangent = kfe._tangent * (float.IsNaN(frameRatio) ? 1 : frameRatio);
}
}
e._keyframes = newArr;
}
}
FrameCount = newFrameCount;
}
public static void EncodeFrames(KeyframeArray kf, ref VoidPtr dataAddr, VoidPtr offset)
{
*(bint *)offset = (int)dataAddr - (int)offset;
EncodeFrames(kf, ref dataAddr);
}
public static int EncodeKeyframes(KeyframeArray kf, VoidPtr dataAddr, VoidPtr offset)
{
*(bint *)offset = (int)dataAddr - (int)offset;
return(EncodeKeyframes(kf, dataAddr));
}
