public void DrawMap(LandmassMap map, MapDisplayMode displayMode)
    {
        CheckRefs();

        // Store values
        Map = map;

        // If display mode is a texture type
        if (DisplayModeIsTextureType(displayMode))
        {
            // Init vars
            Texture2D texture;

            // Generate texture
            switch (displayMode)
            {
            case MapDisplayMode.Noise:
                texture = TextureGenerator.NewHeightMap(map.Width, map.Height, map.NoiseMap);
                break;

            case MapDisplayMode.Colour:
                texture = TextureGenerator.NewColourMap(map.Width, map.Height, map.ColourMap);
                break;

            default: goto case MapDisplayMode.Noise;
            }

            // Apply texture
            textureRenderer.sharedMaterial.mainTexture = texture;
        }
        // If display mode is a mesh type
        else if (displayMode == MapDisplayMode.Mesh)
        {
            // Generate data
            var meshData = MeshGenerator.GenerateTerrianMesh(map.NoiseMap, map.MeshHeighMultiplier, map.MeshHeightCurve, map.LOD);
            var texture  = TextureGenerator.NewColourMap(map.Width, map.Height, map.ColourMap);

            // Apply data
            meshFilter.sharedMesh = meshData.ToMesh();
            meshRenderer.sharedMaterial.mainTexture = texture;
        }
        else
        {
            // Display mode is invalid
            throw new InvalidStateException("Display mode cannot be " + displayMode.ToString()
                                            + " as no display option is configured for this state");
        }
        transform.localScale = new Vector3(map.Width, (map.Width + map.Height) / 2, map.Height);
    }
    public static LandmassMap GenerateLandmassMap(NoiseGenerator.MapData noiseMapData, TerrainLayer[] terrainLayers, float meshHeightMultiplier, AnimationCurve meshHeightCurve)
    {
        var map = new LandmassMap();

        // Set noise
        var noiseMap = NoiseGenerator.GenerateNoiseMap(noiseMapData);

        if (noiseMap == null)
        {
            return(null);
        }
        map.NoiseMap = noiseMap;

        // Set colours
        Color[] colourMap = new Color[ChunkSize * ChunkSize];
        for (int y = 0; y < ChunkSize; y++)
        {
            for (int x = 0; x < ChunkSize; x++)
            {
                float currentHeight = noiseMap[x, y];
                for (int i = 0; i < terrainLayers.Length; i++)
                {
                    if (currentHeight <= terrainLayers[i].Height)
                    {
                        colourMap[y * ChunkSize + x] = terrainLayers[i].Color;
                        break;
                    }
                }
            }
        }
        map.ColourMap = colourMap;

        // Set mesh height data
        map.MeshHeighMultiplier = meshHeightMultiplier;
        map.MeshHeightCurve     = meshHeightCurve;

        // Set lod
        map.LOD = noiseMapData.LOD;

        return(map);
    }
 public void DrawMap(LandmassMap map) => DrawMap(map, defaultRenderMode);
Example #4
0
 public TemperatureRenderer(LandmassMap landmassmap, TemperatureMap temperaturemap)
 {
     this.landmassmap    = landmassmap;
     this.temperaturemap = temperaturemap;
 }
Example #5
0
 public WindSpeedRenderer(WindMap windmap, LandmassMap landmassmap)
 {
     scale = new ColorScale(Color.blue, Color.red, 0, 1);
     m     = windmap;
     lm    = landmassmap;
 }
Example #6
0
 public WindDirectionRenderer(WindMap windmap, LandmassMap landmassmap)
 {
     m = windmap;
     l = landmassmap;
 }