public static void SelectBuilding(SGBuilding b)
{
_selectedBuilding = b;
BuildingParamEditor bpe = buildingParamEditor;
bpe.SetBuilding(b);
}
public static void UnSelectBuilding()
{
_selectedBuilding = null;
BuildingParamEditor bpe = buildingParamEditor;
//BuildingParamEditor bpe = GameObject.Find("BuildingParams").GetComponent<BuildingParamEditor>();
bpe.SetBuilding(null);
}
public void SetBuilding(SGBuilding b)
{
//if (b == null)
//{
// Clear();
// return;
//}
if (building != null)
{
building.buildingParamEditor = null;
}
building = b;
b.buildingParamEditor = this;
readParamOnly = true;
b.UpdateParams();
UpdateBuildingParamDisplay();
readParamOnly = false;
}
public override void Execute()
{
base.Execute();
List <SGBuilding> buildings = new List <SGBuilding>();
foreach (ShapeObject o in inputs.shapes)
{
SGBuilding sgbuilding = o.parentRule.sgbuilding;
if (!buildings.Contains(sgbuilding))
{
buildings.Add(sgbuilding);
}
}
foreach (SGBuilding sgbuilding in buildings)
{
sgbuilding.UpdateParamDisplay();
}
}
// Use this for initialization
void Start()
{
Vector3[] pts = new Vector3[]
{
new Vector3(),
new Vector3(35, 0, -4),
new Vector3(50, 0, 0),
new Vector3(50, 0, 15),
new Vector3(0, 0, 15)
};
SOPoint sop = SOPoint.CreatePoint();
SGBuilding b1 = new SGBuilding();
ShapeObject so2 = ShapeObject.CreateExtrusion(pts, 30);
so2.meshable.bbox = BoundingBox.CreateFromPoints(so2.meshable.vertices, new Vector3(1, 0, 0));
b1.SetGPlanning(G2(so2));
b1.SetMassing(MassingGrammars.GB());
b1.SetProgram(ProgramGrammars.APT1());
b1.SetFacade(FacadeGrammars.CW01());
SGBuilding b2 = new SGBuilding();
SOPoint so3 = SOPoint.CreatePoint(new Vector3(20, 0, 40));
b2.SetGPlanning(G1(so3, 40, 60));
b2.SetMassing(MassingGrammars.GA());
b2.SetProgram(ProgramGrammars.APT1());
b2.SetFacade(FacadeGrammars.CW01());
SceneManager.SelectedGrammar = b2.gPlaning;
SceneManager.SelectedBuilding = b2;
b1.MassingMode();
b2.MassingMode();
//b1.Execute();
//b2.Execute();
b2.UpdateParams();
}
// Use this for initialization
void Start()
{
List <SGBuilding> buildings = new List <SGBuilding>();
for (int i = 0; i < 5; i++)
{
SOPoint sop = SOPoint.CreatePoint(new Vector3(i * 40, 0, 0));
SGBuilding building = SGBuilding.CreateApt(sop, new Vector3(30, 60, 15));
building.Execute();
buildings.Add(building);
}
buildings[buildings.Count - 1].ClearAllAssociated();
buildings.RemoveAt(buildings.Count - 1);
//building.ClearForDestroy();
//Destroy(sop.gameObject);
//building.Clear();
}
public static SGBuilding CreateApt(SOPoint sop, Vector3 size)
{
SGBuilding building = new SGBuilding();
Grammar gp = new Grammar();
gp.name = "planing1";
gp.inputs.shapes.Add(sop);
gp.AddRule(new Rules.CreateOperableBox("A", new Vector3(30, 30, 20)));
gp.AddRule(new Rules.SizeBuilding3D("A", "A", new Vector3(30, 20, 15)));
gp.AddRule(new Rules.ResidentialLoadFilter("A", "IHUS", "DHUS", "A"));
gp.AddRule(new Rules.ApartmentLoadFilter("A", "SL", "DL", "CV"), false);
gp.AddRule(new Rules.SingleLoaded("SL", "APT"), false);
gp.AddRule(new Rules.DoubleLoaded("DL", "APT"), false);
gp.AddRule(new Rules.CentralVoid("CV", "APT", "APT2"), false);
building.SetGPlanning(gp);
building.SetMassing(MassingGrammars.GA());
//building.SetFacade(FacadeGrammars.CW01());
building.SetSize(size);
sop.grammar = gp;
//sop.onPositionChanged += delegate { building.Execute(); };
//sop.onDestroy += delegate { building.ClearForDestroy(); };
return(building);
}
public override void Execute()
{
Debug.Log("executing " + name);
Dictionary <SGBuilding, List <Meshable> > container = new Dictionary <SGBuilding, List <Meshable> >();
foreach (ShapeObject o in inputs.shapes)
{
if (o.parentRule.grammar == null || o.parentRule.grammar.building == null)
{
continue;
}
SGBuilding b = o.parentRule.grammar.sgbuilding;
//Debug.Log(b.mode.ToString());
//Debug.LogFormat("b.mode==unit{0}", b.mode == Building.DisplayMode.UNIT);
if (b.displayMode != SGBuilding.DisplayMode.PROGRAM)
{
continue;
}
Debug.Log("getting units");
if (!container.ContainsKey(b))
{
container[b] = new List <Meshable>();
}
Meshable[] units = SGUtility.DivideFormToLength(o.meshable, 3, 0);
container[b].AddRange(units);
}
foreach (KeyValuePair <SGBuilding, List <Meshable> > kv in container)
{
SGBuilding b = kv.Key;
b.units = new List <List <Meshable> >();
b.units.Add(kv.Value);
}
outputs.shapes = inputs.shapes;
}
public override void Execute()
{
if (matrix == null)
{
return;
}
PlaningScheme scheme = matrix.recommendedScheme;
//Debug.Log("scheme="+scheme);
if (scheme == null)
{
return;
}
//Debug.Log("has scheme");
int total = 0;
for (int i = 0; i < scheme.counts.Count; i++)
{
total += scheme.counts[i];
}
total = Mathf.Clamp(total, 0, inputs.shapes.Count);
if (buildings == null)
{
buildings = new List <SGBuilding>();
}
else
{
//先删除多出来的building
int dif = buildings.Count - total;
for (int i = 0; i < dif; i++)
{
int index = buildings.Count - 1;
buildings[index].ClearAllAssociated();
buildings.RemoveAt(index);
}//for
}
int typeIndex = 0;
int nextLevel = scheme.counts[0];
for (int i = 0; i < total; i++)
{
if (i >= nextLevel)
{
//Debug.LogFormat("i={0}, typeIndex={1}, total={2}", i, typeIndex,total);
typeIndex++;
nextLevel = nextLevel + scheme.counts[typeIndex];
}
ShapeObject so = inputs.shapes[i];
//补足不够的building
if (i >= buildings.Count)
{
SOPoint sop = SOPoint.CreatePoint(new Vector3(i * 40, 0, 0));
SGBuilding building = SGBuilding.CreateApt(sop, new Vector3(30, 60, 15));
building.Execute();
buildings.Add(building);
}
BuildingType bt = scheme.buildingTypes[typeIndex];
Vector3 size = new Vector3(bt.width, bt.height, bt.depth);
SGBuilding b = buildings[i];
b.gPlaning.inputs.shapes[0].Position = so.Position;
b.SetSize(size);
b.Execute();
}//for
//update particle system
if (psys != null)
{
psys.particles.Clear();
for (int i = 0; i < buildings.Count; i++)
{
GraphNode g = buildings[i].gPlaning;
ShapeObject sop = g.inputs.shapes[0];
psys.particles.Add(sop);
}
}
}
//private Grammar tobeReplaced;
public GrammarItem(string name, Type nodeType, SGBuilding building) : base(name)
{
this.nodeType = nodeType;
this.building = building;
}
