/// <summary> /// This one ignores finding openings within specific shapes as we'll be doing this for rooms in floorplan gen /// </summary> /// <param name="building"></param> /// <param name="volume"></param> /// <returns></returns> public static VerticalOpening[] GetOpeningsQuick(IBuilding building, IVolume volume) { List <VerticalOpening> output = new List <VerticalOpening>(); int count = building.openingCount; VerticalOpening[] openings = building.GetAllOpenings(); int volumeBaseFloor = building.VolumeBaseFloor(volume); int volumeTopFloor = volumeBaseFloor + volume.floors; for (int i = 0; i < count; i++) { VerticalOpening opening = openings[i]; int openingBaseFloor = opening.baseFloor; int openingTopFloor = openingBaseFloor + opening.floors; // Debug.Log("CHECK IT " + openingTopFloor + " " + volume.name); // Debug.Log(volumeBaseFloor + " < " + openingTopFloor + " && " + openingBaseFloor + " < " + volumeTopFloor); if (volumeBaseFloor <= openingTopFloor && openingBaseFloor < volumeTopFloor)//opening and volume floors intersect { // Debug.Log("opening " + openingTopFloor + " "+ volume.name); FlatBounds volumeBounds = new FlatBounds(volume.bounds); volumeBounds.Expand(VerticalOpening.WALL_THICKNESS); Vector2[] openingPoints = opening.PointsRotated(); FlatBounds openingBounds = new FlatBounds(openingPoints); // if(volume.name == "Roof Exit") // { // Debug.Log(volumeBounds.Overlaps(openingBounds, true)); // Debug.Log(openingBounds.Overlaps(volumeBounds, true)); // volumeBounds.DrawDebug(Color.red); // openingBounds.DrawDebug(Color.green); // } if (openingBounds.Overlaps(volumeBounds, true))// opening is within the AABB bounds of the volume { output.Add(opening); // Debug.Log("opening bounds " + openingTopFloor + " " + volume.name); } else { // Debug.Log("opening NOT " + openingTopFloor + " " + volume.name); } } // Debug.Log("================================="); } return(output.ToArray()); }
public static bool SweepIntersects2(Vector2 a1, Vector2 a2, Vector2 b1, Vector2 b2, Vector2 l1, Vector2 l2, out Vector2 intersection, out float percent, float accuracy = 1, bool debug = false) { intersection = Vector2.zero; percent = 0; Vector2[] poly = { a1, a2, b2, b1 }; FlatBounds edgeBounds = new FlatBounds(poly); FlatBounds lineBounds = new FlatBounds(new [] { l1, l2 }); if (!edgeBounds.Overlaps(lineBounds, true)) { if (debug) { edgeBounds.DrawDebug(Color.cyan); } if (debug) { lineBounds.DrawDebug(Color.green); } if (debug) { Debug.DrawLine(ToV3(l1), ToV3(l2), Color.cyan); } return(false); } int numberOfPolyPoints = poly.Length; bool lineIntersectsShape = false; for (int i = 0; i < numberOfPolyPoints; i++) { Vector2 p0 = poly[i]; Vector2 p1 = poly[(i + 1) % numberOfPolyPoints]; if (debug) { Debug.DrawLine(ToV3(p0), ToV3(p1), Color.blue); } if (FastLineIntersection(p0, p1, l1, l2)) { lineIntersectsShape = true; break; } } if (!lineIntersectsShape)//line never crosses shape { Vector2 right = new Vector2(Mathf.Max(edgeBounds.width, edgeBounds.height), 0); int shapeIntersections = 0; for (int i = 0; i < numberOfPolyPoints; i++) { Vector2 p0 = poly[i]; Vector2 p1 = poly[(i + 1) % numberOfPolyPoints]; if (debug) { Debug.DrawLine(ToV3(p0) + Vector3.up * 5, ToV3(p1) + Vector3.up * 5, Color.blue); } if (FastLineIntersection(l1, l1 + right, p0, p1)) { if (debug) { Debug.DrawLine(ToV3(l1), ToV3(l1) + Vector3.up * 5, Color.magenta); } shapeIntersections++; } if (FastLineIntersection(l2, l2 + right, p0, p1)) { if (debug) { Debug.DrawLine(ToV3(l1), ToV3(l1) + Vector3.up * 5, Color.magenta); } shapeIntersections++; break; } } if (shapeIntersections % 2 == 0) { return(false);//line not within shape } } if (debug) { edgeBounds.DrawDebug(Color.green); } Vector2 delta1 = b1 - a1; Vector2 delta2 = b2 - a2; float maxDelta = Mathf.Max(delta1.magnitude, delta2.magnitude); int iterations = Mathf.CeilToInt(maxDelta / accuracy); bool initalState = Ccw(a1, a2, l1); for (int i = 1; i < iterations; i++) { percent = i / (iterations - 1f); Vector2 e1 = Vector2.Lerp(a1, b1, percent); Vector2 e2 = Vector2.Lerp(a2, b2, percent); if (debug) { Debug.DrawLine(ToV3(e1), ToV3(e2), new Color(1, 0, 1, 0.5f)); } Vector2 p = Vector2.Lerp(l1, l2, percent); bool currentState = Ccw(e1, e2, p); if (currentState != initalState || i == iterations - 1) { float dist1 = Vector2.Distance(e1, p); float dist2 = Vector2.Distance(e2, p); float xpercent = dist1 / (dist1 + dist2); intersection = Vector2.Lerp(e1, e2, xpercent); if (debug) { Debug.DrawLine(ToV3(e1), ToV3(e2), Color.red); } if (debug) { Debug.DrawLine(ToV3(intersection), ToV3(intersection) + Vector3.up * 10, Color.red); } break; } } return(true); }
public static void Generate(IBuilding building, IVolume volume, IFloorplan floorplan, int volumeFloor, VerticalOpening[] openings, BuildRMesh mesh, BuildRCollider collider) { SubmeshLibrary submeshLibrary = mesh.submeshLibrary; bool generateColliders = building.colliderType != BuildingColliderTypes.None; bool generateMeshColliders = building.colliderType != BuildingColliderTypes.Primitive && generateColliders; BuildRCollider sendCollider = (generateColliders) ? collider : null; collider.thickness = volume.wallThickness; if (!generateMeshColliders) { collider = null; } float wallThickness = volume.wallThickness; float wallUp = volume.floorHeight - wallThickness; Vector3 wallUpV = Vector3.up * wallUp; Vector3 floorBaseV = Vector3.up * volume.baseHeight; int roomCount = floorplan.RoomCount; int actualFloor = building.VolumeBaseFloor(volume) + volumeFloor; int openingCount = openings.Length; bool[] openingBelow = new bool[openingCount]; bool[] openingAbove = new bool[openingCount]; FlatBounds[] openingBounds = new FlatBounds[openingCount]; Vector2[][] openingShapes = new Vector2[openingCount][]; bool[] openingUsedInThisFloor = new bool[openingCount]; for (int o = 0; o < openingCount; o++) { VerticalOpening opening = openings[o]; if (!openings[o].FloorIsIncluded(actualFloor)) { continue; } openingBelow[o] = opening.FloorIsIncluded(actualFloor - 1); openingAbove[o] = opening.FloorIsIncluded(actualFloor + 1); openingShapes[o] = opening.PointsRotated(); openingBounds[o] = new FlatBounds(openingShapes[o]); submeshLibrary.Add(opening.surfaceA); submeshLibrary.Add(opening.surfaceB); submeshLibrary.Add(opening.surfaceC); submeshLibrary.Add(opening.surfaceD); } Dictionary <int, List <Vector2Int> > externalWallAnchors = volume.facadeWallAnchors; Room[] rooms = floorplan.AllRooms(); for (int r = 0; r < roomCount; r++) { Room room = rooms[r]; int pointCount = room.numberOfPoints; Surface floorSurface = null; Surface wallSurface = null; Surface ceilingSurface = null; if (room.style != null) { RoomStyle style = room.style; floorSurface = style.floorSurface; wallSurface = style.wallSurface; ceilingSurface = style.ceilingSurface; } int floorSubmesh = submeshLibrary.SubmeshAdd(floorSurface); int wallSubmesh = submeshLibrary.SubmeshAdd(wallSurface); int ceilingSubmesh = submeshLibrary.SubmeshAdd(ceilingSurface); FloorplanUtil.RoomWall[] walls = FloorplanUtil.CalculatePoints(room, volume); Vector2[] roomArchorPoints = FloorplanUtil.RoomArchorPoints(walls); Vector4 tangent = BuildRMesh.CalculateTangent(Vector3.right); Vector2[] offsetRoomAnchorPoints = QuickPolyOffset.Execute(roomArchorPoints, wallThickness); FlatBounds roomBounds = new FlatBounds(offsetRoomAnchorPoints); List <Vector2[]> floorCuts = new List <Vector2[]>(); List <Vector2[]> ceilingCuts = new List <Vector2[]>(); List <VerticalOpening> roomOpenings = new List <VerticalOpening>(); for (int o = 0; o < openingCount; o++) { if (openings[o].FloorIsIncluded(actualFloor)) { if (roomBounds.Overlaps(openingBounds[o])) { if (CheckShapeWithinRoom(offsetRoomAnchorPoints, openingShapes[o])) { if (openingBelow[o]) { floorCuts.Add(openingShapes[o]); } if (openingAbove[o]) { ceilingCuts.Add(openingShapes[o]); } if (openingAbove[o] || openingBelow[o]) { roomOpenings.Add(openings[o]); openingUsedInThisFloor[o] = true; } } } } } int offsetPointBase = 0; for (int p = 0; p < pointCount; p++)//generate room walls { FloorplanUtil.RoomWall wall = walls[p]; int wallPointCount = wall.offsetPoints.Length; List <RoomPortal> wallPortals = floorplan.GetWallPortals(room, p); int wallPortalCount = wallPortals.Count; if (!wall.isExternal) { int indexA = offsetPointBase; int indexB = (offsetPointBase + 1) % roomArchorPoints.Length; Vector2 origBaseA = roomArchorPoints[indexA]; Vector2 origBaseB = roomArchorPoints[indexB]; Vector2 baseA = offsetRoomAnchorPoints[indexA]; Vector2 baseB = offsetRoomAnchorPoints[indexB]; Vector3 v0 = new Vector3(origBaseA.x, 0, origBaseA.y) + floorBaseV; Vector3 v1 = new Vector3(origBaseB.x, 0, origBaseB.y) + floorBaseV; Vector3 vOffset0 = new Vector3(baseA.x, 0, baseA.y) + floorBaseV; Vector3 vOffset1 = new Vector3(baseB.x, 0, baseB.y) + floorBaseV; if (wallPortalCount == 0) //just draw the wall - no portals to cut { Vector3 v2 = vOffset1 + wallUpV; Vector3 v3 = vOffset0 + wallUpV; Vector2 minUV = Vector2.zero; Vector2 maxUV = new Vector2(Vector2.Distance(baseA, baseB), wallUp); if (wallSurface != null) { maxUV = wallSurface.CalculateUV(maxUV); } Vector3 wallDir = (vOffset0 - vOffset1).normalized; Vector3 wallNormal = Vector3.Cross(Vector3.up, wallDir); Vector4 wallTangent = BuildRMesh.CalculateTangent(wallDir); mesh.AddPlane(vOffset1, vOffset0, v2, v3, minUV, maxUV, wallNormal, wallTangent, wallSubmesh, wallSurface); if (generateColliders) { collider.AddPlane(vOffset1, vOffset0, v2, v3); } } else { List <float> useLaterals = new List <float>(); List <bool> hasPortals = new List <bool>(); for (int wp = 0; wp < wallPortalCount; wp++) { RoomPortal portal = wallPortals[wp]; bool hasPortal = room.HasPortal(portal); hasPortals.Add(hasPortal); if (hasPortal) { useLaterals.Add(portal.lateralPosition); } else { useLaterals.Add(1 - portal.lateralPosition);//portal from other wall - wall orientation is flipped } } Vector3 wallVector = vOffset1 - vOffset0; Vector3 wallDirection = wallVector.normalized; Vector3 wallStart = vOffset0; Vector4 wallTangent = BuildRMesh.CalculateTangent(wallDirection); Vector3 wallNormal = Vector3.Cross(Vector3.up, wallDirection); Vector4 wallNormalTangent = BuildRMesh.CalculateTangent(wallNormal); Vector4 wallNormalTangentReverse = BuildRMesh.CalculateTangent(-wallNormal); while (wallPortalCount > 0) { int portalIndex = 0; RoomPortal usePortal = wallPortals[0]; float lowestLat = useLaterals[0]; for (int wp = 1; wp < wallPortalCount; wp++) { if (useLaterals[wp] < lowestLat) { portalIndex = wp; usePortal = wallPortals[wp]; lowestLat = useLaterals[wp]; } } wallPortals.RemoveAt(portalIndex); useLaterals.RemoveAt(portalIndex); wallPortalCount--; Vector3 vl0 = v0 + (-wallNormal + wallDirection) * wallThickness; Vector3 vl1 = v1 + (-wallNormal - wallDirection) * wallThickness; Vector3 portalCenter = Vector3.Lerp(vl0, vl1, lowestLat); Vector3 portalHalfvector = wallDirection * (usePortal.width * 0.5f); Vector3 portalBase = Vector3.up * (volume.floorHeight - usePortal.height) * usePortal.verticalPosition; Vector3 portalUp = portalBase + Vector3.up * usePortal.height; Vector3 portalStart = portalCenter - portalHalfvector; Vector3 portalEnd = portalCenter + portalHalfvector; Vector2 initalWallUVMin = new Vector2(Vector3.Dot(portalStart, wallDirection), 0); Vector2 initalWallUVMax = new Vector2(Vector3.Dot(wallStart, wallDirection), wallUp); mesh.AddPlane(portalStart, wallStart, portalStart + wallUpV, wallStart + wallUpV, initalWallUVMin, initalWallUVMax, wallNormal, wallTangent, wallSubmesh, wallSurface);//initial wall if (generateColliders) { collider.AddPlane(portalStart, wallStart, portalStart + wallUpV, wallStart + wallUpV); } if (usePortal.verticalPosition > 0) { Vector2 portalBaseUVMin = new Vector2(Vector3.Dot(portalEnd, wallDirection), 0); Vector2 portalBaseUVMax = new Vector2(Vector3.Dot(portalStart, wallDirection), portalBase.y); mesh.AddPlane(portalEnd, portalStart, portalEnd + portalBase, portalStart + portalBase, portalBaseUVMin, portalBaseUVMax, wallNormal, wallTangent, wallSubmesh, wallSurface);//bottom if (generateColliders) { collider.AddPlane(portalEnd, portalStart, portalEnd + portalBase, portalStart + portalBase); } } if (usePortal.verticalPosition < 1) { Vector2 portalBaseUVMin = new Vector2(Vector3.Dot(portalEnd, wallDirection), portalUp.y); Vector2 portalBaseUVMax = new Vector2(Vector3.Dot(portalStart, wallDirection), wallUp); mesh.AddPlane(portalEnd + portalUp, portalStart + portalUp, portalEnd + wallUpV, portalStart + wallUpV, portalBaseUVMin, portalBaseUVMax, wallNormal, wallTangent, wallSubmesh, wallSurface);//top if (generateColliders) { collider.AddPlane(portalEnd + portalUp, portalStart + portalUp, portalEnd + wallUpV, portalStart + wallUpV); } } if (hasPortals[portalIndex])//only do this once - from the room it's attached to { //portal interior frame Vector3 portalDepth = wallNormal * wallThickness * 2; //sides mesh.AddPlane(portalStart + portalDepth + portalBase, portalStart + portalBase, portalStart + portalDepth + portalUp, portalStart + portalUp, wallDirection, wallNormalTangentReverse, wallSubmesh); mesh.AddPlane(portalEnd + portalBase, portalEnd + portalDepth + portalBase, portalEnd + portalUp, portalEnd + portalDepth + portalUp, -wallDirection, wallNormalTangent, wallSubmesh); if (generateMeshColliders) { collider.AddPlane(portalStart + portalDepth + portalBase, portalStart + portalBase, portalStart + portalDepth + portalUp, portalStart + portalUp); collider.AddPlane(portalEnd + portalBase, portalEnd + portalDepth + portalBase, portalEnd + portalUp, portalEnd + portalDepth + portalUp); } //floor Vector2 minFloorUv = new Vector2((portalEnd + portalBase).z, (portalEnd + portalBase).x); Vector2 maxFloorUv = minFloorUv + new Vector2(wallThickness, usePortal.width); mesh.AddPlane(portalStart + portalBase, portalStart + portalDepth + portalBase, portalEnd + portalBase, portalEnd + portalDepth + portalBase, minFloorUv, maxFloorUv, Vector3.up, wallTangent, floorSubmesh, floorSurface); if (generateMeshColliders) { collider.AddPlane(portalStart + portalBase, portalStart + portalDepth + portalBase, portalEnd + portalBase, portalEnd + portalDepth + portalBase); } //ceiling mesh.AddPlane(portalEnd + portalUp, portalEnd + portalDepth + portalUp, portalStart + portalUp, portalStart + portalDepth + portalUp, Vector3.down, wallTangent, wallSubmesh); if (generateMeshColliders) { collider.AddPlane(portalEnd + portalUp, portalEnd + portalDepth + portalUp, portalStart + portalUp, portalStart + portalDepth + portalUp); } } wallStart = portalEnd;//move the start for the next calculation } Vector2 finalWallUVMin = new Vector2(Vector3.Dot(vOffset1, wallDirection), 0); Vector2 finalWallUVMax = new Vector2(Vector3.Dot(wallStart, wallDirection), wallUp); mesh.AddPlane(vOffset1, wallStart, vOffset1 + wallUpV, wallStart + wallUpV, finalWallUVMin, finalWallUVMax, wallNormal, wallTangent, wallSubmesh, wallSurface);//final wall section if (generateColliders) { collider.AddPlane(vOffset1, wallStart, vOffset1 + wallUpV, wallStart + wallUpV); } } offsetPointBase += 1; } else//external anchored wall { int facadeIndex = wall.facadeIndex; Facade facadeDesign = volume.GetFacade(facadeIndex); int currentFacadeWallSectionLength = externalWallAnchors[facadeIndex].Count - 1; int currentWallSectionIndex = wall.offsetPointWallSection[0]; int wallOffsetPoints = wall.offsetPoints.Length; for (int w = 0; w < wallOffsetPoints - 1; w++) { int roomPointIndex = offsetPointBase + w; Vector2 baseA = offsetRoomAnchorPoints[roomPointIndex]; int offsetIndexB = (roomPointIndex + 1) % offsetRoomAnchorPoints.Length; Vector2 baseB = offsetRoomAnchorPoints[offsetIndexB]; Vector3 v0 = new Vector3(baseA.x, 0, baseA.y) + floorBaseV; Vector3 v1 = new Vector3(baseB.x, 0, baseB.y) + floorBaseV; int wallSectionIndex = wall.offsetPointWallSection[w]; bool canGenerateWallSection = facadeDesign != null; Vector3 wallVector = v0 - v1; Vector3 wallDir = wallVector.normalized; float wallLength = wallVector.magnitude; if (!canGenerateWallSection) { if (wallSurface != null) { submeshLibrary.Add(wallSurface); } Vector3 v2 = v1 + wallUpV; Vector3 v3 = v0 + wallUpV; Vector2 minUV = Vector2.zero; Vector2 maxUV = new Vector2(Vector2.Distance(baseA, baseB), wallUp); Vector3 wallNormal = Vector3.Cross(Vector3.up, wallDir); Vector4 wallTangent = BuildRMesh.CalculateTangent(wallDir); mesh.AddPlane(v1, v0, v2, v3, minUV, maxUV, wallNormal, wallTangent, wallSubmesh, wallSurface); if (generateMeshColliders) { collider.AddPlane(v1, v0, v2, v3); } } else { WallSection section = facadeDesign.GetWallSection(wallSectionIndex, volumeFloor, currentFacadeWallSectionLength, volume.floors); if (section.model != null) { continue;//cannot account for custom meshes assume custom mesh does include interior mesh or if does - will be generated with the exterior } GenerationOutput generatedSection = GenerationOutput.CreateRawOutput(); Vector2 wallSectionSize = new Vector2(wallLength, wallUp + wallThickness); bool cullOpening = building.cullDoors && section.isDoor; SubmeshLibrary sectionLib = new SubmeshLibrary(); if (wallSurface != null) { sectionLib.Add(wallSurface);//add interior wall surface submeshLibrary.Add(wallSurface); } sectionLib.Add(section.openingSurface);//add windows - the only surface we'll use in the interior room submeshLibrary.Add(section.openingSurface); float offset = 0; if (w == 0) { offset = wallThickness; } if (w == wallOffsetPoints - 2) { offset = -wallThickness; } WallSectionGenerator.Generate(section, generatedSection, wallSectionSize, true, wallThickness, cullOpening, null, sectionLib, offset); int[] mapping = submeshLibrary.MapSubmeshes(generatedSection.raw.materials); Vector3 curveNormal = Vector3.Cross(wallDir, Vector3.up); Quaternion meshRot = Quaternion.LookRotation(curveNormal, Vector3.up); Vector3 meshPos = new Vector3(v1.x, volume.baseHeight, v1.z) + wallDir * wallSectionSize.x + Vector3.up * wallSectionSize.y; meshPos += meshRot * -new Vector3(wallSectionSize.x, wallSectionSize.y, 0) * 0.5f; mesh.AddData(generatedSection.raw, mapping, meshPos, meshRot, Vector3.one); } currentWallSectionIndex++; if (currentWallSectionIndex >= currentFacadeWallSectionLength) { //reached the end of the facade - move to the next one and continue currentFacadeWallSectionLength = externalWallAnchors[facadeIndex].Count; currentWallSectionIndex = 0; } } offsetPointBase += wallPointCount - 1; } } //FLOOR Vector2[] mainShape = offsetRoomAnchorPoints; Vector2[][] floorCutPoints = floorCuts.ToArray(); int floorVertCount = mainShape.Length; for (int flc = 0; flc < floorCutPoints.Length; flc++) { floorVertCount += floorCutPoints[flc].Length; } Vector2[] allFloorPoints = new Vector2[floorVertCount]; int mainShapeLength = mainShape.Length; for (int ms = 0; ms < mainShapeLength; ms++) { allFloorPoints[ms] = mainShape[ms]; } int cutPointIterator = mainShapeLength; for (int flc = 0; flc < floorCutPoints.Length; flc++) { for (int flcp = 0; flcp < floorCutPoints[flc].Length; flcp++) { allFloorPoints[cutPointIterator] = floorCutPoints[flc][flcp]; cutPointIterator++; } } Vector3[] floorPoints = new Vector3[floorVertCount]; Vector2[] floorUvs = new Vector2[floorVertCount]; Vector3[] floorNorms = new Vector3[floorVertCount]; Vector4[] floorTangents = new Vector4[floorVertCount]; for (int rp = 0; rp < floorVertCount; rp++) { floorPoints[rp] = new Vector3(allFloorPoints[rp].x, 0, allFloorPoints[rp].y) + floorBaseV; Vector2 uv = allFloorPoints[rp]; if (floorSurface != null) { uv = floorSurface.CalculateUV(uv); } floorUvs[rp] = uv; floorNorms[rp] = Vector3.up; floorTangents[rp] = tangent; } int[] tris = Poly2TriWrapper.Triangulate(mainShape, true, floorCutPoints); mesh.AddData(floorPoints, floorUvs, tris, floorNorms, floorTangents, floorSubmesh); if (generateColliders) { collider.mesh.AddData(floorPoints, floorUvs, tris, floorNorms, floorTangents, 0); } //CEILING! Vector2[][] ceilingCutPoints = ceilingCuts.ToArray(); int ceilingVertCount = mainShape.Length; for (int flc = 0; flc < ceilingCutPoints.Length; flc++) { ceilingVertCount += ceilingCutPoints[flc].Length; } Vector2[] allCeilingPoints = new Vector2[ceilingVertCount]; for (int ms = 0; ms < mainShapeLength; ms++) { allCeilingPoints[ms] = mainShape[ms]; } cutPointIterator = mainShapeLength; for (int flc = 0; flc < ceilingCutPoints.Length; flc++) { for (int flcp = 0; flcp < ceilingCutPoints[flc].Length; flcp++) { allCeilingPoints[cutPointIterator] = ceilingCutPoints[flc][flcp]; cutPointIterator++; } } Vector3[] ceilingPoints = new Vector3[ceilingVertCount]; Vector2[] ceilingUvs = new Vector2[ceilingVertCount]; Vector3[] ceilingNorms = new Vector3[ceilingVertCount]; Vector4[] ceilingTangents = new Vector4[ceilingVertCount]; for (int rp = 0; rp < ceilingVertCount; rp++) { ceilingPoints[rp] = new Vector3(allCeilingPoints[rp].x, wallUp, allCeilingPoints[rp].y) + floorBaseV; Vector2 uv = allCeilingPoints[rp]; if (floorSurface != null) { uv = ceilingSurface.CalculateUV(uv); } ceilingUvs[rp] = uv; ceilingNorms[rp] = Vector3.down; ceilingTangents[rp] = tangent; } tris = Poly2TriWrapper.Triangulate(mainShape, false, ceilingCutPoints); mesh.AddData(ceilingPoints, ceilingUvs, tris, ceilingNorms, ceilingTangents, ceilingSubmesh); if (generateColliders) { collider.mesh.AddData(ceilingPoints, ceilingUvs, tris, ceilingNorms, ceilingTangents, 0); } for (int ob = 0; ob < openingCount; ob++) { VerticalOpening opening = openings[ob]; int openingIndex = Array.IndexOf(openings, opening); Vector3 basePosition = openingBounds[openingIndex].center; basePosition.z = basePosition.y; basePosition.y = volume.baseHeight; if (roomOpenings.Contains(opening))//opening used in this floorplan { int externalWallSubmesh = wallSubmesh != -1 ? wallSubmesh : -1; switch (opening.usage) { case VerticalOpening.Usages.Space: if (ceilingCutPoints.Length <= ob) { continue; } Vector3 ceilingCutUpV = Vector3.up * wallThickness; Vector2[] ceilingCut = ceilingCutPoints[ob]; int custSize = ceilingCut.Length; for (int cp = 0; cp < custSize; cp++) { int indexA = (cp + 1) % custSize; int indexB = cp; Vector3 cp0 = new Vector3(ceilingCut[indexA].x, wallUp, ceilingCut[indexA].y) + floorBaseV; Vector3 cp1 = new Vector3(ceilingCut[indexB].x, wallUp, ceilingCut[indexB].y) + floorBaseV; Vector3 cp2 = cp0 + ceilingCutUpV; Vector3 cp3 = cp1 + ceilingCutUpV; mesh.AddPlane(cp0, cp1, cp2, cp3, ceilingSubmesh); if (generateColliders) { collider.AddPlane(cp0, cp1, cp2, cp3); } } break; case VerticalOpening.Usages.Stairwell: StaircaseGenerator.Generate(mesh, opening, basePosition, volume.floorHeight, actualFloor, externalWallSubmesh, sendCollider); if (volumeFloor == volume.floors - 1 && opening.baseFloor + opening.floors > building.VolumeBaseFloor(volume) + volume.floors - 1 && volume.abovePlanCount == 0) { StaircaseGenerator.GenerateRoofAccess(mesh, opening, basePosition, volume.floorHeight, actualFloor, externalWallSubmesh, sendCollider); } break; case VerticalOpening.Usages.Elevator: ElevatorShaftGenerator.Generate(ref mesh, opening, actualFloor, basePosition, volume.floorHeight, externalWallSubmesh, sendCollider); break; } } } } for (int ob = 0; ob < openingCount; ob++) { Vector2[] openingShape = openingShapes[ob]; if (openingShape == null) { continue; //opening not used by this floorplan } if (openingUsedInThisFloor[ob]) { continue; //opening already generated } //seal this opening from the void VerticalOpening opening = openings[ob]; int openingIndex = Array.IndexOf(openings, opening); Vector3 basePosition = openingBounds[openingIndex].center; basePosition.z = basePosition.y; basePosition.y = 0; int cutSize = openingShape.Length; Vector3 sealingWallUpV = Vector3.up * volume.floorHeight; int sealWallSubmesh = submeshLibrary.SubmeshAdd(opening.surfaceB); Vector2[] offsetOpeningShape = QuickPolyOffset.Execute(openingShape, wallThickness); for (int cp = 0; cp < cutSize; cp++) { int indexA = (cp + 1) % cutSize; int indexB = cp; Vector2 p0 = opening.usage == VerticalOpening.Usages.Space ? openingShape[indexA] : offsetOpeningShape[indexA]; Vector2 p1 = opening.usage == VerticalOpening.Usages.Space ? openingShape[indexB] : offsetOpeningShape[indexB]; Vector3 cp0 = new Vector3(p0.x, 0, p0.y) + floorBaseV; Vector3 cp1 = new Vector3(p1.x, 0, p1.y) + floorBaseV; Vector3 cp2 = cp0 + sealingWallUpV; Vector3 cp3 = cp1 + sealingWallUpV; mesh.AddPlane(cp0, cp1, cp2, cp3, sealWallSubmesh); if (generateColliders) { collider.AddPlane(cp0, cp1, cp2, cp3); } } switch (opening.usage) { case VerticalOpening.Usages.Space: //nothing to implement break; case VerticalOpening.Usages.Stairwell: //need stairs to connect used floors StaircaseGenerator.GenerateStairs(mesh, opening, basePosition, volume.floorHeight, actualFloor, -1, sendCollider); if (volumeFloor == volume.floors - 1) { StaircaseGenerator.GenerateRoofAccess(mesh, opening, basePosition, volume.floorHeight, actualFloor, -1, sendCollider); } break; case VerticalOpening.Usages.Elevator: //nothing to implement break; } } }
public void Execute() { calculatedPartitions.Clear(); //remvoe duplicate points for (int i = 0; i < shape.Count; i++) { Vector2Int p0 = shape[i]; Vector2Int p1 = shape[i < shape.Count - 1 ? i + 1 : 0]; float sqrM = Vector2Int.SqrMagnitudeFloat(p1, p0); if (sqrM < Mathf.Epsilon) { shape.RemoveAt(i); i--; } } //break poly down into convex shapes TPPLPoly poly = new TPPLPoly(); for (int i = 0; i < shape.Count; i++) { poly.Points.Add(new TPPLPoint(shape[i].x, shape[i].y)); } if (BuildrPolyClockwise.Check(shape)) { poly.SetOrientation(TPPLOrder.CW); } else { poly.SetOrientation(TPPLOrder.CCW); } List <TPPLPoly> parts = new List <TPPLPoly>(); TPPLPartition tpplPartition = new TPPLPartition(); tpplPartition.ConvexPartition_HM(poly, parts); //generate an irregular grid upon each convex poly int partCount = parts.Count; PlotSplitter plotSplitter = new PlotSplitter(); floorSegments.Clear(); for (int p = 0; p < partCount; p++) { TPPLPoly partPoly = parts[p]; int partSize = partPoly.Count; List <Vector2Int> plotPoints = new List <Vector2Int>(); for (int w = 0; w < partSize; w++) { TPPLPoint tpplPoint = partPoly[w]; Vector2Int p0 = new Vector2Int(tpplPoint.X, tpplPoint.Y); plotPoints.Add(p0); } Plot plot = new Plot(seed, plotPoints, minimumWallUnitSpacing); plot.splitSettings = splitSettings; plotSplitter.Execute(plot, seed); int splitCount = plotSplitter.plots.Count; for (int s = 0; s < splitCount; s++) { IPlot segmentPlot = plotSplitter.plots[s]; Vector2Int[] points = Vector2Int.Parse(segmentPlot.pointsV2); FloorSegment segment = new FloorSegment(segmentPlot.area, segmentPlot.flatbounds, points); floorSegments.Add(segment); } } int segmentCount = floorSegments.Count; List <FloorSegment> availableSegments = new List <FloorSegment>(floorSegments); int restrictedAreaCount = restrictedAreas.Count; Partition restrictedPartition = null; for (int r = 0; r < restrictedAreaCount; r++) { RestrictedArea area = restrictedAreas[r]; FlatBounds areaBounds = new FlatBounds(); areaBounds.Encapsulate(Vector2Int.Parse(area.shape)); for (int fs = 0; fs < segmentCount; fs++) { FloorSegment segment = availableSegments[fs]; if (areaBounds.Overlaps(segment.bounds)) { if (JMath.ShapesIntersect(Vector2Int.Parse(area.shape), Vector2Int.Parse(segment.points))) { if (restrictedPartition == null) { restrictedPartition = new Partition(); } restrictedPartition.AddSegment(segment); availableSegments.Remove(segment); segmentCount--; fs--; } } } } //Link up floor segments segmentCount = availableSegments.Count; for (int x = 0; x < segmentCount; x++) { FloorSegment subject = floorSegments[x]; FlatBounds subjectBounds = subject.nBounds; for (int y = 0; y < segmentCount; y++) { if (x == y) { continue; } FloorSegment candidate = floorSegments[y]; FlatBounds candidateBounds = candidate.nBounds; if (subjectBounds.Overlaps(candidateBounds)) { if (candidate.neighbours.Contains(subject)) { continue; } subject.neighbours.Add(candidate); candidate.neighbours.Add(subject); } } } //Grow out partitions to fill the available space List <PartitionGrowth> partitionGs = new List <PartitionGrowth>(); Dictionary <FloorSegment, FloorSegmentClaim> segmentClaims = new Dictionary <FloorSegment, FloorSegmentClaim>(); for (int i = 0; i < partitions.Count; i++) { partitionGs.Add(new PartitionGrowth(partitions[i])); } int it = 1000; while (true) { int growthCount = partitionGs.Count; int completePartitionGrowths = 0; int[] partitionGrowthAmount = new int[growthCount]; segmentClaims.Clear(); for (int g = 0; g < growthCount; g++) { PartitionGrowth partitionG = partitionGs[g]; if (!partitionG.active) { completePartitionGrowths++; continue; } if (availableSegments.Count == 0) { break; } //assign inital segment to begin partition from if (!partitionG.initialised) { float nearestSqrMag = float.PositiveInfinity; FloorSegment candidate = availableSegments[0]; for (int x = 0; x < availableSegments.Count; x++) { FloorSegment subject = availableSegments[x]; float sqrMag = Vector2Int.SqrMagnitudeFloat(partitionG.subject.position, subject.position); if (sqrMag < nearestSqrMag) { candidate = subject; nearestSqrMag = sqrMag; } } partitionG.capturedSegments.Add(candidate); partitionG.processSegments.Add(candidate); availableSegments.Remove(candidate); partitionG.initialised = true; partitionGrowthAmount[g] = 1; continue;//don't start growth until next iteration } //grow partition if (partitionG.initialised) { List <FloorSegment> neighbourCandiates = new List <FloorSegment>(); int processCount = partitionG.processSegments.Count; // float additionalArea = 0; for (int p = 0; p < processCount; p++) { FloorSegment processSegment = partitionG.processSegments[p]; int processNeighbourCount = processSegment.neighbours.Count; for (int n = 0; n < processNeighbourCount; n++) { FloorSegment neighbour = processSegment.neighbours[n]; bool isAvailable = availableSegments.Contains(neighbour); bool notDuplicateNeighbour = !neighbourCandiates.Contains(neighbour); if (isAvailable && notDuplicateNeighbour) { neighbourCandiates.Add(neighbour); float fit = processSegment.BestFit(neighbour); if (fit > Mathf.Epsilon) { FloorSegmentClaim newClaim = new FloorSegmentClaim(); newClaim.partition = partitionG; newClaim.growthIndex = g; newClaim.segment = neighbour; newClaim.priority = partitionG.subject.priority * fit; if (!segmentClaims.ContainsKey(neighbour)) { segmentClaims.Add(neighbour, newClaim); } else { FloorSegmentClaim currentClaim = segmentClaims[neighbour]; if (currentClaim.priority < newClaim.priority) { segmentClaims[neighbour] = newClaim; } } } // additionalArea += neighbour.area; } } } // int neighbourCandiatesCount = neighbourCandiates.Count; // for (int n = 0; n < neighbourCandiatesCount; n++) { // FloorSegment segement = neighbourCandiates[n]; // // if (segmentClaims.ContainsKey(segement)) { // // } // else { // // } // } // if (neighbourCandiatesCount > 0) { // // bool canAddAll = partitionG.AvailableArea(additionalArea); // if (canAddAll) { // partitionG.processSegments.Clear(); // for (int n = 0; n < neighbourCandiatesCount; n++) // availableSegments.Remove(neighbourCandiates[n]); //// partitionG.AddSegments(neighbourCandiates); // } // else { // // TODO partial add (?) //// partitionG.AddSegments(neighbourCandiates); // partitionG.Complete(); // } // } // else { // partitionG.Complete(); // } // if (partitionG.processSegments.Count == 0) // partitionG.Complete(); } } foreach (KeyValuePair <FloorSegment, FloorSegmentClaim> kv in segmentClaims) { //TODO - support instance when new areas to add are too large //TODO - fall back on partial adding of single side FloorSegmentClaim claim = kv.Value; claim.partition.AddSegment(claim.segment); availableSegments.Remove(claim.segment); partitionGrowthAmount[claim.growthIndex]++; } for (int g = 0; g < growthCount; g++) { PartitionGrowth partitionG = partitionGs[g]; if (!partitionG.active) { continue; } // Debug.Log(g+" "+ partitionG.AcceptableAreaUsed()+" " + partitionGrowthAmount[g]+" "+ partitionG.processSegments.Count); if (partitionG.AcceptableAreaUsed() || partitionGrowthAmount[g] == 0 || partitionG.processSegments.Count == 0) { completePartitionGrowths++; partitionG.Complete(); } } if (completePartitionGrowths == growthCount) //all partitions have been completed { break; } if (availableSegments.Count == 0) { foreach (PartitionGrowth part in partitionGs) { if (part.active) { part.Complete(); } } foreach (PartitionGrowth part in partitionGs) { int childCount = part.subject.children.Count; if (childCount > 0) { for (int c = 0; c < childCount; c++) { partitionGs.Add(new PartitionGrowth(part.subject.children[c])); } part.subject.children.Clear(); availableSegments.AddRange(part.capturedSegments); part.capturedSegments.Clear(); break; } } if (availableSegments.Count == 0) { break; } } it--; if (it == 0) { Debug.Log(" MAX reached!"); Debug.Log(availableSegments.Count); foreach (PartitionGrowth pg in partitionGs) { Debug.Log(pg.processSegments.Count); Debug.Log(pg.capturedSegments.Count); pg.Complete(); } break; } } foreach (PartitionGrowth part in partitionGs) { if (part.active) { part.Complete(); } calculatedPartitions.Add(part.subject); } // if (floorplan != null) // { // int roomCount = calculatedPartitions.Count; // // // // // Room floorplanRoom = new Room(); // // // floorplan.rooms.Add(); // } // foreach (Partition part in partitions) { // Debug.Log(part.segments.Count); // } }
public static VerticalOpening[] GetOpenings(Building building, Volume volume) { List <VerticalOpening> output = new List <VerticalOpening>(); int count = building.openingCount; VerticalOpening[] openings = building.GetAllOpenings(); int volumeBaseFloor = building.VolumeBaseFloor(volume); int volumeTopFloor = volumeBaseFloor + volume.floors; for (int i = 0; i < count; i++) { VerticalOpening opening = openings[i]; int openingBaseFloor = opening.baseFloor; int openingTopFloor = openingBaseFloor + opening.floors - 1; if (volumeBaseFloor < openingTopFloor && openingBaseFloor < volumeTopFloor)//opening and volume floors intersect { FlatBounds volumeBounds = new FlatBounds(volume.bounds); Vector2[] openingPoints = opening.PointsRotated(); FlatBounds openingBounds = new FlatBounds(openingPoints); if (volumeBounds.Overlaps(openingBounds, true))// opening is within the AABB bounds of the volume { Vector2[] volumePoints = volume.AllPointsV2(); int volumePointCount = volumePoints.Length; int openingPointCount = openingPoints.Length; bool openingIntersects = false; for (int op = 0; op < openingPointCount; op++) { Vector2 opa = openingPoints[op]; Vector2 opb = openingPoints[(op + 1) % openingPointCount]; for (int vp = 0; vp < volumePointCount; vp++) { Vector2 vpa = volumePoints[vp]; Vector2 vpb = volumePoints[(vp + 1) % volumePointCount]; if (FastLineIntersection(opa, opb, vpa, vpb)) { openingIntersects = true; } if (openingIntersects) { break; } } if (openingIntersects) { break; } } if (!openingIntersects)//check that the opening is within the volume shape { Vector2 opa = openingPoints[0]; Vector2 opb = openingPoints[1]; int intersections = 0;//we should intersect an odd number of times for (int vp = 0; vp < volumePointCount; vp++) { Vector2 vpa = volumePoints[vp]; Vector2 vpb = volumePoints[(vp + 1) % volumePointCount]; if (FastLineIntersection(opa, opb, vpa, vpb)) { intersections++; } } if (intersections % 2 != 0) { output.Add(opening); } } } } } return(output.ToArray()); }