WorldWind Kotlin

https://github.com/worldwindearth/worldwindkotlin
Admin
WorldWind Kotlin is a 3D virtual globe API for Android, Web, and Java, providing high-resolution...
Tokens:31,688
Snippets:91
Trust Score:7.1
License:Apache-2.0
Update:11 months ago
Show doc for...
Tokens:
Raw
### Initialize CodeMirror for Kotlin Code (JavaScript)

Source: https://github.com/worldwindearth/worldwindkotlin/blob/develop/worldwind-tutorials/src/androidMain/assets/placemarks_picking_tutorial.html

Initializes a CodeMirror editor instance for a textarea element with the ID 'kotlin-code'. This setup enables features like line numbers, bracket matching, and sets the mode specifically for Google Kotlin syntax. The editor is configured to be read-only.

```javascript
var javaEditor = CodeMirror.fromTextArea(document.getElementById("kotlin-code"), {
    lineNumbers: true,
    matchBrackets: true,
    mode: "google-kotlin",
    readOnly: true
});
```

--------------------------------

### Add Placemarks to Globe - Kotlin

Source: https://github.com/worldwindearth/worldwindkotlin/blob/develop/worldwind-tutorials/src/androidMain/assets/placemarks_tutorial.html

The PlacemarksFragment class initializes the WorldWindow and adds a RenderableLayer containing four distinct placemarks. This example demonstrates various placemark creation methods, including color-coded squares, image-based placemarks with leader lines, and placemarks with labels and custom image offsets. It utilizes the WorldWind engine and its associated classes for rendering.

```kotlin
class PlacemarksFragment : BasicGlobeFragment() { /**
 * Creates a new WorldWindow with a RenderableLayer populated with four Placemarks.
 */
override fun createWorldWindow() = super.createWorldWindow().also { PlacemarksTutorial(it.engine).start() }
}

class PlacemarksTutorial(private val engine: WorldWind) : AbstractTutorial() {
    private val layer = RenderableLayer("Placemarks").apply {
        // Create a simple placemark at downtown Ventura, CA. This placemark is a 20x20 cyan square centered on the
        // geographic position. This placemark demonstrates the creation with a convenient factory method.
        addRenderable(
            Placemark.createWithColorAndSize(
                Position.fromDegrees(34.281, -119.293, 0.0),
                Color(0f, 1f, 1f, 1f),
                20
            ).apply { altitudeMode = AltitudeMode.CLAMP_TO_GROUND }
        )

        // Create an image-based placemark of an aircraft above the ground with a leader-line to the surface.
        // This placemark demonstrates creation via a constructor and a convenient PlacemarkAttributes factory method.
        // The image is scaled to 1.5 times its original size.
        addRenderable(
            Placemark(Position.fromDegrees(34.260, -119.2, 5000.0)).apply {
                attributes = PlacemarkAttributes.createWithImageAndLeader(ImageSource.fromResource(MR.images.aircraft_fixwing)).apply { imageScale = 1.5 }
            }
        )

        // Create an image-based placemark with a label at Oxnard Airport, CA. This placemark demonstrates creation
        // with a constructor and a convenient PlacemarkAttributes factory method. The image is scaled to 2x
        // its original size, with the bottom center of the image anchored at the geographic position.
        addRenderable(
            Placemark(Position.fromDegrees(34.200, -119.208, 0.0)).apply {
                altitudeMode = AltitudeMode.CLAMP_TO_GROUND
                attributes = PlacemarkAttributes.createWithImage(ImageSource.fromResource(MR.images.airport_terminal)).apply {
                    imageOffset = Offset.bottomCenter()
                    imageScale = 2.0
                }
                displayName = "Oxnard Airport"
            }
        )

        // Create an image-based placemark from a bitmap. This placemark demonstrates creation with a
        // constructor and a convenient PlacemarkAttributes factory method. First, a 64x64 bitmap is loaded,
        // and then it is passed into the placemark attributes. The bottom center of the image anchored
        // at the geographic position.
        addRenderable(
            Placemark(Position.fromDegrees(34.300, -119.25, 0.0)).apply {
                altitudeMode = AltitudeMode.CLAMP_TO_GROUND
                attributes = PlacemarkAttributes.createWithImage(ImageSource.fromResource(MR.images.ehipcc)).apply {
                    imageOffset = Offset.bottomCenter()
                }
            }
        )
    }

    override fun start() {
        super.start()
        engine.layers.addLayer(layer)
        engine.cameraFromLookAt(
            LookAt(
                position = Position.fromDegrees(34.200, -119.208, 0.0),
                altitudeMode = AltitudeMode.ABSOLUTE,
                range = 1e5,
                heading = Angle.ZERO,
                tilt = Angle.fromDegrees(80.0),
                roll = Angle.ZERO
            )
        )
    }

    override fun stop() {
        super.stop()
        engine.layers.removeLayer(layer)
    }
}
```

--------------------------------

### Kotlin Surface Image Tutorial Implementation

Source: https://github.com/worldwindearth/worldwindkotlin/blob/develop/worldwind-tutorials/src/androidMain/assets/surface_image_tutorial.html

This Kotlin code defines a tutorial for adding SurfaceImages to a WorldWind globe. It extends a basic globe fragment and customizes the WorldWindow creation to include a RenderableLayer with two SurfaceImage instances: one from a local resource and another from a remote URL. The tutorial also includes methods to start and stop the layer, and to position the camera to view the images.

```kotlin
class SurfaceImageFragment : BasicGlobeFragment() { 
    /** 
     * Creates a new WorldWindow with an additional RenderableLayer containing two SurfaceImages. 
     */ 
    override fun createWorldWindow() = super.createWorldWindow().also { SurfaceImageTutorial(it.engine).start() } 
}

class SurfaceImageTutorial(private val engine: WorldWind) : AbstractTutorial() {
    private val layer = RenderableLayer("Surface image").apply {
        // Configure a Surface Image to display an Android resource showing the WorldWindEarth logo.
        addRenderable(
            SurfaceImage(
                Sector.fromDegrees(37.46, 15.5, 0.5, 0.6),
                ImageSource.fromResource(MR.images.worldwind_logo)
            )
        )

        // Configure a Surface Image to display a remote image showing Mount Etna erupting on July 13th, 2001.
        addRenderable(
            SurfaceImage(
                Sector.fromDegrees(37.46543388598137, 14.60128369746704, 0.45360804083528, 0.75704283995502),
                ImageSource.fromUrlString("https://worldwind.arc.nasa.gov/android/tutorials/data/etna.jpg")
            )
        )
    }

    override fun start() {
        super.start()
        engine.layers.addLayer(layer)
        engine.camera.set(
            Angle.fromDegrees(37.46543388598137),
            Angle.fromDegrees(14.97980511744455),
            4.0e5,
            AltitudeMode.ABSOLUTE,
            heading = Angle.ZERO,
            tilt = Angle.ZERO,
            roll = Angle.ZERO
        )
    }

    override fun stop() {
        super.stop()
        engine.layers.removeLayer(layer)
    }
}
```

--------------------------------

### Create and Display Elevation Heatmap Layer (Kotlin)

Source: https://github.com/worldwindearth/worldwindkotlin/blob/develop/worldwind-tutorials/src/androidMain/assets/elevation_heatmap_tutorial.html

This Kotlin code snippet shows how to create an ElevationHeatmapLayer and add it to a WorldWind globe. It overrides the default WorldWindow creation in a BasicGlobeFragment to initialize the heatmap and sets the camera's viewpoint. The layer is added during the tutorial's start and removed upon stopping.

```kotlin
class ElevationHeatmapFragment: BasicGlobeFragment() { /** * Creates a new WorldWindow (GLSurfaceView) object with an Elevation Heatmap * * @return The WorldWindow object containing the globe. */ override fun createWorldWindow() = super.createWorldWindow().also { ElevationHeatmapTutorial(it.engine).start() } }

class ElevationHeatmapTutorial(private val engine: WorldWind) : AbstractTutorial() {
    var elevationHeatmapLayer = ElevationHeatmapLayer();

    override fun start() {
        super.start()
        engine.layers.addLayer(elevationHeatmapLayer)
        engine.cameraFromLookAt(
            LookAt(
                position = Position.fromDegrees(50.4501 , 30.5234 , 0.0), // Kyiv
                altitudeMode = AltitudeMode.ABSOLUTE,
                range = 1e4,
                heading = Angle.ZERO,
                tilt = 0.0.degrees,
                roll = Angle.ZERO
            )
        )
    }

    override fun stop() {
        super.stop()
        engine.layers.removeLayer(elevationHeatmapLayer)
    }
}
```

--------------------------------

### Create Aircraft Placemark with Customization (Kotlin)

Source: https://github.com/worldwindearth/worldwindkotlin/blob/develop/worldwind-tutorials/src/androidMain/assets/placemarks_picking_tutorial.html

This function creates an aircraft placemark at a specified position. It customizes the placemark's image, scale, highlight attributes, and altitude mode. Dependencies include Worldwind's Position, Placemark, PlacemarkAttributes, AltitudeMode, and resource loading functions.

```kotlin
private fun createAircraftPlacemark(position: Position): Placemark {
    val placemark = createWithImage(position, fromResource(MR.images.aircraft_fighter))
    placemark.attributes.imageOffset = bottomCenter()
    placemark.attributes.imageScale = NORMAL_IMAGE_SCALE
    placemark.attributes.isDrawLeader = true
    val highlightedAttributes = PlacemarkAttributes(placemark.attributes)
    highlightedAttributes.imageScale = HIGHLIGHTED_IMAGE_SCALE
    placemark.highlightAttributes = highlightedAttributes
    placemark.altitudeMode = AltitudeMode.ABSOLUTE
    return placemark
}
```

--------------------------------

### Initialize WorldWindow and Add Layers on Android

Source: https://context7.com/worldwindearth/worldwindkotlin/llms.txt

This snippet demonstrates the basic setup of the WorldWindow view component in an Android Activity. It includes initializing the WorldWindow, adding background and satellite imagery layers, an atmosphere layer, and a star field layer. It also configures the globe's projection and vertical exaggeration, and sets an initial camera position.

```kotlin
class MapActivity : AppCompatActivity() {
    private lateinit var wwd: WorldWindow

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_map)

        // Initialize WorldWindow
        wwd = WorldWindow(this)
        findViewById<FrameLayout>(R.id.globe_container).addView(wwd)

        // Configure globe projection
        wwd.engine.globe.projection = Wgs84Projection()
        wwd.engine.globe.verticalExaggeration = 2.0

        // Add base layers
        wwd.engine.layers.apply {
            addLayer(BackgroundLayer())
            addLayer(WebMercatorLayerFactory.createLayer(
                urlTemplate = "https://mt.google.com/vt/lyrs=s&x={x}&y={y}&z={z}",
                imageFormat = "image/jpeg",
                displayName = "Satellite Imagery"
            ))
            addLayer(AtmosphereLayer())
            addLayer(StarFieldLayer())
        }

        // Add elevation model
        wwd.engine.globe.elevationModel.addCoverage(BasicElevationCoverage())

        // Set initial camera position
        wwd.engine.camera.set(
            latitude = 37.5.degrees,
            longitude = -122.0.degrees,
            altitude = 10000000.0,
            altitudeMode = AltitudeMode.ABSOLUTE,
            heading = 0.degrees,
            tilt = 0.degrees,
            roll = 0.degrees
        )
    }

    override fun onPause() {
        super.onPause()
        wwd.onPause()
    }

    override fun onResume() {
        super.onResume()
        wwd.onResume()
    }
}
```

--------------------------------

### Placemark Picking Fragment Implementation in Kotlin

Source: https://github.com/worldwindearth/worldwindkotlin/blob/develop/worldwind-tutorials/src/androidMain/assets/placemarks_picking_tutorial.html

This Kotlin class, PlacemarksPickingFragment, extends BasicGlobeFragment to manage placemarks on a WorldWind globe. It overrides `createWorldWindow` to add a RenderableLayer with placemarks and a custom `PickNavigateController` to handle touch interactions. The controller allows for picking placemarks and toggling their highlighted state.

```kotlin
class PlacemarksPickingFragment: BasicGlobeFragment() { /**
 * Creates a new WorldWindow (GLSurfaceView) object with a WMS Layer
 * @return The WorldWindow object containing the globe.
 */
override fun createWorldWindow(): WorldWindow {
 // Let the super class (BasicGlobeFragment) do the creation
 val wwd = super.createWorldWindow()
 // Override the WorldWindow's built-in navigation behavior by adding picking support.
 wwd.controller = PickNavigateController(wwd)
 // Add a layer for placemarks to the WorldWindow
 val layer = RenderableLayer("Placemarks")
 wwd.engine.layers.addLayer(layer)
 // Create a few placemarks with highlight attributes and add them to the layer
 layer.addRenderable(
 createAirportPlacemark(
 fromDegrees(34.2000, -119.2070, 0.0),
 "Oxnard Airport"
 )
 )
 layer.addRenderable(
 createAirportPlacemark(
 fromDegrees(34.2138, -119.0944, 0.0),
 "Camarillo Airport"
 )
 )
 layer.addRenderable(
 createAirportPlacemark(
 fromDegrees(34.1193, -119.1196, 0.0),
 "Pt Mugu Naval Air Station"
 )
 )
 layer.addRenderable(createAircraftPlacemark(fromDegrees(34.15, -119.15, 2000.0)))
 // Position the viewer to look near the airports
 val lookAt = LookAt(
 position = Position(34.15.degrees, (-119.15).degrees, 0.0),
 altitudeMode = AltitudeMode.ABSOLUTE,
 range = 2e4,
 heading = 0.0.degrees,
 tilt = 45.0.degrees,
 roll = 0.0.degrees
 )
 wwd.engine.cameraFromLookAt(lookAt)
 return wwd
}

/**
 * This inner class is a custom WorldWindController that handles both picking and navigation via a combination of
 * the native WorldWind navigation gestures and Android gestures. This class' onTouchEvent method arbitrates
 * between pick events and globe navigation events.
 */
open inner class PickNavigateController(wwd: WorldWindow) : BasicWorldWindowController(wwd) {
 private lateinit var pickRequest: Deferred<PickedObjectList> // last picked objects from onDown event
 private var selectedObject: Any? = null // last "selected" object from single tap

 /**
 * Assign a subclassed SimpleOnGestureListener to a GestureDetector to handle the "pick" events.
 */
 private val pickGestureDetector = GestureDetector(requireContext().applicationContext, object : SimpleOnGestureListener() {
 override fun onDown(event: MotionEvent): Boolean {
 pick(event) // Pick the object(s) at the tap location
 return false // By not consuming this event, we allow it to pass on to the navigation gesture handlers
 }

 override fun onSingleTapUp(e: MotionEvent): Boolean {
 toggleSelection() // Highlight the picked object
 // By not consuming this event, we allow the "up" event to pass on to the navigation gestures,
 // which is required for proper zoom gestures. Consuming this event will cause the first zoom
 // gesture to be ignored. As an alternative, you can implement onSingleTapConfirmed and consume
 // event as you would expect, with the trade-off being a slight delay tap response.
 return false
 }
 })

 /**
 * Delegates events to the pick handler or the native WorldWind navigation handlers.
 */
 override fun onTouchEvent(event: MotionEvent): Boolean {
 // Allow pick listener to process the event first.
 val consumed = pickGestureDetector.onTouchEvent(event)
 // If event was not consumed by the pick operation, pass it on the globe navigation handlers
 // The super class performs the pan, tilt, rotate and zoom
 return if (!consumed) super.onTouchEvent(event) else true
 }

 /**
 * Performs a pick at the tap location.
 */
 fun pick(event: MotionEvent) {
 pickRequest = wwd.pickAsync(event.x, event.y)
 }

 /**
 * Toggles the selected state of a picked object.
 */
 fun toggleSelection() {
 wwd.mainScope.launch {
 // Get the top-most object for our new picked object
 val pickedObject = pickRequest.await().topPickedObject?.userObject
 // Display the highlight or normal attributes to indicate the
 // selected or unselected state respectively.
 if (pickedObject is Highlightable) {
 val oldSelectedObject = selectedObject
 // Determine if we've picked a "new" object so we know to deselect the previous selection
 val isNewSelection = pickedObject !== oldSelectedObject
 // Only one object can be selected at time, deselect any previously selected object
 if (isNewSelection && oldSelectedObject is Highlightable)
 oldSelectedObject.isHighlighted = false
 // Show the selection by showing its highlight attributes
 pickedObject.isHighlighted = isNewSelection
 wwd.requestRedraw() // Track the selected object
 selectedObject = if (isNewSelection) pickedObject else null
 }
 }
 }
 }

 companion object {
 private const val NORMAL_IMAGE_SCALE = 3.0
 private const val HIGHLIGHTED_IMAGE_SCALE = 4.0

 /**
 * Helper method to create aircraft placemarks.
 */
 private fun createAircraftPlacemark(posi
```

--------------------------------

### Gradle Configuration for WorldWind Kotlin

Source: https://context7.com/worldwindearth/worldwindkotlin/llms.txt

Demonstrates how to add WorldWind Kotlin as a dependency in Gradle build files for Android, JVM, and JavaScript projects. Includes configurations for stable releases, snapshot builds, and multiplatform setups.

```groovy
// build.gradle (project level)
buildscript {
    repositories {
        google()
        mavenCentral()
    }
    dependencies {
        classpath 'com.android.tools.build:gradle:8.1.0'
        classpath 'org.jetbrains.kotlin:kotlin-gradle-plugin:1.9.0'
    }
}

// build.gradle (app level) - Android
repositories {
    mavenCentral()
}

dependencies {
    // Latest stable release
    implementation 'earth.worldwind:worldwind:1.9.4'

    // Required dependencies
    implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-android:1.7.3'
}

// For snapshot builds with latest features
repositories {
    maven { url 'https://s01.oss.sonatype.org/content/repositories/snapshots/' }
}

dependencies {
    implementation 'earth.worldwind:worldwind:+'
}

// build.gradle.kts (Kotlin DSL)
repositories {
    mavenCentral()
}

dependencies {
    implementation("earth.worldwind:worldwind:1.9.4")
    implementation("org.jetbrains.kotlinx:kotlinx-coroutines-android:1.7.3")
}

// Multiplatform setup
kotlin {
    android()
    jvm()
    js(IR) {
        browser()
    }

    sourceSets {
        val commonMain by getting {
            dependencies {
                implementation("earth.worldwind:worldwind:1.9.4")
            }
        }
    }
}
```

--------------------------------

### Create Airport Placemark with Customization (Kotlin)

Source: https://github.com/worldwindearth/worldwindkotlin/blob/develop/worldwind-tutorials/src/androidMain/assets/placemarks_picking_tutorial.html

This function creates an airport placemark at a specified position, assigning it a display name. It customizes the placemark's image, scale, highlight attributes, and altitude mode. Dependencies include Worldwind's Position, Placemark, PlacemarkAttributes, AltitudeMode, and resource loading functions.

```kotlin
private fun createAirportPlacemark(position: Position, airportName: String): Placemark {
    val placemark = createWithImage(position, fromResource(MR.images.airport_terminal))
    placemark.attributes.imageOffset = bottomCenter()
    placemark.attributes.imageScale = NORMAL_IMAGE_SCALE
    val highlightedAttributes = PlacemarkAttributes(placemark.attributes)
    highlightedAttributes.imageScale = HIGHLIGHTED_IMAGE_SCALE
    placemark.highlightAttributes = highlightedAttributes
    placemark.displayName = airportName
    placemark.altitudeMode = AltitudeMode.CLAMP_TO_GROUND
    return placemark
}
```

--------------------------------

### Create and Configure WorldWindow in Kotlin

Source: https://github.com/worldwindearth/worldwindkotlin/blob/develop/worldwind-tutorials/src/androidMain/assets/basic_globe_tutorial.html

This Kotlin code demonstrates the creation and configuration of a WorldWindow object within an Android Fragment. It sets up layers (BackgroundLayer, WebMercatorLayerFactory for satellite imagery, StarFieldLayer, AtmosphereLayer) and elevation coverages (BasicElevationCoverage), utilizing caching mechanisms.

```kotlin
open class BasicGlobeFragment: Fragment() {
    /**
     * Gets the WorldWindow (GLSurfaceView) object.
     */
    lateinit var wwd: WorldWindow private set

    /**
     * Creates a new WorldWindow (GLSurfaceView) object.
     */
    open fun createWorldWindow(): WorldWindow {
        // Create the WorldWindow (a GLSurfaceView) which displays the globe.
        wwd = WorldWindow(requireContext())

        // Define cache content manager
        val contentManager = GpkgContentManager(File(requireContext().cacheDir, "cache_content.gpkg").absolutePath)

        // Setting up the WorldWindow's layers.
        wwd.engine.layers.apply {
            addLayer(BackgroundLayer())
            addLayer(
                WebMercatorLayerFactory.createLayer(
                    urlTemplate = "https://mt.google.com/vt/lyrs=s&x={x}&y={y}&z={z}&hl={lang}",
                    imageFormat = "image/jpeg",
                    name = "Google Satellite"
                ).apply {
                    wwd.mainScope.launch {
                        configureCache(contentManager, "GSat")
                    }
                }
            )
            addLayer(AtmosphereLayer())
        }

        // Setting up the WorldWindow's elevation coverages.
        wwd.engine.globe.elevationModel.addCoverage(
            BasicElevationCoverage().apply {
                configureCache(contentManager, "NASADEM")
            }
        )
        return wwd
    }

    /**
     * Adds the WorldWindow to this Fragment's layout.
     */
    override fun onCreateView(
        inflater: LayoutInflater,
        container: ViewGroup?,
        savedInstanceState: Bundle?
    ): View? {
        val rootView = inflater.inflate(R.layout.fragment_globe, container, false)
        val globeLayout = rootView.findViewById<FrameLayout>(R.id.globe)

        // Add the WorldWindow view object to the layout that was reserved for the globe.
        globeLayout.addView(createWorldWindow())
        return rootView
    }

    /**
     * Resumes the WorldWindow's rendering thread
     */
    override fun onResume() {
        super.onResume()
        wwd.onResume() // resumes a paused rendering thread
    }

    /**
     * Pauses the WorldWindow's rendering thread
     */
    override fun onPause() {
        super.onPause()
        wwd.onPause() // pauses the rendering thread
    }
}
```

--------------------------------

### Configure Globe Projection, Elevation, and Visuals in Kotlin

Source: https://context7.com/worldwindearth/worldwindkotlin/llms.txt

Set globe projection (Mercator, WGS84), vertical exaggeration, 2D offset, and add elevation coverages. Includes examples for custom geoid models, atmosphere altitude, getting absolute positions, and checking for 2D projection.

```kotlin
// Set projection to Mercator (2D map view)
wwd.engine.globe.projection = MercatorProjection()

// Set projection to WGS84 (3D globe)
wwd.engine.globe.projection = Wgs84Projection()

// Configure vertical exaggeration
wwd.engine.globe.verticalExaggeration = 3.0 // Exaggerate terrain 3x

// Configure 2D offset for continuous scrolling
wwd.engine.globe.offset = Offset.Center
// Or use left/right offset
wwd.engine.globe.offset = Offset(
    xUnits = OffsetMode.FRACTION,
    x = -1.0, // One globe width to the left
    yUnits = OffsetMode.FRACTION,
    y = 0.0
)

// Add elevation coverage
val elevationCoverage = BasicElevationCoverage()
wwd.engine.globe.elevationModel.addCoverage(elevationCoverage)

// Add multiple elevation sources
val highResElevation = TiledElevationCoverage(
    serviceAddress = "https://elevation.example.com/tiles",
    coverageName = "SRTM"
)
wwd.engine.globe.elevationModel.addCoverage(highResElevation)

// Set custom geoid model
wwd.engine.globe.geoid = EGM96Geoid()

// Configure atmosphere
wwd.engine.atmosphereAltitude = 160000.0 // 160 km

// Get absolute position considering altitude mode
val relativePosition = Position(37.7749.degrees, -122.4194.degrees, 1000.0)
val absolutePosition = wwd.engine.globe.getAbsolutePosition(
    position = relativePosition,
    altitudeMode = AltitudeMode.RELATIVE_TO_GROUND
)

// Check if using 2D projection
if (wwd.engine.globe.is2D) {
    Log.d("Globe", "Using 2D projection")
}
```

--------------------------------

### Kotlin: Create and Display Polygons on WorldWind Globe

Source: https://github.com/worldwindearth/worldwindkotlin/blob/develop/worldwind-tutorials/src/androidMain/assets/polygons_tutorial.html

This Kotlin code defines a WorldWind scene with multiple polygons. It includes examples of basic polygons, terrain-following polygons, extruded polygons, and polygons with inner holes, along with custom attribute configurations. The polygons are added to a RenderableLayer on the globe.

```kotlin
class PolygonsFragment : BasicGlobeFragment() { 
override fun createWorldWindow() = super.createWorldWindow().also { PolygonsTutorial(it.engine).start() } 
}

class PolygonsTutorial(private val engine: WorldWind) : AbstractTutorial() {
    private val layer = RenderableLayer("Polygons").apply {
        // Create a basic polygon with the default attributes, the default altitude mode (ABSOLUTE),
        // and the default path type (GREAT_CIRCLE).
        addRenderable( Polygon( listOf( Position.fromDegrees(40.0, -135.0, 5.0e5),
                                         Position.fromDegrees(45.0, -140.0, 7.0e5),
                                         Position.fromDegrees(50.0, -130.0, 9.0e5),
                                         Position.fromDegrees(45.0, -120.0, 7.0e5),
                                         Position.fromDegrees(40.0, -125.0, 5.0e5) ) )
        )

        // Create a terrain following polygon with the default attributes, and the default path type (GREAT_CIRCLE).
        addRenderable( Polygon( listOf( Position.fromDegrees(40.0, -105.0, 0.0),
                                         Position.fromDegrees(45.0, -110.0, 0.0),
                                         Position.fromDegrees(50.0, -100.0, 0.0),
                                         Position.fromDegrees(45.0, -90.0, 0.0),
                                         Position.fromDegrees(40.0, -95.0, 0.0) ) ).apply {
            altitudeMode = AltitudeMode.CLAMP_TO_GROUND // clamp the polygon vertices to the ground
            followTerrain = true // follow the ground between polygon vertices
        } )

        // Create an extruded polygon with the default attributes, the default altitude mode (ABSOLUTE),
        // and the default path type (GREAT_CIRCLE).
        addRenderable( Polygon( listOf( Position.fromDegrees(20.0, -135.0, 5.0e5),
                                         Position.fromDegrees(25.0, -140.0, 7.0e5),
                                         Position.fromDegrees(30.0, -130.0, 9.0e5),
                                         Position.fromDegrees(25.0, -120.0, 7.0e5),
                                         Position.fromDegrees(20.0, -125.0, 5.0e5) ) ).apply {
            isExtrude = true // extrude the polygon from the ground to each polygon position's altitude
        } )

        // Create an extruded polygon with custom attributes that display the extruded vertical lines,
        // make the extruded interior 50% transparent, and increase the polygon line with.
        addRenderable( Polygon( listOf( Position.fromDegrees(20.0, -105.0, 5.0e5),
                                         Position.fromDegrees(25.0, -110.0, 7.0e5),
                                         Position.fromDegrees(30.0, -100.0, 9.0e5),
                                         Position.fromDegrees(25.0, -90.0, 7.0e5),
                                         Position.fromDegrees(20.0, -95.0, 5.0e5) ) ).apply {
            attributes.apply {
                isDrawVerticals = true // display the extruded verticals
                interiorColor = Color(1f, 1f, 1f, 0.5f) // 50% transparent white
                outlineWidth = 3f
            }
            isExtrude = true // extrude the polygon from the ground to each polygon position's altitude
        } )

        // Create a polygon with an inner hole by specifying multiple polygon boundaries
        addRenderable( Polygon().apply {
            addBoundary( listOf( Position.fromDegrees(0.0, -135.0, 5.0e5),
                                 Position.fromDegrees(5.0, -140.0, 7.0e5),
                                 Position.fromDegrees(10.0, -130.0, 9.0e5),
                                 Position.fromDegrees(5.0, -120.0, 7.0e5),
                                 Position.fromDegrees(0.0, -125.0, 5.0e5) ) )
            addBoundary( listOf( Position.fromDegrees(2.5, -130.0, 6.0e5),
                                 Position.fromDegrees(5.0, -135.0, 7.0e5),
                                 Position.fromDegrees(7.5, -130.0, 8.0e5),
                                 Position.fromDegrees(5.0, -125.0, 7.0e5) ) )
        } )

        // Create an extruded polygon with an inner hole and custom attributes that display the extruded vertical lines,
        // make the extruded interior 50% transparent, and increase the polygon line with.
        addRenderable( Polygon(emptyList()).apply {
            attributes.apply {
                isDrawVerticals = true // display the extruded verticals
                interiorColor = Color(1f, 1f, 1f, 0.5f) // 50% transparent white
                outlineWidth = 3f
            }
            addBoundary( listOf( Position.fromDegrees(0.0, -105.0, 5.0e5),
                                 Position.fromDegrees(5.0, -110.0, 7.0e5),
                                 Position.fromDegrees(10.0, -100.0, 9.0e5),
                                 Position.fromDegrees(5.0, -90.0, 7.0e5),
                                 Position.fromDegrees(0.0, -95.0, 5.0e5) ) )
            addBoundary( listOf( Position.fromDegrees(2.5, -100.0, 6.0e5),
                                 Position.fromDegrees(5.0, -105.0, 7.0e5),
                                 Position.fromDegrees(7.5, -100.0, 8.0e5),
                                 Position.fromDegrees(5.0, -95.0, 7.0e5) ) )
            isExtrude = true // extrude the polygon from the ground to each polygon position's altitude
        } )
    }

    override fun start() {
        super.start()
        engine.layers.addLayer(layer)
        engine.camera.set( Angle.fromDegrees(30.0), Angle.fromDegrees(-115.0), engine.distanceToViewGlobeExtents * 1.1, AltitudeMode.ABSOLUTE, heading = Angle.ZERO, tilt = Angle.ZERO, roll = Angle.ZERO )
    }

    override fun stop() {
        super.stop()
        engine.layers.removeLayer(layer)
    }
}
```

--------------------------------

### Configure Camera View with Kotlin

Source: https://github.com/worldwindearth/worldwindkotlin/blob/develop/worldwind-tutorials/src/androidMain/assets/camera_view_tutorial.html

Sets up the WorldWindow camera to view a specific location from a given altitude and orientation. It calculates heading, tilt, and distance using WorldWind's geometry functions. Requires WorldWind engine and Position objects.

```kotlin
class CameraViewFragment: BasicGlobeFragment() { 
/** 
 * Creates a new WorldWindow with its camera positioned at a given location and configured to point in a given 
 * direction. 
 */ 
override fun createWorldWindow() = super.createWorldWindow().also { CameraViewTutorial(wwd.engine).start() } 
}

class CameraViewTutorial(private val engine: WorldWind) : AbstractTutorial() {
    override fun start() {
        super.start()
        setCameraAction()
    }

    private fun setCameraAction() {
        // Create a view of Point Mugu airport as seen from an aircraft above Oxnard, CA.
        val aircraft = Position.fromDegrees(34.2, -119.2, 3000.0) // Above Oxnard CA, altitude in meters
        val airport = Position.fromDegrees(34.1192744, -119.1195850, 4.0) // KNTD airport, Point Mugu CA, altitude MSL

        // Compute heading and tilt angles from aircraft to airport
        val heading = aircraft.greatCircleAzimuth(airport)
        val distanceRadians = aircraft.greatCircleDistance(airport)
        val distanceMeters = distanceRadians * engine.globe.getRadiusAt(aircraft.latitude, aircraft.longitude)
        val tilt = Angle.fromRadians(atan(distanceMeters / aircraft.altitude))

        // Apply the camera view
        engine.camera.set(
            aircraft.latitude,
            aircraft.longitude,
            aircraft.altitude,
            AltitudeMode.ABSOLUTE,
            heading,
            tilt,
            roll = Angle.ZERO
        )
    }
}
```

--------------------------------

### Configure Labels on WorldWind Globe (Kotlin)

Source: https://github.com/worldwindearth/worldwindkotlin/blob/develop/worldwind-tutorials/src/androidMain/assets/labels_tutorial.html

This Kotlin code defines a fragment and a tutorial class to display various configurable labels on a WorldWind globe. It includes dependencies on WorldWind engine, renderables, and utility classes. The input is the WorldWind engine, and the output is a layer with configured labels added to the globe.

```kotlin
class LabelsFragment : BasicGlobeFragment() { /**
 * Creates a new WorldWindow (GLSurfaceView) object with a set of label shapes
 * 
 * @return The WorldWindow object containing the globe.
 */
 override fun createWorldWindow() = super.createWorldWindow().also { LabelsTutorial(it.engine).start() }
}

class LabelsTutorial(private val engine: WorldWind): AbstractTutorial() {
    private val layer = RenderableLayer("Labels").apply {
        // Create a basic label with the default attributes, including the default text color (white), the default text
        // size (24 pixels), the system default font, and the default alignment (bottom center).
        addRenderable(
            Label(Position.fromDegrees(38.8977, -77.0365, 0.0), "The White House").apply {
                altitudeMode = AltitudeMode.CLAMP_TO_GROUND
            }
        )

        // Create a label with a black text color, the default text size, the system default font, the default
        // alignment, and a thick white text outline.
        addRenderable(
            Label(Position.fromDegrees(38.881389, -77.036944, 0.0), "Thomas Jefferson Memorial").apply {
                altitudeMode = AltitudeMode.CLAMP_TO_GROUND
                attributes.apply {
                    textColor = Color(0f, 0f, 0f, 1f) // black text via r,g,b,a
                    outlineColor = Color(1f, 1f, 1f, 1f) // white outline via r,g,b,a
                    outlineWidth = 5f // thicken the white outline
                }
            }
        )

        // Create a right-aligned label using a bottom-right offset.
        addRenderable(
            Label(Position.fromDegrees(38.8893, -77.050111, 0.0), "Lincoln Memorial").apply {
                altitudeMode = AltitudeMode.CLAMP_TO_GROUND
                attributes.apply {
                    textOffset = Offset.bottomRight()
                }
            }
        )

        // Create a left-aligned label using a bottom-left offset.
        addRenderable(
            Label(Position.fromDegrees(38.889803, -77.009114, 0.0), "United States Capitol").apply {
                altitudeMode = AltitudeMode.CLAMP_TO_GROUND
                attributes.apply {
                    textOffset = Offset.bottomLeft()
                }
            }
        )

        // Create a label with a 48 pixel text size and a bold font.
        addRenderable(
            Label(Position.fromDegrees(38.907192, -77.036871, 0.0), "Washington").apply {
                altitudeMode = AltitudeMode.CLAMP_TO_GROUND
                attributes.apply {
                    font = Font("arial", FontWeight.BOLD, 28)
                }
            }
        )

        // Create a label with its orientation fixed relative to the globe.
        addRenderable(
            Label(Position.fromDegrees(38.89, -77.023611, 0.0), "National Mall").apply {
                altitudeMode = AltitudeMode.CLAMP_TO_GROUND
                rotationMode = OrientationMode.RELATIVE_TO_GLOBE
            }
        )
    }

    override fun start() {
        super.start()
        engine.layers.addLayer(layer)
        engine.camera.set(
            Angle.fromDegrees(38.89),
            Angle.fromDegrees(-77.023611),
            10e3,
            AltitudeMode.ABSOLUTE,
            heading = Angle.ZERO,
            tilt = Angle.ZERO,
            roll = Angle.ZERO
        )
    }

    override fun stop() {
        super.stop()
        engine.layers.removeLayer(layer)
    }
}
```

--------------------------------

### Customizing Shape Rendering Attributes in WorldWind Kotlin

Source: https://context7.com/worldwindearth/worldwindkotlin/llms.txt

Provides a comprehensive example of configuring `ShapeAttributes` and `PlacemarkAttributes` in Kotlin for WorldWind. This covers interior/outline styling, image sources, label appearance, and level-of-detail selection for placemarks.

```kotlin
// Create comprehensive shape attributes
val attributes = ShapeAttributes().apply {
    // Interior (fill) properties
    interiorColor = Color(0.0f, 0.5f, 1.0f, 0.6f)
    interiorImageSource = ImageSource.fromResource(R.drawable.pattern)
    interiorImageRepeat = ImageRepeat.REPEAT

    // Outline properties
    outlineColor = Color(1.0f, 1.0f, 1.0f, 1.0f)
    outlineWidth = 3f
    outlineImageSource = ImageSource.fromResource(R.drawable.border)
    outlineStippleFactor = 2
    outlineStipplePattern = 0xAAAA.toShort()

    // Drawing properties
    isDrawInterior = true
    isDrawOutline = true
    isDrawVerticals = false // For extruded shapes
    isDepthTest = true
    isDepthWrite = true
    isLighting = false

    // Picking
    isPickEnabled = true
}

// Apply to polygon
val polygon = Polygon().apply {
    this.attributes = attributes
    highlightAttributes = ShapeAttributes(attributes).apply {
        interiorColor = Color(1.0f, 0.5f, 0.0f, 0.8f)
        outlineColor = Color(1.0f, 0.0f, 0.0f, 1.0f)
        outlineWidth = 5f
    }
}

// Placemark attributes
val placemarkAttrs = PlacemarkAttributes().apply {
    // Image properties
    imageSource = ImageSource.fromResource(R.drawable.marker)
    imageScale = 1.5
    imageOffset = Offset.bottomCenter()
    imageColor = Color(1.0f, 1.0f, 1.0f, 1.0f) // Tint color

    // Label properties
    labelAttributes = TextAttributes().apply {
        font = Font(24f, Typeface.DEFAULT_BOLD)
        textColor = Color(1.0f, 1.0f, 1.0f, 1.0f)
        backgroundColor = Color(0.0f, 0.0f, 0.0f, 0.7f)
        textOffset = Offset(OffsetMode.PIXELS, 0.0, OffsetMode.PIXELS, -25.0)
        enableOutline = true
        outlineColor = Color(0.0f, 0.0f, 0.0f, 1.0f)
        outlineWidth = 2f
    }

    // Leader line (connecting line to ground)
    isDrawLeader = true
    leaderAttributes = ShapeAttributes().apply {
        outlineColor = Color(1.0f, 1.0f, 1.0f, 0.8f)
        outlineWidth = 2f
    }
}

// Level of detail selector for placemarks
val lodSelector = object : LevelOfDetailSelector {
    override fun selectLevelOfDetail(
        rc: RenderContext,
        renderable: Renderable,
        cameraDistance: Double
    ): Boolean {
        // Only show if closer than 5000km
        return cameraDistance < 5000000.0
    }
}

val placemark = Placemark(position, "City", placemarkAttrs)
placemark.levelOfDetailSelector = lodSelector

```

--------------------------------

### Create and Display WMS Layer in Kotlin

Source: https://github.com/worldwindearth/worldwindkotlin/blob/develop/worldwind-tutorials/src/androidMain/assets/wms_layer_tutorial.html

This Kotlin code snippet demonstrates how to create and display an OGC Web Map Service (WMS) layer using WorldWind's LayerFactory. It handles asynchronous layer creation, adds the layer to the WorldWind engine, and manages layer removal when stopped. Error handling for layer creation is also included. Dependencies include WorldWind, CoroutineScope, and Logger.

```kotlin
class WmsLayerFragment : BasicGlobeFragment() { 
    /**
     * Creates a new WorldWindow (GLSurfaceView) object with a WMS Layer
     *
     * @return The WorldWindow object containing the globe.
     */
    override fun createWorldWindow() = super.createWorldWindow().also { WmsLayerTutorial(it.engine, it.mainScope).start() }
}

class WmsLayerTutorial(private val engine: WorldWind, private val mainScope: CoroutineScope) : AbstractTutorial() {
    private var wmsLayer: TiledImageLayer? = null
    private var isStarted = false

    override fun start() {
        super.start()
        mainScope.launch {
            try {
                isStarted = true
                // Create an OGC Web Map Service (WMS) layer to display the
                // surface temperature layer from NASA's Near Earth Observations WMS.
                WmsLayerFactory.createLayer("https://neo.gsfc.nasa.gov/wms/wms", listOf("MOD_LSTD_CLIM_M")
                ).also {
                    if (isStarted) {
                        wmsLayer = it
                        engine.layers.addLayer(it)
                        WorldWind.requestRedraw()
                    }
                }
                Logger.log(Logger.INFO, "WMS layer creation succeeded")
            } catch (e: Exception) {
                Logger.log(Logger.ERROR, "WMS layer creation failed", e)
            }
        }
        engine.camera.apply {
            position.altitude = engine.distanceToViewGlobeExtents * 1.1
            heading = Angle.ZERO
            tilt = Angle.ZERO
            roll = Angle.ZERO
        }
    }

    override fun stop() {
        super.stop()
        isStarted = false
        wmsLayer?.let { engine.layers.removeLayer(it) }.also { wmsLayer = null }
    }
}
```

--------------------------------

### Add MGRS Graticule Layer - Kotlin

Source: https://github.com/worldwindearth/worldwindkotlin/blob/develop/worldwind-tutorials/src/androidMain/assets/mgrs_graticule_tutorial.html

This Kotlin code extends a basic globe fragment to include an MGRS Graticule layer. It overrides the createWorldWindow method to initialize and start the MGRSGraticuleTutorial, which adds the MGRSGraticuleLayer to the WorldWind engine's layers.

```kotlin
class MGRSGraticuleFragment : BasicGlobeFragment() { 
    /** 
     * Creates a new WorldWindow with a MGRS Graticule layer. 
     */ 
    override fun createWorldWindow() = super.createWorldWindow().also { MGRSGraticuleTutorial(it.engine).start() }
}

class MGRSGraticuleTutorial(private val engine: WorldWind) : AbstractTutorial() {
    // Create a layer that displays the globe's tessellation geometry.
    private val layer = MGRSGraticuleLayer()

    override fun start() {
        super.start()
        engine.layers.addLayer(layer)
    }

    override fun stop() {
        super.stop()
        engine.layers.removeLayer(layer)
    }
}
```

--------------------------------

### Kotlin Tessellation Layer Initialization

Source: https://github.com/worldwindearth/worldwindkotlin/blob/develop/worldwind-tutorials/src/androidMain/assets/show_tessellation_tutorial.html

Initializes a WorldWindow with a custom tessellation layer. This Kotlin code defines a fragment that overrides the base class's method to add the ShowTessellationLayer to the globe's engine. It demonstrates how to programmatically control the layers displayed on the globe.

```kotlin
class ShowTessellationFragment : BasicGlobeFragment() { /** * Creates a new WorldWindow with a tessellation layer. */ override fun createWorldWindow() = super.createWorldWindow().also { ShowTessellationTutorial(it.engine).start() } }
class ShowTessellationTutorial(private val engine: WorldWind) : AbstractTutorial() {
    // Create a layer that displays the globe's tessellation geometry.
    private val layer = ShowTessellationLayer()

    override fun start() {
        super.start()
        engine.layers.addLayer(layer)
    }

    override fun stop() {
        super.stop()
        engine.layers.removeLayer(layer)
    }
}
```
Tokens:
Raw