//Draws a polygon given a list of Vector3 that is a closed shape
public GameObject dropPolygon(List <Vector3> shape, float height, Material material)
{
GameObject polygon = new GameObject("Polygon");
MeshFilter filter = polygon.AddComponent <MeshFilter>();
MeshRenderer renderer = polygon.AddComponent <MeshRenderer>();
Poly2Mesh.Polygon poly = new Poly2Mesh.Polygon();
poly.outside = shape;
Mesh mesh = Poly2Mesh.CreateMesh(poly);
Vector2[] uvs = new Vector2[mesh.vertices.Length];
for (int i = 0; i < uvs.Length; i++)
{
uvs[i] = new Vector2(mesh.vertices[i].x, mesh.vertices[i].z) * 100;
}
mesh.uv = uvs;
if (height > 0)
{
mesh = SimpleExtruder.SliceExtrude(mesh, polygon, height, 4f, 4f, 10f);
}
filter.sharedMesh = mesh;
renderer.material = material;
polygon.AddComponent <MeshCollider> ();
return(polygon);
}
//Draws a polygon given a list of Vector3 that is a closed shape
public GameObject dropPolygon(List <Vector3> shape, float height, Material material, GOUVMappingStyle uvMappingStyle)
{
GameObject polygon = new GameObject("Polygon");
MeshFilter filter = polygon.AddComponent <MeshFilter>();
MeshRenderer renderer = polygon.AddComponent <MeshRenderer>();
Poly2Mesh.Polygon poly = new Poly2Mesh.Polygon();
poly.outside = shape;
GOMesh goMesh = Poly2Mesh.CreateMeshInBackground(poly);
goMesh.uvMappingStyle = uvMappingStyle;
goMesh.ApplyUV(shape);
if (height > 0)
{
goMesh = SimpleExtruder.SliceExtrudePremesh(goMesh, height, 4f, 4f, 10f);
}
Mesh mesh = goMesh.ToSubmeshes();
filter.sharedMesh = mesh;
renderer.material = material;
polygon.AddComponent <MeshCollider> ();
return(polygon);
}
private static GameObject GenerateFloor(
List <Vector2> roomContour,
Vector3 centroid,
Material floorMat)
{
GameObject go = new GameObject("floor");
MeshFilter mf = go.AddComponent <MeshFilter>();
MeshRenderer mr = go.AddComponent <MeshRenderer>();
go.transform.position = centroid / MeasurmentK;
var polygon = new Poly2Mesh.Polygon();
var converter = new Converter <Vector2, Vector3>(Vector2ToVector3);
polygon.outside = roomContour.ConvertAll(converter);
var mesh = Poly2Mesh.CreateMesh(polygon);
var verts = mesh.vertices;
for (int i = 0; i < verts.Length; i++)
{
verts[i] = (centroid - new Vector3(verts[i].x, verts[i].z, verts[i].y)) / MeasurmentK;
}
mesh.vertices = verts;
mesh.uv = MathUtils.CreatePlaneUVs(mesh);
mesh.RecalculateNormals();
mesh.RecalculateBounds();
mesh.name = go.name;
mf.sharedMesh = mesh;
mr.sharedMaterial = floorMat;
go.transform.rotation = Quaternion.Euler(0, 180, 0);
return(go);
}
public GameObject ToGameObject()
{
Poly2Mesh.Polygon polygon = this.Geometry.ToPolygonMesh();
GameObject go = Poly2Mesh.CreateGameObject(polygon, this.FID);
return(go);
}
void GenMesh(List <Vector3> myVerts, float gravityScale, int pushDir, Vector3 pos, Vector3 scale, float weight)
{
Poly2Mesh.Polygon poly = new Poly2Mesh.Polygon();
poly.outside = myVerts;
GameObject myObj = Poly2Mesh.CreateGameObject(poly);
myObj.transform.position = pos;
myObj.transform.localScale = scale;
myObj.gameObject.tag = "Target";
myObj.AddComponent <PolygonCollider2D>().points = myHelpers.L3ToV2(myVerts);
myObj.GetComponent <Renderer>().material.shader = Shader.Find("Sprites/Default");
myObj.GetComponent <Renderer>().material.mainTexture = tex;
Mesh myMesh = myObj.GetComponent <MeshFilter>().mesh;
myMesh.uv = GetUV(myMesh.vertices);
MeshScript meshScript = myObj.AddComponent <MeshScript>();
meshScript.CurrentRotation = 0f;
meshScript.OriginWeight = weight;
meshScript.OriginArea = meshScript.MyArea = myHelpers.getArea(myObj);
meshScript.MyCenter = myHelpers.GetCentroid(myVerts);
myObj.AddComponent <Rigidbody2D>().gravityScale = gravityScale;
}
private void CreateTileBackground(GOTile tile)
{
MeshFilter filter = tile.gameObject.AddComponent <MeshFilter> ();
MeshRenderer renderer = tile.gameObject.AddComponent <MeshRenderer> ();
tile.vertices = new List <Vector3> ();
IList verts = tile.tileCenter.tileVertices(zoomLevel);
foreach (Vector3 v in verts)
{
tile.vertices.Add(tile.transform.InverseTransformPoint(v));
}
Poly2Mesh.Polygon poly = new Poly2Mesh.Polygon();
poly.outside = tile.vertices;
Mesh mesh = Poly2Mesh.CreateMesh(poly);
Vector3[] meshverts = mesh.vertices;
Vector2[] uvs = new Vector2[meshverts.Length];
for (int i = 0; i < uvs.Length; i++)
{
uvs [i] = new Vector2(meshverts [i].x, meshverts [i].z);
}
mesh.uv = uvs;
filter.sharedMesh = mesh;
tile.gameObject.AddComponent <MeshCollider> ();
renderer.material = tileBackground;
}
private void CreateTemporaryMapBackground()
{
tempTileBackgorund = new GameObject("Temporary tile background");
MeshFilter filter = tempTileBackgorund.AddComponent <MeshFilter>();
MeshRenderer renderer = tempTileBackgorund.AddComponent <MeshRenderer>();
float size = 1000;
Poly2Mesh.Polygon poly = new Poly2Mesh.Polygon();
poly.outside = new List <Vector3> {
new Vector3(size, -0.1f, size),
new Vector3(size, -0.1f, -size),
new Vector3(-size, -0.1f, -size),
new Vector3(-size, -0.1f, size)
};
Mesh mesh = Poly2Mesh.CreateMesh(poly);
Vector2[] uvs = new Vector2[mesh.vertices.Length];
for (int i = 0; i < uvs.Length; i++)
{
uvs[i] = new Vector2(mesh.vertices[i].x, mesh.vertices[i].z);
}
mesh.uv = uvs;
filter.mesh = mesh;
renderer.material = tileBackground;
}
void GenMeshForUV(Vector2[] parentUV, List <Vector3> myVerts, out Vector3[] allVertsMesh, out Vector2[] allUV, float angle)
{
Poly2Mesh.Polygon poly = new Poly2Mesh.Polygon();
poly.outside = myVerts;
Mesh mesh = Poly2Mesh.CreateMesh(poly);
mesh.uv = GetUVSplit(parentUV, mesh.vertices, angle);
allVertsMesh = mesh.vertices;
allUV = mesh.uv;
}
private static GameObject GenerateWall(
Vector3 begin,
Vector3 end,
Vector3 center,
List <List <Vector2> > holes,
float apartmentHeight,
Material wallMat,
int index)
{
GameObject wallGO = new GameObject("wall" + index);
MeshFilter wallMf = wallGO.AddComponent <MeshFilter>();
MeshRenderer wallMr = wallGO.AddComponent <MeshRenderer>();
float wallLength = (Vector2.Distance(begin, end) / 2) / MeasurmentK;
float wallHeight = apartmentHeight / MeasurmentK;
List <Vector2> wallContour = new List <Vector2>
{
new Vector2(-wallLength, 0),
new Vector2(-wallLength, wallHeight),
new Vector2(wallLength, wallHeight),
new Vector2(wallLength, 0)
};
var polygon = new Poly2Mesh.Polygon();
var converter = new Converter <Vector2, Vector3>(Vector2ToVector3);
polygon.outside = wallContour.ConvertAll(converter);
var v3Holes = new List <List <Vector3> >();
holes.ForEach(x => v3Holes.Add(x.ConvertAll(converter)));
for (int i = 0; i < v3Holes.Count; i++)
{
var hole = v3Holes[i];
for (int j = 0; j < hole.Count; j++)
{
hole[j] = hole[j] / MeasurmentK;
}
}
polygon.holes = v3Holes;
var mesh = Poly2Mesh.CreateMesh(polygon);
mesh.RecalculateNormals();
mesh.RecalculateBounds();
mesh.uv = MathUtils.CreatePlaneUVs(mesh);
mesh.name = wallGO.name;
wallMf.sharedMesh = mesh;
wallMr.sharedMaterial = wallMat;
var transform = wallGO.transform;
transform.rotation = Quaternion.Euler(0, -Vector2.SignedAngle(Vector2.right, end - begin), 0);
transform.position = center / MeasurmentK;
return(wallGO);
}
private static void RegisterFloor(string localType, float lowestHeight, string lowestFaceName, Poly2Mesh.Polygon floorPolygon)
{
GameObject floorObj = Poly2Mesh.CreateGameObject(floorPolygon);
floorObj.name = lowestHeight + "_" + lowestFaceName;
// 하나의 솔리드에서 공간타입이 2개 이상 존재할 수는 없다
ApplyCellSpaceMaterial(localType, floorObj);
floorObj.transform.parent = CommonObjs.gmlRootFloor.transform;
}
public GameObject CreateModel(Layer layer, float height)
{
GameObject polygon = new GameObject();
try {
Poly2Mesh.Polygon poly = new Poly2Mesh.Polygon();
poly.outside = convertedSubject;
if (clips != null)
{
foreach (IList clipVerts in clips)
{
poly.holes.Add(CoordsToVerts(clipVerts));
}
}
MeshFilter filter = polygon.AddComponent <MeshFilter>();
polygon.AddComponent(typeof(MeshRenderer));
Mesh mesh = Poly2Mesh.CreateMesh(poly);
if (mesh)
{
Vector2[] uvs = new Vector2[mesh.vertices.Length];
for (int i = 0; i < uvs.Length; i++)
{
uvs[i] = new Vector2(mesh.vertices[i].x, mesh.vertices[i].z);
}
mesh.uv = uvs;
mesh2D = Mesh.Instantiate(mesh);
if (height > 0)
{
mesh = SimpleExtruder.Extrude(mesh, polygon, height);
}
}
filter.sharedMesh = mesh;
if (layer.useColliders)
{
polygon.AddComponent <MeshCollider>().sharedMesh = mesh;
}
}
catch (Exception ex) {
Debug.Log("[PolygonHandler] Catched exeption: " + ex);
}
return(polygon);
}
GameObject AddPolygonMesh(GameObject parent, Vector3[] ps, Material material)
{
GameObject s = new GameObject("SurfacePolygon");
s.transform.parent = parent.transform;
s.AddComponent <MeshRenderer>();
MeshFilter filter = s.AddComponent <MeshFilter>();
Poly2Mesh.Polygon polygon = new Poly2Mesh.Polygon();
polygon.outside = new List <Vector3>(ps);
filter.mesh = Poly2Mesh.CreateMesh(polygon);
ApplyMaterial(s, material);
return(s);
}
void GenMeshSplit(Vector3[] parentVerts, Vector2[] parentUV, List <Vector3> myVerts, Vector3 centerInterPoint, Texture tex, float rotAngle, Vector2 parentVelocity, float parentGravity, float originArea, float originWeight)
{
Poly2Mesh.Polygon poly = new Poly2Mesh.Polygon();
poly.outside = myVerts;
GameObject myObj = Poly2Mesh.CreateGameObject(poly);
myObj.gameObject.tag = "Target";
Material myMat = myObj.GetComponent <Renderer>().material;
myMat.shader = Shader.Find("Sprites/Default");
myMat.mainTexture = tex;
Mesh myMesh = myObj.GetComponent <MeshFilter>().mesh;
myMesh.uv = deductUV(parentVerts, parentUV, myMesh.vertices);
MeshScript meshScript = myObj.AddComponent <MeshScript>();
meshScript.ShowPerc = ShowPercentage;
meshScript.CurrentRotation = rotAngle;
meshScript.OriginWeight = originWeight;
meshScript.OriginArea = originArea;
float myArea = myHelpers.getArea(myObj);
meshScript.MyArea = myArea;
meshScript.MyCenter = myHelpers.GetCentroid(myVerts);
myObj.AddComponent <PolygonCollider2D>().points = myHelpers.L3ToV2(myVerts);
Rigidbody2D myRB = myObj.AddComponent <Rigidbody2D>();
myRB.gravityScale = parentGravity;
myRB.velocity = parentVelocity;
myRB.mass = (myArea * originWeight) / originArea;
applyForceObj.MyRBS.Add(myRB);
Vector3 myDir = myHelpers.GetCentroid(myVerts) - centerInterPoint;
applyForceObj.MyDirs.Add(myDir.normalized);
}
private void CreateTileBackground(GOTile tile)
{
MeshFilter filter = tile.gameObject.AddComponent <MeshFilter>();
MeshRenderer renderer = tile.gameObject.AddComponent <MeshRenderer>();
tile.vertices = tile.tileCenter.tileVertices(zoomLevel);
Poly2Mesh.Polygon poly = new Poly2Mesh.Polygon();
poly.outside = tile.vertices;
Mesh mesh = Poly2Mesh.CreateMesh(poly);
Vector2[] uvs = new Vector2[mesh.vertices.Length];
for (int i = 0; i < uvs.Length; i++)
{
uvs[i] = new Vector2(mesh.vertices[i].x, mesh.vertices[i].z);
}
mesh.uv = uvs;
filter.mesh = mesh;
renderer.material = tileBackground;
}
private TexturedMesh CreateSurface(Surface surf)
{
Poly2Mesh.Polygon poly = new Poly2Mesh.Polygon();
poly.outside = CreateVectorlist(surf.outerRing);
if (surf.outerringUVs.Count > 0)
{
surf.outerringUVs.Reverse();
poly.outsideUVs = surf.outerringUVs;
}
;
if (surf.innerRings.Count > 0)
{
foreach (var innerring in surf.innerRings)
{
poly.holes.Add(CreateVectorlist(innerring));
}
}
if (surf.innerringUVs.Count > 0)
{
surf.innerringUVs.Reverse();
poly.holesUVs = surf.innerringUVs;
}
Mesh submesh = Poly2Mesh.CreateMesh(poly);
TexturedMesh texturedmesh = new TexturedMesh();
texturedmesh.mesh = submesh;
if (surf.surfacetexture != null)
{
texturedmesh.TextureName = surf.surfacetexture.path;
//texturedmesh.texture = LoadTexture(surf.surfacetexture);
}
submesh = null;
return(texturedmesh);
}
public GameObject BuildPolygon(GOLayer layer, float height)
{
if (feature.convertedGeometry.Count == 2 && feature.convertedGeometry[0].Equals(feature.convertedGeometry[1]))
{
return(null);
}
List <Vector3> clean = feature.convertedGeometry.Distinct().ToList();
if (clean == null || clean.Count <= 2)
{
return(null);
}
GameObject polygon = new GameObject();
Profiler.BeginSample("[GoMap] Start poly2mesh");
Poly2Mesh.Polygon poly = new Poly2Mesh.Polygon();
poly.outside = feature.convertedGeometry;
if (feature.clips != null)
{
foreach (IList clipVerts in feature.clips)
{
poly.holes.Add(GOFeature.CoordsToVerts(clipVerts, true));
}
}
Profiler.EndSample();
MeshFilter filter = polygon.AddComponent <MeshFilter>();
meshRenderer = polygon.AddComponent <MeshRenderer>();
Profiler.BeginSample("[GoMap] Create polygon mesh");
try {
mesh = Poly2Mesh.CreateMesh(poly);
} catch {
}
Profiler.EndSample();
if (mesh)
{
Profiler.BeginSample("[GoMap] Set polygon UV");
Vector2[] uvs = new Vector2[mesh.vertices.Length];
Vector3[] vertices = mesh.vertices;
for (int i = 0; i < uvs.Length; i++)
{
uvs[i] = new Vector2(vertices[i].x, vertices[i].z);
}
mesh.uv = uvs;
Profiler.EndSample();
Profiler.BeginSample("[GoMap] instantiate mesh 2D");
mesh2D = Mesh.Instantiate(mesh);
Profiler.EndSample();
Profiler.BeginSample("[GoMap] polygon extrusion");
if (height > 0)
{
mesh = SimpleExtruder.SliceExtrude(mesh, polygon, height, 4f, 4f, 10f);
// mesh = SimpleExtruder.Extrude (mesh, polygon, height);
}
Profiler.EndSample();
}
filter.sharedMesh = mesh;
if (layer.useColliders && mesh != null && feature.convertedGeometry.Count() > 2)
{
polygon.AddComponent <MeshCollider>().sharedMesh = mesh;
}
return(polygon);
}
private void OnCellSpaceBoundaryMember(XmlReader reader)
{
List <Vector2> localUVs = new List <Vector2>();
Poly2Mesh.Polygon localPolygon = new Poly2Mesh.Polygon();
string localFileName = string.Empty;
string localName = string.Empty;
while (isEndElement(reader, "cellSpaceBoundaryMember") == false)
{
reader.Read();
if (string.IsNullOrWhiteSpace(localName))
{
reader.Read();
localName = reader.GetAttribute("gml:id");
}
if (isStartElement(reader, "Polygon") || isStartElement(reader, "PolygonPatch"))
{
localPolygon = OnPolygon(reader);
}
if (isStartElement(reader, "TextureImage"))
{
reader.Read();
localFileName = reader.Value;
}
if (isStartElement(reader, "TextureCoordinate"))
{
localUVs = new List <Vector2>();
while (isEndElement(reader, "TextureCoordinate") == false)
{
reader.Read();
if (isStartElement(reader, "pos"))
{
reader.Read();
localUVs.Add(GetPos2D(reader));
}
}
}
if (isStartElement(reader, "OrientableSurface"))
{
// Now, Viewer shows always both of sides.
// So nothing to do for viewing for other side.
return;
}
}
//tagStack.Pop();
if (localUVs.Count() > 2)
{
localPolygon.outsideUVs = localUVs;
localPolygon.holesUVs = new List <List <Vector2> >();
localPolygon.outsideUVs.Reverse();
}
localPolygon.outside.Reverse();
for (int i = 0; i < localPolygon.holes.Count(); i++)
{
localPolygon.holes[i].Reverse();
localPolygon.holesUVs.Add(new List <Vector2>());
}
// Texture 구멍 무시.
if (string.IsNullOrWhiteSpace(localFileName) == false)
{
localPolygon.holes = new List <List <Vector3> >();
localPolygon.holesUVs = new List <List <Vector2> >();
}
GameObject cellSpaceBoundary = Poly2Mesh.CreateGameObject(localPolygon);
cellSpaceBoundary.name = localName;
if (string.IsNullOrWhiteSpace(localFileName))
{
// 일반 벽과 지오메트리 정보가 겹칠경우를 대비하여 앞쪽으로 조금 이동
cellSpaceBoundary.transform.Translate(localPolygon.planeNormal * 0.01f);
}
else
{
//덱스쳐가 면별로 긴밀하게 붙어있는 경우 기둥사이가 보이는 현상이 발생하므로 적절히 수치를 조절하여 사용.
//cellSpaceBoundary.transform.Translate(localPolygon.planeNormal * 0.005f);
}
if (string.IsNullOrWhiteSpace(localFileName) == false)
{
//Debug.Log(GetDirectoryName() + "\\" + localFileName);
IEnumerator tmpRunner = ApplyTexture(cellSpaceBoundary, GetDirectoryName() + "\\" + localFileName);
StartCoroutine(tmpRunner);
}
else
{
cellSpaceBoundary.GetComponent <Renderer>().material = CommonObjs.materialCellSpaceBoundary;
}
cellSpaceBoundary.tag = CommonObjs.TAG_CELLSPACEBOUNDARY;
cellSpaceBoundary.transform.parent = CommonObjs.gmlRootCellSpaceBoundary.transform;
}
public static GameObject PolyToMesh(XmlReader reader, string id, CityGml2GO cityGml2Go, SemanticType semanticType = null)
{
var extPositions = new List <Vector3>();
var intPositions = new List <List <Vector3> >();
var polyName = "";
while (reader.MoveToNextAttribute())
{
if (reader.LocalName == "id")
{
polyName = reader.Value;
}
}
while (reader.Read())
{
if (((IXmlLineInfo)reader).LineNumber >= 14459)
{
int idfg = 0;
}
if (string.IsNullOrEmpty(polyName))
{
while (reader.MoveToNextAttribute())
{
if (reader.LocalName == "id")
{
polyName = reader.Value;
}
}
}
if (reader.NodeType == XmlNodeType.Element && reader.LocalName == "exterior")
{
while (reader.Read())
{
if (reader.NodeType == XmlNodeType.Element && reader.LocalName == "posList")
{
var range = PositionHandler.GetPosList(reader, cityGml2Go.ActualTranslate);
if (range != null)
{
extPositions.AddRange(range);
}
}
if (reader.NodeType == XmlNodeType.Element && reader.LocalName == "pos")
{
extPositions.Add(PositionHandler.GetPos(reader, cityGml2Go.ActualTranslate));
}
if (reader.NodeType == XmlNodeType.EndElement && reader.LocalName == "exterior")
{
break;
}
}
}
if (reader.NodeType == XmlNodeType.Element && reader.LocalName == "interior")
{
var curInt = new List <Vector3>();
while (reader.Read())
{
if (reader.NodeType == XmlNodeType.Element && reader.LocalName == "posList")
{
var range = PositionHandler.GetPosList(reader, cityGml2Go.ActualTranslate);
if (range != null)
{
curInt.AddRange(range);
}
}
if (reader.NodeType == XmlNodeType.Element && reader.LocalName == "pos")
{
curInt.Add(PositionHandler.GetPos(reader, cityGml2Go.ActualTranslate));
}
if (reader.NodeType == XmlNodeType.EndElement && reader.LocalName == "interior")
{
break;
}
}
intPositions.Add(curInt);
}
if (reader.NodeType == XmlNodeType.EndElement && reader.LocalName == "Polygon")
{
break;
}
}
var lastPoint = extPositions.Last();
//extPositions = extPositions.Distinct().ToList();
extPositions.Add(lastPoint);
for (var index = 0; index < intPositions.Count; index++)
{
lastPoint = intPositions[index].Last();
//intPositions[index] = intPositions[index].Distinct().ToList();
intPositions[index].Add(lastPoint);
}
if (!PolygonHandler.IsPolyValid(extPositions))
{
IXmlLineInfo xmlInfo = (IXmlLineInfo)reader;
int lineNumber = xmlInfo.LineNumber;
Debug.Log(lineNumber);
return(null);
}
foreach (var intRing in intPositions)
{
if (!IsPolyValid(intRing))
{
IXmlLineInfo xmlInfo = (IXmlLineInfo)reader;
int lineNumber = xmlInfo.LineNumber;
Debug.Log(lineNumber);
return(null);
}
}
var polygon = new Poly2Mesh.Polygon();
extPositions.Reverse();
intPositions.Reverse();
polygon.outside = extPositions;
polygon.holes = intPositions;
GameObject go = null;
try
{
go = Poly2Mesh.CreateGameObject(polygon, string.IsNullOrEmpty(polyName) ? id : polyName);
}
catch (Exception ex)
{
Debug.Log(ex);
}
if (cityGml2Go.GenerateColliders)
{
//go.AddComponent<MeshCollider>();
}
if (go != null)
{
if (cityGml2Go.Semantics && semanticType != null)
{
SemanticsHandler.HandleSemantics(go, semanticType, cityGml2Go);
}
else if (cityGml2Go.DefaultMaterial != null)
{
var mr = go.GetComponent <MeshRenderer>();
if (mr != null)
{
mr.sharedMaterial = cityGml2Go.DefaultMaterial;
}
}
}
cityGml2Go.Polygons.Add(go);
return(go);
}
private void OnCellSpace(XmlReader reader)
{
GameObject solid = new GameObject();
string localName = string.Empty;
string localType = string.Empty;
while (isEndElement(reader, "cellSpaceMember") == false)
{
reader.Read();
if (string.IsNullOrWhiteSpace(localName))
{
reader.Read();
localName = reader.GetAttribute("gml:id");
localType = reader.LocalName;
if (localType.Equals("TransitionSpace"))
{
solid.tag = CommonObjs.TAG_TRANSITIONSPACE;
solid.transform.parent = CommonObjs.gmlRootTransitionSpace.transform;
}
else if (localType.Equals("GeneralSpace"))
{
solid.tag = CommonObjs.TAG_GENERALSPACE;
solid.transform.parent = CommonObjs.gmlRootGeneralSpace.transform;
}
else
{
solid.tag = CommonObjs.TAG_CELLSPACE;
solid.transform.parent = CommonObjs.gmlRootCellSpace.transform;
}
}
if (isStartElement(reader, "Solid"))
{
int faceCnt = 1;
solid.name = localName;
reader.Read();
float lowestHeight = float.MaxValue;
string lowestFaceName = "";
Poly2Mesh.Polygon floorPolygon = new Poly2Mesh.Polygon();
while (isEndElement(reader, "Solid") == false)
{
reader.Read();
if (isStartElement(reader, "Polygon") || isStartElement(reader, "PolygonPatch"))
{
Poly2Mesh.Polygon polygon = OnPolygon(reader);
GameObject genPolygon = Poly2Mesh.CreateGameObject(polygon);
genPolygon.name = string.Format("{0}_Face:{1}", localName, faceCnt++);
genPolygon.transform.parent = solid.transform;
// 각 솔리드에서 가장 낮은 면을 바닥으로 잡음.
// 조금은 기울어진 바닥이라 할지라도 잡아낼 수 있게끔한게 의도.
// 현재까지의 모든 데이터는 바닥이 모두 평면으로 되어 있음.
float thisMinY = polygon.outside.Average(v => v.y);
if (thisMinY < lowestHeight)
{
lowestHeight = thisMinY;
floorPolygon = polygon;
lowestFaceName = localName;
}
ApplyCellSpaceMaterial(localType, genPolygon);
}
}
//RegisterFloor(localType, lowestHeight, lowestFaceName, floorPolygon);
}
}
}
public static GOMesh PreloadPolygon(GOFeature feature)
{
if (feature.convertedGeometry == null)
{
return(null);
}
if (feature.convertedGeometry.Count == 2 && feature.convertedGeometry[0].Equals(feature.convertedGeometry[1]))
{
return(null);
}
List <Vector3> clean = feature.convertedGeometry.Distinct().ToList();
if (clean == null || clean.Count <= 2)
{
return(null);
}
Poly2Mesh.Polygon poly = new Poly2Mesh.Polygon();
poly.outside = feature.convertedGeometry;
if (feature.clips != null)
{
foreach (List <Vector3> clipVerts in feature.clips)
{
poly.holes.Add(clipVerts);
}
}
GOMesh goMesh = null;
goMesh = Poly2Mesh.CreateMeshInBackground(poly);
if (goMesh != null)
{
goMesh.uvMappingStyle = feature.layer.uvMappingStyle;
goMesh.ApplyUV(feature.convertedGeometry);
goMesh.Y = feature.y;
if (feature.goTile.useElevation)
{
feature.ComputeHighestAltitude();
}
if (feature.height > 0)
{
feature.height *= feature.goTile.worldScale;
goMesh.secondaryMesh = new GOMesh(goMesh);
float h = feature.height;
if (feature.goTile.useElevation)
{
h += GOFeature.BuildingElevationOffset;
}
h += Noise();
goMesh.separateTop = feature.renderingOptions.hasRoof;
if (feature.layer.slicedExtrusion)
{
goMesh = SimpleExtruder.SliceExtrudePremesh(goMesh, h, 4f, 4f, 10f * feature.goTile.worldScale);
}
else
{
goMesh = SimpleExtruder.ExtrudePremesh(goMesh, h);
}
}
if (feature.height < feature.layer.colliderHeight)
{
float h = feature.layer.colliderHeight;
h *= feature.goTile.worldScale;
if (feature.goTile.useElevation)
{
h += GOFeature.BuildingElevationOffset;
}
goMesh.secondaryMesh = new GOMesh(goMesh);
goMesh.secondaryMesh = SimpleExtruder.SliceExtrudePremesh(goMesh.secondaryMesh, h, 4f, 4f, 10f * feature.goTile.worldScale);
}
}
return(goMesh);
}
public void CreateFace()
{
Action action = new Action(Nothing);
if (selected.Count < 3)
{
Debug.Log("-----ERROR MUST BELONG SAME OBJECT-----");
MobileNativePopups.OpenAlertDialog("Error", "Please select at least 3 vertices", "Cancel", action);
return;
}
CADObject cadObject = selected [0].transform.parent.GetComponent <CADObject> ();
string objName = selected [0].transform.parent.name;
List <GameObject> pool = new List <GameObject> ();
foreach (GameObject g in selected)
{
pool.Add(g);
if (!g.transform.parent.name.Equals(objName))
{
Debug.Log("-----ERROR MUST BELONG SAME OBJECT-----");
MobileNativePopups.OpenAlertDialog("Error", "Please select vertices that belong to the same object", "Cancel", action);
return;
}
}
GameObject startingPoint = pool [0];
GameObject recent = startingPoint;
pool.Remove(startingPoint);
List <GameObject> orderedList = new List <GameObject> ();
List <Vector3> orderListPositions = new List <Vector3> ();
orderedList.Add(recent);
orderListPositions.Add(recent.transform.position);
//action += Nothing;
int toFind = pool.Count;
while (true)
{
if (pool.Count == 0)
{
break;
}
GameObject found = null;
foreach (GameObject checkNeighbor in pool)
{
HashSet <GameObject> key = new HashSet <GameObject> ();
key.Add(checkNeighbor);
key.Add(recent);
if (cadObject.edges.ContainsKey(key))
{
found = checkNeighbor;
toFind--;
break;
}
}
if (found == null)
{
Debug.Log("-error form loop");
MobileNativePopups.OpenAlertDialog("Error", "Please select vertices that form a single, complete loop", "Cancel", action);
return;
}
else
{
recent = found;
pool.Remove(found);
orderedList.Add(found);
orderListPositions.Add(found.transform.position);
}
}
HashSet <GameObject> keyEnd = new HashSet <GameObject> ();
keyEnd.Add(orderedList[0]);
keyEnd.Add(orderedList[orderedList.Count - 1]);
if (!cadObject.edges.ContainsKey(keyEnd))
{
Debug.Log("-error form loop");
MobileNativePopups.OpenAlertDialog("Error", "Please select vertices that form a single, complete loop", "Cancel", action);
return;
}
if (orderedList.Count != selected.Count)
{
Debug.Log("-error form loop");
MobileNativePopups.OpenAlertDialog("Error", "You need to select vertices that form a single loop", "Cancel", action);
return;
}
Poly2Mesh.Polygon poly = new Poly2Mesh.Polygon();
poly.outside = orderListPositions;
GameObject a = Poly2Mesh.CreateGameObject(poly);
a.transform.parent = cadObject.gameObject.transform;
a.GetComponent <Renderer> ().material = meshTexture;
orderListPositions.Reverse();
Poly2Mesh.Polygon poly2 = new Poly2Mesh.Polygon();
poly2.outside = orderListPositions;
GameObject a2 = Poly2Mesh.CreateGameObject(poly2);
a2.transform.parent = cadObject.gameObject.transform;
a2.GetComponent <Renderer> ().material = meshTexture;
Debug.Log("CREATE FACE NOW");
Debug.Log(orderedList.Count);
}
protected override void ThreadFunction()
{
premesh = Poly2Mesh.CreateMeshInBackground(poly);
}
public GameObject BuildPolygon(string name, Vector3 pos)
{
Poly2Mesh.Polygon poly = new Poly2Mesh.Polygon();
poly.outside = feature.convertedGeometry;
if (feature.clips != null)
{
foreach (IList clipVerts in feature.clips)
{
poly.holes.Add(GOFeature.CoordsToVerts(clipVerts));
}
}
try
{
mesh = Poly2Mesh.CreateMesh(poly);
}
catch
{
}
float d = 0f;
Vector3 f_Pos = pos;
for (int i = 0; i < mesh.vertices.Length; i++)
{
var l = Vector2.Distance(pos, mesh.vertices[i]);
if (d < l)
{
d = l;
f_Pos = mesh.vertices[i];
}
}
float ea_y = GetSC(f_Pos, pos);
var sc = d / 1.414f;
if (sc > 2f)
{
sc = sc / 4;
GameObject polygon = new GameObject("polygon");
polygon.transform.localPosition = pos;
//for (int i = 0;i<2;i++)
// {
// for (int j = 0;j<2;j++)
// {
GameObject item = GameObject.Instantiate((GameObject)Resources.Load("Prefabs/CityBuildings/" + "B_10"));
item.transform.localPosition = pos; //new Vector3((pos.x-sc/2)+sc*i,0, (pos.z - sc / 2) + sc * j) ;
item.transform.localEulerAngles = new Vector3(0, ea_y, 0);
item.transform.localScale = Vector3.one * (sc * Global.tilesizeRank);
item.transform.SetParent(polygon.transform);
// }
// }
polygon.transform.Rotate(0, ea_y, 0);
return(polygon);
}
else
{
if (sc < 0.8f)
{
sc = 1f;
}
GameObject polygon = GameObject.Instantiate((GameObject)Resources.Load("Prefabs/CityBuildings/" + "B_" + UnityEngine.Random.Range(3, 10)));
polygon.transform.localPosition = pos;
polygon.transform.localEulerAngles = new Vector3(0, ea_y, 0);
polygon.transform.localScale = Vector3.one * (sc * Global.tilesizeRank);
return(polygon);
}
}
private void OnCellSpaceBoundaryMember(XmlReader reader)
{
List <Vector2> localUVs = new List <Vector2>();
Poly2Mesh.Polygon localPolygon = new Poly2Mesh.Polygon();
string localFileName = string.Empty;
string localName = string.Empty;
while (IsEndElement(reader, "cellSpaceBoundaryMember") == false)
{
reader.Read();
if (string.IsNullOrWhiteSpace(localName))
{
reader.Read();
localName = reader.GetAttribute("gml:id");
}
if (IsStartElement(reader, "Polygon") || IsStartElement(reader, "PolygonPatch"))
{
localPolygon = OnPolygon(reader);
}
if (IsStartElement(reader, "TextureImage"))
{
reader.Read();
localFileName = reader.Value;
}
if (IsStartElement(reader, "TextureCoordinate"))
{
localUVs = new List <Vector2>();
while (IsEndElement(reader, "TextureCoordinate") == false)
{
reader.Read();
if (IsStartElement(reader, "pos"))
{
reader.Read();
localUVs.Add(GetPos2D(reader));
}
}
}
}
if (localUVs.Count() > 2)
{
localPolygon.outsideUVs = localUVs;
localPolygon.holesUVs = new List <List <Vector2> >();
localPolygon.outsideUVs.Reverse();
}
localPolygon.outside.Reverse();
for (int i = 0; i < localPolygon.holes.Count(); i++)
{
localPolygon.holes[i].Reverse();
localPolygon.holesUVs.Add(new List <Vector2>());
}
// Texture 구멍 무시.
if (string.IsNullOrWhiteSpace(localFileName) == false)
{
localPolygon.holes = new List <List <Vector3> >();
localPolygon.holesUVs = new List <List <Vector2> >();
}
GameObject cellSpaceBoundary = Poly2Mesh.CreateGameObject(localPolygon, true);
cellSpaceBoundary.name = localName;
cellSpaceBoundary.GetComponent <MeshCollider>().enabled = true;
cellSpaceBoundary.GetComponent <MeshCollider>().convex = true;
cellSpaceBoundary.GetComponent <MeshCollider>().isTrigger = true;
if (string.IsNullOrWhiteSpace(localFileName))
{
cellSpaceBoundary.transform.Translate(localPolygon.planeNormal * 0.01f);
}
else
{
//cellSpaceBoundary.transform.Translate(localPolygon.planeNormal * 0.005f);
}
if (string.IsNullOrWhiteSpace(localFileName) == false)
{
//Debug.Log(GetDirectoryName() + "\\" + localFileName);
IEnumerator tmpRunner = ApplyTexture(cellSpaceBoundary, Path.GetDirectoryName(fileUrl) + "\\" + localFileName);
StartCoroutine(tmpRunner);
}
else
{
cellSpaceBoundary.GetComponent <Renderer>().material = CommonObjs.materialCellSpaceBoundary;
}
cellSpaceBoundary.tag = CommonObjs.TAG_CELLSPACEBOUNDARY;
cellSpaceBoundary.transform.parent = CommonObjs.gmlRootCellSpaceBoundary.transform;
}
public GameObject BuildPolygon(string name, GOLayer layer, float height)
{
//GameObject polygon = GameObject.Instantiate((GameObject)Resources.Load("Prefabs/CityBuildings/" + "Building_CornerHouse_A"));
GameObject polygon = new GameObject();
Poly2Mesh.Polygon poly = new Poly2Mesh.Polygon();
poly.outside = feature.convertedGeometry;
if (feature.clips != null)
{
foreach (IList clipVerts in feature.clips)
{
poly.holes.Add(GOFeature.CoordsToVerts(clipVerts));
}
}
MeshFilter filter = polygon.AddComponent <MeshFilter>();
polygon.AddComponent(typeof(MeshRenderer));
try {
mesh = Poly2Mesh.CreateMesh(poly);
} catch {
}
if (height > 1)
{
if (mesh)
{
Vector2[] uv2d = new Vector2[mesh.vertices.Length];
for (int i = 0; i < uv2d.Length; i++)
{
uv2d[i] = new Vector2(mesh.vertices[i].x, mesh.vertices[i].z);
}
var meshlemp = Mesh.Instantiate(mesh);
meshlemp.uv = uv2d;
mesh2D = Mesh.Instantiate(meshlemp);
mesh.uv = uv2d;
if (height > 0)
{
mesh = SimpleExtruder.Extrude(mesh, polygon, height);
Vector2[] uvs3D = new Vector2[mesh.vertices.Length];
for (int i = 0; i < uvs3D.Length - 1; i++)
{
uvs3D[i] = new Vector2(Vector2.Distance(new Vector2(mesh.vertices[i + 1].x, mesh.vertices[i + 1].z), new Vector2(mesh.vertices[i].x, mesh.vertices[i].z)), mesh.vertices[i].y);
}
// uvs2[uvs2.Length - 1] = new Vector2(Mathf.Sqrt((float)(Math.Pow(mesh.vertices[0].x - mesh.vertices[uvs2.Length - 1].x, 2) + Math.Pow(mesh.vertices[0].z - mesh.vertices[uvs2.Length - 1].z, 2))), mesh.vertices[uvs2.Length - 1].y);
uvs3D[uvs3D.Length - 1] = new Vector2(10, mesh.vertices[uvs3D.Length - 1].y);
mesh.uv = uvs3D;
}
}
}
else
{
if (mesh)
{
Vector2[] uvs = new Vector2[mesh.vertices.Length];
for (int i = 0; i < uvs.Length; i++)
{
uvs[i] = new Vector2(mesh.vertices[i].x, mesh.vertices[i].z);
}
mesh.uv = uvs;
if (height > 0)
{
mesh = SimpleExtruder.Extrude(mesh, polygon, height);
}
}
}
filter.sharedMesh = mesh;
if (layer.useColliders)
{
polygon.AddComponent <MeshCollider>().sharedMesh = mesh;
}
return(polygon);
}
private void OnCellSpace(XmlReader reader)
{
GameObject solid = new GameObject();
string localName = string.Empty;
string localType = string.Empty;
while (isEndElement(reader, "cellSpaceMember") == false)
{
reader.Read();
if (string.IsNullOrWhiteSpace(localName))
{
reader.Read();
localName = reader.GetAttribute("gml:id");
localType = reader.LocalName;
if (localType.Equals("TransitionSpace"))
{
solid.tag = CommonObjs.TAG_TRANSITIONSPACE;
solid.transform.parent = CommonObjs.gmlRootTransitionSpace.transform;
}
else if (localType.Equals("GeneralSpace"))
{
solid.tag = CommonObjs.TAG_GENERALSPACE;
solid.transform.parent = CommonObjs.gmlRootGeneralSpace.transform;
}
else
{
solid.tag = CommonObjs.TAG_CELLSPACE;
solid.transform.parent = CommonObjs.gmlRootCellSpace.transform;
}
}
if (isStartElement(reader, "Solid"))
{
int faceCnt = 1;
solid.name = localName;
reader.Read();
while (isEndElement(reader, "Solid") == false)
{
reader.Read();
if (isStartElement(reader, "Polygon") || isStartElement(reader, "PolygonPatch"))
{
var polygon = OnPolygon(reader);
GameObject genPolygon = Poly2Mesh.CreateGameObject(polygon);
genPolygon.name = string.Format("{0}_Face:{1}", localName, faceCnt++);
genPolygon.transform.parent = solid.transform;
if (localType.Equals("TransitionSpace"))
{
genPolygon.GetComponent <Renderer>().material = CommonObjs.materialTransitionSpace;
}
else if (localType.Equals("GeneralSpace"))
{
genPolygon.GetComponent <Renderer>().material = CommonObjs.materialGeneralSpace;
}
else
{
// CellSpace
genPolygon.GetComponent <Renderer>().material = CommonObjs.materialCellSpace;
}
}
}
}
}
}
public static GOMesh PreloadPolygon(GOFeature feature)
{
if (feature.convertedGeometry == null)
{
return(null);
}
if (feature.convertedGeometry.Count == 2 && feature.convertedGeometry[0].Equals(feature.convertedGeometry[1]))
{
return(null);
}
List <Vector3> clean = feature.convertedGeometry.Distinct().ToList();
if (clean == null || clean.Count <= 2)
{
return(null);
}
Poly2Mesh.Polygon poly = new Poly2Mesh.Polygon();
poly.outside = feature.convertedGeometry;
if (feature.clips != null)
{
foreach (List <Vector3> clipVerts in feature.clips)
{
poly.holes.Add(clipVerts);
}
}
GOMesh preMesh = null;
preMesh = Poly2Mesh.CreateMeshInBackground(poly);
if (preMesh != null)
{
// if (feature.layer.layerType != GOLayer.GOLayerType.Buildings) {
Vector2[] uvs = new Vector2[preMesh.vertices.Length];
Vector3[] vertices = preMesh.vertices;
for (int i = 0; i < uvs.Length; i++)
{
uvs [i] = new Vector2(vertices [i].x, vertices [i].z) * 0.01f;
}
preMesh.uv = uvs;
// }
if (feature.goTile.useElevation)
{
feature.ComputeHighestAltitude();
}
// feature.height += GOFeature.BuildingElevationOffset;
if (feature.height > 0)
{
feature.height *= feature.goTile.worldScale;
preMesh.secondaryMesh = new GOMesh(preMesh);
float h = feature.height;
if (feature.goTile.useElevation)
{
h += GOFeature.BuildingElevationOffset;
}
h += Noise();
preMesh.separateTop = feature.renderingOptions.hasRoof;
preMesh = SimpleExtruder.SliceExtrudePremesh(preMesh, h, 4f, 4f, 10f * feature.goTile.worldScale);
}
}
return(preMesh);
}
//End m2
public void Generation()
{
if (points.Count >= 3)
{
points.Add(points[0]);
lineRenderer.positionCount += 1;
lineRenderer.SetPosition(transform.childCount - 1, lineRenderer.GetPosition(0));
Poly2Mesh.Polygon poly = new Poly2Mesh.Polygon();
poly.outside = points;
// Set up game object with mesh;
GameObject gob = new GameObject();
gob.name = "Polygon";
gob.tag = "Polygon";
gob.AddComponent(typeof(MeshRenderer));
MeshFilter filter = gob.AddComponent(typeof(MeshFilter)) as MeshFilter;
GameObject polyMesh = Poly2Mesh.CreateGameObject(poly);
filter.mesh = polyMesh.GetComponent <MeshFilter>().mesh;
if (filter != null)
{
Mesh mesh2 = filter.mesh;
Vector3[] normals = mesh2.normals;
for (int i = 0; i < normals.Length; i++)
{
normals[i] = -normals[i];
}
mesh2.normals = normals;
for (int m = 0; m < mesh2.subMeshCount; m++)
{
int[] triangles = mesh2.GetTriangles(m);
for (int i = 0; i < triangles.Length; i += 3)
{
int temp = triangles[i + 0];
triangles[i + 0] = triangles[i + 1];
triangles[i + 1] = temp;
}
mesh2.SetTriangles(triangles, m);
}
}
//gob.AddComponent<BoxCollider>().size = new Vector3(1f, 1f, 0.001f);
//m2
areaSum = AreaOfMesh(polyMesh.GetComponent <MeshFilter>().sharedMesh);
xyArea = areaSum;
txt_areaSum.text = "~ " + areaSum.ToString("#.##") + " m2";
if (areaSum < 1)
{
txt_areaSum.text = "~ 0" + areaSum.ToString("#.##") + " m2";
}
_changeMaterial.work = true;
start = true;
lineRenderer.positionCount = 0;
punkDot.positionCount = 0;
ClearAllDots();
_changeMaterial.Material1();
_swipeAnim.UpSwipe();
first_Toturial = false;
_TextBox_3.SetActive(false);
_TextBox_1.SetActive(false);
_TextBox_2.SetActive(false);
_TextBox_4.SetActive(false);
first_Box_1 = false;
first_Box_2 = false;
first_Box_3 = false;
first_Box_4 = false;
_ToturialUI.SetActive(false);
}
}
private void OnCellSpace(XmlReader reader) //read room data
{
GameObject solid = new GameObject();
string cellname = null;
string localType = null;
GameObject genPolygon;
bool isWorkshop = false;
while (IsEndElement(reader, "cellSpaceMember") == false)
{
reader.Read();
if (string.IsNullOrWhiteSpace(localType))
{
reader.Read();
localType = reader.GetAttribute("gml:id");
if (localType.Equals("TransitionSpace"))
{
solid.tag = CommonObjs.TAG_TRANSITIONSPACE;
solid.transform.parent = CommonObjs.gmlRootTransitionSpace.transform;
}
else if (localType.Equals("GeneralSpace"))
{
solid.tag = CommonObjs.TAG_GENERALSPACE;
solid.transform.parent = CommonObjs.gmlRootGeneralSpace.transform;
}
else
{
solid.tag = CommonObjs.TAG_CELLSPACE;
solid.transform.parent = CommonObjs.gmlRootCellSpace.transform;
}
}
if (IsStartElement(reader, "name"))
{
cellname = reader.ReadInnerXml();
isWorkshop = cellname.Contains("Workshop");
}
if (IsStartElement(reader, "Solid"))
{
int faceCnt = 1;
solid.name = cellname;
reader.Read();
while (IsEndElement(reader, "Solid") == false)
{
reader.Read();
if (IsStartElement(reader, "Polygon") || IsStartElement(reader, "PolygonPatch"))
{
var polygon = OnPolygon(reader);
genPolygon = Poly2Mesh.CreateGameObject(polygon, isWorkshop);
genPolygon.name = string.Format("{0}_Face:{1}", localType, faceCnt++);
genPolygon.transform.parent = solid.transform;
if (localType.Equals("TransitionSpace"))
{
genPolygon.GetComponent <Renderer>().material = CommonObjs.machineFront;
}
else if (localType.Equals("GeneralSpace"))
{
genPolygon.GetComponent <Renderer>().material = CommonObjs.materialGeneralSpace;
}
if (isWorkshop)
{
genPolygon.GetComponent <Renderer>().material = CommonObjs.materialWorkshop;
workshopObjects.Add(genPolygon);
}
else
{
genPolygon.GetComponent <Renderer>().material = CommonObjs.materialCellSpace;
}
}
#region machines
if (IsStartElement(reader, "Objects"))
{
while (IsEndElement(reader, "Objects") == false)
{
reader.Read();
if (IsStartElement(reader, "Machine")) //read machine data
{
string machineName = reader.GetAttribute("name");
string[] machineState = new string[2];
if (reader.GetAttribute("extRef") == "true")
{
reader.Read();
Vector3 machinePosition = new Vector3();
string machineFileURL = fileUrl;
string machineFileName;
machineFileURL = machineFileURL.Substring(8);
string last = machineFileURL[machineFileURL.Length - 1].ToString();
float machineRotation = 0;
while (last != @"/") //delete IndoorGML Filename from URL
{
machineFileURL = machineFileURL.TrimEnd(machineFileURL[machineFileURL.Length - 1]);
last = machineFileURL[machineFileURL.Length - 1].ToString();
}
while (IsEndElement(reader, "Machine") == false)
{
reader.Read();
if (IsStartElement(reader, "ref"))
{
while (IsEndElement(reader, "ref") == false)
{
reader.Read();
if (IsStartElement(reader, "objectfile"))
{
machineFileName = reader.GetAttribute("file");
refFileURL = machineFileURL + machineFileName + "/";
machineFileURL += machineFileName + "/" + machineFileName + ".obj";
}
if (IsStartElement(reader, "picture"))
{
machineRefs.Add(new string[4] {
machineName, "picture", null, refFileURL + reader.GetAttribute("file")
});
}
if (IsStartElement(reader, "documents"))
{
while (IsEndElement(reader, "documents") == false)
{
reader.Read();
if (IsStartElement(reader, "document"))
{
machineRefs.Add(new string[4] {
machineName, "document", reader.GetAttribute("name"), refFileURL + reader.GetAttribute("file")
});
}
}
}
}
}
if (IsStartElement(reader, "pos"))
{
reader.Read();
machinePosition = GetPos3D(reader);
}
if (IsStartElement(reader, "rot"))
{
float.TryParse(reader.ReadInnerXml(), out machineRotation);
}
if (IsStartElement(reader, "partialboundedBy"))
{
machineState[1] = reader.GetAttribute("xlink:href");
}
}
GameObject machineObj = new GameObject {
name = machineName
};
machineObj.AddComponent(typeof(MeshRenderer));
MeshFilter filter = machineObj.AddComponent(typeof(MeshFilter)) as MeshFilter;
ObjImporter importer = new ObjImporter();
Mesh mesh = importer.ImportFile(machineFileURL);
filter.mesh = mesh;
mesh.RecalculateNormals();
machineObj.AddComponent(typeof(MeshCollider));
machineObj.GetComponent <MeshCollider>().sharedMesh = mesh;
machineObj.GetComponent <MeshCollider>().convex = true;
machineObj.transform.position = machinePosition;
machineObj.transform.localScale = new Vector3(0.001f, 0.001f, 0.001f);
machineObj.transform.localEulerAngles = new Vector3(0, machineRotation, 0);
machineObj.transform.parent = solid.transform;
Assembly asm = Assembly.Load("Assembly-CSharp, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null");
Type type = asm.GetType("MachineStatus");
machineObj.AddComponent(type);
machines.Add(machineObj);
if (inspection)
{
machineState[0] = machineName;
machineStates.Add(machineState);
machineObj.GetComponent <Renderer>().material = Resources.Load("Materials/Machine_INSPECTION", typeof(Material)) as Material;
foreach (Dropdown dropdown in machineChoiceOption)
{
dropdown.options.Add(new Dropdown.OptionData()
{
text = machineName
});
}
}
}
}
}
}
#endregion
}
}
if (IsStartElement(reader, "partialboundedBy"))
{
string[] boundedBy = new string[2];
boundedBy[0] = localType;
boundedBy[1] = reader.GetAttribute("xlink:href");
if (!inspection)
{
player.GetComponent <PlayerController>().roomBoundaries.Add(boundedBy);
}
}
}
}
public static GOMesh PreloadPolygon(GOFeature feature)
{
if (feature.convertedGeometry == null)
{
return(null);
}
if (feature.convertedGeometry.Count == 2 && feature.convertedGeometry[0].Equals(feature.convertedGeometry[1]))
{
return(null);
}
List <Vector3> clean = feature.convertedGeometry.Distinct().ToList();
if (clean == null || clean.Count <= 2)
{
return(null);
}
Poly2Mesh.Polygon poly = new Poly2Mesh.Polygon();
poly.outside = feature.convertedGeometry;
if (feature.clips != null)
{
foreach (List <Vector3> clipVerts in feature.clips)
{
poly.holes.Add(clipVerts);
}
}
GOMesh preMesh = null;
// try {
preMesh = Poly2Mesh.CreateMeshInBackground(poly);
// } catch {
// Debug.LogWarning ("Catched polygon");
// }
if (preMesh != null)
{
Vector2[] uvs = new Vector2[preMesh.vertices.Length];
Vector3[] vertices = preMesh.vertices;
for (int i = 0; i < uvs.Length; i++)
{
uvs[i] = new Vector2(vertices[i].x, vertices[i].z);
}
preMesh.uv = uvs;
if (feature.height > 0)
{
preMesh.secondaryMesh = new GOMesh(preMesh);
float h = feature.height;
if (GOMap.GOLink)
{
h += GOFeature.BuildingElevationOffset;
}
h += Noise();
preMesh = SimpleExtruder.SliceExtrudePremesh(preMesh, h, 4f, 4f, 10f);
}
}
return(preMesh);
}
