private void ReadStreamedData(ImportedKeyframedAnimation iAnim, AnimationClipBindingConstant m_ClipBindingConstant, float time, StreamedClip.StreamedCurveKey curveKey)
{
var binding = m_ClipBindingConstant.FindBinding(curveKey.index);
if (binding.path == 0) // Model binding, path is empty
{
var target = "Model";
var id = string.Empty;
if (binding.attribute == 2353026298) // Opacity -> Opacity
{
id = "Opacity";
}
else if (binding.attribute == 66473442) // EyeOpening -> EyeBlink
{
id = "EyeBlink";
}
else if (binding.attribute == 4109387685) // MouthOpening -> LipSync
{
id = "LipSync";
}
var track = iAnim.FindTrack(id);
track.Target = target;
track.Curve.Add(new ImportedKeyframe <float>(time, curveKey.value, curveKey.inSlope, curveKey.outSlope));
}
else
{
GetLive2dPath(binding.path, out var target, out var boneName);
var track = iAnim.FindTrack(boneName);
track.Target = target;
track.Curve.Add(new ImportedKeyframe <float>(time, curveKey.value, curveKey.inSlope, curveKey.outSlope));
}
}
private void ProcessDenses(Clip clip, AnimationClipBindingConstant bindings, IReadOnlyDictionary <uint, string> tos)
{
DenseClip dense = clip.DenseClip;
int streamCount = clip.StreamedClip.CurveCount;
float[] slopeValues = new float[4]; // no slopes - 0 values
for (int frameIndex = 0; frameIndex < dense.FrameCount; frameIndex++)
{
float time = frameIndex / dense.SampleRate;
int frameOffset = frameIndex * dense.CurveCount;
for (int curveIndex = 0; curveIndex < dense.CurveCount;)
{
int index = streamCount + curveIndex;
GenericBinding binding = bindings.FindBinding(index);
string path = GetCurvePath(tos, binding.Path);
int framePosition = frameOffset + curveIndex;
if (binding.IsTransform)
{
AddTransformCurve(time, binding.TransformType, dense.SampleArray, slopeValues, slopeValues, framePosition, path);
curveIndex += binding.TransformType.GetDimension();
}
else if (binding.CustomType == BindingCustomType.None)
{
AddDefaultCurve(binding, path, time, dense.SampleArray[framePosition]);
curveIndex++;
}
else
{
AddCustomCurve(bindings, binding, path, time, dense.SampleArray[framePosition]);
curveIndex++;
}
}
}
}
private void ReadCurveData(ImportedKeyframedAnimation iAnim, AnimationClipBindingConstant m_ClipBindingConstant, int index, float time, float[] data, int offset, ref int curveIndex)
{
var binding = m_ClipBindingConstant.FindBinding(index);
if (binding.path == 0) // Model binding, path is empty
{
var target = "Model";
var id = string.Empty;
if (binding.attribute == 2353026298) // Opacity -> Opacity
{
id = "Opacity";
}
else if (binding.attribute == 66473442) // EyeOpening -> EyeBlink
{
id = "EyeBlink";
}
else if (binding.attribute == 4109387685) // MouthOpening -> LipSync
{
id = "LipSync";
}
var track = iAnim.FindTrack(id);
track.Target = target;
var value = data[curveIndex++];
track.Curve.Add(new ImportedKeyframe <float>(time, value));
}
else
{
GetLive2dPath(binding.path, out var target, out var boneName);
var track = iAnim.FindTrack(boneName);
track.Target = target;
var value = data[curveIndex++];
track.Curve.Add(new ImportedKeyframe <float>(time, value));
}
}
private void ReadStreamedData(ImportedKeyframedAnimation iAnim, AnimationClipBindingConstant m_ClipBindingConstant, float time, StreamedClip.StreamedCurveKey curveKey)
{
var binding = m_ClipBindingConstant.FindBinding(curveKey.index);
GetLive2dPath(binding, out var target, out var boneName);
var track = iAnim.FindTrack(boneName);
track.Target = target;
track.Curve.Add(new ImportedKeyframe <float>(time, curveKey.value, curveKey.inSlope, curveKey.outSlope));
}
private void ReadCurveData(ImportedKeyframedAnimation iAnim, AnimationClipBindingConstant m_ClipBindingConstant, int index, float time, float[] data, int offset, ref int curveIndex)
{
var binding = m_ClipBindingConstant.FindBinding(index);
GetLive2dPath(binding, out var target, out var boneName);
var track = iAnim.FindTrack(boneName);
track.Target = target;
var value = data[curveIndex++];
track.Curve.Add(new ImportedKeyframe <float>(time, value, 0, 0));
}
private void ProcessStreams(IReadOnlyList <StreamedFrame> streamFrames, AnimationClipBindingConstant bindings, IReadOnlyDictionary <uint, string> tos, float sampleRate)
{
float[] curveValues = new float[4];
float[] inSlopeValues = new float[4];
float[] outSlopeValues = new float[4];
float interval = 1.0f / sampleRate;
// first (index [0]) stream frame is for slope calculation for the first real frame (index [1])
// last one (index [count - 1]) is +Infinity
// it is made for slope processing, but we don't need them
for (int frameIndex = 1; frameIndex < streamFrames.Count - 1; frameIndex++)
{
StreamedFrame frame = streamFrames[frameIndex];
for (int curveIndex = 0; curveIndex < frame.Curves.Length;)
{
StreamedCurveKey curve = frame.Curves[curveIndex];
GenericBinding binding = bindings.FindBinding(curve.Index);
string path = GetCurvePath(tos, binding.Path);
if (binding.IsTransform)
{
GetPreviousFrame(streamFrames, curve.Index, frameIndex, out int prevFrameIndex, out int prevCurveIndex);
int dimension = binding.TransformType.GetDimension();
for (int key = 0; key < dimension; key++)
{
StreamedCurveKey keyCurve = frame.Curves[curveIndex];
StreamedFrame prevFrame = streamFrames[prevFrameIndex];
StreamedCurveKey prevKeyCurve = prevFrame.Curves[prevCurveIndex + key];
float deltaTime = frame.Time - prevFrame.Time;
curveValues[key] = keyCurve.Value;
inSlopeValues[key] = prevKeyCurve.CalculateNextInSlope(deltaTime, keyCurve.Value);
outSlopeValues[key] = keyCurve.OutSlope;
curveIndex = GetNextCurve(frame, curveIndex);
}
AddTransformCurve(frame.Time, binding.TransformType, curveValues, inSlopeValues, outSlopeValues, 0, path);
}
else if (binding.CustomType == BindingCustomType.None)
{
AddDefaultCurve(binding, path, frame.Time, frame.Curves[curveIndex].Value);
curveIndex = GetNextCurve(frame, curveIndex);
}
else
{
AddCustomCurve(bindings, binding, path, frame.Time, frame.Curves[curveIndex].Value);
curveIndex = GetNextCurve(frame, curveIndex);
}
}
}
}
private void AddPPtrKeyframe(PPtrCurve curve, AnimationClipBindingConstant bindings, float time, int index)
{
if (!m_pptrs.TryGetValue(curve, out List <PPtrKeyframe> pptrCurve))
{
pptrCurve = new List <PPtrKeyframe>();
m_pptrs.Add(curve, pptrCurve);
AddPPtrKeyframe(curve, bindings, 0.0f, index - 1);
}
PPtr <Object> value = bindings.PPtrCurveMapping[index];
PPtrKeyframe pptrKey = new PPtrKeyframe(time, value);
pptrCurve.Add(pptrKey);
}
private void ProcessInner()
{
Clip clip = m_clip.MuscleClip.Clip;
AnimationClipBindingConstant bindings = m_clip.ClipBindingConstant;
IReadOnlyDictionary <uint, string> tos = m_clip.FindTOS();
IReadOnlyList <StreamedFrame> streamedFrames = clip.StreamedClip.GenerateFrames(Layout);
float lastDenseFrame = clip.DenseClip.FrameCount / clip.DenseClip.SampleRate;
float lastSampleFrame = streamedFrames.Count > 1 ? streamedFrames[streamedFrames.Count - 2].Time : 0.0f;
float lastFrame = Math.Max(lastDenseFrame, lastSampleFrame);
ProcessStreams(streamedFrames, bindings, tos, clip.DenseClip.SampleRate);
ProcessDenses(clip, bindings, tos);
if (Clip.HasConstantClip(Layout.Info.Version))
{
ProcessConstant(clip, bindings, tos, lastFrame);
}
CreateCurves();
}
private void ReadCurveData(ImportedKeyframedAnimation iAnim, AnimationClipBindingConstant m_ClipBindingConstant, int index, float time, float[] data, int offset, ref int curveIndex)
{
var binding = m_ClipBindingConstant.FindBinding(index);
if (binding.path == 0)
{
curveIndex++;
return;
}
GetLive2dPath(binding.path, out var target, out var boneName);
var track = iAnim.FindTrack(boneName);
track.Target = target;
switch (binding.attribute)
{
default:
track.Curve.Add(new ImportedKeyframe <float>(time, data[curveIndex++]));
break;
}
}
private void AddCustomCurve(AnimationClipBindingConstant bindings, GenericBinding binding, string path, float time, float value)
{
switch (binding.CustomType)
{
case BindingCustomType.AnimatorMuscle:
AddAnimatorMuscleCurve(binding, time, value);
break;
default:
string attribute = m_customCurveResolver.ToAttributeName(Layout, binding.CustomType, binding.Attribute, path);
if (binding.IsPPtrCurve)
{
PPtrCurve curve = new PPtrCurve(path, attribute, binding.ClassID, binding.Script.CastTo <MonoScript>());
AddPPtrKeyframe(curve, bindings, time, (int)value);
}
else
{
FloatCurve curve = new FloatCurve(path, attribute, binding.ClassID, binding.Script.CastTo <MonoScript>());
AddFloatKeyframe(curve, time, value);
}
break;
}
}
private void ProcessConstant(Clip clip, AnimationClipBindingConstant bindings, IReadOnlyDictionary <uint, string> tos, float lastFrame)
{
ConstantClip constant = clip.ConstantClip;
int streamCount = clip.StreamedClip.CurveCount;
int denseCount = clip.DenseClip.CurveCount;
float[] slopeValues = new float[4]; // no slopes - 0 values
// only first and last frames
float time = 0.0f;
for (int i = 0; i < 2; i++, time += lastFrame)
{
for (int curveIndex = 0; curveIndex < constant.Constants.Length;)
{
int index = streamCount + denseCount + curveIndex;
GenericBinding binding = bindings.FindBinding(index);
string path = GetCurvePath(tos, binding.Path);
if (binding.IsTransform)
{
AddTransformCurve(time, binding.TransformType, constant.Constants, slopeValues, slopeValues, curveIndex, path);
curveIndex += binding.TransformType.GetDimension();
}
else if (binding.CustomType == BindingCustomType.None)
{
AddDefaultCurve(binding, path, time, constant.Constants[curveIndex]);
curveIndex++;
}
else
{
AddCustomCurve(bindings, binding, path, time, constant.Constants[curveIndex]);
curveIndex++;
}
}
}
}
public AnimationClip(AssetInfo assetInfo) :
base(assetInfo)
{
MuscleClip = new ClipMuscleConstant(AssetsFile);
ClipBindingConstant = new AnimationClipBindingConstant(AssetsFile);
}
