// Start is called before the first frame update
private IEnumerator Start()
{
int numOfImages = 10;
int numOfPNGs = 0; // Used to load the last PNG in the folder (loads "SavedImage" + numOfPNGs)
string filePath = Application.persistentDataPath; // Where the images are stored
string individualFilePath; // The file directory of a specific image to load
List <string> PNGImages = new List <string>(); // Stores all PNG files
RawImage[] paintings = { painting1, painting2, painting3, painting4, painting5, painting6, painting7, painting8, painting9, painting10 };
Texture loadedTexture;
// Stores the info on what is saved in the filePath to an array
DirectoryInfo info = new DirectoryInfo(filePath);
FileInfo[] fileInfo = info.GetFiles();
// Goes through each file within he array, if the file extension is a '.png', numOfPNGs increments
foreach (FileInfo file in fileInfo)
{
if (file.Extension == ".png")
{
numOfPNGs++;
PNGImages.Add(filePath + "/SavedImage" + numOfPNGs + ".png"); // Stores only the png files
}
}
PNGImages.Reverse(); // Reverses array have last object loaded first
// For every image frame, a savedImage is loaded
for (int i = 0; i < numOfImages; i++)
{
individualFilePath = PNGImages[i];
using (UnityWebRequest uwr = UnityWebRequestTexture.GetTexture(individualFilePath)) {
yield return(uwr.SendWebRequest());
if (uwr.isNetworkError || uwr.isHttpError)
{
loadedTexture = null;
Debug.Log("Error loading texture.");
Debug.Log(uwr.error);
}
else
{
loadedTexture = DownloadHandlerTexture.GetContent(uwr);
Debug.Log("Succesfully loaded texture!");
}
paintings[i].texture = loadedTexture;
}
}
}
protected virtual IEnumerator LoadImage(Image image)
{
Texture2D texture;
if (image.Uri != null)
{
var uri = image.Uri;
Regex regex = new Regex(Base64StringInitializer);
Match match = regex.Match(uri);
if (match.Success)
{
var base64Data = uri.Substring(match.Length);
var textureData = Convert.FromBase64String(base64Data);
texture = new Texture2D(0, 0);
texture.LoadImage(textureData);
}
else
{
var www = UnityWebRequest.Get(AbsolutePath(uri));
www.downloadHandler = new DownloadHandlerTexture();
yield return(www.Send());
// HACK to enable mipmaps :(
var tempTexture = DownloadHandlerTexture.GetContent(www);
if (tempTexture != null)
{
texture = new Texture2D(tempTexture.width, tempTexture.height, tempTexture.format, true);
texture.SetPixels(tempTexture.GetPixels());
texture.Apply(true);
}
else
{
Debug.LogFormat("{0} {1}", www.responseCode, www.url);
texture = new Texture2D(16, 16);
}
}
}
else
{
texture = new Texture2D(0, 0);
var bufferView = image.BufferView.Value;
var buffer = bufferView.Buffer.Value;
var data = new byte[bufferView.ByteLength];
System.Buffer.BlockCopy(buffer.Contents, bufferView.ByteOffset, data, 0, data.Length);
texture.LoadImage(data);
}
image.Contents = texture;
}
internal static void TextureFetched(AsyncOperation op)
{
var searchPreview = s_CurrentSearchAssetData.Values.FirstOrDefault(sp => sp.requestOp == op);
if (searchPreview != null)
{
if (searchPreview.request.isDone && !searchPreview.request.isHttpError && !searchPreview.request.isNetworkError)
{
searchPreview.preview = DownloadHandlerTexture.GetContent(searchPreview.request);
}
searchPreview.requestOp.completed -= TextureFetched;
searchPreview.requestOp = null;
}
}
private IEnumerator OutputRoutine(string url)
{
using UnityWebRequest uwr = UnityWebRequestTexture.GetTexture(url);
yield return(uwr.SendWebRequest());
if (uwr.result == UnityWebRequest.Result.ConnectionError || uwr.result == UnityWebRequest.Result.ProtocolError)
{
Debug.LogError(uwr.error);
}
else
{
output.texture = DownloadHandlerTexture.GetContent(uwr);
}
}
// Download thumbnail from URL
private async Task <Sprite> DownloadThumbnail(string id)
{
using (UnityWebRequest www = UnityWebRequestTexture.GetTexture(id))
{
var asyncOp = www.SendWebRequest();
while (asyncOp.isDone == false)
{
await Task.Delay(1000 / 30);
}
var texture = DownloadHandlerTexture.GetContent(www);
var rect = new Rect(0, 0, texture.width, texture.height);
return(Sprite.Create(texture, rect, Vector2.one * .5f));
}
}
IEnumerator LoadImage(string ImageName)
{
using (UnityWebRequest uwr = UnityWebRequestTexture.GetTexture("file:///C:/MyFilePath" + ImageName + ".jpg"))
{
yield return(uwr.SendWebRequest());
if (uwr.isNetworkError || uwr.isHttpError)
{
Debug.Log(uwr.error);
}
else
{
// Get downloaded texture
var texture = DownloadHandlerTexture.GetContent(uwr);
private void FinishDownload()
{
if (m_webrequest == null)
{
error = string.Format("webrequest is null ,key={0},url={1} ", cRequest.key, cRequest.url);
return;
}
#if UNITY_2017
if (m_webrequest.isNetworkError)
#else
if (m_webrequest.isError)
#endif
{
error = string.Format("url:{0},erro:{1}", cRequest.url, m_webrequest.error);
Debug.LogErrorFormat(error);
return;
}
if (m_webrequest.responseCode != 200)
{
error = string.Format("response error code = {0},url={1}", m_webrequest.responseCode, cRequest.url); // m_webrequest.error;
Debug.LogError(error);
return;
}
var type = cRequest.assetType;
if (CacheManager.Typeof_AudioClip.Equals(type))
{
m_Data = DownloadHandlerAudioClip.GetContent(m_webrequest);
}
else if (CacheManager.Typeof_Texture2D.Equals(type))
{
m_Data = DownloadHandlerTexture.GetContent(m_webrequest);
}
else if (CacheManager.Typeof_Bytes.Equals(type))
{
m_Data = m_webrequest.downloadHandler.data;
}
else
{
m_Data = DownloadHandlerBuffer.GetContent(m_webrequest);
}
UriGroup.CheckWWWComplete(cRequest, m_webrequest);
cRequest.data = m_Data;
m_webrequest.Dispose();
m_webrequest = null;
m_asyncOperation = null;
}
/// <summary>
/// テクスチャを取得する
/// コルーチンではなく、async/awaitを使ってUnityWebRequestを待ち受ける
/// </summary>
private async UniTask <Texture> GetTextureAsync(string uri, CancellationToken token)
{
using (var uwr = UnityWebRequestTexture.GetTexture(uri))
{
await uwr.SendWebRequest().ToUniTask(cancellationToken: token);
if (uwr.isHttpError || uwr.isNetworkError)
{
throw new Exception(uwr.error);
}
return(DownloadHandlerTexture.GetContent(uwr));
}
}
IEnumerator ChangeBackground(string bg) //ID 1
{
ToggleTextbox(false, 3);
ready = false;
Debug.Log($"New background loaded: {bg}");
UnityWebRequest uwr = UnityWebRequestTexture.GetTexture($"file://{Application.dataPath}/Backgrounds/{bg}.png");
yield return(uwr.SendWebRequest());
var texture = DownloadHandlerTexture.GetContent(uwr);
background.GetComponent <SpriteRenderer>().sprite = Sprite.Create(texture, new Rect(0, 0, texture.width, texture.height), new Vector2(0.5f, 0.5f));
ready = true;
}
public static IEnumerator GetTexture(string imgPath, UnityAction <Texture2D> callback)
{
using var www = UnityWebRequestTexture.GetTexture(imgPath);
yield return(www.SendWebRequest());
if (www.result == UnityWebRequest.Result.ConnectionError)
{
Debug.Log(www.error + " / " + imgPath);
}
else
{
callback.Invoke(DownloadHandlerTexture.GetContent(www));
}
}
IEnumerator WaitForImage(string path, Action <Sprite> callback = null, bool updateMainPage = true)
{
if (runningCoroutines.Count <= 0)
{
startLoadingImages.Invoke();
}
UnityWebRequest www = UnityWebRequestTexture.GetTexture(path);
UnityWebRequestAsyncOperation imageRequest = www.SendWebRequest();
runningCoroutines.Add(www);
int timeOutCounter = 0;
currentlyLoadedSprite = defaultSprite;
while (!imageRequest.isDone && timeOutCounter < 20)
{
timeOutCounter++;
yield return(new WaitForSeconds(1));
}
if (!imageRequest.isDone || www.isNetworkError || www.isHttpError)
{
currentlyLoadedSprite = defaultSprite;
if (updateMainPage)
{
SetImagesToCurrentSprite();
}
}
else
{
//return valid results:
Texture2D result = DownloadHandlerTexture.GetContent(www);
currentlyLoadedSprite = Sprite.Create(result, new Rect(0, 0, result.width, result.height), Vector2.one * 0.5f);
if (callback != null)
{
callback.Invoke(currentlyLoadedSprite);
}
if (updateMainPage)
{
SetImagesToCurrentSprite();
}
}
runningCoroutines.Remove(www);
if (runningCoroutines.Count <= 0)
{
//No more Images to load
onImageChanged.Invoke();
}
}
void m_Done()
{
var type = cRequest.assetType;
#if UNITY_2017
if (m_webrequest == null || m_webrequest.isNetworkError)
#else
if (m_webrequest == null || m_webrequest.isError)
#endif
{
error = string.Format("url:{0},erro:{1}", cRequest.url, m_webrequest == null?"m_webrequest is null":m_webrequest.error);
cRequest.error = error;
Debug.LogError(error);
}
else if (!(m_webrequest.responseCode == 200 || m_webrequest.responseCode == 0))
{
error = string.Format("response error code = {0},url={1}", m_webrequest.responseCode, cRequest.url); // m_webrequest.error;
cRequest.error = error;
Debug.LogError(error);
}
else
{
object m_Data = null;
if (LoaderType.Typeof_Bytes.Equals(type))
{
m_Data = m_webrequest.downloadHandler.data;
}
else if (LoaderType.Typeof_Texture2D.Equals(type))
{
m_Data = DownloadHandlerTexture.GetContent(m_webrequest);
}
else if (LoaderType.Typeof_AssetBundle.Equals(type))
{
m_Data = DownloadHandlerAssetBundle.GetContent(m_webrequest);
}
else
{
m_Data = DownloadHandlerBuffer.GetContent(m_webrequest);
}
cRequest.data = m_Data;
}
if (m_webrequest != null)
{
m_webrequest.Dispose();
}
m_webrequest = null;
m_asyncOperation = null;
}
IEnumerator GetTextureData()
{
//text.text = "Loading images...";
Debug.Log("Loading images...");
foreach (KeyValuePair <string, MediaElement> entry in mediaDictionary)
{
manager.UpdateLoadingBar(0.2f / mediaDictionary.Count);
using (UnityWebRequest uwr = UnityWebRequestTexture.GetTexture(entry.Value.PictureURL))
{
Debug.Log("Loading the image as a texture");
uwr.certificateHandler = new AcceptAllCertificates(); // To remove before going to production because certificate is valid
yield return(uwr.SendWebRequest());
while (!uwr.isDone)
{
yield return(uwr);
}
if (uwr.isNetworkError)
{
//text.text = "Network error while loading texture";
Debug.Log("Network error while loading texture");
Debug.Log(uwr.error);
}
else if (uwr.isHttpError)
{
//text.text = "Http error while loading texture";
Debug.Log("Http error while loading texture");
Debug.Log(uwr.error);
}
else
{
// Get downloaded asset bundle
Debug.Log("Texture " + entry.Key + " loaded");
if (!retrievedTextures.ContainsKey(entry.Key))
{
retrievedTextures.Add(entry.Key, DownloadHandlerTexture.GetContent(uwr));
}
}
}
}
Debug.Log("All " + retrievedTextures.Count + " textures loaded!!!");
// Start next coroutine
StartNextCoRoutine();
}
void AssetReferer.ReferAsset(AssetUnitInfo assetUnitInfo, AssetReferenceListener listener)
{
if (string.IsNullOrEmpty(clientID) || string.IsNullOrEmpty(clientSecret))
{
return;
}
//asume like "deviantart:{GUID}"
string[] assetRef = assetUnitInfo.reference.Split(':');
if (System.Collections.CaseInsensitiveComparer.Equals(assetRef[0], "deviantart"))
{
listener.OnBeginRefering();
var webReq = new UnityWebRequest("https://www.deviantart.com/oauth2/token?grant_type=client_credentials&client_id=" + clientID + "&client_secret=" + clientSecret);
webReq.downloadHandler = new DownloadHandlerBuffer();
NetworkUtil.ProcessWebRequest(
webReq,
(www) => {
if (www.error != null)
{
listener.OnFinish();
return;
}
var token = JsonUtility.FromJson <DeviantArtToken>(www.downloadHandler.text);
var webReq2 = new UnityWebRequest("https://www.deviantart.com/api/v1/oauth2/deviation/download/" + assetRef[1] + "?token=" + token.access_token);
webReq2.downloadHandler = new DownloadHandlerBuffer();
NetworkUtil.ProcessWebRequest(
webReq2,
(www2) => {
if (www2.error != null)
{
listener.OnFinish();
return;
}
var dl = JsonUtility.FromJson <DeviantArtDownload>(www2.downloadHandler.text);
NetworkUtil.ProcessWebRequest(UnityWebRequestTexture.GetTexture(dl.src), (www3) => {
if (www3.error != null)
{
listener.OnFinish();
return;
}
Debug.Log("Deviant art texture obtained.");
var texture = DownloadHandlerTexture.GetContent(www3);
listener.OnAssetContentObtained(texture, "");
listener.OnFinish();
});
});
}
);
}
}
/// <summary>
/// Downloads an image at the given URL and converts it to a Unity Texture2D.
/// </summary>
/// <param name="package">The package to set the icon on</param>
/// <param name="url">The URL of the image to download.</param>
private static IEnumerator DownloadAndSetIconRoutine(NugetPackage package, string url)
{
var stopwatch = new Stopwatch();
stopwatch.Start();
var fromCache = false;
if (ExistsInDiskCache(url))
{
url = "file:///" + GetFilePath(url);
fromCache = true;
}
Texture2D result = null;
using (var request = UnityWebRequestTexture.GetTexture(url, false))
{
const int timeout = 5;
request.timeout = timeout;
// Since we are handling coroutines by ourselves we can't yield return this directly
request.SendWebRequest();
while (!request.isDone && stopwatch.ElapsedMilliseconds < timeout * 1000)
{
yield return(null);
}
if (request.isDone && !request.isNetworkError && !request.isHttpError)
{
result = DownloadHandlerTexture.GetContent(request);
}
else if (!string.IsNullOrEmpty(request.error))
{
LogWarning($"Request {url} error after {stopwatch.ElapsedMilliseconds} ms: {request.error}");
}
else
{
LogWarning($"Request {url} timed out after {stopwatch.ElapsedMilliseconds} ms");
}
if (result != null && !fromCache)
{
CacheTextureOnDisk(url, request.downloadHandler.data);
}
}
package.Icon = result;
}
IEnumerator DownloadThumbnailFunc(YoutubeData videoData)
{
var url = videoData.snippet.thumbnails.mediumThumbnail.url;
var www = UnityWebRequestTexture.GetTexture(url);
yield return(www.SendWebRequest());
var tex = DownloadHandlerTexture.GetContent(www);
rawImage.texture = tex;
videoRT = new RenderTexture(tex.width, tex.height, 24);
youtube.unityVideoPlayer.targetTexture = videoRT;
GetComponent <AspectRatioFitter>().aspectRatio = (float)tex.width / tex.height;
}
public static WebRequestAsyncOperation FetchTexture(string textureURL, Action <Texture2D> OnSuccess, Action <UnityWebRequest> OnFail = null)
{
//NOTE(Brian): This closure is called when the download is a success.
void SuccessInternal(UnityWebRequest request)
{
var texture = DownloadHandlerTexture.GetContent(request);
OnSuccess?.Invoke(texture);
}
return(WebRequestController.i.GetTexture(
url: textureURL,
OnSuccess: SuccessInternal,
OnFail: OnFail));
}
public void DownloadImage(string url)
{
StartCoroutine(ImageRequest(url, (UnityWebRequest req) =>
{
if (req.isNetworkError || req.isHttpError)
{
Debug.Log($"{req.error}: {req.downloadHandler.text}");
}
else
{
Texture2D texture = DownloadHandlerTexture.GetContent(req);
image.sprite = Sprite.Create(texture, new Rect(0, 0, texture.width, texture.height), new Vector2(0.5f, 0.5f));
}
}));
}
public static IEnumerator DownloadSpriteAsync(string url, Action <Sprite> downloadCompleted)
{
using (UnityWebRequest www = UnityWebRequestTexture.GetTexture(url))
{
yield return(www.SendWebRequest());
if (www.isNetworkError || www.isHttpError)
{
Plugin.Log($"Http request error! {www.error}");
yield break;
}
Plugin.Log($"Success downloading \"{url}\"");
downloadCompleted?.Invoke(UIUtilities.LoadSpriteFromTexture(DownloadHandlerTexture.GetContent(www)));
}
}
//사용자 프로필 이미지 데이터 요청
IEnumerator UserProfile(string url)
{
UnityWebRequest ur = UnityWebRequestTexture.GetTexture(url);
yield return(ur.SendWebRequest());
if (ur.isNetworkError || ur.isHttpError)
{
Debug.Log(ur.error);
}
else
{
GameObject.Find("userImage").GetComponent <RawImage>().texture = DownloadHandlerTexture.GetContent(ur);
}
}
private async Task <Texture2D> FetchTexture(string laTeX)
{
try {
UnityWebRequest www = GeneratePutRequest(laTeX);
await www.SendWebRequest();
www = UnityWebRequestTexture.GetTexture(GetUrlFromResponse(www));
await www.SendWebRequest();
return(DownloadHandlerTexture.GetContent(www));
} catch (InvalidOperationException e) {
Debug.LogError(e);
return(await FetchTexture(laTeX));
}
}
IEnumerator LoadTexture(string path)
{
UnityWebRequest www = UnityWebRequestTexture.GetTexture("file://" + path);
yield return(www.SendWebRequest());
if (!www.isNetworkError)
{
// Get text content like this:
//myTe.LoadImage(www.downloadHandler.data);
myTe = DownloadHandlerTexture.GetContent(www);
myTe.Apply();
m_Renderer.material.mainTexture = myTe;
}
}
//서버로부터 이미지 데이터 요청
IEnumerator DownloadImage(string url, int num)
{
UnityWebRequest uwr = UnityWebRequestTexture.GetTexture(url);
yield return(uwr.SendWebRequest());
if (uwr.isNetworkError || uwr.isHttpError)
{
Debug.Log(uwr.error);
}
else
{
GameObject.Find("image" + num).GetComponent <RawImage>().texture = DownloadHandlerTexture.GetContent(uwr);
}
}
/// <summary>
/// Fetches the profile image of the user from the web
/// </summary>
/// <param name="user">The user whose profile image should be fetched</param>
/// <returns>The profile image of the given user</returns>
private static async Task <ApiResult <Texture2D> > FetchProfileImage(User user)
{
UnityWebRequest www = UnityWebRequestTexture.GetTexture(user.ProfileImageUrl);
await www.SendWebRequest();
if (www.isNetworkError || www.isHttpError)
{
if (www.GetResponseHeaders() == null)
{
return(new ApiResult <Texture2D>(0, "Device unavailable"));
}
return(new ApiResult <Texture2D>(www.responseCode, www.downloadHandler.text));
}
return(new ApiResult <Texture2D>(DownloadHandlerTexture.GetContent(www)));
}
public IEnumerator loadTextureFromInternet()
{
UnityWebRequest www = UnityWebRequestTexture.GetTexture("https://www.dropbox.com/s/dzxp63e3l4vg3s2/Screenshot%202019-11-16%20at%209.20.28%20PM.png?dl=1");
yield return(www.SendWebRequest());
if (www.isNetworkError || www.isHttpError)
{
Debug.Log("connection problem");
}
else
{
downloadableTexture = DownloadHandlerTexture.GetContent(www);
}
}
IEnumerator DownloadImage(string MediaUrl)
{
UnityWebRequest request = UnityWebRequestTexture.GetTexture(MediaUrl);
yield return(request.SendWebRequest());
if (request.isNetworkError || request.isHttpError)
{
Debug.Log(request.error);
}
else
{
texture = DownloadHandlerTexture.GetContent(request);
}
}
IEnumerator LoadSprite(string fileName)
{
var uri = new System.Uri(Path.Combine(Application.streamingAssetsPath, fileName));
UnityWebRequest wr = UnityWebRequestTexture.GetTexture(uri.AbsoluteUri);
yield return(wr.SendWebRequest());
while (!wr.isDone)
{
}
Texture2D tex = DownloadHandlerTexture.GetContent(wr);
Sprite s = Sprite.Create(tex, new Rect(0, 0, tex.width, tex.height),
new Vector2(0.5f, 0.5f));
//target.GetComponent<SpriteRenderer>().sprite = s;
}
IEnumerator Map()
{
lat = dataStream.get("latitude");
lon = dataStream.get("longitude");
url = "https://maps.googleapis.com/maps/api/staticmap?center=" + lat + "," + lon
+ "&markers=color:blue%7Clabel:A%7C" + lat + "," + lon
+ urlMarkers + "&zoom=" + zoom + urlEnding;
Debug.Log(url);
UnityWebRequest www = UnityWebRequestTexture.GetTexture(url);
yield return(www.SendWebRequest());
myRenderer = GetComponent <Renderer>();
myRenderer.material.mainTexture = DownloadHandlerTexture.GetContent(www);
}
IEnumerator GetTexture()
{
UnityWebRequest www = UnityWebRequestTexture.GetTexture(RecipeMenuList.SelectedRecipe.imgUrl);
yield return(www.SendWebRequest());
if (www.isNetworkError)
{
Debug.Log(www.error);
}
else
{
GameObject.Find("Recipe Photo").GetComponent <RawImage>().texture = DownloadHandlerTexture.GetContent(www);
}
}
IEnumerator GetTexture(string thisURL, GameObject currrentImage)
{
UnityWebRequest www = UnityWebRequestTexture.GetTexture(thisURL);
yield return(www.SendWebRequest());
if (www.isNetworkError)
{
UnityEngine.Debug.Log(www.error);
}
else
{
currrentImage.GetComponent <RawImage>().texture = DownloadHandlerTexture.GetContent(www);
}
}
