public void SolicitMesh(HeightMapAndColorArray heightMapAndColorArray, int LOD, Action <DataOfMesh> method)
    {
        //establece el metodo que se ejecutara cuando se inicie el hilo: mallaThread()
        ThreadStart threadStart = delegate { generateMeshInThread(heightMapAndColorArray, LOD, method); };

        //inicio del hilo
        new Thread(threadStart).Start();
    }
Exemple #2
0
 /// <summary>
 /// Solicita los datos de la malla en un hilo externo
 /// </summary>
 /// <param name="heightAndColoMap"></param>
 public void SolicitDataOfMeshInExternalThread(HeightMapAndColorArray heightAndColoMap)
 {
     _dataOfMeshHasBeenSolicit = true;
     if (_generator == null)
     {
         _generator = FindObjectOfType <ProceduralGenerator>();
     }
     _generator.SolicitMesh(heightAndColoMap, _LOD, DataOfMeshHasBeenReceived);
 }
    /// <summary>
    /// Metodo para obtener los datos de la malla dentro del hilo
    /// </summary>
    /// <param name="heightMapAndColorArray"></param>
    /// <param name="increaseOfLOD"></param>
    /// <param name="Method"></param>
    void generateMeshInThread(HeightMapAndColorArray heightMapAndColorArray, int increaseOfLOD, Action <DataOfMesh> Method)
    {
        //genera la los datos de la malla
        DataOfMesh dataOfMesh = makeMesh(heightMapAndColorArray.HeightMap, increaseOfLOD);

        //Bloqueo si algún otro hilo esta usando la cola para evitar fallos de ejecución. añade a la cola un objeto de la clase ThreadInfoMapa el metodo (metodo) y el parametro que necesita (mapaAyC)
        lock (_queueDataOfMesh)
        {
            _queueDataOfMesh.Enqueue(new ThreadInfo <DataOfMesh>(Method, dataOfMesh));
        }
    }
    /// <summary>
    /// Metodo para obtener los datos del mapa altura y color dentro del hilo
    /// </summary>
    /// <param name="coord"></param>
    /// <param name="center"></param>
    /// <param name="method"></param>
    void generateHeightMapAndColorArrayInThread(Vector2 coord, Vector2 center, Action <HeightMapAndColorArray> method)
    {
        //genera los datos: mapa de alturas y mapa de color
        HeightMapAndColorArray heightMapAndColorArray = generateHeightMapAndColorArray(coord, center);

        //Bloqueo si algún otro hilo esta usando la cola para evitar fallos de ejecución. añade a la cola un objeto de la clase ThreadInfoMapa el metodo (metodo) y el parametro que necesita (mapaAyC)
        lock (_queueHeightMapAndColorArray)
        {
            _queueHeightMapAndColorArray.Enqueue(new ThreadInfo <HeightMapAndColorArray>(method, heightMapAndColorArray));
        }
    }
Exemple #5
0
    /// <summary>
    /// Cuando se reciba la información del mapa de color y de altura se ejecutará este metodo
    /// </summary>
    /// <param name="heightMapAndColorArray"></param>
    private void applyTheHeightMapAndColorArrayToTheObject(HeightMapAndColorArray heightMapAndColorArray)
    {
        _heightMapAndColorArray           = heightMapAndColorArray;
        _heightMapAndColorArrayHaveStored = true;

        Texture2D texture = new Texture2D(_generator.SizeOfChunk, _generator.SizeOfChunk);

        texture.filterMode = FilterMode.Point;
        texture.wrapMode   = TextureWrapMode.Clamp;
        texture.SetPixels(heightMapAndColorArray.ColorArray);
        texture.Apply();

        _meshRenderer.material.mainTexture = texture;

        UpdateThisChunk();
    }
    /// <summary>
    /// Metodo para añadir recursos al mapa
    /// </summary>
    public void AñadirRecursos(Vector3 position, HeightMapAndColorArray heightMapAndColoArray)
    {
        for (int i = 0; i < 25; i++)
        {
            RaycastHit raycastHit;

            //situa en un plano por encima del mapa objetos py hace ray cast para conocer la altura de ese punto.
            if (Physics.Raycast(position + Vector3.up * _heightOfRaycast + Vector3.right * UnityEngine.Random.Range(-180f, 180f) + Vector3.forward * UnityEngine.Random.Range(-180f, 180f), -Vector3.up, out raycastHit))
            {
                if (raycastHit.transform.name == "Chunk")
                {
                    //altura del mapa de ruido, NO altura global de la escena.
                    float heightNoiseMap = heightMapAndColoArray.HeightMap[Mathf.RoundToInt(raycastHit.textureCoord.x * heightMapAndColoArray.HeightMap.GetLength(1)), Mathf.RoundToInt(raycastHit.textureCoord.y * heightMapAndColoArray.HeightMap.GetLength(1))];
                    int   index          = 0;
                    //obtenemos el bioma donde esta situado ese punto
                    while (index < biomes.Length)
                    {
                        if (heightNoiseMap >= biomes[index].Height)
                        {
                            index++;
                        }
                        else
                        {
                            break;
                        }
                    }

                    DataOfResources dataOfResource = new DataOfResources(biomes[index - 1].Name, raycastHit.point);

                    switch (dataOfResource.MyBiome)
                    {
                    case "Agua":
                        break;

                    case "Arena":
                        addResourceInBeach(dataOfResource);
                        break;

                    case "Pradera":
                        addResourceInMeadow(dataOfResource);
                        break;

                    case "Bosque":
                        addResourceInForest(dataOfResource);
                        break;

                    case "BajaM":
                        addResourceInLMountain(dataOfResource);
                        break;

                    case "MediaM":
                        addResourceInMMountain(dataOfResource);
                        break;

                    case "AltaM":
                        addResourceInHMountain(dataOfResource);
                        break;
                    }
                }
            }
        }
    }