public static void GenerateRoofAccess(BuildRMesh mesh, VerticalOpening opening, Vector3 basePosition, float height, int floor, int wallSubmesh = -1, BuildRCollider collider = null)
{
// bool stepped = true;//todo
float minimumWidth = 0.9f; //UK standard
// float maximumWidth = 2.0f;
// float stepHeight = 0.22f;
float wallThickness = VerticalOpening.WALL_THICKNESS;
float stairWidth = 0.70f; //todo / calculate
float doorWidth = 1.3f;
float doorHeight = 2.04f;
bool generateColldier = collider != null;
float minimumRunLength = 0.25f;
float maximumRiserHeight = 0.2f;
SubmeshLibrary submeshLibrary = mesh.submeshLibrary;
int externalWallSubmesh = submeshLibrary.SubmeshAdd(opening.surfaceA);
int internalWallSubmesh = submeshLibrary.SubmeshAdd(opening.surfaceB);
int doorFrameSubmesh = submeshLibrary.SubmeshAdd(opening.surfaceC);
int internalFloorSubmesh = submeshLibrary.SubmeshAdd(opening.surfaceD);
//base positions
Quaternion rotation = Quaternion.Euler(0, opening.rotation, 0);
Vector2Int openingSize = opening.size;
Vector3 b0 = basePosition + rotation * new Vector3(-opening.size.vx * 0.5f, height, -opening.size.vy * 0.5f);
Vector3 b1 = basePosition + rotation * new Vector3(opening.size.vx * 0.5f, height, -opening.size.vy * 0.5f);
Vector3 b2 = basePosition + rotation * new Vector3(-opening.size.vx * 0.5f, height, opening.size.vy * 0.5f);
Vector3 b3 = basePosition + rotation * new Vector3(opening.size.vx * 0.5f, height, opening.size.vy * 0.5f);
//inner points
Vector3 b0i = b0 + rotation * new Vector3(1, 0, 1) * wallThickness;
Vector3 b1i = b1 + rotation * new Vector3(-1, 0, 1) * wallThickness;
Vector3 b2i = b2 + rotation * new Vector3(1, 0, -1) * wallThickness;
Vector3 b3i = b3 + rotation * new Vector3(-1, 0, -1) * wallThickness;
Vector2 internalSize = new Vector2(openingSize.vx - wallThickness * 2, openingSize.vy - wallThickness * 2);
float stairWidthFromX = internalSize.x * 0.5f;
float stairWidthFromY = internalSize.y - Mathf.Ceil(height / maximumRiserHeight) * minimumRunLength;
float useLandingWidth = (stairWidthFromX + stairWidthFromY) * 0.5f;
useLandingWidth = Mathf.Clamp(useLandingWidth, minimumWidth, opening.stairWidth);
Vector3 escalationFlatDir = (b2i - b0i).normalized;
Vector3 landingDrop = Vector3.down * wallThickness;
//landing
Vector3 l0 = b0i;
Vector3 l1 = b1i;
Vector3 l2 = b0i + escalationFlatDir * useLandingWidth;
Vector3 l3 = b1i + escalationFlatDir * useLandingWidth;
//top
mesh.AddPlane(l0, l1, l2, l3, internalFloorSubmesh);
//bottom
mesh.AddPlane(l1 + landingDrop, l0 + landingDrop, l3 + landingDrop, l2 + landingDrop, internalWallSubmesh);
//front
mesh.AddPlane(l2, l3, l2 + landingDrop, l3 + landingDrop, internalWallSubmesh);
if (generateColldier)
{
collider.mesh.AddPlane(l0, l1, l2, l3, 0);
collider.mesh.AddPlane(l1 + landingDrop, l0 + landingDrop, l3 + landingDrop, l2 + landingDrop, 0);
collider.mesh.AddPlane(l2, l3, l2 + landingDrop, l3 + landingDrop, 0);
}
//internal walls
Vector3 wallUp = Vector3.up * height;
wallUp.y += -wallThickness * 0.5f;
Vector3 wallUpI = Vector3.up * (height - wallThickness);
mesh.AddPlane(b0i, b2i, b0i + wallUpI, b2i + wallUpI, internalWallSubmesh);
mesh.AddPlane(b2i, b3i, b2i + wallUpI, b3i + wallUpI, internalWallSubmesh);
mesh.AddPlane(b3i, b1i, b3i + wallUpI, b1i + wallUpI, internalWallSubmesh);
mesh.AddPlane(b1i + wallUpI, b0i + wallUpI, b3i + wallUpI, b2i + wallUpI, internalWallSubmesh);
//external walls
mesh.AddPlane(b2, b0, b2 + wallUp, b0 + wallUp, externalWallSubmesh);
mesh.AddPlane(b3, b2, b3 + wallUp, b2 + wallUp, externalWallSubmesh);
mesh.AddPlane(b1, b3, b1 + wallUp, b3 + wallUp, externalWallSubmesh);
mesh.AddPlane(b0 + wallUp, b1 + wallUp, b2 + wallUp, b3 + wallUp, internalWallSubmesh);
if (generateColldier)
{
collider.AddPlane(b2, b0, b2 + wallUp, b0 + wallUp);
collider.AddPlane(b3, b2, b3 + wallUp, b2 + wallUp);
collider.AddPlane(b1, b3, b1 + wallUp, b3 + wallUp);
collider.mesh.AddPlane(b1i + wallUpI, b0i + wallUpI, b3i + wallUpI, b2i + wallUpI, 0);
collider.mesh.AddPlane(b0 + wallUp, b1 + wallUp, b2 + wallUp, b3 + wallUp, 0);
if (!collider.usingPrimitives)
{
collider.mesh.AddPlane(b0i, b2i, b0i + wallUpI, b2i + wallUpI, 0);
collider.mesh.AddPlane(b2i, b3i, b2i + wallUpI, b3i + wallUpI, 0);
collider.mesh.AddPlane(b3i, b1i, b3i + wallUpI, b1i + wallUpI, 0);
}
}
//door wall
//internal
float internalWallLength = openingSize.vx - (wallThickness * 2f);
float lerpA = Mathf.Max(stairWidth - doorWidth, 0.05f) / internalWallLength;
float lerpB = (Mathf.Max(stairWidth - doorWidth, 0.05f) + doorWidth) / internalWallLength;
Vector3 bd0i = Vector3.Lerp(b0i, b1i, lerpA);
Vector3 bd1i = Vector3.Lerp(b0i, b1i, lerpB);
Vector3 doorUp = Vector3.up * doorHeight;
//Right side
mesh.AddPlane(bd0i, b0i, bd0i + doorUp, b0i + doorUp, internalWallSubmesh);
//left side
mesh.AddPlane(b1i, bd1i, b1i + doorUp, bd1i + doorUp, internalWallSubmesh);
//top
mesh.AddPlane(b1i + doorUp, b0i + doorUp, b1i + wallUpI, b0i + wallUpI, internalWallSubmesh);
//external
Vector3 doorOut = -escalationFlatDir * wallThickness;
//left
mesh.AddPlane(b0, bd0i + doorOut, b0 + doorUp, bd0i + doorOut + doorUp, externalWallSubmesh);
//right
mesh.AddPlane(bd1i + doorOut, b1, bd1i + doorOut + doorUp, b1 + doorUp, externalWallSubmesh);
//top
mesh.AddPlane(b0 + doorUp, b1 + doorUp, b0 + wallUp, b1 + wallUp, externalWallSubmesh);
//frame
//floor
mesh.AddPlane(bd1i, bd0i, bd1i + doorOut, bd0i + doorOut, externalWallSubmesh);
//left
mesh.AddPlane(bd0i + doorOut, bd0i, bd0i + doorOut + doorUp, bd0i + doorUp, doorFrameSubmesh);
//right
mesh.AddPlane(bd1i, bd1i + doorOut, bd1i + doorUp, bd1i + doorOut + doorUp, doorFrameSubmesh);
//top
mesh.AddPlane(bd0i + doorUp, bd1i + doorUp, bd0i + doorOut + doorUp, bd1i + doorOut + doorUp, doorFrameSubmesh);
if (generateColldier)
{
collider.AddPlane(b0, bd0i + doorOut, b0 + doorUp, bd0i + doorOut + doorUp);
collider.AddPlane(bd1i + doorOut, b1, bd1i + doorOut + doorUp, b1 + doorUp);
collider.AddPlane(b0 + doorUp, b1 + doorUp, b0 + wallUp, b1 + wallUp);
if (!collider.usingPrimitives)
{
collider.mesh.AddPlane(bd0i, b0i, bd0i + doorUp, b0i + doorUp, 0);
collider.mesh.AddPlane(b1i, bd1i, b1i + doorUp, bd1i + doorUp, 0);
collider.mesh.AddPlane(b1i + doorUp, b0i + doorUp, b1i + wallUpI, b0i + wallUpI, 0);
collider.mesh.AddPlane(bd1i, bd0i, bd1i + doorOut, bd0i + doorOut, 0);
collider.mesh.AddPlane(bd0i + doorOut, bd0i, bd0i + doorOut + doorUp, bd0i + doorUp, 0);
collider.mesh.AddPlane(bd1i, bd1i + doorOut, bd1i + doorUp, bd1i + doorOut + doorUp, 0);
collider.mesh.AddPlane(bd0i + doorUp, bd1i + doorUp, bd0i + doorOut + doorUp, bd1i + doorOut + doorUp, 0);
}
}
}
public static void Generate(IBuilding building)
{
int numberOfVolumes = building.numberOfVolumes;
// Debug.Log("n vol "+numberOfVolumes);
for (int v = 0; v < numberOfVolumes; v++)
{
IVolume volume = building[v];
volume.CheckVolume();
if (!volume.isLegal)
{
GenerateMesh.ClearVisuals(volume);
continue;
}
int numberOfPoints = volume.numberOfPoints;
float totalPlanHeight = volume.planHeight;
Vector3 planUp = totalPlanHeight * Vector3.up;
VerticalOpening[] volumeOpenings = BuildrUtils.GetOpeningsQuick(building, volume);
float foundation = building.IsBaseVolume(volume) ? building.foundationDepth : 0;//set suspended volumes foundation to 0
IVisualPart visual = volume.visualPart;
BuildRMesh dMesh = visual.dynamicMesh;
BuildRCollider cMesh = visual.colliderMesh;
BuildingMeshTypes meshType = building.meshType;
BuildingColliderTypes colliderType = building.colliderType;
dMesh.Clear();
cMesh.Clear();
cMesh.TogglePrimitives(colliderType == BuildingColliderTypes.Primitive);
cMesh.thickness = volume.wallThickness;
if (colliderType == BuildingColliderTypes.None)
{
cMesh = null;
}
Transform[] prefabs = volume.prefabs.GetComponentsInChildren <Transform>();
int prefabCount = prefabs.Length;
for (int p = 0; p < prefabCount; p++)
{
if (prefabs[p] == volume.prefabs)
{
continue;
}
if (prefabs[p] == null)
{
continue; //gone already man
}
#if UNITY_EDITOR
Object.DestroyImmediate(prefabs[p].gameObject);
#else
Object.Destroy(prefabs[p].gameObject);
#endif
}
Dictionary <int, List <Vector2Int> > anchorPoints = volume.facadeWallAnchors;
Texture2D facadeTexture = null;
#region Exteriors
// Debug.Log("ext");
if (building.generateExteriors)
{
for (int p = 0; p < numberOfPoints; p++)
{
if (!volume[p].render)
{
continue;
}
Vector3 p0 = volume.BuildingPoint(p);
Vector3 p1 = volume.BuildingPoint((p + 1) % numberOfPoints);
Vector3 p0u = p0 + planUp;
Vector3 p1u = p1 + planUp;
Vector3 cw0 = volume.BuildingControlPointA(p);
Vector3 cw1 = volume.BuildingControlPointB(p);
Facade facade = volume.GetFacade(p);
bool isStraight = volume.IsWallStraight(p);
Vector3 facadeVector = p1 - p0;
Vector3 facadeDirection = facadeVector.normalized;
float facadeLength = facadeVector.magnitude;
if (facadeLength < Mathf.Epsilon)
{
continue;
}
// Debug.Log("flength "+facadeLength);
if (facade == null || colliderType == BuildingColliderTypes.Simple)
{
// Debug.Log("simple");
if (isStraight)
{
Vector3 normal = Vector3.Cross(Vector3.up, facadeDirection);
Vector4 tangent = BuildRMesh.CalculateTangent(facadeDirection);
if (facade == null)
{
dMesh.AddPlane(p0, p1, p0u, p1u, normal, tangent, 0);
}
if (colliderType != BuildingColliderTypes.None)
{
cMesh.AddPlane(p0, p1, p0u, p1u);
}
if (foundation > Mathf.Epsilon)
{
Vector3 fp2 = p0;
Vector3 fp3 = p1;
Vector3 fp0 = fp2 + Vector3.down * foundation;
Vector3 fp1 = fp3 + Vector3.down * foundation;
if (facade == null)
{
Surface foundationSurface = building.foundationSurface != null ? building.foundationSurface : null;
int foundationSubmesh = dMesh.submeshLibrary.SubmeshAdd(foundationSurface);
Vector2 uxmax = new Vector2(Vector3.Distance(p0, p1), foundation);
dMesh.AddPlane(fp0, fp1, fp2, fp3, Vector2.zero, uxmax, normal, tangent, foundationSubmesh, foundationSurface);
}
if (colliderType != BuildingColliderTypes.None)
{
cMesh.mesh.AddPlane(fp0, fp1, fp2, fp3, 0);
}
}
}
else
{
List <Vector2Int> facadeAnchorPoints = anchorPoints[p];
int anchorCount = facadeAnchorPoints.Count;
for (int i = 0; i < anchorCount - 1; i++)
{
Vector3 c0 = facadeAnchorPoints[i].vector3XZ;
c0.y = p0.y;
Vector3 c1 = facadeAnchorPoints[i + 1].vector3XZ;
c1.y = p0.y;
Vector3 c2 = c0 + planUp;
Vector3 c3 = c1 + planUp;
Vector3 sectionDirection = (c1 - c0).normalized;
Vector3 normal = Vector3.Cross(Vector3.up, sectionDirection);
Vector4 tangent = BuildRMesh.CalculateTangent(sectionDirection);
if (facade == null)
{
dMesh.AddPlane(c0, c1, c2, c3, normal, tangent, 0);
}
if (colliderType != BuildingColliderTypes.None)
{
cMesh.AddPlane(c0, c1, c2, c3);
}
if (foundation > Mathf.Epsilon)
{
Vector3 fp2 = c0;
Vector3 fp3 = c1;
Vector3 fp0 = fp2 + Vector3.down * foundation;
Vector3 fp1 = fp3 + Vector3.down * foundation;
if (facade == null)
{
Surface foundationSurface = building.foundationSurface != null ? building.foundationSurface : null;
int foundationSubmesh = dMesh.submeshLibrary.SubmeshAdd(foundationSurface);
Vector2 uxmax = new Vector2(Vector3.Distance(c0, c1), foundation);
dMesh.AddPlane(fp0, fp1, fp2, fp3, Vector2.zero, uxmax, normal, tangent, foundationSubmesh, foundationSurface);
}
if (colliderType != BuildingColliderTypes.None)
{
cMesh.AddPlane(fp0, fp1, fp2, fp3);
}
}
}
}
// Debug.Log("Generate facade " + p + " " + dMesh.vertexCount );
}
// Debug.Log("fac "+p);
if (facade != null && (meshType == BuildingMeshTypes.Full || colliderType == BuildingColliderTypes.Primitive || colliderType == BuildingColliderTypes.Complex))
{
//generate the facade
// Debug.Log("full");
FacadeGenerator.FacadeData fData = new FacadeGenerator.FacadeData();
// fData.building = building;
// fData.volume = volume;
fData.baseA = p0;
fData.baseB = p1;
fData.controlA = cw0;
fData.controlB = cw1;
fData.anchors = anchorPoints[p];
fData.isStraight = isStraight;
fData.curveStyle = volume[p].curveStyle;
fData.floorCount = volume.floors;
fData.facadeDesign = facade;
// fData.submeshList = usedFloorplanSurfaces;
fData.startFloor = BuildRFacadeUtil.MinimumFloor(building, volume, p);
fData.actualStartFloor = building.VolumeBaseFloor(volume);
fData.foundationDepth = foundation;
fData.foundationSurface = building.foundationSurface;
fData.wallThickness = volume.wallThickness;
fData.minimumWallUnitLength = volume.minimumWallUnitLength;
fData.floorHeight = volume.floorHeight;
fData.floors = volume.floors;
fData.meshType = building.meshType;
fData.colliderType = building.colliderType;
fData.cullDoors = building.cullDoors;
fData.prefabs = volume.prefabs;
// Debug.Log("mesh");
FacadeGenerator.GenerateFacade(fData, dMesh, cMesh);
// Debug.Log("pref");
FacadeGenerator.GeneratePrefabs(fData);
// Debug.Log("Generate facade "+p+" "+dMesh.vertexCount);
}
}
}
#endregion
#region Interiors
// Debug.Log("int");
bool generateInteriors = building.generateInteriors && meshType == BuildingMeshTypes.Full;
if (generateInteriors)
{
int floors = volume.floors;
IFloorplan[] floorplans = volume.InteriorFloorplans();
for (int fl = 0; fl < floors; fl++)
{
IFloorplan floorplan = floorplans[fl];
IVisualPart floorVisual = floorplan.visualPart;
BuildRMesh flMesh = floorVisual.dynamicMesh;
BuildRCollider flCollider = floorVisual.colliderMesh;
flMesh.Clear();
flCollider.Clear();
flCollider.TogglePrimitives(colliderType == BuildingColliderTypes.Primitive);
FloorplanGenerator.Generate(building, volume, floorplans[fl], fl, volumeOpenings, flMesh, flCollider);
floorVisual.GenerateFromDynamicMesh();
floorplan.transform.localPosition = Vector3.up * (fl * volume.floorHeight);
floorVisual.transform.localPosition = Vector3.zero;//
floorVisual.transform.localRotation = Quaternion.identity;
}
}
else
{
IFloorplan[] floorplans = volume.InteriorFloorplans();
int floors = floorplans.Length;
for (int fl = 0; fl < floors; fl++)
{
floorplans[fl].visualPart.Clear();
}
}
#endregion
#region Volume Underside Generation
// Debug.Log("und");
BuildRVolumeUtil.VolumeShape[] underShapes = BuildRVolumeUtil.GetBottomShape(building, volume);
int underShapeCount = underShapes.Length;
float volumeBaseHeight = volume.baseHeight - building.foundationDepth;
for (int u = 0; u < underShapeCount; u++)
{
if (underShapes[u].outer == null)
{
continue; //no underside shape
}
int undersideSubmesh = dMesh.submeshLibrary.SubmeshAdd(volume.undersideSurafce);
Poly2TriWrapper.BMesh(dMesh, volumeBaseHeight, null, undersideSubmesh, underShapes[u].outer, new Rect(0, 0, 0, 0), false, underShapes[u].holes);
}
#endregion
// Debug.Log("roof");
if (building.generateExteriors)
{
RoofGenerator.Generate(building, volume, dMesh, cMesh);
visual.GenerateFromDynamicMesh();
}
else
{
visual.Clear();
}
// Debug.Log("mat");
switch (meshType)
{
case BuildingMeshTypes.None:
visual.materials = null;
break;
case BuildingMeshTypes.Box:
visual.materials = new[] { new Material(Shader.Find("Standard")) };
break;
case BuildingMeshTypes.Simple:
facadeTexture.filterMode = FilterMode.Bilinear;
facadeTexture.Apply(true, false);
Material simpleMaterial = new Material(Shader.Find("Standard"));
simpleMaterial.mainTexture = facadeTexture;
visual.materials = new[] { simpleMaterial };
break;
case BuildingMeshTypes.Full:
visual.materials = dMesh.materials.ToArray();
break;
}
}
}
public static void GenerateWall(BuildRMesh mesh, VerticalOpening opening, Vector3 basePosition, float height, int wallSubmesh = -1, BuildRCollider collider = null)
{
float stairWidth = 0.70f; //todo / calculate
float wallThickness = VerticalOpening.WALL_THICKNESS;
float doorWidth = 1.3f;
float doorHeight = 2.04f;
bool generateColldier = collider != null;
// bool generateMeshCollider = generateColldier && !collider.usingPrimitives;
SubmeshLibrary submeshLibrary = mesh.submeshLibrary;
int externalWallSubmesh = submeshLibrary.SubmeshAdd(opening.surfaceA);
int internalWallSubmesh = submeshLibrary.SubmeshAdd(opening.surfaceB);
int doorFrameSubmesh = submeshLibrary.SubmeshAdd(opening.surfaceC);
//base positions
Quaternion rotation = Quaternion.Euler(0, opening.rotation, 0);
Vector2Int openingSize = opening.size;
Vector3 b0 = basePosition + rotation * new Vector3(-opening.size.vx * 0.5f, 0, -opening.size.vy * 0.5f);
Vector3 b1 = basePosition + rotation * new Vector3(opening.size.vx * 0.5f, 0, -opening.size.vy * 0.5f);
Vector3 b2 = basePosition + rotation * new Vector3(-opening.size.vx * 0.5f, 0, opening.size.vy * 0.5f);
Vector3 b3 = basePosition + rotation * new Vector3(opening.size.vx * 0.5f, 0, opening.size.vy * 0.5f);
//inner points
Vector3 b0i = b0 + rotation * new Vector3(1, 0, 1) * wallThickness;
Vector3 b1i = b1 + rotation * new Vector3(-1, 0, 1) * wallThickness;
Vector3 b2i = b2 + rotation * new Vector3(1, 0, -1) * wallThickness;
Vector3 b3i = b3 + rotation * new Vector3(-1, 0, -1) * wallThickness;
Vector3 escalationFlatDir = (b2i - b0i).normalized;
Vector3 wallUp = Vector3.up * height;
//external walls
Vector2 uv20_min = new Vector2(0, 0);
Vector2 uv20_max = new Vector2(opening.size.vy, height);
Vector3 normal02 = rotation * Vector3.left;
Vector4 tangent02 = BuildRMesh.CalculateTangent((b0 - b2).normalized);
mesh.AddPlane(b2, b0, b2 + wallUp, b0 + wallUp, uv20_min, uv20_max, normal02, tangent02, externalWallSubmesh, opening.surfaceA);
Vector2 uv32_min = new Vector2(0, 0);
Vector2 uv32_max = new Vector2(opening.size.vx, height);
Vector3 normal32 = rotation * Vector3.forward;
Vector4 tangent32 = BuildRMesh.CalculateTangent((b2 - b3).normalized);
mesh.AddPlane(b3, b2, b3 + wallUp, b2 + wallUp, uv32_min, uv32_max, normal32, tangent32, externalWallSubmesh, opening.surfaceA);
Vector2 uv13_min = new Vector2(0, 0);
Vector2 uv13_max = new Vector2(opening.size.vy, height);
Vector3 normal13 = rotation * Vector3.right;
Vector4 tangent13 = BuildRMesh.CalculateTangent((b3 - b1).normalized);
mesh.AddPlane(b1, b3, b1 + wallUp, b3 + wallUp, uv13_min, uv13_max, normal13, tangent13, externalWallSubmesh, opening.surfaceA);
//internal walls
Vector2 uv20i_min = new Vector2(wallThickness, 0);
Vector2 uv20i_max = new Vector2(opening.size.vy - wallThickness, height);
Vector3 normal02i = rotation * Vector3.right;
Vector4 tangent02i = BuildRMesh.CalculateTangent((b2 - b0).normalized);
mesh.AddPlane(b0i, b2i, b0i + wallUp, b2i + wallUp, uv20i_min, uv20i_max, normal02i, tangent02i, internalWallSubmesh, opening.surfaceB);
Vector2 uv32i_min = new Vector2(0, 0);
Vector2 uv32i_max = new Vector2(opening.size.vx - wallThickness, height);
Vector3 normal32i = rotation * Vector3.back;
Vector4 tangent32i = BuildRMesh.CalculateTangent((b3 - b2).normalized);
mesh.AddPlane(b2i, b3i, b2i + wallUp, b3i + wallUp, uv32i_min, uv32i_max, normal32i, tangent32i, internalWallSubmesh, opening.surfaceB);
Vector2 uv13i_min = new Vector2(0, 0);
Vector2 uv13i_max = new Vector2(opening.size.vy - wallThickness, height);
Vector3 normal13i = rotation * Vector3.left;
Vector4 tangent13i = BuildRMesh.CalculateTangent((b1 - b3).normalized);
mesh.AddPlane(b3i, b1i, b3i + wallUp, b1i + wallUp, uv13i_min, uv13i_max, normal13i, tangent13i, internalWallSubmesh, opening.surfaceB);
if (generateColldier)
{
collider.AddPlane(b2, b0, b2 + wallUp, b0 + wallUp);
collider.AddPlane(b3, b2, b3 + wallUp, b2 + wallUp);
collider.AddPlane(b1, b3, b1 + wallUp, b3 + wallUp);
if (!collider.usingPrimitives)
{
collider.mesh.AddPlane(b0i, b2i, b0i + wallUp, b2i + wallUp, 0);
collider.mesh.AddPlane(b2i, b3i, b2i + wallUp, b3i + wallUp, 0);
collider.mesh.AddPlane(b3i, b1i, b3i + wallUp, b1i + wallUp, 0);
}
}
//door wall
float internalWallLength = openingSize.vx - (wallThickness * 2f);
float lerpA = Mathf.Max(stairWidth - doorWidth, 0.05f) / internalWallLength;
float lerpB = (Mathf.Max(stairWidth - doorWidth, 0.05f) + doorWidth) / internalWallLength;
Vector2 uvd_b0 = new Vector2(0, 0);
Vector2 uvd_b1 = new Vector2(opening.size.vx * lerpA, 0);
Vector2 uvd_b2 = new Vector2(opening.size.vx * lerpB, 0);
Vector2 uvd_b3 = new Vector2(opening.size.vx, 0);
Vector2 uvd_m0 = new Vector2(uvd_b0.x, doorHeight);
Vector2 uvd_m1 = new Vector2(uvd_b1.x, doorHeight);
Vector2 uvd_m3 = new Vector2(uvd_b3.x, doorHeight);
Vector2 uvd_t0 = new Vector2(0, height);
Vector2 uvd_t3 = new Vector2(opening.size.vx, height);
//internal
Vector3 bd0i = Vector3.Lerp(b0i, b1i, lerpA);
Vector3 bd1i = Vector3.Lerp(b0i, b1i, lerpB);
Vector3 normal01i = rotation * Vector3.forward;
Vector4 tangent01i = BuildRMesh.CalculateTangent((b0 - b1).normalized);
Vector3 doorUp = Vector3.up * doorHeight;
//Right side
mesh.AddPlane(bd0i, b0i, bd0i + doorUp, b0i + doorUp, uvd_b0, uvd_m1, normal01i, tangent01i, internalWallSubmesh, opening.surfaceB);
//left side
mesh.AddPlane(b1i, bd1i, b1i + doorUp, bd1i + doorUp, uvd_b2, uvd_m3, normal01i, tangent01i, internalWallSubmesh, opening.surfaceB);
//top
mesh.AddPlane(b1i + doorUp, b0i + doorUp, b1i + wallUp, b0i + wallUp, uvd_m3, uvd_t0, normal01i, tangent01i, internalWallSubmesh, opening.surfaceB);
//external
Vector3 doorOut = -escalationFlatDir * wallThickness;
Vector3 normal01 = rotation * Vector3.back;
Vector4 tangent01 = BuildRMesh.CalculateTangent((b1 - b0).normalized);
//left
mesh.AddPlane(b0, bd0i + doorOut, b0 + doorUp, bd0i + doorOut + doorUp, uvd_b0, uvd_m1, normal01, tangent01, externalWallSubmesh, opening.surfaceA);
//right
mesh.AddPlane(bd1i + doorOut, b1, bd1i + doorOut + doorUp, b1 + doorUp, uvd_b2, uvd_m3, normal01, tangent01, externalWallSubmesh, opening.surfaceA);
//top
mesh.AddPlane(b0 + doorUp, b1 + doorUp, b0 + wallUp, b1 + wallUp, uvd_m0, uvd_t3, normal01, tangent01, externalWallSubmesh, opening.surfaceA);
//frame
//floor
mesh.AddPlane(bd1i, bd0i, bd1i + doorOut, bd0i + doorOut, externalWallSubmesh);
//left
mesh.AddPlane(bd0i + doorOut, bd0i, bd0i + doorOut + doorUp, bd0i + doorUp, doorFrameSubmesh);
//right
mesh.AddPlane(bd1i, bd1i + doorOut, bd1i + doorUp, bd1i + doorOut + doorUp, doorFrameSubmesh);
//top
mesh.AddPlane(bd0i + doorUp, bd1i + doorUp, bd0i + doorOut + doorUp, bd1i + doorOut + doorUp, doorFrameSubmesh);
if (generateColldier)
{
collider.AddPlane(b0, bd0i + doorOut, b0 + doorUp, bd0i + doorOut + doorUp);
collider.AddPlane(bd1i + doorOut, b1, bd1i + doorOut + doorUp, b1 + doorUp);
collider.AddPlane(b0 + doorUp, b1 + doorUp, b0 + wallUp, b1 + wallUp);
if (!collider.usingPrimitives)
{
collider.mesh.AddPlane(bd0i, b0i, bd0i + doorUp, b0i + doorUp, 0);
collider.mesh.AddPlane(b1i, bd1i, b1i + doorUp, bd1i + doorUp, 0);
collider.mesh.AddPlane(b1i + doorUp, b0i + doorUp, b1i + wallUp, b0i + wallUp, 0);
collider.mesh.AddPlane(bd1i, bd0i, bd1i + doorOut, bd0i + doorOut, 0);
collider.mesh.AddPlane(bd0i + doorOut, bd0i, bd0i + doorOut + doorUp, bd0i + doorUp, 0);
collider.mesh.AddPlane(bd1i, bd1i + doorOut, bd1i + doorUp, bd1i + doorOut + doorUp, 0);
collider.mesh.AddPlane(bd0i + doorUp, bd1i + doorUp, bd0i + doorOut + doorUp, bd1i + doorOut + doorUp, 0);
}
}
}
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 static void Generate(IBuilding building)
{
int numberOfVolumes = building.numberOfPlans;
for (int v = 0; v < numberOfVolumes; v++)
{
IVolume volume = building[v];
volume.CheckVolume();
if (!volume.isLegal)
{
GenerateMesh.ClearVisuals(volume);
continue;
}
int numberOfPoints = volume.numberOfPoints;
float totalPlanHeight = volume.planHeight;
Vector3 planUp = totalPlanHeight * Vector3.up;
// List<Surface> usedFloorplanSurfaces = volume.CalculateSurfaceArray();
// VerticalOpening[] volumeOpenings = BuildrUtils.GetOpeningsQuick(building, volume);
IVisualPart visual = volume.visualPart;
BuildRMesh dMesh = visual.dynamicMesh;
BuildRCollider cMesh = visual.colliderMesh;
BuildingMeshTypes meshType = building.meshType;
BuildingColliderTypes colliderType = building.colliderType;
dMesh.Clear();
dMesh.ignoreSubmeshAssignment = true;
cMesh.Clear();
cMesh.TogglePrimitives(colliderType == BuildingColliderTypes.Primitive);
cMesh.thickness = volume.wallThickness;
if (meshType == BuildingMeshTypes.None && colliderType == BuildingColliderTypes.None)
{
visual.Clear();
return;
}
Dictionary <int, List <Vector2Int> > anchorPoints = volume.facadeWallAnchors;
Texture2D facadeTexture = null;
Rect[] faciaRectangles = null;
Rect[] faciaUVs = null;
Rect roofRect = new Rect();
Rect roofPixelRect = new Rect();
#region Exteriors
if (building.generateExteriors)
{
// List<Rect> faciaRectangles = null;
faciaRectangles = new Rect[numberOfPoints + 1]; //one additional for the roof
float foundation = building.IsBaseVolume(volume) ? building.foundationDepth : 0; //set suspended volumes foundation to 0
// faciaRectangles = new List<Rect>();
for (int p = 0; p < numberOfPoints; p++)
{
if (!volume[p].render)
{
continue;
}
int indexA = p;
int indexB = (p < numberOfPoints - 1) ? p + 1 : 0;
Vector2Int p0 = volume[indexA].position;
Vector2Int p1 = volume[indexB].position;
float facadeWidth = Vector2Int.DistanceWorld(p0, p1) * PIXELS_PER_METER;
int floorBase = BuildRFacadeUtil.MinimumFloor(building, volume, indexA);
int numberOfFloors = volume.floors - floorBase;
if (numberOfFloors < 1)//no facade - adjacent facade is taller and covers this one
{
continue;
}
float floorHeight = volume.floorHeight;
float facadeHeight = ((volume.floors - floorBase) * floorHeight) * PIXELS_PER_METER;
if (facadeHeight < 0)//??
{
facadeWidth = 0;
facadeHeight = 0;
}
Rect newFacadeRect = new Rect(0, 0, facadeWidth, facadeHeight);
faciaRectangles[p] = newFacadeRect;
// Debug.Log(newFacadeRect);
// faciaRectangles.Add(newFacadeRect);
}
roofRect = new Rect(0, 0, volume.bounds.size.x, volume.bounds.size.z);
roofPixelRect = new Rect(0, 0, volume.bounds.size.x * PIXELS_PER_METER, volume.bounds.size.z * PIXELS_PER_METER);
faciaRectangles[numberOfPoints] = roofPixelRect;
// Debug.Log(roofRect);
int currentWidth = RectanglePack.Pack(faciaRectangles, ATLAS_PADDING);
currentWidth = RectanglePack.CheckMaxScale(faciaRectangles, currentWidth, MAXIMUM_TEXTURESIZE);
faciaUVs = RectanglePack.ConvertToUVSpace(faciaRectangles, currentWidth);
facadeTexture = new Texture2D(currentWidth, currentWidth);
// float uvOffsetX = 0;
int rectIndex = 0;
for (int p = 0; p < numberOfPoints; p++)
{
if (!volume[p].render)
{
continue;
}
Vector3 p0 = volume.BuildingPoint(p);
Vector3 p1 = volume.BuildingPoint((p + 1) % numberOfPoints);
Vector3 p0u = p0 + planUp;
Vector3 p1u = p1 + planUp;
Vector3 cw0 = volume.BuildingControlPointA(p);
Vector3 cw1 = volume.BuildingControlPointB(p);
Facade facade = volume.GetFacade(p);
bool isStraight = volume.IsWallStraight(p);
Vector3 facadeVector = p1 - p0;
Vector3 facadeDirection = facadeVector.normalized;
FacadeGenerator.FacadeData fData = new FacadeGenerator.FacadeData();
fData.baseA = p0;
fData.baseB = p1;
fData.controlA = cw0;
fData.controlB = cw1;
fData.anchors = anchorPoints[p];
fData.isStraight = isStraight;
fData.curveStyle = volume[p].curveStyle;
fData.floorCount = volume.floors;
fData.facadeDesign = facade;
fData.wallThickness = volume.wallThickness;
fData.minimumWallUnitLength = volume.minimumWallUnitLength;
fData.floorHeight = volume.floorHeight;
fData.floors = volume.floors;
fData.meshType = building.meshType;
fData.colliderType = building.colliderType;
fData.cullDoors = building.cullDoors;
fData.prefabs = volume.prefabs;
// fData.submeshList = usedFloorplanSurfaces;
fData.startFloor = BuildRFacadeUtil.MinimumFloor(building, volume, p);
if (isStraight)
{
Vector3 normal = Vector3.Cross(Vector3.up, facadeDirection);
Vector4 tangent = BuildRMesh.CalculateTangent(facadeDirection);
Vector3 fp2 = p0;
Vector3 fp3 = p1;
Vector3 fp0 = fp2 + Vector3.down * foundation;
Vector3 fp1 = fp3 + Vector3.down * foundation;
if (meshType == BuildingMeshTypes.Simple)
{
// if(facade != null)
// {
if (facade != null)
{
SimpleTextureGenerator.GenerateFacade(fData, facadeTexture, faciaRectangles[rectIndex]);
}
Vector3[] verts = { p0, p1, p0u, p1u };
Vector2[] uvs = new Vector2[4];
Rect uvRect = faciaUVs[rectIndex];
uvs[0] = new Vector2(uvRect.xMin, uvRect.yMin);
uvs[1] = new Vector2(uvRect.xMax, uvRect.yMin);
uvs[2] = new Vector2(uvRect.xMin, uvRect.yMax);
uvs[3] = new Vector2(uvRect.xMax, uvRect.yMax);
int[] tris = { 0, 2, 1, 1, 2, 3 };
Vector3[] norms = { normal, normal, normal, normal };
Vector4[] tangents = { tangent, tangent, tangent, tangent };
dMesh.AddData(verts, uvs, tris, norms, tangents, 0);
if (foundation > Mathf.Epsilon)
{
dMesh.AddPlane(fp0, fp1, fp2, fp3, uvs[0], uvs[0], normal, tangent, 0, null);
}
}
else
{
dMesh.AddPlane(p0, p1, p0u, p1u, normal, tangent, 0);
if (foundation > Mathf.Epsilon)
{
dMesh.AddPlane(fp0, fp1, fp2, fp3, normal, tangent, 0);
}
}
if (colliderType != BuildingColliderTypes.None)
{
cMesh.AddPlane(p0, p1, p0u, p1u);
if (foundation > Mathf.Epsilon)
{
cMesh.mesh.AddPlane(fp0, fp1, fp2, fp3, 0);
}
}
}
else
{
List <Vector2Int> facadeAnchorPoints = anchorPoints[p];
int anchorCount = facadeAnchorPoints.Count;
for (int i = 0; i < anchorCount - 1; i++)
{
Vector3 c0 = facadeAnchorPoints[i].vector3XZ;
c0.y = p0.y;
Vector3 c1 = facadeAnchorPoints[i + 1].vector3XZ;
c1.y = p0.y;
Vector3 c2 = c0 + planUp;
Vector3 c3 = c1 + planUp;
Vector3 sectionDirection = (c1 - c0).normalized;
Vector3 normal = Vector3.Cross(Vector3.up, sectionDirection);
Vector4 tangent = BuildRMesh.CalculateTangent(sectionDirection);
Vector3 fp2 = c0;
Vector3 fp3 = c1;
Vector3 fp0 = fp2 + Vector3.down * foundation;
Vector3 fp1 = fp3 + Vector3.down * foundation;
if (meshType == BuildingMeshTypes.Simple)
{
if (facade != null)
{
SimpleTextureGenerator.GenerateFacade(fData, facadeTexture, faciaRectangles[rectIndex]);
}
Rect uvRect = faciaUVs[rectIndex];
float facadePercentA = i / (float)(anchorCount - 1);
float facadePercentB = (i + 1) / (float)(anchorCount - 1);
float uvxa = uvRect.xMin + uvRect.width * facadePercentA;
float uvxb = uvRect.xMin + uvRect.width * facadePercentB;
Vector3[] verts = { c0, c1, c2, c3 };
Vector2[] uvs = new Vector2[4];
uvs[0] = new Vector2(uvxa, uvRect.yMin);
uvs[1] = new Vector2(uvxb, uvRect.yMin);
uvs[2] = new Vector2(uvxa, uvRect.yMax);
uvs[3] = new Vector2(uvxb, uvRect.yMax);
int[] tris = { 0, 2, 1, 1, 2, 3 };
Vector3[] norms = { normal, normal, normal, normal };
Vector4[] tangents = { tangent, tangent, tangent, tangent };
// Vector2 uvMin = new Vector2(uvOffsetX, 0);
// Vector2 uvMax = new Vector2(uvOffsetX + facadeLength, totalPlanHeight);
dMesh.AddData(verts, uvs, tris, norms, tangents, 0);
// dMesh.AddPlane(p0, p1, p0u, p1u, uvMin, uvMax, normal, tangent, 0);
//todo simple mesh with textured facade
// rectIndex++;
if (foundation > Mathf.Epsilon)
{
dMesh.AddPlane(fp0, fp1, fp2, fp3, uvs[0], uvs[0], normal, tangent, 0, null);
}
}
else
{
dMesh.AddPlane(p0, p1, p0u, p1u, normal, tangent, 0);
if (foundation > Mathf.Epsilon)
{
dMesh.AddPlane(fp0, fp1, fp2, fp3, normal, tangent, 0);
}
}
if (colliderType != BuildingColliderTypes.None)
{
cMesh.AddPlane(c0, c1, c2, c3);
if (foundation > Mathf.Epsilon)
{
cMesh.mesh.AddPlane(fp0, fp1, fp2, fp3, 0);
}
}
}
}
rectIndex++;
}
}
#endregion
#region Interiors
IFloorplan[] floorplans = volume.InteriorFloorplans();
int floors = volume.floors;
for (int fl = 0; fl < floors; fl++)
{
floorplans[fl].visualPart.Clear();
}
#endregion
#region Volume Underside Generation
BuildRVolumeUtil.VolumeShape[] underShapes = BuildRVolumeUtil.GetBottomShape(building, volume);
int underShapeCount = underShapes.Length;
// Debug.Log(underShapeCount);
float volumeBaseHeight = volume.baseHeight;
for (int u = 0; u < underShapeCount; u++)
{
// Debug.Log(underShapes[u].outer);
if (underShapes[u].outer == null)
{
continue; //no underside shape
}
// Debug.Log(underShapes[u].outer.Length);
Poly2TriWrapper.BMesh(dMesh, volumeBaseHeight, null, 0, underShapes[u].outer, new Rect(0, 0, 0, 0), false, underShapes[u].holes);
}
#endregion
if (building.generateExteriors)
{
Surface roofSurface = volume.roof.mainSurface;
if (roofSurface != null)
{
SimpleTextureGenerator.GenerateTexture(facadeTexture, roofSurface, faciaRectangles[faciaRectangles.Length - 1], roofRect);
}
RoofGenerator.Generate(building, volume, dMesh, cMesh, faciaUVs[faciaUVs.Length - 1]);
visual.GenerateFromDynamicMesh();
}
else
{
visual.Clear();
}
switch (meshType)
{
case BuildingMeshTypes.Box:
visual.materials = new[] { new Material(Shader.Find("Standard")) };
break;
case BuildingMeshTypes.Simple:
facadeTexture.filterMode = FilterMode.Bilinear;
facadeTexture.Apply(true, false);
Material simpleMaterial = new Material(Shader.Find("Standard"));
simpleMaterial.mainTexture = facadeTexture;
visual.materials = new[] { simpleMaterial };
break;
}
}
}
public static void Generate(IBuilding building, IVolume volume, BuildRMesh mesh, BuildRCollider collider, Rect clampUV)
{
int numberOfPoints = volume.numberOfPoints;
float totalPlanHeight = volume.planTotalHeight;
Roof roof = volume.roof;
bool generateColliders = building.colliderType != BuildingColliderTypes.None;
if (!roof.exists)
{
return;
}
List <Vector2> roofPoints = new List <Vector2>();
List <int> facadeIndicies = new List <int>();
mesh.submeshLibrary.SubmeshAdd(roof.mainSurface);
int wallSubmesh = mesh.submeshLibrary.SubmeshAdd(roof.wallSurface != null ? roof.wallSurface : roof.mainSurface);
int floorSubmesh = mesh.submeshLibrary.SubmeshAdd(roof.floorSurface != null?roof.floorSurface: roof.mainSurface);
bool[] facadeParapets = new bool[numberOfPoints];
for (int p = 0; p < numberOfPoints; p++)
{
Vector3 p0 = volume.BuildingPoint(p);
roofPoints.Add(new Vector2(p0.x, p0.z));
facadeIndicies.Add(p);
if (!volume.IsWallStraight(p))
{
int anchorCount = volume.facadeWallAnchors[p].Count;
for (int a = 1; a < anchorCount - 1; a++)
{
roofPoints.Add(volume.facadeWallAnchors[p][a].vector2);
facadeIndicies.Add(p);
}
}
facadeParapets[p] = BuildRFacadeUtil.HasParapet(building, volume, p);
}
int numberOfRoofPoints = roofPoints.Count;
Vector3[] facadeNormals = new Vector3[numberOfRoofPoints];
Vector3[] facadeDirections = new Vector3[numberOfRoofPoints];
float[] facadeLengths = new float[numberOfRoofPoints];
for (int p = 0; p < numberOfRoofPoints; p++)
{
Vector3 p0 = roofPoints[p];
Vector3 p1 = roofPoints[(p + 1) % numberOfRoofPoints];
Vector3 facadeVector = (p1 - p0);
facadeDirections[p] = facadeVector.normalized;
facadeNormals[p] = Vector3.Cross(Vector3.up, facadeDirections[p]);
facadeLengths[p] = facadeVector.magnitude;
}
Vector2[] roofPointsA = roofPoints.ToArray();
bool[] roofGables = new bool[numberOfPoints];
for (int g = 0; g < numberOfPoints; g++)
{
roofGables[g] = volume[g].isGabled;
}
Vector2[] baseRoofPoints = new Vector2[0];
if (roof.overhang > 0)
{
OffsetPoly polyOffset = new OffsetPoly(roofPointsA, -roof.overhang);
polyOffset.Execute();
baseRoofPoints = polyOffset.Shape();
ShapeToRoofMesh.OverhangUnderside(ref mesh, roofPointsA, baseRoofPoints, totalPlanHeight, roof);
}
else
{
baseRoofPoints = roofPointsA;
}
if (baseRoofPoints.Length == 0)
{
return;
}
Vector2[] parapetExternalPoints = new Vector2[0];
Vector2[] parapetInternalPoints = new Vector2[0];
float parapetFrontDepth = roof.parapetFrontDepth;
float parapetBackDepth = roof.parapetBackDepth;
if (generateColliders)
{
collider.thickness = parapetFrontDepth * 0.5f + parapetBackDepth;
}
bool parapet = roof.parapet && building.meshType == BuildingMeshTypes.Full;
if (parapet)
{
OffsetPoly polyOffset = new OffsetPoly(baseRoofPoints, -parapetFrontDepth);
polyOffset.Execute();
parapetExternalPoints = polyOffset.Shape();
polyOffset = new OffsetPoly(baseRoofPoints, parapetBackDepth);
polyOffset.Execute();
parapetInternalPoints = polyOffset.Shape();
}
int roofPointCount = baseRoofPoints.Length;
if (parapet && parapetExternalPoints.Length > 0 && parapetInternalPoints.Length > 0)
{
List <BuildRVolumeUtil.ParapetWallData> parapetShapes = BuildRVolumeUtil.GetParapetShapes(building, volume, baseRoofPoints);
for (int p = 0; p < roofPointCount; p++)
{
BuildRVolumeUtil.ParapetWallData parapetWallData = parapetShapes[p];
int facadeIndex = facadeIndicies[p];
if (!facadeParapets[facadeIndex] || parapetWallData.type == BuildRVolumeUtil.ParapetWallData.Types.None)
{
continue;
}
int pb = (p + 1) % roofPointCount;
int pbi = (p + 1) % parapetInternalPoints.Length;
int pbe = (p + 1) % parapetExternalPoints.Length;
int facadeIndexB = (facadeIndex + 1) % numberOfPoints;
int facadeIndexC = (facadeIndex - 1 + numberOfPoints) % numberOfPoints;
bool facadeParapetB = facadeParapets[facadeIndexB] && parapetShapes[facadeIndexB].type != BuildRVolumeUtil.ParapetWallData.Types.None;
bool facadeParapetC = facadeParapets[facadeIndexC] && parapetShapes[facadeIndexC].type != BuildRVolumeUtil.ParapetWallData.Types.None;
Vector3 p0 = new Vector3(baseRoofPoints[p].x, totalPlanHeight, baseRoofPoints[p].y);
Vector3 p1 = new Vector3(baseRoofPoints[pb].x, totalPlanHeight, baseRoofPoints[pb].y);
Vector3 facadeVector = (p1 - p0);
Vector3 facadeDirection = facadeVector.normalized;
Vector3 facadeNormal = Vector3.Cross(Vector3.up, facadeDirection);
int pCount = Mathf.Min(parapetExternalPoints.Length, parapetInternalPoints.Length);
if (p < pCount)
{
float facadeLength = facadeVector.magnitude;
if (!facadeParapetC)//need to straighten the ends if no parapet exists
{
Vector3 parapetEndExternalC = p0 + facadeNormal * parapetFrontDepth;
Vector3 parapetEndInternalC = p0 - facadeNormal * parapetBackDepth;
parapetExternalPoints[p] = new Vector2(parapetEndExternalC.x, parapetEndExternalC.z);
parapetInternalPoints[p] = new Vector2(parapetEndInternalC.x, parapetEndInternalC.z);
}
if (!facadeParapetB)//need to straighten the ends if no parapet exists
{
Vector3 parapetEndExternalB = p1 + facadeNormal * parapetFrontDepth;
Vector3 parapetEndInternalB = p1 - facadeNormal * parapetBackDepth;
parapetExternalPoints[pbe] = new Vector2(parapetEndExternalB.x, parapetEndExternalB.z);
parapetInternalPoints[pbi] = new Vector2(parapetEndInternalB.x, parapetEndInternalB.z);
}
//external points
Vector3 p0e = new Vector3(parapetExternalPoints[p].x, totalPlanHeight, parapetExternalPoints[p].y);
Vector3 p1e = new Vector3(parapetExternalPoints[pbe].x, totalPlanHeight, parapetExternalPoints[pbe].y);
//internal points
Vector3 p0i = new Vector3(parapetInternalPoints[p].x, totalPlanHeight, parapetInternalPoints[p].y);
Vector3 p1i = new Vector3(parapetInternalPoints[pbi].x, totalPlanHeight, parapetInternalPoints[pbi].y);
float uvAngle = JMath.SignAngle(new Vector2(facadeDirection.x, facadeDirection.z).normalized) + 90;
Vector4 facadeTangent = BuildRMesh.CalculateTangent(facadeDirection);
Vector4 facadeTangentInverse = BuildRMesh.CalculateTangent(-facadeDirection);
if (parapetWallData.type == BuildRVolumeUtil.ParapetWallData.Types.AtoIntersection)
{
Vector2 intV2 = parapetWallData.Int;
Vector3 intV3 = new Vector3(intV2.x, totalPlanHeight, intV2.y);
p1e = intV3 + facadeNormal * parapetFrontDepth;
p1i = intV3 - facadeNormal * parapetBackDepth;
}
if (parapetWallData.type == BuildRVolumeUtil.ParapetWallData.Types.IntersectiontoB)
{
Vector2 intV2 = parapetWallData.Int;
Vector3 intV3 = new Vector3(intV2.x, totalPlanHeight, intV2.y);
p0e = intV3 + facadeNormal * parapetFrontDepth;
p0i = intV3 - facadeNormal * parapetBackDepth;
}
if (roof.parapetStyle == Roof.ParapetStyles.Flat)
{
Vector3 parapetUp = Vector3.up * roof.parapetHeight;
Vector3 w0 = p0e; //front left
Vector3 w1 = p1e; //front right
Vector3 w2 = p0i; //back left
Vector3 w3 = p1i; //back right
Vector3 w6 = w2 + parapetUp; //front left top
Vector3 w7 = w3 + parapetUp; //front right top
Vector3 w4 = w0 + parapetUp; //back left top
Vector3 w5 = w1 + parapetUp; //back right top
mesh.AddPlane(w0, w1, w4, w5, Vector2.zero, new Vector2(facadeLength, roof.parapetHeight), facadeNormal, facadeTangent, wallSubmesh, roof.wallSurface); //front
mesh.AddPlane(w3, w2, w7, w6, Vector2.zero, new Vector2(facadeLength, roof.parapetHeight), -facadeNormal, facadeTangentInverse, wallSubmesh, roof.wallSurface); //back
mesh.AddPlaneComplexUp(w7, w6, w5, w4, uvAngle, Vector3.up, facadeTangent, wallSubmesh, roof.wallSurface); //top
if (generateColliders)
{
collider.AddPlane(w0, w1, w4, w5);
if (!collider.usingPrimitives)
{
collider.mesh.AddPlane(w3, w2, w7, w6, 0);
collider.mesh.AddPlane(w7, w6, w5, w4, 0);
}
}
if (parapetFrontDepth > 0)
{
mesh.AddPlaneComplexUp(p0, p1, w0, w1, uvAngle, Vector3.down, facadeTangent, wallSubmesh, roof.wallSurface);//bottom
}
bool leftParapet = facadeParapetB;
if (!leftParapet)
{
//todo proper calculations
Vector3 leftCapNormal = Vector3.forward;
mesh.AddPlane(w0, w2, w4, w6, Vector2.zero, new Vector2(parapetBackDepth + parapetFrontDepth, roof.parapetHeight), leftCapNormal, facadeTangent, wallSubmesh, roof.wallSurface);//left cap
}
bool rightParapet = facadeParapetC;
if (!rightParapet)
{
//todo proper calculations
Vector3 rightCapNormal = Vector3.forward;
mesh.AddPlane(w3, w1, w7, w5, Vector2.zero, new Vector2(parapetBackDepth + parapetFrontDepth, roof.parapetHeight), rightCapNormal, facadeTangent, wallSubmesh, roof.wallSurface);//right cap
}
}
else//battlements!
{
int battlementCount = Mathf.CeilToInt(facadeLength / roof.battlementSpacing) * 2 + 1;
for (int b = 0; b < battlementCount + 1; b++)
{
float percentLeft = b / (float)(battlementCount);
float percentRight = (b + 1f) / (battlementCount);
float parapetUVStart = percentLeft * facadeLength;
float parapetUVWidth = (percentRight - percentLeft) * facadeLength;
Vector3 b0 = Vector3.Lerp(p0e, p1e, percentLeft);
Vector3 b1 = Vector3.Lerp(p0e, p1e, percentRight);
Vector3 b2 = Vector3.Lerp(p0i, p1i, percentLeft);
Vector3 b3 = Vector3.Lerp(p0i, p1i, percentRight);
bool upperBattlement = b % 2 == 0;
float battlementUp = upperBattlement ? roof.parapetHeight : roof.parapetHeight * roof.battlementHeightRatio;
Vector3 battlementUpV = Vector3.up * battlementUp;
Vector3 b6 = b2 + battlementUpV; //front left top
Vector3 b7 = b3 + battlementUpV; //front right top
Vector3 b4 = b0 + battlementUpV; //back left top
Vector3 b5 = b1 + battlementUpV; //back right top
//front
mesh.AddPlane(b0, b1, b4, b5, new Vector2(parapetUVStart, 0), new Vector2(parapetUVStart + parapetUVWidth, battlementUp), facadeNormal, facadeTangent, wallSubmesh, roof.wallSurface);
//back
mesh.AddPlane(b3, b2, b7, b6, new Vector2(parapetUVStart, 0), new Vector2(parapetUVStart + parapetUVWidth, battlementUp), -facadeNormal, facadeTangentInverse, wallSubmesh, roof.wallSurface);
//top
mesh.AddPlaneComplexUp(b7, b6, b5, b4, uvAngle, Vector3.up, facadeTangent, wallSubmesh, roof.wallSurface);
if (parapetFrontDepth > 0)
{
mesh.AddPlaneComplexUp(p0, p1, b0, b1, uvAngle, Vector3.down, facadeTangent, wallSubmesh, roof.wallSurface);//bottom
}
if (generateColliders)
{
collider.AddPlane(b0, b1, b4, b5);
if (!collider.usingPrimitives)
{
collider.mesh.AddPlane(b3, b2, b7, b6, 0);
collider.mesh.AddPlane(b7, b6, b5, b4, 0);
}
}
if (upperBattlement)
{
//todo proper calculations
float uvBattlementCapUp = roof.parapetHeight * roof.battlementHeightRatio;
Vector3 leftCapNormal = -facadeDirection;
Vector4 leftCapTangent = BuildRMesh.CalculateTangent(-facadeNormal);
mesh.AddPlane(b2, b0, b6, b4, new Vector2(parapetUVStart, 0), new Vector2(parapetUVStart + roof.parapetBackDepth + parapetFrontDepth, uvBattlementCapUp), leftCapNormal, leftCapTangent, wallSubmesh, roof.wallSurface);//left cap
Vector3 rightCapNormal = facadeDirection;
Vector4 rightCapTangent = BuildRMesh.CalculateTangent(facadeNormal);
mesh.AddPlane(b1, b3, b5, b7, new Vector2(parapetUVStart, 0), new Vector2(parapetUVStart + roof.parapetBackDepth + parapetFrontDepth, uvBattlementCapUp), rightCapNormal, rightCapTangent, wallSubmesh, roof.wallSurface);//right cap
if (generateColliders)
{
if (!collider.usingPrimitives)
{
collider.mesh.AddPlane(b2, b0, b6, b4, 0);
collider.mesh.AddPlane(b1, b3, b5, b7, 0);
}
}
}
}
}
}
}
}
Vector2[] roofFloorBasePoints = (roof.parapet && roof.parapetBackDepth > 0 && parapetInternalPoints.Length > 0) ? parapetInternalPoints : baseRoofPoints;
Roof.Types roofType = roof.type;
if (volume.abovePlanCount > 0)
{
roofType = Roof.Types.Flat;
}
switch (roofType)
{
default:
Flat(building, volume, mesh, collider, roofFloorBasePoints, totalPlanHeight, roof, floorSubmesh, roof.floorSurface, clampUV);
break;
case Roof.Types.Pitched:
if (!PitchedRoofGenerator.Generate(mesh, collider, roofFloorBasePoints, facadeIndicies.ToArray(), totalPlanHeight, volume, clampUV))
{
Flat(building, volume, mesh, collider, roofFloorBasePoints, totalPlanHeight, roof, floorSubmesh, roof.floorSurface, clampUV);
}
break;
case Roof.Types.Mansard:
if (!MansardRoofGenerator.Generate(mesh, collider, roofFloorBasePoints, facadeIndicies.ToArray(), totalPlanHeight, volume))
{
Flat(building, volume, mesh, collider, roofFloorBasePoints, totalPlanHeight, roof, floorSubmesh, roof.floorSurface, clampUV);
}
// ShapeToRoofMesh.MansardRoof(ref mesh, roofFloorBasePoints, roofGables, totalPlanHeight, roof, surfaceMapping);
break;
// case Roof.Types.Gambrel:
// ShapeToRoofMesh.Gambrel(ref mesh, roofFloorBasePoints, roofGables, totalPlanHeight, roof, surfaceMapping);
// break;
}
}
public static void Generate(ref BuildRMesh mesh, VerticalOpening opening, int actualFloor, Vector3 basePosition, float height, int wallSubmesh = -1, BuildRCollider collider = null)
{
// bool lowerLanding = true;
// float wallDepth = 0.5f;//todo
bool generateColldier = collider != null;
float wallThickness = VerticalOpening.WALL_THICKNESS;
if (collider != null)
{
collider.thickness = VerticalOpening.WALL_THICKNESS;
}
// bool generateMeshCollider = generateColldier && !collider.usingPrimitives;
SubmeshLibrary submeshLibrary = mesh.submeshLibrary;
int externalWallSubmesh = submeshLibrary.SubmeshAdd(opening.surfaceA);
int internalWallSubmesh = submeshLibrary.SubmeshAdd(opening.surfaceB);
int doorFrameSubmesh = submeshLibrary.SubmeshAdd(opening.surfaceC);
if (wallSubmesh != -1)
{
externalWallSubmesh = wallSubmesh;
}
if (externalWallSubmesh == -1)
{
externalWallSubmesh = 0;
}
if (internalWallSubmesh == -1)
{
internalWallSubmesh = 0;
}
if (doorFrameSubmesh == -1)
{
doorFrameSubmesh = 0;
}
//base positions
Quaternion rotation = Quaternion.Euler(0, opening.rotation, 0);
// Vector2Int openingSize = opening.size;
Vector3 b0 = basePosition + rotation * new Vector3(-opening.size.vx * 0.5f, 0, -opening.size.vy * 0.5f);
Vector3 b1 = basePosition + rotation * new Vector3(opening.size.vx * 0.5f, 0, -opening.size.vy * 0.5f);
Vector3 b2 = basePosition + rotation * new Vector3(-opening.size.vx * 0.5f, 0, opening.size.vy * 0.5f);
Vector3 b3 = basePosition + rotation * new Vector3(opening.size.vx * 0.5f, 0, opening.size.vy * 0.5f);
//inner points
Vector3 b0i = b0 + rotation * new Vector3(1, 0, 1) * wallThickness;
Vector3 b1i = b1 + rotation * new Vector3(-1, 0, 1) * wallThickness;
Vector3 b2i = b2 + rotation * new Vector3(1, 0, -1) * wallThickness;
Vector3 b3i = b3 + rotation * new Vector3(-1, 0, -1) * wallThickness;
//walls
Vector3 wallUpInternal = Vector3.up * height;
Vector3 wallUpExternal = Vector3.up * height;
wallUpExternal.y += -wallThickness * 0.5f;
//external
mesh.AddPlane(b2, b0, b2 + wallUpExternal, b0 + wallUpExternal, externalWallSubmesh);
mesh.AddPlane(b3, b2, b3 + wallUpExternal, b2 + wallUpExternal, externalWallSubmesh);
mesh.AddPlane(b1, b3, b1 + wallUpExternal, b3 + wallUpExternal, externalWallSubmesh);
//internal
mesh.AddPlane(b0i, b2i, b0i + wallUpInternal, b2i + wallUpInternal, internalWallSubmesh);
mesh.AddPlane(b2i, b3i, b2i + wallUpInternal, b3i + wallUpInternal, internalWallSubmesh);
mesh.AddPlane(b3i, b1i, b3i + wallUpInternal, b1i + wallUpInternal, internalWallSubmesh);
//door
Vector3 b0d = b0 + rotation * (Vector3.right * opening.size.vx * 0.15f);
Vector3 b1d = b1 + rotation * (Vector3.left * opening.size.vx * 0.15f);
Vector3 doorUp = wallUpInternal * 0.85f;
//external
mesh.AddPlane(b0, b0d, b0 + doorUp, b0d + doorUp, externalWallSubmesh);
mesh.AddPlane(b1d, b1, b1d + doorUp, b1 + doorUp, externalWallSubmesh);
mesh.AddPlane(b0 + doorUp, b1 + doorUp, b0 + wallUpExternal, b1 + wallUpExternal, externalWallSubmesh);
//internal
Vector3 doorFrameV = rotation * new Vector3(0, 0, 1) * wallThickness;
mesh.AddPlane(b1i, b1d + doorFrameV, b1i + doorUp, b1d + doorFrameV + doorUp, internalWallSubmesh);
mesh.AddPlane(b0d + doorFrameV, b0i, b0d + doorFrameV + doorUp, b0i + doorUp, internalWallSubmesh);
mesh.AddPlane(b1i + doorUp, b0i + doorUp, b1i + wallUpInternal, b0i + wallUpInternal, internalWallSubmesh);
//door frame
mesh.AddPlane(b0d, b1d, b0d + doorFrameV, b1d + doorFrameV, doorFrameSubmesh);
mesh.AddPlane(b0d, b0d + doorFrameV, b0d + doorUp, b0d + doorFrameV + doorUp, doorFrameSubmesh);
mesh.AddPlane(b1d + doorFrameV, b1d, b1d + doorFrameV + doorUp, b1d + doorUp, doorFrameSubmesh);
mesh.AddPlane(b0d + doorFrameV + doorUp, b1d + doorFrameV + doorUp, b0d + doorUp, b1d + doorUp, doorFrameSubmesh);
if (generateColldier)
{
collider.AddPlane(b2, b0, b2 + wallUpExternal, b0 + wallUpExternal);
collider.AddPlane(b3, b2, b3 + wallUpExternal, b2 + wallUpExternal);
collider.AddPlane(b1, b3, b1 + wallUpExternal, b3 + wallUpExternal);
collider.AddPlane(b0, b0d, b0 + doorUp, b0d + doorUp);
collider.AddPlane(b1d, b1, b1d + doorUp, b1 + doorUp);
collider.AddPlane(b0 + doorUp, b1 + doorUp, b0 + wallUpExternal, b1 + wallUpExternal);
if (!collider.usingPrimitives)
{
collider.mesh.AddPlane(b0i, b2i, b0i + wallUpInternal, b2i + wallUpInternal, 0);
collider.mesh.AddPlane(b2i, b3i, b2i + wallUpInternal, b3i + wallUpInternal, 0);
collider.mesh.AddPlane(b3i, b1i, b3i + wallUpInternal, b1i + wallUpInternal, 0);
collider.mesh.AddPlane(b1i, b1d + doorFrameV, b1i + doorUp, b1d + doorFrameV + doorUp, 0);
collider.mesh.AddPlane(b0d + doorFrameV, b0i, b0d + doorFrameV + doorUp, b0i + doorUp, 0);
collider.mesh.AddPlane(b1i + doorUp, b0i + doorUp, b1i + wallUpInternal, b0i + wallUpInternal, 0);
collider.mesh.AddPlane(b0d, b1d, b0d + doorFrameV, b1d + doorFrameV, 0);
collider.mesh.AddPlane(b0d, b0d + doorFrameV, b0d + doorUp, b0d + doorFrameV + doorUp, 0);
collider.mesh.AddPlane(b1d + doorFrameV, b1d, b1d + doorFrameV + doorUp, b1d + doorUp, 0);
collider.mesh.AddPlane(b0d + doorFrameV + doorUp, b1d + doorFrameV + doorUp, b0d + doorUp, b1d + doorUp, 0);
}
}
}
