public Keyframe ToKeyframe(EditDataSet editSet, DataSet.AnimationBits bits)
{
Keyframe ret = new Keyframe();
// Get the intensity from the color and scale
ret.setTimeAndIntensity((ushort)(time * 1000), (byte)(ColorUtils.desaturate(color) * 255.0f));
return(ret);
}
public RGBKeyframe ToRGBKeyframe(EditDataSet editSet, DataSet.AnimationBits bits)
{
RGBKeyframe ret = new RGBKeyframe();
// Add the color to the palette if not already there, otherwise grab the color index
var colorIndex = EditColor.toColorIndex(ref bits.palette, color);
ret.setTimeAndColorIndex((ushort)(time * 1000), (ushort)colorIndex);
return(ret);
}
public override Animation ToAnimation(EditDataSet editSet, DataSet.AnimationBits bits)
{
var ret = new AnimationSimple();
ret.duration = (ushort)(this.duration * 1000.0f);
ret.faceMask = (uint)this.faces;
ret.colorIndex = (ushort)color.toColorIndex(ref bits.palette);
ret.fade = (byte)(255.0f * fade);
ret.count = (byte)count;
return(ret);
}
public override Animation ToAnimation(EditDataSet editSet, DataSet.AnimationBits bits)
{
var ret = new AnimationRainbow();
ret.duration = (ushort)(this.duration * 1000.0f);
ret.faceMask = (uint)this.faces;
ret.fade = (byte)(255.0f * fade);
ret.count = (byte)count;
ret.traveling = traveling ? (byte)1 : (byte)0;
return(ret);
}
public override Animation ToAnimation(EditDataSet editSet, DataSet.AnimationBits bits)
{
var ret = new AnimationGradient();
ret.duration = (ushort)(this.duration * 1000.0f);
ret.faceMask = (uint)this.faces;
// Add gradient
ret.gradientTrackOffset = (ushort)bits.rgbTracks.Count;
var tempTrack = new EditRGBTrack()
{
gradient = gradient
};
var gradientTrack = tempTrack.ToTrack(editSet, bits);
bits.rgbTracks.Add(gradientTrack);
return(ret);
}
/// <summary>
/// Evaluate an animation track's for a given time, in milliseconds
/// Values outside the track's range are clamped to first or last keyframe value.
/// </summary>
public uint evaluateColor(DataSet.AnimationBits bits, int time)
{
if (keyFrameCount == 0)
{
return(0);
}
// Find the first keyframe
int nextIndex = 0;
while (nextIndex < keyFrameCount && getKeyframe(bits, (ushort)nextIndex).time() < time)
{
nextIndex++;
}
uint color = 0;
if (nextIndex == 0)
{
// The first keyframe is already after the requested time, clamp to first value
color = getKeyframe(bits, (ushort)nextIndex).color(bits);
}
else if (nextIndex == keyFrameCount)
{
// The last keyframe is still before the requested time, clamp to the last value
color = getKeyframe(bits, (ushort)(nextIndex - 1)).color(bits);
}
else
{
// Grab the prev and next keyframes
var nextKeyframe = getKeyframe(bits, (ushort)nextIndex);
ushort nextKeyframeTime = nextKeyframe.time();
uint nextKeyframeColor = nextKeyframe.color(bits);
var prevKeyframe = getKeyframe(bits, (ushort)(nextIndex - 1));
ushort prevKeyframeTime = prevKeyframe.time();
uint prevKeyframeColor = prevKeyframe.color(bits);
// Compute the interpolation parameter
color = ColorUtils.interpolateColors(prevKeyframeColor, prevKeyframeTime, nextKeyframeColor, nextKeyframeTime, time);
}
return(color);
}
public RGBTrack ToTrack(EditDataSet editSet, DataSet.AnimationBits bits)
{
RGBTrack ret = new RGBTrack();
ret.keyframesOffset = (ushort)bits.rgbKeyframes.Count;
ret.keyFrameCount = (byte)gradient.keyframes.Count;
ret.ledMask = 0;
foreach (int index in ledIndices)
{
ret.ledMask |= (uint)(1 << index);
}
// Add the keyframes
foreach (var editKeyframe in gradient.keyframes)
{
var kf = editKeyframe.ToRGBKeyframe(editSet, bits);
bits.rgbKeyframes.Add(kf);
}
return(ret);
}
/// <summary>
/// Evaluate an animation track's for a given time, in milliseconds
/// Values outside the track's range are clamped to first or last keyframe value.
/// </summary>
public uint modulateColor(DataSet.AnimationBits bits, uint color, int time)
{
// Find the first keyframe
int nextIndex = 0;
while (nextIndex < keyFrameCount && getKeyframe(bits, (ushort)nextIndex).time() < time)
{
nextIndex++;
}
byte intensity = 0;
if (nextIndex == 0)
{
// The first keyframe is already after the requested time, clamp to first value
intensity = getKeyframe(bits, (ushort)nextIndex).intensity();
}
else if (nextIndex == keyFrameCount)
{
// The last keyframe is still before the requested time, clamp to the last value
intensity = getKeyframe(bits, (ushort)(nextIndex - 1)).intensity();
}
else
{
// Grab the prev and next keyframes
var nextKeyframe = getKeyframe(bits, (ushort)nextIndex);
ushort nextKeyframeTime = nextKeyframe.time();
byte nextKeyframeIntensity = nextKeyframe.intensity();
var prevKeyframe = getKeyframe(bits, (ushort)(nextIndex - 1));
ushort prevKeyframeTime = prevKeyframe.time();
byte prevKeyframeIntensity = prevKeyframe.intensity();
// Compute the interpolation parameter
intensity = ColorUtils.interpolateIntensity(prevKeyframeIntensity, prevKeyframeTime, nextKeyframeIntensity, nextKeyframeTime, time);
}
return(ColorUtils.modulateColor(color, intensity));
}
public Track[] ToTracks(EditDataSet editSet, DataSet.AnimationBits bits)
{
Track[] ret = new Track[gradients.Count];
for (int i = 0; i < gradients.Count; ++i)
{
Track t = new Track();
t.keyframesOffset = (ushort)bits.keyframes.Count;
t.keyFrameCount = (byte)gradients[i].keyframes.Count;
t.ledMask = 0;
t.ledMask = (uint)(1 << i);
// Add the keyframes
foreach (var editKeyframe in gradients[i].keyframes)
{
var kf = editKeyframe.ToKeyframe(editSet, bits);
bits.keyframes.Add(kf);
}
ret[i] = t;
}
return(ret);
}
public override Animation ToAnimation(EditDataSet editSet, DataSet.AnimationBits bits)
{
var ret = new AnimationGradientPattern();
ret.duration = (ushort)(duration * 1000); // stored in milliseconds
ret.speedMultiplier256 = (ushort)(this.speedMultiplier * 256.0f);
ret.tracksOffset = (ushort)editSet.getPatternTrackOffset(pattern);
ret.trackCount = (ushort)pattern.gradients.Count;
// Add gradient
ret.gradientTrackOffset = (ushort)bits.rgbTracks.Count;
var tempTrack = new EditRGBTrack()
{
gradient = gradient
};
var gradientTrack = tempTrack.ToTrack(editSet, bits);
bits.rgbTracks.Add(gradientTrack);
ret.overrideWithFace = (byte)(overrideWithFace ? 1 : 0);
return(ret);
}
/// <summary>
/// Evaluate an animation track's for a given time, in milliseconds, and fills returns arrays of led indices and colors
/// Values outside the track's range are clamped to first or last keyframe value.
/// </summary>
public int evaluate(DataSet.AnimationBits bits, uint color, int time, int[] retIndices, uint[] retColors)
{
if (keyFrameCount == 0)
{
return(0);
}
uint mcolor = modulateColor(bits, color, time);
// Fill the return arrays
int currentCount = 0;
for (int i = 0; i < 20; ++i) // <-- should come from somewhere!
{
if ((ledMask & (1 << i)) != 0)
{
retIndices[currentCount] = i;
retColors[currentCount] = mcolor;
currentCount++;
}
}
return(currentCount);
}
public override Animation ToAnimation(EditDataSet editSet, DataSet.AnimationBits bits)
{
var ret = new AnimationKeyframed();
ret.duration = (ushort)(duration * 1000); // stored in milliseconds
ret.speedMultiplier256 = (ushort)(this.speedMultiplier * 256.0f);
ret.tracksOffset = (ushort)editSet.getPatternRGBTrackOffset(pattern);
//// Copy the pattern so we can adjust the hue of the keyframes
//var patternCopy = pattern.Duplicate();
//foreach (var t in patternCopy.gradients)
//{
// foreach (var k in t.keyframes)
// {
// float h, s, v;
// Color.RGBToHSV(k.color, out h, out s, out v);
// h = Mathf.Repeat(h + hueAdjust, 1.0f);
// k.color = Color.HSVToRGB(h, s, v);
// }
//}
//var tracks = patternCopy.ToRGBTracks(editSet, bits);
ret.trackCount = (ushort)pattern.gradients.Count;
ret.flowOrder = flowOrder ? (byte)1 : (byte)0;
return(ret);
}
public AnimationInstance(Animation animation, DataSet.AnimationBits bits)
{
animationPreset = animation;
animationBits = bits;
}
public Keyframe getKeyframe(DataSet.AnimationBits bits, ushort keyframeIndex)
{
Debug.Assert(keyframeIndex < keyFrameCount);
return(bits.getKeyframe((ushort)(keyframesOffset + keyframeIndex)));
}
public uint ledMask; // Each bit indicates whether the led is included in the animation track
public ushort getDuration(DataSet.AnimationBits bits)
{
var kf = bits.getRGBKeyframe((ushort)(keyframesOffset + keyFrameCount - 1));
return(kf.time());
}
public AnimationInstanceGradientPattern(AnimationGradientPattern preset, DataSet.AnimationBits bits)
: base(preset, bits)
{
}
public AnimationInstance CreateInstance(DataSet.AnimationBits bits)
{
return(new AnimationInstanceGradientPattern(this, bits));
}
public AnimationInstance CreateInstance(DataSet.AnimationBits bits)
{
return(new AnimationInstanceFadeCandy(this, bits));
}
public uint specialColorPayload; // meaning varies
public AnimationInstanceKeyframed(AnimationKeyframed preset, DataSet.AnimationBits bits)
: base(preset, bits)
{
}
public AnimationInstanceFadeCandy(Animation animation, DataSet.AnimationBits bits)
: base(animation, bits)
{
}
public AnimationInstanceRainbow(Animation animation, DataSet.AnimationBits bits)
: base(animation, bits)
{
}
public AnimationInstance CreateInstance(DataSet.AnimationBits bits)
{
return(new AnimationInstanceSimple(this, bits));
}
public AnimationInstanceGradient(Animation animation, DataSet.AnimationBits bits)
: base(animation, bits)
{
}
public uint color(DataSet.AnimationBits bits)
{
return(bits.getColor32(colorIndex()));
}
public abstract Animation ToAnimation(EditDataSet editSet, DataSet.AnimationBits bits);
public AnimationInstanceSimple(Animation animation, DataSet.AnimationBits bits)
: base(animation, bits)
{
}
public AnimationInstance CreateInstance(DataSet.AnimationBits bits)
{
return(new AnimationInstanceKeyframed(this, bits));
}
