Examples/GettingStarted/GettingStarted.cs

using Astra.Asset;
using Astra.Core;
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.UI;
 
namespace Astra.Examples
{
    public class GettingStarted : MonoBehaviour
    {
 
        public Button ButtonInitialize;
 
        public Text InitializeText;
 
        public Text AvatarText;
 
        public Button ButtonSearchAvatars;
 
        public Button ButtonSearchFigures;
 
        public Button ButtonSearchCloth;
 
        public Button ButtonSearchDecals;
 
        public Button ButtonSearchMorphable;
 
        public Text LastSearchAssetsText;
 
        public Button ButtonLoadNextAsset;
 
        public Text LoadNextAssetText;
 
        public Button ButtonLoadNextAvatar;
 
        public Text AvatarLoadText;
 
 
        public Button ButtonClearItems;
 
        public TextAsset AppConfig;
 
        public Helpers.ProgressBar ProgressBar;
 
        private GameObject _rootGO;
        private AvatarItem _avatarItem;
 
        private List<CatalogEntry> _avatarList = null;
        private List<CatalogEntry> _lastAssetSearch = null;
        private int _assetIndex = 0;
 
        private int _avatarIndex = 0;
 
        private string _assetSearchType;
 
        // Use this for initialization
        void Start()
        {
            //Link up our buttons with their triggers
            BindEvents();
        }
 
        #region event management
 
        protected void BindEvents()
        {
            ButtonInitialize.onClick.AddListener(HandleButtonInitialize);
            ButtonSearchAvatars.onClick.AddListener(HandleButtonSearchAvatars);
            ButtonSearchFigures.onClick.AddListener(HandleButtonSearchFigures);
            ButtonLoadNextAsset.onClick.AddListener(HandleButtonLoadNextAsset);
            ButtonSearchCloth.onClick.AddListener(HandleButtonSearchCloth);
            ButtonSearchDecals.onClick.AddListener(HandleButtonSearchDecals);
            ButtonSearchMorphable.onClick.AddListener(HandleButtonSearchMorphables);
            ButtonLoadNextAvatar.onClick.AddListener(HandleButtonLoadNextAvatar);
            ButtonClearItems.onClick.AddListener(HandleButtonClearItems);
        }
 
        private void HandleButtonInitialize()
        {
            InitializeText.text = "Initializing...";
 
            StartCoroutine(InitializeCoroutine());
        }
 
        private IEnumerator InitializeCoroutine()
        {
            AstraManager.StartupAstra();
            yield return AstraManager.WaitForInit();
 
            Configuration.ProjectConfigError error = Configuration.ProjectConfigError.Success;
            yield return Configuration.Initialize(AppConfig).AsCoroutine(null, null, e => error = e);
 
            if (error == Configuration.ProjectConfigError.Success)
            {
                InitializeText.text = "Initialized";
            }
            else
            {
                InitializeText.text = "Init Failed: " + error.ToString();
            }
        }
 
        private void HandleButtonSearchAvatars()
        {
            AvatarText.text = "Searching...";
            StartCoroutine(Catalog.GetAvatars().AsCoroutine(CallbackProgress,
                // Callback when the avatar list is loaded
                (avatarList) =>
                {
                    _avatarList = avatarList;
                    Astra.Logger.Log("Found: " + avatarList.Count);
                    AvatarText.text = avatarList.Count + " Avatars";
                },
                CallbackCatalogError));
        }
 
        private void HandleButtonSearchFigures()
        {
            LastSearchAssetsText.text = "Searching for figures...";
            _assetSearchType = "Figure";
 
            StartCoroutine(Catalog.SearchForFigures(_avatarItem).AsCoroutine(CallbackProgress, CallbackAssetListLoaded, CallbackCatalogError));
        }
 
        private void HandleButtonSearchCloth()
        {
            LastSearchAssetsText.text = "Searching for clothing...";
            _assetSearchType = "Clothing";
 
            StartCoroutine(Catalog.SearchForClothing(_avatarItem, null).AsCoroutine(CallbackProgress, CallbackAssetListLoaded, CallbackCatalogError));
        }
 
        private void HandleButtonSearchDecals()
        {
            LastSearchAssetsText.text = "Searching for decals...";
            _assetSearchType = "Decal";
 
            StartCoroutine(Catalog.SearchForDecals(_avatarItem, null).AsCoroutine(CallbackProgress, CallbackAssetListLoaded, CallbackCatalogError));
        }
 
        private void HandleButtonSearchMorphables()
        {
            LastSearchAssetsText.text = "Searching for morphs...";
            _assetSearchType = "Morph";
 
            StartCoroutine(Catalog.SearchForMorphables(_avatarItem).AsCoroutine(CallbackProgress, CallbackAssetListLoaded, CallbackCatalogError));
        }
 
        private void HandleButtonLoadNextAsset()
        {
            LoadNextAssetText.text = "Loading...";
 
            if (_lastAssetSearch == null || _lastAssetSearch.Count <= 0)
            {
                LoadNextAssetText.text = "No assets to load";
                return;
            }
 
            if (_assetIndex >= _lastAssetSearch.Count)
            {
                _assetIndex = 0;
            }
 
            ButtonLoadNextAsset.enabled = false;
 
            var catalogEntry = _lastAssetSearch[_assetIndex];
 
            LoadNextAssetText.text = "Loading: " + catalogEntry.Name;
            StartCoroutine(_avatarItem.ApplyAsset(catalogEntry).AsCoroutine(CallbackProgress,
                () =>
                {
                    LoadNextAssetText.text = "Loaded: " + catalogEntry.Name;
                    ButtonLoadNextAsset.enabled = true;
                },
                () => { Astra.Logger.LogError("Failed to load asset: " + catalogEntry.Name); }));
 
            _assetIndex++;
        }
 
        private void HandleButtonLoadNextAvatar()
        {
            if (_avatarList == null || _avatarList.Count <= 0)
            {
                Astra.Logger.LogWarning("No app avatars found, make sure you search them first");
            }
 
            if (_avatarIndex >= _avatarList.Count)
            {
                _avatarIndex = 0;
            }
 
            var guid = _avatarList[_avatarIndex].Guid;
            Astra.Logger.Log("Loading avatar: " + guid);
            AvatarLoadText.text = "Loading: " + guid;
 
            StartCoroutine(Loader.LoadAvatar(guid).AsCoroutine(CallbackProgress,
                (avatarItem) => {
                    Astra.Logger.Log("Avatar loaded");
                    AvatarLoadText.text = "Loaded: " + guid;
                    _avatarItem = avatarItem;
 
                    if (_rootGO != null)
                    {
                        GameObject.Destroy(_rootGO);
                    }
                    _rootGO = _avatarItem.gameObject;
                },
                (error) => { Astra.Logger.LogError("Failed loading avatar: " + error); }));
 
            _avatarIndex++;
        }
 
        private void HandleButtonClearItems()
        {
            if (_avatarItem == null)
            {
                Astra.Logger.LogError("You need an avatar to use this");
                return;
            }
 
            _avatarItem.RemoveAllItems();
        }
 
        #endregion
 
        #region callbacks
 
        private void CallbackProgress(float progress)
        {
            ProgressBar.UpdatePercent(progress);
        }
 
        private void CallbackCatalogError(Catalog.CatalogError catalogError)
        {
            Astra.Logger.LogError("Error when fetching assets: " + catalogError.ToString());
        }
 
        private void CallbackAssetListLoaded(List<CatalogEntry> assetList)
        {
            _lastAssetSearch = assetList;
            var logMessage = "Found: " + assetList.Count + " " + _assetSearchType + " assets";
            Astra.Logger.Log(logMessage);
            LastSearchAssetsText.text = logMessage;
        }
 
 
        #endregion
    }
}