Skip to content
Merged
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
4 changes: 4 additions & 0 deletions Editor/AvatarAidNdmfPlugin.cs
Original file line number Diff line number Diff line change
Expand Up @@ -16,6 +16,10 @@ protected override void Configure()
{
InPhase(BuildPhase.Generating).Run("Apply FaceEmote", ctx => new FaceEmoteProcessor().Process(ctx));
InPhase(BuildPhase.Transforming).Run("Apply DistanceFade", ctx => new LiltoonDistanceFadeProcessor().Process(ctx));
InPhase(BuildPhase.Optimizing)
.AfterPlugin("nadena.dev.modular-avatar")
.AfterPlugin("nadena.dev.modular-avatar.late-transform-stages")
.Run("Compress Shared Int Parameters", ctx => new CompressSharedIntParametersProcessor().Process(ctx));
}
}
}
349 changes: 349 additions & 0 deletions Editor/CompressSharedIntParametersProcessor.cs
Original file line number Diff line number Diff line change
@@ -0,0 +1,349 @@
using System.Collections.Generic;
using System.Linq;
using UnityEditor.Animations;
using UnityEngine;
using VRC.SDK3.Avatars.Components;
using VRC.SDK3.Avatars.ScriptableObjects;
using nadena.dev.ndmf;

namespace Paltee.AvatarAid
{
public class CompressSharedIntParametersProcessor
{
private const string IsLocalParamName = "IsLocal";

private List<string> _excludePrefixes;

public void Process(BuildContext context)
{
var marker = context.AvatarRootObject.GetComponent<Runtime.CompressSharedIntParameters>();
if (marker == null) return;

_excludePrefixes = marker.ExcludePrefixes;

Apply(context);

UnityEngine.Object.DestroyImmediate(marker);
}

protected void Apply(BuildContext context)
{
var descriptor = context.AvatarRootObject.GetComponent<VRCAvatarDescriptor>();
if (descriptor == null) return;

var expressionParameters = descriptor.expressionParameters;
if (expressionParameters == null) return;

var fxController = GetFxAnimatorController(descriptor);
if (fxController == null) return;

var controllerParamNames = new HashSet<string>(
fxController.parameters.Select(p => p.name));

var syncedIntParams = expressionParameters.parameters
.Where(p => p.networkSynced && p.valueType == VRCExpressionParameters.ValueType.Int)
.ToList();

foreach (var expParam in syncedIntParams)
{
var controllerParamName = FindControllerParamName(expParam.name, controllerParamNames);
if (controllerParamName == null) continue;

if (IsExcluded(expParam.name) || IsExcluded(controllerParamName)) continue;

ProcessParameter(expParam, controllerParamName, fxController, expressionParameters);
}
}

private string FindControllerParamName(string expParamName, HashSet<string> controllerParamNames)
{
if (controllerParamNames.Contains(expParamName))
return expParamName;

foreach (var name in controllerParamNames)
{
if (name.StartsWith(expParamName + "$"))
return name;
}

return null;
}

private bool IsExcluded(string paramName)
{
foreach (var prefix in _excludePrefixes)
{
if (!string.IsNullOrEmpty(prefix) && paramName.StartsWith(prefix))
return true;
}
return false;
}

protected AnimatorController GetFxAnimatorController(VRCAvatarDescriptor descriptor)
{
if (!descriptor.customizeAnimationLayers) return null;

foreach (var layer in descriptor.baseAnimationLayers)
{
if (layer.type == VRCAvatarDescriptor.AnimLayerType.FX && !layer.isDefault)
{
return layer.animatorController as AnimatorController;
}
}
return null;
}

protected void ProcessParameter(
VRCExpressionParameters.Parameter expParam,
string controllerParamName,
AnimatorController controller,
VRCExpressionParameters expressionParameters)
{
var defaultValue = (int)expParam.defaultValue;

var isFloatParam = IsFloatParameter(controller, controllerParamName);

var possibleValues = DetectPossibleValues(controller, controllerParamName, defaultValue);
if (possibleValues.Count == 0) return;

int bitCount = CalculateBitCount(possibleValues.Count);
if (bitCount >= 8) return;

var sortedValues = possibleValues.OrderBy(v => v).ToList();
var valueToIndex = new Dictionary<int, int>();
for (int i = 0; i < sortedValues.Count; i++)
{
valueToIndex[sortedValues[i]] = i;
}

EnsureIsLocalParam(controller);
for (int n = 0; n < bitCount; n++)
{
var bitParamName = $"{controllerParamName}_bit{n}";
if (controller.parameters.All(p => p.name != bitParamName))
{
controller.AddParameter(bitParamName, AnimatorControllerParameterType.Bool);
}
}

controller.AddLayer(GenerateEncoderLayer(controllerParamName, valueToIndex, bitCount, isFloatParam));
controller.AddLayer(GenerateDecoderLayer(controllerParamName, valueToIndex, bitCount));

expParam.networkSynced = false;

var paramsList = expressionParameters.parameters.ToList();
for (int n = 0; n < bitCount; n++)
{
paramsList.Add(new VRCExpressionParameters.Parameter
{
name = $"{controllerParamName}_bit{n}",
valueType = VRCExpressionParameters.ValueType.Bool,
defaultValue = 0,
saved = false,
networkSynced = true,
});
}
expressionParameters.parameters = paramsList.ToArray();
}

public HashSet<int> DetectPossibleValues(AnimatorController controller, string paramName, int defaultValue)
{
var values = new HashSet<int> { defaultValue };

foreach (var layer in controller.layers)
{
CollectValuesFromStateMachine(layer.stateMachine, paramName, values);
}

return values;
}

private void CollectValuesFromStateMachine(AnimatorStateMachine stateMachine, string paramName, HashSet<int> values)
{
if (stateMachine == null) return;

foreach (var transition in stateMachine.anyStateTransitions)
{
CollectValuesFromConditions(transition.conditions, paramName, values);
}

foreach (var stateInfo in stateMachine.states)
{
var state = stateInfo.state;
foreach (var transition in state.transitions)
{
CollectValuesFromConditions(transition.conditions, paramName, values);
}

foreach (var behaviour in state.behaviours)
{
if (behaviour is VRCAvatarParameterDriver driver)
{
foreach (var driverParam in driver.parameters)
{
if (driverParam.name == paramName &&
driverParam.type == VRCAvatarParameterDriver.ChangeType.Set)
{
values.Add((int)driverParam.value);
}
}
}
}
}

foreach (var subSM in stateMachine.stateMachines)
{
CollectValuesFromStateMachine(subSM.stateMachine, paramName, values);
}
}

private void CollectValuesFromConditions(AnimatorCondition[] conditions, string paramName, HashSet<int> values)
{
foreach (var condition in conditions)
{
if (condition.parameter == paramName)
{
values.Add((int)condition.threshold);
}
}
}

public int CalculateBitCount(int distinctCount)
{
if (distinctCount <= 1) return 1;
int bits = 1;
long capacity = 2;
while (capacity < distinctCount)
{
bits++;
capacity <<= 1;
}
return bits;
}

private void EnsureIsLocalParam(AnimatorController controller)
{
if (controller.parameters.All(p => p.name != IsLocalParamName))
{
controller.AddParameter(IsLocalParamName, AnimatorControllerParameterType.Bool);
}
}

private bool IsFloatParameter(AnimatorController controller, string paramName)
{
return controller.parameters.Any(p => p.name == paramName && p.type == AnimatorControllerParameterType.Float);
}

protected AnimatorControllerLayer GenerateEncoderLayer(
string paramName,
Dictionary<int, int> valueToIndex,
int bitCount,
bool isFloatParam)
{
var stateMachine = new AnimatorStateMachine();
var idleState = new AnimatorState { name = "Idle" };
stateMachine.AddState(idleState, Vector3.zero);
stateMachine.defaultState = idleState;

foreach (var kvp in valueToIndex.OrderBy(x => x.Key))
{
int value = kvp.Key;
int index = kvp.Value;

var state = new AnimatorState { name = $"Encode_{value}" };
stateMachine.AddState(state, new Vector3(200, index * 80));

var driver = state.AddStateMachineBehaviour<VRCAvatarParameterDriver>();
driver.localOnly = false;
driver.parameters = new List<VRCAvatarParameterDriver.Parameter>();
for (int n = 0; n < bitCount; n++)
{
int bitValue = (index >> n) & 1;
driver.parameters.Add(new VRCAvatarParameterDriver.Parameter
{
type = VRCAvatarParameterDriver.ChangeType.Set,
name = $"{paramName}_bit{n}",
value = bitValue,
});
}

var transition = stateMachine.AddAnyStateTransition(state);
transition.canTransitionToSelf = false;
transition.duration = 0;
transition.hasExitTime = false;
transition.hasFixedDuration = true;
transition.AddCondition(AnimatorConditionMode.If, 1, IsLocalParamName);
if (isFloatParam)
{
transition.AddCondition(AnimatorConditionMode.Greater, value - 0.5f, paramName);
transition.AddCondition(AnimatorConditionMode.Less, value + 0.5f, paramName);
}
else
{
transition.AddCondition(AnimatorConditionMode.Equals, value, paramName);
}
}

return new AnimatorControllerLayer
{
name = $"{paramName}_Encoder",
defaultWeight = 1f,
stateMachine = stateMachine,
};
}

protected AnimatorControllerLayer GenerateDecoderLayer(
string paramName,
Dictionary<int, int> valueToIndex,
int bitCount)
{
var stateMachine = new AnimatorStateMachine();
var idleState = new AnimatorState { name = "Idle" };
stateMachine.AddState(idleState, Vector3.zero);
stateMachine.defaultState = idleState;

foreach (var kvp in valueToIndex.OrderBy(x => x.Key))
{
int value = kvp.Key;
int index = kvp.Value;

var state = new AnimatorState { name = $"Decode_{value}" };
stateMachine.AddState(state, new Vector3(200, index * 80));

var driver = state.AddStateMachineBehaviour<VRCAvatarParameterDriver>();
driver.localOnly = false;
driver.parameters = new List<VRCAvatarParameterDriver.Parameter>
{
new VRCAvatarParameterDriver.Parameter
{
type = VRCAvatarParameterDriver.ChangeType.Set,
name = paramName,
value = value,
}
};

var transition = stateMachine.AddAnyStateTransition(state);
transition.canTransitionToSelf = false;
transition.duration = 0;
transition.hasExitTime = false;
transition.hasFixedDuration = true;
transition.AddCondition(AnimatorConditionMode.IfNot, 0, IsLocalParamName);
for (int n = 0; n < bitCount; n++)
{
int bitValue = (index >> n) & 1;
transition.AddCondition(
bitValue == 1 ? AnimatorConditionMode.If : AnimatorConditionMode.IfNot,
bitValue,
$"{paramName}_bit{n}");
}
}

return new AnimatorControllerLayer
{
name = $"{paramName}_Decoder",
defaultWeight = 1f,
stateMachine = stateMachine,
};
}
}
}
11 changes: 11 additions & 0 deletions Editor/CompressSharedIntParametersProcessor.cs.meta

Some generated files are not rendered by default. Learn more about how customized files appear on GitHub.

14 changes: 14 additions & 0 deletions Runtime/CompressSharedIntParameters.cs
Original file line number Diff line number Diff line change
@@ -0,0 +1,14 @@
using System.Collections.Generic;
using UnityEngine;
using VRC.SDKBase;

namespace Paltee.AvatarAid.Runtime
{
[DisallowMultipleComponent]
[AddComponentMenu("AvatarAid/Compress Shared Int Parameters")]
public sealed class CompressSharedIntParameters : MonoBehaviour, IEditorOnly
{
[Tooltip("処理対象から除外するパラメーター名のプレフィックスのリスト(前方一致)")]
public List<string> ExcludePrefixes = new List<string>();
}
}
11 changes: 11 additions & 0 deletions Runtime/CompressSharedIntParameters.cs.meta

Some generated files are not rendered by default. Learn more about how customized files appear on GitHub.

Loading
Loading