/// <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); }