Display a scene

Learn how to create and display a scene with a basemap layer and an elevation layer. Set properties of the scene's camera to control the 3D perspective.

image

Like a map, a scene contains layers of geographic data. It contains a basemap layer and, optionally, one or more data layers. To provide a realistic view of the terrain, you can also add elevation layers to define the height of the surface across the scene. The 3D perspective of the scene is controlled by the scene's camera, which defines the position of the scene observer in 3D space.

In this tutorial, you create and display a scene using the imagery basemap layer. The surface of the scene is defined with an elevation layer and the camera is positioned to display an area of the Santa Monica Mountains in the scene view.

The scene and code will be used as the starting point for other 3D tutorials.

Prerequisites

The following are required for this tutorial:

  1. An ArcGIS account to access your API keys. If you don't have an account, sign up for free.
  2. Confirm that your system meets the minimum system requirements.
  3. An IDE for Java.

Steps

Create a new Java project with Gradle

  1. Open IntelliJ IDEA.

  2. From the Welcome to IntelliJ IDEA screen, click the New Project button. (If you're already inside a project, click File > New > Project in the menu bar.)

  3. In the New Project window, do the following:

    • Enter a name for your new project and choose a location to save it. Your app name can contain only Latin characters, digits, _ , - and :.

    • Deselect Create Git repository, if necessary

    • Select Java as your programming language, if necessary

    • Select Gradle as your build system

    • Select JDK 17
    • Select Groovy as your Gradle build language (i.e. DSL), if necessary

    • Check the Add sample code box, if necessary

    • Click Advanced Settings to expand the drop-down. In GroupId enter com.example.app. You can leave the default for ArtifactId.

    • Click Create to build your new project.

  4. In the Project tool window, replace the contents of the build.gradle file with the following script to configure your app and reference the API. Make sure that you load the gradle changes after modifying build.gradle.

    build.gradle
    Use dark colors for code blocksCopy
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    plugins {
        id 'application'
        id 'org.openjfx.javafxplugin' version '0.1.0'
        id 'idea'
    }
    
    idea {
        module {
            downloadJavadoc = true
        }
    }
    
    ext {
        arcgisVersion = '200.3.0'
    }
    
    repositories {
        mavenCentral()
        maven {
            url 'https://esri.jfrog.io/artifactory/arcgis'
        }
    }
    
    configurations {
        natives
    }
    
    dependencies {
        implementation "com.esri.arcgisruntime:arcgis-java:$arcgisVersion"
        natives "com.esri.arcgisruntime:arcgis-java-jnilibs:$arcgisVersion"
        natives "com.esri.arcgisruntime:arcgis-java-resources:$arcgisVersion"
        implementation 'org.slf4j:slf4j-nop:2.0.9'
    }
    
    javafx {
        version = "21.0.1"
        modules = [ 'javafx.controls', 'javafx.graphics', 'javafx.fxml', 'javafx.web', 'javafx.media' ]
    }
    
    application {
        mainModule = "com.example.app"
        mainClass = "com.example.app.App"
    }
    
    task copyNatives(type: Copy) {
        description = "Copies the arcgis native libraries into the .arcgis directory for development."
        group = "build"
        configurations.natives.asFileTree.each {
            from(zipTree(it))
        }
        into "${System.properties.getProperty("user.home")}/.arcgis/$arcgisVersion"
    }
    
    run {
        dependsOn copyNatives
    }
    
    wrapper {
        gradleVersion = '8.4'
    }
  5. Click View > Tool Windows > Gradle to open the Gradle view, then in Tasks > build, double-click copyNatives. This unpacks the native library dependencies to $USER_HOME/.arcgis.

  6. In the Project tool window, under your package com.example.app, right-click Main and click Refactor > Rename....

  7. Rename the Java class to App and click Refactor.

Add import statements

  1. In App.java, add import statements to reference the ArcGIS and JavaFX classes.

    App.java
    Use dark colors for code blocks
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    package com.example.app;
    
    import com.esri.arcgisruntime.ArcGISRuntimeEnvironment;
    import com.esri.arcgisruntime.geometry.Point;
    import com.esri.arcgisruntime.geometry.SpatialReferences;
    import com.esri.arcgisruntime.mapping.ArcGISScene;
    import com.esri.arcgisruntime.mapping.ArcGISTiledElevationSource;
    import com.esri.arcgisruntime.mapping.BasemapStyle;
    import com.esri.arcgisruntime.mapping.Surface;
    import com.esri.arcgisruntime.mapping.view.Camera;
    import com.esri.arcgisruntime.mapping.view.SceneView;
    
    import javafx.application.Application;
    import javafx.scene.Scene;
    import javafx.scene.layout.StackPane;
    import javafx.stage.Stage;
    
    public class App extends Application {
    

Add a UI for the scene view

A scene view is a UI component that displays a scene. It also handles user interactions with the scene. Use JavaFX to add a scene view to the UI.

  1. In App.java, define a class named App that extends the JavaFX Application class.

    • Add a private member variable for a SceneView.

    • Inside the main() method, replace the print statement with a call to Application.launch(args).

    • Override the start() method, in which you configure the JavaFX Stage with a title and dimensions, and then show it.

    • Create a JavaFX StackPane, and use it to create a JavaFX Scene. Then set the scene on the stage.

    App.java
    Expand
    Use dark colors for code blocks
    31 31 31 31 31 31 31 31 31 31 31 31 31 31 31 31 31 31 31 31 31 31 31 31 31 31 31 31 31 31 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 54 54 54 54 54 54 54 54 54 54 54 54 54 54 54 54 54 54 54 54 54 54 54 54 54 54 54 55 56 56 56 56 56 56 56 56 56 56 56 57
    Add line.Add line.Add line.Add line.Add line.Add line.Add line.Add line.Add line.Add line.Add line.Add line.Add line.Add line.Add line.Add line.Add line.Add line.Add line.Add line.Add line.Add line.Add line.Add line.Add line.Add line.
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    public class App extends Application {
    
      private SceneView sceneView;
    
      public static void main(String[] args) {
        Application.launch(args);
      }
    
      @Override
      public void start(Stage stage) {
    
        // set the title and size of the stage and show it
        stage.setTitle("Display a scene tutorial");
        stage.setWidth(800);
        stage.setHeight(700);
        stage.show();
    
        // create a JavaFX scene with a stack pane as the root node, and add it to the scene
        StackPane stackPane = new StackPane();
        Scene fxScene = new Scene(stackPane);
    
        stage.setScene(fxScene);
    
      }
    
    }
  2. Initialize your member variable, sceneView, and add it to the JavaFX UI.

    App.java
    Expand
    Use dark colors for code blocks
    48 48 48 48 48 48 48 48 48 48 48 48 48 48 48 48 48 48 48 48 48 48 48 48 48 48 48 48 48 48 48 48 48 48 48 48 48 48 48 48 48 48 48 48 48 48 48 48 49 50 51 52 53 54 54 54 54 54 54 55 56 57 57 56 55 54 53 52 51 50 49 48 47 46 45 44 43 42 41 40 39 39 39 38 37 36 35 34 33 32 31 30 29 29
    Add line.Add line.Add line.
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
        // create a JavaFX scene with a stack pane as the root node, and add it to the scene
        StackPane stackPane = new StackPane();
        Scene fxScene = new Scene(stackPane);
    
        stage.setScene(fxScene);
    
        // create a scene view to display the scene and add it to the stack pane
        sceneView = new SceneView();
        stackPane.getChildren().add(sceneView);
    
    Expand

Add a scene

Use the scene view to display a scene centered on the Santa Monica Mountains in California. The scene will contain an imagery basemap layer.

  1. Create a new ArcGISScene with an imagery basemap.

    App.java
    Expand
    Use dark colors for code blocks
    59 59 59 59 59 59 59 59 59 59 59 59 59 59 59 59 59 59 59 59 59 59 59 59 59 59 59 59 59 59 59 59 59 59 59 59 59 59 59 59 59 59 59 59 59 59 59 59 59 59 59 59 59 59 58 57 56 55 54 55 56 57 58 59 60 60 60 60 60 60 60 60 60 60 60 60 60 60 60 60 59 59 59 58 57 56 55 54 53 52 51 50 49 49
    Add line.
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
        // create a scene view to display the scene and add it to the stack pane
        sceneView = new SceneView();
        stackPane.getChildren().add(sceneView);
    
        ArcGISScene scene = new ArcGISScene(BasemapStyle.ARCGIS_IMAGERY_STANDARD);
    
    
    Expand
  2. To display the scene in the scene view, call the sceneView's setArcGISScene() method, passing the newly created ArcGISScene as a parameter.

    App.java
    Expand
    Use dark colors for code blocks
    63 63 63 63 63 63 63 63 63 63 63 63 63 63 63 63 63 63 63 63 63 63 63 63 63 63 63 63 63 63 63 63 63 63 63 63 63 63 63 63 63 63 63 63 63 63 63 63 63 63 63 63 63 63 62 61 60 59 58 58 58 58 58 59 60 61 62 63 63 63 63 63 63 63 63 63 63 63 63 63 62 62 62 61 60 59 58 57 56 55 54 53 52 52
    Add line.Add line.
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
        ArcGISScene scene = new ArcGISScene(BasemapStyle.ARCGIS_IMAGERY_STANDARD);
    
        // set the scene on the scene view
        sceneView.setArcGISScene(scene);
    
    
    Expand
  3. Create a new Surface and add a new ArcGISTiledElevationSource to it to define the base surface for the scene. Next, set the setElevationExaggeration property on the surface to 2.5f to increase the 3D effect of the elevation. Finally, set the surface as the base surface of the scene.

    App.java
    Expand
    Use dark colors for code blocks
    65 65 65 65 65 65 65 65 65 65 65 65 65 65 65 65 65 65 65 65 65 65 65 65 65 65 65 65 65 65 65 65 65 65 65 65 65 65 65 65 65 65 65 65 65 65 65 65 65 65 65 65 65 65 64 63 62 61 60 60 60 60 60 60 60 61 62 63 64 65 66 67 68 69 70 71 71 70 69 68 67 67 67 66 65 64 63 62 61 60 59 58 57 57
    Add line.Add line.Add line.Add line.Add line.Add line.Add line.Add line.
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
        // set the scene on the scene view
        sceneView.setArcGISScene(scene);
    
        // add base surface for elevation data
        Surface surface = new Surface();
        String elevationServiceUrl = "https://elevation3d.arcgis.com/arcgis/rest/services/WorldElevation3D/Terrain3D/ImageServer";
        surface.getElevationSources().add(new ArcGISTiledElevationSource(elevationServiceUrl));
        // add an exaggeration factor to increase the 3D effect of the elevation.
        surface.setElevationExaggeration(2.5f);
    
        scene.setBaseSurface(surface);
    
    Expand
  4. Set the initial viewpoint of the sceneView using a Point and a Camera.

    App.java
    Expand
    Use dark colors for code blocks
    75 75 75 75 75 75 75 75 75 75 75 75 75 75 75 75 75 75 75 75 75 75 75 75 75 75 75 75 75 75 75 75 75 75 75 75 75 75 75 75 75 75 75 75 75 75 75 75 75 75 75 75 75 75 74 73 72 71 70 70 70 70 70 70 70 70 70 70 70 70 70 70 70 70 70 71 72 73 74 75 75 75 75 74 73 72 71 70 69 68 67 66 65 65
    Add line.Add line.Add line.
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
        scene.setBaseSurface(surface);
    
        Point cameraLocation = new Point(-118.794, 33.909, 5330.0, SpatialReferences.getWgs84());
        Camera camera = new Camera(cameraLocation, 355.0, 72.0, 0.0);
        sceneView.setViewpointCamera(camera);
    
    Expand

Set your API key

An API key is required to enable access to services, web maps, and web scenes hosted in ArcGIS Online.

If you haven't already, go to your developer dashboard to get your API key. For these tutorials, use your default API key. It is scoped to include all of the services demonstrated in the tutorials.

  1. Set the API key property on the ArcGISRuntimeEnvironment with your API key.

In the code below, replace YOUR_API_KEY with your actual API Key. The value is a string so surround it with double quotes.

App.java
Expand
Use dark colors for code blocks
52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 53 54 55 56 57 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 57 56 55 54 53 52 51 50 49 48 48
Add line.Add line.Add line.Add line.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
    stage.setScene(fxScene);

    // Note: it is not best practice to store API keys in source code.
    // The API key is referenced here for the convenience of this tutorial.
    String yourApiKey = "YOUR_API_KEY";
    ArcGISRuntimeEnvironment.setApiKey(yourApiKey);
Expand

Release API resources

To ensure that API resources used in the application are released when it is closed, override the JavaFX stop() method and call the dispose() method on the sceneView:

App.java
Expand
Use dark colors for code blocks
83 83 83 83 83 83 83 83 83 83 83 83 83 83 83 83 83 83 83 83 83 83 83 83 83 83 83 83 83 83 83 83 83 83 83 83 83 83 83 83 83 83 83 83 83 83 83 83 83 83 83 83 83 83 83 83 83 83 83 83 83 83 83 83 83 83 83 83 83 83 83 83 83 83 83 83 83 83 83 83 83 83 83 84 85 86 87 88 89 90 91 92 92 92
Add line.Add line.Add line.Add line.Add line.Add line.Add line.Add line.Add line.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
  /**
   * Stops and releases all resources used in application.
   */
  @Override
  public void stop() {
    if (sceneView != null) {
      sceneView.dispose();
    }
  }
Expand

Modularize the app

A Java module adds a higher level of aggregation above packages. A module must provide a module descriptor that specifies the dependencies, the packages the module makes available to other modules, and more.

You will create the module descriptor for this project in a file named module-info.java.

  1. In the Project tool window, under src/main, right-click the java folder, and click New > module-info.java.

  2. Inside module-info.java replace the module name (i.e. highlighted text) with com.example.app.

  3. In the body of the module descriptor, define the three required packages this application depends on: com.esri.arcgisruntime, javafx.graphics, and org.slf4j.nop.

  4. Export this project's module package to make it accessible to code in all other modules.

module-info.java
Expand
Use dark colors for code blocks
13 13 13 13 13 13 13 13 13 13 13 13 13 14 15 16 17 18 19 20 21 22 23 24 25
Add line.Add line.Add line.Add line.Add line.Add line.Add line.Add line.Add line.Add line.Add line.Add line.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
module com.example.app {
    // require ArcGIS Runtime module
    requires com.esri.arcgisruntime;

    // requires JavaFX modules that the application uses
    requires javafx.graphics;

    // requires SLF4j module
    requires org.slf4j.nop;

    exports com.example.app;
}

Run the app

Run the app. Ensure to run the app as a Gradle task and not as an application in your IDE. In the Gradle tool window, under Tasks > application, double-click run.

You should see a scene with the imagery basemap layer centered on the Santa Monica Mountains in California. Click, drag, and scroll the mouse wheel on the scene view to explore the scene.

What's next?

Learn how to use additional API features, ArcGIS location services, and ArcGIS tools in these tutorials:

Your browser is no longer supported. Please upgrade your browser for the best experience. See our browser deprecation post for more details.