public void Init()
{
if (isInit)
{
return;
}
isInit = true;
InitGameObjects();
HUDConfiguration hudConfig = new HUDConfiguration();
hudConfig.active = true;
hudConfig.visible = false;
HUDController.i.CreateHudElement <BuildModeHUDController>(hudConfig, HUDController.HUDElementID.BUILDER_IN_WORLD_MAIN);
HUDController.i.CreateHudElement <BuilderInWorldInititalHUDController>(hudConfig, HUDController.HUDElementID.BUILDER_IN_WORLD_INITIAL);
HUDController.i.builderInWorldMainHud.Initialize();
HUDController.i.builderInWorldInititalHud.OnEnterEditMode += TryStartEnterEditMode;
HUDController.i.builderInWorldMainHud.OnTutorialAction += StartTutorial;
HUDController.i.builderInWorldMainHud.OnLogoutAction += ExitEditMode;
ConfigureLoadingController();
InitControllers();
CommonScriptableObjects.builderInWorldNotNecessaryUIVisibilityStatus.Set(true);
catalogAsyncOp = BuilderInWorldUtils.MakeGetCall(BuilderInWorldSettings.BASE_URL_ASSETS_PACK, CatalogReceived);
isCatalogLoading = true;
BuilderInWorldNFTController.i.Initialize();
BuilderInWorldNFTController.i.OnNFTUsageChange += OnNFTUsageChange;
}
void LoadAsset()
{
if (!string.IsNullOrEmpty(OBJUrl))
{
Destroy(loadedOBJGameObject);
asyncOp = Environment.i.platform.webRequest.Get(
url: OBJUrl,
OnSuccess: (webRequestResult) =>
{
loadedOBJGameObject = OBJLoader.LoadOBJFile(webRequestResult.downloadHandler.text, true);
loadedOBJGameObject.name = "LoadedOBJ";
loadedOBJGameObject.transform.SetParent(transform);
loadedOBJGameObject.transform.localPosition = Vector3.zero;
OnFinishedLoadingAsset?.Invoke();
alreadyLoadedAsset = true;
},
OnFail: (webRequestResult) =>
{
Debug.Log("Couldn't get OBJ, error: " + webRequestResult.error + " ... " + OBJUrl);
});
}
else
{
Debug.Log("couldn't load OBJ because url is empty");
}
if (loadingPlaceholder != null)
{
loadingPlaceholder.SetActive(false);
}
}
IEnumerator Fetch()
{
bool shouldRetry = true;
int retryCount = 0;
string url = API_URL_ASSETS + assetContractAddress;
do
{
if (OpenSeaRequestController.VERBOSE)
{
Debug.Log($"RequestGroup: Request to OpenSea {url}");
}
// NOTE(Santi): In this case, as this code is implementing a very specific retries system (including delays), we use our
// custom WebRequest system without retries (requestAttemps = 1) and let the current code to apply the retries.
WebRequestAsyncOperation requestOp = WebRequestController.i.Get(url: url, requestAttemps: 1, disposeOnCompleted: false);
yield return(requestOp);
AssetsResponse response = null;
if (requestOp.isSucceded)
{
response = Utils.FromJsonWithNulls <AssetsResponse>(requestOp.webRequest.downloadHandler.text);
}
if (OpenSeaRequestController.VERBOSE)
{
Debug.Log($"RequestGroup: Request resolving {response != null} {requestOp.webRequest.error} {url}");
}
if (response != null)
{
shouldRetry = false;
OnSuccess?.Invoke(response);
requestOp.Dispose();
}
else
{
shouldRetry = retryCount < REQUEST_RETRIES;
if (!shouldRetry)
{
OnError?.Invoke("Error " + requestOp.webRequest.downloadHandler.text);
requestOp.Dispose();
}
else
{
retryCount++;
if (OpenSeaRequestController.VERBOSE)
{
Debug.Log($"RequestGroup: Request retrying {url}");
}
yield return(new WaitForSeconds(GetRetryDelay()));
requestOp.Dispose();
}
}
} while (shouldRetry);
}
private IEnumerator UniGifProcessorLoad(string url, Action<GifFrameData[]> OnSuccess, Action OnFail)
{
webRequestOp = DCL.Environment.i.platform.webRequest.Get(url: url, disposeOnCompleted: false);
yield return webRequestOp;
if (webRequestOp.isSucceded)
{
var bytes = webRequestOp.webRequest.downloadHandler.data;
yield return UniGif.GetTextureListCoroutine(bytes,
(frames, loopCount, width, height) =>
{
if (frames != null)
{
OnSuccess?.Invoke(frames);
}
else
{
OnFail?.Invoke();
}
});
}
else
{
OnFail?.Invoke();
}
webRequestOp.Dispose();
}
private IEnumerator CreateHTTPRequest(string rootUri, string httpRequestPath)
{
string finalUrl = httpRequestPath;
if (!string.IsNullOrEmpty(rootUri))
{
finalUrl = Path.Combine(rootUri, httpRequestPath);
}
WebRequestAsyncOperation asyncOp = webRequestController.Get(
url: finalUrl,
downloadHandler: new DownloadHandlerBuffer(),
timeout: 5000,
disposeOnCompleted: false);
yield return(asyncOp);
if (!asyncOp.isSucceded)
{
Debug.LogError($"{asyncOp.webRequest.error} - {finalUrl}");
yield break;
}
if (asyncOp.webRequest.downloadedBytes > int.MaxValue)
{
Debug.LogError("Stream is too big for a byte array");
yield break;
}
if (asyncOp.webRequest.downloadHandler.data == null)
{
yield break;
}
//NOTE(Brian): Caution, webRequestResult.downloadHandler.data returns a COPY of the data, if accessed twice,
// 2 copies will be performed for the entire file (and then discarded by GC, introducing hiccups).
// The correct fix is by using DownloadHandler.ReceiveData. But this is in version > 2019.3.
byte[] data = asyncOp.webRequest.downloadHandler.data;
if (data != null)
{
LoadedStream = new MemoryStream(data, 0, data.Length, true, true);
}
asyncOp.Dispose();
}
private void GetCatalog()
{
if (catalogAdded)
{
return;
}
if (areCatalogHeadersReady)
{
catalogAsyncOp = BIWUtils.MakeGetCall(BIWUrlUtils.GetUrlCatalog(), CatalogReceived, catalogCallHeaders);
}
else
{
builderInWorldBridge.AskKernelForCatalogHeaders();
}
isCatalogRequested = true;
}
private void FetchScenePreviewImage(string previewImageUrl)
{
if (string.IsNullOrEmpty(previewImageUrl))
{
return;
}
spinnerImage.SetActive(true);
fetchParcelImageOp = Utils.FetchTexture(previewImageUrl, (texture) =>
{
downloadedBanner = texture;
imageSceneThumbnail.texture = texture;
RectTransform rt = (RectTransform)imageSceneThumbnail.transform.parent;
float h = rt.rect.height;
float w = h * (texture.width / (float)texture.height);
imageSceneThumbnail.rectTransform.sizeDelta = new Vector2(w, h);
spinnerImage.SetActive(false);
imageSceneThumbnail.gameObject.SetActive(true);
});
}
private void SendRequest(IRequestHandler requestHandler)
{
string url = requestHandler.GetUrl();
if (VERBOSE)
{
Debug.Log($"RequestController: Send Request: {url}");
}
// NOTE: In this case, as this code is implementing a very specific retries system (including delays), we use our
// custom WebRequest system without retries (requestAttemps = 1) and let the current code to apply the retries.
WebRequestAsyncOperation asyncOp = Environment.i.platform.webRequest.Get(url, requestAttemps: 1, disposeOnCompleted: true);
asyncOp.completed += operation =>
{
UnityWebRequest unityWebRequest = operation.webRequest;
bool shouldTryToRetry = true;
string serverResponse = unityWebRequest.downloadHandler.text;
if (VERBOSE)
{
Debug.Log($"RequestController: Request completed: success? {unityWebRequest.result == UnityWebRequest.Result.Success} {serverResponse}");
}
if (unityWebRequest.result == UnityWebRequest.Result.Success)
{
requestHandler.SetApiResponse(serverResponse,
() =>
{
if (VERBOSE)
{
Debug.Log($"RequestController: Request Succeeded: {url}");
}
shouldTryToRetry = false;
},
error =>
{
serverResponse = $"RequestController: Parse Request Error: {url}: {error}";
if (VERBOSE)
{
Debug.Log(serverResponse);
}
});
}
if (shouldTryToRetry)
{
if (requestHandler.CanRetry())
{
requestHandler.Retry();
}
else
{
requestHandler.SetApiResponseError(serverResponse);
}
}
unityWebRequest.Dispose();
};
}
IEnumerator Fetch(float delayRequest)
{
yield return(new WaitForSeconds(delayRequest));
CloseGroup();
bool shouldRetry = false;
int retryCount = 0;
string url = API_URL_ASSETS + requestUrl;
do
{
if (OpenSeaRequestController.VERBOSE)
{
Debug.Log($"RequestGroup: Request to OpenSea {url}");
}
// NOTE(Santi): In this case, as this code is implementing a very specific retries system (including delays), we use our
// custom WebRequest system without retries (requestAttemps = 1) and let the current code to apply the retries.
WebRequestAsyncOperation asyncOp = WebRequestController.i.Get(url: url, requestAttemps: 1, disposeOnCompleted: false);
yield return(asyncOp);
AssetsResponse response = null;
if (asyncOp.isSucceded)
{
response = Utils.FromJsonWithNulls <AssetsResponse>(asyncOp.webRequest.downloadHandler.text);
}
if (OpenSeaRequestController.VERBOSE)
{
Debug.Log($"RequestGroup: Request resolving {response != null} {asyncOp.webRequest.error} {url}");
}
if (response != null)
{
shouldRetry = false;
//if we have one element in the group, is the one failing and we dont group it again
if (response.assets.Length != 0 || requests.Count <= 1)
{
using (var iterator = requests.GetEnumerator())
{
while (iterator.MoveNext())
{
iterator.Current.Value.Resolve(response);
}
}
}
else
{
//There are invalids NFTs to fetch, we split the request into 2 smaller groups to find the ofender
SplitGroup();
}
asyncOp.Dispose();
}
else
{
shouldRetry = retryCount < REQUEST_RETRIES;
if (!shouldRetry)
{
using (var iterator = requests.GetEnumerator())
{
while (iterator.MoveNext())
{
iterator.Current.Value.Resolve(asyncOp.webRequest.error);
}
}
asyncOp.Dispose();
}
else
{
retryCount++;
if (OpenSeaRequestController.VERBOSE)
{
Debug.Log($"RequestGroup: Request retrying {url}");
}
asyncOp.Dispose();
yield return(new WaitForSeconds(GetRetryDelay()));
}
}
} while (shouldRetry);
}
