public IDisposable ApplyToShader(ShaderLayerParams layerParams, ComputeShader computeShader)
        {
            computeShader.SetInt("lod", lod);
            computeShader.SetVector("globalPosition", position);
            computeShader.SetFloat("globalScale", layerParams.globalScale);

            return(Disposable.Empty);
        }
        public IDisposable ApplyToShader(ShaderLayerParams layerParams, ComputeShader computeShader)
        {
            var gridInterval = (int)Mathf.Pow(2f, (float)gridLOD);

            computeShader.SetInt("lattice_GridSize", gridSize);
            computeShader.SetInt("lattice_GridInterval", gridInterval);

            ComputeBuffer pointsBuffer = new ComputeBuffer(points.Length, sizeof(float) * 2);

            pointsBuffer.SetData(points);
            computeShader.SetBuffer(0, "lattice_Points", pointsBuffer);

            return(Disposable.Create(pointsBuffer.Release));
        }
        public void GenerateTerrain()
        {
            mutatorData.position = new Vector2(transform.position.x, transform.position.z);

            var lodMultiplier = Mathf.Pow(2, mutatorData.lod);

            TerrainPointData pointData = new TerrainPointData
            {
                data    = new float[mapSize * mapSize],
                mapSize = mapSize
            };

            var minMax = new int[] { int.MaxValue, 0 };

            CompositeDisposable shaderDisposables = new CompositeDisposable();

            var shaderParams = new ShaderLayerParams
            {
                globalScale = globalScale
            };

            perlinData.ApplyToShader(shaderParams, terrainComputeShader)
            .AddTo(shaderDisposables);
            mutatorData.ApplyToShader(shaderParams, terrainComputeShader)
            .AddTo(shaderDisposables);
            latticeGrid.latticeData.ApplyToShader(shaderParams, terrainComputeShader)
            .AddTo(shaderDisposables);
            falloffData.ApplyToShader(shaderParams, terrainComputeShader)
            .AddTo(shaderDisposables);

            RunHeightmapShader(ref minMax, ref pointData.data, mapSize)
            .AddTo(shaderDisposables);

            RunFinalPass(minMax, ref pointData.data)
            .AddTo(shaderDisposables);

            shaderDisposables.Dispose();

            TerrainMeshData terrainData = new TerrainMeshData
            {
                lod       = mutatorData.lod,
                pointData = pointData
            };

            var factory = new TerrainMeshFactory();

            factory.GenerateTerrainMesh(terrainData)
            .Subscribe(mesh => meshFilter.mesh = mesh);
        }
        public IDisposable ApplyToShader(ShaderLayerParams layerParams, ComputeShader computeShader)
        {
            computeShader.SetInt("perlin_Octaves", octaves);
            computeShader.SetFloat("perlin_Lacunarity", lacunarity);
            computeShader.SetFloat("perlin_Persistence", persistance);
            computeShader.SetFloat("perlin_Scale", scale);

            var rnd = new System.Random(seed);

            Vector2[] offsets = new Vector2[octaves];
            for (int i = 0; i < octaves; i++)
            {
                offsets[i] = new Vector2(rnd.Next(-10000, 10000), rnd.Next(-10000, 10000));
            }
            ComputeBuffer offsetsBuffer = new ComputeBuffer(offsets.Length, sizeof(float) * 2);

            offsetsBuffer.SetData(offsets);
            computeShader.SetBuffer(0, "perlin_Offsets", offsetsBuffer);

            return(Disposable.Create(offsetsBuffer.Release));
        }