/// <summary>
/// De-compress the data to general Live2D model files
/// </summary>
/// <param name="data">file json file</param>
/// <returns>Decomplessed model data with CompressedLive2D</returns>
public CompressedLive2D DeCompress(string data)
{
try
{
CompressedLive2D profile = JsonUtility.FromJson <CompressedLive2D>(data);
return(profile);
}
catch (Exception e)
{
throw e;
}
}
/// <summary>
/// Moad model information from de compressed data
/// </summary>
/// <param name="data">Compressed byte data</param>
public void LoadModelFromCompressor(byte[] data)
{
//set compressor
var compressor = new ModelCompressor();
var modelData = new CompressedLive2D(compressor.DeCompress(Encoding.UTF8.GetString(data)));
if (modelData != null)
{
//Load models
ToModel(modelData);
}
}
/// <summary>
/// Moad model information from de compressed data
/// </summary>
/// <param name="data">Compressed data</param>
public void LoadModelFromCompressor(string data)
{
//set compressor
var compressor = new ModelCompressor();
var modelData = new CompressedLive2D(compressor.DeCompress(data));
if (modelData != null)
{
//Load models
ToModel(modelData);
}
}
/// <summary>
/// compress the Live2D model files
/// </summary>
public async Task <string> CompressAsync(string path)
{
//read model json file to get other data path
string directoryPath = Path.GetDirectoryName(path);
Debug.Log(path);
CubismModel3Json datas;
string modelJson = "";
try
{
using (var reader = new StreamReader(path))
{
modelJson = reader.ReadToEnd();
Debug.Log(modelJson);
datas = JsonUtility.FromJson <CubismModel3Json>(modelJson);
Debug.Log("version : " + datas.Version);
Debug.Log("Moc : " + datas.FileReferences.Moc);
foreach (string a in datas.FileReferences.Textures)
{
Debug.Log("Texture : " + a);
}
Debug.Log("Physics : " + datas.FileReferences.Physics);
}
}
catch (Exception e)
{
Debug.Log("Error in load model3Json");
Debug.Log(e);
return(null);
}
//collect the texture datas
List <TextureImage> textures = new List <TextureImage>();
try
{
const int MegaByte = 1024 * 1024;
foreach (string target in datas.FileReferences.Textures)
{
//check the file size of texture
FileInfo fi = new FileInfo(directoryPath + "/" + target);
Debug.Log("file size : " + fi.Length);
//when file size under the 500MB add it
if (fi.Length < 500 * MegaByte)
{
//Open file
using (FileStream fs = new FileStream(directoryPath + "/" + target, FileMode.Open, FileAccess.Read))
{
//make the byte array for file size
var bs = new byte[fs.Length];
//read all of file
fs.Read(bs, 0, bs.Length);
string base64String = Convert.ToBase64String(bs);
// add data to class
textures.Add(new TextureImage(fi.Name, base64String));
}
}
}
}
catch (Exception e)
{
Debug.Log("Error in load texture");
Debug.Log(e);
return(null);
}
//convert moc3 file
string file = "";
try
{
using (var fs = new FileStream(directoryPath + "/" + datas.FileReferences.Moc, FileMode.Open, FileAccess.Read))
{
//make the byte array for file size
var fileData = new byte[fs.Length];
//read all of file
fs.Read(fileData, 0, fileData.Length);
file = Convert.ToBase64String(fileData);
}
}
catch (Exception e)
{
Debug.Log("Error in load moc3 file");
Debug.Log(e);
return(null);
}
//physics3json
string physicsJson = "";
try
{
using (var reader = new StreamReader(directoryPath + "/" + datas.FileReferences.Physics))
{
await Task.Run(() =>
{
physicsJson = Utility.RemoveChars(reader.ReadToEnd(), new char[] { '\r', '\n', '\t' });
});
}
}
catch (Exception e)
{
Debug.Log("Error in load physics3Json");
Debug.Log(e);
}
string userJson = "";
try
{
using (var reader = new StreamReader(directoryPath + "/" + datas.FileReferences.UserData))
{
await Task.Run(() =>
{
userJson = Utility.RemoveChars(reader.ReadToEnd(), new char[] { '\r', '\n', '\t' });
});
}
}
catch (Exception e)
{
Debug.Log("Error in load physics3Json");
Debug.Log(e);
}
var mergedFile = new CompressedLive2D(file, textures, modelJson, physicsJson, userJson);
return(JsonUtility.ToJson(mergedFile, true));
}
public CubismModel ToModel(MaterialPicker pickMaterial, TexturePicker pickTexture,
CompressedLive2D current, bool shouldImportAsOriginalWorkflow = false)
{
// Initialize model source and instantiate it.
var mocAsBytes = Convert.FromBase64String(current.MocFile);
if (mocAsBytes == null)
{
return(null);
}
var moc = CubismMoc.CreateFrom(mocAsBytes);
var model = CubismModel.InstantiateFrom(moc);
//init CubismModel3Json
var modelJson = JsonUtility.FromJson <CubismModel3Json>(current.Model3Json);
var references = modelJson.FileReferences;
model.name = references.Moc.Replace(".moc3", "");
model.tag = "Player";
//make the texture 2D for attach the model data
var modelTextures = new Texture2D[references.Textures.Length];
for (int index = 0; index < references.Textures.Length; index++)
{
modelTextures[index] = ReadPng(current.Textures[index].imageData);
}
#if UNITY_EDITOR
// Add parameters and parts inspectors.
model.gameObject.AddComponent <CubismParametersInspector>();
model.gameObject.AddComponent <CubismPartsInspector>();
#endif
// Create renderers.
var rendererController = model.gameObject.AddComponent <CubismRenderController>();
var renderers = rendererController.Renderers;
var drawables = model.Drawables;
// Initialize materials.
for (var i = 0; i < renderers.Length; ++i)
{
renderers[i].Material = pickMaterial(modelJson, drawables[i]);
}
// Initialize textures.
for (var i = 0; i < renderers.Length; ++i)
{
renderers[i].MainTexture = pickTexture(current, drawables[i], modelTextures);
}
rendererController.SortingMode = CubismSortingMode.BackToFrontOrder;
// Initialize drawables.
if (modelJson.HitAreas != null)
{
for (var i = 0; i < modelJson.HitAreas.Length; i++)
{
for (var j = 0; j < drawables.Length; j++)
{
if (drawables[j].Id == modelJson.HitAreas[i].Id)
{
// Add components for hit judgement to HitArea target Drawables.
var hitDrawable = drawables[j].gameObject.AddComponent <CubismHitDrawable>();
hitDrawable.Name = modelJson.HitAreas[i].Name;
drawables[j].gameObject.AddComponent <CubismRaycastable>();
break;
}
}
}
}
// Initialize groups.
var parameters = model.Parameters;
for (var i = 0; i < parameters.Length; ++i)
{
if (IsParameterInGroup(modelJson, parameters[i], "EyeBlink"))
{
if (model.gameObject.GetComponent <CubismEyeBlinkController>() == null)
{
model.gameObject.AddComponent <CubismEyeBlinkController>();
}
parameters[i].gameObject.AddComponent <CubismEyeBlinkParameter>();
}
// Set up mouth parameters.
if (IsParameterInGroup(modelJson, parameters[i], "LipSync"))
{
if (model.gameObject.GetComponent <CubismMouthController>() == null)
{
model.gameObject.AddComponent <CubismMouthController>();
}
parameters[i].gameObject.AddComponent <CubismMouthParameter>();
}
}
// Add mask controller if required.
for (var i = 0; i < drawables.Length; ++i)
{
if (!drawables[i].IsMasked)
{
continue;
}
// Add controller exactly once...
model.gameObject.AddComponent <CubismMaskController>();
break;
}
// Add original workflow component if is original workflow.
if (shouldImportAsOriginalWorkflow)
{
// Add cubism update manager.
var updateaManager = model.gameObject.GetComponent <CubismUpdateController>();
if (updateaManager == null)
{
model.gameObject.AddComponent <CubismUpdateController>();
}
// Add parameter store.
var parameterStore = model.gameObject.GetComponent <CubismParameterStore>();
if (parameterStore == null)
{
parameterStore = model.gameObject.AddComponent <CubismParameterStore>();
}
// Add pose controller.
var poseController = model.gameObject.GetComponent <CubismPoseController>();
if (poseController == null)
{
poseController = model.gameObject.AddComponent <CubismPoseController>();
}
// Add expression controller.
var expressionController = model.gameObject.GetComponent <CubismExpressionController>();
if (expressionController == null)
{
expressionController = model.gameObject.AddComponent <CubismExpressionController>();
}
// Add fade controller.
var motionFadeController = model.gameObject.GetComponent <CubismFadeController>();
if (motionFadeController == null)
{
motionFadeController = model.gameObject.AddComponent <CubismFadeController>();
}
}
// Initialize physics if JSON exists.
string physics3JsonAsString = current.Physics3Json;
if (!string.IsNullOrEmpty(physics3JsonAsString))
{
var physics3Json = CubismPhysics3Json.LoadFrom(physics3JsonAsString);
var physicsController = model.gameObject.GetComponent <CubismPhysicsController>();
if (physicsController == null)
{
physicsController = model.gameObject.AddComponent <CubismPhysicsController>();
}
physicsController.Initialize(physics3Json.ToRig());
}
string userData3JsonAsString = current.UserData3Json;
if (!string.IsNullOrEmpty(userData3JsonAsString))
{
var userData3Json = CubismUserData3Json.LoadFrom(userData3JsonAsString);
var drawableBodies = userData3Json.ToBodyArray(CubismUserDataTargetType.ArtMesh);
for (var i = 0; i < drawables.Length; ++i)
{
var index = GetBodyIndexById(drawableBodies, drawables[i].Id);
if (index >= 0)
{
var tag = drawables[i].gameObject.GetComponent <CubismUserDataTag>();
if (tag == null)
{
tag = drawables[i].gameObject.AddComponent <CubismUserDataTag>();
}
tag.Initialize(drawableBodies[index]);
}
}
}
if (model.gameObject.GetComponent <Animator>() == null)
{
model.gameObject.AddComponent <Animator>();
}
// Make sure model is 'fresh'
model.ForceUpdateNow();
return(model);
}
public CubismModel ToModel(CompressedLive2D model, bool shouldImportAsOriginalWorkflow = false)
{
return(ToModel(CubismBuiltinPickers.MaterialPicker, ModelDataPicker.TexturePicker,
model, shouldImportAsOriginalWorkflow));
}
/// <summary>
/// Builtin <see cref="Texture2D"/> picker.
/// </summary>
/// <param name="compressedLive2D">model file.</param>
/// <param name="drawable">Drawable to map to.</param>
/// <param name="modelTextures">Loaded Live2D model textures</param>
/// <returns>Mapped texture.</returns>
public static Texture2D TexturePicker(CompressedLive2D compressedLive2D, CubismDrawable drawable, Texture2D[] modelTextures)
{
var index = drawable.TextureIndex;
return(modelTextures[index]);
}
