Click or drag to resize

ModelSceneSymbol Class

Used to display point or multipoint geoelements in a scene using a 3D model.
Inheritance Hierarchy

Namespace:  Esri.ArcGISRuntime.Symbology
Assembly:  Esri.ArcGISRuntime (in Esri.ArcGISRuntime.dll) Version: 100.11.0
public sealed class ModelSceneSymbol : MarkerSceneSymbol

The ModelSceneSymbol type exposes the following members.

Public propertyCode exampleAnchorPosition
Gets or sets the anchor position of the simple marker scene symbol.
(Inherited from MarkerSceneSymbol.)
Public propertyColor
Gets or sets the symbol color.
(Inherited from MarkerSceneSymbol.)
Public propertyDepth
Gets or sets the depth (in meters) of the simple marker scene symbol.
(Inherited from MarkerSceneSymbol.)
Public propertyCode exampleHeading
Gets or sets the heading (in degrees) of the scene marker symbol.
(Inherited from MarkerSceneSymbol.)
Public propertyHeight
Gets or sets the height (in meters) of the simple marker scene symbol.
(Inherited from MarkerSceneSymbol.)
Public propertyCode examplePitch
Gets or sets the pitch (in degrees) of the scene marker symbol.
(Inherited from MarkerSceneSymbol.)
Public propertyRoll
Gets or sets the roll (in degrees) of the scene marker symbol.
(Inherited from MarkerSceneSymbol.)
Public propertySymbolSizeUnits
Gets or sets the size units for rendering model scene symbol.
Public propertyUri
Get or sets the URI of the model scene symbol.
Public propertyWidth
Gets or sets the width (in meters) of the simple marker scene symbol.
(Inherited from MarkerSceneSymbol.)
Public methodClone
Clones this instance of Symbol and its members.
(Inherited from Symbol.)
Public methodStatic memberCode exampleCreateAsync(Uri)
Creates a new instance of a model marker symbol.
Public methodStatic memberCode exampleCreateAsync(Uri, Double)
Creates a new instance of a model marker symbol.
Public methodCode exampleCreateSwatchAsync(Double)
Creates a swatch image of this symbol using the default size and a transparent background.
(Inherited from Symbol.)
Public methodCreateSwatchAsync(Color, Double)
Creates a swatch image of this symbol, using the default sizing and a transparent background.
(Inherited from Symbol.)
Public methodCreateSwatchAsync(Int32, Int32, Double, Color)
Creates a swatch image of this symbol, scaled to fit the specified dimensions.
(Inherited from Symbol.)
Public methodCreateSwatchAsync(Int32, Int32, Single, Color, Geometry)
Creates a swatch image of this symbol, with the specified image size, dpi, background color, and geometry.
(Inherited from Symbol.)
Public methodToJson
Returns the json representation of the symbol
(Inherited from Symbol.)
Public eventPropertyChanged
Occurs when a property value changes.
(Inherited from Symbol.)

By default, the symbol will be positioned using the centroid of the model object. Note that this may not be the same as the center of its bounding extent. Refer to the 'Symbol types' topic in the developers guide for a list of supported 3D model types.

A model symbol is used to provide a realistic three-dimensional visualization for scene features. Create a ModelSceneSymbol using a 3D model file, passing the URL of the file and a scale factor to the model symbol constructor. Depending on the model file's default orientation, you may have to rotate the symbol to get your model in the desired orientation. Note that ModelSceneSymbol will not display using static rendering mode.



Example Name: Animate3DGraphic

An `OrbitGeoElementCameraController` follows a graphic while the graphic's position and rotation are animated.

Code example screen shot.

// Copyright 2018 Esri.
// Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License.
// You may obtain a copy of the License at:
// Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an
// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific
// language governing permissions and limitations under the License.

using ArcGISRuntime.Samples.Managers;
using Esri.ArcGISRuntime.Geometry;
using Esri.ArcGISRuntime.Mapping;
using Esri.ArcGISRuntime.Symbology;
using Esri.ArcGISRuntime.UI;
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Threading.Tasks;
using System.Timers;
using System.Windows;
using System.Windows.Controls;
using System.Drawing;
using PointCollection = Esri.ArcGISRuntime.Geometry.PointCollection;
using Viewpoint = Esri.ArcGISRuntime.Mapping.Viewpoint;

namespace ArcGISRuntime.WPF.Samples.Animate3DGraphic
        name: "Animate 3D graphic",
        category: "GraphicsOverlay",
        description: "An `OrbitGeoElementCameraController` follows a graphic while the graphic's position and rotation are animated.",
        instructions: "Animation Controls:",
        tags: new[] { "Camera", "ModelSceneSymbol", "OrbitGeoElementCameraController", "RendererSceneProperties", "SceneView" })]
    [ArcGISRuntime.Samples.Shared.Attributes.OfflineData("290f0c571c394461a8b58b6775d0bd63", "681d6f7694644709a7c830ec57a2d72b", "e87c154fb9c2487f999143df5b08e9b1", "5a9b60cee9ba41e79640a06bcdf8084d", "12509ffdc684437f8f2656b0129d2c13")]
    public partial class Animate3DGraphic
        // URL to the elevation service - provides terrain elevation
        private readonly Uri _elevationServiceUrl = new Uri("");

        // Graphic for highlighting the route in the inset map
        private Graphic _routeGraphic;

        // Graphic for highlighting the airplane in the inset map
        private Graphic _plane2D;

        // Graphic for showing the 3D plane model in the scene
        private Graphic _plane3D;

        // Camera controller for centering the camera on the airplane
        private OrbitGeoElementCameraController _orbitCameraController;

        // Timer enables frame-by-frame animation
        private Timer _animationTimer;

        // Number of frames in the mission animation
        private int _frameCount;

        // Index of current frame in the animation
        private int _keyframe;

        // Dictionary of mission file names and the corresponding portal item IDs
        private readonly Dictionary<string, string> _missionToItemId = new Dictionary<string, string>
            {"Hawaii", "e87c154fb9c2487f999143df5b08e9b1"},
            {"Pyrenees", "5a9b60cee9ba41e79640a06bcdf8084d"},
            {"Snowdon", "12509ffdc684437f8f2656b0129d2c13"}

        // Array of animation frames for the current mission
        //    A MissionFrame describes the position of the plane for a single moment in the animation
        private MissionFrame[] _missionData;

        public Animate3DGraphic()

            // Create the UI, setup the control references and execute initialization

        private async void Initialize()
            // Apply appropriate maps to the scene and the inset map view
            InsetMapView.Map = new Map(BasemapStyle.ArcGISImageryStandard);
            MySceneView.Scene = new Scene(BasemapStyle.ArcGISImageryStandard);

            // Update the mission selection UI
            MissionSelectionBox.ItemsSource = _missionToItemId.Keys;
            MissionSelectionBox.SelectedIndex = 0;

            // Wire up the selection change event to call the ChangeMission method; this method resets the animation and starts a new mission
            MissionSelectionBox.SelectionChanged += async (sender, args) => { await ChangeMission(args.AddedItems[0].ToString()); };

            // Apply the elevation source
            Surface surface = new Surface();
            ElevationSource elevationSource = new ArcGISTiledElevationSource(_elevationServiceUrl);
            MySceneView.Scene.BaseSurface = surface;

            // Create and add the graphics overlay
            GraphicsOverlay sceneOverlay = new GraphicsOverlay
                SceneProperties = { SurfacePlacement = SurfacePlacement.Absolute }

            // Create a renderer to handle updating plane's orientation
            SimpleRenderer renderer3D = new SimpleRenderer();
            RendererSceneProperties renderProperties = renderer3D.SceneProperties;
            // Use expressions to keep the renderer properties updated as parameters of the rendered object
            renderProperties.HeadingExpression = "[HEADING]";
            renderProperties.PitchExpression = "[PITCH]";
            renderProperties.RollExpression = "[ROLL]";
            // Apply the renderer to the scene view's overlay
            sceneOverlay.Renderer = renderer3D;

            // Create renderer to symbolize plane and update plane orientation in the inset map
            SimpleRenderer renderer2D = new SimpleRenderer();
            // Create the symbol that will be used for the plane
            SimpleMarkerSymbol plane2DSymbol = new SimpleMarkerSymbol(SimpleMarkerSymbolStyle.Triangle, Color.Blue, 10);
            // Apply the symbol to the renderer
            renderer2D.Symbol = plane2DSymbol;
            // Apply a rotation expression to the renderer
            renderer2D.RotationExpression = "[ANGLE]";
            // Update the inset map with a new GraphicsOverlay based on the renderer
            GraphicsOverlay insetMapOperlay = new GraphicsOverlay
                Renderer = renderer2D

            // Create placeholder graphic for showing the mission route in the inset map
            SimpleLineSymbol routeSymbol = new SimpleLineSymbol(SimpleLineSymbolStyle.Solid, Color.Red, 2);
            _routeGraphic = new Graphic { Symbol = routeSymbol };

            // Create the plane graphic; this is symbolized as a blue triangle because of renderer implemented above
            // Create the attribute dictionary
            Dictionary<string, object> plane2DAttributes = new Dictionary<string, object>();
            // Set the angle for the plane graphic
            plane2DAttributes["ANGLE"] = 0f;
            // Create the graphic from the attributes and the initial point
            _plane2D = new Graphic(new MapPoint(0, 0, SpatialReferences.Wgs84), plane2DAttributes);
            // Add the plane graphic to the inset map via the overlay

                // Create the model graphic for the plane
                // Get the path to the 3D model
                string modelPath = GetModelPath();
                // Create the scene symbol from the path to the model
                ModelSceneSymbol plane3DSymbol = await ModelSceneSymbol.CreateAsync(new Uri(modelPath), 1.0);
                // Create the graphic with an initial location and the plane symbol
                _plane3D = new Graphic(new MapPoint(0, 0, 0, SpatialReferences.Wgs84), plane3DSymbol);
                // Add the plane to the overlay

                // Create the orbit camera controller to follow the plane
                _orbitCameraController = new OrbitGeoElementCameraController(_plane3D, 20.0)
                    CameraPitchOffset = 75.0
                MySceneView.CameraController = _orbitCameraController;

                // Create a timer; this will enable animating the plane
                // The value is the duration of the timer in milliseconds. This controls the speed of the animation (fps)
                _animationTimer = new Timer(60)
                    Enabled = true,
                    AutoReset = true

                // Move the plane every time the timer expires
                _animationTimer.Elapsed += AnimatePlane;

                // Set the initial mission for when the sample loads
                await ChangeMission(_missionToItemId.Keys.First());
            catch (Exception e)
                MessageBox.Show(e.ToString(), "Error");

        private async Task ChangeMission(string mission)
            // Stop animating the current mission

            // Get mission data
            _missionData = GetMissionData(mission);

            // Draw mission route on the inset
            // Create a collection of points to hold the mission
            PointCollection points = new PointCollection(SpatialReferences.Wgs84);
            // Add all of the points from the mission to the point collection
            points.AddPoints(_missionData.Select(m => m.ToMapPoint()));
            // Create a polyline to symbolize the route from the point collection
            Polyline route = new Polyline(points);
            // Update the route graphic's geometry with the newly created route polyline
            _routeGraphic.Geometry = route;
            // Update the inset map's scale
            await InsetMapView.SetViewpointScaleAsync(100000);

            // Update animation parameters
            _frameCount = _missionData.Length;
            _keyframe = 0;

            // Set the MissionPlayPause button back to the currently 'playing' state
            MissionPlayPause.Content = "Pause";

            // Restart the animation

        private MissionFrame[] GetMissionData(string mission)
            // Get the path to the file
            string filePath = GetMissionFilePath(mission);

            // Read the file text
            string fileContents = File.ReadAllText(filePath);

            // Split the file contents into a list of lines
            return fileContents.Split('\n')
                // Then for each line, create a MissionFrame object
                // Then remove any null MissionFrames
                .Where(missionPart => missionPart != null)
                // Finally return that list of MissionFrames as an array

        private string GetMissionFilePath(string mission)
            string itemId = _missionToItemId[mission];
            string filename = mission + ".csv";

            return DataManager.GetDataFolder(itemId, filename);

        private void AnimatePlane(object sender, ElapsedEventArgs elapsedEventArgs)
            // Get the next position; % prevents going out of bounds even if the keyframe value is
            //     changed unexpectedly (e.g. due to user interaction with the progress slider).
            MissionFrame currentFrame = _missionData[_keyframe % _frameCount];

            // Update the UI
            double missionProgress = _keyframe / (double)_frameCount;

            // This is needed because the event could be running on a non-UI thread
            Dispatcher.BeginInvoke(new Action(() =>
                // Update the progress slider
                MissionProgressBar.Value = missionProgress;

                // Update stats display
                AltitudeLabel.Text = currentFrame.Elevation.ToString("F") + "m";
                HeadingLabel.Text = currentFrame.Heading.ToString("F") + "�";
                PitchLabel.Text = currentFrame.Pitch.ToString("F") + "�";
                RollLabel.Text = currentFrame.Roll.ToString("F") + "�";

            // Update plane's position
            _plane3D.Geometry = currentFrame.ToMapPoint();
            _plane3D.Attributes["HEADING"] = currentFrame.Heading;
            _plane3D.Attributes["PITCH"] = currentFrame.Pitch;
            _plane3D.Attributes["ROLL"] = currentFrame.Roll;

            // Update the inset map; plane symbol position
            _plane2D.Geometry = currentFrame.ToMapPoint();
            // Update inset's viewpoint and heading
            Viewpoint vp = new Viewpoint(currentFrame.ToMapPoint(), InsetMapView.MapScale,
                360 + (float)currentFrame.Heading);

            // Update the keyframe. This advances the animation

            // Restart the animation if it has finished
            if (_keyframe >= _frameCount)
                _keyframe = 0;

        private static string GetModelPath()
            return DataManager.GetDataFolder("681d6f7694644709a7c830ec57a2d72b", "Bristol.dae");

        private void MissionPlayPlauseClick(object sender, RoutedEventArgs e)
            // Get a reference to the button that sent the event
            Button playButton = (Button)sender;

            // Get the text of the button
            string playtext = playButton.Content.ToString();

            switch (playtext)
                // Resume the animation
                case "Play":
                    playButton.Content = "Pause";
                // Stop the animation
                case "Pause":
                    playButton.Content = "Play";

        private void MissionProgressOnSeek(object sender, RoutedPropertyChangedEventArgs<double> e)
            // Get a reference to the slider that sent the event
            Slider sliderControl = (Slider)sender;

            // Return if the user didn't change the progress
            //    (this event is also fired when the value is changed programmatically)
            if (!sliderControl.IsFocused)

            // Stop the animation

            // Get the new mission progress
            double missionProgress = e.NewValue;

            // Update the keyframe based on the progress
            _keyframe = (int)(missionProgress * _frameCount);

            // Set the MissionPlayPause button back to the currently 'playing' state
            MissionPlayPause.Content = "Pause";

            // Restart the animation

        private void ToggleFollowPlane(object sender, RoutedEventArgs e)
            // Get a reference to the button
            Button cameraControlButton = (Button)sender;

            // Get the current text of the button
            string cameraControlText = cameraControlButton.Content.ToString();

            switch (cameraControlText)
                // Resume following
                case "Follow":
                    cameraControlButton.Content = "Don't follow";
                    MySceneView.CameraController = _orbitCameraController;
                // Stop following
                case "Don't follow":
                    cameraControlButton.Content = "Follow";
                    // Setting the scene view's camera controller to null has the effect of resetting the value to the default
                    MySceneView.CameraController = null;

        private void MissionPlaySpeedChanged(object sender, RoutedPropertyChangedEventArgs<double> e)
            // Return if timer not initialized yet
            if (_animationTimer == null)

            // Get the speed multiplier from the slider value
            double speedMultiplier = e.NewValue;

            // Stop the animation

            // Update the animation speed
            _animationTimer.Interval = 60 / speedMultiplier;

            // Set the MissionPlayPause button back to the currently 'playing' state
            MissionPlayPause.Content = "Pause";

            // Restart the animation

        /// <summary>
        /// Private helper class represents a single frame in the animation
        /// </summary>
        private class MissionFrame
            private double Longitude { get; set; }
            private double Latitude { get; set; }
            public double Elevation { get; private set; }
            public double Heading { get; private set; }
            public double Pitch { get; private set; }
            public double Roll { get; private set; }

            /// <summary>
            /// Private constructor ensures that only the factory method (Create) can be called.
            /// </summary>
            /// <param name="missionLine">A string describing a single frame in the mission animation.</param>
            private MissionFrame(string missionLine)
                // Split the string into a list of entries (columns)
                // Example line: -156.3666517,20.6255059,999.999908,83.77659,.00009,-47.766567
                string[] missionFrameParameters = missionLine.Split(',');

                // Throw if the line isn't valid
                if (missionFrameParameters.Length != 6)
                    throw new Exception("Invalid mission part definition");

                // Populate the object's properties from the array of parameters
                Longitude = Convert.ToDouble(missionFrameParameters[0]);
                Latitude = Convert.ToDouble(missionFrameParameters[1]);
                Elevation = Convert.ToDouble(missionFrameParameters[2]);
                Heading = Convert.ToDouble(missionFrameParameters[3]);
                Pitch = Convert.ToDouble(missionFrameParameters[4]);
                Roll = Convert.ToDouble(missionFrameParameters[5]);

            /// <summary>
            /// Creates a new MissionFrame.
            /// The private constructor + static construction method allows
            ///     for keeping the exception-handling logic for the constructor
            ///     internal to the class.
            /// </summary>
            /// <param name="missionLine">A string describing a single frame in the mission animation</param>
            /// <returns>Constructed MissionFrame or null if the line is invalid</returns>
            public static MissionFrame Create(string missionLine)
                    return new MissionFrame(missionLine);
                catch (Exception ex)
                    return null;

            public MapPoint ToMapPoint()
                return new MapPoint(Longitude, Latitude, Elevation, SpatialReferences.Wgs84);
        <Style TargetType="Button">
            <Setter Property="Margin" Value="5,0,5,0" />
            <Setter Property="Height" Value="25" />
            <Setter Property="Padding" Value="5,0,5,0" />
        <Style TargetType="Slider">
            <Setter Property="VerticalAlignment" Value="Center" />
        <Style TargetType="Label">
            <Setter Property="FontWeight" Value="Bold" />
        <Style TargetType="TextBlock">
            <Setter Property="Margin" Value="5,0,5,0" />
            <RowDefinition Height="Auto" />
            <RowDefinition Height="*" />
            <RowDefinition Height="225" />
            <ColumnDefinition Width="225" />
            <ColumnDefinition Width="*" />
            <ColumnDefinition Width="150" />
            AtmosphereEffect="Realistic" />
                VerticalAlignment="Top" />
                Content="Pause" />
            <TextBlock Margin="5" Text="Progress" />
                ValueChanged="MissionProgressOnSeek" />
                Content="Don't follow" />
                <SolidColorBrush Opacity="0.7" Color="White" />
            <StackPanel Margin="5">
                <Label Content="Play speed" />
                        <ColumnDefinition Width="*" />
                        <ColumnDefinition Width="40" />
                        Value="1" />
                    <TextBlock Grid.Column="1" Text="{Binding ElementName=MissionPlaySpeedSlider, Path=Value, StringFormat=N2}" />
                <Separator />
                <Label Content="Stats" FontSize="16" />
                <Label Content="Altitude:" />
                <TextBlock x:Name="AltitudeLabel" />
                <Label Content="Heading:" />
                <TextBlock x:Name="HeadingLabel" />
                <Label Content="Pitch:" />
                <TextBlock x:Name="PitchLabel" />
                <Label Content="Roll:" />
                <TextBlock x:Name="RollLabel" />
            IsAttributionTextVisible="False" />
See Also
Additional Examples
Hyperlink to ExampleDescription
Animate3DGraphicAn `OrbitGeoElementCameraController` follows a graphic while the graphic's position and rotation are animated.
ChooseCameraControllerControl the behavior of the camera in a scene.
LineOfSightGeoElementShow a line of sight between two moving objects.
UseDistanceCompositeSymChange a graphic's symbol based on the camera's proximity to it.
ViewshedGeoElementAnalyze the viewshed for an object (GeoElement) in a scene.