private static void LegacyRemoval(VRCExpressionParameters expressionParameters)
{
var legacyParamA = expressionParameters.FindParameter("J1I7T_A_Sync");
var legacyParamB = expressionParameters.FindParameter("J1I7T_B_Sync");
if (legacyParamA != null || legacyParamB != null)
{
EditorGUILayout.LabelField("Legacy", EditorStyles.boldLabel);
if (legacyParamA != null)
{
EditorGUILayout.HelpBox("Your avatar has an Expression Parameter with name J1I7T_A_Sync. It is no longer used.", MessageType.Error);
}
if (legacyParamB != null)
{
EditorGUILayout.HelpBox("Your avatar has an Expression Parameter with name J1I7T_B_Sync. It is no longer used.", MessageType.Error);
}
if (GUILayout.Button("Fix: Remove legacy Expression Parameters"))
{
expressionParameters.parameters = expressionParameters.parameters
.Where(parameter => parameter.name != "J1I7T_A_Sync")
.Where(parameter => parameter.name != "J1I7T_B_Sync")
.ToArray();
ForceSaveAsset(expressionParameters);
}
}
}
public static void MergeParameters(this VRCExpressionParameters source, params VRCExpressionParameters[] parameters)
{
foreach (var parameter in parameters.SelectMany(w => w.parameters))
{
if (string.IsNullOrWhiteSpace(parameter.name))
{
continue;
}
if (DefaultParameterNames.Contains(parameter.name))
{
continue;
}
if (source.HasParameter(parameter.name))
{
continue;
}
source.AddParameter(parameter);
if (source.CalcTotalCost() > VRCExpressionParameters.MAX_PARAMETER_COST)
{
Debug.LogWarning($"parameter `{parameter.name}` is merged but total cost is greater than allowed size => ${source.CalcTotalCost()}");
}
}
}
public void Set(Animator animator, VRCExpressionsMenu menu, VRCExpressionParameters parameters, IEnumerable <AnimatorControllerPlayable> animatorControllerPlayables)
{
_menu = menu;
MainMenuPrefab();
_paramType.Clear();
foreach (var controller in animatorControllerPlayables)
{
foreach (var parameter in RadialMenuUtility.GetParameters(controller))
{
_paramType[parameter.name] = RadialMenuUtility.CreateParamFromController(animator, parameter, controller);
}
}
if (!parameters)
{
return;
}
foreach (var parameter in parameters.parameters)
{
if (!_paramType.ContainsKey(parameter.name))
{
_paramType[parameter.name] = RadialMenuUtility.CreateParamFromNothing(parameter);
}
}
foreach (var parameter in parameters.parameters)
{
_paramType[parameter.name].InternalSet(parameter.defaultValue);
}
}
public Emh.EmhQualification Qualify(VRCExpressionParameters expParametersOptional, string[] tags)
{
var myTags = !string.IsNullOrEmpty(discardTags) ? discardTags.Split(',') : new string[0];
foreach (var discardTag in tags)
{
if (myTags.Contains(discardTag))
{
return(Emh.EmhQualification.ElementIsNonFunctional);
}
}
switch (type)
{
case Emh.EmhType.SubMenu:
var functional = Functional(expParametersOptional, parameter);
return(functional == Emh.EmhQualification.ElementIsAesthetic ? Emh.EmhQualification.ElementIsFunctional : functional);
case Emh.EmhType.Button:
case Emh.EmhType.Toggle:
return(Functional(expParametersOptional, parameter));
case Emh.EmhType.TwoAxisPuppet:
return(Functional(expParametersOptional, parameter, puppetParameter0, puppetParameter1));
case Emh.EmhType.FourAxisPuppet:
return(Functional(expParametersOptional, parameter, puppetParameter0, puppetParameter1, puppetParameter2, puppetParameter3));
case Emh.EmhType.RadialPuppet:
return(Functional(expParametersOptional, parameter, puppetParameter0));
default:
throw new ArgumentOutOfRangeException();
}
}
public static IEnumerable <string> CheckWarnings(VRCExpressionsMenu menu, VRCExpressionParameters param)
{
return(from paramName in GetParams(GetMenus(menu))
let isDefined = string.IsNullOrEmpty(paramName) || param.FindParameter(paramName) != null
where !isDefined
select "Menu uses a parameter that is not defined: " + paramName);
}
public BitActionSwitchCreator(VRCAvatarDescriptor avatarDescriptor, AnimatorController animatorController,
VRCExpressionParameters expressionParameters, Scripts.BitActionSwitch bitActionSwitch, string workingDirectory)
{
this.animatorController = animatorController;
this.expressionParameters = expressionParameters;
this.bitActionSwitch = bitActionSwitch;
this.avatarDescriptor = avatarDescriptor;
this.workingDirectory = workingDirectory;
}
public static void RemoveBitKeys(VRCExpressionParameters parameters)
{
List <VRCExpressionParameters.Parameter> parametersList = parameters.parameters.ToList();
parametersList.RemoveAll(p => p.name.Contains("BitKey"));
parameters.parameters = parametersList.ToArray();
EditorUtility.SetDirty(parameters);
}
public RadialMenu CreateMainMenu(VRCExpressionsMenu menu, VRCExpressionParameters parameters)
{
RadialMenu rMenu = Instantiate(RadialMenuPrefab) as RadialMenu;
rMenu.gameObject.name = menu.name;
rMenu.Initialize(null, menu, parameters);
rMenu.transform.SetParent(transform, false);
rMenu.gameObject.SetActive(false);
return(rMenu);
}
private int GetParameterSize()
{
int size = 0;
for (int i = 0; i < expressionParams.parameters.Length; i++)
{
size += VRCExpressionParameters.TypeCost(expressionParams.parameters[i].valueType);
}
return(size);
}
public static void AddParametersToLastEmptySpace(this VRCExpressionParameters obj, string name, VRCExpressionParameters.ValueType type)
{
var last = obj.GetLastEmptyParameter();
if (last == null)
{
throw new ArgumentOutOfRangeException($"This exceeds the maximum number that can be set in {nameof(VRCExpressionParameters)}");
}
last.name = name;
last.valueType = type;
}
public static IEnumerable <string> CheckErrors(VRCExpressionsMenu menu, VRCExpressionParameters param)
{
var errors = new List <string>();
if (!menu && !param)
{
return(errors);
}
if (!menu || !param)
{
errors.Add(!menu ? "- No menu defined when parameters are defined!" : "- No parameters defined when menu is defined!");
}
return(errors);
}
private void OnEnable()
{
avatars = GetAvatars();
avatarKeys = avatars.Keys.ToArray();
if (0 != avatars.Count)
{
_8TrackEditor = new Avatar8TrackEditor(avatars[avatarKeys[0]]);
expressionParameters = avatars[avatarKeys[0]].expressionParameters;
expressionsMenu = avatars[avatarKeys[0]].expressionsMenu;
}
else
{
_8TrackEditor = new Avatar8TrackEditor();
}
}
public EmhCompose(ExpressionsMenuHierarchyCompiler compiler)
{
_mainAssetContainer = compiler.generatedMenu;
_defaultIconOptional = compiler.defaultIcon;
_mainMenu = compiler.mainMenu;
_generatedMenu = compiler.generatedMenu;
_expressionParametersOptional = compiler.expressionParameters;
_discardTags = !string.IsNullOrEmpty(compiler.discardTags) ? compiler.discardTags.Split(',') : new string[0];
_compilerDiscardType = compiler.discardType == Emh.EmhDiscardType.Default ? Emh.EmhDiscardType.GrayOut : compiler.discardType;
_discardGrayOut = compiler.discardGrayOut == null
? new Material(Shader.Find("Hai/ExpressionsMenuHierarchyEditorGrayOut"))
: compiler.discardGrayOut;
// Last operation (depends on the previous lines)
_discardApplicable = compiler.autoDiscard && (_expressionParametersOptional != null || _discardTags.Length != 0);
}
public static bool AddBitKeys(VRCExpressionParameters parameters)
{
List <VRCExpressionParameters.Parameter> paramList = parameters.parameters.ToList();
for (int i = 0; i < KeyCount; ++i)
{
string bitKeyName = $"BitKey{i}";
int index = Array.FindIndex(parameters.parameters, p => p.name == bitKeyName);
if (index != -1)
{
Debug.Log($"Found BitKey in params {bitKeyName}");
parameters.parameters[index].saved = true;
parameters.parameters[index].defaultValue = 0;
parameters.parameters[index].valueType = VRCExpressionParameters.ValueType.Bool;
}
else
{
Debug.Log($"Adding BitKey in params {bitKeyName}");
var newParam = new VRCExpressionParameters.Parameter
{
name = bitKeyName,
saved = true,
defaultValue = 0,
valueType = VRCExpressionParameters.ValueType.Bool
};
paramList.Add(newParam);
}
}
parameters.parameters = paramList.ToArray();
int remainingCost = VRCExpressionParameters.MAX_PARAMETER_COST - parameters.CalcTotalCost();;
Debug.Log(remainingCost);
if (remainingCost < 0)
{
Debug.LogError("Adding BitKeys took up too many parameters!");
EditorUtility.DisplayDialog("Adding BitKeys took up too many parameters!", "Go to your VRCExpressionParameters and remove some unnecessary parameters to make room for the 32 BitKey bools and run this again.", "Okay");
return(false);
}
EditorUtility.SetDirty(parameters);
return(true);
}
private static void NoNameRemoval(VRCExpressionParameters expressionParameters)
{
var anyBlankParameter = expressionParameters.parameters.Any(parameter => parameter.name == "");
if (anyBlankParameter)
{
EditorGUILayout.LabelField("Clean up", EditorStyles.boldLabel);
EditorGUILayout.HelpBox("Your avatar has Expression Parameters with no name. This will take up unnecessary memory that Just Hai Toggles Inventory System won't be able to use.", MessageType.Error);
if (GUILayout.Button("Fix: Remove empty Expression Parameters"))
{
expressionParameters.parameters = expressionParameters.parameters
.Where(parameter => parameter.name != "")
.ToArray();
ForceSaveAsset(expressionParameters);
}
}
}
private bool Initialized()
{
if (_initialized)
{
return(true);
}
Avatar = TEA_Manager.current.Avatar;
if (null == Avatar)
{
return(false);
}
newPosition = Avatar.transform.position;
horizontalRotation = Avatar.transform.rotation;
//--- paramters ---
mainMenu = Avatar.expressionsMenu;
parameters = Avatar.expressionParameters;
avatarAnim = Avatar.gameObject.GetComponent <Animator>();
avatarAnim.runtimeAnimatorController = TEA_Manager.current.Controllers[TEA_Manager.AvatarIndex()];
Grounded = true;
avatarAnim.SetBool("Grounded", Grounded);
TEA_PlayableLayerData layerData = TEA_Manager.current.LayerInfo[TEA_Manager.AvatarIndex()];
TEA_PlayableLayerData.PlayableLayerData data = layerData.FindPlayableLayerData(VRCAvatarDescriptor.AnimLayerType.Base);
for (int i = data.start; i < data.end; i++)
{
avatarAnim.SetLayerWeight(i, 1);
}
//--- events ---
controlEvents = new Dictionary <VRC.SDKBase.VRC_PlayableLayerControl.BlendableLayer, TEA_PlayableLayerControl>();
if (null == TEA_PlayableLayerControl.ApplySettings)
{
TEA_PlayableLayerControl.ApplySettings += TEA_PlayableLayerEvent;
}
_initialized = true;
return(true);
}
public void Initialize(RadialMenu parent, VRCExpressionsMenu menu, VRCExpressionParameters parameters)
{
this.Parent = parent;
this.VRCMenu = menu;
this.Parameters = parameters;
backButton = CreateButton(null, 0, 1);
//Debug.Log("VRCMenu: null=" + (null == VRCMenu) + " : control="+ (null==VRCMenu.controls));
int buttonCount = VRCMenu.controls.Count + 1;
int buttonIndex = 1;
foreach (VRCExpressionsMenu.Control control in VRCMenu.controls)
{
float theta = (2 * Mathf.PI / buttonCount) * buttonIndex++;
float xpos = Mathf.Sin(theta);
float ypos = Mathf.Cos(theta);
CreateButton(control, xpos, ypos);
}
}
public static void InitExpressionParameters(this VRCExpressionParameters parameters, bool populateWithDefault)
{
if (!populateWithDefault)
{
parameters.parameters = new VRCExpressionParameters.Parameter[0];
return;
}
parameters.parameters = new VRCExpressionParameters.Parameter[3];
parameters.parameters[0] = new VRCExpressionParameters.Parameter {
name = "VRCEmote", valueType = VRCExpressionParameters.ValueType.Int
};
parameters.parameters[1] = new VRCExpressionParameters.Parameter {
name = "VRCFaceBlendH", valueType = VRCExpressionParameters.ValueType.Float
};
parameters.parameters[2] = new VRCExpressionParameters.Parameter {
name = "VRCFaceBlendV", valueType = VRCExpressionParameters.ValueType.Float
};
}
private void findComponents()
{
var obj = new SerializedObject(avatarDescriptor);
var baseAnimationLayers = obj.FindProperty("baseAnimationLayers.Array");
var size = baseAnimationLayers.arraySize;
for (int i = 0; i < size; i++)
{
var layer = baseAnimationLayers.GetArrayElementAtIndex(i);
if ((AnimLayerType)(layer.FindPropertyRelative("type").enumValueIndex) != AnimLayerType.FX)
{
continue;
}
var controllerProp = layer.FindPropertyRelative("animatorController");
fxController = controllerProp.objectReferenceValue as AnimatorController;
}
expressionMenu = avatarDescriptor.expressionsMenu;
expressionParams = avatarDescriptor.expressionParameters;
}
private static void ParameterFixes(VRCExpressionParameters.Parameter param, VRCExpressionParameters expressionParameters, JustHaiToggleGroup @group)
{
if (param == null)
{
EditorGUILayout.HelpBox("Expression Parameter does not exist", MessageType.Error);
if (GUILayout.Button("Fix: Create Expression Parameter"))
{
var newParameters = new VRCExpressionParameters.Parameter[expressionParameters.parameters.Length + 1];
expressionParameters.parameters.CopyTo(newParameters, 0);
expressionParameters.parameters = newParameters;
expressionParameters.parameters[expressionParameters.parameters.Length - 1] = new VRCExpressionParameters.Parameter()
{
name = @group.parameterName,
defaultValue = @group.hintEnabled ? 1f : 0f,
saved = true,
valueType = VRCExpressionParameters.ValueType.Bool
};
ForceSaveAsset(expressionParameters);
}
}
else if (param.valueType != VRCExpressionParameters.ValueType.Bool)
{
EditorGUILayout.HelpBox($"Expression Parameter exists but it is not a Bool (currently: {param.valueType})", MessageType.Error);
if (GUILayout.Button("Fix: Change Expression Parameter Type to Bool"))
{
param.valueType = VRCExpressionParameters.ValueType.Bool;
param.defaultValue = @group.hintEnabled ? 1f : 0f;
ForceSaveAsset(expressionParameters);
}
}
else if (param.defaultValue != (@group.hintEnabled ? 1f : 0f))
{
EditorGUILayout.HelpBox($"Expression Parameter default value is not the same", MessageType.Warning);
if (GUILayout.Button("Fix: Change Expression Parameter Default Value"))
{
param.defaultValue = @group.hintEnabled ? 1f : 0f;
ForceSaveAsset(expressionParameters);
}
}
}
public static VRCExpressionParameters.Parameter AddVRCExpressionsParameter(VRCAvatarDescriptor avatarDescriptor, VRCExpressionParameters.ValueType type, string name, List <Object> dirtyAssets)
{
VRCExpressionParameters parameters = avatarDescriptor.expressionParameters;
VRCExpressionParameters.Parameter parameter = parameters.FindParameter(name);
if (parameter == null)
{
var list = parameters.parameters.Where(e => e != null && !string.IsNullOrEmpty(e.name)).ToList();
parameter = new VRCExpressionParameters.Parameter
{
name = name,
valueType = type,
};
list.Add(parameter);
parameters.parameters = list.ToArray();
}
dirtyAssets.Add(parameters);
dirtyAssets.Add(avatarDescriptor.gameObject);
return(parameter);
}
public static void MergeParameters(this VRCExpressionParameters source, params VRCExpressionParameters[] parameters)
{
foreach (var parameter in parameters.SelectMany(w => w.parameters))
{
if (string.IsNullOrWhiteSpace(parameter.name))
{
continue;
}
if (DefaultParameterNames.Contains(parameter.name))
{
continue;
}
if (source.HasParameter(parameter.name))
{
Debug.LogWarning($"Parameter {parameter.name} is already registered");
continue;
}
source.AddParametersToFirstEmptySpace(parameter.name, parameter.valueType);
}
}
private Emh.EmhQualification Functional(VRCExpressionParameters expressionParametersOptional, params string[] parameters)
{
if (parameters.All(s => s == ""))
{
return(Emh.EmhQualification.ElementIsAesthetic);
}
if (expressionParametersOptional == null)
{
return(Emh.EmhQualification.ElementIsFunctional);
}
var allExpParams = expressionParametersOptional.parameters
.Select(p => p.name)
.Distinct()
.Where(p => p != "")
.ToList();
var allAreValid = parameters
.Where(s => !string.IsNullOrEmpty(s))
.All(s => allExpParams.Contains(s));
if (allAreValid)
{
return(Emh.EmhQualification.ElementIsFunctional);
}
var allAreInvalid = parameters
.Where(s => !string.IsNullOrEmpty(s))
.All(s => !allExpParams.Contains(s));
if (allAreInvalid)
{
return(Emh.EmhQualification.ElementIsNonFunctional);
}
return(Emh.EmhQualification.ElementIsPartiallyFunctional);
}
public static bool Add(this VRCExpressionParameters parameters, VRCExpressionParameters.Parameter parameter)
{
var emptyFirstIndex = 0;
for (var i = 0; i < parameters.parameters.Length; i++)
{
if (!string.IsNullOrEmpty(parameters.parameters[i].name))
{
continue;
}
emptyFirstIndex = i;
break;
}
if (emptyFirstIndex == parameters.parameters.Length)
{
return(false);
}
parameters.parameters[emptyFirstIndex] = parameter;
return(true);
}
public static void AddParameter(this VRCExpressionParameters source, VRCExpressionParameters.Parameter parameter)
{
var so = new SerializedObject(source);
so.Update();
var sourceParameters = so.FindProperty(nameof(source.parameters));
sourceParameters.arraySize += 1;
var idx = sourceParameters.arraySize - 1;
sourceParameters.InsertArrayElementAtIndex(idx);
var obj = sourceParameters.GetArrayElementAtIndex(idx);
obj.FindPropertyRelative("name").stringValue = parameter.name;
obj.FindPropertyRelative("valueType").intValue = (int)parameter.valueType;
obj.FindPropertyRelative("defaultValue").floatValue = parameter.defaultValue;
obj.FindPropertyRelative("saved").boolValue = parameter.saved;
so.ApplyModifiedProperties();
}
public static void InitExpressionParameters(this VRCExpressionParameters obj)
{
// Simulate `VRCExpressionParametersEditor#InitExpressionParameters(bool)`
obj.parameters = new VRCExpressionParameters.Parameter[VRCExpressionParameters.MAX_PARAMETERS];
for (var i = 0; i < VRCExpressionParameters.MAX_PARAMETERS; i++)
{
obj.parameters[i] = new VRCExpressionParameters.Parameter
{
name = "",
valueType = VRCExpressionParameters.ValueType.Int
}
}
;
obj.parameters[0].name = DefaultParameterNames[0];
obj.parameters[0].valueType = VRCExpressionParameters.ValueType.Int;
obj.parameters[1].name = DefaultParameterNames[1];
obj.parameters[1].valueType = VRCExpressionParameters.ValueType.Float;
obj.parameters[2].name = DefaultParameterNames[2];
obj.parameters[2].valueType = VRCExpressionParameters.ValueType.Float;
}
static void RemoveBitKeys(MenuCommand command)
{
VRCExpressionParameters parameters = (VRCExpressionParameters)command.context;
RemoveBitKeys(parameters);
}
public int ApplyChanges()
{
try
{
EditorUtility.DisplayProgressBar("Avatar Scaling", "Starting", 0f);
/*
* // Check if necessary objects are found.
*/
if (avatar == null)
{
return(3);
}
else if (addExpressionParameters && avatar.expressionParameters == null)
{
return(7);
}
else if (curveType == 3 && customCurve == null)
{
return(9);
}
/*
* // Create any files needed in destination folder.
*/
EditorUtility.DisplayProgressBar("Avatar Scaling", "Checking Destination", 0.05f);
VerifyDestination();
//Copy SDK templates (if needed)
if (insertLayers)
{
EditorUtility.DisplayProgressBar("Avatar Scaling", "Looking for Existing Animators", 0.1f);
}
AnimatorController gesture = (avatar.baseAnimationLayers[2].animatorController != null && insertLayers) ? (AnimatorController)avatar.baseAnimationLayers[2].animatorController : null;
AnimatorController sitting = (avatar.specialAnimationLayers[0].animatorController != null && insertLayers) ? (AnimatorController)avatar.specialAnimationLayers[0].animatorController : null;
AnimatorController tpose = (avatar.specialAnimationLayers[1].animatorController != null && insertLayers) ? (AnimatorController)avatar.specialAnimationLayers[1].animatorController : null;
AnimationClip sizeSettings = new AnimationClip();
EditorUtility.DisplayProgressBar("Avatar Scaling", "Creating New Files", 0.2f);
if (gesture == null || gesture == templateAnimators[0] || gesture == templateAnimators[1] || gesture == templateAnimators[2])
{
switch (CopySDKTemplate(avatar.gameObject.name + "_Gesture.controller", "vrc_AvatarV3HandsLayer"))
{
case 1:
return(98);
case 3:
return(11);
default:
break;
}
}
else if (IsSDKController(gesture))
{
switch (CopySDKTemplate(avatar.gameObject.name + "_Gesture.controller", AssetDatabase.GetAssetPath(gesture).Substring(AssetDatabase.GetAssetPath(gesture).IndexOf("vrc_"), AssetDatabase.GetAssetPath(gesture).IndexOf(".controller"))))
{
case 1:
return(98);
case 3:
return(11);
default:
break;
}
}
EditorUtility.DisplayProgressBar("Avatar Scaling", "Creating New Files", 0.25f);
if (sitting == null || sitting == templateAnimators[0] || sitting == templateAnimators[1] || sitting == templateAnimators[2])
{
switch (CopySDKTemplate(avatar.gameObject.name + "_Sitting.controller", "vrc_AvatarV3SittingLayer"))
{
case 1:
return(98);
case 3:
return(11);
default:
break;
}
}
else if (IsSDKController(sitting))
{
switch (CopySDKTemplate(avatar.gameObject.name + "_Sitting.controller", AssetDatabase.GetAssetPath(sitting).Substring(AssetDatabase.GetAssetPath(sitting).IndexOf("vrc_"), AssetDatabase.GetAssetPath(sitting).IndexOf(".controller"))))
{
case 1:
return(98);
case 3:
return(11);
default:
break;
}
}
EditorUtility.DisplayProgressBar("Avatar Scaling", "Creating New Files", 0.3f);
if (tpose == null || tpose == templateAnimators[0] || tpose == templateAnimators[1] || tpose == templateAnimators[2])
{
switch (CopySDKTemplate(avatar.gameObject.name + "_TPose.controller", "vrc_AvatarV3UtilityTPose"))
{
case 1:
return(98);
case 3:
return(11);
default:
break;
}
}
else if (IsSDKController(tpose))
{
switch (CopySDKTemplate(avatar.gameObject.name + "_TPose.controller", AssetDatabase.GetAssetPath(tpose).Substring(AssetDatabase.GetAssetPath(tpose).IndexOf("vrc_"), AssetDatabase.GetAssetPath(tpose).IndexOf(".controller"))))
{
case 1:
return(98);
case 3:
return(11);
default:
break;
}
}
EditorUtility.DisplayProgressBar("Avatar Scaling", "Creating New Files", 0.35f);
switch (CopySizeTemplate())
{
case 1:
return(98);
case 3:
return(11);
default:
break;
}
EditorUtility.DisplayProgressBar("Avatar Scaling", "Refreshing Asset Database", 0.4f);
AssetDatabase.Refresh();
EditorUtility.DisplayProgressBar("Avatar Scaling", "Loading New Files", 0.45f);
string[] results = AssetDatabase.FindAssets(avatar.gameObject.name + "_", new string[] { outputPath });
foreach (string guid in results)
{
string path = AssetDatabase.GUIDToAssetPath(guid);
//Gesture Animator
if (path.Contains(avatar.gameObject.name + "_Gesture.controller") && gesture == null)
{
gesture = (AnimatorController)AssetDatabase.LoadAssetAtPath(path, typeof(AnimatorController));
}
//Sitting Animator
else if (path.Contains(avatar.gameObject.name + "_Sitting.controller") && sitting == null)
{
sitting = (AnimatorController)AssetDatabase.LoadAssetAtPath(path, typeof(AnimatorController));
}
//TPose Animator
else if (path.Contains(avatar.gameObject.name + "_TPose.controller") && tpose == null)
{
tpose = (AnimatorController)AssetDatabase.LoadAssetAtPath(path, typeof(AnimatorController));
}
//Size Settings Anim
else if (path.Contains(avatar.gameObject.name + "_Sizes.anim"))
{
sizeSettings = (AnimationClip)AssetDatabase.LoadAssetAtPath(path, typeof(AnimationClip));
}
}
/*
* // Append scaling layers to Animators.
*/
EditorUtility.DisplayProgressBar("Avatar Scaling", "Appending Layers", 0.5f);
if (!AddLayersParameters(gesture, templateAnimators[0]))
{
return(6);
}
EditorUtility.DisplayProgressBar("Avatar Scaling", "Appending Layers", 0.65f);
if (!AddLayersParameters(sitting, templateAnimators[1]))
{
return(6);
}
EditorUtility.DisplayProgressBar("Avatar Scaling", "Appending Layers", 0.8f);
if (!AddLayersParameters(tpose, templateAnimators[2]))
{
return(6);
}
/*
* // Modify copy of AnimationClip to use new sizes.
*/
EditorUtility.DisplayProgressBar("Avatar Scaling", "Configuring Animations", 0.825f);
if (!ModifyAnimation(sizeSettings))
{
return(10);
}
/*
* // Replace reference to template AnimationClip in Gesture with the modified one.
*/
EditorUtility.DisplayProgressBar("Avatar Scaling", "Configuring Animators", 0.85f);
if (!ReplaceAnimation(gesture, "Scaling", templateSizes, sizeSettings))
{
return(12);
}
/*
* // Add new Animators to the Avatar Descriptor if possible.
*/
EditorUtility.DisplayProgressBar("Avatar Scaling", "Updating Avatar Descriptor", 0.875f);
//Enable custom layers
if (avatar.customizeAnimationLayers == false)
{
avatar.customizeAnimationLayers = true;
}
EditorUtility.DisplayProgressBar("Avatar Scaling", "Updating Avatar Descriptor", 0.9f);
//Add Gesture
if (!avatar.baseAnimationLayers[2].isEnabled)
{
avatar.baseAnimationLayers[2].isEnabled = true;
avatar.baseAnimationLayers[2].isDefault = false;
avatar.baseAnimationLayers[2].animatorController = gesture;
}
else if (avatar.baseAnimationLayers[2].animatorController == null)
{
avatar.baseAnimationLayers[2].animatorController = gesture;
avatar.baseAnimationLayers[2].isDefault = false;
}
EditorUtility.DisplayProgressBar("Avatar Scaling", "Updating Avatar Descriptor", 0.92f);
//Add Sitting
if (!avatar.specialAnimationLayers[0].isEnabled)
{
avatar.specialAnimationLayers[0].isEnabled = true;
avatar.specialAnimationLayers[0].isDefault = false;
avatar.specialAnimationLayers[0].animatorController = sitting;
}
else if (avatar.specialAnimationLayers[0].animatorController == null)
{
avatar.specialAnimationLayers[0].animatorController = sitting;
avatar.specialAnimationLayers[0].isDefault = false;
}
EditorUtility.DisplayProgressBar("Avatar Scaling", "Updating Avatar Descriptor", 0.94f);
//Add TPose
if (!avatar.specialAnimationLayers[1].isEnabled)
{
avatar.specialAnimationLayers[1].isEnabled = true;
avatar.specialAnimationLayers[1].isDefault = false;
avatar.specialAnimationLayers[1].animatorController = tpose;
}
else if (avatar.specialAnimationLayers[1].animatorController == null)
{
avatar.specialAnimationLayers[1].animatorController = tpose;
avatar.specialAnimationLayers[1].isDefault = false;
}
/*
* // Check avatar's ExpressionParameters for needed parameters. Skip if present, attempt to append to list if absent. In cases where the list is full, inform the user and abort.
*/
EditorUtility.DisplayProgressBar("Avatar Scaling", "Finalizing", 0.96f);
if (addExpressionParameters)
{
VRCExpressionParameters avatarParameters = avatar.expressionParameters;
int count = 0;
bool scalePresent = false;
bool sizeOpPresent = false;
for (int i = 0; i < avatarParameters.parameters.Length; i++)
{
switch (avatarParameters.parameters[i].name)
{
case "Scale":
if (avatarParameters.parameters[i].valueType != VRCExpressionParameters.ValueType.Float)
{
return(4);
}
scalePresent = true;
break;
case "SizeOp":
if (avatarParameters.parameters[i].valueType != VRCExpressionParameters.ValueType.Int)
{
return(5);
}
sizeOpPresent = true;
break;
case "":
break;
default:
count++;
break;
}
}
if ((count >= 15 && !scalePresent && !sizeOpPresent) || (count == 16 && (!scalePresent || !sizeOpPresent)))
{
return(8);
}
else
{
if (!scalePresent)
{
for (int i = 0; i < avatarParameters.parameters.Length; i++)
{
if (avatarParameters.parameters[i].name == "")
{
avatarParameters.parameters[i].name = "Scale";
avatarParameters.parameters[i].valueType = VRCExpressionParameters.ValueType.Float;
break;
}
}
}
if (!sizeOpPresent)
{
for (int i = 0; i < avatarParameters.parameters.Length; i++)
{
if (avatarParameters.parameters[i].name == "")
{
avatarParameters.parameters[i].name = "SizeOp";
avatarParameters.parameters[i].valueType = VRCExpressionParameters.ValueType.Int;
break;
}
}
}
}
}
/*
* // Check if a Expressions Menu was provided and attempt to add Scale Controls as a submenu to it. If none was provided then assign the template to the descriptor if the slot is empty.
*/
EditorUtility.DisplayProgressBar("Avatar Scaling", "Finalizing", 0.98f);
if (expressionsMenu != null)
{
if (expressionsMenu.controls.Count == 8)
{
return(2);
}
else
{
bool exists = false;
foreach (VRCExpressionsMenu.Control control in expressionsMenu.controls)
{
if (control.type == VRCExpressionsMenu.Control.ControlType.SubMenu && control.subMenu == templateMenu.controls[0].subMenu)
{
exists = true;
break;
}
}
if (!exists)
{
expressionsMenu.controls.Add(templateMenu.controls[0]);
}
else
{
return(1);
}
}
}
else
{
if (avatar.expressionsMenu == null)
{
avatar.expressionsMenu = (VRCExpressionsMenu)AssetDatabase.LoadAssetAtPath(AssetDatabase.GUIDToAssetPath(AssetDatabase.FindAssets("Scale Controls", new string[] { relativePath + Path.DirectorySeparatorChar + "Menus" })[0]), typeof(VRCExpressionsMenu));
}
}
EditorUtility.DisplayProgressBar("Avatar Scaling", "Finalizing", 1.0f);
return(0);
}
catch (Exception err)
{
Debug.LogException(err);
return(99);
}
}
public static bool HasParameter(this VRCExpressionParameters obj, string name)
{
return(obj.FindParameter(name) != null);
}
public static VRCExpressionParameters.Parameter GetLastEmptyParameter(this VRCExpressionParameters obj)
{
return(obj.parameters.LastOrDefault(w => string.IsNullOrWhiteSpace(w.name)));
}
