/// <summary>
/// Download main texture into memory. Can be used right away to create Unity texture.
/// </summary>
public virtual AsyncWebRequest <byte[]> DownloadTextureBytesAsync(AvatarData avatar)
{
var r = AvatarDataRequestAsync(avatar.texture);
r.State = AvatarSdkMgr.Str(Strings.DownloadingHeadTexture);
return(r);
}
private AsyncRequest <AvatarData> GenerateAvatarAsync(byte[] selectedImageBytes, PipelineType pipelineType)
{
var request = new AsyncRequest <AvatarData>();
AvatarSdkMgr.SpawnCoroutine(GenerateAvatarFunc(selectedImageBytes, pipelineType, request));
return(request);
}
public void ConvertAvatarToObjFormat()
{
var haircutRecoloring = GetComponent <HaircutRecoloring>();
string haircutName = string.Empty;
if (avatarHaircuts != null && string.Compare(avatarHaircuts[currentHaircut], BALD_HAIRCUT_NAME) != 0)
{
haircutName = avatarHaircuts[currentHaircut];
}
var outputObjDir = AvatarSdkMgr.Storage().GetAvatarSubdirectory(currentAvatarCode, AvatarSubdirectory.OBJ_EXPORT);
var outputObjFile = Utils.CombinePaths(outputObjDir, "model.obj");
CoreTools.AvatarPlyToObj(currentAvatarCode, AvatarFile.MESH_PLY, AvatarFile.TEXTURE, outputObjFile);
if (!string.IsNullOrEmpty(haircutName))
{
var haircutObjFile = Path.Combine(Path.GetDirectoryName(outputObjFile), HaircutIdToFileName(haircutName, "obj"));
CoreTools.HaircutPlyToObj(currentAvatarCode, haircutName, haircutObjFile, haircutRecoloring.CurrentColor, haircutRecoloring.CurrentTint);
}
#if UNITY_EDITOR || UNITY_STANDALONE_WIN
System.Diagnostics.Process.Start(outputObjDir);
#else
progressText.text = string.Format("OBJ file was saved to avatar directory");
#endif
}
/// <summary>
/// Download haircut preview and save it to disk
/// </summary>
public AsyncRequest DownloadAndSaveHaircutPreviewAsync(AvatarHaircutData haircutData)
{
var request = new AsyncRequest(AvatarSdkMgr.Str(Strings.GettingHaircutPreview));
AvatarSdkMgr.SpawnCoroutine(DownloadAndSaveHaircutPreviewFunc(haircutData, request));
return(request);
}
/// <summary>
/// Waits while the avatar is being calulated. Calculations start automatically after the photo was loaded to the server.
/// </summary>
public AsyncRequest StartAndAwaitAvatarCalculationAsync(string avatarCode)
{
var request = new AsyncRequest(AvatarSdkMgr.Str(Strings.GeneratingAvatar));
AvatarSdkMgr.SpawnCoroutine(StartAndAwaitAvatarCalculationFunc(avatarCode, request));
return(request);
}
/// <summary>
/// Requests server to delete all data permanently and deletes local avatar files.
/// </summary>
public AsyncRequest DeleteAvatarAsync(string avatarCode)
{
var request = new AsyncRequest(AvatarSdkMgr.Str(Strings.DeletingAvatarFiles));
AvatarSdkMgr.SpawnCoroutine(DeleteAvatarFunc(avatarCode, request));
return(request);
}
/// <summary>
/// Get haircut info
/// </summary>
/// <param name="avatarCode">Avatar code</param>
/// <param name="haircutId">Haircut identity</param>
public AsyncRequest <AvatarHaircutData> GetHaircutDataAsync(string avatarCode, string haircutId)
{
var request = new AsyncRequest <AvatarHaircutData>(AvatarSdkMgr.Str(Strings.GettingHaircutInfo));
AvatarSdkMgr.SpawnCoroutine(GetHaircutDataFunc(avatarCode, haircutId, request));
return(request);
}
protected override AsyncRequest <GalleryAvatar[]> GetAllAvatarsAsync(int maxItems)
{
var request = new AsyncRequest <GalleryAvatar[]>(AvatarSdkMgr.Str(Strings.GettingAvatarState));
AvatarSdkMgr.SpawnCoroutine(GetAllAvatarsFunc(maxItems, request));
return(request);
}
private Color GetAvatarPredictedColor(string avatarCode)
{
string modelJsonPath = AvatarSdkMgr.Storage().GetAvatarFilename(avatarCode, AvatarFile.MODEL_JSON);
ModelInfo modelInfo = JsonUtility.FromJson <ModelInfo>(File.ReadAllText(modelJsonPath));
return(new Color(modelInfo.hair_color.red / 255.0f, modelInfo.hair_color.green / 255.0f, modelInfo.hair_color.blue / 255.0f));
}
/// <summary>
/// Edit avatar name/description on the server.
/// </summary>
public virtual AsyncWebRequest EditAvatarAsync(AvatarData avatar, string name = null, string description = null)
{
var request = new AsyncWebRequest(AvatarSdkMgr.Str(Strings.EditingAvatar));
byte[] requestBodyData = null;
using (var requestBody = new MultipartBody()) {
requestBody.WriteTextField("name", name);
requestBody.WriteTextField("description", description);
requestBody.WriteFooter();
requestBodyData = requestBody.GetRequestBodyData();
Func <UnityWebRequest> webRequestFactory = () => {
var webRequest = UnityWebRequest.Post(avatar.url, " ");
webRequest.chunkedTransfer = false;
webRequest.method = "PATCH";
webRequest.uploadHandler = new UploadHandlerRaw(requestBodyData);
webRequest.SetRequestHeader(
"Content-Type", string.Format("multipart/form-data; boundary=\"{0}\"", requestBody.Boundary)
);
SetAuthHeaders(webRequest);
return(webRequest);
};
Debug.LogFormat("Uploading photo...");
AvatarSdkMgr.SpawnCoroutine(AwaitJsonWebRequest(webRequestFactory, request));
return(request);
}
}
public override AsyncRequest <AvatarResources> GetResourcesAsync(AvatarResourcesSubset resourcesSubset, PipelineType pipelineType)
{
var request = new AsyncRequest <AvatarResources>(AvatarSdkMgr.Str(Strings.GettingResourcesList));
AvatarSdkMgr.SpawnCoroutine(GetResourcesFunc(resourcesSubset, pipelineType, request));
return(request);
}
/// <summary>
/// Get a particular page in the list of avatars.
/// </summary>
public virtual AsyncWebRequest <Page <AvatarData> > GetAvatarsPageAsync(int pageNumber)
{
var r = AvatarJsonPageRequest <AvatarData> (GetUrl("avatars"), pageNumber);
r.State = AvatarSdkMgr.Str(Strings.GettingAvatarList);
return(r);
}
/// <summary>
/// Downloads the haircut point cloud zip into memory.
/// </summary>
public virtual AsyncWebRequest <byte[]> DownloadHaircutPointCloudZipAsync(AvatarHaircutData haircut)
{
var r = AvatarDataRequestAsync(haircut.pointcloud);
r.State = AvatarSdkMgr.Str(Strings.DownloadingHaircutPointCloud);
return(r);
}
/// <summary>
/// Download haircut preview into memory.
/// </summary>
public virtual AsyncWebRequest <byte[]> DownloadHaircutPreviewBytesAsync(AvatarHaircutData haircut)
{
var r = AvatarDataRequestAsync(haircut.preview);
r.State = AvatarSdkMgr.Str(Strings.DownloadingHaircutPreview);
return(r);
}
/// <summary>
/// Downloads from the server haircut preview image and saves it locally.
/// Note: this method isn't implemented yet.
/// </summary>
/// <param name="haircutId">Haircut identity</param>
public AsyncRequest <byte[]> GetHaircutPreviewAsync(string avatarCode, string haircutId)
{
var request = new AsyncRequest <byte[]>(AvatarSdkMgr.Str(Strings.GettingHaircutPreview));
AvatarSdkMgr.SpawnCoroutine(GetHaircutPreviewFunc(avatarCode, haircutId, request));
return(request);
}
protected AsyncRequest <GalleryAvatar[]> GetAllAvatarsAsync(int maxItems)
{
var request = new AsyncRequest <GalleryAvatar[]>(AvatarSdkMgr.Str(Strings.GettingAvatarState));
EditorRunner.instance.Run(GetAllAvatarsRoutine(maxItems, request));
return(request);
}
/// <summary>
/// Requests from the server identities of the latest "maxItems" avatars.
/// </summary>
public AsyncRequest <string[]> GetAllAvatarsAsync(int maxItems)
{
var request = new AsyncRequest <string[]>(AvatarSdkMgr.Str(Strings.GettingAvatarList));
AvatarSdkMgr.SpawnCoroutine(GetAllAvatarsFunc(maxItems, request));
return(request);
}
/// <summary>
/// Determinates state of the avatar. It simply checks existence of the mesh and texture files.
/// </summary>
private GalleryAvatarState GetAvatarState(string avatarCode)
{
OfflineAvatarProvider offlineAvatarProvider = avatarProvider as OfflineAvatarProvider;
GalleryAvatarState avatarState = GalleryAvatarState.UNKNOWN;
var session = offlineAvatarProvider.Session;
if (session.IsAvatarCalculating(avatarCode))
{
avatarState = GalleryAvatarState.GENERATING;
}
else
{
string meshFilePath = AvatarSdkMgr.Storage().GetAvatarFilename(avatarCode, AvatarFile.MESH_PLY);
string textureFilePath = AvatarSdkMgr.Storage().GetAvatarFilename(avatarCode, AvatarFile.TEXTURE);
if (File.Exists(meshFilePath) && File.Exists(textureFilePath))
{
avatarState = GalleryAvatarState.COMPLETED;
}
else
{
avatarState = GalleryAvatarState.FAILED;
}
}
return(avatarState);
}
/// <summary>
/// Download all avatar files, unzip and save to disk.
/// </summary>
/// <param name="connection">Connection session.</param>
/// <param name="avatar">Avatar to download.</param>
/// <param name="withHaircutPointClouds">If set to true, download all haircut point clouds too.</param>
/// <param name="withBlendshapes">If set to true, download blendshapes too.</param>
public AsyncRequest DownloadAndSaveAvatarModelAsync(AvatarData avatar, bool withHaircutPointClouds, bool withBlendshapes)
{
var request = new AsyncRequest <AvatarData>(AvatarSdkMgr.Str(Strings.DownloadingAvatar));
AvatarSdkMgr.SpawnCoroutine(DownloadAndSaveAvatarModel(avatar, withHaircutPointClouds, withBlendshapes, request));
return(request);
}
/// <summary>
/// Get avatar information by code. Firstly finds data in cache. If there is no data in cache, requests it from the server
/// </summary>
private AsyncRequest <AvatarData> GetAvatarAsync(string avatarCode)
{
var request = new AsyncRequest <AvatarData>();
AvatarSdkMgr.SpawnCoroutine(GetAvatarFunc(avatarCode, request));
return(request);
}
/// <summary>
/// Download haircut points and save them to disk
/// </summary>
public AsyncRequest DownloadAndSaveHaircutPointsAsync(string avatarCode, AvatarHaircutData haircutData)
{
var request = new AsyncRequest(AvatarSdkMgr.Str(Strings.GettingHaircutPointCloud));
AvatarSdkMgr.SpawnCoroutine(DownloadAndSaveHaircutPointsFunc(avatarCode, haircutData, request));
return(request);
}
/// <summary>
/// Downloads avatar files and stores them on disk.
/// </summary>
/// <param name="avatarCode">Avatar code</param>
/// <param name="withHaircutPointClouds">If True, haircut point clouds will be downloaded.</param>
/// <param name="withBlendshapes">If true, blendshapes will be downloaded.</param>
/// <returns></returns>
public AsyncRequest MoveAvatarModelToLocalStorageAsync(string avatarCode, bool withHaircutPointClouds, bool withBlendshapes)
{
var request = new AsyncRequest <AvatarData>(AvatarSdkMgr.Str(Strings.DownloadingAvatar));
AvatarSdkMgr.SpawnCoroutine(MoveAvatarModelToLocalStorage(avatarCode, withHaircutPointClouds, withBlendshapes, request));
return(request);
}
/// <summary>
/// GetHaircutPreviewAsync implementation
/// </summary>
private IEnumerator GetHaircutPreviewFunc(string avatarCode, string haircutId, AsyncRequest <byte[]> request)
{
string haircutPreviewFilename = AvatarSdkMgr.Storage().GetHaircutFilename(haircutId, HaircutFile.HAIRCUT_PREVIEW);
if (!File.Exists(haircutPreviewFilename))
{
var haircutDataRequest = GetHaircutDataAsync(avatarCode, haircutId);
yield return(request.AwaitSubrequest(haircutDataRequest, 0.05f));
if (request.IsError)
{
yield break;
}
var downloadRequest = DownloadAndSaveHaircutPreviewAsync(haircutDataRequest.Result);
yield return(request.AwaitSubrequest(downloadRequest, 0.9f));
if (request.IsError)
{
yield break;
}
}
byte[] previewBytes = File.ReadAllBytes(haircutPreviewFilename);
request.IsDone = true;
request.Result = previewBytes;
}
/// <summary>
/// Creates TexturedMesh of the head for a given avatar.
/// If required files (mesh and texture) don't exist on disk, it downloads them from the cloud.
/// </summary>
/// <param name="avatarCode">code of the loaded avatar</param>
/// <param name="withBlendshapes">blendshapes will be added to mesh</param>
public AsyncRequest <TexturedMesh> GetHeadMeshAsync(string avatarCode, bool withBlendshapes, int detailsLevel = 0)
{
var request = new AsyncRequest <TexturedMesh>(AvatarSdkMgr.Str(Strings.GettingHeadMesh));
AvatarSdkMgr.SpawnCoroutine(GetHeadMeshFunc(avatarCode, withBlendshapes, detailsLevel, request));
return(request);
}
/// <summary>
/// Process blendshapes slightly differently compared to other zips (for compatibility reasons).
/// Blendshapes are unzipped not just in avatar directory, but in their own personal folder.
/// </summary>
/// <param name="blendshapesZip">Full path to blendshapes zip archive.</param>
/// <param name="avatarId">Avatar identifier to determine the correct unzip location.</param>
public static AsyncRequest <string> UnzipBlendshapes(string blendshapesZip, string avatarId)
{
Debug.LogWarning("This method is obsolete. Use CloudAvatarProvider instead.");
var blendshapesDir = AvatarSdkMgr.Storage().GetAvatarSubdirectory(avatarId, AvatarSubdirectory.BLENDSHAPES);
return(CoreTools.UnzipFileAsync(blendshapesZip, blendshapesDir));
}
/// <summary>
/// Returns identities of all haircuts available for the avatar
/// </summary>
public AsyncRequest <string[]> GetHaircutsIdAsync(string avatarCode)
{
var request = new AsyncRequest <string[]>(AvatarSdkMgr.Str(Strings.GettingAvailableHaircuts));
AvatarSdkMgr.SpawnCoroutine(GetHaircutsIdFunc(avatarCode, request));
return(request);
}
private AsyncRequest DownloadAvatarAsync(AvatarData avatar, PipelineType pipelineType)
{
var request = new AsyncRequest();
AvatarSdkMgr.SpawnCoroutine(DownloadAvatarFunc(avatar, pipelineType, request));
return(request);
}
/// <summary>
/// Creates TexturedMesh of the haircut.
/// If any of the required files doesn't exist it downloads them from the cloud and saves on the disk.
/// </summary>
/// <param name="avatarCode">Avatar code</param>
/// <param name="haircutName">Haircut identity</param>
public AsyncRequest <TexturedMesh> GetHaircutMeshAsync(string avatarCode, string haircutId)
{
var request = new AsyncRequest <TexturedMesh>(AvatarSdkMgr.Str(Strings.GettingHaircutMesh));
AvatarSdkMgr.SpawnCoroutine(GetHaircutMeshFunc(avatarCode, haircutId, request));
return(request);
}
public void ExportAvatarAsFbx()
{
var haircutRecoloring = GetComponent <HaircutRecoloring>();
string haircutName = string.Empty;
if (avatarHaircuts != null && string.Compare(avatarHaircuts[currentHaircut], BALD_HAIRCUT_NAME) != 0)
{
haircutName = avatarHaircuts[currentHaircut];
}
var exportDir = AvatarSdkMgr.Storage().GetAvatarSubdirectory(currentAvatarCode, AvatarSubdirectory.FBX_EXPORT);
var outputFbxFile = Utils.CombinePaths(exportDir, "model.fbx");
CoreTools.ExportAvatarAsFbx(currentAvatarCode, outputFbxFile);
if (!string.IsNullOrEmpty(haircutName))
{
var haircutFbxFile = Path.Combine(Path.GetDirectoryName(outputFbxFile), HaircutIdToFileName(haircutName, "fbx"));
CoreTools.HaircutPlyToFbx(currentAvatarCode, haircutName, haircutFbxFile, haircutRecoloring.CurrentColor, haircutRecoloring.CurrentTint);
}
#if UNITY_EDITOR || UNITY_STANDALONE_WIN
System.Diagnostics.Process.Start(exportDir);
#else
progressText.text = string.Format("FBX file was saved to avatar directory");
#endif
}
/// <summary>
/// Downloading coordinates of the vertices of the head model. This can be used to save download time, because faces and UV are always the same.
/// </summary>
public virtual AsyncWebRequest <byte[]> DownloadPointCloudZipAsync(AvatarData avatar)
{
var r = AvatarDataRequestAsync(GetUrl("avatars", avatar.code, "pointcloud"));
r.State = AvatarSdkMgr.Str(Strings.DownloadingHeadMesh);
return(r);
}
