public static System.String SaveInstance(UMADnaBase instance)
{
System.Type dnaType = instance.GetType();
if( dnaType == typeof(UMADnaHumanoid))
return UMADnaHumanoid.SaveInstance(instance as UMADnaHumanoid);
return null;
}
public float GetUmaDNAValue(string DNATypeName, UMADnaBase umaDnaIn)
{
if (umaDnaIn == null)
{
return(0.5f);
}
DynamicUMADnaBase umaDna = (DynamicUMADnaBase)umaDnaIn;
float val = 0.5f;
if (DNATypeName == "None" || umaDna == null)
{
return(val);
}
val = umaDna.GetValue(DNATypeName, true); //implimented a 'failSilently' option here because recipes may have dna in that the dna asset no longer has
return(val);
}
public void Initialize(string name, int index, UMADnaBase owner, DynamicCharacterAvatar avatar, float currentval)
{
_DNAName = name;
_Index = index;
_Owner = owner;
_Avatar = avatar;
_InitialValue = currentval;
DNARangeAsset[] dnaRangeAssets = avatar.activeRace.data.dnaRanges;
foreach (DNARangeAsset d in dnaRangeAssets)
{
if (d.ContainsDNARange(_Index, _DNAName))
{
_dnr = d;
return;
}
}
}
/// <summary>
/// Applies any dna converters (plugins) in this assets converter controller that are set to apply in the dna 'Pre Pass'
/// </summary>
/// <param name="umaData"></param>
/// <param name="skeleton"></param>
/// <param name="dnaTypeHash"></param>
public void PreApplyDynamicDnaAction(UMAData umaData, UMASkeleton skeleton)
{
if (!_prepared)
{
Prepare();
}
UMADnaBase umaDna = umaData.GetDna(DNATypeHash);
//Make the DNAAssets match if they dont already, can happen when some parts are in bundles and others arent
if (((DynamicUMADnaBase)umaDna).dnaAsset != dnaAsset)
{
((DynamicUMADnaBase)umaDna).dnaAsset = dnaAsset;
}
if (_converterController != null)
{
_converterController.ApplyDNAPrepass(umaData, skeleton /*, DNATypeHash*/);
}
}
public static System.String SaveInstance(UMADnaBase instance)
{
System.Type dnaType = instance.GetType();
if (dnaType == typeof(UMADnaHumanoid))
{
return(UMADnaHumanoid.SaveInstance(instance as UMADnaHumanoid));
}
if (dnaType == typeof(UMADnaTutorial))
{
return(UMADnaTutorial.SaveInstance(instance as UMADnaTutorial));
}
if (dnaType == typeof(DynamicUMADna))
{
return(DynamicUMADna.SaveInstance(instance as DynamicUMADna));
}
return(null);
}
public void OnEnable()
{
dnaRange = target as DNARangeAsset;
if (dnaRange.dnaConverter != null)
{
dnaSource = dnaRange.dnaConverter.DNAType.GetConstructor(System.Type.EmptyTypes).Invoke(null) as UMADnaBase;
if (dnaSource != null)
{
if (dnaRange.dnaConverter.DNAType == typeof(DynamicUMADna))
{
entryCount = ((DynamicDNAConverterBehaviourBase)dnaRange.dnaConverter).dnaAsset.Names.Length;
}
else
{
entryCount = dnaSource.Count;
}
}
}
}
public void BakeEarMorph()
{
if (dna == null)
{
dna = data.GetDna(dnaTypeHash);
}
if (dna != null)
{
data.blendShapeSettings.bakeBlendShapes = new Dictionary <string, float>();
float dnaValue = dna.GetValue(dnaEntryIndex);
float morphWeight = 0.0f;
if (dnaValue > 0.51f)
{
morphWeight = (dnaValue - 0.5f) * 2f;
}
data.blendShapeSettings.bakeBlendShapes.Add("MaleElvenEars", morphWeight);
data.Dirty(true, true, true);
}
}
//UMA 2.8 FixDNAPrefabs:multiUse function for getting this
private void GetEntryCount()
{
if (dnaRange.dnaConverter != null)
{
if (dnaRange.dnaConverter.DNAType == typeof(DynamicUMADna))
{
entryCount = ((IDynamicDNAConverter)dnaRange.dnaConverter).dnaAsset.Names.Length;
}
else
{
dnaSource = dnaRange.dnaConverter.DNAType.GetConstructor(System.Type.EmptyTypes).Invoke(null) as UMADnaBase;
if (dnaSource != null)
{
entryCount = dnaSource.Count;
}
}
}
else
{
entryCount = 0;
}
}
public void ApplyDynamicDnaAction(UMAData umaData, UMASkeleton skeleton, bool asReset)
{
//System.Diagnostics.Stopwatch st = new System.Diagnostics.Stopwatch();
//st.Start();
UMADnaBase umaDna = null;
//reset the live scale on the overallModifiers ready for any adjustments any plugins might make
liveScale = -1;
if (!asReset)
{
umaDna = umaData.GetDna(DNATypeHash);
//Make the DNAAssets match if they dont already, can happen when some parts are in bundles and others arent
if (((DynamicUMADnaBase)umaDna).dnaAsset != dnaAsset)
{
((DynamicUMADnaBase)umaDna).dnaAsset = dnaAsset;
}
}
//hmm how do we deal with 'asReset' without forcing plugins to deal with it
//I guess the converter could cherry pick the skeletonModifiers out of it and just apply those
//although its only going to be skeletonModifiers with a hardcoded 'value' override that will do anything when dna is null
if (_converterController != null)
{
_converterController.ApplyDNA(umaData, skeleton /*, DNATypeHash*/);
}
else
{
ApplySkeletonModifiers(umaData, umaDna, skeleton);
if (!asReset)
{
ApplyStartingPose(skeleton);
}
_overallModifiers.UpdateCharacter(umaData, skeleton, asReset);
ApplyDnaCallbackDelegates(umaData);
}
//st.Stop();
//Debug.Log(this.gameObject.name + " ApplyDNA took " + st.Elapsed);
}
public void OnCharacterCreated(UMAData umaData)
{
this.data = umaData;
Slider slider = gameObject.GetComponent <Slider>();
dna = umaData.GetDna(dnaTypeHash);
if (dna != null)
{
string[] dnaNames = dna.Names;
for (int i = 0; i < dnaNames.Length; i++)
{
if (dnaName == dnaNames[i])
{
dnaEntryIndex = i;
break;
}
}
if (dnaEntryIndex >= 0)
{
slider.value = dna.GetValue(dnaEntryIndex);
}
}
}
public void BakeMorph(bool isBaked)
{
if (dna == null)
{
dna = data.GetDna(dnaTypeHash);
}
if (dna != null && dnaEntryIndex >= 0)
{
data.SetBlendShapeData(dnaName, isBaked, true);
if (statusText != null)
{
if (isBaked)
{
statusText.text = "(Baked)";
}
else
{
statusText.text = "(Unbaked)";
}
}
}
}
//Dont use LegacyDNA here
public static void RandomizeShape(UMAData umaData)
{
var allDNA = umaData.umaRecipe.GetAllDna();
UMADnaBase mainDNA = null;
//find the main dna to use
foreach (UMADnaBase dna in allDNA)
{
if (System.Array.IndexOf(dna.Names, "height") > -1)
{
mainDNA = dna;
break;
}
}
if (mainDNA != null && mainDNA.GetType() == typeof(DynamicUMADna))
{
DynamicUMADna umaDna = mainDNA as DynamicUMADna;
umaDna.SetValue("height", Random.Range(0.4f, 0.5f));
umaDna.SetValue("headSize", Random.Range(0.485f, 0.515f));
umaDna.SetValue("headWidth", Random.Range(0.4f, 0.6f));
umaDna.SetValue("neckThickness", Random.Range(0.495f, 0.51f));
if (umaData.umaRecipe.raceData.raceName.IndexOf("HumanMale") > -1)
{
umaDna.SetValue("handsSize", Random.Range(0.485f, 0.515f));
umaDna.SetValue("feetSize", Random.Range(0.485f, 0.515f));
umaDna.SetValue("legSeparation", Random.Range(0.4f, 0.6f));
umaDna.SetValue("waist", 0.5f);
}
else
{
umaDna.SetValue("handsSize", Random.Range(0.485f, 0.515f));
umaDna.SetValue("feetSize", Random.Range(0.485f, 0.515f));
umaDna.SetValue("legSeparation", Random.Range(0.485f, 0.515f));
umaDna.SetValue("waist", Random.Range(0.3f, 0.8f));
}
umaDna.SetValue("armLength", Random.Range(0.485f, 0.515f));
umaDna.SetValue("forearmLength", Random.Range(0.485f, 0.515f));
umaDna.SetValue("armWidth", Random.Range(0.3f, 0.8f));
umaDna.SetValue("forearmWidth", Random.Range(0.3f, 0.8f));
umaDna.SetValue("upperMuscle", Random.Range(0.0f, 1.0f));
umaDna.SetValue("upperWeight", Random.Range(-0.2f, 0.2f) + umaDna.GetValue("upperMuscle"));
if (umaDna.GetValue("upperWeight") > 1.0)
{
umaDna.SetValue("upperWeight", 1.0f);
}
if (umaDna.GetValue("upperWeight") < 0.0)
{
umaDna.SetValue("upperWeight", 0.0f);
}
umaDna.SetValue("lowerMuscle", Random.Range(-0.2f, 0.2f) + umaDna.GetValue("upperMuscle"));
if (umaDna.GetValue("lowerMuscle") > 1.0)
{
umaDna.SetValue("lowerMuscle", 1.0f);
}
if (umaDna.GetValue("lowerMuscle") < 0.0)
{
umaDna.SetValue("lowerMuscle", 0.0f);
}
umaDna.SetValue("lowerWeight", Random.Range(-0.1f, 0.1f) + umaDna.GetValue("upperWeight"));
if (umaDna.GetValue("lowerWeight") > 1.0)
{
umaDna.SetValue("lowerWeight", 1.0f);
}
if (umaDna.GetValue("lowerWeight") < 0.0)
{
umaDna.SetValue("lowerWeight", 0.0f);
}
umaDna.SetValue("belly", umaDna.GetValue("upperWeight") * Random.Range(0.0f, 1.0f));
umaDna.SetValue("legsSize", Random.Range(0.45f, 0.6f));
umaDna.SetValue("gluteusSize", Random.Range(0.4f, 0.6f));
umaDna.SetValue("earsSize", Random.Range(0.3f, 0.8f));
umaDna.SetValue("earsPosition", Random.Range(0.3f, 0.8f));
umaDna.SetValue("earsRotation", Random.Range(0.3f, 0.8f));
umaDna.SetValue("noseSize", Random.Range(0.3f, 0.8f));
umaDna.SetValue("noseCurve", Random.Range(0.3f, 0.8f));
umaDna.SetValue("noseWidth", Random.Range(0.3f, 0.8f));
umaDna.SetValue("noseInclination", Random.Range(0.3f, 0.8f));
umaDna.SetValue("nosePosition", Random.Range(0.3f, 0.8f));
umaDna.SetValue("nosePronounced", Random.Range(0.3f, 0.8f));
umaDna.SetValue("noseFlatten", Random.Range(0.3f, 0.8f));
umaDna.SetValue("chinSize", Random.Range(0.3f, 0.8f));
umaDna.SetValue("chinPronounced", Random.Range(0.3f, 0.8f));
umaDna.SetValue("chinPosition", Random.Range(0.3f, 0.8f));
umaDna.SetValue("mandibleSize", Random.Range(0.45f, 0.52f));
umaDna.SetValue("jawsSize", Random.Range(0.3f, 0.8f));
umaDna.SetValue("jawsPosition", Random.Range(0.3f, 0.8f));
umaDna.SetValue("cheekSize", Random.Range(0.3f, 0.8f));
umaDna.SetValue("cheekPosition", Random.Range(0.3f, 0.8f));
umaDna.SetValue("lowCheekPronounced", Random.Range(0.3f, 0.8f));
umaDna.SetValue("lowCheekPosition", Random.Range(0.3f, 0.8f));
umaDna.SetValue("foreheadSize", Random.Range(0.3f, 0.8f));
umaDna.SetValue("foreheadPosition", Random.Range(0.15f, 0.65f));
umaDna.SetValue("lipsSize", Random.Range(0.3f, 0.8f));
umaDna.SetValue("mouthSize", Random.Range(0.3f, 0.8f));
umaDna.SetValue("eyeRotation", Random.Range(0.3f, 0.8f));
umaDna.SetValue("eyeSize", Random.Range(0.3f, 0.8f));
umaDna.SetValue("breastSize", Random.Range(0.3f, 0.8f));
}
else if (mainDNA != null)
{
RandomizeShapeLegacy(umaData);
}
}
public override void OnInspectorGUI()
{
bool dirty = false;
var currentSource = dnaRange.dnaConverter;
IDNAConverter newSource = currentSource;
var converterProp = serializedObject.FindProperty("_dnaConverter");
EditorGUI.BeginChangeCheck();
EditorGUILayout.PropertyField(converterProp);
if (EditorGUI.EndChangeCheck())
{
var converterFieldProp = converterProp.FindPropertyRelative("_converter");
if (converterFieldProp.objectReferenceValue != null)
{
newSource = converterFieldProp.objectReferenceValue as IDNAConverter;
dnaRange.dnaConverter = newSource;
}
GetEntryCount();
serializedObject.ApplyModifiedProperties();
}
//UMA 2.8 FixDNAPrefabs:Use the propertyField
//newSource = EditorGUILayout.ObjectField("DNA Converter", dnaRange.dnaConverter, typeof(DnaConverterBehaviour), true) as DnaConverterBehaviour;
if (currentSource != newSource)
{
dnaRange.dnaConverter = newSource;
dnaSource = null;
//UMA 2.8 FixDNAPrefabs: We want to preserve the settings if we can
var matchingIndexes = GetMatchingIndexes(currentSource, newSource);
var newMeans = new float[entryCount];
var newDeviations = new float[entryCount];
var newSpreads = new float[entryCount];
for (int i = 0; i < entryCount; i++)
{
if (matchingIndexes.ContainsKey(i))
{
newMeans[i] = dnaRange.means[matchingIndexes[i]];
newDeviations[i] = dnaRange.deviations[matchingIndexes[i]];
newSpreads[i] = dnaRange.spreads[matchingIndexes[i]];
}
else
{
newMeans[i] = 0.5f;
newDeviations[i] = 0.16f;
newSpreads[i] = 0.5f;
}
}
/*dnaRange.means = new float[entryCount];
* dnaRange.deviations = new float[entryCount];
* dnaRange.spreads = new float[entryCount];
* for (int i = 0; i < entryCount; i++)
* {
* dnaRange.means[i] = 0.5f;
* dnaRange.deviations[i] = 0.16f;
* dnaRange.spreads[i] = 0.5f;
* }*/
dnaRange.means = newMeans;
dnaRange.deviations = newDeviations;
dnaRange.spreads = newSpreads;
dirty = true;
}
GUILayout.Box("", GUILayout.ExpandWidth(true), GUILayout.Height(1));
if (dnaRange.dnaConverter != null)
{
GUILayout.Space(2f);
GUIStyle headerStyle = new GUIStyle();
headerStyle.alignment = TextAnchor.MiddleCenter;
headerStyle.normal.textColor = Color.white;
headerStyle.fontSize = 12;
EditorGUILayout.LabelField(dnaRange.dnaConverter.DNAType.Name, headerStyle);
string[] dnaNames;
if (dnaRange.dnaConverter.DNAType == typeof(DynamicUMADna))
{
dnaNames = ((IDynamicDNAConverter)dnaRange.dnaConverter).dnaAsset.Names;
}
else
{
dnaNames = dnaSource.Names;
}
for (int i = 0; i < entryCount; i++)
{
if (i > dnaRange.means.Length - 1)
{
break;
}
float currentMin = dnaRange.means[i] - dnaRange.spreads[i];
float currentMax = dnaRange.means[i] + dnaRange.spreads[i];
float min = currentMin;
float max = currentMax;
EditorGUILayout.PrefixLabel(dnaNames[i]);
EditorGUILayout.MinMaxSlider(ref min, ref max, 0f, 1f);
if ((min != currentMin) || (max != currentMax))
{
dnaRange.means[i] = (min + max) / 2f;
dnaRange.spreads[i] = (max - min) / 2f;
dnaRange.deviations[i] = dnaRange.spreads[i] / 3f;
dirty = true;
}
}
}
if (dirty)
{
EditorUtility.SetDirty(dnaRange);
AssetDatabase.SaveAssets();
}
}
private float CalculateLegacyModifiers(float startingVal, List <spValModifier> _modifiers, UMADnaBase umaDNA)
{
float modifierVal = 0;
float tempModifierVal = 0;
string dnaCombineMethod = "";
bool inModifierPair = false;
for (int i = 0; i < _modifiers.Count; i++)
{
if (_modifiers[i].DNATypeName != "None" && (_modifiers[i].modifier == spValModifier.spValModifierType.AddDNA ||
_modifiers[i].modifier == spValModifier.spValModifierType.DivideDNA ||
_modifiers[i].modifier == spValModifier.spValModifierType.MultiplyDNA ||
_modifiers[i].modifier == spValModifier.spValModifierType.SubtractDNA))
{
tempModifierVal = GetUmaDNAValue(_modifiers[i].DNATypeName, umaDNA);
tempModifierVal -= 0.5f;
inModifierPair = true;
if (_modifiers[i].modifier == spValModifier.spValModifierType.AddDNA)
{
dnaCombineMethod = "Add";
}
else if (_modifiers[i].modifier == spValModifier.spValModifierType.DivideDNA)
{
dnaCombineMethod = "Divide";
}
else if (_modifiers[i].modifier == spValModifier.spValModifierType.MultiplyDNA)
{
dnaCombineMethod = "Multiply";
}
else if (_modifiers[i].modifier == spValModifier.spValModifierType.SubtractDNA)
{
dnaCombineMethod = "Subtract";
}
}
else
{
if (_modifiers[i].modifier == spValModifier.spValModifierType.Add)
{
modifierVal += (tempModifierVal + _modifiers[i].modifierValue);
tempModifierVal = 0;
inModifierPair = false;
}
else if (_modifiers[i].modifier == spValModifier.spValModifierType.Divide)
{
modifierVal += (tempModifierVal / _modifiers[i].modifierValue);
tempModifierVal = 0;
inModifierPair = false;
}
else if (_modifiers[i].modifier == spValModifier.spValModifierType.Multiply)
{
modifierVal += (tempModifierVal * _modifiers[i].modifierValue);
tempModifierVal = 0;
inModifierPair = false;
}
else if (_modifiers[i].modifier == spValModifier.spValModifierType.Subtract)
{
modifierVal += (tempModifierVal - _modifiers[i].modifierValue);
tempModifierVal = 0;
inModifierPair = false;
}
}
if (modifierVal != 0 && inModifierPair == false)
{
if (dnaCombineMethod == "Add")
{
startingVal += modifierVal;
}
if (dnaCombineMethod == "Subtract")
{
startingVal -= modifierVal;
}
if (dnaCombineMethod == "Multiply")
{
startingVal *= modifierVal;
}
if (dnaCombineMethod == "Divide")
{
startingVal /= modifierVal;
}
modifierVal = 0;
dnaCombineMethod = "";
}
}
//in the case of left/Right(Up)LegAdjust the umadna is subtracted from the result without being multiplied by anything
//this accounts for the scenario where umaDna is left trailing with no correcponding add/subtract/multiply/divide multiplier
if (tempModifierVal != 0 && inModifierPair != false)
{
if (dnaCombineMethod == "Add")
{
startingVal += tempModifierVal;
}
if (dnaCombineMethod == "Subtract")
{
startingVal -= tempModifierVal;
}
if (dnaCombineMethod == "Multiply")
{
startingVal *= tempModifierVal;
}
if (dnaCombineMethod == "Divide")
{
startingVal /= tempModifierVal;
}
dnaCombineMethod = "";
modifierVal = 0;
tempModifierVal = 0;
inModifierPair = false;
}
return(startingVal);
}
public Vector3 CalculateValueZ(UMADnaBase umaDNA)
{
var resVal = _valuesZ.CalculateValue(_umaDNA);
return(resVal);
}
public override void OnInspectorGUI()
{
bool dirty = false;
DnaConverterBehaviour newSource = EditorGUILayout.ObjectField("DNA Converter", dnaRange.dnaConverter, typeof(DnaConverterBehaviour), true) as DnaConverterBehaviour;
if (newSource != dnaRange.dnaConverter)
{
dnaRange.dnaConverter = newSource;
dnaSource = null;
if (dnaRange.dnaConverter != null)
{
dnaSource = dnaRange.dnaConverter.DNAType.GetConstructor(System.Type.EmptyTypes).Invoke(null) as UMADnaBase;
}
if (dnaSource == null)
{
entryCount = 0;
}
else
{
if (dnaRange.dnaConverter.DNAType == typeof(DynamicUMADna))
{
entryCount = ((DynamicDNAConverterBehaviourBase)dnaRange.dnaConverter).dnaAsset.Names.Length;
}
else
{
entryCount = dnaSource.Count;
}
}
dnaRange.means = new float[entryCount];
dnaRange.deviations = new float[entryCount];
dnaRange.spreads = new float[entryCount];
for (int i = 0; i < entryCount; i++)
{
dnaRange.means[i] = 0.5f;
dnaRange.deviations[i] = 0.16f;
dnaRange.spreads[i] = 0.5f;
}
dirty = true;
}
GUILayout.Box("", GUILayout.ExpandWidth(true), GUILayout.Height(1));
if (dnaRange.dnaConverter != null)
{
GUILayout.Space(2f);
GUIStyle headerStyle = new GUIStyle();
headerStyle.alignment = TextAnchor.MiddleCenter;
headerStyle.normal.textColor = Color.white;
headerStyle.fontSize = 12;
EditorGUILayout.LabelField(dnaRange.dnaConverter.DNAType.Name, headerStyle);
string[] dnaNames;
if (dnaRange.dnaConverter.DNAType == typeof(DynamicUMADna))
{
dnaNames = ((DynamicDNAConverterBehaviourBase)dnaRange.dnaConverter).dnaAsset.Names;
}
else
{
dnaNames = dnaSource.Names;
}
for (int i = 0; i < entryCount; i++)
{
float currentMin = dnaRange.means[i] - dnaRange.spreads[i];
float currentMax = dnaRange.means[i] + dnaRange.spreads[i];
float min = currentMin;
float max = currentMax;
EditorGUILayout.PrefixLabel(dnaNames[i]);
EditorGUILayout.MinMaxSlider(ref min, ref max, 0f, 1f);
if ((min != currentMin) || (max != currentMax))
{
dnaRange.means[i] = (min + max) / 2f;
dnaRange.spreads[i] = (max - min) / 2f;
dnaRange.deviations[i] = dnaRange.spreads[i] / 3f;
dirty = true;
}
}
}
if (dirty)
{
EditorUtility.SetDirty(dnaRange);
AssetDatabase.SaveAssets();
}
}
// This code is generally the same as used in the DynamicDNAConverterCustomizer
// Probably worth breaking it out at some point and having it geenric
protected void CreateBonePoseCallback(UMAData umaData)
{
avatarDNAisDirty = false;
UMABonePose bonePose = ScriptableObject.CreateInstance <UMABonePose>();
UMAData umaPreDNA = tempAvatarPreDNA.GetComponent <UMADynamicAvatar>().umaData;
UMAData umaPostDNA = tempAvatarPostDNA.GetComponent <UMADynamicAvatar>().umaData;
UMADnaBase activeDNA = umaPostDNA.umaRecipe.GetDna(selectedDNAHash);
UMASkeleton skeletonPreDNA = umaPreDNA.skeleton;
UMASkeleton skeletonPostDNA = umaPostDNA.skeleton;
if (poseSaveIndex < 0)
{
poseSaveName = startingPoseName;
// Now that StartingPose has been generated
// add the active DNA to the pre DNA avatar
// UMA2.8+ Lots of converters can use the same DNA now
//UMA2.8+ FixDNAPrefabs raceData.GetConverter(s) now returns IDNAConverter([])
IDNAConverter[] activeConverters = sourceUMA.umaRecipe.raceData.GetConverters(sourceUMA.umaRecipe.GetDna(selectedDNAHash));
//umaPreDNA.umaRecipe.raceData.dnaConverterList = new DnaConverterBehaviour[1];
//umaPreDNA.umaRecipe.raceData.dnaConverterList[0] = activeConverter;
umaPreDNA.umaRecipe.raceData.dnaConverterList = activeConverters;
umaPreDNA.umaRecipe.raceData.UpdateDictionary();
umaPreDNA.umaRecipe.EnsureAllDNAPresent();
umaPreDNA.Dirty(true, false, true);
}
Transform transformPreDNA;
Transform transformPostDNA;
bool transformDirty;
int parentHash;
foreach (int boneHash in skeletonPreDNA.BoneHashes)
{
skeletonPreDNA.TryGetBoneTransform(boneHash, out transformPreDNA, out transformDirty, out parentHash);
skeletonPostDNA.TryGetBoneTransform(boneHash, out transformPostDNA, out transformDirty, out parentHash);
if ((transformPreDNA == null) || (transformPostDNA == null))
{
Debug.LogWarning("Bad bone hash in skeleton: " + boneHash);
continue;
}
if (!LocalTransformsMatch(transformPreDNA, transformPostDNA))
{
bonePose.AddBone(transformPreDNA, transformPostDNA.localPosition, transformPostDNA.localRotation, transformPostDNA.localScale);
}
}
int activeDNACount = activeDNA.Count;
for (int i = 0; i < activeDNACount; i++)
{
activeDNA.SetValue(i, 0.5f);
}
AssetDatabase.CreateAsset(bonePose, folderPath + "/" + poseSaveName + ".asset");
EditorUtility.SetDirty(bonePose);
AssetDatabase.SaveAssets();
poseSaveIndex++;
if (poseSaveIndex < activeDNACount)
{
poseSaveName = activeDNA.Names[poseSaveIndex] + "_0";
activeDNA.SetValue(poseSaveIndex, 0.0f);
avatarDNAisDirty = true;
}
else if (poseSaveIndex < (activeDNACount * 2))
{
int dnaIndex = poseSaveIndex - activeDNACount;
poseSaveName = activeDNA.Names[dnaIndex] + "_1";
activeDNA.SetValue(dnaIndex, 1.0f);
umaPostDNA.Dirty();
avatarDNAisDirty = true;
}
else
{
UMAUtils.DestroySceneObject(tempAvatarPreDNA);
UMAUtils.DestroySceneObject(tempAvatarPostDNA);
// Build a prefab DNA Converter and populate it with the morph set
string assetName = "Morph Set";
string assetPath = AssetDatabase.GenerateUniqueAssetPath(folderPath + "/" + assetName + ".asset");
MorphSetDnaAsset asset = CustomAssetUtility.CreateAsset <MorphSetDnaAsset>(assetPath, false);
SerializedObject serializedAsset = new SerializedObject(asset);
SerializedProperty startingPose = serializedAsset.FindProperty("startingPose");
startingPose.objectReferenceValue = AssetDatabase.LoadAssetAtPath <UMABonePose>(folderPath + "/" + startingPoseName + ".asset");
SerializedProperty morphSetArray = serializedAsset.FindProperty("dnaMorphs");
morphSetArray.ClearArray();
for (int i = 0; i < activeDNACount; i++)
{
string posePairName = activeDNA.Names[i];
morphSetArray.InsertArrayElementAtIndex(i);
SerializedProperty posePair = morphSetArray.GetArrayElementAtIndex(i);
SerializedProperty dnaEntryName = posePair.FindPropertyRelative("dnaEntryName");
dnaEntryName.stringValue = posePairName;
SerializedProperty zeroPose = posePair.FindPropertyRelative("poseZero");
zeroPose.objectReferenceValue = AssetDatabase.LoadAssetAtPath <UMABonePose>(folderPath + "/" + posePairName + "_0.asset");
SerializedProperty onePose = posePair.FindPropertyRelative("poseOne");
onePose.objectReferenceValue = AssetDatabase.LoadAssetAtPath <UMABonePose>(folderPath + "/" + posePairName + "_1.asset");
}
serializedAsset.ApplyModifiedPropertiesWithoutUndo();
// Build a prefab DNA Converter and populate it with the morph set
string prefabName = "Converter Prefab";
string prefabPath = AssetDatabase.GenerateUniqueAssetPath(folderPath + "/" + prefabName + ".prefab");
GameObject tempConverterPrefab = new GameObject(prefabName);
MorphSetDnaConverterBehaviour converter = tempConverterPrefab.AddComponent <MorphSetDnaConverterBehaviour>();
SerializedObject serializedConverter = new SerializedObject(converter);
SerializedProperty morphSet = serializedAsset.FindProperty("morphSet");
morphSet.objectReferenceValue = AssetDatabase.LoadAssetAtPath <MorphSetDnaAsset>(assetPath);
serializedConverter.ApplyModifiedPropertiesWithoutUndo();
#if UNITY_2018_3_OR_NEWER
PrefabUtility.SaveAsPrefabAsset(tempConverterPrefab, prefabPath);
#else
PrefabUtility.CreatePrefab(prefabPath, tempConverterPrefab);
#endif
DestroyImmediate(tempConverterPrefab, false);
}
}
