org.outernet.cesium-unity 1.15.3-linux.1

package/Runtime/CesiumMetadataValue.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: ba5cd61d23885da41ba682e27481f73c
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Runtime/CesiumMetadataValueType.cs

@@ -0,0 +1,203 @@
+using UnityEngine;
+using Unity.Mathematics;
+using System;
+
+namespace CesiumForUnity
+{
+    /// <summary>
+    /// Identifies the type of a property in EXT_structural_metadata. 
+    /// </summary>
+    public enum CesiumMetadataType
+    {
+        Invalid = 0,
+        Scalar,
+        Vec2,
+        Vec3,
+        Vec4,
+        Mat2,
+        Mat3,
+        Mat4,
+        String,
+        Boolean,
+        Enum
+    }
+
+    /// <summary>
+    /// Identifies the component type of a property in EXT_structural_metadata. 
+    /// Only applicable if the property has a Scalar, VecN, or MatN type.
+    /// </summary>
+    public enum CesiumMetadataComponentType
+    {
+        None = 0,
+        Int8,
+        Uint8,
+        Int16,
+        Uint16,
+        Int32,
+        Uint32,
+        Int64,
+        Uint64,
+        Float32,
+        Float64
+    }
+
+    /// <summary>
+    /// Represents the value type of a metadata value or property, akin to the 
+    /// property types in EXT_structural_metadata.
+    /// </summary>
+    public struct CesiumMetadataValueType
+    {
+        #region Fields
+        /// <summary>
+        /// The type of the metadata property or value.
+        /// </summary>
+        public CesiumMetadataType type;
+
+        /// <summary>
+        /// The component of the metadata property or value. Only applies when 
+        /// the type is a Scalar, VecN, or MatN type.
+        /// </summary>
+        public CesiumMetadataComponentType componentType;
+
+        /// <summary>
+        /// Whether or not this represents an array containing elements of the 
+        /// specified types.
+        /// </summary>
+        public bool isArray;
+        #endregion
+
+        #region Constructor
+        /// <summary>
+        /// Constructs a metadata value type from the given parameters.
+        /// </summary>
+        /// <param name="type">The type of the metadata property or value.</param>
+        /// <param name="componentType"> The component type of the metadata property or value.</param>
+        /// <param name="isArray">Whether or not the property or value is an array.</param>
+        public CesiumMetadataValueType(
+            CesiumMetadataType type, CesiumMetadataComponentType componentType, bool isArray)
+        {
+            this.type = type;
+            this.componentType = componentType;
+            this.isArray = isArray;
+        }
+        #endregion
+
+        #region Static methods
+        public static CesiumMetadataValueType GetValueType(System.Object inObject)
+        {
+            if (inObject == null)
+            {
+                return new CesiumMetadataValueType();
+            }
+
+            if (inObject.GetType() == typeof(CesiumPropertyArray))
+            {
+                CesiumPropertyArray array = inObject as CesiumPropertyArray;
+                return new CesiumMetadataValueType(array.elementValueType.type, array.elementValueType.componentType, true);
+            }
+
+            switch (inObject)
+            {
+                case System.Boolean:
+                    return new CesiumMetadataValueType(CesiumMetadataType.Boolean, CesiumMetadataComponentType.None, false);
+                case System.SByte:
+                    return new CesiumMetadataValueType(CesiumMetadataType.Scalar, CesiumMetadataComponentType.Int8, false);
+                case Byte:
+                    return new CesiumMetadataValueType(CesiumMetadataType.Scalar, CesiumMetadataComponentType.Uint8, false);
+                case Int16:
+                    return new CesiumMetadataValueType(CesiumMetadataType.Scalar, CesiumMetadataComponentType.Int16, false);
+                case UInt16:
+                    return new CesiumMetadataValueType(CesiumMetadataType.Scalar, CesiumMetadataComponentType.Uint16, false);
+                case Int32:
+                    return new CesiumMetadataValueType(CesiumMetadataType.Scalar, CesiumMetadataComponentType.Int32, false);
+                case UInt32:
+                    return new CesiumMetadataValueType(CesiumMetadataType.Scalar, CesiumMetadataComponentType.Uint32, false);
+                case Int64:
+                    return new CesiumMetadataValueType(CesiumMetadataType.Scalar, CesiumMetadataComponentType.Int64, false);
+                case UInt64:
+                    return new CesiumMetadataValueType(CesiumMetadataType.Scalar, CesiumMetadataComponentType.Uint64, false);
+                case float:
+                    return new CesiumMetadataValueType(CesiumMetadataType.Scalar, CesiumMetadataComponentType.Float32, false);
+                case double:
+                    return new CesiumMetadataValueType(CesiumMetadataType.Scalar, CesiumMetadataComponentType.Float64, false);
+                case int2:
+                    return new CesiumMetadataValueType(CesiumMetadataType.Vec2, CesiumMetadataComponentType.Int32, false);
+                case int3:
+                    return new CesiumMetadataValueType(CesiumMetadataType.Vec3, CesiumMetadataComponentType.Int32, false);
+                case int4:
+                    return new CesiumMetadataValueType(CesiumMetadataType.Vec4, CesiumMetadataComponentType.Int32, false);
+                case uint2:
+                    return new CesiumMetadataValueType(CesiumMetadataType.Vec2, CesiumMetadataComponentType.Uint32, false);
+                case uint3:
+                    return new CesiumMetadataValueType(CesiumMetadataType.Vec3, CesiumMetadataComponentType.Uint32, false);
+                case uint4:
+                    return new CesiumMetadataValueType(CesiumMetadataType.Vec4, CesiumMetadataComponentType.Uint32, false);
+                case float2:
+                    return new CesiumMetadataValueType(CesiumMetadataType.Vec2, CesiumMetadataComponentType.Float32, false);
+                case float3:
+                    return new CesiumMetadataValueType(CesiumMetadataType.Vec3, CesiumMetadataComponentType.Float32, false);
+                case float4:
+                    return new CesiumMetadataValueType(CesiumMetadataType.Vec4, CesiumMetadataComponentType.Float32, false);
+                case double2:
+                    return new CesiumMetadataValueType(CesiumMetadataType.Vec2, CesiumMetadataComponentType.Float64, false);
+                case double3:
+                    return new CesiumMetadataValueType(CesiumMetadataType.Vec3, CesiumMetadataComponentType.Float64, false);
+                case double4:
+                    return new CesiumMetadataValueType(CesiumMetadataType.Vec4, CesiumMetadataComponentType.Float64, false);
+                case int2x2:
+                    return new CesiumMetadataValueType(CesiumMetadataType.Mat2, CesiumMetadataComponentType.Int32, false);
+                case int3x3:
+                    return new CesiumMetadataValueType(CesiumMetadataType.Mat3, CesiumMetadataComponentType.Int32, false);
+                case int4x4:
+                    return new CesiumMetadataValueType(CesiumMetadataType.Mat4, CesiumMetadataComponentType.Int32, false);
+                case CesiumIntVec2:
+                    return new CesiumMetadataValueType(CesiumMetadataType.Vec2, (inObject as CesiumIntVec2?).Value.componentType, false);
+                case CesiumIntVec3:
+                    return new CesiumMetadataValueType(CesiumMetadataType.Vec3, (inObject as CesiumIntVec3?).Value.componentType, false);
+                case CesiumIntVec4:
+                    return new CesiumMetadataValueType(CesiumMetadataType.Vec4, (inObject as CesiumIntVec4?).Value.componentType, false);
+                case CesiumUintVec2:
+                    return new CesiumMetadataValueType(CesiumMetadataType.Vec2, (inObject as CesiumUintVec2?).Value.componentType, false);
+                case CesiumUintVec3:
+                    return new CesiumMetadataValueType(CesiumMetadataType.Vec3, (inObject as CesiumUintVec3?).Value.componentType, false);
+                case CesiumUintVec4:
+                    return new CesiumMetadataValueType(CesiumMetadataType.Vec4, (inObject as CesiumUintVec4?).Value.componentType, false);
+                case uint2x2:
+                    return new CesiumMetadataValueType(CesiumMetadataType.Mat2, CesiumMetadataComponentType.Uint32, false);
+                case uint3x3:
+                    return new CesiumMetadataValueType(CesiumMetadataType.Mat3, CesiumMetadataComponentType.Uint32, false);
+                case uint4x4:
+                    return new CesiumMetadataValueType(CesiumMetadataType.Mat4, CesiumMetadataComponentType.Uint32, false);
+                case float2x2:
+                    return new CesiumMetadataValueType(CesiumMetadataType.Mat2, CesiumMetadataComponentType.Float32, false);
+                case float3x3:
+                    return new CesiumMetadataValueType(CesiumMetadataType.Mat3, CesiumMetadataComponentType.Float32, false);
+                case float4x4:
+                    return new CesiumMetadataValueType(CesiumMetadataType.Mat4, CesiumMetadataComponentType.Float32, false);
+                case double2x2:
+                    return new CesiumMetadataValueType(CesiumMetadataType.Mat2, CesiumMetadataComponentType.Float64, false);
+                case double3x3:
+                    return new CesiumMetadataValueType(CesiumMetadataType.Mat3, CesiumMetadataComponentType.Float64, false);
+                case double4x4:
+                    return new CesiumMetadataValueType(CesiumMetadataType.Mat4, CesiumMetadataComponentType.Float64, false);
+                case CesiumIntMat2x2:
+                    return new CesiumMetadataValueType(CesiumMetadataType.Mat2, (inObject as CesiumIntMat2x2?).Value.componentType, false);
+                case CesiumIntMat3x3:
+                    return new CesiumMetadataValueType(CesiumMetadataType.Mat3, (inObject as CesiumIntMat3x3?).Value.componentType, false);
+                case CesiumIntMat4x4:
+                    return new CesiumMetadataValueType(CesiumMetadataType.Mat4, (inObject as CesiumIntMat4x4?).Value.componentType, false);
+                case CesiumUintMat2x2:
+                    return new CesiumMetadataValueType(CesiumMetadataType.Mat2, (inObject as CesiumUintMat2x2?).Value.componentType, false);
+                case CesiumUintMat3x3:
+                    return new CesiumMetadataValueType(CesiumMetadataType.Mat3, (inObject as CesiumUintMat3x3?).Value.componentType, false);
+                case CesiumUintMat4x4:
+                    return new CesiumMetadataValueType(CesiumMetadataType.Mat4, (inObject as CesiumUintMat4x4?).Value.componentType, false);
+                case System.String:
+                    return new CesiumMetadataValueType(CesiumMetadataType.String, CesiumMetadataComponentType.None, false);
+                default:
+                    return new CesiumMetadataValueType();
+            }
+        }
+        #endregion
+    }
+}

package/Runtime/CesiumMetadataValueType.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: c7e68a0b15383cc4a907a6812814e0e2
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Runtime/CesiumModelMetadata.cs

@@ -0,0 +1,26 @@
+using UnityEngine;
+
+namespace CesiumForUnity
+{
+    /// <summary>
+    /// Represents the root `EXT_structural_metadata` extension of a glTF model in a 
+    /// <see cref="Cesium3DTileset"/>. It holds views of property tables
+    /// available on the glTF.
+    /// </summary>
+    /// <remarks>
+    /// This component is automatically added 
+    /// to tile game objects if their models contain the root extension.
+    /// </remarks>
+    [IconAttribute("Packages/com.cesium.unity/Editor/Resources/Cesium-24x24.png")]
+    [AddComponentMenu("")]
+    public class CesiumModelMetadata : MonoBehaviour
+    {
+        /// <summary>
+        /// The <see cref="CesiumPropertyTable"/>s available on this model metadata.
+        /// </summary>
+        public CesiumPropertyTable[] propertyTables
+        {
+            get; internal set;
+        }
+    }
+}

package/Runtime/CesiumModelMetadata.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: bb1383ae79c2acf488fe07883008ab31
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Runtime/CesiumObjectPool.cs

@@ -0,0 +1,74 @@
+using System;
+using System.Collections.Generic;
+
+namespace CesiumForUnity
+{
+    internal class CesiumObjectPool<T> : IDisposable where T : class
+    {
+        private List<T> _pool;
+        private int _maximumSize;
+        private Func<T> _createCallback;
+        private Action<T> _releaseCallback;
+        private Action<T> _destroyCallback;
+
+        public CesiumObjectPool(Func<T> createCallback, Action<T> releaseCallback, Action<T> destroyCallback, int maximumSize = 1000)
+        {
+            this._pool = new List<T>(maximumSize);
+            this._maximumSize = maximumSize;
+            this._createCallback = createCallback;
+            this._releaseCallback = releaseCallback;
+            this._destroyCallback = destroyCallback;
+        }
+
+        public void Dispose()
+        {
+            this.Clear();
+
+            // A null pool indicates released objects should be freed,
+            // rather than added back into the pool.
+            this._pool = null;
+        }
+
+        public int CountInactive => this._pool.Count;
+
+        public void Clear()
+        {
+            if (this._pool == null)
+                return;
+
+            foreach (T o in this._pool)
+            {
+                this._destroyCallback(o);
+            }
+        }
+
+        public T Get()
+        {
+            if (this._pool != null && this._pool.Count > 0)
+            {
+                int pos = this._pool.Count - 1;
+                T result = this._pool[pos];
+                this._pool.RemoveAt(pos);
+                return result;
+            }
+            else
+            {
+                return this._createCallback();
+            }
+        }
+
+        public void Release(T element)
+        {
+            this._releaseCallback(element);
+
+            if (this._pool != null && this._pool.Count < this._maximumSize)
+            {
+                this._pool.Add(element);
+            }
+            else
+            {
+                this._destroyCallback(element);
+            }
+        }
+    }
+}

package/Runtime/CesiumObjectPool.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 377239c81df171c4695d99031a54fd1f
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Runtime/CesiumObjectPools.cs

@@ -0,0 +1,39 @@
+using UnityEngine;
+
+#if UNITY_EDITOR
+using UnityEditor;
+#endif
+
+namespace CesiumForUnity
+{
+    internal class CesiumObjectPools
+    {
+        public static CesiumObjectPool<Mesh> MeshPool => _meshPool;
+
+        private static CesiumObjectPool<Mesh> _meshPool;
+
+        public static void Dispose()
+        {
+            _meshPool.Dispose();
+        }
+
+        static CesiumObjectPools()
+        {
+            _meshPool = new CesiumObjectPool<Mesh>(
+                () => new Mesh(),
+                (mesh) => mesh.Clear(),
+                (mesh) => UnityLifetime.Destroy(mesh));
+
+#if UNITY_EDITOR
+            EditorApplication.playModeStateChanged += OnPlayModeStateChanged;
+#endif
+        }
+
+#if UNITY_EDITOR
+        private static void OnPlayModeStateChanged(PlayModeStateChange obj)
+        {
+            Dispose();
+        }
+#endif
+    }
+}

package/Runtime/CesiumObjectPools.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 79e50188ee452fb4b97d4fb2a5331e1f
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Runtime/CesiumOriginShift.cs

@@ -0,0 +1,146 @@
+using System.Collections.Generic;
+using Unity.Mathematics;
+using UnityEngine;
+
+namespace CesiumForUnity
+{
+    /// <summary>
+    /// Automatically shifts the origin of a <see cref="CesiumGeoreference"/> as the object to which
+    /// it is attached moves. This improves rendering precision by keeping coordinate values small.
+    /// </summary>
+    /// <remarks>
+    /// <para>
+    /// This component is typically attached to a camera, and it automatically updates the <see cref="CesiumGeoreference"/>
+    /// to keep its origin near the location of the camera. This improves rendering precision by keeping the
+    /// coordinate values of objects that are near the camera as small as possible. A game object with this
+    /// component must be nested inside a <see cref="CesiumGeoreference"/>, and it must also have a
+    /// <see cref="CesiumGlobeAnchor"/>. It is essential to add a <see cref="CesiumGlobeAnchor"/> to all
+    /// other objects in the scene as well; otherwise, they will appear to move when the origin is shifted.
+    /// </para>
+    /// <para>
+    /// This component also switches between <see cref="CesiumSubScene"/> instances based on the distance
+    /// to them. When inside a sub-scene, the origin shifting described above is not performed. This allows
+    /// relatively normal Unity scenes to be defined at different locations on the globe.
+    /// </para>
+    /// </remarks>
+    [RequireComponent(typeof(CesiumGlobeAnchor))]
+    [DisallowMultipleComponent]
+    [AddComponentMenu("Cesium/Cesium Origin Shift")]
+    [IconAttribute("Packages/com.cesium.unity/Editor/Resources/Cesium-24x24.png")]
+    public class CesiumOriginShift : MonoBehaviour
+    {
+        /// <summary>
+        /// The maximum distance between the origin of the Unity coordinate system and
+        /// the game object to which this component is attached. When this distance is
+        /// exceeded, the <see cref="CesiumGeoreference"/> origin is shifted to bring it
+        /// close to the game object.
+        /// </summary>
+        /// <remarks>
+        /// When the value of this property is 0.0, the origin is shifted continuously.
+        /// </remarks>
+        public double distance
+        {
+            get => _distance;
+            set => _distance = value;
+        }
+
+        [SerializeField]
+        [Min(0)]
+        [Tooltip("The maximum distance between the origin of the Unity coordinate system and " +
+                 "the game object to which this component is attached. When this distance is" +
+                 "exceeded, the CesiumGeoreference origin is shifted to bring it close to the " +
+                 "game object.\n\n" +
+                 "When the value of this property is 0.0, the origin is shifted continuously.")]
+        private double _distance = 0.0;
+
+        void LateUpdate()
+        {
+            CesiumGeoreference georeference = this.GetComponentInParent<CesiumGeoreference>();
+
+            if (georeference == null)
+            {
+                Debug.LogWarning("CesiumOriginShift is doing nothing because it is not nested inside a game object with a CesiumGeoreference component.");
+                return;
+            }
+
+            CesiumGlobeAnchor anchor = this.GetComponent<CesiumGlobeAnchor>();
+
+            // The RequireComponent attribute should ensure the globe anchor exists, but it may not be active.
+            if (anchor == null || !anchor.isActiveAndEnabled)
+            {
+                Debug.LogWarning("CesiumOriginShift is doing nothing because its CesiumGlobeAnchor component is missing or disabled.");
+                return;
+            }
+
+            this.UpdateFromEcef(georeference, anchor.positionGlobeFixed);
+        }
+
+        private List<CesiumSubScene> _sublevelsScratch = new List<CesiumSubScene>();
+
+        private void UpdateFromEcef(CesiumGeoreference georeference, double3 ecef)
+        {
+            CesiumSubScene closestLevel = null;
+            double distanceSquaredToClosest = double.MaxValue;
+
+            // Are we inside a sub-level?
+            georeference.GetComponentsInChildren<CesiumSubScene>(true, this._sublevelsScratch);
+            foreach (CesiumSubScene level in this._sublevelsScratch)
+            {
+                // TODO: Make sure ECEF position is actually up-to-date
+                double x = level.ecefX - ecef.x;
+                double y = level.ecefY - ecef.y;
+                double z = level.ecefZ - ecef.z;
+                double distanceSquared = x * x + y * y + z * z;
+                if (distanceSquared > level.activationRadius * level.activationRadius)
+                    // We're outside this level's activation radius
+                    continue;
+
+                if (closestLevel == null || distanceSquared < distanceSquaredToClosest)
+                {
+                    closestLevel = level;
+                    distanceSquaredToClosest = distanceSquared;
+                }
+            }
+
+            if (closestLevel != null)
+            {
+                if (!closestLevel.isActiveAndEnabled)
+                {
+                    // Setting a level active will automatically disable all other levels.
+                    closestLevel.gameObject.SetActive(true);
+                    closestLevel.enabled = true;
+
+                    Physics.SyncTransforms();
+                }
+            }
+            else
+            {
+                bool deactivatedAnySublevel = false;
+
+                // Deactivate all active sub-levels
+                foreach (CesiumSubScene level in this._sublevelsScratch)
+                {
+                    if (level.isActiveAndEnabled)
+                    {
+                        level.gameObject.SetActive(false);
+                        deactivatedAnySublevel = true;
+                    }
+                }
+
+                double distance = math.length(new double3(georeference.ecefX, georeference.ecefY, georeference.ecefZ) - ecef);
+
+                if (distance >= this._distance)
+                {
+                    // Update the origin if we've surpassed the distance threshold.
+                    georeference.SetOriginEarthCenteredEarthFixed(ecef.x, ecef.y, ecef.z);
+                    // Make sure the physics system is informed that things have moved
+                    Physics.SyncTransforms();
+                }
+                else if (deactivatedAnySublevel)
+                {
+                    Physics.SyncTransforms();
+                }
+            }
+        }
+    }
+}

package/Runtime/CesiumOriginShift.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 3bef32f31a547984f88be1ab98b65f04
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: