void Start()
    {
        TextureGenerator myGenerator = new TextureGenerator();

        // Get the mesh we are rendering our output to
        HeightMapRenderer     = transform.Find("HeightTexture").GetComponent <MeshRenderer>();
        BiomeMapRenderer      = transform.Find("BiomeTexture").GetComponent <MeshRenderer>();
        HeatMapRenderer       = transform.Find("HeatTexture").GetComponent <MeshRenderer>();
        MoistureMapRenderer   = transform.Find("MoistureTexture").GetComponent <MeshRenderer>();
        PaletteMapRenderer    = transform.Find("PaletteTexture").GetComponent <MeshRenderer>();
        SettlementMapRenderer = transform.Find("SettlementTexture").GetComponent <MeshRenderer>();
        RailMapManager        = transform.Find("RailTexture").GetComponent <MeshRenderer>();
        RiverMapManager       = transform.Find("RiverTexture").GetComponent <MeshRenderer>();

        // Initialize the generator
        Initialize();
        //LoadTiles(out HeightData);
        //HeightData.Dispose();

        Stopwatch ts = Stopwatch.StartNew(); //BURST NEEDS to be called twice b/c first primes it.

        //CreateHeightMapNoBurst(out HeightData);
        ts.Stop();
        //UnityEngine.Debug.LogWarning("Heightmap Generator w/o Burst: " + ts.ElapsedMilliseconds);
        //HeightData.Dispose();


        ts = Stopwatch.StartNew();
        // Build the height map
        LoadTiles(out HeightData);
        ts.Stop();
        UnityEngine.Debug.LogWarning("Heightmap Generator w/ Burst: " + ts.ElapsedMilliseconds);



        // Build our final objects based on our data

        ts = Stopwatch.StartNew();
        // Render a texture representation of our map

        HeightMapRenderer.materials[0].mainTexture = myGenerator.GetHeightMapTexture(Width, Height, HeightData);

        HeatMapRenderer.materials[0].mainTexture = myGenerator.GetHeatMapTexture(Width, Height, HeightData);

        PaletteMapRenderer.materials[0].mainTexture = myGenerator.GetPalletBase(Width, Height, HeightData);

        MoistureMapRenderer.materials[0].mainTexture = myGenerator.GetMoistureMapTexture(Width, Height, HeightData);

        BiomeMapRenderer.materials[0].mainTexture = myGenerator.GetBiomeMapTexture(Width, Height, HeightData);

        RiverMapManager.materials[0].mainTexture = myGenerator.GetRiverTexture(Width, Height, HeightData);

        myPlanet.materials[0].mainTexture = BiomeMapRenderer.materials[0].mainTexture;



        ts.Stop();
        UnityEngine.Debug.LogWarning("Texture Generator: " + ts.ElapsedMilliseconds);
        HeightData.Dispose();
    }
Exemple #2
0
    public int LoadMap()
    {
        Map loadData = SaveSystem.LoadMap();

        if (loadData != null)
        {
            HeightMapRenderer.materials[0].mainTexture   = TextureGenerator.GetHeightMapTexture(loadData.mapWidth, loadData.mapHeight, loadData.mapTiles);
            HeatMapRenderer.materials[0].mainTexture     = TextureGenerator.GetHeatMapTexture(loadData.mapWidth, loadData.mapHeight, loadData.mapTiles);
            MoistureMapRenderer.materials[0].mainTexture = TextureGenerator.GetMoistureMapTexture(loadData.mapWidth, loadData.mapHeight, loadData.mapTiles);
            BiomeMapRenderer.materials[0].mainTexture    = TextureGenerator.GetBiomeMapTexture(loadData.mapWidth, loadData.mapHeight, loadData.mapTiles, ColdestValue, ColderValue, ColdValue);
            return(0);
        }
        return(-1);
    }
Exemple #3
0
    protected virtual void Generate()
    {
        GetData();
        LoadTiles();
        UpdateNeighbors();

        GenerateRivers();
        BuildRiverGroups();
        DigRiverGroups();
        AdjustMoistureMap();

        UpdateBitmasks();
        FloodFill();

        GenerateBiomeMap();
        UpdateBiomeBitmask();

        HeightMapRenderer.materials[0].mainTexture   = TextureGenerator.GetHeightMapTexture(Width, Height, Tiles);
        HeatMapRenderer.materials[0].mainTexture     = TextureGenerator.GetHeatMapTexture(Width, Height, Tiles);
        MoistureMapRenderer.materials[0].mainTexture = TextureGenerator.GetMoistureMapTexture(Width, Height, Tiles);
        BiomeMapRenderer.materials[0].mainTexture    = TextureGenerator.GetBiomeMapTexture(Width, Height, Tiles, ColdestValue, ColderValue, ColdValue);
    }
Exemple #4
0
    public void CreateMap()
    {
        // LOAD MAP
        cMap = SaveSystem.LoadMap();
        // Create Grid
        PathfindingGridSetup.Instance.CreateGrid(cMap.mapWidth, cMap.mapHeight);
        float cellSize = PathfindingGridSetup.Instance.pathfindingGrid.GetCellSize();

        Debug.Log("cellsize: " + cellSize);
        // Mini Map
        miniMapRenderer.materials[0].mainTexture = TextureGenerator.GetBiomeMapTexture(cMap.mapWidth, cMap.mapHeight, cMap.mapTiles, 0.05f, 0.18f, 0.4f);
        // Convert prefabs into entities
        var settings = GameObjectConversionSettings.FromWorld(World.DefaultGameObjectInjectionWorld, blobAssetStore);
        NativeArray <Entity> entities = new NativeArray <Entity>(13, Allocator.Temp);

        entities[0]  = GameObjectConversionUtility.ConvertGameObjectHierarchy(prefabDesert, settings);
        entities[1]  = GameObjectConversionUtility.ConvertGameObjectHierarchy(prefabSavanna, settings);
        entities[2]  = GameObjectConversionUtility.ConvertGameObjectHierarchy(prefabTropicalRainforest, settings);
        entities[3]  = GameObjectConversionUtility.ConvertGameObjectHierarchy(prefabGrassland, settings);
        entities[4]  = GameObjectConversionUtility.ConvertGameObjectHierarchy(prefabWoodland, settings);
        entities[5]  = GameObjectConversionUtility.ConvertGameObjectHierarchy(prefabSeasonalForest, settings);
        entities[6]  = GameObjectConversionUtility.ConvertGameObjectHierarchy(prefabTemperateRainforest, settings);
        entities[7]  = GameObjectConversionUtility.ConvertGameObjectHierarchy(prefabBorealForest, settings);
        entities[8]  = GameObjectConversionUtility.ConvertGameObjectHierarchy(prefabTundra, settings);
        entities[9]  = GameObjectConversionUtility.ConvertGameObjectHierarchy(prefabIce, settings);
        entities[10] = GameObjectConversionUtility.ConvertGameObjectHierarchy(prefabWater, settings);
        entities[11] = GameObjectConversionUtility.ConvertGameObjectHierarchy(prefabDeepWater, settings);

        var manager = World.DefaultGameObjectInjectionWorld.EntityManager;

        for (int y = 0; y < cMap.mapHeight; y++)
        {
            for (int x = 0; x < cMap.mapWidth; x++)
            {
                var        prefab = entities[GetPrefabFromType(cMap.mapTiles[x, y].BiomeType)];
                HeightType height = cMap.mapTiles[x, y].HeightType;
                Entity     instance;
                bool       collidable = cMap.mapTiles[x, y].Collidable;
                if (height == HeightType.DeepWater)
                {
                    instance = manager.Instantiate(entities[11]);
                    PathfindingGridSetup.Instance.pathfindingGrid.GetGridObject(x, y).SetIsWalkable(false);
                }
                else if (height == HeightType.ShallowWater)
                {
                    instance = manager.Instantiate(entities[10]);
                    PathfindingGridSetup.Instance.pathfindingGrid.GetGridObject(x, y).SetIsWalkable(false);
                }
                else //(height != HeightType.DeepWater && height != HeightType.ShallowWater)
                {
                    instance = manager.Instantiate(prefab);
                    PathfindingGridSetup.Instance.pathfindingGrid.GetGridObject(x, y).SetIsWalkable(collidable);
                }

                var position = transform.TransformPoint(new float3(x + 0.5f, y + 0.5f, 1f));
                manager.SetComponentData(instance, new Translation
                {
                    Value = position
                });
            }
        }
    }