Пример #1
0
    public static void SelectBuilding(SGBuilding b)
    {
        _selectedBuilding = b;
        BuildingParamEditor bpe = buildingParamEditor;

        bpe.SetBuilding(b);
    }
Пример #2
0
    public static void UnSelectBuilding()
    {
        _selectedBuilding = null;
        BuildingParamEditor bpe = buildingParamEditor;

        //BuildingParamEditor bpe = GameObject.Find("BuildingParams").GetComponent<BuildingParamEditor>();
        bpe.SetBuilding(null);
    }
Пример #3
0
    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;
    }
Пример #4
0
        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();
            }
        }
Пример #5
0
    // 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();
    }
Пример #6
0
    // 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();
    }
Пример #7
0
    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);
    }
Пример #8
0
        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;
        }
Пример #9
0
        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);
                }
            }
        }
Пример #10
0
    //private Grammar tobeReplaced;

    public GrammarItem(string name, Type nodeType, SGBuilding building) : base(name)
    {
        this.nodeType = nodeType;
        this.building = building;
    }