コード例 #1
0
    private MapData GenerarMapData(Vector2 centro)
    {
        //Mapa de ruido. El penultimo parametro es para que genere mapas diferentes en diferentes chunks
        float[,] mapaRuido = Ruido.GeneradorRuido(tamañoMapaChunk, tamañoMapaChunk, seed, escaladoRuido, octaves, persistencia, lacunaridad, centro + offset, normalizeMode);

        //Mapa de colores
        Color[] mapaColores = new Color[tamañoMapaChunk * tamañoMapaChunk];
        for (int y = 0; y < tamañoMapaChunk; y++)
        {
            for (int x = 0; x < tamañoMapaChunk; x++)
            {
                if (useFalloff)
                {
                    mapaRuido[x, y] = Mathf.Clamp01(mapaRuido[x, y] - falloffMap[x, y]);
                }

                float alturaActual = mapaRuido[x, y];
                for (int i = 0; i < terrenos.Length; i++)
                {
                    //Devolvemos el color dentro del cual este la altura de este punto
                    if (alturaActual >= terrenos[i].altura)
                    {
                        mapaColores[y * tamañoMapaChunk + x] = terrenos[i].color;
                    }
                    else
                    {
                        break;
                    }
                }
            }
        }
        return(new MapData(mapaRuido, mapaColores));
    }
コード例 #2
0
    public Mesh GenerarMeshTerreno()
    {
        //Mapa de ruido
        mapaRuido  = Ruido.GeneradorRuido(dimensionMapa, dimensionMapa, semilla, escala, octaves, persistencia, lacunaridad, offset, Ruido.NormalizeMode.Local);
        falloffMap = FalloffGenerator.GenerateFalloffMap(dimensionMapa);

        //Inicializamos con floats porque si, para que este inicializado con algo
        DatosMesh datosMesh = DatosMeshFloats();

        if (modoAltura == ModoAltura.Floats)
        {
            datosMesh = DatosMeshFloats();
        }
        else if (modoAltura == ModoAltura.Enteros)
        {
            datosMesh = DatosMeshEnteros();
        }

        mesh = CrearMesh(datosMesh.vertices, datosMesh.triangulos, datosMesh.uvs);
        return(mesh);
    }
コード例 #3
0
    //IEnumerator CreateShape(){
    void CreateShape()
    {
        vertices  = new List <Vector3>();
        normales  = new List <Vector3>();
        mapaRuido = Ruido.GeneradorRuido(filas, columnas, 4, escalado, 30, 0.5f, 2f, new Vector2(0, 0), Ruido.NormalizeMode.Local);
        float xR = comienzoRuido; float yR = comienzoRuido;

        for (int z = 0; z <= filas; z++)
        {
            xR = comienzoRuido;
            for (int x = 0; x <= columnas; x++)
            {
                //float y = Mathf.PerlinNoise(xR, yR) * escalado;
                //float y = Mathf.PerlinNoise(x * .3f, z * .3f) * escalado;
                //float y = (x==columnas || z==filas )? Mathf.PerlinNoise(xR, yR) * escalado : mapaRuido[x,z] * escalado;
                //NOTA: En unity la altura es Y asi que vamos a usar solo x y z
                float y = Mathf.PerlinNoise(x, z) * escalado;
                print("x: " + x + " z: " + z);
                print("y: " + y);
                vertices.Add(new Vector3(x, y, z));
                normales.Add(Vector3.up);

                xR += aumentoRuido;
            }
            yR += aumentoRuido;
        }

        triangulos = new int[columnas * filas * 6];
        int triang = 0;
        int vert   = 0;

        for (int z = 0; z < filas; z++)
        {
            for (int x = 0; x < columnas; x++)
            {
                triangulos[triang + 0] = vert + 0;
                triangulos[triang + 1] = vert + columnas + 1;
                triangulos[triang + 2] = vert + 1;
                triangulos[triang + 3] = vert + 1;
                triangulos[triang + 4] = vert + columnas + 1;
                triangulos[triang + 5] = vert + columnas + 2;

                vert++;
                triang += 6;
            }
            vert++;
            //yield return new WaitForSeconds(0.1f);
        }
        //Prueba quads
        quads = new int[columnas * filas * 4];
        int qd = 0;

        vert = 0;
        for (int z = 0; z < filas; z++)
        {
            for (int x = 0; x < columnas; x++)
            {
                quads[qd + 0] = vert + 0;
                quads[qd + 1] = vert + 1;
                quads[qd + 2] = vert + columnas + 2;
                quads[qd + 3] = vert + columnas + 1;

                vert++;
                qd += 4;
            }
            vert++;
        }
    }