CesiumCreditSystem.cs

Go to the documentation of this file.

using Reinterop;
using System;
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.SceneManagement;
using UnityEngine.Networking;
 
#if UNITY_EDITOR
using UnityEditor.SceneManagement;
using UnityEditor;
#endif
 
namespace CesiumForUnity
{
    internal class CesiumCreditComponent
    {
        private string _text;
        private string _link;
        private int _imageId = -1;

        public string text
        {
            get => this._text;
        }

        public string link
        {
            get => this._link;
        }

        public int imageId
        {
            get => this._imageId;
        }
 
        public CesiumCreditComponent(string text, string link, int imageId)
        {
            this._text = text;
            this._link = link;
            this._imageId = imageId;
        }
    }

    internal class CesiumCredit
    {
        private List<CesiumCreditComponent> _components;

        public List<CesiumCreditComponent> components
        {
            get => this._components;
        }
 
        public CesiumCredit() : this(new List<CesiumCreditComponent>())
        { }
 
        public CesiumCredit(List<CesiumCreditComponent> components)
        {
            this._components = components;
        }
    }

    [ExecuteInEditMode]
    [ReinteropNativeImplementation("CesiumForUnityNative::CesiumCreditSystemImpl", "CesiumCreditSystemImpl.h")]
    [AddComponentMenu("Cesium/Cesium Credit System")]
    [IconAttribute("Packages/com.cesium.unity/Editor/Resources/Cesium-24x24.png")]
    public partial class CesiumCreditSystem : MonoBehaviour
    {
        private static CesiumCreditSystem _defaultCreditSystem;
 
        private List<CesiumCredit> _onScreenCredits = new List<CesiumCredit>();
        private List<CesiumCredit> _popupCredits = new List<CesiumCredit>();
        private List<Texture2D> _images = new List<Texture2D>();
        private int _numLoadingImages = 0;
 
        const string base64Prefix = "data:image/png;base64,";
        const string creditSystemPrefabName = "CesiumCreditSystem";
        const string defaultName = "CesiumCreditSystemDefault";
 
        #region Fields and Events
        internal List<CesiumCredit> onScreenCredits
        {
            get => this._onScreenCredits;
        }

        internal List<CesiumCredit> popupCredits
        {
            get => this._popupCredits;
        }

        internal List<Texture2D> images
        {
            get => this._images;
        }

        internal delegate void CreditsUpdateDelegate(List<CesiumCredit> onScreenCredits, List<CesiumCredit> onPopupCredits);

        internal event CreditsUpdateDelegate OnCreditsUpdate;
        #endregion
 
        #region Unity Messages
 
        private void OnEnable()
        {
            this._onScreenCredits.Clear();
            this._popupCredits.Clear();
            this.ClearImages();
 
            Cesium3DTileset.OnSetShowCreditsOnScreen += this.ForceUpdateCredits;
        }
 
        private void Update()
        {
            this.UpdateCredits(false);
        }
 
        private void OnDisable()
        {
            this._onScreenCredits.Clear();
            this._popupCredits.Clear();
            this.ClearImages();
 
            Cesium3DTileset.OnSetShowCreditsOnScreen -= this.ForceUpdateCredits;
        }
 
        private void OnDestroy()
        {
            if (this == _defaultCreditSystem)
            {
                _defaultCreditSystem = null;
            }
        }

        private void OnApplicationQuit()
        {
            UnityLifetime.Destroy(this.gameObject);
        }
        #endregion

        private void ForceUpdateCredits()
        {
            this.UpdateCredits(true);
        }

        private partial void UpdateCredits(bool forceUpdate);
 
        internal void BroadcastCreditsUpdate()
        {
            if (this.OnCreditsUpdate != null)
            {
                this.OnCreditsUpdate(this._onScreenCredits, this._popupCredits);
            }
        }

        private static CesiumCreditSystem CreateDefaultCreditSystem()
        {
            GameObject creditSystemPrefab = Resources.Load<GameObject>(creditSystemPrefabName);
            GameObject creditSystemGameObject = UnityEngine.Object.Instantiate(creditSystemPrefab);
            creditSystemGameObject.name = defaultName;
            creditSystemGameObject.hideFlags = HideFlags.HideAndDontSave;
 
            return creditSystemGameObject.GetComponent<CesiumCreditSystem>();
        }

        public static CesiumCreditSystem GetDefaultCreditSystem()
        {
            if (_defaultCreditSystem == null)
            {
                CesiumCreditSystem[] creditSystems = Resources.FindObjectsOfTypeAll<CesiumCreditSystem>();
                for (int i = 0; i < creditSystems.Length; i++)
                {
                    if (creditSystems[i].gameObject.name == defaultName)
                    {
                        _defaultCreditSystem = creditSystems[i];
                        break;
                    }
                }
            }
 
            if (_defaultCreditSystem == null)
            {
                _defaultCreditSystem = CreateDefaultCreditSystem();
            }
 
            return _defaultCreditSystem;
        }

        internal int GetNumberOfLoadingImages()
        {
            return this._numLoadingImages;
        }

        internal IEnumerator LoadImage(string url)
        {
            int index = this._images.Count;
            this._numLoadingImages++;
 
            // Initialize a texture of arbitrary size as a placeholder,
            // so that when other images are loaded, their IDs align properly
            // with the current list of images.
            Texture2D texture = new Texture2D(1, 1);
            this._images.Add(texture);
 
            if (url.LastIndexOf(base64Prefix, base64Prefix.Length) == 0)
            {
                // Load an image from a string that contains the
                // "data:image/png;base64," prefix
                string byteString = url.Substring(base64Prefix.Length);
                try
                {
                    byte[] bytes = Convert.FromBase64String(byteString);
                    if (!texture.LoadImage(bytes))
                    {
                        Debug.Log("Credit image could not be loaded into Texture2D.");
                    }
                }
                catch (FormatException)
                {
                    Debug.Log("Could not parse credit image from base64 string.");
                }
            }
            else
            {
                // Load an image from a URL.
                UnityWebRequest request = UnityWebRequestTexture.GetTexture(url);
                yield return request.SendWebRequest();
 
                if (request.result == UnityWebRequest.Result.ConnectionError ||
                    request.result == UnityWebRequest.Result.ProtocolError)
                {
                    Debug.LogError(request.error);
                }
                else
                {
                    texture = ((DownloadHandlerTexture)request.downloadHandler).texture;
 
                    Texture2D placeholderTexture = this._images[index];
                    this._images[index] = texture;
                    UnityLifetime.Destroy(placeholderTexture);
                }
 
            }
 
            texture.wrapMode = TextureWrapMode.Clamp;
            this._numLoadingImages--;
        }
 
        private void ClearImages()
        {
            for (int i = 0, count = this._images.Count; i < count; i++)
            {
                UnityLifetime.Destroy(this._images[i]);
            }
 
            this._images.Clear();
        }
    }
}