public static GameObject CreateHighway(OsmWay highwayData, OsmBounds bounds, Transform parent)
{
Vector3[] linePoints = new Vector3[highwayData.Nodes.Count];
for (int i = 0; i < highwayData.Nodes.Count; i++)
{
linePoints[i] = OsmToUnityConverter.GetPointFromUnityPointVec3(highwayData.Nodes[i].Point, bounds);
}
HighwayTypeEnum type = OSMtoSharp.Enums.Helpers.EnumExtensions.
GetTagKeyEnum <HighwayTypeEnum>
(highwayData.Tags[TagKeyEnum.Highway]);
float width = GetHighwayWidth(type);
Color color = GetHighwayColor(type);
GameObject result = LineFactory.CreateLine(linePoints, width, color, new Material(Shader.Find("Sprites/Default")));
if (highwayData.Tags.ContainsKey(TagKeyEnum.Name))
{
result.name = highwayData.Tags[TagKeyEnum.Name];
CreateRoadNameLabel(linePoints, result.name, result.transform);
}
else
{
result.name = "<highway>";
}
result.transform.parent = parent;
return(result);
}
public static Vector2 GetPointFromUnityPointVec2(Point point, OsmBounds bounds)
{
float x = (((float)point.Lat - (float)bounds.MinLat) * Assets.Scripts.Constants.Constants.multipler);
float y = -(((float)point.Lon - (float)bounds.MinLon) * Assets.Scripts.Constants.Constants.multipler);
return(new Vector2(x, y));
}
public static GameObject CreateMesh(OsmWay areaData, OsmBounds bounds, Transform parent)
{
GameObject result = CreateMesh(areaData, bounds);
result.transform.parent = parent;
return(result);
}
public void Clear()
{
Debug.Log("Clearing");
if (nodes != null)
{
nodes.Clear();
}
nodes = null;
if (ways != null)
{
ways.Clear();
}
ways = null;
bounds = null;
var children = new List <GameObject>();
foreach (Transform child in transform)
{
children.Add(child.gameObject);
}
children.ForEach(child => DestroyImmediate(child));
IsReady = false;
}
public static void CreateRoof(OsmWay buildingData, OsmBounds bounds, float height, Transform parent)
{
GameObject roof = OsmMeshFactory.CreateMesh(buildingData, bounds);
roof.transform.localPosition = new Vector3(roof.transform.localPosition.x, height, roof.transform.localPosition.z);
roof.name = "roof";
if (ConfigManager.Instance.Textures)
{
bool colorSet = false;
if (buildingData.Tags.ContainsKey(TagKeyEnum.RoofColour))
{
var colorString = buildingData.Tags[TagKeyEnum.RoofColour].Replace("#", "");
colorSet = SetColor(colorString, roof.GetComponent <Renderer>().material);
colorSet = true;
}
if (!colorSet)
{
string materiaName = string.Format("{0}/{1}_{2}",
Constants.Constants.MaterialsFolderName,
"roof", new System.Random().Next(BuildingsConstants.firstIndexRandomRoof, BuildingsConstants.endIndexRandomRoof));
Material material = Resources.Load(materiaName, typeof(Material)) as Material;
roof.GetComponent <Renderer>().material = material;
}
}
roof.transform.parent = parent;
}
public static void CreateBuilding(OsmWay buildingData, OsmBounds bounds, Transform parent)
{
if (buildingData.Nodes.Count < 3)
{
return;
}
GameObject result = new GameObject();
float levels = 0;
float height = 0;
float minHeight = 0;
if (buildingData.Tags.ContainsKey(TagKeyEnum.Name))
{
result.name = buildingData.Tags[TagKeyEnum.Name];
}
else
{
result.name = "<building>";
}
if (buildingData.Tags.ContainsKey(TagKeyEnum.BuildingLevels))
{
levels += float.Parse(buildingData.Tags[TagKeyEnum.BuildingLevels], CultureInfo.InvariantCulture);
height = levels * BuildingsConstants.wallHeight;
}
if (buildingData.Tags.ContainsKey(TagKeyEnum.BuildingMinLevel))
{
float minLevel = float.Parse(buildingData.Tags[TagKeyEnum.BuildingMinLevel], CultureInfo.InvariantCulture);
levels -= minLevel;
minHeight = BuildingsConstants.wallHeight * minLevel;
}
if (buildingData.Tags.ContainsKey(TagKeyEnum.BuildingHeight))
{
height = float.Parse(buildingData.Tags[TagKeyEnum.BuildingHeight].Replace(" ", "").Replace("m", ""), CultureInfo.InvariantCulture);
}
if (buildingData.Tags.ContainsKey(TagKeyEnum.BuildingMinHeight))
{
minHeight = float.Parse(buildingData.Tags[TagKeyEnum.BuildingMinHeight], CultureInfo.InvariantCulture);
}
if (levels == 0)
{
levels = 1;
}
if (height == 0)
{
height = BuildingsConstants.wallHeight;
}
CreateWalls(buildingData, bounds, BuildingsConstants.wallWidth, levels, height, minHeight, result.transform);
CreateRoof(buildingData, bounds, height, result.transform);
result.transform.parent = parent;
}
private static void WriteBounds(XmlWriter writer, OsmBounds osmBounds)
{
writer.WriteStartElement(Constants.Constants.osmBounds);
writer.WriteAttributeString(Constants.Constants.MinLatString, osmBounds.MinLat.ToString(CultureInfo.InvariantCulture));
writer.WriteAttributeString(Constants.Constants.MinLonString, osmBounds.MinLon.ToString(CultureInfo.InvariantCulture));
writer.WriteAttributeString(Constants.Constants.MaxLatString, osmBounds.MaxLat.ToString(CultureInfo.InvariantCulture));
writer.WriteAttributeString(Constants.Constants.MaxLonString, osmBounds.MaxLon.ToString(CultureInfo.InvariantCulture));
writer.WriteEndElement();
}
public static void CreatePower(OsmNode towerData, OsmBounds bounds, Transform parent)
{
Vector3[] linePoints = new Vector3[2];
linePoints[0] = OsmToUnityConverter.GetPointFromUnityPointVec3(towerData.Point, bounds);
linePoints[1] = linePoints[0];
linePoints[1].y = GetPowerTowerHeight();
float width = GetPowerTowerWidth();
Color color = GetPowerTowerColor();
GameObject result = LineFactory.CreateLine(linePoints, width, color, new Material(Shader.Find("Sprites/Default")));
result.name = "<powertower>";
result.transform.parent = parent;
}
public static void CreateRailway(OsmWay railway, OsmBounds bounds, Transform parent)
{
RailwayTypeEnum type = OSMtoSharp.Enums.Helpers.EnumExtensions.
GetTagKeyEnum <RailwayTypeEnum>
(railway.Tags[TagKeyEnum.Railway]);
Vector3[] linePoints = new Vector3[railway.Nodes.Count];
for (int i = 0; i < railway.Nodes.Count; i++)
{
linePoints[i] = OsmToUnityConverter.GetPointFromUnityPointVec3(railway.Nodes[i].Point, bounds);
}
float width = GetHighwayWidth(type);
Color color = GetHighwayColor(type);
GameObject result = LineFactory.CreateLine(linePoints, width, color, new Material(Shader.Find("Sprites/Default")));
result.name = "<railway>";
result.transform.parent = parent;
}
public static GameObject CreateMesh(OsmWay areaData, OsmBounds bounds)
{
var buildingCorners = new List <Vector3>();
for (int i = 0; i < areaData.Nodes.Count - 1; i++)
{
buildingCorners.Add(OsmToUnityConverter.GetPointFromUnityPointVec3(areaData.Nodes[i].Point, bounds));
}
GameObject result = new GameObject();
result.AddComponent <MeshRenderer>();
MeshFilter mf = result.AddComponent <MeshFilter>();
if (buildingCorners.Count > 2)
{
Mesh mesh = Assets.Scripts.Factories.Unity.UnityMeshFactory.CreateMesh(buildingCorners);
mf.mesh = mesh;
}
return(result);
}
public static void CreatePower(OsmWay lineData, OsmBounds bounds, Transform parent)
{
GameObject result = new GameObject();
result.name = "<powerline>";
PowerTypeEnum type = OSMtoSharp.Enums.Helpers.EnumExtensions.
GetTagKeyEnum <PowerTypeEnum>
(lineData.Tags[TagKeyEnum.Power]);
Vector3[] linePoints = new Vector3[lineData.Nodes.Count];
for (int i = 0; i < lineData.Nodes.Count; i++)
{
linePoints[i] = OsmToUnityConverter.GetPointFromUnityPointVec3(lineData.Nodes[i].Point, bounds);
linePoints[i].y = GetPowerLineHeight(type);
}
LineRenderer lineRender = result.AddComponent <LineRenderer>();
lineRender.positionCount = lineData.Nodes.Count;
lineRender.material = new Material(Shader.Find("Sprites/Default"));
float width = GetPowerLineWidth(type);
Color color = GetPowerLineColor(type);
lineRender.startWidth = width;
lineRender.endWidth = width;
lineRender.startColor = color;
lineRender.endColor = color;
lineRender.SetPositions(linePoints);
result.transform.parent = parent;
}
void SetBounds(XmlNode xmlNode)
{
bounds = new OsmBounds(xmlNode);
}
private object ParseChild(XmlElement xmlNode, OsmFile osm)
{
var name = xmlNode.Name;
var attrs = xmlNode.Attributes;
var result = default(object);
if (name == "bounds")
{
var bounds = new OsmBounds();
ApplyAttributes(attrs, bounds);
osm.Bounds = bounds;
result = bounds;
}
else if (name == "node")
{
var node = new OsmNode();
ApplyAttributes(attrs, node);
osm.Nodes.Add(node);;
foreach (XmlElement xmlNodeChildNode in xmlNode.ChildNodes)
{
var childElement = ParseChild(xmlNodeChildNode, osm);
if (childElement.GetType() == typeof(OsmTag))
{
node.Tags.Add((OsmTag)childElement);
}
}
result = node;
}
else if (name == "tag")
{
var tag = new OsmTag();
ApplyAttributes(attrs, tag);
result = tag;
}
else if (name == "way")
{
var way = new OsmWay();
ApplyAttributes(attrs, way);
osm.Ways.Add(way);
foreach (XmlElement xmlNodeChildNode in xmlNode.ChildNodes)
{
var childElement = ParseChild(xmlNodeChildNode, osm);
if (childElement.GetType() == typeof(OsmTag))
{
way.Tags.Add((OsmTag)childElement);
}
else if (childElement.GetType() == typeof(OsmNd))
{
way.Nds.Add((OsmNd)childElement);
}
}
result = way;
}
else if (name == "nd")
{
var nd = new OsmNd();
ApplyAttributes(attrs, nd);
result = nd;
}
return(result);
}
public static void CreateArea(OsmWay areaData, OsmBounds bounds, Transform parent)
{
Material material = null;
if (ConfigManager.Instance.Textures)
{
if (areaData.Tags.ContainsKey(TagKeyEnum.Landuse))
{
Enums.LanduseTypeEnum type = OSMtoSharp.Enums.Helpers.EnumExtensions.GetTagKeyEnum <Enums.LanduseTypeEnum>(areaData.Tags[TagKeyEnum.Landuse]);
if (type != Enums.LanduseTypeEnum.None)
{
string materiaName = string.Format("{0}/{1}_{2}",
Constants.Constants.MaterialsFolderName,
OSMtoSharp.Enums.Helpers.EnumExtensions.GetEnumAttributeValue(TagKeyEnum.Landuse),
OSMtoSharp.Enums.Helpers.EnumExtensions.GetEnumAttributeValue(type));
material = Resources.Load(materiaName, typeof(Material)) as Material;
}
}
if (areaData.Tags.ContainsKey(TagKeyEnum.Leisure))
{
Enums.LeisureTypeEnum type = OSMtoSharp.Enums.Helpers.EnumExtensions.GetTagKeyEnum <Enums.LeisureTypeEnum>(areaData.Tags[TagKeyEnum.Leisure]);
if (type != Enums.LeisureTypeEnum.None)
{
string materiaName = string.Format("{0}/{1}_{2}",
Constants.Constants.MaterialsFolderName,
OSMtoSharp.Enums.Helpers.EnumExtensions.GetEnumAttributeValue(TagKeyEnum.Leisure),
OSMtoSharp.Enums.Helpers.EnumExtensions.GetEnumAttributeValue(type));
material = Resources.Load(materiaName, typeof(Material)) as Material;
}
}
if (areaData.Tags.ContainsKey(TagKeyEnum.Amenity))
{
Enums.AmenityTypeEnum type = OSMtoSharp.Enums.Helpers.EnumExtensions.GetTagKeyEnum <Enums.AmenityTypeEnum>(areaData.Tags[TagKeyEnum.Amenity]);
if (type != Enums.AmenityTypeEnum.None)
{
string materiaName = string.Format("{0}/{1}_{2}",
Constants.Constants.MaterialsFolderName,
OSMtoSharp.Enums.Helpers.EnumExtensions.GetEnumAttributeValue(TagKeyEnum.Amenity),
OSMtoSharp.Enums.Helpers.EnumExtensions.GetEnumAttributeValue(type));
material = Resources.Load(materiaName, typeof(Material)) as Material;
}
}
if (material != null)
{
GameObject result = OsmMeshFactory.CreateMesh(areaData, bounds);
if (areaData.Tags.ContainsKey(TagKeyEnum.Name))
{
result.name = areaData.Tags[TagKeyEnum.Name];
}
else
{
result.name = "landuse";
}
result.GetComponent <Renderer>().material = material;
result.transform.parent = parent;
}
}
}
public static void CreateWalls(OsmWay buildingData, OsmBounds bounds, float width, float levels, float height, float minHeight, Transform parent)
{
BuildingsTypeEnum type = OSMtoSharp.Enums.Helpers.EnumExtensions.
GetTagKeyEnum <BuildingsTypeEnum>
(buildingData.Tags[TagKeyEnum.Building]);
string materiaName;
Material material = null;
if (ConfigManager.Instance.Textures)
{
if (!buildingData.Tags.ContainsKey(TagKeyEnum.BuildingColor))
{
if (buildingData.Tags.ContainsKey(TagKeyEnum.Shop) || buildingData.Tags.ContainsKey(TagKeyEnum.Shop1) || buildingData.Tags.ContainsKey(TagKeyEnum.Shop2))
{
materiaName = string.Format("{0}/{1}_{2}",
Constants.Constants.MaterialsFolderName,
"shop", new System.Random().Next(BuildingsConstants.firstIndexRandomShop, BuildingsConstants.endIndexRandomShop));
}
else if (type == BuildingsTypeEnum.House ||
type == BuildingsTypeEnum.Apartments ||
type == BuildingsTypeEnum.Bungalow ||
type == BuildingsTypeEnum.Detached ||
type == BuildingsTypeEnum.Greenhouse ||
type == BuildingsTypeEnum.Residential
)
{
materiaName = string.Format("{0}/{1}_{2}",
Constants.Constants.MaterialsFolderName,
OSMtoSharp.Enums.Helpers.EnumExtensions.GetEnumAttributeValue(TagKeyEnum.Building),
OSMtoSharp.Enums.Helpers.EnumExtensions.GetEnumAttributeValue(BuildingsTypeEnum.House));
}
else if (type == BuildingsTypeEnum.Hotel ||
type == BuildingsTypeEnum.Commercial
)
{
materiaName = string.Format("{0}/{1}_{2}",
Constants.Constants.MaterialsFolderName,
OSMtoSharp.Enums.Helpers.EnumExtensions.GetEnumAttributeValue(TagKeyEnum.Building),
OSMtoSharp.Enums.Helpers.EnumExtensions.GetEnumAttributeValue(BuildingsTypeEnum.Hotel));
}
else
{
materiaName = string.Format("{0}/{1}_{2}",
Constants.Constants.MaterialsFolderName,
OSMtoSharp.Enums.Helpers.EnumExtensions.GetEnumAttributeValue(TagKeyEnum.Building),
new System.Random().Next(BuildingsConstants.firstIndexRandomBuilding, BuildingsConstants.endIndexRandomBuilding));
}
material = Resources.Load(materiaName, typeof(Material)) as Material;
}
}
for (int i = 1; i < buildingData.Nodes.Count; i++)
{
Vector2 pointA = OsmToUnityConverter.GetPointFromUnityPointVec2(buildingData.Nodes[i].Point, bounds);
Vector2 pointB = OsmToUnityConverter.GetPointFromUnityPointVec2(buildingData.Nodes[i - 1].Point, bounds);
GameObject wall = CreateWall(new Vector3(pointA.x, minHeight, pointA.y),
new Vector3(pointB.x, minHeight, pointB.y),
width, height, minHeight);
if (buildingData.Tags.ContainsKey(TagKeyEnum.BuildingColor))
{
var color = buildingData.Tags[TagKeyEnum.BuildingColor].Replace("#", "");
SetColor(color, wall.GetComponent <Renderer>().material);
}
else
{
if (material != null)
{
Material mat = new Material(material);
int tilingX = (int)wall.transform.localScale.z;
if (tilingX == 0)
{
tilingX = 1;
}
mat.mainTextureScale = new Vector2(tilingX, levels);
wall.GetComponent <Renderer>().material = mat;
}
}
wall.transform.SetParent(parent);
}
}
