private void createTerrainOutput(TerrainOutput terrainOutput)
{
if (terrainOutput.Type.Equals(OutputType.Object))
{
return;
}
UnityEngine.Object tabButtonPrefab = Resources.Load("Prefabs/TabButtonOutput", typeof(GameObject));
GameObject tabButton = (GameObject)Instantiate(tabButtonPrefab);
tabButton.transform.SetParent(TabPanel.transform, false);
System.Console.WriteLine("Output is " + terrainOutput.Title);
tabButton.GetComponentInChildren <Text>().text = terrainOutput.Title;
tabButtons.Add(tabButton);
GameObject layerOutput = null;
UnityEngine.Object terrainOutputPrefab;
switch (terrainOutput.Type)
{
case OutputType.Group:
terrainOutputPrefab = Resources.Load("Prefabs/TerrainOutputGroupPanel", typeof(GameObject));
layerOutput = (GameObject)Instantiate(terrainOutputPrefab);
layerOutput.GetComponent <TerrainOutputGroupPanel>().Init(terrainOutput);
break;
case OutputType.Image:
terrainOutputPrefab = Resources.Load("Prefabs/TerrainOutputImagePanel", typeof(GameObject));
layerOutput = (GameObject)Instantiate(terrainOutputPrefab);
layerOutput.GetComponent <TerrainOutputImagePanel>().Init(terrainOutput);
break;
case OutputType.Mesh:
terrainOutputPrefab = Resources.Load("Prefabs/TerrainOutputMeshPanel", typeof(GameObject));
layerOutput = (GameObject)Instantiate(terrainOutputPrefab);
layerOutput.GetComponent <TerrainOutputMeshPanel>().Init(terrainOutput);
break;
case OutputType.Values:
terrainOutputPrefab = Resources.Load("Prefabs/TerrainOutputValuesPanel", typeof(GameObject));
layerOutput = (GameObject)Instantiate(terrainOutputPrefab);
layerOutput.GetComponent <TerrainOutputValuesPanel>().Init(terrainOutput);
break;
}
tabButton.GetComponent <Button>().onClick.AddListener(() => selectTab(layerOutput, tabButton));
terrainOutputObjects.Add(terrainOutput, layerOutput);
if (firstLayout)
{
firstLayout = false;
selectTab(layerOutput, tabButton);
}
}
internal void Init(TerrainOutput terrainOutput)
{
for (int i = 0; i < ((TerrainOutputValues)terrainOutput).ValueTitles.Count; i++)
{
UnityEngine.Object terrainOutputPrefab = Resources.Load("Prefabs/TerrainOutputValuePanel", typeof(GameObject));
GameObject layerOutput = (GameObject)Instantiate(terrainOutputPrefab);
layerOutput.GetComponentsInChildren <Text>()[0].text = ((TerrainOutputValues)terrainOutput).ValueTitles[i];
layerOutput.GetComponentsInChildren <Text>()[1].text = ((TerrainOutputValues)terrainOutput).Values[i];
layerOutput.transform.SetParent(gameObject.transform);
}
}
internal void Init(TerrainOutput terrainOutput)
{
if (File.Exists(((TerrainOutputImage)terrainOutput).ImagePath))
{
byte[] fileData = File.ReadAllBytes(((TerrainOutputImage)terrainOutput).ImagePath);
Texture2D tex = new Texture2D(2, 2);
tex.LoadImage(fileData);
Image.GetComponent <RectTransform>().sizeDelta = new Vector2(tex.width, tex.height);
Image.GetComponent <RawImage>().texture = tex;
}
}
public static void FillHeightMapMesh(TerrainOutputMesh splittedMesh, GeoPoint[][] heightMapGeoPoints, float cellSize, float minHeight, float maxHeight, List <float[]> grassLand)
{
float maxHeightValue = 0;
for (int x = 0; x < heightMapGeoPoints.Length; x++)
{
for (int y = 0; y < heightMapGeoPoints[x].Length; y++)
{
if (maxHeightValue < heightMapGeoPoints[x][y].Height)
{
maxHeightValue = heightMapGeoPoints[x][y].Height;
}
}
}
int chunk = 0;
float heightFactor = (maxHeight / maxHeightValue) / cellSize;
TerrainOutput terrainOutputSplitted = splitTerrainSegments(heightMapGeoPoints);
for (int x = 0; x < heightMapGeoPoints.Length; x++)
{
for (int y = 0; y < heightMapGeoPoints[x].Length; y++)
{
if (heightMapGeoPoints[x][y].Type.Equals(CellType.Grass))
{
grassLand.Add(new float[] { heightMapGeoPoints[x][y].X, heightMapGeoPoints[x][y].Y, heightMapGeoPoints[x][y].Height * heightFactor });
}
}
}
splittedMesh.CameraPosition = new float[] { 0, heightMapGeoPoints.Length / 4, 0 };
splittedMesh.CameraRotation = new float[] { 22.5f, 45, 0 };
foreach (CellType type in Enum.GetValues(typeof(CellType)))
{
splittedMesh.VertexData.Add(new List <float[]>());
splittedMesh.FacesData.Add(new List <int[]>());
splittedMesh.MaterialColor.Add("");
splittedMesh.MaterialTexture.Add("");
splittedMesh.TexureCoordData.Add(new List <float[]>());
exportSplittedHeightMap(heightMapGeoPoints, splittedMesh, chunk, heightFactor, type);
chunk++;
}
exportTransitionHeightMap_(heightMapGeoPoints, splittedMesh, heightFactor);
}
internal void Init(TerrainOutput terrainOutput)
{
List <Dropdown.OptionData> options = new List <Dropdown.OptionData>();
List <GameObject> layerOutputs = new List <GameObject>();
foreach (TerrainOutput terrainOutput_ in ((TerrainOutputGroup)terrainOutput).ChildOutputs)
{
createTerrainOutput(terrainOutput_, options, layerOutputs);
}
TerrainOutputDropdown.GetComponent <Dropdown>().ClearOptions();
TerrainOutputDropdown.GetComponent <Dropdown>().AddOptions(options);
TerrainOutputDropdown.GetComponent <Dropdown>().onValueChanged.AddListener((idx) => selectTab(idx, layerOutputs));
if (options.Count > 0)
{
selectTab(0, layerOutputs);
}
}
internal void Init(TerrainOutput terrainOutput_)
{
terrainOutput = (TerrainOutputMesh)terrainOutput_;
meshes = new List <Mesh>();
materials = new List <Material>();
subMeshes = new List <List <Mesh> >();
subMaterials = new List <List <Material> >();
processMesh(terrainOutput, meshes, materials);
/*foreach (string meshPath in terrainOutput.MeshPath)
* {
* Mesh mesh = new Mesh();
* ObjImporter newMesh = new ObjImporter();
* mesh = newMesh.ImportFile(meshPath);
* meshes.Add(mesh);
* //mesh.RecalculateNormals();
* }*/
}
private void createTerrainOutput(TerrainOutput terrainOutput, List <Dropdown.OptionData> options, List <GameObject> layerOutputs)
{
options.Add(new Dropdown.OptionData(terrainOutput.Title));
GameObject layerOutput = null;
UnityEngine.Object terrainOutputPrefab;
switch (terrainOutput.Type)
{
case OutputType.Group:
terrainOutputPrefab = Resources.Load("Prefabs/TerrainOutputGroupPanel", typeof(GameObject));
layerOutput = (GameObject)Instantiate(terrainOutputPrefab);
layerOutput.GetComponent <TerrainOutputGroupPanel>().Init(terrainOutput);
break;
case OutputType.Image:
terrainOutputPrefab = Resources.Load("Prefabs/TerrainOutputImagePanel", typeof(GameObject));
layerOutput = (GameObject)Instantiate(terrainOutputPrefab);
layerOutput.GetComponent <TerrainOutputImagePanel>().Init(terrainOutput);
break;
case OutputType.Mesh:
terrainOutputPrefab = Resources.Load("Prefabs/TerrainOutputMeshPanel", typeof(GameObject));
layerOutput = (GameObject)Instantiate(terrainOutputPrefab);
layerOutput.GetComponent <TerrainOutputMeshPanel>().Init(terrainOutput);
break;
case OutputType.Values:
terrainOutputPrefab = Resources.Load("Prefabs/TerrainOutputValuesPanel", typeof(GameObject));
layerOutput = (GameObject)Instantiate(terrainOutputPrefab);
layerOutput.GetComponent <TerrainOutputValuesPanel>().Init(terrainOutput);
break;
}
terrainOutputObjects.Add(terrainOutput, layerOutput);
layerOutputs.Add(layerOutput);
}
private static TerrainOutput ParseParadoxFile()
{
var fileTree = new List <(int Key, object Value)>();
var terrainNames = new List <string>();
var terrains = new List <TerrainEntity>();
var terrainCache = new List <List <FirstLevelCore> >();
var paletteLookups = new List <(Color Palette, int Index)>();
// Generating file tree representation.
FileUnpacker.ParseFile(Path.Combine(Application.streamingAssetsPath, "map", "terrain.txt"),
fileTree, TerrainMagicOverride);
for (var index = 0; index < fileTree.Count; index++)
{
var currentTerrain = terrains[index];
var(breakCores, _) = FileUnpacker.AssignFirstLevelDistributeWorkload(ref currentTerrain, fileTree[index],
TerrainOverride);
terrainCache.Add(breakCores);
bool TerrainOverride((int Key, object Value) target)
{
switch ((LoadVariables)target.Key)
{
case LoadVariables.Palette:
if (!ColorUtility.TryParseHtmlString("#" + (string)target.Value, out var paletteColor))
{
throw new Exception("Unknown hex color. " + (string)target.Value);
}
paletteLookups.Add((paletteColor, index));
return(true);
default:
return(false);
}
}
}
int TerrainMagicOverride(int parent, string str)
{
if (parent != -1)
{
return((int)MagicUnifiedNumbers.ContinueMagicNumbers);
}
terrainNames.Add(str);
terrains.Add(new TerrainEntity {
Name = str
});
return((int)MagicUnifiedNumbers.Terrain + terrainNames.Count - 1);
}
var output = new TerrainOutput(terrainNames, terrains, terrainCache, paletteLookups);
//File.WriteAllText(Path.Combine(Application.streamingAssetsPath, "JsonData", "terrain.txt"),
//JsonUtility.ToJson(output, true));
File.WriteAllBytes(Path.Combine(Application.streamingAssetsPath, "JsonData", "terrain.txt"),
LoadMethods.Zip(JsonUtility.ToJson(output)));
return(output);
}
