public GameObject BuildPolygonFromPreloaded(GOFeature feature)
{
if (feature.preloadedMeshData == null)
{
return(null);
}
GameObject polygon = new GameObject();
MeshFilter filter = polygon.AddComponent <MeshFilter>();
meshRenderer = polygon.AddComponent <MeshRenderer>();
Mesh mesh = feature.preloadedMeshData.ToMesh();
if (feature.height > 0 && feature.layer.layerType == GOLayer.GOLayerType.Buildings)
{
SimpleExtruder.FixUV(mesh, feature.preloadedMeshData.sliceHeight);
}
filter.sharedMesh = mesh;
if (feature.layer.useColliders && mesh != null && feature.convertedGeometry.Count() > 2)
{
polygon.AddComponent <MeshCollider> ();
}
return(polygon);
}
public static GOMesh PreloadLine(GOFeature feature)
{
if (feature.convertedGeometry.Count == 2 && feature.convertedGeometry[0].Equals(feature.convertedGeometry[1]))
{
return(null);
}
GOMesh preMesh = new GOMesh();
GOLineMesh lineMesh = new GOLineMesh(feature.convertedGeometry);
lineMesh.width = feature.renderingOptions.lineWidth;
preMesh = lineMesh.CreatePremesh();
if (feature.height > 0)
{
float h = feature.height;
if (GOMap.GOLink)
{
h += GOFeature.BuildingElevationOffset;
}
preMesh = SimpleExtruder.SliceExtrudePremesh(preMesh, h + Noise(), 4f, 4f, 10f);
}
if (feature.renderingOptions.outlineWidth > 0)
{
lineMesh.width = feature.renderingOptions.lineWidth + feature.layer.defaultRendering.outlineWidth;
preMesh.secondaryMesh = lineMesh.CreatePremesh();
}
return(preMesh);
}
public static GOMesh PreloadFeatureData(GOFeature feature)
{
try {
switch (feature.goFeatureType)
{
case GOFeatureType.Polygon:
case GOFeatureType.MultiPolygon:
if (!feature.layer.isPolygon)
{
return(PreloadLine(feature));
}
else if (feature.goTile.useElevation && feature.layer.layerType != GOLayer.GOLayerType.Buildings)
{
return(Preload3DPolygon(feature));
}
else
{
return(PreloadPolygon(feature));
}
case GOFeatureType.Line:
case GOFeatureType.MultiLine:
return(PreloadLine(feature));
default:
return(null);
}
} catch (Exception ex) {
Debug.LogWarning("[GOMAP] error catched in feature: " + feature.name + ", " + feature.kind + ", " + feature.convertedGeometry + ", " + ex);
return(null);
}
}
public override GOFeature EditFeatureData(GOFeature goFeature)
{
IDictionary properties = goFeature.properties;
if (goFeature.goFeatureType == GOFeatureType.Point)
{
goFeature.name = (string)goFeature.properties ["name"];
return(goFeature);
}
else
{
goFeature.name = goFeature.layer.name;
}
goFeature.kind = GOEnumUtils.MapboxToKind(goFeature.layer.name);
goFeature.setRenderingOptions();
goFeature.y = goFeature.layer.defaultLayerY();
if (properties.Contains("_symbol"))
{
goFeature.y = Convert.ToInt64(properties ["_symbol"]) / 15.0f;
}
// float fraction = 20f;
// goFeature.y = (1 + goFeature.layerIndex + goFeature.featureIndex/goFeature.featureCount)/fraction;
goFeature.height = goFeature.layer.defaultRendering.polygonHeight;
return(goFeature);
}
private void ComputeFeatureRanges(GOFeature feature)
{
xRange.x = xRange.y = feature.convertedGeometry [0].x;
zRange.x = zRange.y = feature.convertedGeometry [0].z;
foreach (Vector3 v in feature.convertedGeometry)
{
if (v.x > xRange.y)
{
xRange.y = v.x;
}
if (v.x < xRange.x)
{
xRange.x = v.x;
}
if (v.z > zRange.y)
{
zRange.y = v.z;
}
if (v.z < zRange.x)
{
zRange.x = v.z;
}
}
}
public override GOFeature EditLabelData(GOFeature goFeature)
{
goFeature.name = (string)goFeature.properties ["name"];
goFeature.kind = GOEnumUtils.MapzenToKind((string)goFeature.properties ["kind"]);
if (goFeature.properties.Contains("kind_detail")) //Mapzen
{
goFeature.kind = GOEnumUtils.MapzenToKind((string)goFeature.properties ["kind_detail"]);
}
Int64 sort = 0;
if (goFeature.properties.Contains("sort_rank"))
{
sort = Convert.ToInt64(goFeature.properties ["sort_rank"]);
}
else if (goFeature.properties.Contains("sort_key"))
{
sort = Convert.ToInt64(goFeature.properties ["sort_key"]);
}
goFeature.y = sort / 1000.0f;
goFeature.sort = sort;
return(goFeature);
}
public static GOMesh PreloadFeatureData(GOFeature feature)
{
try {
switch (feature.goFeatureType)
{
case GOFeatureType.Polygon:
return(PreloadPolygon(feature));
case GOFeatureType.MultiPolygon:
return(PreloadPolygon(feature));
case GOFeatureType.Line:
return(PreloadLine(feature));
case GOFeatureType.MultiLine:
return(PreloadLine(feature));
default:
return(null);
}
} catch (Exception ex) {
Debug.LogWarning("[GOMAP] error catched in feature: " + feature.name + ", " + feature.kind + ", " + feature.convertedGeometry + ", " + ex);
return(null);
}
}
public override GOFeature EditFeatureData(GOFeature goFeature)
{
IDictionary properties = goFeature.properties;
if (goFeature.goFeatureType == GOFeatureType.Point)
{
goFeature.name = (string)goFeature.properties ["name"];
return(goFeature);
}
if (goFeature.layer != null && goFeature.layer.layerType == GOLayer.GOLayerType.Roads)
{
((GORoadFeature)goFeature).isBridge = properties.Contains("brunnel") && (string)properties ["brunnel"] == "bridge";
((GORoadFeature)goFeature).isTunnel = properties.Contains("brunnel") && (string)properties ["brunnel"] == "tunnel";
((GORoadFeature)goFeature).isLink = properties.Contains("brunnel") && (string)properties ["brunnel"] == "link";
}
goFeature.kind = GOEnumUtils.MapboxToKind((string)properties["class"]);
// goFeature.y = goFeature.featureIndex/1000 + goFeature.layer.defaultLayerY();
// if (goFeature.kind == GOFeatureKind.lake) //terrible fix for vector maps without a sort value.
// goFeature.y = GOLayer.defaultLayerY (GOLayer.GOLayerType.Landuse)+0.1f;
float fraction = 20f;
goFeature.y = (1 + goFeature.layerIndex + goFeature.featureIndex / goFeature.featureCount) / fraction;
if (goFeature.kind == GOFeatureKind.lake) //terrible fix for vector maps without a sort value.
{
goFeature.y += 0.5f;
}
goFeature.setRenderingOptions();
goFeature.height = goFeature.renderingOptions.polygonHeight;
if (goFeature.layer.useRealHeight && properties.Contains("render_height"))
{
double h = Convert.ToDouble(properties["render_height"]);
goFeature.height = (float)h;
}
if (goFeature.layer.useRealHeight && properties.Contains("render_min_height"))
{
double hm = Convert.ToDouble(properties["render_min_height"]);
goFeature.y = (float)hm;
if (goFeature.height >= hm)
{
goFeature.y = (float)hm;
goFeature.height = (float)goFeature.height - (float)hm;
}
}
if (goFeature.layer.forceMinHeight && goFeature.height < goFeature.renderingOptions.polygonHeight && goFeature.y < 0.5f)
{
goFeature.height = goFeature.renderingOptions.polygonHeight;
}
return(goFeature);
}
public GOFeatureMeshBuilder(GOFeature f)
{
feature = f;
if (feature.goFeatureType == GOFeatureType.Polygon || feature.goFeatureType == GOFeatureType.MultiPolygon)
{
center = feature.convertedGeometry.Aggregate((acc, cur) => acc + cur) / feature.convertedGeometry.Count;
}
}
public GameObject CreateRoofFromPreloaded(GOFeature feature, GOMesh premesh, GameObject parent)
{
GameObject roof = GameObject.Instantiate(feature.goTile.featurePrototype, parent.transform);
MeshFilter filter = roof.GetComponent <MeshFilter>();
filter.mesh = premesh.ToMesh();
return(roof);
}
private void AddFatureToList(GOFeature f, IList list)
{
f.preloadedMeshData = GOFeatureMeshBuilder.PreloadFeatureData(f);
if (f.goFeatureType == GOFeatureType.Point || f.goFeatureType == GOFeatureType.Label || f.preloadedMeshData != null)
{
list.Add(f);
}
}
public GameObject BuildPolygonFromPreloaded(GOFeature feature, GameObject parent)
{
if (feature.preloadedMeshData == null)
{
return(null);
}
GameObject polygon = GameObject.Instantiate(feature.goTile.featurePrototype, parent.transform);
meshRenderer = polygon.GetComponent <MeshRenderer>();
Mesh mesh = null;
Profiler.BeginSample("Load preloaded mesh data");
if (feature.renderingOptions.hasRoof) //&& feature.roofMat != null) {
{
if (feature.layer.outlinedPolygon)
{
mesh = feature.preloadedMeshData.ToOutlinedPolygonMesh();
}
else
{
mesh = feature.preloadedMeshData.ToSubmeshes();
}
}
else
{
mesh = feature.preloadedMeshData.ToMesh();
}
Profiler.EndSample();
// if (feature.layer.layerType == GOLayer.GOLayerType.Buildings && feature.height > 0 && feature.layer.useRealHeight)
// SimpleExtruder.FixUV (mesh, feature.preloadedMeshData.sliceHeight,10f);
polygon.GetComponent <MeshFilter>().sharedMesh = mesh;
if (feature.layer.useColliders && mesh != null && feature.convertedGeometry.Count() > 2)
{
MeshCollider collider = polygon.GetComponent <MeshCollider> ();
collider.enabled = true;
collider.sharedMesh = mesh;
if (feature.height < feature.layer.colliderHeight)
{
//GameObject colliderGameObject = new GameObject("Collider");
//colliderGameObject.transform.parent = polygon.transform;
//MeshCollider collider2 = colliderGameObject.AddComponent<MeshCollider>();
//collider2.enabled = true;
//collider2.sharedMesh = feature.preloadedMeshData.secondaryMesh.ToMesh();
//MeshCollider.Destroy(collider);
collider.sharedMesh = feature.preloadedMeshData.secondaryMesh.ToMesh();
}
}
return(polygon);
}
private void breakLine(GOFeature f)
{
#if GOLINK
if (GOMap.GOLink)
{
f.convertedGeometry = GOFeatureMeshBuilder.BreakLine(f.convertedGeometry, tile.map.goTerrain);
}
#endif
}
public void OnFeatureLoad(GOFeature feature, GameObject featureObject)
{
if (feature.layer.layerType == GOLayer.GOLayerType.Buildings)
{
foreach (GOEnvironmentKind kind in buildings)
{
bool kindCondition = kind.kind == feature.kind;
// if (kindCondition) {
// if (Application.isPlaying)
// StartCoroutine (SpawnBuildings (feature, featureObject, kind));
// else
// GORoutine.start (SpawnBuildings (feature, featureObject, kind), this);
// }
}
}
else if (goMap.useElevation == true)
{
foreach (GOEnvironmentKind kind in featureEnvironment)
{
bool kindCondition = kind.kind == feature.kind;
bool layerCondition = kind.layer == feature.layer.layerType && kind.kind == GOFeatureKind.baseKind;
if (kindCondition || layerCondition)
{
if (Application.isPlaying)
{
StartCoroutine(SpawnPrefabsIn3DMesh(feature, featureObject, kind));
}
else
{
GORoutine.start(SpawnPrefabsIn3DMesh(feature, featureObject, kind), this);
}
}
}
}
else
{
foreach (GOEnvironmentKind kind in featureEnvironment)
{
bool kindCondition = kind.kind == feature.kind;
bool layerCondition = kind.layer == feature.layer.layerType && kind.kind == GOFeatureKind.baseKind;
if (kindCondition || layerCondition)
{
if (Application.isPlaying)
{
StartCoroutine(SpawnPrefabsInMesh(feature, featureObject, kind));
}
else
{
GORoutine.start(SpawnPrefabsInMesh(feature, featureObject, kind), this);
}
}
}
}
}
private void ParseLabelLayerToList(List <GOParsedLayer> list, VectorTile vt, GOLabelsLayer layer)
{
string[] lyrs = tile.GetLabelsStrings().Split(',');
// string kindKey = tile.GetPoisKindKey();
foreach (string l in lyrs)
{
VectorTileLayer lyr = vt.GetLayer(l);
if (lyr != null)
{
int featureCount = lyr.FeatureCount();
if (featureCount == 0)
{
continue;
}
GOParsedLayer pl = new GOParsedLayer();
pl.name = lyr.Name;
pl.labelsLayer = layer;
pl.goFeatures = new List <GOFeature> ();
for (int i = 0; i < featureCount; i++)
{
VectorTileFeature vtf = lyr.GetFeature(i);
IDictionary properties = vtf.GetProperties();
List <List <LatLng> > geomWgs = vtf.GeometryAsWgs84((ulong)goTile.zoomLevel, (ulong)goTile.tileCoordinates.x, (ulong)goTile.tileCoordinates.y, 0);
if (geomWgs.Count == 0 || geomWgs[0].Count <= 1)
{
continue;
}
GOFeature gf = new GOFeature();
gf.properties = properties;
gf.goFeatureType = vtf.GOFeatureType(geomWgs);
gf.labelsLayer = layer;
gf.featureIndex = (Int64)i + vt.LayerNames().IndexOf(lyr.Name);
gf.goTile = goTile;
gf = tile.EditLabelData(gf);
gf.goFeatureType = GOFeatureType.Label;
gf.ConvertAttributes();
if (geomWgs.Count > 0)
{
gf.geometry = geomWgs[0];
gf.ConvertGeometries();
gf.preloadedLabelData = GOSegment.FindTheLongestStreightSegment(gf.convertedGeometry, 0);
AddFatureToList(gf, pl.goFeatures);
}
}
list.Add(pl);
}
}
}
public override GOFeature EditLabelData(GOFeature goFeature)
{
IDictionary properties = goFeature.properties;
goFeature.name = (string)goFeature.properties ["name"];
goFeature.kind = GOEnumUtils.MapboxToKind((string)properties["class"]);
goFeature.y = goFeature.getLayerDefaultY();
return(goFeature);
}
public override GOFeature EditFeatureData(GOFeature goFeature)
{
if (goFeature.goFeatureType == GOFeatureType.Point)
{
goFeature.name = (string)goFeature.properties ["name"];
return(goFeature);
}
IDictionary properties = goFeature.properties;
if (goFeature.layer != null && goFeature.layer.layerType == GOLayer.GOLayerType.Roads)
{
((GORoadFeature)goFeature).isBridge = properties.Contains("structure") && (string)properties ["structure"] == "bridge";
((GORoadFeature)goFeature).isTunnel = properties.Contains("structure") && (string)properties ["structure"] == "tunnel";
((GORoadFeature)goFeature).isLink = properties.Contains("structure") && (string)properties ["structure"] == "link";
}
goFeature.kind = GOEnumUtils.MapboxToKind((string)properties["class"]);
goFeature.name = (string)properties ["class"];
// goFeature.y = (goFeature.index / 50.0f) + goFeature.getLayerDefaultY() /150.0f;
// float fraction = goFeature.layer.layerType == GOLayer.GOLayerType.Buildings? 100f:10f;
float fraction = 20f;
goFeature.y = (1 + goFeature.layerIndex + goFeature.featureIndex / goFeature.featureCount) / fraction;
goFeature.setRenderingOptions();
goFeature.height = goFeature.renderingOptions.polygonHeight;
bool extrude = properties.Contains("extrude") && (string)properties["extrude"] == "true";
if (goFeature.layer.useRealHeight && properties.Contains("height") && extrude)
{
double h = Convert.ToDouble(properties["height"]);
goFeature.height = (float)h;
}
if (goFeature.layer.useRealHeight && properties.Contains("min_height") && extrude)
{
double minHeight = Convert.ToDouble(properties["min_height"]);
goFeature.y = (float)minHeight;
goFeature.height = (float)goFeature.height - (float)minHeight;
}
if (goFeature.height < goFeature.layer.defaultRendering.polygonHeight && goFeature.y == 0)
{
goFeature.height = goFeature.layer.defaultRendering.polygonHeight;
}
return(goFeature);
}
public override GOFeature EditLabelData(GOFeature goFeature)
{
goFeature.name = (string)goFeature.properties ["_name_global"];
goFeature.kind = GOEnumUtils.MapboxToKind(goFeature.labelsLayer.name);
goFeature.y = goFeature.getLayerDefaultY() + 1;
// if (properties.Contains ("_symbol"))
// goFeature.y = Convert.ToInt64 (properties ["_symbol"]) / 10.0f;
return(goFeature);
}
public static GOMesh PreloadLine(GOFeature feature)
{
if (feature.convertedGeometry.Count == 2 && feature.convertedGeometry[0].Equals(feature.convertedGeometry[1]))
{
return(null);
}
GOMesh preMesh = new GOMesh();
GOLineMesh lineMesh = new GOLineMesh(feature, true);
lineMesh.width = feature.renderingOptions.lineWidth * feature.goTile.worldScale;
preMesh = lineMesh.CreatePremesh();
feature.isLoop = lineMesh.isLoop;
// GORoad road = new GORoad (feature, 25, 1, 0);
// road.computeRoad ();
// preMesh = road.goMesh;
if (feature.goTile.useElevation && feature.height == 0)
{
feature.height += GOFeature.RoadsHeightForElevation;
}
if (feature.height > 0)
{
float h = feature.height * feature.goTile.worldScale;
if (feature.goTile.useElevation)
{
h += GOFeature.BuildingElevationOffset;
}
preMesh = SimpleExtruder.ExtrudePremesh(preMesh, h + Noise(), false);
}
if (feature.renderingOptions.outlineWidth > 0 && !feature.goTile.useElevation)
{
lineMesh.width = (feature.renderingOptions.lineWidth + feature.layer.defaultRendering.outlineWidth) * feature.goTile.worldScale;
preMesh.secondaryMesh = lineMesh.CreatePremesh();
if (feature.height > 0)
{
float h = feature.height * feature.goTile.worldScale;
if (feature.goTile.useElevation)
{
h += GOFeature.BuildingElevationOffset;
}
preMesh.secondaryMesh = SimpleExtruder.ExtrudePremesh(preMesh.secondaryMesh, h + Noise(), false);
}
}
return(preMesh);
}
public void GrowTrees(Mesh mesh, GOFeature feature, Vector3 center)
{
if (feature.kind == GOFeatureKind.park || feature.kind == GOFeatureKind.garden)
{
var randomRotation = Quaternion.Euler(0, Random.Range(0, 360), 0);
int n = Random.Range(0, treePrefab.Length);
center.y = treePrefab [n].transform.position.y + feature.goTile.altitudeForPoint(center);
center.y *= feature.goTile.worldScale;
GameObject obj = (GameObject)Instantiate(treePrefab[n], center, randomRotation);
obj.transform.parent = feature.parent.transform;
obj.transform.localScale *= feature.goTile.worldScale;
}
}
public GOLineMesh(GOFeature goFeature_, bool curved = false)
{
goFeature = goFeature_;
this.isLoop = goFeature.convertedGeometry [0].Equals(goFeature.convertedGeometry[goFeature.convertedGeometry.Count - 1]);
if ((goFeature.goTile.useElevation || curved) && goFeature.layer.layerType == GOLayer.GOLayerType.Roads)
{
geometry = GOCurver.MakeBetterCurve(goFeature.convertedGeometry, 15, isLoop);
}
else
{
geometry = goFeature.convertedGeometry;
}
}
public void AddBoats(Mesh mesh, GOFeature feature, Vector3 center)
{
bool spawn = Random.value > 0.5f;
if (feature.kind != GOFeatureKind.riverbank && feature.kind != GOFeatureKind.water && spawn)
{
var randomRotation = Quaternion.Euler(0, Random.Range(0, 360), 0);
center.y = 2 + feature.goTile.altitudeForPoint(center);
center.y *= feature.goTile.worldScale;
GameObject obj = (GameObject)Instantiate(boatPrefab, center, randomRotation);
obj.transform.parent = feature.parent.transform;
obj.transform.localScale *= feature.goTile.worldScale;
}
}
public IEnumerator SpawnPrefabsInMesh(GOFeature feature, GameObject parent, GOEnvironmentKind kind)
{
if (feature.preloadedMeshData == null)
{
yield break;
}
float area = Area(feature.convertedGeometry);
float rate = kind.density / 1000.0f;
int k = Mathf.FloorToInt(area * rate / 100);
//Debug.Log (area + " " + rate + " " + k);
for (int i = 0; i < k; i++)
{
try {
// int spawn = UnityEngine.Random.Range (0, rate);
// if (spawn != 0)
// continue;
int n = UnityEngine.Random.Range(0, kind.prefabs.Length);
Vector3 pos = randomPointInShape(feature.convertedGeometry);
if (GOMap.IsPointAboveWater(pos))
{
continue;
}
pos.y += kind.prefabs [n].transform.position.y;
var rotation = kind.prefabs [n].transform.eulerAngles;
var randomRotation = new Vector3(0, UnityEngine.Random.Range(0, 360), 0);
GameObject obj = (GameObject)GameObject.Instantiate(kind.prefabs[n], pos, Quaternion.Euler(rotation + randomRotation));
obj.transform.parent = parent.transform;
} catch {
}
if (Application.isPlaying)
{
yield return(null);
}
}
yield return(null);
}
public IEnumerator SpawnPrefabsIn3DMesh(GOFeature feature, GameObject parent, GOEnvironmentKind kind)
{
if (feature.preloadedMeshData == null)
{
yield break;
}
int rate = 100 / kind.density;
foreach (Vector3 vertex in feature.preloadedMeshData.vertices)
{
try {
int spawn = UnityEngine.Random.Range(0, rate);
if (spawn != 0)
{
continue;
}
int n = UnityEngine.Random.Range(0, kind.prefabs.Length);
Vector3 pos = vertex;
if (GOMap.IsPointAboveWater(pos))
{
continue;
}
pos.y += kind.prefabs [n].transform.position.y;
var rotation = kind.prefabs [n].transform.eulerAngles;
var randomRotation = new Vector3(0, UnityEngine.Random.Range(0, 360), 0);
GameObject obj = (GameObject)GameObject.Instantiate(kind.prefabs[n], pos, Quaternion.Euler(rotation + randomRotation));
obj.transform.parent = parent.transform;
} catch {
}
if (Application.isPlaying)
{
yield return(null);
}
}
yield return(null);
}
public void OnFeatureLoad(GOFeature feature, GameObject featureObject)
{
if (goMap.useElevation == true)
{
foreach (GOEnvironmentKind kind in featureEnvironment)
{
bool kindCondition = kind.kind == feature.kind;
bool layerCondition = kind.layer == feature.layer.layerType && kind.kind == GOFeatureKind.baseKind;
if (kindCondition || layerCondition)
{
if (Application.isPlaying)
{
StartCoroutine(SpawnPrefabsIn3DMesh(feature, featureObject, kind));
}
else
{
GORoutine.start(SpawnPrefabsIn3DMesh(feature, featureObject, kind), this);
}
}
}
}
else
{
foreach (GOEnvironmentKind kind in featureEnvironment)
{
bool kindCondition = kind.kind == feature.kind || kind.kind == GOFeatureKind.baseKind;
bool layerCondition = kind.layer == feature.layer.layerType;
if (kindCondition && layerCondition)
{
//Debug.Log(kind.layer + " " + feature.layer.layerType);
if (Application.isPlaying)
{
StartCoroutine(SpawnPrefabsInMesh(feature, featureObject, kind));
}
else
{
GORoutine.start(SpawnPrefabsInMesh(feature, featureObject, kind), this);
}
}
}
}
}
public override GOFeature EditLabelData(GOFeature goFeature)
{
string labelKey = goFeature.labelsLayer.LanguageKey(goFeature.goTile.mapType);
if (goFeature.properties.Contains(labelKey) && !string.IsNullOrEmpty((string)goFeature.properties [labelKey]))
{
goFeature.name = (string)goFeature.properties [labelKey];
}
else
{
goFeature.name = (string)goFeature.properties ["name"];
}
goFeature.kind = GOEnumUtils.MapboxToKind(goFeature.labelsLayer.name);
goFeature.y = goFeature.getLayerDefaultY() + 1;
return(goFeature);
}
public void OnFeatureLoad(GOFeature feature, GameObject featureObject)
{
foreach (GOEnvironmentKind kind in featureEnvironment)
{
int spawn = 0;
if (spawn == 0 && kind.kind == feature.kind)
{
if (Application.isPlaying)
{
StartCoroutine(SpawnPrefabsInMesh(feature, featureObject, kind));
}
else
{
GORoutine.start(SpawnPrefabsInMesh(feature, featureObject, kind), this);
}
}
}
}
private void AddFatureToList(GOFeature f, IList list)
{
// if (f.GetType () == typeof(GORoadFeature)) {
//
// GORoadFeature rf = (GORoadFeature)f;
// GORoadFeature.MergeRoad (list, rf);
//
// } else {
f.preloadedMeshData = GOFeatureMeshBuilder.PreloadFeatureData(f);
if (f.goFeatureType == GOFeatureType.Point || f.preloadedMeshData != null)
{
list.Add(f);
}
// }
}
public IEnumerator SpawnBuildings(GOFeature feature, GameObject parent, GOEnvironmentKind kind)
{
if (feature.preloadedMeshData == null)
{
yield break;
}
int rate = 100 / (kind.density + 1);
// foreach (Vector3 vertex in feature.preloadedMeshData.vertices) {
//
// try {
int spawn = UnityEngine.Random.Range(0, rate);
if (spawn != 0)
{
yield break;
}
int n = UnityEngine.Random.Range(0, kind.prefabs.Length);
Vector3 pos = feature.featureCenter;
pos.y += kind.prefabs [n].transform.position.y;
var rotation = kind.prefabs [n].transform.eulerAngles;
var randomRotation = new Vector3(0, UnityEngine.Random.Range(0, 360), 0);
GameObject obj = (GameObject)GameObject.Instantiate(kind.prefabs[n], pos, Quaternion.Euler(rotation + randomRotation));
obj.transform.parent = parent.transform;
// } catch {
// }
if (Application.isPlaying)
{
yield return(null);
}
// }
yield return(null);
}
public GOMesh ProjectFeature(GOFeature feature, GOMesh terrainMesh, float distance)
{
Vector3[] vertices = terrainMesh.vertices;
int[] triangles = terrainMesh.triangles;
GOTempPolyNew poly;
ComputeFeatureRanges(feature);
for (int i = 0; i < triangles.Length; i += 3)
{
int i1 = triangles[i];
int i2 = triangles[i + 1];
int i3 = triangles[i + 2];
Vector3 v1 = feature.goTile.position + vertices [i1];
Vector3 v2 = feature.goTile.position + vertices [i2];
Vector3 v3 = feature.goTile.position + vertices [i3];
Vector3 side1 = v2 - v1;
Vector3 side2 = v3 - v1;
Vector3 normal = Vector3.Cross(side1, side2).normalized;
poly = new GOTempPolyNew(v1, v2, v3);
poly.normal = normal;
poly.indices.AddRange(new int[] { i1, i2, i3 });
poly.xRange = xRange;
poly.zRange = zRange;
// Profiler.BeginSample ("Wrap Polygon");
poly = poly.WrapPolygon(feature.convertedGeometry.ToArray(), terrainMesh);
// Profiler.EndSample ();
if (poly == null)
{
continue;
}
polys.Add(poly);
}
return(MergeTempPolys(distance));
}