示例#1
0
        /// <summary> Builds instance responsible for composing object graph. </summary>
        private static CompositionRoot BuildCompositionRoot(IContainer container, ITrace trace)
        {
            // create configuration from default overriding some properties
            var config = ConfigBuilder.GetDefault()
                         .SetIndex("Index/")
                         .Build();

            // create entry point for utymap functionallity
            var compositionRoot = new CompositionRoot(container, config)
                                  // override default services with unity specific implementation
                                  .RegisterAction((c, _) => c.RegisterInstance <ITrace>(trace))
                                  .RegisterAction((c, _) => c.Register(Component.For <IPathResolver>().Use <UnityPathResolver>()))
                                  .RegisterAction((c, _) => c.Register(Component.For <INetworkService>().Use <UnityNetworkService>()))
                                  .RegisterAction((c, _) => c.Register(Component.For <IMapDataLibrary>().Use <MapDataLibrary>()))
                                  // register scene specific services (plugins)
                                  .RegisterAction((c, _) => c.Register(Component.For <UnityModelBuilder>().Use <UnityModelBuilder>()))
                                  .RegisterAction((c, _) => c.Register(Component.For <MaterialProvider>().Use <MaterialProvider>()))
                                  // register default mapcss
                                  .RegisterAction((c, _) => c.Register(Component.For <Stylesheet>().Use <Stylesheet>(@"MapCss/default/default.mapcss")));

            // setup object graph
            compositionRoot.Setup();

            return(compositionRoot);
        }
示例#2
0
        /// <summary> Builds instance responsible for composing object graph. </summary>
        private static CompositionRoot BuildCompositionRoot(Action <IContainer, IConfigSection> action, ITrace trace)
        {
            // create entry point for library functionallity using default configuration overriding some properties
            var root = new CompositionRoot(new Container(), ConfigBuilder.GetDefault().SetIndex("index").Build())
                       // override library's default services with demo specific implementations
                       .RegisterAction((container, config) =>
            {
                container
                .RegisterInstance <ITrace>(trace)
                .Register(Component.For <IPathResolver>().Use <UnityPathResolver>())
                .Register(Component.For <INetworkService>().Use <UnityNetworkService>())
                .Register(Component.For <IMapDataLibrary>().Use <MapDataLibrary>());
            })
                       // override with scene specific implementations
                       .RegisterAction(action)
                       // setup object graph
                       .Setup();

            // Register default data storages: one keeps data on disk, another one - in memory.
            // You are not limited with these two: you can add more disk and/or memory storages.
            // NOTE First registered storage will be used to save map data received from downloaded data
            var mapDataStore = root.GetService <IMapDataStore>();

            mapDataStore.Register(MapDataStorages.PersistentStorageKey, @"index/data");
            mapDataStore.Register(MapDataStorages.TransientStorageKey);

            // Enable mesh caching.
            root.GetService <IMapDataLibrary>().EnableCache();

            return(root);
        }
    void Start()
    {
        // init utymap library
        _compositionRoot = InitTask.Run((container, config) =>
        {
            container
            .Register(Component.For <Stylesheet>().Use <Stylesheet>(@"mapcss/ground/ground.mapcss"))
            .Register(Component.For <MaterialProvider>().Use <MaterialProvider>())
            .Register(Component.For <GameObjectBuilder>().Use <GameObjectBuilder>())
            .Register(Component.For <IGeocoder>().Use <UtyMapGeocoder>())
            .Register(Component.For <IElementBuilder>().Use <PlaceElementBuilder>().Named("place"));
        });

        // initial geo position and quad key of character
        var coordinate = new GeoCoordinate(StartLatitude, StartLongitude);
        var quadKey    = GeoUtils.CreateQuadKey(coordinate, LevelOfDetail);

        // init address controller which is responsible for searching address
        _addressController = new AddressController(
            _compositionRoot.GetService <IGeocoder>(),
            Text.GetComponent <Text>());

        // init tile controller which is responsible for tile processing
        _tileController = new TileController(
            _compositionRoot.GetService <IMapDataStore>(),
            _compositionRoot.GetService <Stylesheet>(),
            ElevationType,
            coordinate,
            LevelOfDetail);

        // freeze target till initial tile is loaded
        var rigidbody = CharacterTarget.transform.GetComponent <Rigidbody>();

        rigidbody.isKinematic = true;
        // TODO unsubscribe listener
        _compositionRoot
        .GetService <IMapDataStore>()
        .ObserveOn <Tile>(Scheduler.MainThread)
        .Subscribe(tile =>
        {
            if (!quadKey.Equals(tile.QuadKey))
            {
                return;
            }

            // get elevation at current position
            var elevation = _compositionRoot
                            .GetService <IMapDataLibrary>()
                            .GetElevation(ElevationType, quadKey, coordinate);
            // move character accordingly
            CharacterTarget.transform.localPosition = new Vector3(
                CharacterTarget.transform.localPosition.x,
                (float)elevation + 5f,
                CharacterTarget.transform.localPosition.z);
            rigidbody.isKinematic = false;
        });
    }
示例#4
0
 /// <summary> Builds instance responsible for composing object graph. </summary>
 private static CompositionRoot BuildCompositionRoot(Action <IContainer, IConfigSection> action, ITrace trace)
 {
     // create entry point for library functionallity using default configuration overriding some properties
     return(new CompositionRoot(new Container(), ConfigBuilder.GetDefault().SetIndex("index/").Build())
            // override library's default services with demo specific implementations
            .RegisterAction((container, config) =>
     {
         container
         .RegisterInstance <ITrace>(trace)
         .Register(Component.For <IPathResolver>().Use <UnityPathResolver>())
         .Register(Component.For <INetworkService>().Use <UnityNetworkService>())
         .Register(Component.For <IMapDataLibrary>().Use <MapDataLibrary>());
     })
            // override with scene specific implementations
            .RegisterAction(action)
            // setup object graph
            .Setup());
 }