Package com.massifmaps.components

Class Options

java.lang.Object
com.massifmaps.components.Options
public class Options extends Object
A class containing various options for rendering and map manipulation.

  • Method Details

    • equals

      public boolean equals(Object obj)
      Checks if this object is equal to the specified object.
      Overrides:
      equals in class Object
      Parameters:
      obj - The reference object.
      Returns:
      True when objects are equal, false otherwise.

    • hashCode

      public int hashCode()
      Returns the hash value of this object.
      Overrides:
      hashCode in class Object
      Returns:
      The hash value of this object.

    • getAmbientLightColor

      public Color getAmbientLightColor()
      Returns the color of the ambient light.
      Returns:
      The color of the ambient light.

    • setAmbientLightColor

      public void setAmbientLightColor(Color color)
      Sets the ambient light color.
      Ambient light affects all lighting enabled models in the scene equally, it has no direction or location.
      Parameters:
      color - The new color for the ambient light.

    • getMainLightColor

      public Color getMainLightColor()
      Returns the color of the main light.
      Returns:
      The color of the main light.

    • setMainLightColor

      public void setMainLightColor(Color color)
      Sets the color of the main light. The main light affects all lighting enabled models
      in the scene equally from a certain direction. This light can be used to simulate sun or moon light.
      Parameters:
      color - The new color for the main light.

    • getMainLightDirection

      public MapVec getMainLightDirection()
      Returns the direction of the main light.
      Returns:
      The direction of the main light.

    • setMainLightDirection

      public void setMainLightDirection(MapVec direction)
      Sets the direction of the main light. The main light affects all lighting enabled models
      in the scene equally from a certain direction. This light can be used to simulate sun or moon light.
      The direction is always measured based on the local tangent frame of the focus point.
      Parameters:
      direction - The new direction vector for the main light. (0,0,-1) means straight down, (-0.707,0,-0.707) means
      from east with a 45 degree angle. The direction vector will be normalized.

    • getRenderProjectionMode

      public int getRenderProjectionMode()
      Returns the render projection mode.
      Returns:
      The render projection mode.

    • setRenderProjectionMode

      public void setRenderProjectionMode(int renderProjectionMode)
      Sets the render projection mode. The default is RenderProjectionMode::PLANAR.
      Parameters:
      renderProjectionMode - The new render projection mode.

    • isDebugTileBorders

      public boolean isDebugTileBorders()
      Returns the state of the tile border debug overlay.
      Returns:
      True if every tile layer outlines the tiles it draws.

    • setDebugTileBorders

      public void setDebugTileBorders(boolean enabled)
      Sets the state of the tile border debug overlay. Every tile layer then outlines the
      tiles it actually draws, in 3D following the terrain, with a colour per zoom level and
      alternating brightness between neighbours - so a layer using a coarser tile set than
      the one under it, an overzoomed stand-in, or a tile that owns pixels it should not, is
      visible on screen. The default is false.
      Parameters:
      enabled - The new state of the tile border debug overlay.

    • isClickTypeDetection

      public boolean isClickTypeDetection()
      Returns the click type detection state.
      Returns:
      True if click type detection is enabled.

    • setClickTypeDetection

      public void setClickTypeDetection(boolean enabled)
      Sets the state of the click type detection flag. If set to true clicks are categorized as normal clicks, double clicks,
      long clicks and dual clicks. The default is true.
      Parameters:
      enabled - The new state of the click type detection flag.

    • getClickMovingTolerance

      public float getClickMovingTolerance()
      Returns how far a pointer may travel before a press stops counting as a click.
      Returns:
      The tolerance in density-independent pixels (dp). The default is 32.

    • setClickMovingTolerance

      public void setClickMovingTolerance(float tolerance)
      Sets how far a pointer may travel before a press stops counting as a click and the map
      starts panning. The default, 32 dp, is a finger-sized threshold; a mouse wants far less
      (maplibre uses 3 px), which is why a desktop or web host lowers it.
      Parameters:
      tolerance - The new tolerance in density-independent pixels (dp).

    • isDoubleClickDetection

      public boolean isDoubleClickDetection()
      Returns the double click detection state.
      Returns:
      True if double click detection is enabled.

    • setDoubleClickDetection

      public void setDoubleClickDetection(boolean enabled)
      Sets the state of the double click detection flag. If set to true clicks, then double clicks are detected separately from normal clicks. are categorized as normal clicks, double clicks,
      The click type resolving takes about 400ms (configurable via setDoubleClickMaxDuration), so for applications that do not
      require this functionality, it can be turned off. The default is true.
      Parameters:
      enabled - The new state of the double click detection flag.

    • getLongClickDuration

      public float getLongClickDuration()
      Returns the long click duration in seconds.
      Returns:
      The long click duration in seconds.

    • setLongClickDuration

      public void setLongClickDuration(float duration)
      Sets the long click duration in seconds. The default is value is 0.4 (400ms).
      Parameters:
      duration - The new duration for the long click in seconds.

    • getDoubleClickMaxDuration

      public float getDoubleClickMaxDuration()
      Returns the double click max duration in seconds.
      Returns:
      The double click max duration in seconds.

    • setDoubleClickMaxDuration

      public void setDoubleClickMaxDuration(float duration)
      Sets the double click max in seconds. The default is value is 0.4 (400ms).
      Parameters:
      duration - The new value for the double click max duration detection in seconds.

    • getTileDrawSize

      public int getTileDrawSize()
      Returns the tile size used for drawing map tiles.
      Returns:
      The tile size in density-independent pixels (dp).

    • setTileDrawSize

      public void setTileDrawSize(int tileDrawSize)
      Sets the tile size for drawing map tiles. Different datasources may have different tile sizes, this option
      can be used to compensate for bigger or smaller tiles than default. The default is 256.

      A style's own sizes do NOT follow it: a vector tile layer decodes against this size, so a
      label stays the same dp whatever tile the layer picks. Set it before adding the layer -
      a layer reads it when it joins the map.
      Parameters:
      tileDrawSize - The new tile size in density-independent pixels (dp).

    • getZoomOffset

      public float getZoomOffset()
      Returns how many zoom levels the camera is offset from the tile-size convention.
      Returns:
      The zoom offset in levels. The default is 0.

    • setZoomOffset

      public void setZoomOffset(float offset)
      Sets how many zoom levels the camera is offset from the tile-size convention.

      The SDK calibrates on a 256-pixel tile, maplibre and mapbox-gl on a 512-pixel one, so an
      offset of 1 adopts theirs. It RENUMBERS and nothing else: label and line sizes do not
      move with it, which is why it is not just a bigger TileDrawSize. Changing it changes what
      getZoom() reports, so a stored camera and a visibleZoomRange move with it.
      Parameters:
      offset - The new zoom offset in levels. The default is 0.

    • getTileLODFactor

      public float getTileLODFactor()
      Returns the factor on the screen size a tile may cover before it is refined.
      Returns:
      The tile LOD factor. The default is 0.5; 1 is exactly tangram's rule.

    • setTileLODFactor

      public void setTileLODFactor(float factor)
      Sets how big a tile may get on screen before the next zoom level is used, as a factor on
      tangram's rule (core/src/tile/tileManager.cpp): refine while the tile's projected screen
      area is at least that of a 2x2 block of nominal tiles. A factor of 1 is that rule
      verbatim, larger keeps tiles coarser (fewer tiles, fewer labels, less detail), smaller
      refines further.
      Where it matters is a tilted view: a tile near the horizon collapses to a few pixels of
      screen while its distance barely grows, so this - not the view distance - is what decides
      how much of the horizon band is drawn at full detail.
      Parameters:
      factor - The new tile LOD factor. The default is 0.5.

    • getTileLODMaxZoomLevelsOnScreen

      public float getTileLODMaxZoomLevelsOnScreen()
      Returns how many distinct zoom levels a tilted view may spread over.
      Returns:
      The zoom levels on screen. The default is 9.314, maplibre's.

    • setTileLODMaxZoomLevelsOnScreen

      public void setTileLODMaxZoomLevelsOnScreen(float levels)
      Sets how many distinct zoom levels the frame may spread over when the horizon is at the
      top of the screen - maplibre's maxZoomLevelsOnScreen (setSourceTileLodParams).
      It sets how fast the level decays toward the horizon: HIGHER spreads more levels over the
      frame, so the far field coarsens faster and costs fewer tiles; LOWER keeps far ground
      finer and costs more. maplibre's 9.314 is our screen-area rule exactly, so it is the
      default and changing nothing changes nothing.
      This supersedes the old TileLODForeshorteningLimit, which bounded the same term from the
      other side with a number that had no reference behind it.
      Parameters:
      levels - The zoom levels on screen. The default is 9.314.

    • getTileLODTileCountRatio

      public float getTileLODTileCountRatio()
      Returns how many times more tiles a tilted view may load than a top-down one.
      Returns:
      The ratio. The default is 3, maplibre's.

    • setTileLODTileCountRatio

      public void setTileLODTileCountRatio(float ratio)
      Sets the cap on how many more tiles a tilted view may load than a top-down one -
      maplibre's tileCountMaxMinRatio. When the cap would be exceeded the level is lowered
      uniformly across the frame until it fits.
      NOTE this binds only when TileLODMaxZoomLevelsOnScreen asks for a gentler far field than
      the default: at the default the pitched view never counts as asking for more tiles than a
      flat one, so the cap is inert. It bounds the cost of refining the horizon, it does not
      rescue a view that is slow for another reason.
      Parameters:
      ratio - The ratio. The default is 3.

    • setTileLODProfile

      public void setTileLODProfile(int profile)
      Applies a named set of the tile LOD numbers - TileLODFactor,
      TileLODMaxZoomLevelsOnScreen, TileLODTileCountRatio and TileStyleZoomLift at once.
      They multiply into the tile count, so tuning them separately is how a map ends up four
      times more expensive than any reference renderer without anyone deciding to. Set a
      profile for the platform, then override one number if a specific map needs it.
      Parameters:
      profile - The profile to apply.

    • getTileStyleZoomLift

      public int getTileStyleZoomLift()
      Returns how many zoom levels above its own a coarsened tile may be styled at.
      Returns:
      The lift in zoom levels. The default is 2.

    • setTileStyleZoomLift

      public void setTileStyleZoomLift(int levels)
      Sets how many zoom levels above its own zoom a coarsened tile matches its style rules at.
      The LOD rule (see setTileLODFactor) hands back a tile coarser than the camera asked for,
      and a CartoCSS [zoom] filter gates on the TILE, so a converted MapBox style's
      `minzoom` - a VIEW-zoom gate in the original - stops matching the moment the tile
      coarsens: one level, and the far half of a tilted view loses every building along a
      straight tile edge.
      This lifts the zoom the rules are matched at, without changing which tiles are drawn. It
      is bounded because a far tile styled at the camera's zoom emits the whole near-field
      content - every label, every arrow - over ground tens of times wider. 2 covers the first
      two coarsening steps, where the visible edge is; 0 restores the tile's own zoom.
      Parameters:
      levels - The lift in zoom levels. The default is 2.

    • getDPI

      public float getDPI()
      Returns the dots per inch value.
      Returns:
      The dots per inch value.

    • setDPI

      public void setDPI(float dpi)
      Sets the dots per inch value. This is calculated automatically by the SDK when the MapView is created using
      the device screen parameters. The purpose of this value is to compensate for very high or low resolution devices,
      so that the map remains readable.
      Parameters:
      dpi - The new dots per inch value.

    • getDrawDistance

      public float getDrawDistance()
      Returns the draw distance value.
      Returns:
      The draw distance value.

    • setDrawDistance

      public void setDrawDistance(float drawDistance)
      Sets a new draw distance value. The higher the draw distance the more tiles can be seen, if the map is tilted.
      Changing the draw distance will cause the horizon to move, which means that the if the sky bitmap is used,
      the horizon may not match up anymore. Increasing this value will decrease performance and increase network traffic,
      if online map is used. The default is 16.
      Parameters:
      drawDistance - The new draw distance value.

    • getFieldOfViewY

      public int getFieldOfViewY()
      Returns the vertial field of view angle.
      Returns:
      The vertical field of view angle in degrees.

    • setFieldOfViewY

      public void setFieldOfViewY(int fovY)
      Sets the vertial field of view angle. Larger values increase the viewable area, at the cost of performance and
      additional perspective distortion. The default is 70.
      Parameters:
      fovY - The new vertical field of view angle in degrees.

    • getPanningMode

      public int getPanningMode()
      Returns the panning mode.
      Returns:
      The panning mode.

    • setPanningMode

      public void setPanningMode(int panningMode)
      Sets the panning mode. The default is PanningMode::FREE.
      Parameters:
      panningMode - The new panning mode.

    • getPivotMode

      public int getPivotMode()
      Returns the pivot mode.
      Returns:
      The pivot mode.

    • setPivotMode

      public void setPivotMode(int pivotMode)
      Sets the pivot mode. The default is PIVOT_MODE_TOUCHPOINT
      Parameters:
      pivotMode - The new pivot mode.

    • isSeamlessPanning

      public boolean isSeamlessPanning()
      Returns the state of seamless horizontal panning flag.
      Returns:
      True if seamless horizontal panning is enabled.

    • setSeamlessPanning

      public void setSeamlessPanning(boolean enabled)
      Sets the state of seamless horizontal panning flag. If set to true, the user can scroll seamlessly from
      the left side of the map to the right, and the other way around. The default is true.
      Parameters:
      enabled - The new state of seamless horizontal panning flag.

    • isRestrictedPanning

      public boolean isRestrictedPanning()
      Returns the state of the restricted panning flag.
      Returns:
      True if restricted panning is enabled.

    • setRestrictedPanning

      public void setRestrictedPanning(boolean enabled)
      Sets the restricted panning flag. If set to true, then focus point coordinates and zoom level of the map view
      will be adjusted to display as little empty background as possible. The default is false.

    • isTiltGestureReversed

      public boolean isTiltGestureReversed()
      Returns true if tilting gesture direction is reversed (and same as with Google Maps).
      Returns:
      True if tilting gesture direction is reversed (and same as with Google Maps). Otherwise returns false.

    • setTiltGestureReversed

      public void setTiltGestureReversed(boolean reversed)
      Sets the tilting gesture direction. By default, the gesture is not reversed.
      Parameters:
      reversed - True if Google Maps compatible mode should be used. False otherwise (default).

    • isZoomGestures

      public boolean isZoomGestures()
      Returns the state of zoom gestures.
      Returns:
      True if zoom gestures are enabled. False otherwise.

    • setZoomGestures

      public void setZoomGestures(boolean enabled)
      Sets the zoom gestures flag. Zoom gestures allow to use double click and dual click to zoom in/out of the map.
      Enabled by default. Note that zoom gestures require that click detection mode is enabled and also that double click detection is enabled.
      Parameters:
      enabled - True if zoom gestured should be enabled, false otherwise.

    • isRotationGestures

      public boolean isRotationGestures()
      Returns the state of rotation gestures.
      Returns:
      True if rotation gestures are enabled. False otherwise.

    • setRotationGestures

      public void setRotationGestures(boolean enabled)
      Sets the rotation gestures flag. Rotation gestures allow to use pinch to rotate the map.
      By default, rotation gestures are not enabled.
      Parameters:
      enabled - True if rotation gestured should be enabled, false otherwise.

    • getEnvelopeThreadPoolSize

      public int getEnvelopeThreadPoolSize()
      Returns the number of threads used by the envelope task pool.
      Returns:
      The envelope task thread pool size.

    • setEnvelopeThreadPoolSize

      public void setEnvelopeThreadPoolSize(int poolSize)
      Sets the number of threads used by the envelope task pool. More threads means more envelope tasks
      are executed in parallel. This might speed up the data query, but may cause performance drops. Default is 1.
      Parameters:
      poolSize - The new envelope task thread pool size.

    • getTileThreadPoolSize

      public int getTileThreadPoolSize()
      Returns the number of threads used by the tile task pool.
      Returns:
      The tile task thread pool size.

    • setTileThreadPoolSize

      public void setTileThreadPoolSize(int poolSize)
      Sets the number of threads used by the tile task pool. More threads means more tile tasks
      are executed in parallel. This might speed up the data query, but may cause performance drops. Default is 1.
      Parameters:
      poolSize - The new tile task thread pool size.

    • getClearColor

      public Color getClearColor()
      Returns the clear color used by the renderer before drawing anything else.
      By default, this is white. It should be set to (0, 0, 0, 0) if transparent MapView is needed.
      Returns:
      The clear color.

    • setClearColor

      public void setClearColor(Color color)
      Sets the clear color of the renderer.
      Parameters:
      color - The new clear color.

    • getSkyColor

      public Color getSkyColor()
      Returns the sky color.
      Returns:
      The sky color.

    • setSkyColor

      public void setSkyColor(Color color)
      Sets the sky color. The purpose of the sky bitmap is to fill out the empty space visible at low tilt angles.
      Parameters:
      color - The new sky color. If the color is transparent, sky is not rendered.

    • getBackgroundBitmap

      public Bitmap getBackgroundBitmap()
      Returns the background bitmap. May be null.
      Returns:
      The background bitmap.

    • setBackgroundBitmap

      public void setBackgroundBitmap(Bitmap backgroundBitmap)
      Sets the background bitmap. The purpose of the background bitmap is to fill out the empty space when there's
      no map data visible. The bitmap will get scaled and repeated to cover the hole visible area. If a null pointer is passed,
      the background won't be drawn.
      The width and height of the bitmap must be power of two (for example: 256 * 256 or 128 * 512).
      It's also preferred if the bitmap was square (width == height), but this is not a requirement.
      The default is "default_background.png".
      Parameters:
      backgroundBitmap - The new background bitmap.

    • isUserInput

      public boolean isUserInput()
      Returns the state of the user input flag.
      Returns:
      True if user input is allowed.

    • setUserInput

      public void setUserInput(boolean enabled)
      Sets the state of the user input flag. If set to false the user won't be able to pan the map using touch controls,
      programmatic map panning using MapView methods is still possible. The default is false.
      Parameters:
      enabled - The new state of the user input flag.

    • getPanningSpeedMode

      public int getPanningSpeedMode()
      Returns the panning speed mode.
      Returns:
      The panning speed mode.

    • setPanningSpeedMode

      public void setPanningSpeedMode(int mode)
      Sets how fast a one-finger pan moves the map on a tilted view. The default is
      PANNING_SPEED_MODE_ANCHORED, which keeps the speed a gesture starts with for as long as
      it lasts; PANNING_SPEED_MODE_MAP is the exact grab-the-world pan, which changes speed as
      the finger moves between near and far parts of the screen.
      Parameters:
      mode - The new panning speed mode.

    • getFreeRoamMode

      public int getFreeRoamMode()
      Returns the free roam mode.
      Returns:
      The free roam mode.

    • setFreeRoamMode

      public void setFreeRoamMode(int mode)
      Sets the free roam mode: what a one-finger drag does, and which camera model the tilt
      and the rotation follow. Free roam is what makes content placed in the sky
      (CelestialLayer) reachable, since it is normally off the top of the screen. To look
      ABOVE the horizon the tilt range has to allow a negative tilt - e.g.
      setTiltRange(MapRange(-90, 90)) - as it stops at the horizon by default.
      The default is FREE_ROAM_MODE_OFF.
      Parameters:
      mode - The new free roam mode.

    • getFreeRoamLookSensitivity

      public float getFreeRoamLookSensitivity()
      Returns how fast a free roam drag turns the view.
      Returns:
      The turn in degrees per inch of drag.

    • setFreeRoamLookSensitivity

      public void setFreeRoamLookSensitivity(float degreesPerInch)
      Sets how fast a free roam drag turns the view, in degrees per inch of drag. The default
      is 90, i.e. an inch of drag turns a quarter turn.
      Parameters:
      degreesPerInch - The turn in degrees per inch of drag.

    • getFreeRoamMoveSpeed

      public float getFreeRoamMoveSpeed()
      Returns how far a first person move drag travels.
      Returns:
      The distance per inch of drag, as a fraction of the camera to focus distance.

    • setFreeRoamMoveSpeed

      public void setFreeRoamMoveSpeed(float distancePerInch)
      Sets how far a two-finger move travels in FREE_ROAM_MODE_FIRST_PERSON, per inch of drag,
      as a fraction of the distance from the camera to its focus point - so a move covers the
      same part of the view at any zoom. The default is 0.5.
      Parameters:
      distancePerInch - The distance per inch of drag.

    • isKineticPan

      public boolean isKineticPan()
      Returns the state of the kinetic panning flag.
      Returns:
      True if kinetic panning is enabled.

    • setKineticPan

      public void setKineticPan(boolean enabled)
      Sets the state of the kinetic panning flag. Kinetic panning allows the map to pan automatically using
      the inertia of the last swipe, after the user has finished interacting with the touch screen.
      Default is true.
      Parameters:
      enabled - The new state of the kinetic panning flag.

    • isKineticRotation

      public boolean isKineticRotation()
      Returns the state of the kinetic rotation flag.
      Returns:
      True if kinetic rotation is enabled.

    • setKineticRotation

      public void setKineticRotation(boolean enabled)
      Sets the state of the kinetic rotation flag. Kinetic rotation allows the map to rotate automatically using
      the inertia of the last swipe, after the user has finished interacting with the touch screen.
      Default is true.
      Parameters:
      enabled - The new state of the kinetic rotation flag.

    • isKineticZoom

      public boolean isKineticZoom()
      Returns the state of kinetic zoom flag.
      Returns:
      True if kinetic zooming is enabled.

    • setKineticZoom

      public void setKineticZoom(boolean enabled)
      Sets the state of the kinetic zooming flag. Kinetic zooming allows the map to zoom automatically using
      the inertia of the last swipe, after the user has finished interacting with the touch screen.
      Default is true.
      Parameters:
      enabled - The new state of the kinetic zooming flag.

    • isRotatable

      public boolean isRotatable()
      Returns the state of the map rotatability flag.
      Returns:
      True if map rotating is enabled.

    • setRotatable

      public void setRotatable(boolean enabled)
      Sets the state of the map rotatability flag. If set to false the map can't be rotated by any means. The default is true.
      Parameters:
      enabled - The new state of the map rotatability flag.

    • getTiltRange

      public MapRange getTiltRange()
      Returns the tilt range constraint.
      Returns:
      The tilt range constraint in degrees.

    • setTiltRange

      public void setTiltRange(MapRange tiltRange)
      Sets the tilt range constraint. This will limit the tilt angle of the camera to the specified range.
      The current tilt angle will remain unaffected, until the next time the tilt angle changes.
      The minimum tilt angle is -90 degrees and the maximum is 90 degrees. Values that are out of range will be clamped.
      The default value is MapRange(0, 90).
      A NEGATIVE tilt looks above the horizon: the camera stays where it is and the view pitches
      up, which is what an application showing the sky needs. It is opt-in, as the default range
      stops at the horizon.
      Parameters:
      tiltRange - The new tilt range constraint in degrees.

    • getZoomRange

      public MapRange getZoomRange()
      Returns the zoom range constraint.
      Returns:
      The zoom range constraint.

    • setZoomRange

      public void setZoomRange(MapRange zoomRange)
      Sets the zoom range constraint. This will limit the zoom level of the camera to the specified range.
      The current zoom level will remain unaffected, until the next time the zoom level changes.
      The minimum zoom value is 0 and the maximum is 24. Values that are out of range will be clamped.
      The default value is MapRange(0, 24).
      Parameters:
      zoomRange - The new zoom range constraint.

    • getPanBounds

      public MapBounds getPanBounds()
      Returns the map panning bounds constraints. Map bounds minimum and maximum points are in the base
      projection's coordinate system.
      Returns:
      The map bounds constraints.

    • setPanBounds

      public void setPanBounds(MapBounds panBounds)
      Sets the map panning bounds constraints. This will limit camera movement to the specified bounds.
      The current camera position will remain unaffected, until the next time camera position changes.
      Map bounds minimum and maximum points are expected to be in the base projection's coordinate system.
      If the bounds are larger than the world size, they will be clamped to world bounds. The default value covers the
      whole world.
      Parameters:
      panBounds - The new map bounds constraints.

    • getFocusPointOffset

      public ScreenPos getFocusPointOffset()
      Returns the focus point offset (from screen center) in pixels.
      Returns:
      The focus point offset in pixels.

    • setFocusPointOffset

      public void setFocusPointOffset(ScreenPos offset)
      Sets the focus point offset (from screen center) in pixels.
      Parameters:
      offset - The new focus point offset in pixels.

    • getBaseProjection

      public Projection getBaseProjection()
      Returns the base projection.
      Returns:
      The base projection.

    • setBaseProjection

      public void setBaseProjection(Projection baseProjection)
      Sets the base projection. All MapView, MapEventListener and Options methods use the coordinate system of this projection.
      For example, if base projection is set to EPSG3857 then MapView::getFocusPos returns the coordinates in the EPSG3857 coordinate system,
      The same applies to setter methods like MapView::setFocusPos which expect the input coordinates to be in the base projection's coordinate system.
      The default is EPSG3857.
      Parameters:
      baseProjection - The new base projection.

    • getTerrainOptions

      public TerrainOptions getTerrainOptions()
      Returns the terrain options. May be null if no terrain is configured.
      Returns:
      The terrain options.

    • setTerrainOptions

      public void setTerrainOptions(TerrainOptions terrainOptions)
      Sets the terrain options. When set, 3D terrain is rendered using the elevation
      data source of the terrain options. Note that terrain is currently only supported
      with the PLANAR render projection mode. Setting null disables terrain.
      Note: this feature is experimental and may change in future SDK versions.
      Parameters:
      terrainOptions - The new terrain options. Can be null.

    • getSkyOptions

      public SkyOptions getSkyOptions()
      Returns the sky options. May be null.
      Returns:
      The sky options.

    • setSkyOptions

      public void setSkyOptions(SkyOptions skyOptions)
      Sets the sky options. Attaching a SkyOptions object replaces the legacy sky bitmap
      band with a full-screen shader sky. Pass a null pointer to go back to the legacy sky.
      Parameters:
      skyOptions - The new sky options.

    • getFogOptions

      public FogOptions getFogOptions()
      Returns the fog (atmosphere) options. May be null.
      Returns:
      The fog options.

    • setFogOptions

      public void setFogOptions(FogOptions fogOptions)
      Sets the fog options - the haze distant ground fades into and the colours it carries
      into the sky. Setting null, or leaving the fog color transparent, means no fog.
      Parameters:
      fogOptions - The new fog options. Can be null.

    • getLightOptions

      public LightOptions getLightOptions()
      Returns the light (sun) options. May be null.
      Returns:
      The light options.

    • setLightOptions

      public void setLightOptions(LightOptions lightOptions)
      Sets the light (sun) options. The sun direction drives the shader sky, terrain
      surface lighting and shadows.
      Parameters:
      lightOptions - The new light options.

    • setLayersLabelsProcessedInReverseOrder

      public void setLayersLabelsProcessedInReverseOrder(boolean enabled)
      Sets wether layers are processed in reversed order to process labels.
      The default is true.
      Parameters:
      enabled - wether to process layers in reversed order.

    • isLayersLabelsProcessedInReverseOrder

      public boolean isLayersLabelsProcessedInReverseOrder()
      Returns wether layers are processed in reversed order to process labels.
      Returns:
      True if layers are processed in reversed order.