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)); }