A!leys Galerie

using UnityEngine;
using UnityEditor;
using System.Collections.Generic;

[RequireComponent(typeof(MeshFilter), typeof(MeshRenderer))]
public class VoronoiFractalTerrain : MonoBehaviour
{
    [Header("Generation Settings")]
    [SerializeField] private int width = 128;
    [SerializeField] private int length = 128;
    [SerializeField] private float scale = 1f;
    [SerializeField] private int maxIterations = 8;
    [SerializeField] private float erosionFactor = 0.7f;
    [SerializeField] private AnimationCurve heightCurve;

    [Header("Visual Settings")]
    [SerializeField] private Material terrainMaterial;
    [SerializeField] private float meshDetail = 1f;

    private Mesh mesh;
    private Vector3[] vertices;
    private int[] triangles;
    private Color[] colors;

    private void Start()
    {
        GenerateTerrain();
        GetComponent<MeshFilter>().mesh = mesh;
        GetComponent<MeshRenderer>().material = terrainMaterial;
    }

    [ContextMenu("Generate Terrain")]
    private void GenerateTerrain()
    {
        GenerateVoronoiFractal();
        CreateMesh();
    }

    private void GenerateVoronoiFractal()
    {
        float[,] heightMap = new float[width, length];

        // Step 1: Generate Voronoi points
        Vector2[] points = GenerateRandomPoints(width, length, scale * 0.1f);

        // Step 2: Calculate Voronoi distances
        float[,] voronoiDistances = CalculateVoronoiDistances(points, width, length);

        // Step 3: Apply fractal erosion
        ErodeFractal(voronoiDistances, maxIterations, erosionFactor);

        // Step 4: Normalize and curve
        float minHeight = Mathf.Min(0f, Mathf.Min(voronoiDistances));
        float maxHeight = Mathf.Max(0f, Mathf.Max(voronoiDistances));
        float range = maxHeight - minHeight;

        for (int x = 0; x < width; x++)
        {
            for (int z = 0; z < length; z++)
            {
                heightMap[x, z] = Mathf.Clamp01((voronoiDistances[x, z] - minHeight) / range);
                heightMap[x, z] = heightCurve.Evaluate(heightMap[x, z]);
            }
        }

        // Generate noise layer for texture variation
        float[,] noiseLayer = GenerateNoiseLayer(width, length, 0.2f);

        // Combine layers
        for (int x = 0; x < width; x++)
        {
            for (int z = 0; z < length; z++)
            {
                heightMap[x, z] = Mathf.Clamp01(heightMap[x, z] + noiseLayer[x, z] * 0.3f);
            }
        }
    }

    private Vector2[] GenerateRandomPoints(int width, int length, float minDistance)
    {
        List<Vector2> points = new List<Vector2>();

        for (int i = 0; i < width * length / 20; i++)
        {
            Vector2 point = new Vector2(
                Random.Range(0, width),
                Random.Range(0, length)
            );

            if (IsPointValid(points, point, minDistance))
            {
                points.Add(point);
            }
        }

        return points.ToArray();
    }

    private bool IsPointValid(List<Vector2> existingPoints, Vector2 newPoint, float minDistance)
    {
        foreach (Vector2 point in existingPoints)
        {
            float distance = Vector2.Distance(point, newPoint);
            if (distance < minDistance)
            {
                return false;
            }
        }
        return true;
    }

    private float[,] CalculateVoronoiDistances(Vector2[] points, int width, int length)
    {
        float[,] distances = new float[width, length];

        for (int x = 0; x < width; x++)
        {
            for (int z = 0; z < length; z++)
            {
                float minDistance = float.MaxValue;

                foreach (Vector2 point in points)
                {
                    float distance = Vector2.Distance(
                        new Vector2(x, z),
                        point
                    );

                    if (distance < minDistance)
                    {
                        minDistance = distance;
                    }
                }

                distances[x, z] = -minDistance; // Invert for mountain-like terrain
            }
        }

        return distances;
    }

    private void ErodeFractal(float[,] heightMap, int iterations, float erosionFactor)
    {
        for (int i = 0; i < iterations; i++)
        {
            float[,] eroded = new float[heightMap.GetLength(0), heightMap.GetLength(1)];

            for (int x = 1; x < heightMap.GetLength(0) - 1; x++)
            {
                for (int z = 1; z < heightMap.GetLength(1) - 1; z++)
                {
                    float erosion = (heightMap[x-1, z] + heightMap[x+1, z] + heightMap[x, z-1] + heightMap[x, z+1]) / 4f;
                    erosion = Mathf.Lerp(heightMap[x, z], erosion, erosionFactor);
                    eroded[x, z] = erosion;
                }
            }

            heightMap = eroded;
        }
    }

    private float[,] GenerateNoiseLayer(int width, int length, float scale)
    {
        float[,] noiseLayer = new float[width, length];
        float[,] perlinNoise = new float[width, length];

        for (int x = 0; x < width; x++)
        {
            for (int z = 0; z < length; z++)
            {
                float xCoord = (float)x / width * scale;
                float zCoord = (float)z / length * scale;
                perlinNoise[x, z] = Mathf.PerlinNoise(xCoord, zCoord) * 0.5f + 0.5f;
            }
        }

        for (int x = 0; x < width; x++)
        {
            for (int z = 0; z < length; z++)
            {
                // Apply fractal noise
                float total = perlinNoise[x, z];
                for (int i = 1; i < 4; i++)
                {
                    xCoord *= 2f;
                    zCoord *= 2f;
                    total += Mathf.PerlinNoise(xCoord, zCoord) * (1f / (float)Mathf.Pow(2, i));
                }
                noiseLayer[x, z] = (total - 0.5f) * 2f; // Normalize to -1..1
            }
        }

        return noiseLayer;
    }

    private void CreateMesh()
    {
        int width = this.width;
        int length = this.length;

        vertices = new Vector3[width * length];
        colors = new Color[width * length];
        triangles = new int[(width - 1) * (length - 1) * 6];

        for (int x = 0, i = 0; x < width; x++, i += length)
        {
            for (int z = 0; z < length; z++, i++)
            {
                vertices[i] = new Vector3(x * meshDetail, 0, z * meshDetail);
                float height = Mathf.Clamp01(heightCurve.Evaluate(Mathf.Abs(vertices[i].x / (float)width * 2f - 1f)));
                vertices[i].y = height * scale * 5f;

                // Create terrain colors based on height
                float r = Mathf.Clamp01(1f - vertices[i].y / (scale * 5f)) * 0.5f;
                float g = Mathf.Clamp01(vertices[i].y / (scale * 5f)) * 0.7f;
                float b = 0.1f;
                colors[i] = new Color(r, g, b, 1f);
            }
        }

        for (int x = 0, i = 0; x < width - 1; x++, i += length)
        {
            for (int z = 0; z < length - 1; z++, i++)
            {
                triangles[i * 6] = i;
                triangles[i * 6 + 1] = i + length;
                triangles[i * 6 + 2] = i + 1;

                triangles[i * 6 + 3] = i + 1;
                triangles[i * 6 + 4] = i + length;
                triangles[i * 6 + 5] = i + length + 1;
            }
        }

        mesh = new Mesh
        {
            vertices = vertices,
            triangles = triangles,
            colors = colors,
            bounds = new Bounds(Vector3.zero, Vector3.one * 10f)
        };
        mesh.RecalculateNormals();
    }

#if UNITY_EDITOR
    [MenuItem("Tools/Generate Terrain")]
    public static void GenerateTerrainFromMenu()
    {
        GameObject terrain = GameObject.FindObjectOfType<VoronoiFractalTerrain>()?.gameObject;
        if (terrain == null)
        {
            terrain = new GameObject("VoronoiTerrain");
            terrain.AddComponent<VoronoiFractalTerrain>();
        }

        VoronoiFractalTerrain generator = terrain.GetComponent<VoronoiFractalTerrain>();
        generator.GenerateTerrain();
    }
#endif
}