/*private void Update()
* {
* if (Input.GetKeyDown("space"))
* {
* DeleteCity();
* LoadBuildingsWithRectanglePlots();
* UpdateHeight();
* }
* }*/
public void LoadBuildingsWithRectanglePlots()
{
GameObject baseSpawnPoint = new GameObject("CitySpawn");
baseSpawnPoint.transform.SetParent(citySpawnPoint.transform);
baseSpawnPoint.transform.localPosition = Vector3.zero;
List <RectInt> plots = GetComponent <CityPlotGenerator>().createPlots();
foreach (RectInt plot in plots)
{
GameObject buildingSpawnPoint = new GameObject("BuildingSpawn");
buildingSpawnPoint.transform.SetParent(baseSpawnPoint.transform);
BuildingSettings s = buildingSettings[Random.Range(0, buildingSettings.Length)];
int width = Mathf.Min(Mathf.Clamp(plot.width / pieceSize - siteOffset, 1, 1000), maxDim);
int height = Mathf.Min(Mathf.Clamp(plot.height / pieceSize - siteOffset, 1, 1000), maxDim);
s.SetSize(new Vector2Int(width, height));
LoadBuilding(buildingSpawnPoint, s);
int xpos = plot.x + plot.width - Random.Range(0, siteOffset) * pieceSize;
int zpos = plot.y + plot.height - Random.Range(0, siteOffset) * pieceSize;
buildingSpawnPoint.transform.localPosition = new Vector3(xpos, 0, zpos);
buildingSpawnPoint.transform.rotation = Quaternion.Euler(0, Random.Range(0f, RotationJitter), 0);
}
}
public void LoadBuilding(GameObject spawnPoint, BuildingSettings settings)
{
Building b = BuildingGenerator.Generate(settings);
GetComponent <BuildingRenderer>().Render(b, spawnPoint);
//Debug.Log(b.ToString());
}
static List <List <Vertical> > GenRectVerticals(BuildingSettings settings, List <RectInt> rectList, int level)
{
List <List <Vertical> > rectVerticals = new List <List <Vertical> >();
foreach (RectInt r in rectList)
{
List <Vertical> verticals = new List <Vertical>();
for (int x = 0; x < r.width; x++)
{
for (int y = 0; y < r.height; y++)
{
verticals.Add(Vertical.Wall);
int rand = Random.Range(1, 100);
if (rand < settings.WindowSeed)
{
verticals[verticals.Count() - 1] = Vertical.Window;
}
rand = Random.Range(1, 100);
if (level == 1 && rand < settings.DoorSeed)
{
verticals[verticals.Count() - 1] = Vertical.Door;
}
}
}
rectVerticals.Add(verticals);
}
return(rectVerticals);
}
public override Wing[] GenerateWings(BuildingSettings settings)
{
if (settings.Size.x > 1 && settings.Size.y > 1)
{
RectInt firstBounds = new RectInt(0, 0, settings.Size.x, 1);
RectInt secondBounds = new RectInt(0, 1, 1, settings.Size.y - 1);
Wing[] wings = new Wing[2];
if (settings.wingStrategy != null)
{
wings[0] = settings.wingStrategy.GenerateWing(settings, firstBounds, settings.Height());
wings[1] = settings.wingStrategy.GenerateWing(settings, secondBounds, settings.Height());
}
else
{
wings[0] = ((WingStrategy)ScriptableObject.CreateInstance <DefaultWingStrategy>()).GenerateWing(settings, firstBounds, settings.Height());
wings[1] = ((WingStrategy)ScriptableObject.CreateInstance <DefaultWingStrategy>()).GenerateWing(settings, secondBounds, settings.Height());
}
return(wings);
}
else
{
return(new Wing[]
{
settings.wingStrategy != null?
settings.wingStrategy.GenerateWing(settings, new RectInt(0, 0, settings.Size.x, settings.Size.y), settings.Height()) :
((WingStrategy)ScriptableObject.CreateInstance <DefaultWingStrategy>()).GenerateWing(settings, new RectInt(0, 0, settings.Size.x, settings.Size.y), settings.Height()),
});
}
}
private void ShowBuildingElement(BuildingSettings element)
{
EditorGUILayout.BeginVertical("box");
{
BuildingType saveKind = element.Type;
element.Type = (BuildingType)EditorGUILayout.EnumPopup("Type Building:", element.Type);
if (GUI.changed && saveKind != element.Type)
{
if (UsingType.Contains("bt_" + saveKind.ToString()))
{
UsingType.Remove("bt_" + saveKind.ToString());
}
UsingType.Add("bt_" + element.Type.ToString());
}
element.Material = (Material)EditorGUILayout.ObjectField("Material", element.Material, typeof(Material));
if (element.Material == null)
{
DisplayErrorMEssage("Not setting material");
}
element.IsVolumetric = EditorGUILayout.Toggle("IsVolumetric", element.IsVolumetric);
EditorGUILayout.LabelField("BuildingHeight");
EditorGUILayout.BeginHorizontal("box");
element.MaximumBuildingHeight = EditorGUILayout.IntField("Maximum", element.MaximumBuildingHeight);
element.MinimumBuildingHeight = EditorGUILayout.IntField("Minimum", element.MinimumBuildingHeight);
EditorGUILayout.EndHorizontal();
}
EditorGUILayout.EndVertical();
}
public override Wall[] GenerateWalls(BuildingSettings settings, RectInt bounds, int level)
{
Wall[] walls = new Wall[(bounds.size.x + bounds.size.y) * 2];
List <int> usedIndices = new List <int>();
if (level == 0 || enableBalconies)
{
int doorIndex = Random.Range(0, walls.Length);
usedIndices.Add(doorIndex);
walls[doorIndex] = Wall.Door;
}
float percentWindows = .50f;
int numWindows = (int)(walls.Length * percentWindows);
for (int i = 0; i < numWindows; i++)
{
int windowIndex = Random.Range(0, walls.Length);
while (usedIndices.Contains(windowIndex))
{
windowIndex = Random.Range(0, walls.Length);
}
usedIndices.Add(windowIndex);
walls[windowIndex] = Wall.Window;
}
return(walls);
}
public override Story GenerateStory(BuildingSettings settings, RectInt bounds, int level)
{
return(new Story(level, settings.wallsStrategy != null ?
settings.wallsStrategy.GenerateWalls(settings, bounds, level) :
((WallsStrategy)ScriptableObject.CreateInstance <DefaultWallsStrategy>()).GenerateWalls(settings, bounds, level),
bounds
));
}
public static Building Generate(BuildingSettings settings)
{
return(new Building(settings.Size.x, settings.Size.y,
settings.wingsStrategy != null ?
settings.wingsStrategy.GenerateWings(settings) :
((WingsStrategy)ScriptableObject.CreateInstance <DefaultWingsStrategy>()).GenerateWings(settings)
));
}
public override Wing[] GenerateWings(BuildingSettings settings)
{
return(new Wing[]
{
settings.wingStrategy != null?
settings.wingStrategy.GenerateWing(settings, new RectInt(0, 0, settings.Size.x, settings.Size.y), settings.Height()) :
((WingStrategy)ScriptableObject.CreateInstance <DefaultWingStrategy>()).GenerateWing(settings, new RectInt(0, 0, settings.Size.x, settings.Size.y), settings.Height())
});
}
protected BuildingSettings createBuildingSettings(BuildingType type, int min, int max, string material)
{
var bs = new BuildingSettings();
bs.Type = type;
bs.Material = (Material)Resources.Load(material, typeof(Material));
bs.MinimumBuildingHeight = 20;
bs.MaximumBuildingHeight = 50;
bs.IsVolumetric = true;
return(bs);
}
private void CreateMesh(List <Vector3> corners, BuildingSettings typeSettings, MeshData data, Vector2 min, Vector2 size)
{
var vertsStartCount = _useTriangulationNet
? CreateRoofTriangulation(corners, data)
: CreateRoofClass(corners, data);
foreach (var c in corners)
{
data.UV.Add(new Vector2((c.x - min.x), (c.z - min.y)));
}
}
public override Story[] GenerateStories(BuildingSettings settings, RectInt bounds, int numberOfStories)
{
Story[] stories = new Story[numberOfStories];
for (int level = 0; level < numberOfStories; level++)
{
stories[level] = settings.storyStrategy != null?
settings.storyStrategy.GenerateStory(settings, bounds, level) :
((StoryStrategy)ScriptableObject.CreateInstance <DefaultStoryStrategy>()).GenerateStory(settings, bounds, level);
}
return(stories);
}
public override Wing GenerateWing(BuildingSettings settings, RectInt bounds, int numberOfStories)
{
return(new Wing(bounds,
settings.storiesStrategy != null ?
settings.storiesStrategy.GenerateStories(settings, bounds, numberOfStories) :
((StoriesStrategy)ScriptableObject.CreateInstance <DefaultStoriesStrategy>()).GenerateStories(settings, bounds, numberOfStories),
settings.roofStrategy != null ?
settings.roofStrategy.GenerateRoof(settings, bounds) :
((RoofStrategy)ScriptableObject.CreateInstance <DefaultRoofStrategy>()).GenerateRoof(settings, bounds)
));
}
protected BuildingSettings createBuildingSettings(BuildingType type, int min, int max, string material)
{
const int EXAGERATION_FACTOR = 2;
var bs = new BuildingSettings();
bs.Type = type;
bs.Material = (Material)Resources.Load(material, typeof(Material));
bs.MinimumBuildingHeight = EXAGERATION_FACTOR * min;
bs.MaximumBuildingHeight = EXAGERATION_FACTOR * max;
bs.IsVolumetric = true;
return(bs);
}
public override Roof GenerateRoof(BuildingSettings settings, RectInt bounds)
{
if (bounds.size.x < bounds.size.y)
{
Roof roof = new Roof(RoofType.Peak);
roof.IsDefault = true;
return(roof);
}
else
{
return(new Roof(RoofType.Peak, RoofDirection.East));
}
}
public override Roof GenerateRoof(BuildingSettings settings, RectInt bounds)
{
if (bounds.size.x == 1 && bounds.size.y == 1)
{
return(new Roof(RoofType.Point));
}
else
{
Roof roof = new Roof(RoofType.Peak);
roof.IsDefault = true;
return(roof);
}
}
public void LoadBuilding()
{
settings = settingsArray[Random.Range(0, settingsArray.Length)];
SetSize(new Vector2Int(width, depth));
SetHeight(height);
Building b = BuildingGenerator.Generate(settings);
GetComponent <BuildingRenderer>().Render(b, spawnPoint);
explosionSystem.Play();
currentCoroutine = LoadAnimation();
StartCoroutine(currentCoroutine);
//Debug.Log(b.ToString());
}
public override Wing[] GenerateWings(BuildingSettings settings)
{
if (settings.Size.x > 2 && settings.Size.y > 1)
{
RectInt firstBounds = new RectInt(0, 0, settings.Size.x, 1);
RectInt secondBounds;
RectInt thirdBounds;
if (scaleWings && settings.Size.x > 4)
{
int size = settings.Size.x / 2;
if (size % 2 == 0)
{
size -= 1;
}
secondBounds = new RectInt(0, 1, size, settings.Size.y - 1);
thirdBounds = new RectInt(settings.Size.x - size, 1, size, settings.Size.y - 1);
}
else
{
secondBounds = new RectInt(0, 1, 1, settings.Size.y - 1);
thirdBounds = new RectInt(settings.Size.x - 1, 1, 1, settings.Size.y - 1);
}
Wing[] wings = new Wing[3];
if (settings.wingStrategy != null)
{
wings[0] = settings.wingStrategy.GenerateWing(settings, firstBounds, settings.Height());
wings[1] = settings.wingStrategy.GenerateWing(settings, secondBounds, settings.Height());
wings[2] = settings.wingStrategy.GenerateWing(settings, thirdBounds, settings.Height());
}
else
{
wings[0] = ((WingStrategy)ScriptableObject.CreateInstance <DefaultWingStrategy>()).GenerateWing(settings, firstBounds, settings.Height());
wings[1] = ((WingStrategy)ScriptableObject.CreateInstance <DefaultWingStrategy>()).GenerateWing(settings, secondBounds, settings.Height());
wings[2] = ((WingStrategy)ScriptableObject.CreateInstance <DefaultWingStrategy>()).GenerateWing(settings, thirdBounds, settings.Height());
}
return(wings);
}
else
{
return(new Wing[]
{
settings.wingStrategy != null?
settings.wingStrategy.GenerateWing(settings, new RectInt(0, 0, settings.Size.x, settings.Size.y), settings.Height()) :
((WingStrategy)ScriptableObject.CreateInstance <DefaultWingStrategy>()).GenerateWing(settings, new RectInt(0, 0, settings.Size.x, settings.Size.y), settings.Height()),
});
}
}
/// <summary>
/// This is the method that actually does the work.
/// </summary>
/// <param name="DA">The DA object is used to retrieve from inputs and store in outputs.</param>
protected override void SolveInstance(IGH_DataAccess DA)
{
double _indoorTemp_ = 293.00;
bool _indoorConst_ = false;
DA.GetData(0, ref _indoorTemp_);
DA.GetData(1, ref _indoorConst_);
Active constTemperature = (_indoorConst_) ? Active.YES : Active.NO;
BuildingSettings buildingTemp = new BuildingSettings(_indoorTemp_, constTemperature);
DA.SetData(0, buildingTemp);
}
private static void SetProperties(JSONObject geo, Building building, BuildingSettings typeSettings)
{
building.name = "building " + geo["properties"]["id"].ToString();
if (geo["properties"].HasField("name"))
{
building.Name = geo["properties"]["name"].str;
}
building.Id = geo["properties"]["id"].ToString();
building.Type = geo["type"].str;
building.SortKey = (int)geo["properties"]["sort_key"].f;
building.Kind = typeSettings.Type.ToString();
building.Type = typeSettings.Type.ToString();
building.GetComponent <MeshRenderer>().material = typeSettings.Material;
}
private void CreateMesh(List <Vector3> corners, BuildingSettings typeSettings, MeshData data, Vector2 min, Vector2 size)
{
if (_useTriangulationNet)
{
CreateRoofTriangulation(corners, data);
}
else
{
CreateRoofClass(corners, data);
}
foreach (var c in corners)
{
data.UV.Add(new Vector2((c.x - min.x), (c.z - min.y)));
}
}
public override Roof GenerateRoof(BuildingSettings settings, RectInt bounds)
{
for (int i = 0; i < strategies.Length; i++)
{
if (Random.Range(0f, 1f) > (1f - randomChance) && useRandom)
{
return(new Roof((RoofType)Random.Range(0, 3)));
}
Roof roof = strategies[i].GenerateRoof(settings, bounds);
if (!roof.IsDefault)
{
return(roof);
}
}
return(new Roof(RoofType.Peak));
}
public override Story[] GenerateStories(BuildingSettings settings, RectInt bounds, int numberOfStories)
{
Story[] stories = new Story[numberOfStories];
for (int level = 0; level < numberOfStories; level++)
{
stories[level] = settings.storyStrategy != null?
settings.storyStrategy.GenerateStory(settings, bounds, level) :
((StoryStrategy)ScriptableObject.CreateInstance <DefaultStoryStrategy>()).GenerateStory(settings, bounds, level);
if (bounds.width > WidthShrinkAmount)
{
bounds = new RectInt(bounds.x, bounds.y, bounds.width - WidthShrinkAmount, bounds.height);
}
if (bounds.height > HeightShrinkAmount)
{
bounds = new RectInt(bounds.x, bounds.y, bounds.width, bounds.height - HeightShrinkAmount);
}
}
return(stories);
}
static List <Story> GenStories(BuildingSettings settings)
{
int numberOfStories = Random.Range(settings.MinNumberOfStories, settings.MaxNumberOfStories);
List <Story> stories = new List <Story>();
List <RectInt> bounds = new List <RectInt>();
bounds.Add(new RectInt(0, 0, settings.BuildingSize.x, settings.BuildingSize.y));
stories.Add(GenStory(settings, bounds, 1));
for (int i = 1; i < numberOfStories; i++)
{
Story prevStory = stories[stories.Count - 1];
stories.Add(GenStory(settings, prevStory.RectList, i + 1));
}
for (int i = 0; i < stories.Count() - 1; i++)
{
FixRoof(stories[i + 1], stories[i]);
}
return(stories);
}
public abstract Wing GenerateWing(BuildingSettings settings, RectInt bounds, int numberOfStories);
public abstract Wall[] GenerateWalls(BuildingSettings settings, RectInt bounds, int level);
private void CreateMesh(List <Vector3> corners, float min_height, float height, BuildingSettings typeSettings, MeshData data, Vector2 min, Vector2 size)
{
var vertsStartCount = _useTriangulationNet
? CreateRoofTriangulation(corners, height, data)
: CreateRoofClass(corners, height, data);
foreach (var c in corners)
{
data.UV.Add(new Vector2((c.x - min.x), (c.z - min.y)));
}
if (typeSettings.IsVolumetric)
{
float d = 0f;
Vector3 v1;
Vector3 v2;
int ind = 0;
for (int i = 1; i < corners.Count; i++)
{
v1 = data.Vertices[vertsStartCount + i - 1];
v2 = data.Vertices[vertsStartCount + i];
ind = data.Vertices.Count;
data.Vertices.Add(v1);
data.Vertices.Add(v2);
data.Vertices.Add(new Vector3(v1.x, min_height, v1.z));
data.Vertices.Add(new Vector3(v2.x, min_height, v2.z));
d = (v2 - v1).magnitude;
data.UV.Add(new Vector2(0, 0));
data.UV.Add(new Vector2(d, 0));
data.UV.Add(new Vector2(0, height));
data.UV.Add(new Vector2(d, height));
data.Indices.Add(ind);
data.Indices.Add(ind + 2);
data.Indices.Add(ind + 1);
data.Indices.Add(ind + 1);
data.Indices.Add(ind + 2);
data.Indices.Add(ind + 3);
}
v1 = data.Vertices[vertsStartCount];
v2 = data.Vertices[vertsStartCount + corners.Count - 1];
ind = data.Vertices.Count;
data.Vertices.Add(v1);
data.Vertices.Add(v2);
data.Vertices.Add(new Vector3(v1.x, min_height, v1.z));
data.Vertices.Add(new Vector3(v2.x, min_height, v2.z));
d = (v2 - v1).magnitude;
data.UV.Add(new Vector2(0, 0));
data.UV.Add(new Vector2(d, 0));
data.UV.Add(new Vector2(0, height));
data.UV.Add(new Vector2(d, height));
data.Indices.Add(ind);
data.Indices.Add(ind + 1);
data.Indices.Add(ind + 2);
data.Indices.Add(ind + 1);
data.Indices.Add(ind + 3);
data.Indices.Add(ind + 2);
}
}
public abstract Roof GenerateRoof(BuildingSettings settings, RectInt bounds);
public override Roof GenerateRoof(BuildingSettings settings, RectInt bounds)
{
return(new Roof());
}
private void CreateMesh(List <Vector3> corners, float height, BuildingSettings typeSettings, MeshData data, Vector2 min, Vector2 size)
{
_mesh = new TriangleNet.Mesh();
var inp = new InputGeometry(corners.Count);
for (int i = 0; i < corners.Count; i++)
{
var v = corners[i];
inp.AddPoint(v.x, v.z);
inp.AddSegment(i, (i + 1) % corners.Count);
}
_mesh.Behavior.Algorithm = TriangulationAlgorithm.SweepLine;
_mesh.Behavior.Quality = true;
_mesh.Triangulate(inp);
var vertsStartCount = data.Vertices.Count;
data.Vertices.AddRange(corners.Select(x => new Vector3(x.x, height, x.z)).ToList());
foreach (var tri in _mesh.Triangles)
{
data.Indices.Add(vertsStartCount + tri.P1);
data.Indices.Add(vertsStartCount + tri.P0);
data.Indices.Add(vertsStartCount + tri.P2);
}
foreach (var c in corners)
{
data.UV.Add(new Vector2((c.x - min.x), (c.z - min.y)));
}
if (typeSettings.IsVolumetric)
{
float d = 0f;
Vector3 v1;
Vector3 v2;
int ind = 0;
for (int i = 1; i < corners.Count; i++)
{
v1 = data.Vertices[vertsStartCount + i - 1];
v2 = data.Vertices[vertsStartCount + i];
ind = data.Vertices.Count;
data.Vertices.Add(v1);
data.Vertices.Add(v2);
data.Vertices.Add(new Vector3(v1.x, 0, v1.z));
data.Vertices.Add(new Vector3(v2.x, 0, v2.z));
d = (v2 - v1).magnitude;
data.UV.Add(new Vector2(0, 0));
data.UV.Add(new Vector2(d, 0));
data.UV.Add(new Vector2(0, height));
data.UV.Add(new Vector2(d, height));
data.Indices.Add(ind);
data.Indices.Add(ind + 2);
data.Indices.Add(ind + 1);
data.Indices.Add(ind + 1);
data.Indices.Add(ind + 2);
data.Indices.Add(ind + 3);
}
v1 = data.Vertices[vertsStartCount];
v2 = data.Vertices[vertsStartCount + corners.Count - 1];
ind = data.Vertices.Count;
data.Vertices.Add(v1);
data.Vertices.Add(v2);
data.Vertices.Add(new Vector3(v1.x, 0, v1.z));
data.Vertices.Add(new Vector3(v2.x, 0, v2.z));
d = (v2 - v1).magnitude;
data.UV.Add(new Vector2(0, 0));
data.UV.Add(new Vector2(d, 0));
data.UV.Add(new Vector2(0, height));
data.UV.Add(new Vector2(d, height));
data.Indices.Add(ind);
data.Indices.Add(ind + 1);
data.Indices.Add(ind + 2);
data.Indices.Add(ind + 1);
data.Indices.Add(ind + 3);
data.Indices.Add(ind + 2);
}
}
