private static void ImportFacades(XmlDocument xml, BuildrData data)
{
foreach(XmlNode node in xml.SelectNodes("buildr/facades/facade"))
{
BuildrFacadeDesign facadeDesign = new BuildrFacadeDesign();
data.facades.Add(facadeDesign);
facadeDesign.name = node["name"].FirstChild.Value;
facadeDesign.hasWindows = node["hasWindows"].FirstChild.Value == valueTrue;
facadeDesign.type = (BuildrFacadeDesign.types)System.Enum.Parse(typeof(BuildrFacadeDesign.types), (string)node["type"].FirstChild.Value);
facadeDesign.simpleBay.name = node["simpleBayName"].FirstChild.Value;
facadeDesign.simpleBay.openingWidth = float.Parse(node["simpleBayOpeningWidth"].FirstChild.Value);
facadeDesign.simpleBay.openingHeight = float.Parse(node["simpleBayOpeningHeight"].FirstChild.Value);
facadeDesign.simpleBay.minimumBayWidth = float.Parse(node["simpleBayMinimumBayWidth"].FirstChild.Value);
facadeDesign.simpleBay.openingWidthRatio = float.Parse(node["simpleBayOpeningWidthRatio"].FirstChild.Value);
facadeDesign.simpleBay.openingHeightRatio = float.Parse(node["simpleBayOpeningHeightRatio"].FirstChild.Value);
facadeDesign.simpleBay.openingDepth = float.Parse(node["simpleBayOpeningDepth"].FirstChild.Value);
facadeDesign.simpleBay.columnDepth = float.Parse(node["simpleBayColumnDepth"].FirstChild.Value);
facadeDesign.simpleBay.rowDepth = float.Parse(node["simpleBayRowDepth"].FirstChild.Value);
facadeDesign.simpleBay.crossDepth = float.Parse(node["simpleBayCrossDepth"].FirstChild.Value);
for(int i = 0; i < 8; i++)
{
facadeDesign.simpleBay.textureValues[i] = int.Parse(node.SelectNodes("simpleBayTextures/texture")[i].FirstChild.Value);
facadeDesign.simpleBay.flipValues[i] = node.SelectNodes("simpleBayflipvalues/flipvalue")[i].FirstChild.Value == valueTrue;
}
foreach(XmlNode baynode in node.SelectNodes("bays/bayid"))
{
facadeDesign.bayPattern.Add(int.Parse(baynode.FirstChild.Value));
}
}
}
public int wallTexture = 0;//this is use then there are no windows
public BuildrFacadeDesign Duplicate()
{
BuildrFacadeDesign newDesign = new BuildrFacadeDesign();
newDesign.name = name + " copy";
newDesign.type = type;
newDesign.hasWindows = hasWindows;
newDesign.simpleBay = simpleBay.Duplicate();
newDesign.bayPattern = new List <int>(bayPattern);
//Legacy
newDesign.windowWidth = windowWidth;
newDesign.windowHeight = windowHeight;
newDesign.minimumWindowSpacing = minimumWindowSpacing;
newDesign.alternatingSpacing = alternatingSpacing;
newDesign.minimumWindowSpacingAlt = minimumWindowSpacingAlt;
newDesign.windowHeightRatio = windowHeightRatio;
newDesign.windowDepth = windowDepth;
newDesign.tilesx = tilesx;
newDesign.tilesy = tilesy;
newDesign.columnDepth = columnDepth;
newDesign.rowDepth = rowDepth;
newDesign.crossDepth = crossDepth;
newDesign.hasDoors = hasDoors;
newDesign.doorWidth = doorWidth;
newDesign.doorHeight = doorHeight;
newDesign.doorPosition = doorPosition;
newDesign.textureValues = (int[])textureValues.Clone();
newDesign.flipValues = (bool[])flipValues.Clone();
newDesign.wallTexture = wallTexture;
return(newDesign);
}
public void RemoveFacadeDesign(BuildrFacadeDesign facadeDesign)
{
int bFacadeIndex = facades.IndexOf(facadeDesign);//the the index of the facade BEFORE we delete it
facades.Remove(facadeDesign);
int numberOfVolumes = plan.numberOfVolumes;
for (int s = 0; s < numberOfVolumes; s++)
{
plan.volumes[s].styles.CheckRemovedStyle(bFacadeIndex);
}
}
private static void BuildTextures()
{
List <TexturePaintObject> buildSourceTextures = new List <TexturePaintObject>();
foreach (BuildrTexture btexture in data.textures)//Gather the source textures, resized into Color32 arrays
{
TexturePaintObject texturePaintObject = new TexturePaintObject();
texturePaintObject.pixels = ((Texture2D)btexture.texture).GetPixels32();
texturePaintObject.width = btexture.texture.width;
texturePaintObject.height = btexture.texture.height;
texturePaintObject.tiles = new Vector2(btexture.tiledX, btexture.tiledY);
if (btexture.tiled)
{
int resizedTextureWidth = Mathf.RoundToInt(btexture.textureUnitSize.x * PIXELS_PER_METER * packedScale);
int resizedTextureHeight = Mathf.RoundToInt(btexture.textureUnitSize.y * PIXELS_PER_METER * packedScale);
texturePaintObject.pixels = TextureScale.NearestNeighbourSample(texturePaintObject.pixels, texturePaintObject.width, texturePaintObject.height, resizedTextureWidth, resizedTextureHeight);
texturePaintObject.width = resizedTextureWidth;
texturePaintObject.height = resizedTextureHeight;
}
else
{
texturePaintObject.tiled = false;
}
buildSourceTextures.Add(texturePaintObject);
}
LogTimer("Gather Source into Arrays");
TexturePaintObject[] sourceTextures = buildSourceTextures.ToArray();
textures = data.textures.ToArray();
BuildrFacadeDesign facadeDesign = data.facades[0];
BuildrPlan plan = data.plan;
int numberOfVolumes = data.plan.numberOfVolumes;
int facadeNumber = 0;
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, indexB;
Vector3 p0, p1;
indexA = f;
indexB = (f < numberOfVolumePoints - 1) ? f + 1 : 0;
p0 = plan.points[volume.points[indexA]].vector3;
p1 = plan.points[volume.points[indexB]].vector3;
Rect packedPosition = packedTexturePositions[facadeNumber];
float facadeWidth = Vector3.Distance(p0, p1);
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;
BuildrVolumeStylesUnit[] styleUnits = volume.styles.GetContentsByFacade(volume.points[indexA]);
int floorPatternSize = 0;
List <int> facadePatternReference = new List <int>(); //this contains a list of all the facade style indices to refence when looking for the appropriate style per floor
int patternCount = 0;
foreach (BuildrVolumeStylesUnit styleUnit in styleUnits) //need to knw how big all the styles are together so we can loop through them
{
floorPatternSize += styleUnit.floors;
for (int i = 0; i < styleUnit.floors; i++)
{
facadePatternReference.Add(patternCount);
}
patternCount++;
}
facadePatternReference.Reverse();
int rows = numberOfFloors;
Vector2 bayBase = Vector2.zero;
float currentFloorBase = 0;
for (int r = 0; r < rows; r++)
{
currentFloorBase = floorHeight * r;
int modFloor = (r % floorPatternSize);
facadeDesign = data.facades[styleUnits[facadePatternReference[modFloor]].styleID];
bool isBlankWall = !facadeDesign.hasWindows;
if (facadeDesign.type == BuildrFacadeDesign.types.patterned)
{
BuildrBay firstBay = data.bays[facadeDesign.bayPattern[0]];
if (firstBay.openingWidth > facadeWidth)
{
isBlankWall = true;
}
if (facadeDesign.bayPattern.Count == 0)
{
isBlankWall = true;
}
}
else
{
if (facadeDesign.simpleBay.openingWidth + facadeDesign.simpleBay.minimumBayWidth > facadeWidth)
{
isBlankWall = true;
}
}
if (!isBlankWall)
{
float patternSize = 0;//the space the pattern fills, there will be a gap that will be distributed to all bay styles
int numberOfBays = 0;
BuildrBay[] bays;
int numberOfBayDesigns = 0;
if (facadeDesign.type == BuildrFacadeDesign.types.patterned)
{
numberOfBayDesigns = facadeDesign.bayPattern.Count;
bays = new BuildrBay[numberOfBayDesigns];
for (int i = 0; i < numberOfBayDesigns; i++)
{
bays[i] = data.bays[facadeDesign.bayPattern[i]];
}
}
else
{
bays = new[] { facadeDesign.simpleBay };
numberOfBayDesigns = 1;
}
//start with first window width - we'll be adding to this until we have filled the facade width
int it = 100;
while (true)
{
int patternModIndex = numberOfBays % numberOfBayDesigns;
float patternAddition = bays[patternModIndex].openingWidth + bays[patternModIndex].minimumBayWidth;
if (patternSize + patternAddition < facadeWidth)
{
patternSize += patternAddition;
numberOfBays++;
}
else
{
break;
}
it--;
if (it < 0)
{
break;
}
}
float perBayAdditionalSpacing = (facadeWidth - patternSize) / numberOfBays;
float windowXBase = 0;
for (int c = 0; c < numberOfBays; c++)
{
BuildrBay bayStyle;
if (facadeDesign.type == BuildrFacadeDesign.types.patterned)
{
int numberOfBayStyles = facadeDesign.bayPattern.Count;
bayStyle = bays[c % numberOfBayStyles];
}
else
{
bayStyle = facadeDesign.simpleBay;
}
float actualWindowSpacing = bayStyle.minimumBayWidth + perBayAdditionalSpacing;
float leftSpace = actualWindowSpacing * bayStyle.openingWidthRatio;
float rightSpace = actualWindowSpacing - leftSpace;
float openingSpace = bayStyle.openingWidth;
Vector3 bayDimensions;
int subMesh;
bool flipped;
if (!bayStyle.isOpening)
{
subMesh = bayStyle.GetTexture(BuildrBay.TextureNames.WallTexture);
flipped = bayStyle.IsFlipped(BuildrBay.TextureNames.WallTexture);
bayBase.x = windowXBase;
bayBase.y = currentFloorBase;
float bayWidth = (openingSpace + actualWindowSpacing);
float bayHeight = floorHeight;
bayDimensions = new Vector2(bayWidth, bayHeight);
DrawFacadeTexture(sourceTextures, bayBase, bayDimensions, subMesh, flipped, packedPosition);
windowXBase += bayWidth; //move base vertor to next bay
continue; //bay filled - move onto next bay
}
float rowBottomHeight = ((floorHeight - bayStyle.openingHeight) * bayStyle.openingHeightRatio);
float rowTopHeight = (floorHeight - rowBottomHeight - bayStyle.openingHeight);
//Window
subMesh = bayStyle.GetTexture(BuildrBay.TextureNames.OpeningBackTexture);
flipped = bayStyle.IsFlipped(BuildrBay.TextureNames.OpeningBackTexture);
bayBase.x = windowXBase + leftSpace;
bayBase.y = currentFloorBase + rowBottomHeight;
bayDimensions = new Vector2(bayStyle.openingWidth, bayStyle.openingHeight);
DrawFacadeTexture(sourceTextures, bayBase, bayDimensions, subMesh, flipped, packedPosition);
//Column Left
if (leftSpace > 0)
{
subMesh = bayStyle.GetTexture(BuildrBay.TextureNames.ColumnTexture);
flipped = bayStyle.IsFlipped(BuildrBay.TextureNames.ColumnTexture);
bayBase.x = windowXBase;
bayBase.y = currentFloorBase + rowBottomHeight;
bayDimensions = new Vector2(leftSpace, bayStyle.openingHeight);
DrawFacadeTexture(sourceTextures, bayBase, bayDimensions, subMesh, flipped, packedPosition);
}
//Column Right
if (rightSpace > 0)
{
subMesh = bayStyle.GetTexture(BuildrBay.TextureNames.ColumnTexture);
flipped = bayStyle.IsFlipped(BuildrBay.TextureNames.ColumnTexture);
bayBase.x = windowXBase + leftSpace + openingSpace;
bayBase.y = currentFloorBase + rowBottomHeight;
bayDimensions = new Vector2(rightSpace, bayStyle.openingHeight);
DrawFacadeTexture(sourceTextures, bayBase, bayDimensions, subMesh, flipped, packedPosition);
}
//Row Bottom
if (rowBottomHeight > 0)
{
subMesh = bayStyle.GetTexture(BuildrBay.TextureNames.RowTexture);
flipped = bayStyle.IsFlipped(BuildrBay.TextureNames.RowTexture);
bayBase.x = windowXBase + leftSpace;
bayBase.y = currentFloorBase;
bayDimensions = new Vector2(openingSpace, rowBottomHeight);
DrawFacadeTexture(sourceTextures, bayBase, bayDimensions, subMesh, flipped, packedPosition);
}
//Row Top
if (rowTopHeight > 0)
{
subMesh = bayStyle.GetTexture(BuildrBay.TextureNames.RowTexture);
flipped = bayStyle.IsFlipped(BuildrBay.TextureNames.RowTexture);
bayBase.x = windowXBase + leftSpace;
bayBase.y = currentFloorBase + rowBottomHeight + bayStyle.openingHeight;
bayDimensions = new Vector2(openingSpace, rowTopHeight);
DrawFacadeTexture(sourceTextures, bayBase, bayDimensions, subMesh, flipped, packedPosition);
}
//Cross Left
if (leftSpace > 0)
{
//Cross Left Bottom
subMesh = bayStyle.GetTexture(BuildrBay.TextureNames.CrossTexture);
flipped = bayStyle.IsFlipped(BuildrBay.TextureNames.CrossTexture);
bayBase.x = windowXBase;
bayBase.y = currentFloorBase;
bayDimensions = new Vector2(leftSpace, rowBottomHeight);
DrawFacadeTexture(sourceTextures, bayBase, bayDimensions, subMesh, flipped, packedPosition);
//Cross Left Top
subMesh = bayStyle.GetTexture(BuildrBay.TextureNames.CrossTexture);
flipped = bayStyle.IsFlipped(BuildrBay.TextureNames.CrossTexture);
bayBase.x = windowXBase;
bayBase.y = currentFloorBase + rowBottomHeight + bayStyle.openingHeight;
bayDimensions = new Vector2(leftSpace, rowTopHeight);
DrawFacadeTexture(sourceTextures, bayBase, bayDimensions, subMesh, flipped, packedPosition);
}
//Cross Right
if (rightSpace > 0)
{
//Cross Left Bottom
subMesh = bayStyle.GetTexture(BuildrBay.TextureNames.CrossTexture);
flipped = bayStyle.IsFlipped(BuildrBay.TextureNames.CrossTexture);
bayBase.x = windowXBase + leftSpace + openingSpace;
bayBase.y = currentFloorBase;
bayDimensions = new Vector2(rightSpace, rowBottomHeight);
DrawFacadeTexture(sourceTextures, bayBase, bayDimensions, subMesh, flipped, packedPosition);
//Cross Left Top
subMesh = bayStyle.GetTexture(BuildrBay.TextureNames.CrossTexture);
flipped = bayStyle.IsFlipped(BuildrBay.TextureNames.CrossTexture);
bayBase.x = windowXBase + leftSpace + openingSpace;
bayBase.y = currentFloorBase + rowBottomHeight + bayStyle.openingHeight;
bayDimensions = new Vector2(rightSpace, rowTopHeight);
DrawFacadeTexture(sourceTextures, bayBase, bayDimensions, subMesh, flipped, packedPosition);
}
windowXBase += leftSpace + openingSpace + rightSpace;//move base vertor to next bay
}
}
else
{
// windowless wall
int subMesh = facadeDesign.simpleBay.GetTexture(BuildrBay.TextureNames.WallTexture);
bool flipped = facadeDesign.simpleBay.IsFlipped(BuildrBay.TextureNames.WallTexture);
bayBase.x = 0;
bayBase.y = currentFloorBase;
Vector2 dimensions = new Vector2(facadeWidth, floorHeight);
DrawFacadeTexture(sourceTextures, bayBase, dimensions, subMesh, flipped, packedPosition);
}
}
facadeNumber++;
}
}
LogTimer("generate facade textures");
//add roof textures
int numberOfroofTextures = roofTextures.Count;
int scaledPadding = Mathf.FloorToInt(ATLAS_PADDING * packedScale);
for (int i = 0; i < numberOfroofTextures; i++)
{
Rect roofTexturePosition = packedTexturePositions[i + facadeNumber];
BuildrTexture bTexture = roofTextures[i];
int roofTextureWidth = bTexture.texture.width;
int roofTextureHeight = bTexture.texture.height;
int targetTextureWidth = Mathf.RoundToInt(roofTexturePosition.width);
int targetTextureHeight = Mathf.RoundToInt(roofTexturePosition.height);
if (bTexture.maxUVTile == Vector2.zero)
{
LogTimer("BuildTextures: Skip texture " + bTexture.name + " as it appears it's not used");
continue;
}
int sourceTextureWidth = Mathf.RoundToInt(targetTextureWidth / (bTexture.tiled ? bTexture.maxUVTile.x : bTexture.tiledX));
int sourceTextureHeight = Mathf.RoundToInt(targetTextureHeight / (bTexture.tiled ? bTexture.maxUVTile.y : bTexture.tiledY));
int sourceTextureSize = sourceTextureWidth * sourceTextureHeight;
if (sourceTextureSize == 0)
{
//Debug.Log(sourceTextureWidth+" "+sourceTextureHeight+" "+bTexture.tiledX+" "+bTexture.maxUVTile+" "+bTexture.tiledX+","+bTexture.tiledY);
continue;
}
Color32[] roofColourArray = TextureScale.NearestNeighbourSample(((Texture2D)bTexture.texture).GetPixels32(), roofTextureWidth, roofTextureHeight, sourceTextureWidth, sourceTextureHeight);
//Color32[] roofColourArray = bTexture.texture.GetPixels32();
for (int x = 0; x < targetTextureWidth; x++)
{
for (int y = 0; y < targetTextureHeight; y++)
{
int drawX = Mathf.FloorToInt(x + roofTexturePosition.x);
int drawY = Mathf.FloorToInt(y + roofTexturePosition.y);
int colourIndex = drawX + drawY * textureWidth;
int sx = x % sourceTextureWidth;
int sy = y % sourceTextureHeight;
int sourceIndex = sx + sy * sourceTextureWidth;
if (sourceIndex >= sourceTextureSize)
{
Debug.Log("Source Index too big " + sx + " " + sy + " " + sourceTextureWidth + " " + sourceTextureSize + " " + bTexture.maxUVTile + " " + bTexture.name);
}
Color32 sourceColour = roofColourArray[sourceIndex];
if (colourIndex >= textureSize)
{
Debug.Log("Output Index Too big " + drawX + " " + drawY + " " + colourIndex + " " + textureSize + " " + roofTexturePosition);
}
colourArray[colourIndex] = sourceColour;
//Padding
if (x == 0)
{
for (int p = 0; p < scaledPadding; p++)
{
colourArray[colourIndex - p] = sourceColour;
}
}
if (x == targetTextureWidth - 1)
{
for (int p = 0; p < scaledPadding; p++)
{
colourArray[colourIndex + p] = sourceColour;
}
}
if (y == 0)
{
for (int p = 0; p < scaledPadding; p++)
{
colourArray[colourIndex - (p * textureWidth)] = sourceColour;
}
}
if (y == targetTextureHeight - 1)
{
for (int p = 0; p < scaledPadding; p++)
{
colourArray[colourIndex + (p * textureWidth)] = sourceColour;
}
}
}
}
}
LogTimer("generate roof textures");
}
public BuildrFacadeDesign Duplicate()
{
BuildrFacadeDesign newDesign = new BuildrFacadeDesign();
newDesign.name = name + " copy";
newDesign.type = type;
newDesign.hasWindows = hasWindows;
newDesign.simpleBay = simpleBay.Duplicate();
newDesign.bayPattern = new List<int>(bayPattern);
//Legacy
newDesign.windowWidth = windowWidth;
newDesign.windowHeight = windowHeight;
newDesign.minimumWindowSpacing = minimumWindowSpacing;
newDesign.alternatingSpacing = alternatingSpacing;
newDesign.minimumWindowSpacingAlt = minimumWindowSpacingAlt;
newDesign.windowHeightRatio = windowHeightRatio;
newDesign.windowDepth = windowDepth;
newDesign.tilesx = tilesx;
newDesign.tilesy = tilesy;
newDesign.columnDepth = columnDepth;
newDesign.rowDepth = rowDepth;
newDesign.crossDepth = crossDepth;
newDesign.hasDoors = hasDoors;
newDesign.doorWidth = doorWidth;
newDesign.doorHeight = doorHeight;
newDesign.doorPosition = doorPosition;
newDesign.textureValues = (int[])textureValues.Clone();
newDesign.flipValues = (bool[])flipValues.Clone();
newDesign.wallTexture = wallTexture;
return newDesign;
}
private static void GenerateFacades(BuildrData data)
{
BuildrGenerateConstraints constraints = data.generatorConstraints;
RandomGen rgen = constraints.rgen;
//generate bays
//blank
BuildrBay blankBay = new BuildrBay("Blank");
blankBay.isOpening = false;
data.bays.Add(blankBay);
//door
BuildrBay doorBay = new BuildrBay("Door");
doorBay.openingHeight = data.floorHeight * 0.9f;
doorBay.openingHeightRatio = 0.0f;
float doorWidth = (doorTexture.texture.width / (float)doorTexture.texture.height) * doorBay.openingHeight;
doorBay.openingWidth = doorWidth;
doorBay.openingDepth = rgen.OutputRange(0.0f, 0.3f);
doorBay.SetTexture(BuildrBay.TextureNames.OpeningBackTexture, data.textures.IndexOf(doorTexture));
data.bays.Add(doorBay);
//ground window
BuildrBay groundWindow = new BuildrBay("Ground Window");
groundWindow.openingWidth = rgen.OutputRange(constraints.openingMinimumWidth, constraints.openingMaximumWidth);
groundWindow.openingHeight = rgen.OutputRange(constraints.openingMinimumHeight, Mathf.Min(data.floorHeight,constraints.openingMinimumHeight));
groundWindow.openingDepth = rgen.OutputRange(constraints.openingMinimumDepth, constraints.openingMaximumDepth);
groundWindow.openingHeightRatio = 0.8f;
data.bays.Add(groundWindow);
// BuildrTexture groundFloorWindowTexture = windowTexture.Duplicate("groundWindowTexture");
groundFloorWindowTexture.tiled = false;
groundFloorWindowTexture.tiledX = Mathf.RoundToInt(groundWindow.openingWidth / groundWindow.openingHeight);
int groundtextureIndex = data.textures.IndexOf(groundFloorWindowTexture);
// data.textures.Add(groundFloorWindowTexture);
groundWindow.SetTexture(BuildrBay.TextureNames.OpeningBackTexture, groundtextureIndex);
//other windows
BuildrBay windowBay = new BuildrBay("Window");
data.bays.Add(windowBay);
//util window
BuildrBay utilBay = new BuildrBay("Utility Window");
data.bays.Add(utilBay);
//generate facades
BuildrFacadeDesign basicFacadeDesign = new BuildrFacadeDesign("default");
basicFacadeDesign.simpleBay.openingWidth = rgen.OutputRange(constraints.openingMinimumWidth, constraints.openingMaximumWidth);
basicFacadeDesign.simpleBay.openingHeight = rgen.OutputRange(constraints.openingMinimumHeight, Mathf.Min(data.floorHeight, constraints.openingMinimumHeight));
basicFacadeDesign.simpleBay.openingDepth = rgen.OutputRange(constraints.openingMinimumDepth, constraints.openingMaximumDepth);
// float roughBaySize = basicFacadeDesign.simpleBay.openingHeight + basicFacadeDesign.simpleBay.openingWidth;
basicFacadeDesign.simpleBay.minimumBayWidth = rgen.OutputRange(constraints.minimumBayMaximumWidth,constraints.minimumBayMaximumWidth);
data.facades.Add(basicFacadeDesign);
//ground floor with and without door
BuildrFacadeDesign groundFloorDoor = new BuildrFacadeDesign("Ground Floor With Door");
groundFloorDoor.type = BuildrFacadeDesign.types.patterned;
int patternSize = rgen.OutputRange(1, 8);
for(int i = 0; i < patternSize; i++)
groundFloorDoor.bayPattern.Add(rgen.output>0.2f?2:0);
groundFloorDoor.bayPattern.Insert(rgen.OutputRange(0, patternSize), 1);//insert door into pattern
data.facades.Add(groundFloorDoor);
//couple of main facades
//utility/back wall facade
//maybe attic version
BuildrPlan plan = data.plan;
for(int v = 0; v < plan.numberOfVolumes; v++)
{
BuildrVolume volume = plan.volumes[v];
int numberOfFloors = volume.numberOfFloors;
volume.styles.Clear();
for(int f = 0; f < volume.points.Count; f++)
{
int facadeIndex = volume.points[f];
volume.styles.AddStyle(0, facadeIndex, numberOfFloors - 1);
volume.styles.AddStyle(1, facadeIndex, 1);
}
}
}
private static void GenerateFacades(BuildrData data)
{
BuildrGenerateConstraints constraints = data.generatorConstraints;
RandomGen rgen = constraints.rgen;
//generate bays
//blank
BuildrBay blankBay = new BuildrBay("Blank");
blankBay.isOpening = false;
data.bays.Add(blankBay);
//door
BuildrBay doorBay = new BuildrBay("Door");
doorBay.openingHeight = data.floorHeight * 0.9f;
doorBay.openingHeightRatio = 0.0f;
float doorWidth = (doorTexture.texture.width / (float)doorTexture.texture.height) * doorBay.openingHeight;
doorBay.openingWidth = doorWidth;
doorBay.openingDepth = rgen.OutputRange(0.0f, 0.3f);
doorBay.SetTexture(BuildrBay.TextureNames.OpeningBackTexture, data.textures.IndexOf(doorTexture));
data.bays.Add(doorBay);
//ground window
BuildrBay groundWindow = new BuildrBay("Ground Window");
groundWindow.openingWidth = rgen.OutputRange(constraints.openingMinimumWidth, constraints.openingMaximumWidth);
groundWindow.openingHeight = rgen.OutputRange(constraints.openingMinimumHeight, Mathf.Min(data.floorHeight, constraints.openingMinimumHeight));
groundWindow.openingDepth = rgen.OutputRange(constraints.openingMinimumDepth, constraints.openingMaximumDepth);
groundWindow.openingHeightRatio = 0.8f;
data.bays.Add(groundWindow);
// BuildrTexture groundFloorWindowTexture = windowTexture.Duplicate("groundWindowTexture");
groundFloorWindowTexture.tiled = false;
groundFloorWindowTexture.tiledX = Mathf.RoundToInt(groundWindow.openingWidth / groundWindow.openingHeight);
int groundtextureIndex = data.textures.IndexOf(groundFloorWindowTexture);
// data.textures.Add(groundFloorWindowTexture);
groundWindow.SetTexture(BuildrBay.TextureNames.OpeningBackTexture, groundtextureIndex);
//other windows
BuildrBay windowBay = new BuildrBay("Window");
data.bays.Add(windowBay);
//util window
BuildrBay utilBay = new BuildrBay("Utility Window");
data.bays.Add(utilBay);
//generate facades
BuildrFacadeDesign basicFacadeDesign = new BuildrFacadeDesign("default");
basicFacadeDesign.simpleBay.openingWidth = rgen.OutputRange(constraints.openingMinimumWidth, constraints.openingMaximumWidth);
basicFacadeDesign.simpleBay.openingHeight = rgen.OutputRange(constraints.openingMinimumHeight, Mathf.Min(data.floorHeight, constraints.openingMinimumHeight));
basicFacadeDesign.simpleBay.openingDepth = rgen.OutputRange(constraints.openingMinimumDepth, constraints.openingMaximumDepth);
// float roughBaySize = basicFacadeDesign.simpleBay.openingHeight + basicFacadeDesign.simpleBay.openingWidth;
basicFacadeDesign.simpleBay.minimumBayWidth = rgen.OutputRange(constraints.minimumBayMaximumWidth, constraints.minimumBayMaximumWidth);
data.facades.Add(basicFacadeDesign);
//ground floor with and without door
BuildrFacadeDesign groundFloorDoor = new BuildrFacadeDesign("Ground Floor With Door");
groundFloorDoor.type = BuildrFacadeDesign.types.patterned;
int patternSize = rgen.OutputRange(1, 8);
for (int i = 0; i < patternSize; i++)
{
groundFloorDoor.bayPattern.Add(rgen.output > 0.2f?2:0);
}
groundFloorDoor.bayPattern.Insert(rgen.OutputRange(0, patternSize), 1);//insert door into pattern
data.facades.Add(groundFloorDoor);
//couple of main facades
//utility/back wall facade
//maybe attic version
BuildrPlan plan = data.plan;
for (int v = 0; v < plan.numberOfVolumes; v++)
{
BuildrVolume volume = plan.volumes[v];
int numberOfFloors = volume.numberOfFloors;
volume.styles.Clear();
for (int f = 0; f < volume.points.Count; f++)
{
int facadeIndex = volume.points[f];
volume.styles.AddStyle(0, facadeIndex, numberOfFloors - 1);
volume.styles.AddStyle(1, facadeIndex, 1);
}
}
}
public static void Build(DynamicMeshGenericMultiMaterialMesh _mesh, BuildrData _data, int volumeIndex)
{
data = _data;
mesh = _mesh;
mesh.name = "Interior Mesh Volume " + volumeIndex;
textures = data.textures.ToArray();
if (!data.renderInteriors)
{
return;
}
float largestDepthValue = 0;//deepest value of a bay design in the building
float tallestBay = 0;
foreach (BuildrBay bay in data.bays)
{
largestDepthValue = Mathf.Max(largestDepthValue, bay.deepestValue);//get the deepest value
tallestBay = Mathf.Max(tallestBay, bay.openingHeight + (data.floorHeight - bay.openingHeight) * bay.openingHeightRatio);
}
foreach (BuildrFacadeDesign facade in data.facades)
{
if (facade.type != BuildrFacadeDesign.types.simple)
{
continue;
}
largestDepthValue = Mathf.Max(largestDepthValue, facade.simpleBay.deepestValue);//get the deepest value
if (facade.simpleBay.isOpening)
{
tallestBay = Mathf.Max(tallestBay, facade.simpleBay.openingHeight + (data.floorHeight - facade.simpleBay.openingHeight) * facade.simpleBay.openingHeightRatio);
}
}
BuildrFacadeDesign facadeDesign = data.facades[0];
BuildrPlan plan = data.plan;
BuildrVolume volume = plan.volumes[volumeIndex];
int numberOfFloors = volume.numberOfFloors;
float floorHeight = data.floorHeight;
Vector3 floorHeightVector = Vector3.up * floorHeight;
float ceilingHeight = tallestBay + (floorHeight - tallestBay) * data.interiorCeilingHeight;
//Calculate the internal floor plan points
int numberOfVolumePoints = volume.points.Count;
Vector2z[] interiorVolumePoints = new Vector2z[numberOfVolumePoints];
for (int i = 0; i < numberOfVolumePoints; i++)
{
Vector3 lastPoint = plan.points[volume.points[(i > 0) ? i - 1 : numberOfVolumePoints - 1]].vector3;
Vector3 thisPoint = plan.points[volume.points[i]].vector3;
Vector3 nextPoint = plan.points[volume.points[(i + 1) % numberOfVolumePoints]].vector3;
Vector3 normalA = Vector3.Cross(thisPoint - lastPoint, Vector3.up).normalized;
Vector3 normalB = Vector3.Cross(nextPoint - thisPoint, Vector3.up).normalized;
Vector2z facadeALine = new Vector2z(thisPoint - lastPoint);
Vector2z facadeBLine = new Vector2z(thisPoint - nextPoint);
//Calculate facade inner origins for floors
Vector3 facadeOriginV3A = lastPoint + normalA * largestDepthValue;
Vector3 facadeOriginV3B = nextPoint + normalB * largestDepthValue;
Vector2z facadeOriginA = new Vector2z(facadeOriginV3A);
Vector2z facadeOriginB = new Vector2z(facadeOriginV3B);
Vector2z facadeLineIntersection = BuildrUtils.FindIntersection(facadeALine, facadeOriginA, facadeBLine, facadeOriginB);
interiorVolumePoints[i] = facadeLineIntersection;
}
List <Vector2z> interiorVolumePointList = new List <Vector2z>(interiorVolumePoints);
List <Rect> volumeCores = new List <Rect>();
List <int> linkedPoints = new List <int>();
foreach (Rect core in plan.cores)
{
Vector2z coreCenter = new Vector2z(core.center);
if (BuildrUtils.PointInsidePoly(coreCenter, interiorVolumePoints))
{
volumeCores.Add(core);
}
}
int numberOfVolumeCores = volumeCores.Count;
bool print = plan.volumes.IndexOf(volume) == 3;
for (int c = 0; c < numberOfVolumeCores; c++)
{
int numberOfInteriorPoints = interiorVolumePointList.Count;
Rect coreBounds = volumeCores[c];
Vector2z coreCenter = new Vector2z(coreBounds.center);
Vector2z coreBL = new Vector2z(coreBounds.xMin, coreBounds.yMin);
Vector2z coreBR = new Vector2z(coreBounds.xMax, coreBounds.yMin);
Vector2z coreTL = new Vector2z(coreBounds.xMin, coreBounds.yMax);
Vector2z coreTR = new Vector2z(coreBounds.xMax, coreBounds.yMax);
Vector2z[] corePointArray;
corePointArray = new[] { coreBL, coreBR, coreTR, coreTL };
//Find the nearest legal cut we can make to join the core and interior point poly
int connectingPoint = -1;
float connectingPointDistance = Mathf.Infinity;
for (int p = 0; p < numberOfInteriorPoints; p++)
{
if (linkedPoints.Contains(p))
{
continue;
}
Vector2z thisPoint = interiorVolumePointList[p];
float thisPointDistance = Vector2z.SqrMag(thisPoint, coreCenter);
if (thisPointDistance < connectingPointDistance)
{
bool legalCut = true;
for (int pc = 0; pc < numberOfInteriorPoints; pc++)
{
Vector2z p0 = interiorVolumePointList[pc];
Vector2z p1 = interiorVolumePointList[(pc + 1) % numberOfInteriorPoints];
if (BuildrUtils.FastLineIntersection(coreCenter, thisPoint, p0, p1))//check against all lines that this new cut doesn't intersect
{
if (print)
{
Debug.Log("FLI " + pc + " " + coreCenter + " " + thisPoint + " " + p0 + " " + p1);
}
legalCut = false;
break;
}
}
if (legalCut)
{
connectingPoint = p;
connectingPointDistance = thisPointDistance;
}
}
}
if (connectingPoint == -1)
{
Debug.Log("Buildr Could not place core");
continue;
}
Vector2z chosenPoint = interiorVolumePointList[connectingPoint];
int connectingCorePoint = 0;
float connectingCorePointDistance = Mathf.Infinity; // Vector2z.SqrMag(corePointArray[0], chosenPoint);
for (int cp = 0; cp < 4; cp++) //find the core point to make the cut
{
float thisCorePointDistance = Vector2z.SqrMag(corePointArray[cp], chosenPoint);
if (thisCorePointDistance < connectingCorePointDistance)
{
connectingCorePoint = cp;
connectingCorePointDistance = thisCorePointDistance;
}
}
interiorVolumePointList.Insert(connectingPoint, chosenPoint); //loop back on the floorplan to close it
for (int acp = 0; acp < 5; acp++) //loop back on itself to close the core
{
interiorVolumePointList.Insert(connectingPoint + 1, corePointArray[(connectingCorePoint + acp) % 4]);
}
for (int i = 0; i < linkedPoints.Count; i++)
{
if (linkedPoints[i] > connectingPoint)
{
linkedPoints[i] += 7;
}
}
linkedPoints.AddRange(new[] { connectingPoint, connectingPoint + 1, connectingPoint + 2, connectingPoint + 3, connectingPoint + 4, connectingPoint + 5, connectingPoint + 6 });
// linkedPoints.AddRange(new []{connectingPoint,connectingPoint+6});
}
// if(linkedPoints.Count > 0)
// Debug.Log(linkedPoints.Count+" "+linkedPoints[0]);
Vector2z[] interiorPointListCore = interiorVolumePointList.ToArray();
for (int f = 0; f < numberOfVolumePoints; f++)
{
///WALLS
int indexAM = Mathf.Abs((f - 1) % numberOfVolumePoints);
int indexA = f;
int indexB = (f + 1) % numberOfVolumePoints;
int indexBP = (f + 2) % numberOfVolumePoints;
Vector3 p0m = plan.points[volume.points[indexAM]].vector3;
Vector3 p0 = plan.points[volume.points[indexA]].vector3;
Vector3 p1 = plan.points[volume.points[indexB]].vector3;
Vector3 p1p = plan.points[volume.points[indexBP]].vector3;
Vector3 p0interior = interiorVolumePoints[indexA].vector3;
Vector3 p1interior = interiorVolumePoints[indexB].vector3;
float facadeWidth = Vector3.Distance(p0, p1) - largestDepthValue * 2.0f;
Vector3 facadeDirection = (p1 - p0).normalized;
Vector3 facadeCross = Vector3.Cross(facadeDirection, Vector3.up);
Vector3 lastFacadeDirection = (p0 - p0m).normalized;
Vector3 nextFacadeDirection = (p1p - p1).normalized;
//only bother with facade directions when facade may intersect inverted geometry
float facadeDirDotL = Vector3.Dot(-facadeDirection, lastFacadeDirection);
float facadeCrossDotL = Vector3.Dot(-facadeCross, lastFacadeDirection);
if (facadeDirDotL <= 0 || facadeCrossDotL <= 0)
{
lastFacadeDirection = -facadeCross;
}
float facadeDirDotN = Vector3.Dot(-facadeDirection, nextFacadeDirection);
float facadeCrossDotN = Vector3.Dot(-facadeCross, nextFacadeDirection);
if (facadeDirDotN <= 0 || facadeCrossDotN <= 0)
{
nextFacadeDirection = facadeCross;
}
int floorBase = plan.GetFacadeFloorHeight(volumeIndex, volume.points[indexA], volume.points[indexB]);
BuildrVolumeStylesUnit[] styleUnits = volume.styles.GetContentsByFacade(volume.points[indexA]);
int floorPatternSize = 0;
List <int> facadePatternReference = new List <int>(); //this contains a list of all the facade style indices to refence when looking for the appropriate style per floor
int patternCount = 0;
foreach (BuildrVolumeStylesUnit styleUnit in styleUnits) //need to knw how big all the styles are together so we can loop through them
{
floorPatternSize += styleUnit.floors;
for (int i = 0; i < styleUnit.floors; i++)
{
facadePatternReference.Add(patternCount);
}
patternCount++;
}
facadePatternReference.Reverse();
int rows = numberOfFloors;
Vector2 facadeUV = Vector2.zero;
for (int r = 0; r < rows; r++)
{
float currentFloorHeight = floorHeight * r;
Vector3 currentFloorHeightVector = Vector3.up * (data.floorHeight * r);
Vector3 facadeFloorBaseVector = p0 + Vector3.up * currentFloorHeight;
Vector3 ceilingVector = Vector3.up * ceilingHeight;
if (r < floorBase)
{
//no facade rendered
//facade gap filler
//interior gap points
Vector3 i0 = p1 - facadeDirection.normalized * largestDepthValue;
Vector3 i1 = p0 + facadeDirection.normalized * largestDepthValue;
Vector3 w0 = i0 + currentFloorHeightVector;
Vector3 w1 = i1 + currentFloorHeightVector;
Vector3 w2 = w0 + facadeCross * largestDepthValue;
Vector3 w3 = w1 + facadeCross * largestDepthValue;
Vector3 w4 = w0 + ceilingVector;
Vector3 w5 = w1 + ceilingVector;
Vector3 w6 = w2 + ceilingVector;
Vector3 w7 = w3 + ceilingVector;
Vector3 w8 = p1interior + currentFloorHeightVector;
Vector3 w9 = p0interior + currentFloorHeightVector;
Vector3 w10 = w8 + ceilingVector;
Vector3 w11 = w9 + ceilingVector;
//floor
AddData(new[] { w0, w1, w2, w3 }, new[] { 0, 1, 2, 1, 3, 2 }, volume.FloorTexture(r), false);
//ceiling
AddData(new[] { w5, w4, w7, w6 }, new[] { 0, 1, 2, 1, 3, 2 }, volume.CeilingTexture(r), false);
//sides
int wallSubmesh = volume.WallTexture(r);
AddPlane(w0, w2, w4, w6, wallSubmesh, false, Vector3.zero, new Vector2(largestDepthValue, floorHeight));
AddPlane(w3, w1, w7, w5, wallSubmesh, false, Vector3.zero, new Vector2(largestDepthValue, floorHeight));
//other gaps
float uvWidth1 = Vector3.Distance(w2, w8);
AddPlane(w2, w8, w6, w10, wallSubmesh, false, Vector3.zero, new Vector2(uvWidth1, floorHeight));
float uvWidth2 = Vector3.Distance(w3, w9);
AddPlane(w9, w3, w11, w7, wallSubmesh, false, Vector3.zero, new Vector2(uvWidth2, floorHeight));
continue;
}
//Get the facade style id
//need to loop through the facade designs floor by floor until we get to the right one
int modFloor = ((r - floorBase) % floorPatternSize);
facadeDesign = data.facades[styleUnits[facadePatternReference[modFloor]].styleID];
bool isBlankWall = !facadeDesign.hasWindows;
if (facadeDesign.type == BuildrFacadeDesign.types.patterned)
{
if (data.bays.Count == 0 || facadeDesign.bayPattern.Count == 0)
{
data.illegal = true;
return;
}
BuildrBay firstBay = data.bays[facadeDesign.bayPattern[0]];
if (firstBay.openingWidth > facadeWidth)
{
isBlankWall = true;
}
if (facadeDesign.bayPattern.Count == 0)
{
isBlankWall = true;
}
}
else
{
if (facadeDesign.simpleBay.openingWidth + facadeDesign.simpleBay.minimumBayWidth > facadeWidth)
{
isBlankWall = true;
}
}
if (!isBlankWall)
{
float patternSize = 0;//the space the pattern fills, there will be a gap that will be distributed to all bay styles
int numberOfBays = 0;
BuildrBay[] bayDesignPattern;
int numberOfBayDesigns;
if (facadeDesign.type == BuildrFacadeDesign.types.patterned)
{
numberOfBayDesigns = facadeDesign.bayPattern.Count;
bayDesignPattern = new BuildrBay[numberOfBayDesigns];
for (int i = 0; i < numberOfBayDesigns; i++)
{
bayDesignPattern[i] = data.bays[facadeDesign.bayPattern[i]];
}
}
else
{
bayDesignPattern = new[] { facadeDesign.simpleBay };
numberOfBayDesigns = 1;
}
//start with first window width - we'll be adding to this until we have filled the facade width
int it = 100;
while (true)
{
int patternModIndex = numberOfBays % numberOfBayDesigns;
float patternAddition = bayDesignPattern[patternModIndex].openingWidth + bayDesignPattern[patternModIndex].minimumBayWidth;
if (patternSize + patternAddition < facadeWidth)
{
patternSize += patternAddition;
numberOfBays++;
}
else
{
break;
}
it--;
if (it < 0)
{
break;
}
}
Vector3 windowBase = facadeFloorBaseVector;
facadeUV.x = 0;
facadeUV.y += floorHeight;
float perBayAdditionalSpacing = (facadeWidth - patternSize) / numberOfBays;
for (int c = 0; c < numberOfBays; c++)
{
BuildrBay bayStyle;
BuildrBay lastBay;
BuildrBay nextBay;
bool firstColumn = c == 0;
bool lastColumn = c == numberOfBays - 1;
if (facadeDesign.type == BuildrFacadeDesign.types.patterned)
{
int numberOfBayStyles = facadeDesign.bayPattern.Count;
bayStyle = bayDesignPattern[c % numberOfBayStyles];
int lastBayIndex = (c > 0) ? (c - 1) % numberOfBayStyles : 0;
lastBay = bayDesignPattern[lastBayIndex];
nextBay = bayDesignPattern[(c + 1) % numberOfBayStyles];
}
else
{
bayStyle = facadeDesign.simpleBay;
lastBay = facadeDesign.simpleBay;
nextBay = facadeDesign.simpleBay;
}
float actualWindowSpacing = bayStyle.minimumBayWidth + perBayAdditionalSpacing;
float leftWidth = actualWindowSpacing * bayStyle.openingWidthRatio;
float rightWidth = actualWindowSpacing - leftWidth;
float openingWidth = bayStyle.openingWidth;
if (firstColumn)
{
leftWidth += largestDepthValue;
}
if (lastColumn)
{
rightWidth += largestDepthValue;
}
BuildrTexture columnTexture = textures[bayStyle.GetTexture(BuildrBay.TextureNames.ColumnTexture)];
Vector2 columnuvunits = columnTexture.tileUnitUV;
float openingHeight = bayStyle.openingHeight;
if (columnTexture.patterned)
{
openingHeight = Mathf.Ceil(bayStyle.openingHeight / columnuvunits.y) * columnuvunits.y;
}
if (bayStyle.openingHeight == floorHeight)
{
bayStyle.openingHeight = floorHeight;
}
float rowBottomHeight = ((floorHeight - openingHeight) * bayStyle.openingHeightRatio);
if (columnTexture.patterned)
{
rowBottomHeight = Mathf.Ceil(rowBottomHeight / columnuvunits.y) * columnuvunits.y;
}
float rowTopHeight = (floorHeight - rowBottomHeight - openingHeight);
bool previousBayIdentical = bayStyle == lastBay;
bool nextBayIdentical = bayStyle == nextBay;
if (previousBayIdentical && !firstColumn)
{
leftWidth = actualWindowSpacing;//if next design is identical - add the two parts together the reduce polycount
}
Vector3 w0, w1, w2, w3;
int wallSubmesh = volume.WallTexture(r);
bool wallFlipped = false;
if (!bayStyle.isOpening)
{
float bayWidthSize = openingWidth + actualWindowSpacing;
if (firstColumn || lastColumn)
{
bayWidthSize += largestDepthValue;
}
Vector3 bayWidth = facadeDirection * bayWidthSize;
Vector3 bayHeight = Vector3.up * floorHeight;
Vector3 bayDepth = facadeCross * largestDepthValue;
w0 = windowBase + bayDepth;
w1 = windowBase + bayWidth + bayDepth;
w2 = windowBase + bayHeight + bayDepth;
w3 = windowBase + bayWidth + bayHeight + bayDepth;
Vector2 bayOpeningUVEnd = facadeUV + new Vector2(openingWidth + actualWindowSpacing, floorHeight);
AddPlane(w0, w1, w2, w3, wallSubmesh, wallFlipped, facadeUV, bayOpeningUVEnd);
windowBase = windowBase + bayWidth; //move base vertor to next bay
facadeUV.x += openingWidth + actualWindowSpacing;
continue; //bay filled - move onto next bay
}
var verts = new Vector3[16];
verts[0] = windowBase;
verts[1] = verts[0] + leftWidth * facadeDirection;
verts[2] = verts[1] + openingWidth * facadeDirection;
verts[3] = verts[2] + rightWidth * facadeDirection;
windowBase = (nextBayIdentical) ? verts[2] : verts[3];//move to next window - if next design is identical - well add the two parts together the reduce polycount
facadeUV.x += (nextBayIdentical) ? openingWidth : openingWidth + rightWidth;
Vector3 rowBottomVector = Vector3.up * rowBottomHeight;
verts[4] = verts[0] + rowBottomVector;
verts[5] = verts[1] + rowBottomVector;
verts[6] = verts[2] + rowBottomVector;
verts[7] = verts[3] + rowBottomVector;
Vector3 openingVector = Vector3.up * openingHeight;
verts[8] = verts[4] + openingVector;
verts[9] = verts[5] + openingVector;
verts[10] = verts[6] + openingVector;
verts[11] = verts[7] + openingVector;
Vector3 rowTopVector = Vector3.up * rowTopHeight;
verts[12] = verts[8] + rowTopVector;
verts[13] = verts[9] + rowTopVector;
verts[14] = verts[10] + rowTopVector;
verts[15] = verts[11] + rowTopVector;
//Realign facade end points
if (firstColumn)
{
verts[0] = p0interior - facadeCross * largestDepthValue + currentFloorHeightVector;
verts[4] = verts[0] + rowBottomVector;
verts[8] = verts[4] + openingVector;
verts[12] = verts[8] + rowTopVector;
}
if (lastColumn)
{
verts[3] = p1interior - facadeCross * largestDepthValue + currentFloorHeightVector;
verts[7] = verts[3] + rowBottomVector;
verts[11] = verts[7] + openingVector;
verts[15] = verts[11] + rowTopVector;
}
Vector3 openingDepthVector = facadeCross * bayStyle.openingDepth;
Vector3 wallDepthVecotr = facadeCross * largestDepthValue;
///WINDOWS
int windowSubmesh = bayStyle.GetTexture(BuildrBay.TextureNames.OpeningBackTexture);
bool windowFlipped = bayStyle.IsFlipped(BuildrBay.TextureNames.OpeningBackTexture);
w0 = verts[10] + openingDepthVector;
w1 = verts[9] + openingDepthVector;
w2 = verts[6] + openingDepthVector;
w3 = verts[5] + openingDepthVector;
Vector2 windowUVStart = new Vector2(0, 0);
Vector2 windowUVEnd = new Vector2(openingWidth, openingHeight);
if (bayStyle.renderBack && !data.cullBays)
{
AddPlane(w0, w1, w2, w3, windowSubmesh, windowFlipped, windowUVStart, windowUVEnd);
}
///COLUMNS
//Column Face
if (leftWidth > 0)//Column Face Left
{
w0 = verts[4] + wallDepthVecotr;
w1 = verts[5] + wallDepthVecotr;
w2 = verts[8] + wallDepthVecotr;
w3 = verts[9] + wallDepthVecotr;
Vector2 leftColumnUVStart = facadeUV + new Vector2(0, rowBottomHeight);
Vector2 leftColumnUVEnd = leftColumnUVStart + new Vector2(leftWidth, openingHeight);
AddPlane(w0, w1, w2, w3, wallSubmesh, wallFlipped, leftColumnUVStart, leftColumnUVEnd);
}
if ((!nextBayIdentical || lastColumn) && rightWidth > 0)//Column Right
{
w0 = verts[6] + wallDepthVecotr;
w1 = verts[7] + wallDepthVecotr;
w2 = verts[10] + wallDepthVecotr;
w3 = verts[11] + wallDepthVecotr;
Vector2 rightColumnUVStart = facadeUV + new Vector2(leftWidth + openingWidth, rowBottomHeight);
Vector2 rightColumnUVEnd = rightColumnUVStart + new Vector2(rightWidth, openingHeight);
AddPlane(w0, w1, w2, w3, wallSubmesh, wallFlipped, rightColumnUVStart, rightColumnUVEnd);
}
///ROWS
//Row Bottom
if (rowBottomHeight > 0)
{
w0 = verts[1] + wallDepthVecotr;
w1 = verts[2] + wallDepthVecotr;
w2 = verts[5] + wallDepthVecotr;
w3 = verts[6] + wallDepthVecotr;
Vector2 bottomRowUVStart = facadeUV + new Vector2(leftWidth, 0);
Vector2 bottomRowUVEnd = bottomRowUVStart + new Vector2(openingWidth, rowBottomHeight);
AddPlane(w0, w1, w2, w3, wallSubmesh, wallFlipped, bottomRowUVStart, bottomRowUVEnd);
}
//Row Top
if (rowTopHeight > 0)
{
w0 = verts[9] + wallDepthVecotr;
w1 = verts[10] + wallDepthVecotr;
w2 = verts[13] + wallDepthVecotr;
w3 = verts[14] + wallDepthVecotr;
Vector2 topRowUVStart = facadeUV + new Vector2(leftWidth, rowBottomHeight + openingHeight);
Vector2 topRowUVEnd = topRowUVStart + new Vector2(openingWidth, rowTopHeight);
AddPlane(w0, w1, w2, w3, wallSubmesh, wallFlipped, topRowUVStart, topRowUVEnd);
}
//Cross Left Bottom
w0 = verts[0] + wallDepthVecotr;
w1 = verts[1] + wallDepthVecotr;
w2 = verts[4] + wallDepthVecotr;
w3 = verts[5] + wallDepthVecotr;
Vector2 crossLBUVStart = facadeUV + new Vector2(0, 0);
Vector2 crossLBUVEnd = crossLBUVStart + new Vector2(leftWidth, rowBottomHeight);
AddPlane(w0, w1, w2, w3, wallSubmesh, wallFlipped, crossLBUVStart, crossLBUVEnd);
//Cross Left Top
w0 = verts[8] + wallDepthVecotr;
w1 = verts[9] + wallDepthVecotr;
w2 = verts[12] + wallDepthVecotr;
w3 = verts[13] + wallDepthVecotr;
Vector2 crossLTUVStart = facadeUV + new Vector2(0, rowBottomHeight + openingHeight);
Vector2 crossLTUVEnd = crossLTUVStart + new Vector2(leftWidth, rowTopHeight);
AddPlane(w0, w1, w2, w3, wallSubmesh, wallFlipped, crossLTUVStart, crossLTUVEnd);
if ((!nextBayIdentical || lastColumn) && rightWidth > 0)
{
//Cross Right Bottom
w0 = verts[2] + wallDepthVecotr;
w1 = verts[3] + wallDepthVecotr;
w2 = verts[6] + wallDepthVecotr;
w3 = verts[7] + wallDepthVecotr;
Vector2 crossRBUVStart = facadeUV + new Vector2(leftWidth + openingWidth, 0);
Vector2 crossRBUVEnd = crossRBUVStart + new Vector2(rightWidth, rowBottomHeight);
AddPlane(w0, w1, w2, w3, wallSubmesh, wallFlipped, crossRBUVStart, crossRBUVEnd);
//Cross Right Top
w0 = verts[10] + wallDepthVecotr;
w1 = verts[11] + wallDepthVecotr;
w2 = verts[14] + wallDepthVecotr;
w3 = verts[15] + wallDepthVecotr;
Vector2 crossRTUVStart = facadeUV + new Vector2(leftWidth + openingWidth, rowBottomHeight + openingHeight);
Vector2 crossRTUVEnd = crossRTUVStart + new Vector2(rightWidth, rowTopHeight);
AddPlane(w0, w1, w2, w3, wallSubmesh, wallFlipped, crossRTUVStart, crossRTUVEnd);
}
}
}
else
{
// windowless wall
Vector3 interiorStart = p0interior + currentFloorHeightVector;
Vector3 interiorEnd = p1interior + currentFloorHeightVector;
// Vector3 wallVector = (facadeDirection * facadeWidth);
Vector3 wallHeightVector = Vector3.up * floorHeight;
Vector3 w0 = interiorStart;
Vector3 w1 = interiorEnd;
Vector3 w2 = interiorStart + wallHeightVector;
Vector3 w3 = interiorEnd + wallHeightVector;
BuildrTexture texture = textures[facadeDesign.simpleBay.GetTexture(BuildrBay.TextureNames.WallTexture)];
var uvSize = new Vector2(facadeWidth * (1.0f / texture.textureUnitSize.x), floorHeight * (1.0f / texture.textureUnitSize.y));
Vector2 uvunits = texture.tileUnitUV;
uvSize.x = Mathf.Ceil(uvSize.x / uvunits.x) * uvunits.x;
uvSize.y = Mathf.Ceil(uvSize.y / uvunits.y) * uvunits.y;
int wallSubmesh = 0;
bool flipped = false;
Vector2 wallUVStart = facadeUV;
Vector2 wallUVEnd = facadeUV + new Vector2(facadeWidth, floorHeight);
AddPlane(w0, w1, w2, w3, wallSubmesh, flipped, wallUVStart, wallUVEnd);
}
}
}
///FLOORS AND CEILING
int numberOfBasements = volume.numberOfBasementFloors;
int numberOfFloorPoints = interiorVolumePoints.Length;
int[] baseFloorPlanTriangles = EarClipper.Triangulate(interiorVolumePoints);
int baseFloorVectors = interiorVolumePoints.Length;
var newEndVerts = new Vector3[baseFloorVectors];
Vector3 basementBaseDrop = -floorHeightVector * numberOfBasements;
for (int i = 0; i < baseFloorVectors; i++)
{
newEndVerts[i] = interiorVolumePoints[i].vector3 + basementBaseDrop;
}
var tris = new List <int>(baseFloorPlanTriangles);
//Bottom Floor
int floorSubmesh = volume.FloorTexture(-numberOfBasements);
AddData(newEndVerts, baseFloorPlanTriangles, floorSubmesh, false);
//Top Ceiling
if (true)//Todo: add conditional for roof opening
{
Vector3 ceilingHeightVector = floorHeightVector * (numberOfFloors - 1 + numberOfBasements) + Vector3.up * ceilingHeight;
for (int i = 0; i < baseFloorVectors; i++)
{
newEndVerts[i] += ceilingHeightVector;
}
tris.Reverse();
AddData(newEndVerts, tris.ToArray(), volume.CeilingTexture(numberOfFloors - 1), false);
}
//inner floors
int[] floorPlanTriangles = EarClipper.Triangulate(interiorPointListCore);
int numberOfFloorVectors = interiorPointListCore.Length;
for (int floorIndex = -numberOfBasements; floorIndex < numberOfFloors; floorIndex++)
{
Vector3 floorVectorHeight = floorHeightVector * floorIndex;
newEndVerts = new Vector3[numberOfFloorVectors];
for (int i = 0; i < numberOfFloorVectors; i++)
{
newEndVerts[i] = interiorPointListCore[i].vector3 + floorVectorHeight;
}
tris = new List <int>(floorPlanTriangles);
//Floor
if (floorIndex > -numberOfBasements)
{
AddData(newEndVerts, tris.ToArray(), volume.FloorTexture(floorIndex), false);
}
//Ceiling
if (floorIndex < numberOfFloors - 1)
{
Vector3 ceilingHeightVector = Vector3.up * ceilingHeight;
for (int i = 0; i < numberOfFloorVectors; i++)
{
newEndVerts[i] += ceilingHeightVector;
}
tris.Reverse();
AddData(newEndVerts, tris.ToArray(), volume.CeilingTexture(floorIndex), false);
}
//basement walls
if (floorIndex < 0)
{
for (int f = 0; f < numberOfFloorPoints; f++)
{
Vector3 basementVector = floorHeightVector * floorIndex;
int indexA = f;
int indexB = (f + 1) % numberOfFloorPoints;
Vector3 p0 = interiorVolumePoints[indexA].vector3 + basementVector;
Vector3 p1 = interiorVolumePoints[indexB].vector3 + basementVector;
Vector3 p2 = p0 + floorHeightVector;
Vector3 p3 = p1 + floorHeightVector;
Vector2 uv1 = new Vector2(Vector3.Distance(p0, p1), floorHeight);
AddPlane(p0, p1, p2, p3, volume.WallTexture(floorIndex), false, Vector2.zero, uv1);
}
}
}
//Core walls
for (int c = 0; c < numberOfVolumeCores; c++)
{
Rect coreBounds = volumeCores[c];
Vector3 coreBL = new Vector3(coreBounds.xMin, 0, coreBounds.yMin);
Vector3 coreBR = new Vector3(coreBounds.xMax, 0, coreBounds.yMin);
Vector3 coreTL = new Vector3(coreBounds.xMin, 0, coreBounds.yMax);
Vector3 coreTR = new Vector3(coreBounds.xMax, 0, coreBounds.yMax);
for (int floorIndex = -numberOfBasements; floorIndex < numberOfFloors - 1; floorIndex++)
{
Vector3 c0 = floorHeightVector * floorIndex + Vector3.up * ceilingHeight;
Vector3 f0 = floorHeightVector * floorIndex + Vector3.up * floorHeight;
float gapHeight = floorHeight - ceilingHeight;
AddPlane(coreBL + c0, coreBR + c0, coreBL + f0, coreBR + f0, 0, false, Vector2.zero, new Vector2(coreBounds.width, gapHeight));
AddPlane(coreBR + c0, coreTR + c0, coreBR + f0, coreTR + f0, 0, false, Vector2.zero, new Vector2(coreBounds.width, gapHeight));
AddPlane(coreTR + c0, coreTL + c0, coreTR + f0, coreTL + f0, 0, false, Vector2.zero, new Vector2(coreBounds.width, gapHeight));
AddPlane(coreTL + c0, coreBL + c0, coreTL + f0, coreBL + f0, 0, false, Vector2.zero, new Vector2(coreBounds.width, gapHeight));
}
}
}
public static void InspectorGUI(BuildrEditMode editMode, BuildrData _data)
{
int helpWidth = 20;
data = _data;
Undo.RecordObject(data, "Facade Modified");
BuildrFacadeDesign[] facades = data.facades.ToArray();
int numberOfFacades = facades.Length;
selectedFacade = Mathf.Clamp(selectedFacade, 0, numberOfFacades - 1);
if (numberOfFacades == 0)
{
EditorGUILayout.HelpBox("There are no facade designs to show", MessageType.Info);
return;
}
bool hasUnusedFacades = false;
int unusedIndex = 0;
//Check all facades have een used and warn if there are unused ones
for (int i = 0; i < numberOfFacades; i++)
{
bool facadeUnused = true;
foreach (BuildrVolume volume in data.plan.volumes)
{
if (volume.ContainsFacade(i))
{
facadeUnused = false;
break;
}
}
if (facadeUnused)
{
hasUnusedFacades = true;
unusedIndex = i;
break;
}
}
if (hasUnusedFacades)
{
EditorGUILayout.HelpBox("There are facade designs that are not applied to your building and are unused.\nGo to the Building section to apply them to a facade.\nCheck facade design \"" + facades[unusedIndex].name + "\"", MessageType.Warning);
}
//Facade Selector
EditorGUILayout.BeginVertical("box");
EditorGUILayout.BeginHorizontal();
EditorGUILayout.LabelField("Facade Design:", GUILayout.Width(145));
string[] facadeNames = new string[numberOfFacades];
for (int f = 0; f < numberOfFacades; f++)
{
facadeNames[f] = facades[f].name;
}
selectedFacade = EditorGUILayout.Popup(selectedFacade, facadeNames);
BuildrFacadeDesign bFacade = facades[selectedFacade];
EditorGUILayout.EndHorizontal();
EditorGUILayout.BeginHorizontal();
if (GUILayout.Button("Add", GUILayout.Width(60)))
{
data.facades.Add(new BuildrFacadeDesign("new facade " + numberOfFacades));
facades = data.facades.ToArray();
numberOfFacades++;
selectedFacade = numberOfFacades - 1;
}
if (GUILayout.Button("Duplicate", GUILayout.Width(90)))
{
data.facades.Add(bFacade.Duplicate());
facades = data.facades.ToArray();
numberOfFacades++;
selectedFacade = numberOfFacades - 1;
}
if (GUILayout.Button("Delete", GUILayout.Width(70)))
{
if (EditorUtility.DisplayDialog("Deleting Facade Design Entry", "Are you sure you want to delete this facade?", "Delete", "Cancel"))
{
data.RemoveFacadeDesign(bFacade);
selectedFacade = 0;
GUI.changed = true;
return;
}
}
if (GUILayout.Button("Import", GUILayout.Width(71)))
{
string xmlPath = EditorUtility.OpenFilePanel("Select the XML file...", "Assets/BuildR/Exported/", "xml");
if (xmlPath == "")
{
return;
}
BuildrXMLImporter.ImportFacades(xmlPath, _data);
facades = _data.facades.ToArray();
selectedFacade = 0;
GUI.changed = true;
}
if (GUILayout.Button("Export", GUILayout.Width(71)))
{
string xmlPath = EditorUtility.SaveFilePanel("Export as...", "Assets/BuildR/Exported/", _data.name + "_facadeLibrary", "xml");
if (xmlPath == "")
{
return;
}
BuildrXMLExporter.ExportFacades(xmlPath, _data);
GUI.changed = true;
}
EditorGUILayout.EndHorizontal();
EditorGUILayout.Space();
EditorGUILayout.EndVertical();
bFacade = facades[selectedFacade];//reassign
bFacade.name = EditorGUILayout.TextField("Facade Name: ", bFacade.name);
EditorGUILayout.BeginHorizontal();
EditorGUILayout.LabelField("Facade Design Type:", GUILayout.Width(145));
bFacade.type = (BuildrFacadeDesign.types)EditorGUILayout.EnumPopup(bFacade.type);
if (GUILayout.Button("?", GUILayout.Width(helpWidth)))
{
string helpTitle = "Help - Design Type";
string helpBody = "This allows you to select the type of design you're using.\n" +
"Simple - the facade openings will be uniform\n" +
"Patterned - the facade openings will follow a pattern of defined dimensions and textures\n";
EditorUtility.DisplayDialog(helpTitle, helpBody, "close");
}
EditorGUILayout.EndHorizontal();
int numberOfTextures = data.textures.Count;
string[] textureNames = new string[numberOfTextures];
for (int t = 0; t < numberOfTextures; t++)
{
textureNames[t] = data.textures[t].name;
}
bFacade.hasWindows = EditorGUILayout.Toggle("Facade Has Bays", bFacade.hasWindows);
if (bFacade.hasWindows)
{
if (bFacade.type == BuildrFacadeDesign.types.simple)
{
BuildrBay bbay = bFacade.simpleBay;
EditorGUILayout.BeginHorizontal();
EditorGUILayout.LabelField("Render Bay", GUILayout.Width(146));
bool renderBayBack = EditorGUILayout.Toggle(bbay.renderBack);
if (renderBayBack != bbay.renderBack)
{
bbay.renderBack = renderBayBack;
}
EditorGUILayout.EndHorizontal();
EditorGUILayout.BeginHorizontal();
EditorGUILayout.LabelField("Bay Model", GUILayout.Width(146));
bbay.bayModel = (GameObject)EditorGUILayout.ObjectField(bbay.bayModel, typeof(GameObject), false);
if (GUILayout.Button("Clear", GUILayout.Width(70)))
{
bbay.bayModel = null;
}
EditorGUILayout.EndHorizontal();
float bbayopeningWidth = Mathf.Max(EditorGUILayout.FloatField("Opening Width", bbay.openingWidth), 0);
if (bbayopeningWidth != bbay.openingWidth)
{
bbay.openingWidth = bbayopeningWidth;
}
float bbayopeningHeight = Mathf.Max(EditorGUILayout.FloatField("Opening Height", bbay.openingHeight), 0);
if (bbayopeningHeight > data.floorHeight)
{
bbayopeningHeight = data.floorHeight;
}
if (bbayopeningHeight != bbay.openingHeight)
{
bbay.openingHeight = bbayopeningHeight;
}
float bbayminimumBayWidth = Mathf.Max(EditorGUILayout.FloatField("Min. Spacing", bbay.minimumBayWidth), 0);
if (bbayminimumBayWidth != bbay.minimumBayWidth)
{
bbay.minimumBayWidth = bbayminimumBayWidth;
}
float bbayopeningWidthRatio = EditorGUILayout.Slider("Horizontal Space Ratio", bbay.openingWidthRatio, 0, 1);
if (bbayopeningWidthRatio != bbay.openingWidthRatio)
{
bbay.openingWidthRatio = bbayopeningWidthRatio;
}
float bbayopeningHeightRatio = EditorGUILayout.Slider("Vertical Space Ratio", bbay.openingHeightRatio, 0, 1);
if (bbayopeningHeightRatio != bbay.openingHeightRatio)
{
bbay.openingHeightRatio = bbayopeningHeightRatio;
}
float bbayopeningDepth = EditorGUILayout.Slider("Opening Depth", bbay.openingDepth, -depth, depth);
if (bbayopeningDepth != bbay.openingDepth)
{
bbay.openingDepth = bbayopeningDepth;
}
float bbaycolumnDepth = EditorGUILayout.Slider("Column Depth", bbay.columnDepth, -depth, depth);
if (bbaycolumnDepth != bbay.columnDepth)
{
bbay.columnDepth = bbaycolumnDepth;
}
float bbayrowDepth = EditorGUILayout.Slider("Row Depth", bbay.rowDepth, -depth, depth);
if (bbayrowDepth != bbay.rowDepth)
{
bbay.rowDepth = bbayrowDepth;
}
float bbaycrossDepth = EditorGUILayout.Slider("Cross Depth", bbay.crossDepth, -depth, depth);
if (bbaycrossDepth != bbay.crossDepth)
{
bbay.crossDepth = bbaycrossDepth;
}
int numberOfTextureSlots = bbay.numberOfTextures;
string[] titles = new string[numberOfTextureSlots];
for (int bft = 0; bft < numberOfTextureSlots; bft++)
{
titles[bft] = ((BuildrBay.TextureNames)(bft)).ToString();
}
EditorGUILayout.BeginHorizontal();
EditorGUILayout.LabelField("Wall Surface:", GUILayout.Width(75));
editTextureOnFacade = EditorGUILayout.Popup(editTextureOnFacade, titles);
EditorGUILayout.EndHorizontal();
EditorGUILayout.BeginHorizontal();
EditorGUILayout.LabelField("Wall Texture:", GUILayout.Width(75));
int newFacadeTextureID = EditorGUILayout.Popup(bbay.textureValues[editTextureOnFacade], textureNames);
if (newFacadeTextureID != bbay.textureValues[editTextureOnFacade])
{
bbay.textureValues[editTextureOnFacade] = newFacadeTextureID;
}
EditorGUILayout.EndHorizontal();
BuildrTexture bTexture = data.textures[bbay.textureValues[editTextureOnFacade]];
Texture2D texture = bTexture.texture;
EditorGUILayout.BeginHorizontal();
if (texture != null)
{
GUILayout.Label(texture, GUILayout.Width(100), GUILayout.Height(100));
}
else
{
EditorGUILayout.HelpBox("No texture assigned for '" + textureNames[bbay.textureValues[editTextureOnFacade]] + "', assign one in the Textures menu above", MessageType.Warning);
}
bbay.flipValues[editTextureOnFacade] = EditorGUILayout.Toggle("Flip 90\u00B0", bbay.flipValues[editTextureOnFacade]);
EditorGUILayout.EndHorizontal();
}
else
{
//Patterned design GUI
int numberOfBays = bFacade.bayPattern.Count;
int numberOfBayDesigns = data.bays.Count;
EditorGUILayout.BeginHorizontal();
GUILayout.BeginHorizontal("box");
if (GUILayout.Button("Add New Bay Design"))
{
BuildrBay newBay = new BuildrBay("new bay design " + (numberOfBayDesigns + 1));
data.bays.Add(newBay);
bFacade.bayPattern.Add(numberOfBayDesigns);
numberOfBays++;
selectedBayPatternIndex = numberOfBays - 1;
numberOfBayDesigns++;
GUI.changed = true;
}
EditorGUILayout.EndHorizontal();
if (numberOfBays == 0 || data.bays.Count == 0)
{
EditorGUILayout.HelpBox("There are no bay designs to show", MessageType.Info);
// EditorGUILayout.EndHorizontal();
EditorGUILayout.EndVertical();
return;
}
BuildrBay[] bays = new BuildrBay[numberOfBays];
for (int i = 0; i < numberOfBays; i++)
{
bays[i] = data.bays[bFacade.bayPattern[i]];
}
selectedBayPatternIndex = Mathf.Clamp(selectedBayPatternIndex, 0, numberOfBays - 1);
EditorGUILayout.EndHorizontal();
EditorGUILayout.BeginHorizontal();
GUILayout.BeginHorizontal("box");
string[] bayDesignNames = new string[data.bays.Count];
for (int i = 0; i < numberOfBayDesigns; i++)
{
bayDesignNames[i] = data.bays[i].name;
}
selectedBayDesign = EditorGUILayout.Popup(selectedBayDesign, bayDesignNames);
if (GUILayout.Button("Add Selected"))
{
bFacade.bayPattern.Add(selectedBayDesign);
GUI.changed = true;
}
if (GUILayout.Button("Duplicate Selected"))
{
BuildrBay newBay = data.bays[selectedBayDesign].Duplicate();
data.bays.Add(newBay);
bFacade.bayPattern.Add(numberOfBayDesigns);
numberOfBays++;
selectedBayPatternIndex = numberOfBays - 1;
numberOfBayDesigns++;
GUI.changed = true;
}
EditorGUILayout.EndHorizontal();
EditorGUILayout.EndHorizontal();
GUILayout.BeginVertical("box");
EditorGUILayout.LabelField("Bay Design Order:");
var scrollbarHStyle = new GUIStyle(GUI.skin.horizontalScrollbar);
var scrollbarBackStyle = new GUIStyle();
var scrollbarVStyle = new GUIStyle(GUI.skin.verticalScrollbar);
scrollbarVStyle.fixedHeight = scrollbarVStyle.fixedWidth = 0;
bayDesignPatternScrollView = EditorGUILayout.BeginScrollView(bayDesignPatternScrollView, false, false, scrollbarHStyle, scrollbarVStyle, scrollbarBackStyle, GUILayout.Height(40));
List <string> bayNames = new List <string>();
foreach (int bayIndex in bFacade.bayPattern)
{
bayNames.Add(data.bays[bayIndex].name);
}
selectedBayPatternIndex = GUILayout.Toolbar(selectedBayPatternIndex, bayNames.ToArray());
EditorGUILayout.EndScrollView();
BuildrBay bBay = data.bays[bFacade.bayPattern[selectedBayPatternIndex]];
EditorGUILayout.BeginHorizontal();
EditorGUI.BeginDisabledGroup(selectedBayPatternIndex == 0);
if (GUILayout.Button("<<", GUILayout.Width(40)))
{
int bayDesignIndex = bFacade.bayPattern[selectedBayPatternIndex];
bFacade.bayPattern.RemoveAt(selectedBayPatternIndex);
bFacade.bayPattern.Insert(selectedBayPatternIndex - 1, bayDesignIndex);
selectedBayPatternIndex--;
GUI.changed = true;
}
EditorGUI.EndDisabledGroup();
if (GUILayout.Button("Remove"))
{
bFacade.bayPattern.RemoveAt(selectedBayPatternIndex);
GUI.changed = true;
}
if (GUILayout.Button("Delete"))
{
if (EditorUtility.DisplayDialog("Deleting Bay Design Entry", "Are you sure you want to delete this bay?", "Delete", "Cancel"))
{
int deletedBayDesignIndex = bFacade.bayPattern[selectedBayPatternIndex];
Debug.Log("Delete Bay Design " + deletedBayDesignIndex);
Debug.Log("Delete Bay Design " + data.bays[deletedBayDesignIndex].name);
data.bays.RemoveAt(deletedBayDesignIndex);
int numberOfFacadeDesigns = data.facades.Count;
for (int i = 0; i < numberOfFacadeDesigns; i++)
{
BuildrFacadeDesign checkFacade = data.facades[i];
int bayPatternSize = checkFacade.bayPattern.Count;
for (int j = 0; j < bayPatternSize; j++)
{
if (checkFacade.bayPattern[j] == deletedBayDesignIndex)
{
checkFacade.bayPattern.RemoveAt(j);
j--;
bayPatternSize--;
}
else if (checkFacade.bayPattern[j] > deletedBayDesignIndex)
{
checkFacade.bayPattern[j]--;
}
}
}
GUI.changed = true;
}
}
EditorGUI.BeginDisabledGroup(selectedBayPatternIndex == numberOfBays - 1);
if (GUILayout.Button(">>", GUILayout.Width(40)))
{
int bayDesignIndex = bFacade.bayPattern[selectedBayPatternIndex];
bFacade.bayPattern.Insert(selectedBayPatternIndex + 2, bayDesignIndex);
bFacade.bayPattern.RemoveAt(selectedBayPatternIndex);
selectedBayPatternIndex++;
GUI.changed = true;
}
EditorGUI.EndDisabledGroup();
EditorGUILayout.EndHorizontal();
EditorGUILayout.EndVertical();
GUILayout.Space(10);
EditorGUILayout.BeginVertical("box");
bBay.name = EditorGUILayout.TextField("Name: ", bBay.name);
bool bBayisOpening = EditorGUILayout.Toggle("Has Opening", bBay.isOpening);
if (bBayisOpening != bBay.isOpening)
{
bBay.isOpening = bBayisOpening;
}
bool bBayRenderBack = EditorGUILayout.Toggle("Render Back", bBay.renderBack);
if (bBayRenderBack != bBay.renderBack)
{
bBay.renderBack = bBayRenderBack;
}
EditorGUILayout.BeginHorizontal();
EditorGUILayout.LabelField("Bay Model", GUILayout.Width(146));
bBay.bayModel = (GameObject)EditorGUILayout.ObjectField(bBay.bayModel, typeof(GameObject), false);
if (GUILayout.Button("Clear", GUILayout.Width(70)))
{
bBay.bayModel = null;
}
EditorGUILayout.EndHorizontal();
float bBayopeningWidth = Mathf.Max(EditorGUILayout.FloatField("Opening Width", bBay.openingWidth), 0);
if (bBayopeningWidth != bBay.openingWidth)
{
bBay.openingWidth = bBayopeningWidth;
}
float bBayopeningHeight = Mathf.Clamp(EditorGUILayout.FloatField("Opening Height", bBay.openingHeight), 0, data.floorHeight);
if (bBayopeningHeight != bBay.openingHeight)
{
bBay.openingHeight = bBayopeningHeight;
}
float bBayminimumBayWidth = Mathf.Max(EditorGUILayout.FloatField("Bay Spacing Width", bBay.minimumBayWidth), 0);
if (bBayminimumBayWidth != bBay.minimumBayWidth)
{
bBay.minimumBayWidth = bBayminimumBayWidth;
}
float bBayopeningWidthRatio = EditorGUILayout.Slider("Horizontal Space Ratio", bBay.openingWidthRatio, 0, 1);
if (bBayopeningWidthRatio != bBay.openingWidthRatio)
{
bBay.openingWidthRatio = bBayopeningWidthRatio;
}
float bBayopeningHeightRatio = EditorGUILayout.Slider("Vertical Space Ratio", bBay.openingHeightRatio, 0, 1);
if (bBayopeningHeightRatio != bBay.openingHeightRatio)
{
bBay.openingHeightRatio = bBayopeningHeightRatio;
}
float bBayopeningDepth = EditorGUILayout.Slider("Opening Depth", bBay.openingDepth, -depth, depth);
if (bBayopeningDepth != bBay.openingDepth)
{
bBay.openingDepth = bBayopeningDepth;
}
float bBaycolumnDepth = EditorGUILayout.Slider("Column depth", bBay.columnDepth, -depth, depth);
if (bBaycolumnDepth != bBay.columnDepth)
{
bBay.columnDepth = bBaycolumnDepth;
}
float bBayrowDepth = EditorGUILayout.Slider("Row depth", bBay.rowDepth, -depth, depth);
if (bBayrowDepth != bBay.rowDepth)
{
bBay.rowDepth = bBayrowDepth;
}
float bBaycrossDepth = EditorGUILayout.Slider("Cross depth", bBay.crossDepth, -depth, depth);
if (bBaycrossDepth != bBay.crossDepth)
{
bBay.crossDepth = bBaycrossDepth;
}
//BAY TEXTURES
int numberOfTextureSlots = bBay.numberOfTextures;
string[] titles = new string[numberOfTextureSlots];
for (int bft = 0; bft < numberOfTextureSlots; bft++)
{
titles[bft] = ((BuildrBay.TextureNames)(bft)).ToString();
}
EditorGUILayout.BeginHorizontal();
EditorGUILayout.LabelField("Surface:", GUILayout.Width(75));
editTextureOnFacade = EditorGUILayout.Popup(editTextureOnFacade, titles);
EditorGUILayout.EndHorizontal();
EditorGUILayout.BeginHorizontal();
EditorGUILayout.LabelField("Texture:", GUILayout.Width(75));
bBay.textureValues[editTextureOnFacade] = EditorGUILayout.Popup(bBay.textureValues[editTextureOnFacade], textureNames);
EditorGUILayout.EndHorizontal();
BuildrTexture bTexture = data.textures[bBay.textureValues[editTextureOnFacade]];
Texture2D texture = bTexture.texture;
EditorGUILayout.BeginHorizontal();
if (texture != null)
{
GUILayout.Label(texture, GUILayout.Width(100), GUILayout.Height(100));
}
else
{
EditorGUILayout.HelpBox("No texture assigned for '" + textureNames[bBay.textureValues[editTextureOnFacade]] + "', assign one in the Textures menu above", MessageType.Warning);
}
bFacade.flipValues[editTextureOnFacade] = EditorGUILayout.Toggle("Flip 90\u00B0", bFacade.flipValues[editTextureOnFacade]);
EditorGUILayout.EndHorizontal();
EditorGUILayout.EndVertical();
}
}
else
{
editTextureOnFacade = 7;
EditorGUILayout.BeginHorizontal();
EditorGUILayout.LabelField("Surface:", GUILayout.Width(75));
EditorGUILayout.LabelField("Wall");
EditorGUILayout.EndHorizontal();
EditorGUILayout.BeginHorizontal();
EditorGUILayout.LabelField("Texture:", GUILayout.Width(75));
int newFacadeTexture = EditorGUILayout.Popup(bFacade.simpleBay.textureValues[editTextureOnFacade], textureNames);
if (newFacadeTexture != bFacade.simpleBay.textureValues[editTextureOnFacade])
{
bFacade.simpleBay.textureValues[editTextureOnFacade] = newFacadeTexture;
}
EditorGUILayout.EndHorizontal();
BuildrTexture bTexture = data.textures[bFacade.simpleBay.textureValues[editTextureOnFacade]];
Texture2D texture = bTexture.texture;
EditorGUILayout.BeginHorizontal();
if (texture != null)
{
GUILayout.Label(texture, GUILayout.Width(100), GUILayout.Height(100));
}
else
{
EditorGUILayout.HelpBox("No texture assigned for '" + textureNames[bFacade.simpleBay.textureValues[editTextureOnFacade]] + "', assign one in the Textures menu above", MessageType.Warning);
}
bFacade.simpleBay.flipValues[editTextureOnFacade] = EditorGUILayout.Toggle("Flip 90\u00B0", bFacade.simpleBay.flipValues[editTextureOnFacade]);
EditorGUILayout.EndHorizontal();
}
}
private static void ImportFacades(XmlDocument xml, BuildrData data)
{
foreach(XmlNode node in xml.SelectNodes("buildr/facades/facade"))
{
BuildrFacadeDesign facadeDesign = new BuildrFacadeDesign();
data.facades.Add(facadeDesign);
facadeDesign.name = node["name"].FirstChild.Value;
facadeDesign.hasWindows = node["hasWindows"].FirstChild.Value == valueTrue;
facadeDesign.type = (BuildrFacadeDesign.types)System.Enum.Parse(typeof(BuildrFacadeDesign.types), (string)node["type"].FirstChild.Value);
facadeDesign.simpleBay.name = node["simpleBayName"].FirstChild.Value;
facadeDesign.simpleBay.openingWidth = float.Parse(node["simpleBayOpeningWidth"].FirstChild.Value);
facadeDesign.simpleBay.openingHeight = float.Parse(node["simpleBayOpeningHeight"].FirstChild.Value);
facadeDesign.simpleBay.minimumBayWidth = float.Parse(node["simpleBayMinimumBayWidth"].FirstChild.Value);
facadeDesign.simpleBay.openingWidthRatio = float.Parse(node["simpleBayOpeningWidthRatio"].FirstChild.Value);
facadeDesign.simpleBay.openingHeightRatio = float.Parse(node["simpleBayOpeningHeightRatio"].FirstChild.Value);
facadeDesign.simpleBay.openingDepth = float.Parse(node["simpleBayOpeningDepth"].FirstChild.Value);
facadeDesign.simpleBay.columnDepth = float.Parse(node["simpleBayColumnDepth"].FirstChild.Value);
facadeDesign.simpleBay.rowDepth = float.Parse(node["simpleBayRowDepth"].FirstChild.Value);
facadeDesign.simpleBay.crossDepth = float.Parse(node["simpleBayCrossDepth"].FirstChild.Value);
for(int i = 0; i < 8; i++)
{
facadeDesign.simpleBay.textureValues[i] = int.Parse(node.SelectNodes("simpleBayTextures/texture")[i].FirstChild.Value);
facadeDesign.simpleBay.flipValues[i] = node.SelectNodes("simpleBayflipvalues/flipvalue")[i].FirstChild.Value == valueTrue;
}
foreach(XmlNode baynode in node.SelectNodes("bays/bayid"))
{
facadeDesign.bayPattern.Add(int.Parse(baynode.FirstChild.Value));
}
}
}
public void RemoveFacadeDesign(BuildrFacadeDesign facadeDesign)
{
int bFacadeIndex = facades.IndexOf(facadeDesign);//the the index of the facade BEFORE we delete it
facades.Remove(facadeDesign);
int numberOfVolumes = plan.numberOfVolumes;
for (int s = 0; s < numberOfVolumes; s++)
plan.volumes[s].styles.CheckRemovedStyle(bFacadeIndex);
}
public static GameObject[] Place(BuildrData data)
{
BuildrPlan plan = data.plan;
int numberOfVolumes = plan.numberOfVolumes;
BuildrTexture[] textures = data.textures.ToArray();
List <GameObject> output = new List <GameObject>();
float largestDepthValue = 0;//deepest value of a bay design in the building
foreach (BuildrBay bay in data.bays)
{
largestDepthValue = Mathf.Max(largestDepthValue, bay.deepestValue);//get the deepest value
}
foreach (BuildrFacadeDesign facade in data.facades)
{
largestDepthValue = Mathf.Max(largestDepthValue, facade.simpleBay.deepestValue);//get the deepest value
}
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 indexAM = Mathf.Abs((f - 1) % numberOfVolumePoints);
int indexA = f;
int indexB = (f + 1) % numberOfVolumePoints;
int indexBP = (f + 2) % numberOfVolumePoints;
Vector3 p0m = plan.points[volume.points[indexAM]].vector3;
Vector3 p0 = plan.points[volume.points[indexA]].vector3;
Vector3 p1 = plan.points[volume.points[indexB]].vector3;
Vector3 p1p = plan.points[volume.points[indexBP]].vector3;
float facadeWidth = Vector3.Distance(p0, p1) - largestDepthValue * 2.0f;
Vector3 facadeDirection = (p1 - p0).normalized;
Vector3 facadeCross = Vector3.Cross(facadeDirection, Vector3.up).normalized;
Vector3 lastFacadeDirection = (p0 - p0m).normalized;
Vector3 nextFacadeDirection = (p1p - p1).normalized;
//only bother with facade directions when facade may intersect inverted geometry
float facadeDirDotL = Vector3.Dot(-facadeDirection, lastFacadeDirection);
float facadeCrossDotL = Vector3.Dot(-facadeCross, lastFacadeDirection);
if (facadeDirDotL <= 0 || facadeCrossDotL <= 0)
{
lastFacadeDirection = -facadeCross;
}
float facadeDirDotN = Vector3.Dot(-facadeDirection, nextFacadeDirection);
float facadeCrossDotN = Vector3.Dot(-facadeCross, nextFacadeDirection);
if (facadeDirDotN <= 0 || facadeCrossDotN <= 0)
{
nextFacadeDirection = facadeCross;
}
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;
Vector3 floorHeightStart = Vector3.up * (floorBase * floorHeight);
p0 += floorHeightStart;
BuildrVolumeStylesUnit[] styleUnits = volume.styles.GetContentsByFacade(volume.points[indexA]);
int floorPatternSize = 0;
List <int> facadePatternReference = new List <int>(); //this contains a list of all the facade style indices to refence when looking for the appropriate style per floor
int patternCount = 0;
foreach (BuildrVolumeStylesUnit styleUnit in styleUnits) //need to knw how big all the styles are together so we can loop through them
{
floorPatternSize += styleUnit.floors;
for (int i = 0; i < styleUnit.floors; i++)
{
facadePatternReference.Add(patternCount);
}
patternCount++;
}
facadePatternReference.Reverse();
int rows = numberOfFloors;
for (int r = 0; r < rows; r++)
{
//Get the facade style id
//need to loop through the facade designs floor by floor until we get to the right one
float currentHeight = floorHeight * r;
Vector3 facadeFloorBaseVector = p0 + Vector3.up * currentHeight;
int modFloor = (r % floorPatternSize);
BuildrFacadeDesign facadeDesign = data.facades[styleUnits[facadePatternReference[modFloor]].styleID];
bool isBlankWall = !facadeDesign.hasWindows;
if (facadeDesign.type == BuildrFacadeDesign.types.patterned)
{
if (data.bays.Count == 0 || facadeDesign.bayPattern.Count == 0)
{
data.illegal = true;
return(output.ToArray());
}
BuildrBay firstBay = data.bays[facadeDesign.bayPattern[0]];
if (firstBay.openingWidth > facadeWidth)
{
isBlankWall = true;
}
if (facadeDesign.bayPattern.Count == 0)
{
isBlankWall = true;
}
}
else
{
if (facadeDesign.simpleBay.openingWidth + facadeDesign.simpleBay.minimumBayWidth > facadeWidth)
{
isBlankWall = true;
}
}
if (!isBlankWall)
{
float patternSize = 0;//the space the pattern fills, there will be a gap that will be distributed to all bay styles
int numberOfBays = 0;
//float actualWindowSpacing;
BuildrBay[] bayDesignPattern;
int numberOfBayDesigns;
if (facadeDesign.type == BuildrFacadeDesign.types.patterned)
{
numberOfBayDesigns = facadeDesign.bayPattern.Count;
bayDesignPattern = new BuildrBay[numberOfBayDesigns];
for (int i = 0; i < numberOfBayDesigns; i++)
{
bayDesignPattern[i] = data.bays[facadeDesign.bayPattern[i]];
}
}
else
{
bayDesignPattern = new[] { facadeDesign.simpleBay };
numberOfBayDesigns = 1;
}
//start with first window width - we'll be adding to this until we have filled the facade width
int it = 100;
while (true)
{
int patternModIndex = numberOfBays % numberOfBayDesigns;
float patternAddition = bayDesignPattern[patternModIndex].openingWidth + bayDesignPattern[patternModIndex].minimumBayWidth;
if (patternSize + patternAddition < facadeWidth)
{
patternSize += patternAddition;
numberOfBays++;
}
else
{
break;
}
it--;
if (it < 0)
{
break;
}
}
Vector3 windowBase = facadeFloorBaseVector;
float perBayAdditionalSpacing = (facadeWidth - patternSize) / numberOfBays;
for (int c = 0; c < numberOfBays; c++)
{
BuildrBay bayStyle;
if (facadeDesign.type == BuildrFacadeDesign.types.patterned)
{
int numberOfBayStyles = facadeDesign.bayPattern.Count;
bayStyle = bayDesignPattern[c % numberOfBayStyles];
}
else
{
bayStyle = facadeDesign.simpleBay;
}
GameObject bayModel = bayStyle.bayModel;
BuildrTexture columnTexture = textures[bayStyle.GetTexture(BuildrBay.TextureNames.ColumnTexture)];
Vector2 columnuvunits = columnTexture.tileUnitUV;
float openingWidth = bayStyle.openingWidth;
float openingHeight = bayStyle.openingHeight;
if (columnTexture.patterned)
{
openingHeight = Mathf.Ceil(bayStyle.openingHeight / columnuvunits.y) * columnuvunits.y;
}
if (bayStyle.openingHeight == floorHeight)
{
bayStyle.openingHeight = floorHeight;
}
float actualWindowSpacing = bayStyle.minimumBayWidth + perBayAdditionalSpacing;
float leftWidth = actualWindowSpacing * bayStyle.openingWidthRatio;
bool firstColumn = c == 0;
if (firstColumn)
{
leftWidth += largestDepthValue;
}
float rowBottomHeight = ((floorHeight - openingHeight) * bayStyle.openingHeightRatio);
if (columnTexture.patterned)
{
rowBottomHeight = Mathf.Ceil(rowBottomHeight / columnuvunits.y) * columnuvunits.y;
}
float bayWidthSize = openingWidth + actualWindowSpacing;
Vector3 bayWidth = facadeDirection * bayWidthSize;
if (!bayStyle.isOpening || bayModel == null)
{
windowBase += bayWidth;//move base vertor to next bay
if (firstColumn)
{
windowBase += facadeDirection * (largestDepthValue);
}
continue;//bay filled - move onto next bay
}
GameObject newInstance = (GameObject)Instantiate(bayModel);
MeshRenderer[] rends = newInstance.GetComponentsInChildren <MeshRenderer>();
Bounds modelBounds = rends[0].bounds;
foreach (MeshRenderer meshRenderer in rends)
{
modelBounds.Encapsulate(meshRenderer.bounds);
}
if (rends.Length == 0)
{
continue;
}
Vector3 modelSize = modelBounds.size;
Vector3 baySize = new Vector3(openingWidth, openingHeight, modelSize.z);
Vector3 modelScale;
modelScale.x = baySize.x / modelSize.x;
modelScale.y = baySize.y / modelSize.y;
modelScale.z = baySize.z / modelSize.z;
newInstance.transform.localScale = modelScale;
Vector3 upVector = Vector3.up * rowBottomHeight;
Vector3 leftVector = leftWidth * facadeDirection;
Vector3 modelPosition = windowBase + leftVector + upVector;
modelBounds = rends[0].bounds;
foreach (MeshRenderer meshRenderer in rends)
{
modelBounds.Encapsulate(meshRenderer.bounds);
}
modelPosition += Quaternion.LookRotation(facadeCross) * (-modelBounds.min);
newInstance.transform.position = modelPosition;
newInstance.transform.rotation = Quaternion.LookRotation(-facadeCross);
output.Add(newInstance);
windowBase += bayWidth;//move base vertor to next bay
if (firstColumn)
{
windowBase += facadeDirection * (largestDepthValue);
}
}
}
}
}
}
return(output.ToArray());
}
public static bool UpgradeData(BuildrData data)
{
float currentVersion = BuildrVersion.NUMBER;
float dataVersion = data.versionNumber;
if (currentVersion == dataVersion)
{
//The data matches the current version of Buildr - do nothing.
return(true);
}
if (currentVersion < dataVersion)
{
Debug.LogError("BuildR v." + currentVersion + ": Great scot! This data is from the future! (version:" + dataVersion + ") - need to avoid contact to ensure the survival of the universe...");
return(false);//don't touch ANYTHING!
}
Debug.Log("BuildR v." + currentVersion + " Upgrading the data from version " + dataVersion + " to version " + currentVersion + "\nRemember to backup your data!");
if (dataVersion < 0.7f)
{
//upgrade the facade data so we use BuildrBay design elements
int facadeDesignCount = data.facades.Count;
for (int i = 0; i < facadeDesignCount; i++)
{
BuildrFacadeDesign design = data.facades[i];
if (!design.alternatingSpacing)
{
design.type = BuildrFacadeDesign.types.simple;
design.simpleBay.isOpening = design.hasWindows;
design.simpleBay.openingWidth = design.windowWidth;
design.simpleBay.openingHeight = design.windowHeight;
design.simpleBay.minimumBayWidth = design.minimumWindowSpacing;
design.simpleBay.openingWidthRatio = 0.5f;
design.simpleBay.openingHeightRatio = design.windowHeightRatio;
design.simpleBay.openingDepth = design.windowDepth;
design.simpleBay.columnDepth = design.columnDepth;
design.simpleBay.rowDepth = design.rowDepth;
design.simpleBay.crossDepth = design.crossDepth;
design.simpleBay.textureValues[0] = design.textureValues[4]; //openingBackTexture,
design.simpleBay.textureValues[1] = design.textureValues[5]; //openingSideTexture,
design.simpleBay.textureValues[2] = design.textureValues[6]; //openingSillTexture,
design.simpleBay.textureValues[3] = design.textureValues[7]; //openingCeilingTexture,
design.simpleBay.textureValues[4] = design.textureValues[0]; //columnTexture,
design.simpleBay.textureValues[5] = design.textureValues[1]; //rowTexture,
design.simpleBay.textureValues[6] = design.textureValues[2]; //crossTexture,
design.simpleBay.textureValues[7] = design.textureValues[0]; //wallTexture
design.simpleBay.flipValues[0] = design.flipValues[4]; //openingBackTexture,
design.simpleBay.flipValues[1] = design.flipValues[5]; //openingSideTexture,
design.simpleBay.flipValues[2] = design.flipValues[6]; //openingSillTexture,
design.simpleBay.flipValues[3] = design.flipValues[7]; //openingCeilingTexture,
design.simpleBay.flipValues[4] = design.flipValues[0]; //columnTexture,
design.simpleBay.flipValues[5] = design.flipValues[1]; //rowTexture,
design.simpleBay.flipValues[6] = design.flipValues[2]; //crossTexture,
design.simpleBay.flipValues[7] = design.flipValues[0]; //wallTexture
}
else
{
design.type = BuildrFacadeDesign.types.patterned;
float alternateSpacerRatio = (1 / (1 + (1 / design.minimumWindowSpacingAlt)));
BuildrBay bayA = new BuildrBay(design.name + "a");
bayA.isOpening = design.hasWindows;
bayA.openingWidth = design.windowWidth;
bayA.openingHeight = design.windowHeight;
bayA.minimumBayWidth = design.minimumWindowSpacing;
bayA.openingWidthRatio = 1 - alternateSpacerRatio;
bayA.openingHeightRatio = design.windowHeightRatio;
bayA.openingDepth = design.windowDepth;
bayA.columnDepth = design.columnDepth;
bayA.rowDepth = design.rowDepth;
bayA.crossDepth = design.crossDepth;
bayA.textureValues[0] = design.textureValues[4]; //openingBackTexture,
bayA.textureValues[1] = design.textureValues[5]; //openingSideTexture,
bayA.textureValues[2] = design.textureValues[6]; //openingSillTexture,
bayA.textureValues[3] = design.textureValues[7]; //openingCeilingTexture,
bayA.textureValues[4] = design.textureValues[0]; //columnTexture,
bayA.textureValues[5] = design.textureValues[1]; //rowTexture,
bayA.textureValues[6] = design.textureValues[2]; //crossTexture,
bayA.textureValues[7] = design.textureValues[0]; //wallTexture
bayA.flipValues[0] = design.flipValues[4]; //openingBackTexture,
bayA.flipValues[1] = design.flipValues[5]; //openingSideTexture,
bayA.flipValues[2] = design.flipValues[6]; //openingSillTexture,
bayA.flipValues[3] = design.flipValues[7]; //openingCeilingTexture,
bayA.flipValues[4] = design.flipValues[0]; //columnTexture,
bayA.flipValues[5] = design.flipValues[1]; //rowTexture,
bayA.flipValues[6] = design.flipValues[2]; //crossTexture,
bayA.flipValues[7] = design.flipValues[0]; //wallTexture
BuildrBay bayB = new BuildrBay(design.name + "b");
bayB.isOpening = design.hasWindows;
bayB.openingWidth = design.windowWidth;
bayB.openingHeight = design.windowHeight;
bayB.minimumBayWidth = design.minimumWindowSpacing;
bayB.openingWidthRatio = alternateSpacerRatio;
bayB.openingHeightRatio = design.windowHeightRatio;
bayB.openingDepth = design.windowDepth;
bayB.columnDepth = design.columnDepth;
bayB.rowDepth = design.rowDepth;
bayB.crossDepth = design.crossDepth;
bayB.textureValues[0] = design.textureValues[4]; //openingBackTexture,
bayB.textureValues[1] = design.textureValues[5]; //openingSideTexture,
bayB.textureValues[2] = design.textureValues[6]; //openingSillTexture,
bayB.textureValues[3] = design.textureValues[7]; //openingCeilingTexture,
bayB.textureValues[4] = design.textureValues[0]; //columnTexture,
bayB.textureValues[5] = design.textureValues[1]; //rowTexture,
bayB.textureValues[6] = design.textureValues[2]; //crossTexture,
bayB.textureValues[7] = design.textureValues[0]; //wallTexture
bayB.flipValues[0] = design.flipValues[4]; //openingBackTexture,
bayB.flipValues[1] = design.flipValues[5]; //openingSideTexture,
bayB.flipValues[2] = design.flipValues[6]; //openingSillTexture,
bayB.flipValues[3] = design.flipValues[7]; //openingCeilingTexture,
bayB.flipValues[4] = design.flipValues[0]; //columnTexture,
bayB.flipValues[5] = design.flipValues[1]; //rowTexture,
bayB.flipValues[6] = design.flipValues[2]; //crossTexture,
bayB.flipValues[7] = design.flipValues[0]; //wallTexture
int bayIndex = data.bays.Count;
data.bays.Add(bayA);
data.bays.Add(bayB);
design.bayPattern.Clear();
design.bayPattern.Add(bayIndex);
design.bayPattern.Add(bayIndex + 1);
}
}
}
if (dataVersion < 0.9f)
{
//new details addition
data.details = new List <BuildrDetail>();
//update Volume to account for the new array of Render bools
BuildrPlan plan = data.plan;
foreach (BuildrVolume volume in plan.volumes)
{
int volumeSize = volume.points.Count;
for (int i = 0; i < volumeSize; i++)
{
volume.renderFacade.Add(true);
}
}
}
if (dataVersion < 1.0f)
{
foreach (BuildrBay bay in data.bays)
{
bay.renderBack = true;
}
}
data.versionNumber = BuildrVersion.NUMBER;//update the data version number once upgrade is complete
return(true);
}
