/// <summary>
        /// Create a <see cref="MapsService"/> to load geometry.
        /// </summary>
        private void Start()
        {
            // Verify that a Sun and Moon Controller has been defined.
            if (SunAndMoonController == null)
            {
                ExampleErrors.MissingParameter(this, SunAndMoonController, "Sun and Moon Controller");

                return;
            }

            // Get required BuildingTexturer component on this GameObject.
            BuildingTexturer buildingTexturer = GetComponent <BuildingTexturer>();

            // Get required Emission Controller component, and give the Building Wall Materials to it so
            // that the building windows can be lit up at night time.
            GetComponent <EmissionController>().SetMaterials(buildingTexturer.WallMaterials);

            // Get required Dynamic Maps Service component on this GameObject.
            DynamicMapsService dynamicMapsService = GetComponent <DynamicMapsService>();

            // Sign up to event called after each new building is loaded, so can assign Materials to this
            // new building. Note that:
            // - DynamicMapsService.MapsService is auto-found on first access (so will not be null).
            // - This event must be set now during Awake, so that when Dynamic Maps Service starts loading
            //   the map during Start, this event will be triggered for all Extruded Structures.
            dynamicMapsService.MapsService.Events.ExtrudedStructureEvents.DidCreate.AddListener(
                args => buildingTexturer.AssignNineSlicedMaterials(args.GameObject));

            // Sign up to event called after all buildings have been loaded, so can start animating
            // day-night cycle.
            dynamicMapsService.MapsService.Events.MapEvents.Loaded.AddListener(
                args => SunAndMoonController.StartAnimating());
        }
    /// <summary>
    /// Assign a randomly chosen Wall and Roof <see cref="Material"/> to a given building.
    /// </summary>
    /// <param name="building">Building to assign <see cref="Material"/>s to.</param>
    /// <param name="index">
    /// Optional index of Wall and Roof <see cref="Material"/> pair to apply. If this value is not
    /// set a random <see cref="Material"/> pair will be used.
    /// </param>
    internal void AssignNineSlicedMaterials(GameObject building, int?index = null)
    {
        // If a specific Material index was given, verify it is a valid index for a Wall and Roof
        // Material pair.
        if (index.HasValue)
        {
            if (index.Value < 0 || index.Value >= WallMaterials.Length)
            {
                Debug.LogError(ExampleErrors.InvalidArrayIndex(this, WallMaterials, "Wall Materials",
                                                               index.Value));
                return;
            }
        }
        else
        {
            // Pick a random Material index to use for both Wall and Roof Materials. Not that the same
            // index will work for both arrays of Materials, as we have already verified that the Wall and
            // Roof Material arrays are the same length.
            index = Random.Range(0, WallMaterials.Length);
        }

        // Replace building MeshRenderer's sharedMaterials array with chosen Materials. Note that this
        // must be done by creating a new array of Materials, rather than altering the entries of this
        // MeshRenderer's sharedMaterials array, as altering the existing array will not actually
        // change the MeshRenderer's Materials.
        MeshRenderer buildingMeshRenderer = building.GetComponent <MeshRenderer>();

        buildingMeshRenderer.sharedMaterials = new Material[] {
            WallMaterials[index.Value], RoofMaterials[index.Value]
        };
    }
    /// <summary>
    /// Make sure the given <see cref="NearDistance"/> and <see cref="FarDistance"/> define a valid
    /// distance range.
    /// </summary>
    /// <returns>
    /// True if <see cref="NearDistance"/> and <see cref="FarDistance"/> are both positive, and if
    /// <see cref="NearDistance"/> is greater than <see cref="FarDistance"/> (otherwise a specific
    /// error message will be shown).
    /// </returns>
    private bool VerifyRange()
    {
        // Make sure both given distances are positive.
        if (NearDistance <= 0f)
        {
            Debug.LogError(ExampleErrors.NotGreaterThanZero(this, NearDistance, "Near Distance"));
            return(false);
        }
        if (FarDistance <= 0f)
        {
            Debug.LogError(ExampleErrors.NotGreaterThanZero(this, FarDistance, "Far Distance"));
            return(false);
        }

        // Make sure the given far distance is greater than near distance.
        if (FarDistance <= NearDistance)
        {
            Debug.LogError(ExampleErrors
                           .NotGreaterThan(this, FarDistance, "Far Distance", NearDistance, "Near Distance"));
            return(false);
        }

        // If have reached this point then given near and far distances are valid, so return true.
        return(true);
    }
    /// <summary>Connect camera to slider.</summary>
    private void Awake()
    {
        // Make sure the given near and far distances are valid, skipping setup if not.
        if (!VerifyRange())
        {
            return;
        }

        // Get required SliderController for getting input from UI Slider.
        SliderController = GetComponent <SliderController>();

        // Make sure that given start distance is within range of given near and far distances.
        if (StartDistance < NearDistance || StartDistance > FarDistance)
        {
            Debug.LogError(ExampleErrors
                           .OutsideRange(this, StartDistance, "Start Distance", NearDistance, FarDistance));
            StartDistance = Mathf.Clamp(StartDistance, NearDistance, FarDistance);
        }

        // Convert start distance to a percent of near and far distances, and adjust slider to this
        // value.
        float sliderFraction = (StartDistance - NearDistance) / (FarDistance - NearDistance);

        OnSlider(sliderFraction);

        // Set slider's starting value, and only after have done so, connect future changes in slider
        // input to zooming in and out.
        SliderController.SetStartingValue(sliderFraction);
        SliderController.OnChange += OnSlider;
    }
    /// <summary>
    /// Verify that all required parameters have been correctly defined, showing a specific error and
    /// returning false if not.
    /// </summary>
    private bool VerifyParameters()
    {
        // Verify this scene has a main Camera.
        if (Camera.main == null)
        {
            Debug.LogError(ExampleErrors.NullMainCamera(this, "to keep the AR Compass Map in front of"));
            return(false);
        }

        // Verify a Background UI element has been given, and that it has a default texture (to use as
        // a backup if augmented reality mode is not available).
        if (Background == null)
        {
            Debug.LogError(ExampleErrors.MissingParameter(this, Background, "Background",
                                                          "to show the real world background on device"));
            return(false);
        }
        if (Background.texture == null)
        {
            Debug.LogErrorFormat("No default texture applied to {0}, defined as {1}.{2}.Background.\n"
                                 + "This UI element must have a default texture to use if AR mode is not available on "
                                 + "device.",
                                 Background.name, name, GetType());
            return(false);
        }

        // If we have reached this point then we have verified that all required parts are present and
        // properly setup.
        return(true);
    }
    /// <summary>
    /// Use <see cref="DynamicMapsService"/> to load geometry, replacing any buildings as needed.
    /// </summary>
    private void Awake()
    {
        // Make sure a prefab has been specified.
        if (Prefab == null)
        {
            Debug.LogError(ExampleErrors.MissingParameter(this, Prefab, "Prefab",
                                                          "to replace specific buildings with"));
            return;
        }

        // Get required DynamicMapsService component on this GameObject.
        DynamicMapsService dynamicMapsService = GetComponent <DynamicMapsService>();

        // See if any options have been set indicating which types of buildings to replace, signing up
        // to WillCreate events if so.
        if (ReplaceBars || ReplaceBanks || ReplaceLodgings || ReplaceCafes || ReplaceRestaurants ||
            ReplaceEventVenues || ReplaceTouristDestinations || ReplaceShops || ReplaceSchools ||
            ReplaceUnspecifieds)
        {
            // Create styles for ExtrudedStructure and ModeledStructure type buildings that are to be
            // replaced with a prefab.
            ExtrudedStructureStyle extrudedPrefabStyle = new ExtrudedStructureStyle.Builder {
                Prefab = Prefab
            }.Build();
            ModeledStructureStyle modeledPrefabStyle = new ModeledStructureStyle.Builder {
                Prefab = Prefab
            }.Build();

            // Sign up to events called just before any new building is loaded, so we can check each
            // building's usage type and replace it with prefab if needed. Note that:
            // - DynamicMapsService.MapsService is auto-found on first access (so will not be null).
            // - These events must be set now during Awake, so that when DynamicMapsService starts
            //   loading the map during Start, these event will be triggered for all ExtrudedStructures
            //   and ModeledStructures.
            dynamicMapsService.MapsService.Events.ExtrudedStructureEvents.WillCreate.AddListener(args => {
                if (ShouldReplaceBuilding(args.MapFeature.Metadata.Usage))
                {
                    args.Style = extrudedPrefabStyle;
                }
            });
            dynamicMapsService.MapsService.Events.ModeledStructureEvents.WillCreate.AddListener(args => {
                if (ShouldReplaceBuilding(args.MapFeature.Metadata.Usage))
                {
                    args.Style = modeledPrefabStyle;
                }
            });
        }

        // See if we should be replacing any suppressed buildings with prefab, signing up to DidCreate
        // event if so.
        if (ReplaceSuppressed)
        {
            // Sign up to event called just after any new building is loaded, so we can check if the
            // building's mesh has been suppressed and should be replaced with a prefab.
            dynamicMapsService.MapsService.Events.ExtrudedStructureEvents.DidCreate.AddListener(
                args => TryReplaceSuppressedBuilding(args.GameObject));
            dynamicMapsService.MapsService.Events.ModeledStructureEvents.DidCreate.AddListener(
                args => TryReplaceSuppressedBuilding(args.GameObject));
        }
    }
        /// <summary>
        /// Check that we have a <see cref="BaseMapLoader"/> so that we can register appropriate
        /// listeners in OnEnable.
        /// </summary>
        protected override void Awake()
        {
            if (BaseMapLoader == null)
            {
                Debug.LogError(ExampleErrors.MissingParameter(
                                   this, BaseMapLoader, "Base Map Loader", "is required for this script to work."));
            }

            base.Awake();
        }
    /// <summary>
    /// Create a <see cref="MapsService"/> to load buildings, then add borders around their bases and
    /// around the edges of roads.
    /// </summary>
    private void Start()
    {
        // Verify a Building Base Material has been given.
        if (BuildingAndRoadBorder == null)
        {
            Debug.LogError(ExampleErrors.MissingParameter(this, BuildingAndRoadBorder,
                                                          "Building And Road Border", "to apply around the bases of buildings"));
            return;
        }

        // Verify a Roads Material has been given.
        if (Roads == null)
        {
            Debug.LogError(ExampleErrors.MissingParameter(this, Roads, "Roads", "to apply to roads"));
            return;
        }

        // Get the required Dynamic Maps Service on this GameObject.
        DynamicMapsService dynamicMapsService = GetComponent <DynamicMapsService>();

        // Create a roads style that defines a material for roads and for borders of roads. The specific
        // border material used is chosen to look just a little darker than the material of the ground
        // plane (helping the roads to visually blend into the surrounding ground).
        SegmentStyle roadsStyle = new SegmentStyle.Builder {
            Material       = Roads,
            BorderMaterial = BuildingAndRoadBorder,
            Width          = 7.0f,
            BorderWidth    = 1.0f
        }.Build();

        // Get default style options.
        GameObjectOptions renderingStyles = ExampleDefaults.DefaultGameObjectOptions;

        // Replace default roads style with new, just created roads style.
        renderingStyles.SegmentStyle = roadsStyle;

        // Get required BuildingTexturer component on this GameObject.
        BuildingTexturer buildingTexturer = GetComponent <BuildingTexturer>();

        // Sign up to event called after each new building is loaded, so can assign Materials to this
        // new building, and add an extruded base around the building to fake an Ambient Occlusion
        // contact shadow. Note that:
        // - DynamicMapsService.MapsService is auto-found on first access (so will not be null).
        // - This event must be set now during Awake, so that when Dynamic Maps Service starts loading
        //   the map during Start, this event will be triggered for all Extruded Structures.
        dynamicMapsService.MapsService.Events.ExtrudedStructureEvents.DidCreate.AddListener(args => {
            // Apply nine sliced wall and roof materials to this building.
            //  buildingTexturer.AssignNineSlicedMaterials(args.GameObject);

            // Add a border around base to building using Building Border Builder class, coloring it using
            // the given border Material.
            Extruder.AddBuildingBorder(args.GameObject, args.MapFeature.Shape, BuildingAndRoadBorder);
        });
    }
Beispiel #9
0
        private void Awake()
        {
            // Verify that we have a base map loader available

            // Get the required base map loader
            if (BaseMapLoader == null)
            {
                Debug.LogError(ExampleErrors.MissingParameter(
                                   this, BaseMapLoader, "Base Map Loader", "is required for this script to work."));
            }
        }
Beispiel #10
0
        /// <summary>
        /// Make sure all required parameters are given, and connect to <see cref="MapsService"/>'s
        /// <see cref="Google.Maps.Event.MapEvents.Progress"/> event so we can display loading progress
        /// on screen.
        /// </summary>
        void Awake()
        {
            if (BaseMapLoader == null)
            {
                Debug.LogError(ExampleErrors.MissingParameter(
                                   this, BaseMapLoader, "Base Map Loader", "is required for this script to work."));

                return;
            }

            HideProgressBar();
        }
Beispiel #11
0
    /// <summary>
    /// Setup <see cref="Slider"/>.
    /// </summary>
    private void Awake()
    {
        // Make sure we have a UI Slider to work with, printing an error if not.
        if (Slider == null)
        {
            Debug.LogError(ExampleErrors.MissingParameter(this, Slider, "Slider"));
            return;
        }

        // Connect changes in Slider's value to given action.
        Slider.onValueChanged.AddListener(TryOnChange);
    }
Beispiel #12
0
    /// <summary>
    /// Verify that all required parameters have been correctly defined, returning false if not.
    /// </summary>
    private bool VerifyParameters()
    {
        // Verify that all required Materials have been given.
        if (Buildings == null)
        {
            Debug.LogError(ExampleErrors.MissingParameter(
                               this, Buildings, "Buildings", "to assign to buildings"));
            return(false);
        }
        if (Roads == null)
        {
            Debug.LogError(ExampleErrors.MissingParameter(
                               this, Roads, "Roads", "to assign to road segments"));
            return(false);
        }
        if (Borders == null)
        {
            Debug.LogError(ExampleErrors.MissingParameter(
                               this, Borders, "Borders", "to assign to the borders of road segments and buildings"));
            return(false);
        }
        if (Ground == null)
        {
            Debug.LogError(ExampleErrors.MissingParameter(
                               this, Ground, "Ground", "to assign to ground regions"));
            return(false);
        }
        if (Water == null)
        {
            Debug.LogError(ExampleErrors.MissingParameter(this, Water, "Water", "to assign to water"));
            return(false);
        }

        // Verify at least one of the given Materials' Shader has a Vector that can be used for
        // providing the world's Floating Origin.
        if (!Buildings.HasProperty(MaterialOffsetProperty) &&
            !Roads.HasProperty(MaterialOffsetProperty) &&
            !Borders.HasProperty(MaterialOffsetProperty) &&
            !Ground.HasProperty(MaterialOffsetProperty) &&
            !Water.HasProperty(MaterialOffsetProperty))
        {
            Debug.LogErrorFormat("No '{0}' property found on any of the Shaders of any of the Materials "
                                 + "given to {1}.{2}.\n{2} is used to adjust the offset of this Material's world space "
                                 + "texture coordinates, but given none of the given Materials had a '{0}' property to "
                                 + "use for this purpose, {1}.{2} will be disabled.",
                                 MaterialOffsetProperty, name, GetType());
        }

        // If have reached this point then have verified that all required parts are present and
        // properly setup.
        return(true);
    }
Beispiel #13
0
        /// <summary>
        /// Use <see cref="MapsService"/> to load geometry, labelling all created roads with their
        /// names.
        /// </summary>
        void Awake()
        {
            // Get the required base map loader.
            if (BaseMapLoader == null)
            {
                Debug.LogError(ExampleErrors.MissingParameter(
                                   this, BaseMapLoader, "Base Map Loader", "is required for this script to work."));
            }

            // Register listeners prior to loading the map.
            BaseMapLoader.MapsService.Events.ExtrudedStructureEvents.DidCreate.AddListener(
                OnExtrudedStructureCreated);
            BaseMapLoader.MapsService.Events.ModeledStructureEvents.DidCreate.AddListener(
                OnModeledStructureCreated);
            BaseMapLoader.MapsService.Events.MapEvents.Loaded.AddListener(OnMapLoaded);
        }
Beispiel #14
0
    /// <summary>Make sure all required parameters are given.</summary>
    private void Awake()
    {
        // Make sure a canvas has been specified.
        if (Canvas == null)
        {
            Debug.LogError(ExampleErrors.MissingParameter(this, Canvas, "Canvas", "to show road names"));
            return;
        }

        // Make sure a prefab has been specified.
        if (LabelPrefab == null)
        {
            Debug.LogError(ExampleErrors.MissingParameter(this, LabelPrefab, "LabelPrefab",
                                                          "to use to display names above roads in scene"));
        }
    }
    /// <summary>
    /// Verify that all required parameters have been correctly defined, returning false if not.
    /// </summary>
    private bool VerifyParameters()
    {
        // Verify that an Emission Controller has been defined.
        if (EmissionController == null)
        {
            Debug.LogError(ExampleErrors.MissingParameter(this, EmissionController, "Emission Controller",
                                                          "to control the emission values of in-scene lights/windows"));
            return(false);
        }

        // Get required light on this gameObject and make sure it is a directional light.
        Light = GetComponent <Light>();
        if (Light.type != LightType.Directional)
        {
            Debug.LogWarningFormat("{0}.{1} found a {2}-light attached to {0}, when a Directional Light "
                                   + "was expected.\n Changing type from {2} to Directional.",
                                   name, GetType(), Light.type);
            Light.type = LightType.Directional;
        }

        // Verify given Fog Distances.
        if (FogStart < 0f)
        {
            Debug.LogError(ExampleErrors.NotGreaterThanZero(this, FogStart, "Fog Start distance",
                                                            ", as this represents the Linear Fog Start Distance for the scene"));
            return(false);
        }
        if (FogEnd < FogStart)
        {
            Debug.LogError(ExampleErrors.NotGreaterThan(this, FogEnd, "Fog End distance", FogStart,
                                                        "Fog Start distance"));
            return(false);
        }

        // Verify given Render Distance is positive.
        if (RenderDistance < 0f)
        {
            Debug.LogError(ExampleErrors.NotGreaterThanZero(this, RenderDistance, "Render Distance",
                                                            ", as this represents the Camera's far Clipping Plane"));
            return(false);
        }

        // If have reached this point then have verified that all required parts are present and
        // properly setup.
        return(true);
    }
Beispiel #16
0
        /// <summary>Make sure all required parameters are given.</summary>
        protected virtual void Awake()
        {
            // Make sure a canvas has been specified.
            if (Canvas == null)
            {
                Debug.LogError(ExampleErrors.MissingParameter(this, Canvas, "Canvas", "to show labels"));

                return;
            }

            // Make sure a prefab has been specified.
            if (LabelPrefab == null)
            {
                Debug.LogError(ExampleErrors.MissingParameter(
                                   this, LabelPrefab, "Label", "to use to display labels for objects in scene"));
            }
        }
Beispiel #17
0
        // Start is called before the first frame update
        void Start()
        {
            IsReady = true;

            if (BaseMapLoader == null)
            {
                Debug.LogError(ExampleErrors.MissingParameter(
                                   this, BaseMapLoader, "Base Map Loader", "is required for this script to work."));
                IsReady = false;
            }

            if (PathFindingExample == null)
            {
                Debug.LogError(ExampleErrors.MissingParameter(
                                   this,
                                   PathFindingExample,
                                   "Path Finding Example",
                                   "is required for this script to work."));
                IsReady = false;
            }

            if (RoadLatticeNodesVisualizer == null)
            {
                Debug.LogError(ExampleErrors.MissingParameter(
                                   this,
                                   RoadLatticeNodesVisualizer,
                                   "Road Lattice Nodes Visualizer",
                                   "is required for this script to work."));
                IsReady = false;
            }

            if (ShowRoadLatticeToggle != null)
            {
                ShowRoadLatticeToggle.isOn = RoadLatticeNodesVisualizer.RoadLattice.activeSelf;
            }

            if (ShowAIPathsToggle != null)
            {
                ShowAIPathsToggle.isOn = PathFindingExample.IsDebugPathOn;
            }

            if (ActivateAIBotsToggle != null)
            {
                ActivateAIBotsToggle.isOn = PathFindingExample.IsAISearchActive;
            }
        }
Beispiel #18
0
        void Awake()
        {
            // Verify all required parameters are defined and correctly setup, skipping any further setup
            // if any parameter is missing or invalid.
            if (!VerifyParameters())
            {
                // Disable this script to prevent error spamming (where Update will producing one or more
                // errors every frame because one or more parameters are undefined).
                enabled = false;
            }

            // Get the required base map loader
            if (BaseMapLoader == null)
            {
                Debug.LogError(ExampleErrors.MissingParameter(
                                   this, BaseMapLoader, "Base Map Loader", "is required for this script to work."));
            }
        }
Beispiel #19
0
    /// <summary>
    /// Verify that all required parameters have been correctly defined, returning false if not.
    /// </summary>
    private bool VerifyParameters()
    {
        // Verify that a Ground plane has been given.
        if (Ground == null)
        {
            Debug.LogError(ExampleErrors.MissingParameter(this, Ground, "Ground"));
            return(false);
        }

        // Verify that there is a Camera.main in the scene (i.e. a Camera that is tagged: "MainCamera").
        if (Camera.main == null)
        {
            Debug.LogError(ExampleErrors.NullMainCamera(this));
            return(false);
        }

        // If have reached this point then we have verified all required parameters.
        return(true);
    }
    /// <summary>
    /// Verify given <see cref="Material"/> arrays are valid (not empty nor containing any null
    /// entries, and both arrays of the same length).
    /// </summary>
    private void Awake()
    {
        // Verify that at least one Wall Material and at least one Roof Material has been given.
        if (WallMaterials.Length == 0)
        {
            Debug.LogError(ExampleErrors.EmptyArray(this, WallMaterials, "Wall Materials"));
            return;
        }
        if (RoofMaterials.Length == 0)
        {
            Debug.LogError(ExampleErrors.EmptyArray(this, RoofMaterials, "Roof Materials"));
            return;
        }

        // Verify that the same number of Wall and Roof Materials have been given.
        if (WallMaterials.Length != RoofMaterials.Length)
        {
            Debug.LogErrorFormat("Incorrect number of Building Roof Materials defined for {0}.{1}: {2} "
                                 + "Building Wall Materials were given, but {3} Building Roof Materials were given.\n{1} "
                                 + "needs the same number of Building Roof Materials as Building Wall Materials, i.e. {2} "
                                 + "of each.",
                                 name, GetType(), WallMaterials.Length, RoofMaterials.Length);
            return;
        }

        // Verify that no null Materials have been given.
        for (int i = 0; i < WallMaterials.Length; i++)
        {
            if (WallMaterials[i] == null)
            {
                Debug.LogError(ExampleErrors.NullArrayElement(this, WallMaterials, "Wall Materials", i));
                return;
            }
            if (RoofMaterials[i] == null)
            {
                Debug.LogError(ExampleErrors.NullArrayElement(this, RoofMaterials, "Roof Materials", i));
                return;
            }
        }

        // If have reached this point then have verified that all required parts are present and
        // properly set up.
    }
    /// <summary>
    /// Use <see cref="CameraController"/>'s OnMove event to detect when the <see cref="Camera"/> has
    /// moved far enough that the Floating Origin needs to be recentered.
    /// </summary>
    private void Awake()
    {
        // Verify a Camera Controller has been given.
        if (CameraController == null)
        {
            Debug.LogError(ExampleErrors.MissingParameter(this, CameraController, "Camera Controller",
                                                          "to tell when the Camera has moved"));
            return;
        }

        // Verify that a valid Floating Origin range was given, i.e. that given distance was not
        // negative nor zero. Comparison is made to float.Epsilon instead of zero to account for float
        // rounding errors.
        if (FloatingOriginRange <= float.Epsilon)
        {
            Debug.LogError(ExampleErrors.NotGreaterThanZero(this, FloatingOriginRange,
                                                            "Floating Origin Range", "to tell how far the Camera should move before the Floating "
                                                            + "Origin is reset"));
            return;
        }

        // Store the required Dynamic Maps Service on this GameObject.
        DynamicMapsService = GetComponent <DynamicMapsService>();

        // Store the starting position of the Camera.
        CameraOrigin = Camera.main.transform.position;

        // If no additional GameObjects have been set (to be moved when the world's Floating Origin is
        // recentered), set this array to be just Camera.main's GameObject. This is so that, by
        // default, the scene's Camera is moved when the world is recentered, resulting in a seamless
        // recentering of the world that should be invisible to the user.
        if (AdditionalGameObjects == null)
        {
            AdditionalGameObjects = new[] { Camera.main.gameObject };
        }

        // Whenever the Camera moves, check to see if it has moved far enough that the world's Floating
        // Origin needs to be recentered.
        CameraController.OnMove.AddListener(TryMoveFloatingOrigin);
    }
        /// <summary>
        /// Use <see cref="CameraController"/>'s OnMove event to detect when the <see cref="Camera"/>
        /// has moved far enough that the Floating Origin needs to be recentered.
        /// </summary>
        private void Awake()
        {
            // Verify a Camera Controller has been given.
            if (CameraController == null)
            {
                Debug.LogError(ExampleErrors.MissingParameter(
                                   this, CameraController, "Camera Controller", "to tell when the Camera has moved"));

                return;
            }

            // Verify that a valid Floating Origin range was given, i.e. that given distance was not
            // negative nor zero. Comparison is made to float.Epsilon instead of zero to account for float
            // rounding errors.
            if (FloatingOriginRange <= float.Epsilon)
            {
                Debug.LogError(ExampleErrors.NotGreaterThanZero(
                                   this,
                                   FloatingOriginRange,
                                   "Floating Origin Range",
                                   "to tell how far the Camera should move before the Floating " + "Origin is reset"));

                return;
            }

            // Store the initial position of the Camera on the ground plane.
            FloatingOrigin = GetCameraPositionOnGroundPlane();

            // If no additional GameObjects have been set (to be moved when the world's Floating Origin is
            // recentered), set this array to be just Camera.main's GameObject. This is so that, by
            // default, the scene's Camera is moved when the world is recentered, resulting in a seamless
            // recentering of the world that should be invisible to the user.
            if (AdditionalGameObjects == null)
            {
                AdditionalGameObjects = new[] { Camera.main.gameObject };
            }
        }
Beispiel #23
0
    /// <summary>
    /// Use events to connect <see cref="DynamicMapsService"/> to <see cref="BuildingTexturer"/> so
    /// that all extruded buildings can receive a Nine-Sliced <see cref="Material"/>.
    /// </summary>
    private void Awake()
    {
        // Verify that the given Segment Physics layer is valid (positive and within the range of all
        // available physics layers).
        if (SegmentPhysicsLayer < 0 || SegmentPhysicsLayer > 31)
        {
            Debug.LogError(ExampleErrors.OutsideRange(this, SegmentPhysicsLayer, "Segment Physics Layer",
                                                      0, 31));
            return;
        }

        // Convert Segment Physics Layer index into a Layer Mask for ray-casting into this layer only
        // (i.e. for seeing if any segments are hit by a ray-cast).
        SegmentPhysicsLayerMask = 1 << SegmentPhysicsLayer;

        // Get required Building Texturer component on this GameObject.
        BuildingTexturer buildingTexturer = GetComponent <BuildingTexturer>();

        // Get the required Dynamic Maps Service on this GameObject.
        DynamicMapsService dynamicMapsService = GetComponent <DynamicMapsService>();

        // See if any segment types have been given as types to remove buildings over. We check this so
        // that, if no segments types have been given, unnecessary setup can be avoided.
        bool removeAny = RemoveOverRoads || RemoveOverRailways || RemoveOverFerryLanes;

        // If any segment types have been given as types to remove buildings over, then sign up to event
        // called after each new segment is loaded, so can assign a Collider to it and place it in the
        // Segment Physics Layer. Note that:
        // - DynamicMapsService.MapsService is auto-found on first access (so will not be null).
        // - This event must be set now during Awake, so that when Dynamic Maps Service starts loading
        //   the map during Start, this event will be triggered for all Extruded Structures.
        if (removeAny)
        {
            dynamicMapsService.MapsService.Events.SegmentEvents.DidCreate.AddListener(args => {
                args.GameObject.AddComponent <MeshCollider>();
                args.GameObject.layer = SegmentPhysicsLayer;
            });
        }

        // Sign up to event called after each new building is loaded, so can store it for checking
        // against segments and apply a Nine sliced texture.
        dynamicMapsService.MapsService.Events.ExtrudedStructureEvents.DidCreate.AddListener(args => {
            // Store building so it can be check to be over a segment (after all segments are loaded). We
            // skip this if no segment types have been given as types to remove buildings over.
            if (removeAny)
            {
                StoreBuilding(args.GameObject, args.MapFeature);
            }

            // Assign Nine sliced texture to this building.
            buildingTexturer.AssignNineSlicedMaterials(args.GameObject);
        });

        // When all geometry is loaded, check if any buildings are over any segments, and remove them if
        // so. We skip this if no segment types have been given as types to remove buildings over.
        if (removeAny)
        {
            dynamicMapsService.MapsService.Events.MapEvents.Loaded.AddListener(args =>
                                                                               TryRemoveBuildings());
        }
    }