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

package/Runtime/CesiumPointCloudRenderer.cs

@@ -0,0 +1,246 @@
+using UnityEngine;
+using UnityEngine.Rendering;
+using UnityEngine.XR;
+
+#if UNITY_EDITOR
+using UnityEditor;
+#endif
+
+namespace CesiumForUnity
+{
+    internal struct Cesium3DTileInfo
+    {
+        public bool usesAdditiveRefinement;
+        public float geometricError;
+        public Vector3 dimensions;
+        public bool isTranslucent;
+    }
+
+    [ExecuteInEditMode]
+    [AddComponentMenu("")]
+    internal class CesiumPointCloudRenderer : MonoBehaviour
+    {
+        private Cesium3DTileset _tileset;
+
+        private Mesh _mesh;
+        private MeshFilter _meshFilter;
+        private MeshRenderer _meshRenderer;
+        private GraphicsBuffer _meshVertexBuffer;
+
+        private int _pointCount = 0;
+        private Material _pointMaterial;
+
+        private Bounds _bounds;
+
+        private Vector4 _attenuationParameters;
+        private Vector4 _constantColor;
+
+        private Cesium3DTileInfo _tileInfo;
+
+        public Cesium3DTileInfo tileInfo
+        {
+            set => this._tileInfo = value;
+        }
+
+        void OnEnable()
+        {
+            this._tileset = this.gameObject.GetComponentInParent<Cesium3DTileset>();
+
+            this._meshFilter = this.gameObject.GetComponent<MeshFilter>();
+            this._mesh = this._meshFilter.sharedMesh;
+            this._meshRenderer = this.gameObject.GetComponent<MeshRenderer>();
+
+            this._pointCount = this._mesh.vertexCount;
+            this._pointMaterial = UnityEngine.Object.Instantiate(
+                        Resources.Load<Material>("CesiumPointCloudShadingMaterial"));
+
+            GraphicsBuffer sourceBuffer = this._mesh.GetVertexBuffer(0);
+
+            bool usingDirect11 = SystemInfo.graphicsDeviceType == GraphicsDeviceType.Direct3D11;
+            if (usingDirect11)
+            {
+                this._meshVertexBuffer = new GraphicsBuffer(
+                    GraphicsBuffer.Target.Structured | GraphicsBuffer.Target.CopyDestination, 
+                    sourceBuffer.count, 
+                    sourceBuffer.stride);
+                Graphics.CopyBuffer(sourceBuffer, this._meshVertexBuffer);
+                sourceBuffer.Release();
+            } else
+            {
+                this._mesh.vertexBufferTarget |= GraphicsBuffer.Target.Structured;
+                this._meshVertexBuffer = sourceBuffer;
+            }
+
+            if (this._mesh.HasVertexAttribute(VertexAttribute.Color))
+            {
+                this._pointMaterial.EnableKeyword("HAS_POINT_COLORS");
+            }
+            else
+            {
+                Material material = this._meshRenderer.sharedMaterial;
+
+                if (material.HasColor("_Color"))
+                {
+                    this._constantColor = material.color;
+                }
+                else if (material.HasVector("_baseColorFactor"))
+                {
+                    this._constantColor = material.GetVector("_baseColorFactor");
+                }
+                else
+                {
+                    this._constantColor = Color.gray;
+                }
+            }
+
+            if (this._mesh.HasVertexAttribute(VertexAttribute.Normal))
+            {
+                this._pointMaterial.EnableKeyword("HAS_POINT_NORMALS");
+            }
+
+            if (XRSettings.stereoRenderingMode == XRSettings.StereoRenderingMode.SinglePassInstanced ||
+                XRSettings.stereoRenderingMode == XRSettings.StereoRenderingMode.SinglePassMultiview)
+            {
+                this._pointMaterial.EnableKeyword("INSTANCING_ON");
+            }
+        }
+
+        private float GetGeometricError(CesiumPointCloudShading pointCloudShading)
+        {
+            float geometricError = this._tileInfo.geometricError;
+            if (geometricError > 0.0f)
+            {
+                return geometricError;
+            }
+
+            if (pointCloudShading.baseResolution > 0.0f)
+            {
+                return pointCloudShading.baseResolution;
+            }
+
+            // Estimate the geometric error.
+            Vector3 dimensions = this._tileInfo.dimensions;
+            float volume = dimensions.x * dimensions.y * dimensions.z;
+            return Mathf.Pow(volume / this._pointCount, 1.0f / 3.0f);
+        }
+
+        private void UpdateAttenuationParameters()
+        {
+            float maximumPointSize =
+                this._tileInfo.usesAdditiveRefinement ?
+                5.0f :
+                this._tileset.maximumScreenSpaceError;
+
+            if (this._tileset.pointCloudShading.maximumAttenuation > 0.0f)
+            {
+                maximumPointSize = this._tileset.pointCloudShading.maximumAttenuation;
+            }
+
+            if (Screen.dpi > 0)
+            {
+                // Approximation of device pixel ratio
+                maximumPointSize *= Screen.dpi / 150;
+            }
+
+            CesiumPointCloudShading pointCloudShading = this._tileset.pointCloudShading;
+
+            float geometricError = this.GetGeometricError(pointCloudShading);
+            geometricError *= pointCloudShading.geometricErrorScale;
+
+            // Depth multiplier
+            Camera camera = Camera.main;
+            float sseDenominator = 2.0f * Mathf.Tan(0.5f * Mathf.Deg2Rad * camera.fieldOfView);
+            float depthMultplier = camera.scaledPixelHeight / sseDenominator;
+
+            this._attenuationParameters =
+                new Vector4(maximumPointSize, geometricError, depthMultplier, 0);
+        }
+
+        private Vector3[] positionsScratch = new Vector3[3];
+
+        private void UpdateBounds()
+        {
+            Matrix4x4 transformMatrix = this.gameObject.transform.localToWorldMatrix;
+
+            Bounds localBounds = this._mesh.bounds;
+            positionsScratch[0] = localBounds.center;
+            positionsScratch[1] = localBounds.min;
+            positionsScratch[2] = localBounds.max;
+
+            this._bounds = GeometryUtility.CalculateBounds(positionsScratch, transformMatrix);
+        }
+
+        private void DestroyResources()
+        {
+            if (this._meshVertexBuffer != null)
+            {
+                this._meshVertexBuffer.Release();
+                this._meshVertexBuffer = null;
+            }
+
+            if (this._pointMaterial != null)
+            {
+#if UNITY_EDITOR
+            if (!EditorApplication.isPlaying) {
+                DestroyImmediate(this._pointMaterial);
+                return;
+            }
+#endif
+                Destroy(this._pointMaterial);
+            }
+        }
+
+        private void UpdateMaterial()
+        {
+            this._pointMaterial.SetBuffer("_inPoints", this._meshVertexBuffer);
+            this._pointMaterial.SetMatrix("_worldTransform", this.gameObject.transform.localToWorldMatrix);
+            this._pointMaterial.SetVector("_attenuationParameters", this._attenuationParameters);
+            this._pointMaterial.SetVector("_constantColor", this._constantColor);
+
+            if (this._tileInfo.isTranslucent || this._constantColor.w < 1.0f)
+            {
+                this._pointMaterial.SetOverrideTag("RenderType", "Transparent");
+                this._pointMaterial.renderQueue = (int)RenderQueue.Transparent;
+                this._pointMaterial.SetInt("_SrcBlend", (int)BlendMode.SrcAlpha);
+                this._pointMaterial.SetInt("_DstBlend", (int)BlendMode.OneMinusSrcAlpha);
+            }
+            else
+            {
+                this._pointMaterial.SetInt("_SrcBlend", (int)BlendMode.One);
+                this._pointMaterial.SetInt("_DstBlend", (int)BlendMode.Zero);
+            }
+        }
+
+        private void DrawPointsWithAttenuation()
+        {
+            this.UpdateBounds();
+            this.UpdateAttenuationParameters();
+            this.UpdateMaterial();
+
+            Graphics.DrawProcedural(
+                this._pointMaterial,
+                this._bounds,
+                MeshTopology.Triangles,
+                this._pointCount * 6,
+                1);
+        }
+
+        void Update()
+        {
+            if (this._tileset.pointCloudShading.attenuation)
+            {
+                this.DrawPointsWithAttenuation();
+                this._meshRenderer.enabled = false;
+            }
+            else
+            {
+                this._meshRenderer.enabled = true;
+            }
+        }
+
+        void OnDisable()
+        {
+            this.DestroyResources();
+        }
+    }
+}

package/Runtime/CesiumPointCloudRenderer.cs.meta

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

package/Runtime/CesiumPointCloudShading.cs

@@ -0,0 +1,76 @@
+using System;
+using UnityEngine;
+
+namespace CesiumForUnity
+{
+    [Serializable]
+    /// <summary>
+    /// Options for adjusting how point clouds are rendered using 3D Tiles.
+    /// </summary>
+    public class CesiumPointCloudShading
+    {
+        [SerializeField]
+        private bool _attenuation = false;
+
+        /// <summary>
+        /// Whether or not to perform point attenuation. Attenuation controls the size of
+        /// the points rendered based on the geometric error of their tile.
+        /// </summary>
+        public bool attenuation
+        {
+            get => this._attenuation;
+            set => this._attenuation = value;
+        }
+
+        [SerializeField]
+        private float _geometricErrorScale = 1.0f;
+
+        /// <summary>
+        /// The scale to be applied to the tile's geometric error before it is used
+        /// to compute attenuation. Larger values will result in larger points.
+        /// </summary>
+        public float geometricErrorScale
+        {
+            get => this._geometricErrorScale;
+            set
+            {
+                this._geometricErrorScale = Mathf.Max(value, 0.0f);
+            }
+        }
+
+        [SerializeField]
+        private float _maximumAttenuation = 0.0f;
+
+        /// <summary>
+        /// The maximum point attenuation in pixels. If this is zero, the Cesium3DTileset's 
+        /// maximumScreenSpaceError will be used as the maximum point attenuation.
+        /// </summary>
+        public float maximumAttenuation
+        {
+            get => this._maximumAttenuation;
+            set
+            {
+                this._maximumAttenuation = Mathf.Max(value, 0.0f);
+            }
+        }
+
+        [SerializeField]
+        private float _baseResolution = 0.0f;
+
+        /// <summary>
+        /// The average base resolution for the dataset in meters. For example, 
+        /// a base resolution of 0.05 assumes an original capture resolution of
+        /// 5 centimeters between neighboring points.
+        /// <para>
+        /// This is used in place of geometric error when the tile's geometric error is 0. 
+        /// If this value is zero, each tile with a geometric error of 0 will have its 
+        /// geometric error approximated instead.
+        /// </para>
+        /// </summary>
+        public float baseResolution
+        {
+            get => this._baseResolution;
+            set => this._baseResolution = Mathf.Max(value, 0.0f);
+        }
+    }
+}

package/Runtime/CesiumPointCloudShading.cs.meta

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

package/Runtime/CesiumPolygonRasterOverlay.cs

@@ -0,0 +1,109 @@
+using Reinterop;
+using System.Collections.Generic;
+using UnityEngine;
+
+namespace CesiumForUnity
+{
+    /// <summary>
+    /// A raster overlay that rasterizes polygons and drapes them over the tileset.
+    /// This is useful for clipping out parts of a tileset or applying specific material
+    /// effects in an area.
+    /// </summary>
+    /// <remarks>
+    /// Polygon raster overlays will only work in Unity 2022.2 or later.
+    /// </remarks>
+    [ReinteropNativeImplementation(
+        "CesiumForUnityNative::CesiumPolygonRasterOverlayImpl", "CesiumPolygonRasterOverlayImpl.h")]
+#if UNITY_2022_2_OR_NEWER
+    [AddComponentMenu("Cesium/Cesium Polygon Raster Overlay")]
+#else
+    [AddComponentMenu("")]
+#endif
+    [IconAttribute("Packages/com.cesium.unity/Editor/Resources/Cesium-24x24.png")]
+    public partial class CesiumPolygonRasterOverlay : CesiumRasterOverlay
+    {
+        [SerializeField]
+        private List<CesiumCartographicPolygon> _polygons;
+
+        /// <summary>
+        /// The polygons to rasterize for this overlay.
+        /// </summary>
+        public List<CesiumCartographicPolygon> polygons
+        {
+            get => this._polygons;
+            set
+            {
+                this._polygons = value;
+                this.Refresh();
+            }
+        }
+
+        [SerializeField]
+        private bool _invertSelection = false;
+
+        /// <summary>
+        /// Whether to invert the selection specified by the polygons.
+        /// </summary>
+        /// <remarks>
+        /// <para>
+        /// When this setting is false, the areas inside the polygons are rasterized and therefore 
+        /// hidden from the rest of the tileset. In other words, they appear to cut holes in the
+        /// tileset.
+        /// </para>
+        /// <para>
+        /// When this setting is true, the areas outside of all the polygons will be rasterized instead.
+        /// This will hide everything except for the areas inside the polygons.
+        /// </para>
+        /// </remarks>
+        public bool invertSelection
+        {
+            get => this._invertSelection;
+            set
+            {
+                this._invertSelection = value;
+                this.Refresh();
+            }
+        }
+
+        [SerializeField]
+        private bool _excludeSelectedTiles = true;
+
+        /// <summary>
+        /// Whether tiles that fall entirely within the rasterized selection should be 
+        /// excluded from loading and rendering.
+        /// </summary>
+        /// <remarks>
+        /// <para>
+        /// For better performance, this should be enabled when this overlay will be used for clipping.
+        /// But when this overlay is used for other effects, this option should be disabled to avoid 
+        /// missing tiles.
+        /// </para>
+        /// <para>
+        /// Note that if <see cref="invertSelection"/> is true, this will cull tiles that are outside 
+        /// of all the polygons. If it is false, this will cull tiles that are completely inside at 
+        /// least one polygon.
+        /// </para>
+        /// </remarks>
+        public bool excludeSelectedTiles
+        {
+            get => this._excludeSelectedTiles;
+            set
+            {
+                this._excludeSelectedTiles = value;
+                this.Refresh();
+            }
+        }
+
+#if UNITY_EDITOR
+        private void Reset()
+        {
+            this.materialKey = "Clipping";
+        }
+#endif
+
+        /// <inheritdoc/>
+        protected override partial void AddToTileset(Cesium3DTileset tileset);
+        /// <inheritdoc/>
+        protected override partial void RemoveFromTileset(Cesium3DTileset tileset);
+    }
+}

package/Runtime/CesiumPolygonRasterOverlay.cs.meta

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

package/Runtime/CesiumPrimitiveFeatures.cs

@@ -0,0 +1,130 @@
+using System;
+using System.Collections.Generic;
+using UnityEngine;
+
+namespace CesiumForUnity
+{
+    /// <summary>
+    /// Represents the EXT_mesh_features of a glTF primitive in a <see cref="Cesium3DTileset"/>. 
+    /// It holds views of the feature ID sets associated with this primitive.
+    /// </summary>
+    /// <remarks>
+    /// This component is automatically added to primitive game objects if they
+    /// contain the extension.
+    /// </remarks>
+    [IconAttribute("Packages/com.cesium.unity/Editor/Resources/Cesium-24x24.png")]
+    [AddComponentMenu("")]
+    public partial class CesiumPrimitiveFeatures : MonoBehaviour
+    {
+        /// <summary>
+        /// The <see cref="CesiumFeatureIdSet"/>s available on this primitive.
+        /// </summary>
+        public CesiumFeatureIdSet[] featureIdSets
+        {
+            get; internal set;
+        }
+
+        #region Helper functions
+
+        // Cache a list of indices to prevent the allocation of a new array every time
+        // GetFirstVertexFromTriangle is called.
+        private static List<int> _indices;
+
+        private static int GetFirstVertexFromTriangle(MeshFilter meshFilter, int triangleIndex)
+        {
+            if (meshFilter == null || meshFilter.mesh == null)
+            {
+                return -1;
+            }
+
+            if (CesiumPrimitiveFeatures._indices == null)
+            {
+                CesiumPrimitiveFeatures._indices = new List<int>();
+            }
+
+            meshFilter.mesh.GetTriangles(CesiumPrimitiveFeatures._indices, 0);
+            int targetVertex = triangleIndex * 3;
+            return targetVertex < CesiumPrimitiveFeatures._indices.Count ? CesiumPrimitiveFeatures._indices[targetVertex] : -1;
+        }
+        #endregion
+
+        #region Public methods
+        /// <summary>
+        /// Given a successful raycast hit, finds the index of the first vertex
+        /// from the hit triangle.
+        /// </summary>        
+        /// <param name="hitInfo">The raycast hit.</param>
+        /// <returns>The index of the first vertex on the triangle, or -1 if the hit was unsuccessful.</returns>
+        public static int GetFirstVertexFromHitTriangle(RaycastHit hitInfo)
+        {
+            MeshFilter meshFilter = hitInfo.transform.GetComponent<MeshFilter>();
+            return GetFirstVertexFromTriangle(meshFilter, hitInfo.triangleIndex);
+        }
+
+        /// <summary>
+        /// Gets all the feature ID sets of the given type. If the primitive has no sets
+        /// of that type, the returned array will be empty.
+        /// </summary>
+        /// <param name="type"> The desired feature ID set type.</param>
+        /// <returns>An array of feature ID sets of the specified type, if any exist on the CesiumPrimitiveFeatures.</returns>
+        public CesiumFeatureIdSet[] GetFeatureIdSetsOfType(CesiumFeatureIdSetType type)
+        {
+            return Array.FindAll(this.featureIdSets, set => (set.type == type));
+        }
+
+        /// <summary>
+        /// Gets the feature ID associated with the given triangle, specified by index.
+        /// </summary>
+        /// <remarks>
+        /// A primitive may have multiple feature ID sets, so this allows a feature ID
+        /// set to be specified by index.This value should index into the array of
+        /// CesiumFeatureIdSets in the CesiumPrimitiveFeatures. If the specified
+        /// feature ID set index is invalid, this returns -1.
+        /// </remarks>
+        /// <param name="triangleIndex">The index of the target triangle.</param>
+        /// <param name="featureIdSetIndex">The index of the target feature ID set.</param>
+        /// <returns>The feature ID, or -1 if the specified triangle or feature ID set is invalid.</returns>
+
+        public Int64 GetFeatureIdFromTriangle(int triangleIndex, Int64 featureIdSetIndex = 0)
+        {
+            MeshFilter meshFilter = this.gameObject.GetComponent<MeshFilter>();
+            if (meshFilter == null || featureIdSetIndex < 0 || featureIdSetIndex >= this.featureIdSets.Length)
+            {
+                return -1;
+            }
+
+            CesiumFeatureIdSet featureIdSet = this.featureIdSets[featureIdSetIndex];
+
+            return featureIdSet.GetFeatureIdForVertex(
+                GetFirstVertexFromTriangle(meshFilter, triangleIndex));
+        }
+
+        /// <summary>
+        /// Gets the feature ID from the given raycast hit, assuming it has hit a 
+        /// glTF primitive component containing this CesiumPrimitiveFeatures.
+        /// </summary>
+        /// <remarks>
+        /// A primitive may have multiple feature ID sets, so this allows a feature ID
+        /// set to be specified by index. This value should index into the array of
+        /// CesiumFeatureIdSets in the CesiumPrimitiveFeatures. If the specified
+        /// feature ID set index is invalid, this returns -1.
+        /// </remarks>
+        /// <param name="hitInfo">The raycast hit info.</param>
+        /// <param name="featureIdSetIndex">The index of the target feature ID set.</param>
+        /// <returns>The feature ID, or -1 if the specified feature ID set is invalid.</returns>
+        public Int64 GetFeatureIdFromRaycastHit(RaycastHit hitInfo, Int64 featureIdSetIndex = 0)
+        {
+            if (hitInfo.transform.GetComponent<CesiumPrimitiveFeatures>() != this ||
+                featureIdSetIndex < 0 || featureIdSetIndex >= this.featureIdSets.Length)
+            {
+                return -1;
+            }
+
+            CesiumFeatureIdSet featureIdSet = this.featureIdSets[featureIdSetIndex];
+
+            return featureIdSet.GetFeatureIdFromRaycastHit(hitInfo);
+        }
+
+        #endregion 
+    }
+}

package/Runtime/CesiumPrimitiveFeatures.cs.meta

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

package/Runtime/CesiumPropertyArray.cs

@@ -0,0 +1,64 @@
+using System;
+
+namespace CesiumForUnity
+{
+    /// <summary>
+    /// Represents an array value from a property in glTF metadata. The values belong
+    /// to one of the supported property types in EXT_structural_metadata.
+    /// </summary>
+    public class CesiumPropertyArray
+    {
+        internal CesiumMetadataValue[] values { get; set; }
+
+        internal CesiumPropertyArray()
+        {
+            this.values = new CesiumMetadataValue[0];
+        }
+
+        internal CesiumPropertyArray(CesiumMetadataValue[] values)
+        {
+            this.values = values;
+        }
+
+        /// <summary>
+        /// The value type of the elements in the array. Some of these types are
+        /// not accessible from Unity, but can be converted to a close-fitting type.
+        /// </summary>
+        public CesiumMetadataValueType elementValueType
+        {
+            get; internal set;
+        }
+
+        /// <summary>
+        /// Gets the number of elements in the array. Returns 0 if the elements have 
+        /// an unknown type.
+        /// </summary>
+        public Int64 length
+        {
+            get { return this.values.LongLength; }
+        }
+
+        /// <summary>
+        /// Retrieves an element from the array as a CesiumMetadataValue. The value
+        /// can then be retrieved as a specific C# or Unity type.
+        /// 
+        /// If the index is out-of-bounds, this returns a bogus CesiumMetadataValue 
+        /// of an unknown type.
+        /// </summary>
+        /// <param name="index">The desired index</param>
+        /// <returns>The element as a CesiumMetadataValue.</returns>
+        public CesiumMetadataValue this[Int64 index]
+        {
+            get
+            {
+                if (index < 0 || index >= this.length)
+                {
+                    return new CesiumMetadataValue();
+                }
+
+                return values[index];
+            }
+        }
+
+    }
+}

package/Runtime/CesiumPropertyArray.cs.meta

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