private void FillNodeInfos(AvatarMask mask)
{
this.m_NodeInfos = new AvatarMaskInspector.NodeInfo[mask.transformCount];
for (int i = 1; i < this.m_NodeInfos.Length; i++)
{
string fullPath = mask.GetTransformPath(i);
if (this.humanTransforms != null)
{
this.m_NodeInfos[i].m_Enabled = (ArrayUtility.FindIndex <string>(this.humanTransforms, (string s) => fullPath == s) == -1);
}
else
{
this.m_NodeInfos[i].m_Enabled = true;
}
this.m_NodeInfos[i].m_Expanded = true;
this.m_NodeInfos[i].m_ParentIndex = -1;
this.m_NodeInfos[i].m_ChildIndices = new List <int>();
AvatarMaskInspector.NodeInfo[] arg_F6_0_cp_0 = this.m_NodeInfos;
int arg_F6_0_cp_1 = i;
int arg_F6_1;
if (i == 0)
{
arg_F6_1 = 0;
}
else
{
arg_F6_1 = fullPath.Count((char f) => f == '/');
}
arg_F6_0_cp_0[arg_F6_0_cp_1].m_Depth = arg_F6_1;
string text = string.Empty;
int num = fullPath.LastIndexOf('/');
if (num > 0)
{
text = fullPath.Substring(0, num);
}
int transformCount = mask.transformCount;
for (int j = 0; j < transformCount; j++)
{
string transformPath = mask.GetTransformPath(j);
if (text != string.Empty && transformPath == text)
{
this.m_NodeInfos[i].m_ParentIndex = j;
}
if (transformPath.StartsWith(fullPath))
{
if (transformPath.Count((char f) => f == '/') == this.m_NodeInfos[i].m_Depth + 1)
{
this.m_NodeInfos[i].m_ChildIndices.Add(j);
}
}
}
}
}
// PUBLIC METHODS: ------------------------------------------------------------------------
public void PlayGesture(AnimationClip clip, AvatarMask avatarMask,
float transition = GestureAnimation.TRANSITION)
{
if (avatarMask == null)
{
this.gesture.PlayGesture(clip, transition);
}
else
{
this.gestureMask.PlayGesture(clip, avatarMask, transition);
}
}
public void SetState(RuntimeAnimatorController rtc, AvatarMask avatarMask,
float weight, float transition, float speed, int layer, bool syncTime,
params PlayableGesture.Parameter[] parameters)
{
PlayableState prevPlayable;
PlayableState nextPlayable;
int insertIndex = this.GetSurroundingStates(layer,
out prevPlayable,
out nextPlayable
);
if (prevPlayable == null && nextPlayable == null)
{
this.states.Add(PlayableStateRTC.Create(
rtc, avatarMask, layer,
syncTime ? this.runtimeControllerPlayable.GetTime() : 0f,
transition, speed, weight,
ref this.graph,
ref this.mixerStatesInput,
ref this.mixerStatesOutput,
parameters
));
}
else if (prevPlayable != null)
{
if (prevPlayable.Layer == layer)
{
prevPlayable.StretchDuration(transition);
}
this.states.Insert(insertIndex, PlayableStateRTC.CreateAfter(
rtc, avatarMask, layer,
syncTime ? this.runtimeControllerPlayable.GetTime() : 0f,
transition, speed, weight,
ref this.graph,
prevPlayable,
parameters
));
}
else if (nextPlayable != null)
{
this.states.Insert(insertIndex, PlayableStateRTC.CreateBefore(
rtc, avatarMask, layer,
syncTime ? this.runtimeControllerPlayable.GetTime() : 0f,
transition, speed, weight,
ref this.graph,
nextPlayable,
parameters
));
}
}
static public void UpdateTransformMask(AvatarMask mask, string[] refTransformsPath, string[] humanTransforms)
{
mask.transformCount = refTransformsPath.Length;
for (int i = 0; i < refTransformsPath.Length; i++)
{
mask.SetTransformPath(i, refTransformsPath[i]);
bool isActiveTransform = humanTransforms == null
? true
: ArrayUtility.FindIndex(humanTransforms, s => refTransformsPath[i] == s) != -1;
mask.SetTransformActive(i, isActiveTransform);
}
}
private void InitMask(AnimationClipInfoProperties clipInfo)
{
if (m_Mask == null)
{
AnimationClip clip = m_AnimationClipEditor.target as AnimationClip;
m_Mask = new AvatarMask();
m_MaskInspector = (AvatarMaskInspector)Editor.CreateEditor(m_Mask, typeof(AvatarMaskInspector));
m_MaskInspector.canImport = false;
m_MaskInspector.showBody = clip.isHumanMotion;
m_MaskInspector.clipInfo = clipInfo;
}
}
//============================================================================================
/**
* @brief
*
*********************************************************************************************/
public void SetLayerClip(int a_layerId, AnimationClip a_clip, AvatarMask a_mask, float a_time = 0f, float a_weight = 1f)
{
if (a_layerId > 1)
{
MxMLayer layer = null;
if (m_layers.TryGetValue(a_layerId, out layer))
{
layer.SetLayerClip(a_clip, a_time);
layer.Mask = a_mask;
layer.Weight = a_weight;
}
}
}
public void ConfigureMaskFromClip(ref AvatarMask mask)
{
mask.transformCount = this.m_TransformMask.Length;
for (int i = 0; i < mask.transformCount; i++)
{
mask.SetTransformPath(i, this.m_TransformMask[i].path);
mask.SetTransformActive(i, this.m_TransformMask[i].weight > 0f);
}
for (int i = 0; i < this.m_BodyMask.Length; i++)
{
mask.SetHumanoidBodyPartActive((AvatarMaskBodyPart)i, m_BodyMask[i] != 0);
}
}
private void CreateAvatarMaskAssetIfNecessary(ComboGestureCompiler compiler)
{
if (compiler.generatedAvatarMask != null)
{
return;
}
var folderToCreateAssetIn = ResolveFolderToCreateNeutralizedAssetsIn(compiler.folderToGenerateNeutralizedAssetsIn, compiler.animatorController);
var mask = new AvatarMask();
AssetDatabase.CreateAsset(mask, folderToCreateAssetIn + "/GeneratedCGEMask__" + DateTime.Now.ToString("yyyy'-'MM'-'dd'_'HHmmss") + ".asset");
compiler.generatedAvatarMask = mask;
}
/* public void UpdateHandPositions()
* {
* setEdit();
* editHandCoord();
* printHandCoord();
* //logAnimations();
*
* MainCameraControl.main.viewModel.localScale = scale;
*
* XRInputManager xrInput = XRInputManager.GetXRInputManager();
* Vector3 leftHandPos = xrInput.Get(Controller.Left, CommonUsages.devicePosition);
* Quaternion leftHandRot = xrInput.Get(Controller.Left, CommonUsages.deviceRotation);
* Vector3 rightHandPos = xrInput.Get(Controller.Right, CommonUsages.devicePosition);
* Quaternion rightHandRot = xrInput.Get(Controller.Right, CommonUsages.deviceRotation);
*
* Transform rightHand = xrInput.GetGameTransform(Controller.Right);
* rightHand.localPosition += new Vector3(rightPosX, rightPosY, rightPosZ);
* rightHand.localRotation *= Quaternion.Euler(rightRotX, rightRotY, rightRotZ);
* ik.solver.rightHandEffector.target = rightHand;
* ik.solver.rightHandEffector.positionWeight = 1f;
*
* Transform leftHand = xrInput.GetGameTransform(Controller.Left);
* leftHand.localPosition += new Vector3(leftPosX, leftPosY, leftPosZ);
* leftHand.localRotation *= Quaternion.Euler(leftRotX, leftRotY, leftRotZ);
* ik.references.leftHand.localRotation = leftHand.localRotation;
* ik.references.leftHand.localPosition = leftHand.localPosition;
*//* ik.solver.leftHandEffector.target = leftHand;
* ik.solver.leftHandEffector.positionWeight = 1f;*//*
*
* }*/
public void disableArmAnimations()
{
Animator anim = player.playerAnimator;
Transform leftLowerArm = ik.references.leftForearm;
AvatarMask mask = new AvatarMask();
mask.AddTransformPath(leftLowerArm);
PlayableGraph graph = player.playerAnimator.playableGraph;
AnimationPlayableOutput playableOutput = AnimationPlayableOutput.Create(graph, "LayerMixer", anim);
AnimationMixerPlayable mixer = AnimationMixerPlayable.Create(graph, 2);
playableOutput.SetSourcePlayable(mixer);
}
// PRIVATE METHODS: ---------------------------------------------------------------------------
private void SetState(Playable input, AvatarMask mask, float weight, float time)
{
this.graph.Disconnect(this.mixer, 1);
this.graph.Connect(input, 0, this.mixer, 1);
float weight1 = this.mixer.GetInputWeight(0);
this.mixer.SetInputWeight(1, 1.0f - weight1);
this.mixer.SetLayerMaskFromAvatarMask(1, mask);
this.targetWeight = 1.0f - weight;
this.smoothTime = time;
}
private static void CreateAvatarMask()
{
GameObject activeGameObject = Selection.activeGameObject;
if (activeGameObject != null)
{
AvatarMask avatarMask = new AvatarMask();
avatarMask.AddTransformPath(activeGameObject.transform);
var path = string.Format("Assets/{0}.mask", activeGameObject.name.Replace(':', '_'));
AssetDatabase.CreateAsset(avatarMask, path);
}
}
public static void builAvatarMask(GameObject gameObject, SpineData spineData, Animator animator, string directory, string name){
Avatar avatar = AvatarBuilder.BuildGenericAvatar(gameObject,"");
animator.avatar = avatar;
AvatarMask avatarMask = new AvatarMask();
string[] transofrmPaths = getTransformPaths(gameObject, spineData);
avatarMask.transformCount = transofrmPaths.Length;
for (int i=0; i< transofrmPaths.Length; i++){
avatarMask.SetTransformPath(i, transofrmPaths[i]);
avatarMask.SetTransformActive(i, true);
}
createFolderIfNoExists(directory, ANIMATION_FOLDER);
AssetDatabase.CreateAsset(avatar , directory + "/" + ANIMATION_FOLDER + "/" + name + ".anim.asset");
AssetDatabase.CreateAsset(avatarMask, directory + "/" + ANIMATION_FOLDER + "/" + name + ".mask.asset");
}
//============================================================================================
/**
* @brief Begins an event that is masked by a passed avatar mask (e.g. upper body event).
*
* Note that masked events cannot use animation warping and other dynamic features that normal
* events use.
*
* @param [MxMEventDefinition] a_eventDefinition - the event definition to use
* @param [AvatarMask] a_eventMask - the mask to use for the event
*
*********************************************************************************************/
public void BeginEvent(MxMEventDefinition a_eventDefinition, AvatarMask a_eventMask, float a_blendRate,
float a_playbackRate = 1f)
{
if (a_eventDefinition == null)
{
Debug.LogError("Trying to play a layered event but the passed event definision is null.");
return;
}
MxMAnimData currentAnimData = m_mxmAnimator.CurrentAnimData;
float bestCost = float.MaxValue;
int bestWindupPoseId = 0;
ref EventData bestEvent = ref currentAnimData.Events[0];
public void ConfigureClipFromMask(AvatarMask mask)
{
this.m_TransformMask = new TransformMaskElement[mask.transformCount];
for (int i = 0; i < mask.transformCount; i++)
{
this.m_TransformMask[i].path = mask.GetTransformPath(i);
this.m_TransformMask[i].weight = ((!mask.GetTransformActive(i)) ? 0f : 1f);
}
this.m_BodyMask = new int[13];
for (int j = 0; j < 13; j++)
{
this.m_BodyMask[j] = ((!mask.GetHumanoidBodyPartActive((AvatarMaskBodyPart)j)) ? 0 : 1);
}
}
public void CreateDefaultMaskForClip(ModelImporterClipAnimation clip)
{
if (this.defaultClipAnimations.Length > 0)
{
AvatarMask avatarMask = new AvatarMask();
this.defaultClipAnimations[0].ConfigureMaskFromClip(ref avatarMask);
clip.ConfigureClipFromMask(avatarMask);
UnityEngine.Object.DestroyImmediate(avatarMask);
}
else
{
Debug.LogError("Cannot create default mask because the current importer doesn't have any animation information");
}
}
public void SetLayerMaskFromAvatarMask(uint layerIndex, AvatarMask mask)
{
if (layerIndex >= m_Handle.GetInputCount())
{
throw new ArgumentOutOfRangeException("layerIndex", String.Format("layerIndex {0} must be in the range of 0 to {1}.", layerIndex, m_Handle.GetInputCount() - 1));
}
if (mask == null)
{
throw new System.ArgumentNullException("mask");
}
SetLayerMaskFromAvatarMaskInternal(ref m_Handle, layerIndex, mask);
}
private void InitMask(AnimationClipInfoProperties clipInfo)
{
if (!((UnityEngine.Object) this.m_Mask == (UnityEngine.Object)null))
{
return;
}
AnimationClip target = this.m_AnimationClipEditor.target as AnimationClip;
this.m_Mask = new AvatarMask();
this.m_MaskInspector = (AvatarMaskInspector)Editor.CreateEditor((UnityEngine.Object) this.m_Mask);
this.m_MaskInspector.canImport = false;
this.m_MaskInspector.showBody = target.isHumanMotion;
this.m_MaskInspector.clipInfo = clipInfo;
}
protected void CopyFromOtherGUI()
{
if (this.clipInfo != null)
{
EditorGUILayout.BeginHorizontal(new GUILayoutOption[0]);
EditorGUI.BeginChangeCheck();
EditorGUILayout.PropertyField(this.clipInfo.maskSourceProperty, GUIContent.Temp("Source"), new GUILayoutOption[0]);
AvatarMask x = this.clipInfo.maskSourceProperty.objectReferenceValue as AvatarMask;
if (EditorGUI.EndChangeCheck() && x != null)
{
this.UpdateMask(this.clipInfo.maskType);
}
EditorGUILayout.EndHorizontal();
}
}
//============================================================================================
/**
* @brief Sets the animation mask to use for the animator controller layer if you are using
* one. This enables control of masked layer animations directly through the Animator Controller
*
* @param [AvatarMask] a_mask - the avatar mask to use
*
*********************************************************************************************/
public void SetControllerMask(AvatarMask a_mask)
{
if (a_mask == null)
{
Debug.LogWarning("Cannot set animator controller mask on MxMAnimator with a null mask");
return;
}
MxMLayer layer = null;
if (m_layers.TryGetValue(1, out layer))
{
layer.Mask = a_mask;
}
}
/// <summary>
/// 根据模型节点导入遮罩CreateFromThisModel,有些额外节点比如披风是默认没有导入的
/// </summary>
private void CreateMaskFromModel(ModelImporter modelImporter, GameObject model)
{
var clips = modelImporter.clipAnimations;
var avatarMask = new AvatarMask();
avatarMask.AddTransformPath(model.transform, true);
foreach (var clip in clips)
{
clip.maskType = ClipAnimationMaskType.CreateFromThisModel;
clip.ConfigureClipFromMask(avatarMask);
}
modelImporter.clipAnimations = clips;
}
public static void SetActiveHumanTransforms(AvatarMask mask, string[] humanTransforms)
{
for (int index = 0; index < mask.transformCount; ++index)
{
// ISSUE: object of a compiler-generated type is created
// ISSUE: reference to a compiler-generated method
if (ArrayUtility.FindIndex <string>(humanTransforms, new Predicate <string>(new AvatarMaskUtility.\u003CSetActiveHumanTransforms\u003Ec__AnonStorey8B()
{
path = mask.GetTransformPath(index)
}.\u003C\u003Em__14B)) != -1)
{
mask.SetTransformActive(index, true);
}
}
}
/************************************************************************************************************************/
/// <summary>[Pro-Only]
/// Sets an <see cref="AvatarMask"/> to determine which bones the layer at the specified index will affect.
/// </summary>
public void SetMask(int index, AvatarMask mask)
{
SetMinCount(index + 1);
#if UNITY_EDITOR
_Layers[index]._Mask = mask;
#endif
if (mask == null)
{
mask = new AvatarMask();
}
LayerMixer.SetLayerMaskFromAvatarMask((uint)index, mask);
}
//============================================================================================
/**
* @brief
*
*********************************************************************************************/
public void SetLayerMask(int a_layerId, AvatarMask a_mask)
{
if (a_layerId > 1)
{
MxMLayer layer = null;
if (m_animationLayerMixer.IsValid() && m_layers.TryGetValue(a_layerId, out layer))
{
m_layers[a_layerId].Mask = a_mask;
}
else
{
Debug.LogError("Trying to set a layer mask before the playable graph is created. Aborting Operation");
}
}
}
public void ConfigureClipFromMask(AvatarMask mask)
{
this.m_TransformMask = new TransformMaskElement[mask.transformCount];
for (int i = 0; i < mask.transformCount; i++)
{
m_TransformMask[i].path = mask.GetTransformPath(i);
m_TransformMask[i].weight = mask.GetTransformActive(i) ? 1f : 0f;
}
m_BodyMask = new int[(int)AvatarMaskBodyPart.LastBodyPart];
for (int i = 0; i < (int)AvatarMaskBodyPart.LastBodyPart; i++)
{
m_BodyMask[i] = mask.GetHumanoidBodyPartActive((AvatarMaskBodyPart)i) ? 1 : 0;
}
}
void CopyFromOtherGUI()
{
EditorGUILayout.BeginHorizontal();
EditorGUI.BeginChangeCheck();
EditorGUILayout.PropertyField(clipInfo.maskSourceProperty, Styles.CopyFromOtherSource);
AvatarMask maskSource = clipInfo.maskSourceProperty.objectReferenceValue as AvatarMask;
if (EditorGUI.EndChangeCheck() && maskSource != null)
{
UpdateMask(clipInfo.maskType);
}
EditorGUILayout.EndHorizontal();
}
public void SetState(CharacterState stateAsset, AvatarMask avatarMask,
float weight, float transition, float speed, int layer)
{
PlayableState prevPlayable;
PlayableState nextPlayable;
int insertIndex = this.GetSurroundingStates(layer,
out prevPlayable,
out nextPlayable
);
if (prevPlayable == null && nextPlayable == null)
{
this.states.Add(PlayableStateCharacter.Create(
stateAsset, avatarMask, this, layer,
this.runtimeControllerPlayable.GetTime(),
transition, speed, weight,
ref this.graph,
ref this.mixerStatesInput,
ref this.mixerStatesOutput
));
}
else if (prevPlayable != null)
{
if (prevPlayable.Layer == layer)
{
prevPlayable.StretchDuration(transition);
}
this.states.Insert(insertIndex, PlayableStateCharacter.CreateAfter(
stateAsset, avatarMask, this, layer,
this.runtimeControllerPlayable.GetTime(),
transition, speed, weight,
ref this.graph,
prevPlayable
));
}
else if (nextPlayable != null)
{
this.states.Insert(insertIndex, PlayableStateCharacter.CreateBefore(
stateAsset, avatarMask, this, layer,
this.runtimeControllerPlayable.GetTime(),
transition, speed, weight,
ref this.graph,
nextPlayable
));
}
}
public ComboGestureCompilerInternal(
ComboGestureCompiler compiler,
AssetContainer assetContainer)
{
_comboLayers = compiler.comboLayers;
_parameterGeneration = _comboLayers.Count <= 1 ? ParameterGeneration.Unique : (compiler.parameterMode == ParameterMode.SingleInt ? ParameterGeneration.UserDefinedActivity : ParameterGeneration.VirtualActivity);
switch (_parameterGeneration)
{
case ParameterGeneration.Unique:
_activityStageName = null;
break;
case ParameterGeneration.UserDefinedActivity:
_activityStageName = compiler.activityStageName;
break;
case ParameterGeneration.VirtualActivity:
_activityStageName = SharedLayerUtils.HaiVirtualActivity;
break;
default:
throw new ArgumentOutOfRangeException();
}
_animatorController = (AnimatorController)compiler.animatorController;
_gesturePlayableLayerController = compiler.gesturePlayableLayerController as AnimatorController;
_customEmptyClip = compiler.customEmptyClip;
_analogBlinkingUpperThreshold = compiler.analogBlinkingUpperThreshold;
_featuresToggles = (compiler.doNotGenerateBlinkingOverrideLayer ? FeatureToggles.DoNotGenerateBlinkingOverrideLayer : 0)
| (compiler.doNotGenerateLipsyncOverrideLayer ? FeatureToggles.DoNotGenerateLipsyncOverrideLayer : 0)
| (compiler.doNotGenerateWeightCorrectionLayer ? FeatureToggles.DoNotGenerateWeightCorrectionLayer : 0)
| (compiler.doNotFixSingleKeyframes ? FeatureToggles.DoNotFixSingleKeyframes : 0);
_conflictPrevention = ConflictPrevention.OfFxLayer(compiler.writeDefaultsRecommendationMode);
_conflictPreventionTempGestureLayer = ConflictPrevention.OfGestureLayer(compiler.writeDefaultsRecommendationModeGesture, compiler.gestureLayerTransformCapture);
_compilerConflictFxLayerMode = compiler.conflictFxLayerMode;
_compilerIgnoreParamList = compiler.ignoreParamList;
_compilerFallbackParamList = compiler.fallbackParamList;
_avatarDescriptor = compiler.avatarDescriptor;
_expressionsAvatarMask = compiler.expressionsAvatarMask ? compiler.expressionsAvatarMask : AssetDatabase.LoadAssetAtPath <AvatarMask>(SharedLayerUtils.FxPlayableLayerAvatarMaskPath);
_logicalAvatarMask = compiler.logicalAvatarMask ? compiler.logicalAvatarMask : AssetDatabase.LoadAssetAtPath <AvatarMask>(SharedLayerUtils.FxPlayableLayerAvatarMaskPath);
_weightCorrectionAvatarMask = compiler.weightCorrectionAvatarMask ? compiler.weightCorrectionAvatarMask : AssetDatabase.LoadAssetAtPath <AvatarMask>(SharedLayerUtils.FxPlayableLayerAvatarMaskPath);
_gesturePlayableLayerExpressionsAvatarMask = compiler.gesturePlayableLayerExpressionsAvatarMask ? compiler.gesturePlayableLayerExpressionsAvatarMask : AssetDatabase.LoadAssetAtPath <AvatarMask>(GesturePlayableLayerAvatarMaskPath);
_gesturePlayableLayerTechnicalAvatarMask = compiler.gesturePlayableLayerTechnicalAvatarMask ? compiler.gesturePlayableLayerTechnicalAvatarMask : AssetDatabase.LoadAssetAtPath <AvatarMask>(GesturePlayableLayerAvatarMaskPath);
_integrateLimitedLipsync = false; // For now, Limited Lipsync is disabled regardless of the compiler value
_limitedLipsync = compiler.lipsyncForWideOpenMouth;
_assetContainer = assetContainer;
_useGestureWeightCorrection = compiler.WillUseGestureWeightCorrection();
_useSmoothing = _useGestureWeightCorrection;
}
public void SetState(AnimationClip clip, AvatarMask avatarMask,
float weight, float time, float speed, Layer layer)
{
if (avatarMask == null)
{
this.states[(int)layer].activeState = StateType.Norm;
this.states[(int)layer].statesNorm.SetState(clip, weight, time, speed);
this.states[(int)layer].statesMask.ResetState(time);
}
else
{
this.states[(int)layer].activeState = StateType.Mask;
this.states[(int)layer].statesNorm.ResetState(time);
this.states[(int)layer].statesMask.SetState(clip, avatarMask, weight, time, speed);
}
}
public void SetState(RuntimeAnimatorController rtc, AvatarMask avatarMask,
float weight, float time, float speed, Layer layer)
{
if (avatarMask == null)
{
this.states[(int)layer].activeState = StateType.Norm;
this.states[(int)layer].statesNorm.SetState(rtc, weight, time, speed);
this.states[(int)layer].statesMask.ResetState(time);
}
else
{
this.states[(int)layer].activeState = StateType.Mask;
this.states[(int)layer].statesNorm.ResetState(time);
this.states[(int)layer].statesMask.SetState(rtc, avatarMask, weight, time, speed);
}
}
public AnimationLayer(string name, SharedAnimationData sharedData, AnimationClip defaultPose, bool isAdditive,
float layerWeight, AvatarMask layerMask)
{
Name = name;
this.sharedData = sharedData;
this.defaultPose = defaultPose;
this.isAdditive = isAdditive;
this.layerWeight = layerWeight;
this.layerMask = layerMask;
// Debug.Log($"Init animation layer, {Name}");
// mixerPlayable = AnimationMixerPlayable.Create(sharedData.PlayableGraph, 2);
defaultPlayable = AnimationClipPlayable.Create(this.sharedData.PlayableGraph, defaultPose);
mixerRunner = new MixerRunner();
}
public static AvatarMask CreateMaskWith(string name, IEnumerable <AvatarMaskBodyPart> parts)
{
var mask = new AvatarMask {
name = name
};
foreach (var part in BodyParts)
{
mask.SetHumanoidBodyPartActive(part, false);
}
foreach (var part in parts)
{
mask.SetHumanoidBodyPartActive(part, true);
}
return(mask);
}
