Example #1
0
        public void Initialize(Instance inst, Dictionary <Instance, StaticGeometry> dict)
        {
            Instance        = inst;
            Instance.Object = Instance.Object ?? Item.GetDefinition <Importing.Items.Definitions.ObjectDef>(inst.ObjectId);

            Initialize(inst.Position, inst.Rotation);

            _canLoad = Instance.Object != null;

            name = _canLoad ? Instance.Object.ModelName : string.Format("Unknown ({0})", Instance.ObjectId);

            if (_canLoad && Instance.LodInstance != null)
            {
                LodChild           = dict[Instance.LodInstance];
                LodChild.LodParent = this;
            }

            _isVisible = false;
            gameObject.SetActive(false);
            gameObject.isStatic = true;
        }
Example #2
0
        internal void CreateStaticGeometry()
        {
            if (RootDivision == null)
            {
                RootDivision = Division.Create(transform);
                RootDivision.SetBounds(
                    new Vector2(-3000f, -3000f),
                    new Vector2(+3000f, +3000f));
            }

            var placements = Item.GetPlacements <Instance>(CellIds.ToArray());

            m_insts = new Dictionary <Instance, StaticGeometry> (48 * 1024);
            foreach (var plcm in placements)
            {
                m_insts.Add(plcm, StaticGeometry.Create());
            }
            //m_insts = placements.ToDictionary(x => x, x => StaticGeometry.Create());

            UnityEngine.Debug.Log("Num static geometries " + m_insts.Count);

            totalNumObjects = m_insts.Count;
        }
Example #3
0
        void Update()
        {
            if (RootDivision == null && Loader.HasLoaded)
            {
                RootDivision = Division.Create(transform);
                RootDivision.SetBounds(
                    new Vector2(-3000f, -3000f),
                    new Vector2(+3000f, +3000f));

                using (Utilities.Profiler.Start("Cell partitioning time")) {
                    var placements = Item.GetPlacements <Instance> (CellIds.ToArray());
                    var insts      = placements.ToDictionary(x => x, x => StaticGeometry.Create());

                    UnityEngine.Debug.Log("Num static geometries " + placements.Count() + ".");
                    totalNumObjects = placements.Count();

                    foreach (var inst in insts)
                    {
                        inst.Value.Initialize(inst.Key, insts);
                    }

                    //    if (NetConfig.IsServer) {
                    if (this.loadParkedVehicles)
                    {
                        var parkedVehicles = Item.GetPlacements <ParkedVehicle> (CellIds.ToArray());
                        var cars           = parkedVehicles.Select(x => VehicleSpawner.Create(x))
                                             .Cast <MapObject>()
                                             .ToArray();

                        UnityEngine.Debug.Log("Num parked vehicles " + parkedVehicles.Count() + ".");

                        RootDivision.AddRange(insts.Values.Cast <MapObject>().Concat(cars));
                    }
                    else
                    {
                        RootDivision.AddRange(insts.Values.Cast <MapObject>());
                    }
                }

                if (Water != null)
                {
                    using (Utilities.Profiler.Start("Water load time")) {
                        Water.Initialize(new WaterFile(Config.GetPath("water_path")));
                    }
                }

                _timer  = new Stopwatch();
                _leaves = RootDivision.ToList();
            }


            if (null == _leaves)
            {
                return;
            }

            _timer.Reset();
            _timer.Start();
            numLeavesLoadedThisFrame  = 0;
            numObjectsLoadedThisFrame = 0;
            foreach (var div in _leaves)
            {
                if (float.IsPositiveInfinity(div.LoadOrder))
                {
                    break;
                }

                numObjectsLoadedThisFrame += div.LoadWhile(() => _timer.Elapsed.TotalSeconds < 1d / 60d);

                if (_timer.Elapsed.TotalSeconds >= 1d / 60d)
                {
                    //	break;
                }
                else
                {
                    numLeavesLoadedThisFrame++;
                }
            }
            measuredTimes [2] = (float)_timer.Elapsed.TotalMilliseconds;
        }
Example #4
0
File: Cell.cs Project: CyberSys/UTA
        void Update()
        {
            if (RootDivision == null && Loader.HasLoaded)
            {
                RootDivision = Division.Create(transform);
                RootDivision.SetBounds(
                    new Vector2(-3000f, -3000f),
                    new Vector2(+3000f, +3000f));

                using (Utilities.Profiler.Start("Cell partitioning time")) {
                    var insts = Item.GetPlacements <Instance>(CellIds.ToArray())
                                .ToDictionary(x => x, x => StaticGeometry.Create());

                    foreach (var inst in insts)
                    {
                        inst.Value.Initialize(inst.Key, insts);
                    }

                    if (NetConfig.IsServer)
                    {
                        var cars = Item.GetPlacements <ParkedVehicle>(CellIds.ToArray())
                                   .Select(x => VehicleSpawner.Create(x))
                                   .Cast <MapObject>()
                                   .ToArray();

                        RootDivision.AddRange(insts.Values.Cast <MapObject>().Concat(cars));
                    }
                    else
                    {
                        RootDivision.AddRange(insts.Values.Cast <MapObject>());
                    }
                }

                if (Water != null)
                {
                    using (Utilities.Profiler.Start("Water load time")) {
                        Water.Initialize(new WaterFile(Config.GetPath("water_path")));
                    }
                }

                _timer  = new Stopwatch();
                _leaves = RootDivision.ToList();
            }

            if (_leaves == null)
            {
                return;
            }

            var pos    = Focus.position;
            var toLoad = _leaves.Aggregate(false, (current, leaf) => current | leaf.RefreshLoadOrder(pos));

            if (!toLoad)
            {
                return;
            }

            _leaves.Sort();

            _timer.Reset();
            _timer.Start();

            foreach (var div in _leaves)
            {
                if (float.IsPositiveInfinity(div.LoadOrder))
                {
                    break;
                }
                if (!div.LoadWhile(() => _timer.Elapsed.TotalSeconds < 1d / 60d))
                {
                    break;
                }
            }
        }