Code to create Elevation Angle and Azimuth Angle maps, plus base texture and other textures for mapping purposes

1.png = base terrain texture (supplied by NASA)
bunchofnumbers..._darkblue.png = second terrain texture
dark-blue-color-solid-background.png = third terrain texture
images.png = fourth terrain texture

Author: graceemetz

1.png

@@ -0,0 +1,26 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+
+public class ElevationMaterial : MonoBehaviour
+{
+    public Material[] material;
+    public Renderer rend;
+    // Start is called before the first frame update
+    void Start()
+    {
+        rend = GetComponent<Renderer>();
+        rend.enabled = true;
+        rend.sharedMaterial = material[0];
+    }
+
+    // Update is called once per frame
+    void MapElevation()
+    {
+        
+    }
+    void SetPoints()
+    {
+        rend.sharedMaterial = material[1];
+    }
+}

34173cb38f07f89ddbebc2ac9128303f-1244-oberflex_purepapercolor_skin_darkblue020_detail.png

@@ -0,0 +1,202 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+using System.Linq;
+
+public class MakeTerrainMap : MonoBehaviour
+{
+    // Start is called before the first frame update
+
+    // System.Obsolete to minimize errors
+    [System.Obsolete]
+    void Start () {
+        // Get the attached terrain component
+                Terrain terrain = GetComponent<Terrain>();
+         
+        // Get a reference to the terrain data
+            TerrainData terrainData = terrain.terrainData;
+ 
+        // Splatmap data is stored internally as a 3d array of floats, so declare a new empty array ready for your custom splatmap data:
+        float[, ,] splatmapData = new float[terrainData.alphamapWidth, terrainData.alphamapHeight, terrainData.alphamapLayers];
+          // Declare constants for earth and lunar values
+        const float lunarRadius = 1737.4f;
+         const float earthX = 1623.678285f;
+         const float earthY = 590.9705659f;
+         const float earthZ = -181.6077521f;
+         const float earthLatitude = -6f;
+         const float earthLongitude = 20f;
+         const float minLatitude = -88.44359886830375f;
+         const float maxLatitude = -89.17347901603343f;
+         const float minLongitude = 107.5300786165378f;
+         const float maxLongitude = 141.8371251025832f;
+         const float slopeDistance = 0.1f;
+         Vector3 earth = new Vector3(earthX, earthY, earthZ);
+        // Loops through points to find elevation angle at each point
+        for (int y = 0; y < terrainData.alphamapHeight; y++)
+            {
+            for (int x = 0; x < terrainData.alphamapWidth; x++)
+             {
+                // Normalise x/y coordinates to range 0-1 
+                float y_01 = (float)y/(float)terrainData.alphamapHeight;
+                float x_01 = (float)x/(float)terrainData.alphamapWidth;
+                 
+                // Calculate the normal of the terrain (note this is in normalised coordinates relative to the overall terrain dimensions)
+                Vector3 normal = terrainData.GetInterpolatedNormal(y_01,x_01);
+                float terrainwidth = terrainData.size.x;
+                float terrainlength = terrainData.size.z;
+                float terrainpositionx = x_01 * terrainwidth;
+                float terrainpositionz = y_01 * terrainlength;
+                Vector3 worldposition = new Vector3(terrainpositionx, 0, terrainpositionz);
+      
+                // Calculate the steepness of the terrain
+                float steepness = terrainData.GetSteepness(y_01,x_01);
+                 
+                // Setup an array to record the mix of texture weights at this point
+                float[] splatWeights = new float[terrainData.alphamapLayers];
+     
+                // Texture[0] has constant influence
+                splatWeights[0] = 0.5f;
+                
+                // Assign elevation angles to a SplatMap texture
+
+                
+                splatWeights[1] = AzimuthToEarth(terrainpositionz, terrainpositionx);
+                
+                 
+                // Sum of all textures weights must add to 1, so calculate normalization factor from sum of weights
+                float z = splatWeights.Sum();
+                 
+                // Loop through each terrain texture
+                for(int i = 0; i<terrainData.alphamapLayers; i++){
+                     
+                    // Normalize so that sum of all texture weights = 1
+                    splatWeights[i] /= z;
+                     
+                    // Assign this point to the splatmap array
+                    splatmapData[x, y, i] = splatWeights[i];
+                }
+            }
+        }
+      
+float GetElevationAngle(Vector3 point)
+    {
+        (float latitude, float longitude) = FindLatitudeLongitudeOfUnityPoint(point);
+
+        Vector3 cartesianPoint = CartesianConversion(latitude, longitude);
+
+        float azimuthToEarth = AzimuthToEarth(latitude, longitude);
+        float elevationAngleToEarth = ElevationAngleToEarth(cartesianPoint);
+        float elevationAngleOfTerrain = ElevationAngleOfTerrain(cartesianPoint, azimuthToEarth);
+
+        return elevationAngleOfTerrain;
+    }
+
+    (float latitude, float longitude) FindLatitudeLongitudeOfUnityPoint(Vector3 point)
+    {
+        float unityX = point.x;
+        float unityY = point.y;
+
+        float interpolatedX = Mathf.InverseLerp(0, 2499, unityX);
+        float interpolatedY = Mathf.InverseLerp(0, 2499, unityY);
+
+        float latitude = Mathf.Lerp(minLatitude, maxLatitude, interpolatedX);
+        float longitude = Mathf.Lerp(minLongitude, maxLongitude, interpolatedY);
+
+        return (latitude, longitude);
+    }
+
+    Vector3 CartesianConversion(float latitude, float longitude)
+    {
+        float x = lunarRadius * Mathf.Cos(latitude) * Mathf.Cos(longitude);
+        float y = lunarRadius * Mathf.Cos(latitude) * Mathf.Sin(longitude);
+        float z = lunarRadius * Mathf.Sin(latitude);
+
+        return new Vector3(x, y, z);
+    }
+
+    float AzimuthToEarth(float latitude, float longitude)
+    {
+        float latitudeInRadians = DegreesToRadians(latitude);
+        float longitudeInRadians = DegreesToRadians(longitude);
+        float x = Mathf.Sin(longitudeInRadians - earthLongitude) * Mathf.Cos(earthLatitude);
+        float y = (Mathf.Cos(latitudeInRadians) * Mathf.Sin(earthLatitude)) - (Mathf.Sin(latitudeInRadians) * Mathf.Cos(earthLatitude) * Mathf.Cos(earthLongitude - longitudeInRadians));
+        float azimuthAngle = Mathf.Atan2(y, x);
+
+        return azimuthAngle;
+    }
+
+    float DegreesToRadians(float degreeValue)
+    {
+        return degreeValue * Mathf.PI / 180f;
+    }
+
+    float ElevationAngleOfTerrain(Vector3 point, float azimuthAngle)
+    {
+        float xDistanceForSlope = slopeDistance * Mathf.Cos(azimuthAngle);
+        float yDistanceForSlope = slopeDistance * Mathf.Sin(azimuthAngle);
+
+        Vector3 slopeSamplePoint = PointFromClosestTerrain(new Vector3(point.x + xDistanceForSlope, 0f, point.z + yDistanceForSlope));
+        float heightForSlope = point.y - slopeSamplePoint.y;
+
+        float elevationAngle = Mathf.Atan(heightForSlope / slopeDistance);
+
+        return elevationAngle;
+    }
+
+    float ElevationAngleToEarth(Vector3 point)
+    {
+        float xPointToEarth = point.x - earth.x;
+        float yPointToEarth = point.y - earth.y;
+        float zPointToEarth = point.z - earth.z;
+
+        float range = Mathf.Sqrt(Mathf.Pow(xPointToEarth, 2f) + Mathf.Pow(yPointToEarth, 2f) + Mathf.Pow(zPointToEarth, 2f));
+        float rz = (Mathf.Cos(earthLatitude) * Mathf.Cos(earthLongitude)) + (Mathf.Cos(earthLatitude) * Mathf.Sin(earthLongitude)) + Mathf.Sin(earthLongitude);
+
+        return Mathf.Asin(rz / range);
+    }
+
+    Vector3 PointFromClosestTerrain(Vector3 position)
+    {
+        Terrain terrain = GetClosestCurrentTerrain(position);
+
+        position.y = terrain.SampleHeight(position);
+
+        return position;
+    }
+
+    Terrain GetClosestCurrentTerrain(Vector3 position)
+    {
+        //Get all terrain
+        Terrain[] terrains = Terrain.activeTerrains;
+
+        //Make sure that terrains length is ok
+        if (terrains.Length == 0)
+            return null;
+
+        //If just one, return that one terrain
+        if (terrains.Length == 1)
+            return terrains[0];
+
+        //Get the closest one to the player
+        float lowDist = (terrains[0].GetPosition() - position).sqrMagnitude;
+        var terrainIndex = 0;
+
+        for (int i = 1; i < terrains.Length; i++)
+        {
+            Terrain terrain = terrains[i];
+            Vector3 terrainPos = terrain.GetPosition();
+
+            //Find the distance and check if it is lower than the last one then store it
+            var dist = (terrainPos - position).sqrMagnitude;
+            if (dist < lowDist)
+            {
+                lowDist = dist;
+                terrainIndex = i;
+            }
+        }
+        return terrains[terrainIndex];
+    }
+        // Finally assign the new splatmap to the terrainData:
+        terrainData.SetAlphamaps(0, 0, splatmapData);
+    }
+}