/// <summary>
/// Load game image from url. This should also be a clickable link to its url (non-image)
/// </summary>
IEnumerator LoadImageFromURL(string url, int index)
{
string fullURL = "https://www.vgchartz.com" + url;
UnityWebRequest link = UnityWebRequestTexture.GetTexture(fullURL);
yield return(link.SendWebRequest());
if (link.isNetworkError || link.isHttpError)
{
images[index].texture = defaultGame.texture;
Debug.LogError(link.error);
}
else
{
images[index].texture = ((DownloadHandlerTexture)link.downloadHandler).texture;
}
link.Dispose();
}
/// <summary>
/// 请求图片
/// </summary>
/// <param name="url">图片地址,like 'http://www.my-server.com/image.png '</param>
/// <param name="actionResult">请求发起后处理回调结果的委托,处理请求结果的图片</param>
/// <param name="actionProgress"></param>
/// <returns></returns>
public IEnumerator IE_GetTexture(string url, Action <Texture2D> actionResult)
{
using (uwr = UnityWebRequestTexture.GetTexture(url))
{
foreach (var header in headerPairs)
{
uwr.SetRequestHeader(header.Key, header.Value);
}
yield return(uwr.SendWebRequest());
if (uwr.result == UnityWebRequest.Result.Success)
{
actionResult?.Invoke(DownloadHandlerTexture.GetContent(uwr));
}
else
{
Debug.LogError($"[Error:Texture2D] {uwr.error}");
}
}
}
protected IEnumerator DownloadThumbnail(string thumbnailURI, RawImage graphic)
{
UnityWebRequest www = UnityWebRequestTexture.GetTexture(thumbnailURI);
yield return(www.SendWebRequest());
while (!www.isDone)
{
yield return(0);
}
if (www.error == null)
{
Texture2D texture = ((DownloadHandlerTexture)www.downloadHandler).texture;
graphic.texture = texture;
}
www.downloadHandler.Dispose();
www.Dispose();
}
public static IEnumerator GetTextureImage(string uri, OnTextureSuccess callback)
{
using (UnityWebRequest webRequest = UnityWebRequestTexture.GetTexture(uri))
{
yield return(webRequest.SendWebRequest());
if (webRequest.error != null || webRequest.isNetworkError)
{
Debug.LogError(uri + ": Error: " + webRequest.error);
}
else
{
Debug.Log("Got image successfully");
Texture2D myTexture = ((DownloadHandlerTexture)webRequest.downloadHandler).texture;
Debug.Log(myTexture);
Debug.Log(webRequest.downloadHandler.data[3550]);
callback(myTexture, webRequest.downloadHandler.data);
}
}
}
/// <summary>
/// Called as a Coroutine and queries the url. Expects an image as the query-result
/// When the image is downloaded, it is returned to the specified callback method
/// </summary>
/// <param name="url">The url to query</param>
/// <param name="callback">The callback method which receives the downloaded image</param>
/// <returns></returns>
IEnumerator GetWWWTexture(string url, System.Action <UnityWebRequest, Texture> callback)
{
UnityWebRequest req = UnityWebRequestTexture.GetTexture(url);
AddHeadersToRequest(req);
yield return(req.Send());
if (callback != null)
{
if (req.responseCode == 200)
{
callback(req, DownloadHandlerTexture.GetContent(req));
}
else
{
callback(req, null);
}
}
}
public IEnumerator LoadImage(string uri)
{
// Request and wait for the desired page.
UnityWebRequest webRequest = UnityWebRequestTexture.GetTexture(uri);
var asyncOperation = webRequest.SendWebRequest();
//Check progress of request
while (!webRequest.isDone)
{
progress = asyncOperation.progress;
yield return(null);
}
progress = 1f;
//Create texture from web image and assign it to RawImage on the label thumbnail
var texture = DownloadHandlerTexture.GetContent(webRequest);
gameObject.GetComponent <RawImage>().texture = texture;
}
IEnumerator GetTexture()
{
UnityWebRequest www = UnityWebRequestTexture.GetTexture("https://www.pngkit.com/png/full/4-43325_transparent-gavel-png-hammer-png.png");
yield return(www.SendWebRequest());
if (www.isNetworkError || www.isHttpError)
{
Debug.Log(www.error);
Debug.Log("WWW Error !!!");
}
else
{
Debug.Log("WWW Success !!!");
Texture2D myTexture = ((DownloadHandlerTexture)www.downloadHandler).texture;
SpriteRenderer srRend = gameObject.GetComponent <SpriteRenderer> ();
srRend.sprite = Sprite.Create(myTexture, srRend.sprite.rect, new Vector2(0, 0), 100);
}
}
private IEnumerator Download()
{
state = State.LOADING;
stateChanged = true;
UnityWebRequest www = UnityWebRequestTexture.GetTexture(url);
yield return(www.SendWebRequest());
if (www.isNetworkError || www.isHttpError)
{
state = State.ERROR;
stateChanged = true;
yield break;
}
state = State.READY;
stateChanged = true;
Texture2D texture = ((DownloadHandlerTexture)www.downloadHandler).texture;
sprite = Sprite.Create(texture, new Rect(0f, 0f, texture.width, texture.height), new Vector2(0f, 0f));
}
private IEnumerator LoadImage(string url)
{
using (UnityWebRequest www = UnityWebRequestTexture.GetTexture(url))
{
yield return(www.SendWebRequest());
if (www.isNetworkError || www.isHttpError)
{
Debug.Log(www.error);
}
else
{
var tex = DownloadHandlerTexture.GetContent(www);
Sprite shapeSprite = Sprite.Create((Texture2D)tex, new Rect(0f, 0f, tex.width, tex.height), new Vector2(0.5f, 0.5f), 100f);
_shapeImage.sprite = shapeSprite;
Destroy(_loadingSpinner.gameObject);
}
}
}
public IEnumerator GetAlbumArt(string filepath)
{
UnityWebRequest request = UnityWebRequestTexture.GetTexture(filepath);
yield return(request.SendWebRequest());
if (request.isNetworkError || request.isHttpError)
{
UnityEngine.Debug.Log(request.error);
}
else
{
Texture2D tex = ((DownloadHandlerTexture)request.downloadHandler).texture;
Sprite sprite = Sprite.Create(tex, new Rect(0, 0, tex.width, tex.height), new Vector2(tex.width / 2, tex.height / 2));
AlbumArtImg.GetComponent <Image>().overrideSprite = sprite;
AlbumArtImg.GetComponent <Image>().color = new Color32(255, 255, 255, 255);
artText.text = "";
}
yield break;
}
IEnumerator Start()
{
Debug.Log("Start");
yield return(new WaitForSeconds(2));
Debug.Log("BeginDownload");
var www = UnityWebRequestTexture.GetTexture("https://static.pexels.com/photos/236047/pexels-photo-236047.jpeg");
yield return(www.SendWebRequest());
Debug.Log("EndDownload");
Profiler.BeginSample("Texture");
//tex = new Texture2D(2, 2);
var texture = DownloadHandlerTexture.GetContent(www);
//www.LoadImageIntoTexture(tex);
Profiler.EndSample();
}
IEnumerator GetImage()
{
string path = root + "?id=" + index + "&side=" + side;
Debug.Log("Getting image side " + side + " path = " + path);
UnityWebRequest www = UnityWebRequestTexture.GetTexture(path);
yield return(www.SendWebRequest());
if (www.isNetworkError || www.isHttpError)
{
Debug.Log(www.error);
}
else
{
Texture myTexture = ((DownloadHandlerTexture)www.downloadHandler).texture;
display.sprite = Sprite.Create((Texture2D)myTexture, new Rect(0, 0, 512, 512), new Vector2());
}
}
private UnityWebRequest Request(DownloadFileType fileType, string url)
{
switch (fileType)
{
case DownloadFileType.Image:
return(UnityWebRequestTexture.GetTexture(url));
case DownloadFileType.Audio:
#if UNITY_EDITOR && UNITY_STANDALONE
return(UnityWebRequest.Get(url));
#else
return(UnityWebRequestMultimedia.GetAudioClip(url, DetectAudioType(url)));
#endif
case DownloadFileType.Bundle:
return(UnityWebRequestAssetBundle.GetAssetBundle(url));
default:
return(UnityWebRequest.Get(url));
}
}
private IEnumerator LoadSpriteAsync(string imagePath, Action <Sprite, bool> callback)
{
var www = UnityWebRequestTexture.GetTexture(GetImageUri(imagePath));
yield return(www.SendWebRequest());
if (www.isNetworkError || www.isHttpError)
{
Debug.Log(www.error);
callback?.Invoke(null, false);
}
else
{
Debug.Log("Image succesfully loaded");
var t = ((DownloadHandlerTexture)www.downloadHandler).texture;
var sprite = Sprite.Create(t, new Rect(0, 0, t.width, t.height), new Vector2(0, 0));
RegisterSprite(imagePath, sprite);
callback?.Invoke(sprite, true);
}
}
private IEnumerator LoadAvatar(string id, string avatarID)
{
UnityWebRequest avatarURL = UnityWebRequestTexture.GetTexture($"https://cdn.discordapp.com/avatars/{id}/{avatarID}.png");
yield return(avatarURL.SendWebRequest());
avatar = ((DownloadHandlerTexture)avatarURL.downloadHandler).texture;
if (avatar == null || avatar.height < 128)
{
UnityWebRequest standardAvatarURL = UnityWebRequestTexture.GetTexture("https://discordapp.com/assets/6debd47ed13483642cf09e832ed0bc1b.png");
yield return(standardAvatarURL.SendWebRequest());
avatar = ((DownloadHandlerTexture)standardAvatarURL.downloadHandler).texture;
}
TextureScaler.Scale(avatar, 64, 64);
yield return(null);
}
private IEnumerator DownloadImage(string url, Action <Texture2D> callback)
{
using (UnityWebRequest request = UnityWebRequestTexture.GetTexture(url))
{
yield return(request.Send());
if (request.isNetworkError)
{
Debug.LogError("netowrk problem: " + request.error);
}
else if (request.responseCode != (long)System.Net.HttpStatusCode.OK)
{
Debug.LogError("response error: " + request.responseCode);
}
else
{
callback(DownloadHandlerTexture.GetContent(request));
}
}
}
public async UniTask <Texture> LoadTextureAsync(string url)
{
Debug.Log($"<color=yellow>Load start : {url}</color>");
var request = UnityWebRequestTexture.GetTexture($"{url}");
await request.SendWebRequest();
if (request.isNetworkError || request.isHttpError)
{
Debug.LogError(request.error);
return(null);
}
else
{
Texture tex = DownloadHandlerTexture.GetContent(request);
tex.name = Path.GetFileNameWithoutExtension(url);
return(tex);
}
}
internal static void LoadTexture(
string accessToken,
string hash,
Action <Texture2D> success = null,
Action <ErrorMessage> error = null)
{
var url = string.Format(FILE_LOAD_URL, hash);
var request = UnityWebRequestTexture.GetTexture(url);
request.SetAccessToken(accessToken);
void Success()
{
var texture = DownloadHandlerTexture.GetContent(request);
success?.Invoke(texture);
}
request.Request(Success, error);
}
private IEnumerator DownloadImage(string imageUrl, bool isHeader)
{
UnityWebRequest request = UnityWebRequestTexture.GetTexture(imageUrl);
var image = isHeader ? headerImage : posterImage;
yield return(request.SendWebRequest());
if (request.isNetworkError || request.isHttpError)
{
Debug.Log(request.error);
}
else
{
var texture = ((DownloadHandlerTexture)request.downloadHandler).texture;
image.sprite = Sprite.Create(texture, new Rect(0, 0, texture.width, texture.height),
image.rectTransform.pivot, image.pixelsPerUnit);
image.gameObject.SetActive(true);
}
}
/// <summary>
/// Load the image from path/url in runtime.
/// </summary>
/// <param name="url"> Url to the target image file. </param>
/// <param name="callback"> Callback after the image is loaded. </param>
/// <returns> Coroutine status. </returns>
public static IEnumerator LoadImage(string url, ImageLoaded callback)
{
#if UNITY_2018_1_OR_NEWER
UnityWebRequest request = UnityWebRequestTexture.GetTexture(url);
yield return(request.SendWebRequest());
Texture2D tex = ((DownloadHandlerTexture)request.downloadHandler).texture;
#else
WWW request = new WWW(url);
yield return(request);
Texture2D tex = new Texture2D(4, 4, TextureFormat.DXT1, false);
request.LoadImageIntoTexture(tex);
#endif
if (callback != null)
{
callback.Invoke(tex);
}
}
private IEnumerator UpdateImageFromStream(string url)
{
using (UnityWebRequest uwr = UnityWebRequestTexture.GetTexture(url))
{
yield return(uwr.SendWebRequest());
Debug.Log("Let's go");
if (uwr.isNetworkError || uwr.isHttpError)
{
Debug.Log(uwr.error);
}
else
{
// Get downloaded asset bundle
_mesh.material.mainTexture = DownloadHandlerTexture.GetContent(uwr);
Debug.Log("DONE");
}
}
}
IEnumerator DisplayWatsonImage()
{
UnityWebRequest www = UnityWebRequestTexture.GetTexture(imageURL);
yield return(www.SendWebRequest());
if (www.isNetworkError || www.isHttpError)
{
Debug.Log(www.error);
}
else
{
watsonMediaViewer.texture = ((DownloadHandlerTexture)www.downloadHandler).texture;
}
if (imageWatsonDisplayed == false)
{
watsonMediaViewer.GetComponent <Animator>().Play("FadeToOne");
imageWatsonDisplayed = true;
}
}
/// <summary>
/// Downloads texture (player icon) from URL
/// </summary>
public IEnumerator LoadImage(Players player, Action <Players, Texture2D> OnCompleteCallback)
{
UnityWebRequest www = UnityWebRequestTexture.GetTexture(player.Icon);
yield return(www.SendWebRequest());
if (www.isNetworkError || www.isHttpError)
{
Debug.Log("Load Image: " + www.error);
}
else
{
Texture2D texture = new Texture2D(1, 1);
texture = ((DownloadHandlerTexture)www.downloadHandler).texture;
if (OnCompleteCallback != null)
{
OnCompleteCallback(player, texture);
}
}
}
private IEnumerator GetTexture(string uri, float startTime)
{
var www = UnityWebRequestTexture.GetTexture(uri);
yield return(www.SendWebRequest());
if (www.isNetworkError || www.isHttpError)
{
Debug.Log(www.error);
}
else
{
var myTexture = ((DownloadHandlerTexture)www.downloadHandler).texture;
image.sprite = Sprite.Create(myTexture, new Rect(0.0f, 0.0f, myTexture.width, myTexture.height),
new Vector2(0.5f, 0.5f), 100.0f);
}
ChangeMessageColor(Color.green);
displayText.text = "Finished Processing in " + (Time.time - startTime) + " seconds";
}
private IEnumerator RetrieveImage()
{
using (UnityWebRequest uwr = UnityWebRequestTexture.GetTexture(url, false))
{
yield return(uwr.SendWebRequest());
yield return(uwr.isDone);
if (uwr.isNetworkError || uwr.isHttpError)
{
Debug.LogErrorFormat("Unable to load image from {0} for reason {1}", url, uwr.error);
}
else
{
imageDisplay.texture = DownloadHandlerTexture.GetContent(uwr);
SwitchIndicator(false);
imageDisplay.SizeToParent();
}
}
}
private IEnumerator LoadImage(string path, MeshRenderer output)
{
var url = "file://" + path;
var unityWebRequestTexture = UnityWebRequestTexture.GetTexture(url);
yield return(unityWebRequestTexture.SendWebRequest());
var texture = ((DownloadHandlerTexture)unityWebRequestTexture.downloadHandler).texture;
if (texture == null)
{
Debug.LogError("Failed to load texture url:" + url);
}
output.material.mainTexture = texture;
var mySprite = Sprite.Create(texture, new Rect(0.0f, 0.0f, texture.width, texture.height), new Vector2(0.5f, 0.5f), 100.0f);
imageCube.transform.rotation = Quaternion.Euler(0, 0, 180);
photoButton.gameObject.GetComponent <Image>().sprite = mySprite;
}
private IEnumerator LoadImage(string url)
{
using (UnityWebRequest www = UnityWebRequestTexture.GetTexture(url)) {
www.SendWebRequest();
while (!www.isDone)
{
yield return(null);
}
if (!www.isNetworkError)
{
_camera = null;
Texture2D texture = DownloadHandlerTexture.GetContent(www);
Canvas.ForceUpdateCanvases();
yield return(0);
_image.gameObject.SetActive(true);
SetImageTexture(texture);
}
}
}
IEnumerator LoadTexture()
{
var filePath = "file://" + Path.Combine(Application.persistentDataPath, newFilename);
Debug.Log("filePath = " + filePath);
UnityWebRequest uwr = UnityWebRequestTexture.GetTexture(filePath);
yield return(uwr.SendWebRequest());
if (uwr.isNetworkError || uwr.isHttpError)
{
Debug.Log(uwr.error);
}
else
{
Texture texture = ((DownloadHandlerTexture)uwr.downloadHandler).texture;
photoRawImage.texture = texture;
Debug.Log("Texture should load now.");
}
}
IEnumerator TextureLoader()
{
//create post web request
UnityWebRequest webRequest = UnityWebRequestTexture.GetTexture(mData.avatar);
//calling and wait for response
yield return(webRequest.SendWebRequest());
//check for if any error occurred
if (webRequest.isNetworkError || webRequest.isHttpError)
{
Debug.LogError(webRequest.error);
}
else
{
Texture myTexture = ((DownloadHandlerTexture)webRequest.downloadHandler).texture;
profilePic.texture = myTexture;
profilePic.color = Color.white;
}
}
private static IEnumerator RequestTexture(int index, string url, Action <int, Texture2D> callback = null)
{
using (UnityWebRequest request = UnityWebRequestTexture.GetTexture(url))
{
yield return(request.SendWebRequest());
if (request.isNetworkError || request.isHttpError)
{
Debug.Log(request.error);
}
else
{
Texture2D texture = DownloadHandlerTexture.GetContent(request);
if (texture != null)
{
callback?.Invoke(index, texture);
}
}
}
}
