public static bool NewCalcBlendShape(FBSBase __instance)
{
var enabled = LipsyncConfig.Instance.enabled;
if (!enabled)
{
return(true);
}
var nowFace = AccessTools.Field(typeof(FBSCtrlMouth), "dictNowFace").GetValue(__instance) as Dictionary <int, float>;
var openness = (float)AccessTools.Field(typeof(FBSCtrlMouth), "FixedRate").GetValue(__instance);
if (nowFace is null)
{
return(true);
}
if (LipsyncConfig.Instance.frameStore.TryGetValue(__instance.GetHashCode(), out var targetFrame))
{
MapFrame(targetFrame, ref nowFace, ref openness);
AccessTools.Field(typeof(FBSCtrlMouth), "FixedRate").SetValue(__instance, openness);
AccessTools.Field(typeof(FBSCtrlMouth), "dictNowFace").SetValue(__instance, nowFace);
return(true);
}
else
{
return(true);
}
}
private int GetMaxPatterns(FBSBase fbs)
{
int num = 0;
for (int i = 0; i < fbs.FBSTarget.Length; i++)
{
num = Math.Max(num, fbs.FBSTarget[i].PtnSet.Length);
}
return(num);
}
public static bool NewCalcBlendShape(FBSBase __instance)
{
var enabled = LipsyncConfig.Instance.enabled;
if (!enabled)
{
return(true);
}
var nowFace = AccessTools.Field(typeof(FBSCtrlMouth), "dictNowFace").GetValue(__instance) as Dictionary <int, float>;
if (nowFace is null)
{
return(true);
}
LipsyncConfig cfg = LipsyncConfig.Instance;
if (cfg.frameStore.TryGetValue(__instance.GetHashCode(), out var targetFrame))
{
var openness = (float)AccessTools.Field(typeof(FBSCtrlMouth), "openRate").GetValue(__instance);
if (!cfg.baseFaceStore.TryGetValue(__instance.GetHashCode(), out var baseFace))
{
baseFace = new Dictionary <int, float>();
cfg.baseFaceStore[__instance.GetHashCode()] = baseFace;
}
if (!cfg.lastFaceStore.TryGetValue(__instance.GetHashCode(), out var lastFace))
{
lastFace = new Dictionary <int, float>();
cfg.lastFaceStore[__instance.GetHashCode()] = lastFace;
}
MapFrame(targetFrame, ref baseFace, ref lastFace, ref nowFace, ref openness);
AccessTools.Field(typeof(FBSCtrlMouth), "openRate").SetValue(__instance, openness);
AccessTools.Field(typeof(FBSCtrlMouth), "dictNowFace").SetValue(__instance, nowFace);
return(true);
}
else
{
return(true);
}
}
public static bool CalculateBlendShape(FBSBase __instance, float ___correctOpenMax, float ___openRate,
TimeProgressCtrl ___blendTimeCtrl, Dictionary<int, float> ___dictBackFace,
Dictionary<int, float> ___dictNowFace)
{
if (__instance.FBSTarget.Length == 0) return false;
var openMax = ___correctOpenMax >= 0f ? ___correctOpenMax : __instance.OpenMax;
var lerpOpenRate = Mathf.Lerp(__instance.OpenMin, openMax, ___openRate);
if (0f <= __instance.FixedRate) lerpOpenRate = __instance.FixedRate;
var rate = 0f;
if (___blendTimeCtrl != null) rate = ___blendTimeCtrl.Calculate();
retry:
try
{
for (var index = 0; index < __instance.FBSTarget.Length; index++)
{
for (var i = 0; i < _blendIdCache.Count; i++)
{
_blendIdCache[i] = false;
_blendValueCache[i] = 0f;
}
var targetInfo = __instance.FBSTarget[index];
var skinnedMeshRenderer = targetInfo.GetSkinnedMeshRenderer();
var percent = (int)Mathf.Clamp(lerpOpenRate * 100f, 0f, 100f);
for (var j = 0; j < targetInfo.PtnSet.Length; j++)
{
var ptnSet = targetInfo.PtnSet[j];
var resultClose = 0f;
var resultOpen = 0f;
if (rate != 1f)
{
if (___dictBackFace.TryGetValue(j, out var valueBack))
{
resultClose += valueBack * (100 - percent) * (1f - rate);
resultOpen += valueBack * percent * (1f - rate);
}
}
if (___dictNowFace.TryGetValue(j, out var valueNow))
{
resultClose += valueNow * (100 - percent) * rate;
resultOpen += valueNow * percent * rate;
}
if (ptnSet.Close >= 0)
{
_blendIdCache[ptnSet.Close] = true;
_blendValueCache[ptnSet.Close] += resultClose;
}
if (ptnSet.Open >= 0)
{
_blendIdCache[ptnSet.Open] = true;
_blendValueCache[ptnSet.Open] += resultOpen;
}
}
for (var i = 0; i < _blendIdCache.Count; i++)
{
if (_blendIdCache[i])
{
skinnedMeshRenderer.SetBlendShapeWeight(i, _blendValueCache[i]);
}
}
}
return false;
}
catch (ArgumentOutOfRangeException)
{
UnityEngine.Debug.Log("Increasing blend ID cache size");
_blendIdCache.AddRange(Enumerable.Repeat(false, 50));
_blendValueCache.AddRange(Enumerable.Repeat(0f, 50));
goto retry;
}
}
