public static void Build(DynamicMeshGenericMultiMaterialMesh _mesh, BuildrData _data) { // timestart = Time.realtimeSinceStartup; data = _data; mesh = _mesh; textures = data.textures.ToArray(); BuildrPlan plan = data.plan; int facadeIndex = 0; numberOfFacades = 0; int numberOfVolumes = data.plan.numberOfVolumes; LogTimer("Start"); //define rectangles that represent the facades packedTexturePositions.Clear(); for (int v = 0; v < numberOfVolumes; v++) { BuildrVolume volume = plan.volumes[v]; int numberOfVolumePoints = volume.points.Count; for (int f = 0; f < numberOfVolumePoints; f++) { if (!volume.renderFacade[f]) { continue; } int indexA = f; int indexB = (f < numberOfVolumePoints - 1) ? f + 1 : 0; Vector2z p0 = plan.points[volume.points[indexA]]; Vector2z p1 = plan.points[volume.points[indexB]]; float facadeWidth = Vector2z.Distance(p0, p1) * PIXELS_PER_METER; int floorBase = plan.GetFacadeFloorHeight(v, volume.points[indexA], volume.points[indexB]); int numberOfFloors = volume.numberOfFloors - floorBase; if (numberOfFloors < 1)//no facade - adjacent facade is taller and covers this one { continue; } float floorHeight = data.floorHeight; float facadeHeight = (volume.numberOfFloors - floorBase) * floorHeight * PIXELS_PER_METER; if (facadeHeight < 0) { facadeWidth = 0; facadeHeight = 0; } Rect newFacadeRect = new Rect(0, 0, facadeWidth, facadeHeight); packedTexturePositions.Add(newFacadeRect); numberOfFacades++; } } //Build ROOF DynamicMeshGenericMultiMaterialMesh dynMeshRoof = new DynamicMeshGenericMultiMaterialMesh(); dynMeshRoof.name = "Roof Mesh"; dynMeshRoof.subMeshCount = textures.Length; BuildrRoof.Build(dynMeshRoof, data, true); dynMeshRoof.CheckMaxTextureUVs(data); LogTimer("Roof A"); roofTextures.Clear(); roofTextureIndex.Clear(); foreach (BuildrRoofDesign roofDesign in data.roofs) { foreach (int textureIndex in roofDesign.textureValues) { if (!roofTextureIndex.Contains(textureIndex)) { BuildrTexture bTexture = data.textures[textureIndex]; Vector2 largestSubmeshPlaneSize = new Vector2(1, 1); Vector2 minWorldUvSize = dynMeshRoof.MinWorldUvSize(textureIndex); Vector2 maxWorldUvSize = dynMeshRoof.MaxWorldUvSize(textureIndex); largestSubmeshPlaneSize.x = maxWorldUvSize.x - minWorldUvSize.x; largestSubmeshPlaneSize.y = maxWorldUvSize.y - minWorldUvSize.y; int roofTextureWidth = Mathf.RoundToInt(largestSubmeshPlaneSize.x * PIXELS_PER_METER); int roofTextureHeight = Mathf.RoundToInt(largestSubmeshPlaneSize.y * PIXELS_PER_METER); Rect newRoofTexutureRect = new Rect(0, 0, roofTextureWidth, roofTextureHeight); packedTexturePositions.Add(newRoofTexutureRect); roofTextures.Add(bTexture); roofTextureIndex.Add(textureIndex); } } } //run a custom packer to define their postions textureWidth = RectanglePack.Pack(packedTexturePositions, ATLAS_PADDING); //determine the resize scale and apply that to the rects packedScale = 1; int numberOfRects = packedTexturePositions.Count; if (textureWidth > MAXIMUM_TEXTURESIZE) { packedScale = MAXIMUM_TEXTURESIZE / (float)textureWidth; for (int i = 0; i < numberOfRects; i++) { Rect thisRect = packedTexturePositions[i]; thisRect.x *= packedScale; thisRect.y *= packedScale; thisRect.width *= packedScale; thisRect.height *= packedScale; packedTexturePositions[i] = thisRect; //Debug.Log("Rects "+roofTextures[i-+packedTexturePositions[i]); } textureWidth = Mathf.RoundToInt(packedScale * textureWidth); } else { textureWidth = (int)Mathf.Pow(2, (Mathf.FloorToInt(Mathf.Log(textureWidth - 1, 2)) + 1));//find the next power of two } //Debug.Log("Texture Width "+textureWidth); //TODO: maybe restrict the resize to a power of two? LogTimer("Packed Rect Generated"); textureSize = textureWidth * textureWidth; colourArray = new Color32[textureSize]; //TestRectColours();//this test paints all the facades with rainbow colours - real pretty BuildTextures(); LogTimer("texture created"); Texture2D packedTexture = new Texture2D(textureWidth, textureWidth, TextureFormat.ARGB32, true); packedTexture.filterMode = FilterMode.Bilinear; packedTexture.SetPixels32(colourArray); packedTexture.Apply(true, false); LogTimer("apply"); if (data.LODTextureAtlas != null) { Object.DestroyImmediate(data.LODTextureAtlas); } data.LODTextureAtlas = packedTexture; data.LODTextureAtlas.name = "Low Detail Texture"; //build the model with new uvs if (data.drawUnderside) { for (int s = 0; s < numberOfVolumes; s++) { BuildrVolume volume = plan.volumes[s]; int numberOfVolumePoints = volume.points.Count; Vector3[] newEndVerts = new Vector3[numberOfVolumePoints]; Vector2[] newEndUVs = new Vector2[numberOfVolumePoints]; for (int i = 0; i < numberOfVolumePoints; i++) { newEndVerts[i] = plan.points[volume.points[i]].vector3; newEndUVs[i] = Vector2.zero; } List <int> tris = new List <int>(data.plan.GetTrianglesBySectorBase(s)); tris.Reverse(); mesh.AddData(newEndVerts, newEndUVs, tris.ToArray(), 0); } } LogTimer("Floor"); //Build facades for (int s = 0; s < numberOfVolumes; s++) { BuildrVolume volume = plan.volumes[s]; int numberOfVolumePoints = volume.points.Count; for (int f = 0; f < numberOfVolumePoints; f++) { if (!volume.renderFacade[f]) { continue; } int indexA = f; int indexB = (f < numberOfVolumePoints - 1) ? f + 1 : 0; Vector3 p0 = plan.points[volume.points[indexA]].vector3; Vector3 p1 = plan.points[volume.points[indexB]].vector3; int floorBase = plan.GetFacadeFloorHeight(s, volume.points[indexA], volume.points[indexB]); int numberOfFloors = volume.numberOfFloors - floorBase; if (numberOfFloors < 1) { //no facade - adjacent facade is taller and covers this one continue; } float floorHeight = data.floorHeight; Vector3 floorHeightStart = Vector3.up * (floorBase * floorHeight); Vector3 wallHeight = Vector3.up * (volume.numberOfFloors * floorHeight) - floorHeightStart; p0 += floorHeightStart; p1 += floorHeightStart; Vector3 w0 = p0; Vector3 w1 = p1; Vector3 w2 = w0 + wallHeight; Vector3 w3 = w1 + wallHeight; Rect facadeRect = packedTexturePositions[facadeIndex]; float imageSize = textureWidth; Vector2 uvMin = new Vector2(facadeRect.xMin / imageSize, facadeRect.yMin / imageSize); Vector2 uvMax = new Vector2(facadeRect.xMax / imageSize, facadeRect.yMax / imageSize); mesh.AddPlane(w0, w1, w2, w3, uvMin, uvMax, 0); facadeIndex++; } } LogTimer("Facades"); //ROOF Textures int roofRectBase = numberOfFacades; List <Rect> newAtlasRects = new List <Rect>(); for (int i = roofRectBase; i < packedTexturePositions.Count; i++) { Rect uvRect = new Rect();//generate a UV based rectangle off the packed one uvRect.x = packedTexturePositions[i].x / textureWidth; uvRect.y = packedTexturePositions[i].y / textureWidth; uvRect.width = packedTexturePositions[i].width / textureWidth; uvRect.height = packedTexturePositions[i].height / textureWidth; newAtlasRects.Add(uvRect); } dynMeshRoof.Atlas(roofTextureIndex.ToArray(), newAtlasRects.ToArray(), data.textures.ToArray()); //Add the atlased mesh data to the main model data at submesh 0 mesh.AddData(dynMeshRoof.vertices, dynMeshRoof.uv, dynMeshRoof.triangles, 0); LogTimer("Roof B"); data = null; mesh = null; textures = null; //atlasRects = null; LogTimer("Done"); System.GC.Collect(); }
public static void Build(DynamicMeshGenericMultiMaterialMesh _mesh, BuildrData _data) { // timestart = Time.realtimeSinceStartup; data = _data; mesh = _mesh; textures = data.textures.ToArray(); BuildrPlan plan = data.plan; // int facadeIndex = 0; numberOfFacades = 0; int numberOfVolumes = data.plan.numberOfVolumes; //define rectangles that represent the facades packedTexturePositions.Clear(); for (int v = 0; v < numberOfVolumes; v++) { BuildrVolume volume = plan.volumes[v]; int numberOfVolumePoints = volume.points.Count; for (int f = 0; f < numberOfVolumePoints; f++) { if (!volume.renderFacade[f]) { continue; } int indexA = f; int indexB = (f < numberOfVolumePoints - 1) ? f + 1 : 0; Vector2z p0 = plan.points[volume.points[indexA]]; Vector2z p1 = plan.points[volume.points[indexB]]; float facadeWidth = Vector2z.Distance(p0, p1) * PIXELS_PER_METER; int floorBase = plan.GetFacadeFloorHeight(v, volume.points[indexA], volume.points[indexB]); int numberOfFloors = volume.numberOfFloors - floorBase; if (numberOfFloors < 1)//no facade - adjacent facade is taller and covers this one { continue; } float floorHeight = data.floorHeight; float facadeHeight = (volume.numberOfFloors - floorBase) * floorHeight * PIXELS_PER_METER; if (facadeHeight < 0) { facadeWidth = 0; facadeHeight = 0; } Rect newFacadeRect = new Rect(0, 0, facadeWidth, facadeHeight); packedTexturePositions.Add(newFacadeRect); numberOfFacades++; } } //Build ROOF DynamicMeshGenericMultiMaterialMesh dynMeshRoof = new DynamicMeshGenericMultiMaterialMesh(); dynMeshRoof.name = "Roof Mesh"; dynMeshRoof.subMeshCount = textures.Length; BuildrRoof.Build(dynMeshRoof, data, true); dynMeshRoof.CheckMaxTextureUVs(data); roofTextures.Clear(); roofTextureIndex.Clear(); foreach (BuildrRoofDesign roofDesign in data.roofs) { foreach (int textureIndex in roofDesign.textureValues) { if (!roofTextureIndex.Contains(textureIndex)) { BuildrTexture bTexture = data.textures[textureIndex]; Vector2 largestSubmeshPlaneSize = new Vector2(1, 1); Vector2 minWorldUvSize = dynMeshRoof.MinWorldUvSize(textureIndex); Vector2 maxWorldUvSize = dynMeshRoof.MaxWorldUvSize(textureIndex); largestSubmeshPlaneSize.x = maxWorldUvSize.x - minWorldUvSize.x; largestSubmeshPlaneSize.y = maxWorldUvSize.y - minWorldUvSize.y; int roofTextureWidth = Mathf.RoundToInt(largestSubmeshPlaneSize.x * PIXELS_PER_METER); int roofTextureHeight = Mathf.RoundToInt(largestSubmeshPlaneSize.y * PIXELS_PER_METER); Rect newRoofTexutureRect = new Rect(0, 0, roofTextureWidth, roofTextureHeight); packedTexturePositions.Add(newRoofTexutureRect); roofTextures.Add(bTexture); roofTextureIndex.Add(textureIndex); } } } //run a custom packer to define their postions textureWidth = RectanglePack.Pack(packedTexturePositions, ATLAS_PADDING); //determine the resize scale and apply that to the rects packedScale = 1; int numberOfRects = packedTexturePositions.Count; if (textureWidth > MAXIMUM_TEXTURESIZE) { packedScale = MAXIMUM_TEXTURESIZE / (float)textureWidth; for (int i = 0; i < numberOfRects; i++) { Rect thisRect = packedTexturePositions[i]; thisRect.x *= packedScale; thisRect.y *= packedScale; thisRect.width *= packedScale; thisRect.height *= packedScale; packedTexturePositions[i] = thisRect; //Debug.Log("Rects "+roofTextures[i-+packedTexturePositions[i]); } textureWidth = Mathf.RoundToInt(packedScale * textureWidth); } else { textureWidth = (int)Mathf.Pow(2, (Mathf.FloorToInt(Mathf.Log(textureWidth - 1, 2)) + 1));//find the next power of two } textureSize = textureWidth * textureWidth; colourArray = new Color32[textureSize]; //TestRectColours();//this test paints all the facades with rainbow colours - real pretty BuildTextures(); Texture2D packedTexture = new Texture2D(textureWidth, textureWidth, TextureFormat.ARGB32, true); packedTexture.filterMode = FilterMode.Bilinear; packedTexture.SetPixels32(colourArray); packedTexture.Apply(true, false); if (data.OneDrawCallTexture != null) { Object.DestroyImmediate(data.OneDrawCallTexture); } data.OneDrawCallTexture = packedTexture; data.OneDrawCallTexture.name = "One Draw Call Texture"; int numberOfRoofTextures = roofTextures.Count - 1; List <Rect> facadeTexturePositions = new List <Rect>(packedTexturePositions); Debug.Log(numberOfRoofTextures); facadeTexturePositions.RemoveRange(packedTexturePositions.Count - numberOfRoofTextures, numberOfRoofTextures); BuildrBuilding.Build(mesh, data, facadeTexturePositions.ToArray()); data = null; mesh = null; textures = null; System.GC.Collect(); }
// private static float timestart; /// <summary> /// Custom BuildR texture packer. Uses the BuildR Data class to create a single texture used by the generated building, taking into account tiling. /// </summary> /// <param name="data">BuildR Building Data</param> public static void Pack(BuildrData data) { // timestart = Time.realtimeSinceStartup; data.texturesNotPacked.Clear(); data.texturesPacked.Clear(); int numberOfTextures = data.textures.Count; List <Rect> packedTexturePositions = new List <Rect>(); List <int> texturePacked = new List <int>(); for (int t = 0; t < numberOfTextures; t++) { BuildrTexture texture = data.textures[t]; if (texture.tiled) { int textureWidth = texture.texture.width; int textureHeight = texture.texture.height; int targetTextureWidth = Mathf.RoundToInt(textureWidth * texture.maxUVTile.x); int targetTextureHeight = Mathf.RoundToInt(textureHeight * texture.maxUVTile.y); float resizeToLargest = Mathf.Min((float)MAX_SOURCE_TEXTURE_SIZE / (float)targetTextureWidth, (float)MAX_SOURCE_TEXTURE_SIZE / (float)targetTextureHeight, 1);//ensure texture fits smallest size int useTextureWidth = Mathf.RoundToInt(resizeToLargest * targetTextureWidth); int useTextureHeight = Mathf.RoundToInt(resizeToLargest * targetTextureHeight); if (useTextureWidth == 0 || useTextureHeight == 0)//texture no used on model { data.texturesNotPacked.Add(t); continue; } packedTexturePositions.Add(new Rect(0, 0, useTextureWidth, useTextureHeight)); texturePacked.Add(t); } else { int useTextureWidth = texture.texture.width; int useTextureHeight = texture.texture.height; packedTexturePositions.Add(new Rect(0, 0, useTextureWidth, useTextureHeight)); texturePacked.Add(t); } } int atlasedTextureWidth = RectanglePack.Pack(packedTexturePositions, ATLAS_PADDING); //determine the resize scale and apply that to the rects float packedScale = 1; int numberOfRects = packedTexturePositions.Count; if (atlasedTextureWidth > MAXIMUM_TEXTURESIZE) { packedScale = MAXIMUM_TEXTURESIZE / (float)atlasedTextureWidth; for (int i = 0; i < numberOfRects; i++) { Rect thisRect = packedTexturePositions[i]; thisRect.x *= packedScale; thisRect.y *= packedScale; thisRect.width *= packedScale; thisRect.height *= packedScale; packedTexturePositions[i] = thisRect; } atlasedTextureWidth = Mathf.RoundToInt(packedScale * atlasedTextureWidth); } else { atlasedTextureWidth = (int)Mathf.Pow(2, (Mathf.FloorToInt(Mathf.Log(atlasedTextureWidth - 1, 2)) + 1));//find the next power of two } int textureSize = atlasedTextureWidth * atlasedTextureWidth; Color32[] colourArray = new Color32[textureSize]; //Build colour array for (int t = 0; t < numberOfTextures; t++) { BuildrTexture texture = data.textures[t]; Rect packedPosition = packedTexturePositions[t]; int targetTextureWidth = (int)packedPosition.width; int targetTextureHeight = (int)packedPosition.height; int sourceTextureWidth = texture.texture.width; int sourceTextureHeight = texture.texture.height; // int sourceTextureSize = sourceTextureWidth * sourceTextureHeight; int paintTextureWidth = Mathf.RoundToInt(targetTextureWidth / (texture.tiled ? texture.maxUVTile.x : texture.tiledX)); int paintTextureHeight = Mathf.RoundToInt(targetTextureHeight / (texture.tiled ? texture.maxUVTile.y : texture.tiledY)); int paintTextureSize = paintTextureWidth * paintTextureHeight; Color32[] paintColourArray = TextureScale.NearestNeighbourSample(texture.texture.GetPixels32(), sourceTextureWidth, sourceTextureHeight, paintTextureWidth, paintTextureHeight); for (int x = 0; x < targetTextureWidth; x++) { for (int y = 0; y < targetTextureHeight; y++) { int drawX = Mathf.FloorToInt(x + packedPosition.x); int drawY = Mathf.FloorToInt(y + packedPosition.y); int colourIndex = drawX + drawY * atlasedTextureWidth; int sx = x % paintTextureWidth; int sy = y % paintTextureHeight; int paintIndex = sx + sy * paintTextureWidth; if (paintIndex >= paintTextureSize) { Debug.Log("Source Index too big " + sx + " " + sy + " " + paintTextureWidth + " " + paintTextureSize + " " + texture.maxUVTile + " " + texture.name); } Color32 sourceColour = paintColourArray[paintIndex]; if (colourIndex >= textureSize) { Debug.Log("Output Index Too big " + drawX + " " + drawY + " " + colourIndex + " " + textureSize + " " + packedPosition); } colourArray[colourIndex] = sourceColour; } } } Texture2D packedTexture = new Texture2D(atlasedTextureWidth, atlasedTextureWidth, TextureFormat.ARGB32, true); packedTexture.filterMode = FilterMode.Bilinear; packedTexture.SetPixels32(colourArray); packedTexture.Apply(true, false); //remove textures from memory if (data.textureAtlas != null) { DestroyImmediate(data.textureAtlas); } data.textureAtlas = packedTexture; data.texturesPacked = texturePacked; data.atlasCoords = RectanglePack.ConvertToUVSpace(packedTexturePositions.ToArray(), atlasedTextureWidth); System.GC.Collect(); //Debug.Log("BuildR Texutre Pack Complete: " + (Time.realtimeSinceStartup - timestart)+" sec"); }
/// <summary> /// Packs an array of Texture2Ds into a sinlgle Texture2D with a maximum size specified. /// </summary> /// <param name="output">The output Texture2D</param> /// <param name="data">And array of input Texture2Ds</param> /// <param name="maximumSize">The maximum size of the output texture</param> /// <returns></returns> public static Rect[] Pack(out Texture2D output, Texture2D[] data, int maximumSize) { // timestart = Time.realtimeSinceStartup; int numberOfTextures = data.Length; List <Rect> packedTexturePositions = new List <Rect>(); List <int> texturePacked = new List <int>(); for (int t = 0; t < numberOfTextures; t++) { Texture2D texture = data[t]; int useTextureWidth = texture.width; int useTextureHeight = texture.height; packedTexturePositions.Add(new Rect(0, 0, useTextureWidth, useTextureHeight)); texturePacked.Add(t); } int atlasedTextureWidth = RectanglePack.Pack(packedTexturePositions, ATLAS_PADDING); //determine the resize scale and apply that to the rects int numberOfRects = packedTexturePositions.Count; if (atlasedTextureWidth > maximumSize) { float packedScale = maximumSize / (float)atlasedTextureWidth; for (int i = 0; i < numberOfRects; i++) { Rect thisRect = packedTexturePositions[i]; thisRect.x *= packedScale; thisRect.y *= packedScale; thisRect.width *= packedScale; thisRect.height *= packedScale; packedTexturePositions[i] = thisRect; } atlasedTextureWidth = Mathf.RoundToInt(packedScale * atlasedTextureWidth); } else { atlasedTextureWidth = (int)Mathf.Pow(2, (Mathf.FloorToInt(Mathf.Log(atlasedTextureWidth - 1, 2)) + 1));//find the next power of two } int textureSize = atlasedTextureWidth * atlasedTextureWidth; Color32[] colourArray = new Color32[textureSize]; //Build colour array for (int t = 0; t < numberOfTextures; t++) { Texture2D texture = data[t]; Rect packedPosition = packedTexturePositions[t]; int targetTextureWidth = (int)packedPosition.width; int targetTextureHeight = (int)packedPosition.height; int sourceTextureWidth = texture.width; int sourceTextureHeight = texture.height; Color32[] paintColourArray = TextureScale.NearestNeighbourSample(texture.GetPixels32(), sourceTextureWidth, sourceTextureHeight, targetTextureWidth, targetTextureHeight); for (int x = 0; x < targetTextureWidth; x++) { for (int y = 0; y < targetTextureHeight; y++) { int drawX = Mathf.FloorToInt(x + packedPosition.x); int drawY = Mathf.FloorToInt(y + packedPosition.y); int colourIndex = drawX + drawY * atlasedTextureWidth; int paintIndex = x + y * targetTextureWidth; Color32 sourceColour = paintColourArray[paintIndex]; colourArray[colourIndex] = sourceColour; } } } output = new Texture2D(atlasedTextureWidth, atlasedTextureWidth, TextureFormat.ARGB32, true); output.filterMode = FilterMode.Bilinear; output.SetPixels32(colourArray); output.Apply(true, false); //Debug.Log("BuildR Texutre Pack Complete: " + (Time.realtimeSinceStartup - timestart) + " sec"); return(RectanglePack.ConvertToUVSpace(packedTexturePositions.ToArray(), atlasedTextureWidth)); }
/*bool IsMonospace(Graphics Gfx, Font F) { * return Gfx.MeasureString("iiiii", F).Width == Gfx.MeasureString("MMMMM", F).Width; * }*/ public bool Update() { if (!Dirty) { return(false); } Dirty = false; Bitmap Bmp = new Bitmap(1, 1); using (Graphics Gfx = Graphics.FromImage(Bmp)) { RectPack = new RectanglePack(); //bool Monospace = IsMonospace(Gfx, DrawingFont); SizeF Sz = Gfx.MeasureString("X", DrawingFont); foreach (var Chr in Characters) { if (char.IsWhiteSpace(Chr)) { Sz = Gfx.MeasureString("_", DrawingFont); } else { Sz = Gfx.MeasureString(Chr.ToString(), DrawingFont); } RectPack.Add(Chr, new NVector2(Sz.Width + HalfPadding * 2, Sz.Height + HalfPadding * 2)); } CharLocations = RectPack.Pack(); } Bmp = new Bitmap((int)RectPack.Size.X, (int)RectPack.Size.Y); using (Graphics Gfx = Graphics.FromImage(Bmp)) { Gfx.SmoothingMode = SmoothingMode.HighQuality; Gfx.InterpolationMode = InterpolationMode.HighQualityBicubic; Gfx.PixelOffsetMode = PixelOffsetMode.HighQuality; Gfx.TextRenderingHint = TextRenderingHint.ClearTypeGridFit; Gfx.Clear(Color.Transparent); //Gfx.Clear(Color.Black); Random Rnd = new Random(42); foreach (var Chr in Characters) { Rect R = CharLocations[Chr]; // TODO: Convar to colorize /*Gfx.FillRectangle(new SolidBrush(Color.FromArgb(Rnd.Next(256), Rnd.Next(256), Rnd.Next(256))), * new Rectangle((int)R.X, (int)R.Y, (int)R.W, (int)R.H));*/ Gfx.DrawString(Chr.ToString(), DrawingFont, new SolidBrush(Color.FromArgb(255, 255, 255, 255)), R.X + HalfPadding, R.Y + HalfPadding); } } // TODO: Make a convar to control dumping the atlas FilePath.EnsureDirExists("debug"); Bmp.Save("debug\\atlas.png"); FontAtlas.LoadDataFromBitmap(Bmp); return(true); }
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; } } }