public GroupMorphData(MorphData data)
{
foreach (MorphOffsetBase morphOffsetBase in data.MorphOffsetes)
{
this.MorphOffsets.Add((GroupMorphOffset)morphOffsetBase);
}
}
public BoneMorphData(MorphData morphData)
{
foreach (MorphOffsetBase morphOffsetBase in morphData.MorphOffsetes)
{
BoneMorphs.Add((BoneMorphOffset)morphOffsetBase);
}
}
public MaterialMorphData(MorphData morph)
{
foreach (MorphOffsetBase morphOffsetBase in morph.MorphOffsetes)
{
Morphoffsets.Add((MaterialMorphOffset)morphOffsetBase);
}
}
public PmxMaterialMorph(int index, MorphData d, OpType op)
: this()
{
Index = index;
Data = d;
Op = op;
}
public UVMorphData(MorphData morphData)
{
foreach (MorphOffsetBase morphOffsetBase in morphData.MorphOffsetes)
{
this.MorphOffsets.Add((UVMorphOffset)morphOffsetBase);
}
}
public VertexMorphData(MorphData morphData)
{
foreach (MorphOffsetBase morphOffsetBase in morphData.MorphOffsetes)
{
MorphOffsets.Add((VertexMorphOffset)morphOffsetBase);
}
}
public void Mul(MorphData d)
{
Diffuse = mul_v4(Diffuse, d.Diffuse);
Specular = mul_v4(Specular, d.Specular);
Ambient = mul_v3(Ambient, d.Ambient);
EdgeSize *= d.EdgeSize;
EdgeColor = mul_v4(EdgeColor, d.EdgeColor);
Tex = mul_v4(Tex, d.Tex);
Sphere = mul_v4(Sphere, d.Sphere);
Toon = mul_v4(Toon, d.Toon);
}
public override void OnInspectorGUI()
{
MCSMorphFileWrapper wrapper = (MCSMorphFileWrapper)target;
GUILayout.Label("File: " + wrapper.fileName);
try
{
byte[] bytes = System.IO.File.ReadAllBytes(wrapper.fileName);
MorphData morphData = MorphData.ConvertBytesToMorphData(bytes);
GUILayout.Label("Morph: " + morphData.name);
GUILayout.Label("Mesh: " + morphData.meshName);
int i = 0;
GUILayout.Label("Delta Vertices: " + (morphData.blendshapeData.deltaVertices != null ? morphData.blendshapeData.deltaVertices.Length.ToString() : "null"));
if (morphData.blendshapeData.deltaVertices != null)
{
scrollDeltaVertsPos = EditorGUILayout.BeginScrollView(scrollDeltaVertsPos, GUILayout.Height(400));
foreach (Vector3 v in morphData.blendshapeData.deltaVertices)
{
EditorGUILayout.BeginHorizontal();
EditorGUILayout.LabelField(i.ToString(), GUILayout.Width(50));
EditorGUILayout.Vector3Field("", v);//, GUILayout.Width(300));
EditorGUILayout.EndHorizontal();
i++;
}
EditorGUILayout.EndScrollView();
}
GUILayout.Label("Delta Normals: " + (morphData.blendshapeData.deltaNormals != null ? morphData.blendshapeData.deltaNormals.Length.ToString() : "null"));
if (morphData.blendshapeData.deltaNormals != null)
{
scrollDeltaNormalsPos = EditorGUILayout.BeginScrollView(scrollDeltaNormalsPos, GUILayout.Height(400));
i = 0;
foreach (Vector3 v in morphData.blendshapeData.deltaNormals)
{
EditorGUILayout.BeginHorizontal();
EditorGUILayout.Vector3Field(i.ToString(), v);//, GUILayout.Width(300));
EditorGUILayout.EndHorizontal();
i++;
}
EditorGUILayout.EndScrollView();
}
}
catch
{
GUIStyle style = new GUIStyle();
style.normal.textColor = Color.red;
GUILayout.Label("Can't parse morph file, it appears corrupted.");
}
}
public void Add(MorphData d)
{
Diffuse += d.Diffuse;
Specular += d.Specular;
Ambient += d.Ambient;
EdgeSize += d.EdgeSize;
EdgeColor += d.EdgeColor;
Tex += d.Tex;
Sphere += d.Sphere;
Toon += d.Toon;
}
static MorphData RemapMorphData(SkinnedMeshRenderer skinnedMeshRenderer, MorphData morphData, Dictionary <int, int> targetToSourceMap)
{
// This is taken from MCS StreamingMorphs's built-in ConvertMorphDataFromMap, but without requiring a projectionmap.
Mesh mesh = skinnedMeshRenderer.sharedMesh;
Vector3[] targetVertices = mesh.vertices;
MorphData morphDataNew = new MorphData();
morphDataNew.name = morphData.name;
morphDataNew.jctData = morphData.jctData;
morphDataNew.blendshapeData = new BlendshapeData();
morphDataNew.blendshapeData.frameIndex = morphData.blendshapeData.frameIndex;
morphDataNew.blendshapeData.shapeIndex = morphData.blendshapeData.shapeIndex;
morphDataNew.blendshapeData.deltaVertices = new Vector3[targetVertices.Length];
morphDataNew.blendshapeData.deltaNormals = new Vector3[targetVertices.Length];
morphDataNew.blendshapeData.deltaTangents = new Vector3[targetVertices.Length];
foreach (var ts in targetToSourceMap)
{
if (morphData.blendshapeData.deltaNormals != null)
{
morphDataNew.blendshapeData.deltaNormals[ts.Key] = morphData.blendshapeData.deltaNormals[ts.Value];
}
if (morphData.blendshapeData.deltaVertices != null)
{
if (ts.Key >= morphDataNew.blendshapeData.deltaVertices.Length)
{
throw new System.Exception("ts.key in: " + skinnedMeshRenderer.name + " is too large for deltas: " + ts.Key + " => " + ts.Value + " | " + morphDataNew.blendshapeData.deltaVertices.Length);
}
if (ts.Value >= morphData.blendshapeData.deltaVertices.Length)
{
throw new System.Exception("ts.value in: " + skinnedMeshRenderer.name + " is too large for deltas: " + ts.Key + " => " + ts.Value + " | " + morphData.blendshapeData.deltaVertices.Length);
}
morphDataNew.blendshapeData.deltaVertices[ts.Key] = morphData.blendshapeData.deltaVertices[ts.Value];
}
if (morphData.blendshapeData.deltaTangents != null)
{
morphDataNew.blendshapeData.deltaTangents[ts.Key] = morphData.blendshapeData.deltaTangents[ts.Value];
}
}
return(morphDataNew);
}
public static MorphData Inter(MorphData a, MorphData b, float val)
{
if (val == 0f)
{
return(a);
}
if (val == 1f)
{
return(b);
}
MorphData result = a;
result.Mul(1f - val);
MorphData d = b;
d.Mul(val);
result.Add(d);
return(result);
}
void _AddMorphData(List <MorphData> morphDataList, string morphScript)
{
if (morphDataList != null && morphScript != null)
{
MorphData morphData = new MorphData();
for (int i = 0; i < morphScript.Length; ++i)
{
//Debug.Log( "Char:" + morphScript[i] );
morphData.morphChar = morphScript[i];
morphData.morphName = "";
switch (morphData.morphChar)
{
case 'a': morphData.morphName = hiraMorphNameList[0]; break;
case 'i': morphData.morphName = hiraMorphNameList[1]; break;
case 'u': morphData.morphName = hiraMorphNameList[2]; break;
case 'e': morphData.morphName = hiraMorphNameList[3]; break;
case 'o': morphData.morphName = hiraMorphNameList[4]; break;
case 'n': morphData.morphName = hiraMorphNameList[2]; break; // u
case '^': morphData.morphName = hiraMorphNameList[2]; break; // u
case '`': morphData.morphName = ""; break; // n
case '/':
case '-':
case '~':
if (morphDataList.Count > 0)
{
morphData.morphName = morphDataList[morphDataList.Count - 1].morphName;
}
break;
}
morphDataList.Add(morphData);
}
}
}
/// <summary>
/// Removes morphs from selected assets. Useful in cases like hair moving unnaturally with eye blinks.
/// </summary>
public static void RemoveMorphsFromSelected(List <string> morphNamesToBeRemoved)
{
List <GameObject> content = GetContent(true);
if (content.Count == 0 || morphNamesToBeRemoved == null || morphNamesToBeRemoved.Count == 0)
{
return;
}
if (!EditorUtility.DisplayDialog("Warning", "This process is nonreversible.\nAre you sure?", "Yes", "Cancel"))
{
return;
}
// Load common conversion tools and data
_conversionData = new ConversionData();
_activeProcess = new ContentProcessor("Edit", content, true);
_activeProcess.Process = delegate() {
GameObject obj = _activeProcess.GetObject();
if (obj == null)
{
return;
}
CoreMesh[] meshes = obj.GetComponentsInChildren <CoreMesh>();
foreach (CoreMesh mesh in meshes)
{
//_activeProcess.status = mesh.name + " : Checking...";
// Check smr
SkinnedMeshRenderer smr = mesh.GetComponent <SkinnedMeshRenderer>();
if (smr == null)
{
continue;
}
// Create temp directory for generated .morph files
string morphPath = Path.Combine(Application.streamingAssetsPath, mesh.runtimeMorphPath);
Directory.CreateDirectory(morphPath);
try {
// Get manifest
var manifest = _conversionData.GetManifestForCoreMesh(mesh, _manifestSelectionMethod);
// Process morphs
List <string> morphNames = new List <string>(manifest.names);
morphNames.Add("base"); // Add "base" morph that's not in the manifest but is required for clothing and hair
foreach (string morph in morphNames)
{
MorphData data = _conversionData.GetMorphData(morphPath, morph);
if (data != null)
{
if (morphNamesToBeRemoved.Contains(morph))
{
_activeProcess.status = mesh.name + " : Removed Morph " + morph;
}
else
{
// Save .morph file for keeping
MCS_Utilities.MorphExtraction.MorphExtraction.WriteMorphDataToFile(data, morphPath + "/" + data.name + ".morph", false, false);
}
}
}
// Repack morphs into .morph.mr file
//_activeProcess.status = mesh.name + " : Rebuilding MR...";
RepackMorphs(morphPath);
//_activeProcess.status = mesh.name + " : Success!";
} catch {
_activeProcess.status = mesh.name + " : FAILED";
} finally {
MCS_Utilities.Paths.TryDirectoryDelete(morphPath);
}
}
};
}
public static CharacterMorph make_char_morph(MorphData morph)
{
// TODO
return(null);
}
public static DictRadix<MorphData> LoadDictionaryFromHSpellFolder(string path, bool bLoadMorphData)
{
if (path[path.Length - 1] != Path.DirectorySeparatorChar)
path += Path.DirectorySeparatorChar;
if (bLoadMorphData)
{
// Load the count of morphological data slots required
string sizesFile = File.ReadAllText(path + HSpell.Constants.SizesFile);
int lookupLen = sizesFile.IndexOf(' ', sizesFile.IndexOf('\n'));
lookupLen = Convert.ToInt32(sizesFile.Substring(lookupLen + 1));
string[] lookup = new string[lookupLen + 1];
using (GZipStream fdict = new GZipStream(File.OpenRead(path + HSpell.Constants.DictionaryFile), CompressionMode.Decompress))
{
char[] sbuf = new char[HSpell.Constants.MaxWordLength];
int c = 0, n, slen = 0, i = 0;
while ((c = fdict.ReadByte()) > -1)
{
if (c >= '0' && c <= '9') // No conversion required for chars < 0xBE
{
/* new word - finalize and save old word */
lookup[i++] = new string(sbuf, 0, slen);
/* and read how much to go back */
n = 0;
do
{
/* base 10... */
n *= 10;
n += (c - '0');
} while ((c = fdict.ReadByte()) > -1 && c >= '0' && c <= '9');
slen -= n;
}
sbuf[slen++] = ISO8859_To_Unicode(c);
}
}
using (MorphDataLoader dataLoader = new MorphDataLoader(path + HSpell.Constants.DescFile,
path + HSpell.Constants.StemsFile))
{
using (GZipStream fprefixes = new GZipStream(File.OpenRead(path + HSpell.Constants.PrefixesFile), CompressionMode.Decompress))
{
DictRadix<MorphData> ret = new DictRadix<MorphData>();
for (int i = 0; lookup[i] != null; i++)
{
MorphData data = new MorphData();
data.Prefixes = Convert.ToByte(fprefixes.ReadByte()); // Read prefix hint byte
data.DescFlags = dataLoader.ReadDescFile();
List<int> stemReferences = dataLoader.ReadStemFile();
data.Lemmas = new string[stemReferences.Count];
int stemPosition = 0;
foreach (int r in stemReferences)
{
// This is a bypass for the psuedo-stem "×©×•× ×•×ª", as defined by hspell
// TODO: Try looking into changing this in hspell itself
if (lookup[r].Equals("×©×•× ×•×ª") && !lookup[r].Equals(lookup[i]))
{
data.Lemmas[stemPosition++] = null;
}
else
{
data.Lemmas[stemPosition++] = lookup[r];
}
}
ret.AddNode(lookup[i], data);
}
return ret;
}
}
}
else // Use optimized version for loading HSpell's dictionary files
{
using (GZipStream fdict = new GZipStream(File.OpenRead(path + HSpell.Constants.DictionaryFile), CompressionMode.Decompress))
{
using (GZipStream fprefixes = new GZipStream(File.OpenRead(path + HSpell.Constants.PrefixesFile), CompressionMode.Decompress))
{
DictRadix<MorphData> ret = new DictRadix<MorphData>();
char[] sbuf = new char[HSpell.Constants.MaxWordLength];
int c = 0, n, slen = 0;
while ((c = fdict.ReadByte()) > -1)
{
if (c >= '0' && c <= '9') // No conversion required for chars < 0xBE
{
/* new word - finalize old word first (set value) */
sbuf[slen] = '\0';
// TODO: Avoid creating new MorphData object, and enhance DictRadix to store
// the prefixes mask in the node itself
MorphData data = new MorphData();
data.Prefixes = Convert.ToByte(fprefixes.ReadByte()); // Read prefix hint byte
ret.AddNode(sbuf, data);
/* and read how much to go back */
n = 0;
do
{
/* base 10... */
n *= 10;
n += (c - '0');
} while ((c = fdict.ReadByte()) > -1 && c >= '0' && c <= '9');
slen -= n;
}
sbuf[slen++] = ISO8859_To_Unicode(c);
}
return ret;
}
}
}
}
public static void free_morph(MorphData morph)
{
// TODO
}
public static DictRadix <MorphData> LoadDictionaryFromHSpellFolder(string path, bool bLoadMorphData)
{
if (path[path.Length - 1] != Path.DirectorySeparatorChar)
{
path += Path.DirectorySeparatorChar;
}
if (bLoadMorphData)
{
// Load the count of morphological data slots required
int lookupLen = GetWordCountInHSpellFolder(path);
var lookup = new string[lookupLen + 1];
using (GZipStream fdict = new GZipStream(File.OpenRead(path + Constants.DictionaryFile), CompressionMode.Decompress))
{
var sbuf = new char[Constants.MaxWordLength];
int c = 0, n, slen = 0, i = 0;
while ((c = fdict.ReadByte()) > -1)
{
if (c >= '0' && c <= '9') // No conversion required for chars < 0xBE
{
/* new word - finalize and save old word */
lookup[i++] = new string(sbuf, 0, slen);
/* and read how much to go back */
n = 0;
do
{
/* base 10... */
n *= 10;
n += (c - '0');
} while ((c = fdict.ReadByte()) > -1 && c >= '0' && c <= '9');
slen -= n;
}
sbuf[slen++] = ISO8859_To_Unicode(c);
}
}
using (var dataLoader = new MorphDataLoader(path + HSpell.Constants.DescFile, path + Constants.StemsFile))
using (var fprefixes = new GZipStream(File.OpenRead(path + HSpell.Constants.PrefixesFile), CompressionMode.Decompress))
{
DictRadix <MorphData> ret = new DictRadix <MorphData>();
for (int i = 0; lookup[i] != null; i++)
{
MorphData data = new MorphData();
data.Prefixes = Convert.ToByte(fprefixes.ReadByte()); // Read prefix hint byte
data.DescFlags = dataLoader.ReadDescFile();
var stemReferences = dataLoader.ReadStemFile();
data.Lemmas = new string[stemReferences.Count];
int stemPosition = 0;
foreach (int r in stemReferences)
{
// This is a bypass for the psuedo-stem "×©×•× ×•×ª", as defined by hspell
// TODO: Try looking into changing this in hspell itself
if (lookup[r].Equals("×©×•× ×•×ª") && !lookup[r].Equals(lookup[i]))
{
data.Lemmas[stemPosition++] = null;
}
else
{
data.Lemmas[stemPosition++] = lookup[r];
}
}
ret.AddNode(lookup[i], data);
}
return(ret);
}
}
else // Use optimized version for loading HSpell's dictionary files
{
using (var fdict = new GZipStream(File.OpenRead(path + HSpell.Constants.DictionaryFile), CompressionMode.Decompress))
using (var fprefixes = new GZipStream(File.OpenRead(path + HSpell.Constants.PrefixesFile), CompressionMode.Decompress))
{
var ret = new DictRadix <MorphData>();
var sbuf = new char[HSpell.Constants.MaxWordLength];
int c = 0, n, slen = 0;
while ((c = fdict.ReadByte()) > -1)
{
if (c >= '0' && c <= '9') // No conversion required for chars < 0xBE
{
/* new word - finalize old word first (set value) */
sbuf[slen] = '\0';
// TODO: Avoid creating new MorphData object, and enhance DictRadix to store
// the prefixes mask in the node itself
MorphData data = new MorphData();
data.Prefixes = Convert.ToByte(fprefixes.ReadByte()); // Read prefix hint byte
ret.AddNode(sbuf, data);
/* and read how much to go back */
n = 0;
do
{
/* base 10... */
n *= 10;
n += (c - '0');
} while ((c = fdict.ReadByte()) > -1 && c >= '0' && c <= '9');
slen -= n;
}
sbuf[slen++] = ISO8859_To_Unicode(c);
}
return(ret);
}
}
}
public static void morph_defaults(MorphData morph)
{
// TODO
}
public static void copy_morph(MorphData morph, MorphData temp)
{
// TODO
}
public void FromPmxMaterialMorph(PmxMaterialMorph sv)
{
FromPmxBaseMorph(sv);
Op = sv.Op;
Data = sv.Data;
}
public static void unmorph_all(MorphData morph)
{
// TODO
}
public PmxMaterialMorph(int index, MorphData d)
: this()
{
Index = index;
Data = d;
}
public static void send_morph_message(CharacterInstance ch, MorphData morph, bool is_morph)
{
}
public static void fwrite_morph(FileStream fs, MorphData morph)
{
// TODO
}
List <MorphData> _ParseMorphText(string morphText)
{
if (string.IsNullOrEmpty(morphText))
{
return(null);
}
//Debug.Log( "_ParseMorphText:" + morphText ); // for Debug.
System.Text.StringBuilder alphabets = new System.Text.StringBuilder();
List <MorphData> morphDataList = new List <MorphData>();
bool isBeforeAlphabet = false;
bool isBeforeMorph = false;
int textPos = 0;
for (;;)
{
if (textPos >= morphText.Length)
{
break;
}
string japanesePronun = null;
char ch = morphText[textPos];
if (ch == '[')
{
int beginPos = (++textPos);
for ( ; textPos < morphText.Length; ++textPos)
{
if (morphText[textPos] == ']')
{
int milliSeconds = MMD4MecanimCommon.ToInt(morphText, beginPos, textPos - beginPos);
if (isBeforeMorph && morphDataList.Count > 0)
{
MorphData morphData = morphDataList[morphDataList.Count - 1];
morphData.morphLength = (float)milliSeconds * 0.001f;
morphDataList[morphDataList.Count - 1] = morphData;
}
else
{
MorphData morphData = new MorphData();
morphData.morphChar = ' ';
morphData.morphName = "";
morphData.morphLength = (float)milliSeconds * 0.001f;
morphDataList.Add(morphData);
}
++textPos;
break;
}
}
isBeforeMorph = false;
}
else if (_IsEscape(ch))
{
// ^ ... alveolar
// ` ... bilabial
// / ... staccato
// - ... -
// ~ ... -
MorphData morphData = new MorphData();
morphData.morphChar = ch;
morphData.morphName = "";
switch (ch)
{
case '^':
morphData.morphName = hiraMorphNameList[2]; // u
break;
case '`':
morphData.morphName = ""; // n
break;
case '/':
case '-':
case '~':
if (morphDataList.Count > 0)
{
morphData.morphName = morphDataList[morphDataList.Count - 1].morphName;
}
break;
}
isBeforeMorph = true;
morphDataList.Add(morphData);
++textPos;
}
else if (MMD4MecanimCommon.IsAlphabet(ch))
{
// for English.
string tempString = null;
bool processedAnything = false;
ch = MMD4MecanimCommon.ToHalfLower(ch);
if (textPos + 1 < morphText.Length && MMD4MecanimCommon.IsAlphabet(morphText[textPos + 1]))
{
char ch2 = MMD4MecanimCommon.ToHalfLower(morphText[textPos + 1]);
if (textPos + 2 < morphText.Length && MMD4MecanimCommon.IsAlphabet(morphText[textPos + 2]))
{
char ch3 = MMD4MecanimCommon.ToHalfLower(morphText[textPos + 2]);
alphabets.Remove(0, alphabets.Length);
alphabets.Append(ch);
alphabets.Append(ch2);
alphabets.Append(ch3);
if (englishPhraseDictionary.TryGetValue(alphabets.ToString(), out tempString))
{
_AddMorphData(morphDataList, tempString);
processedAnything = true;
textPos += 3;
}
}
if (!processedAnything)
{
alphabets.Remove(0, alphabets.Length);
alphabets.Append(ch);
alphabets.Append(ch2);
if (englishPhraseDictionary.TryGetValue(alphabets.ToString(), out tempString))
{
_AddMorphData(morphDataList, tempString);
processedAnything = true;
textPos += 2;
}
}
}
if (!processedAnything)
{
if (!isBeforeAlphabet && (morphText[textPos] == 'I' || morphText[textPos] == '\uFF29'))
{
_AddMorphData(morphDataList, "ai");
}
else
{
if (textPos > 0 && MMD4MecanimCommon.ToHalfLower(morphText[textPos - 1]) == 'e' && ch == 'e') // lee, bee, ...
{
_AddMorphData(morphDataList, "-");
}
else
{
if (englishPronunDictionary.TryGetValue(ch, out tempString))
{
_AddMorphData(morphDataList, tempString);
}
else
{
_AddMorphData(morphDataList, " ");
}
}
}
processedAnything = true;
++textPos;
}
isBeforeAlphabet = true;
isBeforeMorph = true;
}
else if (japanesePronunDictionary.TryGetValue(ch, out japanesePronun))
{
string postPhaseText = null;
if (textPos + 1 < morphText.Length && japanesePostPhraseDictionary.TryGetValue(morphText[textPos + 1], out postPhaseText))
{
string phaseText = null;
if (japanesePhraseDictionary.TryGetValue(morphText.Substring(textPos, 2), out phaseText))
{
_AddMorphData(morphDataList, phaseText);
}
else
{
_AddMorphData(morphDataList, japanesePronun);
_AddMorphData(morphDataList, postPhaseText);
}
textPos += 2;
}
else
{
_AddMorphData(morphDataList, japanesePronun);
++textPos;
}
isBeforeAlphabet = false;
isBeforeMorph = true;
}
else
{
if (textPos + 1 < morphText.Length) // Simulate VOICEROID
{
string tempString = null;
if (punctuatDictionary.TryGetValue(ch, out tempString))
{
_AddMorphData(morphDataList, " "); // Simulate VOICEROID
}
else
{
// Nothing
}
}
isBeforeAlphabet = false;
isBeforeMorph = false;
++textPos;
}
}
return(morphDataList);
}
PlayingData _ParsePlayingData(AudioClip audioClip, string morphText)
{
PlayingData playingData = new PlayingData();
playingData.audioClip = audioClip;
playingData.playingLength = 0.0f;
playingData.playingTime = 0.0f;
playingData.morphPos = -1;
playingData.morphTime = 0.0f;
if (!string.IsNullOrEmpty(morphText))
{
playingData.morphDataList = _ParseMorphText(morphText);
}
else
{
playingData.morphDataList = _ParseMorphText(System.IO.Path.GetFileNameWithoutExtension(audioClip.name));
}
if (playingData.morphDataList != null)
{
float morphTotalLength = 0.0f;
int morphZeroCount = 0;
for (int i = 0; i < playingData.morphDataList.Count; ++i)
{
char ch = playingData.morphDataList[i].morphChar;
if (playingData.morphDataList[i].morphLength == 0.0f)
{
if (ch != '^' && ch != '`')
{
++morphZeroCount;
}
}
else
{
morphTotalLength += playingData.morphDataList[i].morphLength;
}
}
float elementLength = GetElementLength();
if (audioClip != null)
{
playingData.playingLength = audioClip.length;
if (playingData.playingLength <= morphTotalLength)
{
playingData.playingLength = morphTotalLength;
elementLength = 0.0f;
}
else
{
if (morphZeroCount > 0)
{
elementLength = (playingData.playingLength - morphTotalLength) / (float)morphZeroCount;
}
}
}
else
{
playingData.playingLength = morphTotalLength + elementLength * (float)morphZeroCount;
}
if (elementLength > 0.0f)
{
// Allocate each morphLength.
for (int i = 0; i < playingData.morphDataList.Count; ++i)
{
char ch = playingData.morphDataList[i].morphChar;
if (playingData.morphDataList[i].morphLength == 0.0f)
{
if (ch != '^' && ch != '`')
{
MorphData morphData = playingData.morphDataList[i];
morphData.morphLength = elementLength;
playingData.morphDataList[i] = morphData;
}
}
}
// Fix for each consonantLength.
float consonantLength = GetConsonantLength();
for (int i = 0; i < playingData.morphDataList.Count; ++i)
{
char ch = playingData.morphDataList[i].morphChar;
if (playingData.morphDataList[i].morphLength == 0.0f)
{
if (ch != '^' && ch != '`')
{
// Nothing.
}
else
{
int beginIndex = i;
for (++i; i < playingData.morphDataList.Count; ++i)
{
ch = playingData.morphDataList[i].morphChar;
if (ch != '^' && ch != '`')
{
float morphLength = playingData.morphDataList[i].morphLength;
float tempLength = 0.0f;
if (consonantLength * 2.0f <= morphLength)
{
MorphData morphData = playingData.morphDataList[i];
morphData.morphLength = morphLength - consonantLength;
playingData.morphDataList[i] = morphData;
tempLength = consonantLength;
}
else
{
MorphData morphData = playingData.morphDataList[i];
morphData.morphLength = morphLength * 0.5f;
playingData.morphDataList[i] = morphData;
tempLength = morphData.morphLength;
}
{
MorphData morphData = playingData.morphDataList[beginIndex];
morphData.morphLength = tempLength;
playingData.morphDataList[beginIndex] = morphData;
}
break;
}
else
{
if (playingData.morphDataList[i].morphLength == 0.0f)
{
// Nothing.
}
else
{
break; // Skip processing.( Exception case, no effects. )
}
}
}
}
}
}
}
}
else
{
if (audioClip != null)
{
playingData.playingLength = audioClip.length;
}
}
#if false
if (playingData.morphDataList != null)
{
for (int i = 0; i < playingData.morphDataList.Count; ++i)
{
Debug.Log("" + playingData.morphDataList[i].morphName +
":" + playingData.morphDataList[i].morphChar +
":" + playingData.morphDataList[i].morphLength);
}
}
#endif
return(playingData);
}
public void AddNode(string s, MorphData md)
{
this.mds.Add(s, md);
this.dict.AddNode(s, md);
}
/// <summary>
/// Remaps morph data for all MCS content, or only selected folders if useSelection == true.
/// </summary>
public static void ConvertMorphData(bool useSelection)
{
if (!useSelection)
{
if (!EditorUtility.DisplayDialog("Warning", "This will attempt to convert all MCS morph data in your project. This process is nonreversible.\nAre you sure?", "Yes", "Cancel"))
{
return;
}
}
List <GameObject> content = GetContent(useSelection);
if (content.Count == 0)
{
return;
}
// Load common conversion tools and data
_conversionData = new ConversionData();
_activeProcess = new ContentProcessor("Convert", content, true);
_activeProcess.Process = delegate() {
GameObject obj = _activeProcess.GetObject();
if (obj == null)
{
return;
}
CoreMesh[] meshes = obj.GetComponentsInChildren <CoreMesh>();
foreach (CoreMesh mesh in meshes)
{
//_activeProcess.status = mesh.name + " : Checking...";
_conversionData.CreateReport(mesh.name);
// Check if already converted
if (_conversionData.GetMorphData(mesh.runtimeMorphPath, "_2019compatible") != null)
{
_conversionData.CloseReport("Skipped (already converted)");
continue;
}
// Check smr
SkinnedMeshRenderer smr = mesh.GetComponent <SkinnedMeshRenderer>();
if (smr == null)
{
_conversionData.CloseReport("Skipped (no SkinnedMeshRenderer found)");
continue;
}
// Check for original vertex map
string vmPath = "";
foreach (string path in _conversionData.vertexMaps)
{
if (path.Contains(mesh.name + ".json"))
{
vmPath = path;
break;
}
}
if (vmPath == "")
{
_conversionData.CloseReport("Skipped (no vertex map found)");
continue;
}
// Create temp directory for generated .morph files
string morphPath = Path.Combine(Application.streamingAssetsPath, mesh.runtimeMorphPath);
Directory.CreateDirectory(morphPath);
// Run process
try {
// Read vertex map
string mapData = File.ReadAllText(vmPath);
VertexMap vertexMap = JsonUtility.FromJson <VertexMap>(mapData);
// Generate retarget map
//_activeProcess.status = mesh.name + " : Generating Target Map...";
Dictionary <int, int> ttsMap = _conversionData.projectionMeshMap.GenerateTargetToSourceMap(vertexMap.vertices, smr.sharedMesh.vertices);
// Get manifest
var manifest = _conversionData.GetManifestForCoreMesh(mesh, _manifestSelectionMethod);
// Process morphs
int n = 0;
int total = manifest.names.Length;
List <string> morphNames = new List <string>(manifest.names);
morphNames.Add("base"); // Add "base" morph that's not in the manifest but is required for clothing and hair
foreach (string morph in morphNames)
{
//_activeProcess.status = string.Format("{0} : Processing Morph {1}/{2}", mesh.name, n, total);
n++;
MorphData source = _conversionData.GetMorphData(morphPath, morph); // Not all assets will have all morphs
if (source != null)
{
// Retarget morphs
MorphData target = RemapMorphData(smr, source, ttsMap);
// Save new .morph file
MCS_Utilities.MorphExtraction.MorphExtraction.WriteMorphDataToFile(target, morphPath + "/" + target.name + ".morph", false, false);
}
}
// Inject evidence of conversion so we don't accidentally remap again.
MorphData note = new MorphData();
note.name = "_2019compatible";
MCS_Utilities.MorphExtraction.MorphExtraction.WriteMorphDataToFile(note, morphPath + "/" + note.name + ".morph", false, false);
// Repack morphs into .morph.mr file
_activeProcess.status = mesh.name + " : Repacking Morphs...";
RepackMorphs(morphPath);
_conversionData.CloseReport("Success");
} catch {
_conversionData.CloseReport("Failed");
} finally {
MCS_Utilities.Paths.TryDirectoryDelete(morphPath);
}
}
if (_activeProcess.isLast)
{
_conversionData.PrintSummary();
}
};
}
