Classes

Active Objects are used implement animation.

Active Objects work in conjuction with the renderer to make updates on the main thread. The way they work is this. They’re called right at the beginning of a frame draw. They can make updates to regular Maply objects via the MaplyBaseViewController add and remove calls with the MaplyThreadMode set to MaplyThreadCurrent. This forces the changes to happen immediately on the current (main) thread.

Fill in at least the hasUpdate and updateForFrameMethods.

Active Objects are run on the main thread and you’re probably going to be asking the view controller to add and remove objects on the main thread. As such, this can be slow. Be sure to precalculate whatever you might need to make this run faster. Also consider implementing your changes another way. If it can be done on another thread, do it on another thread.

This object displays an annotation at a particular point and will track that point as the map or globe moves.

An annotation is used to point out some feature on the globe or map, typically that the user has tapped on. It’s a multi-part beast that may contain titles, subtitles, images, background views and such.

To add one, create the MaplyAnnotation and then call addAnnotation:forPoint:offset: on the MaplyBaseViewController.

The MaplyAnnotation is a wrapper around the SMCalloutView by Nick Farina. It exposes much of the functionality, but sets things up correctly and deals with moving the annotation around.

When selecting multiple objects, one or more of these is returned.

When you implement one of the selection delegates that takes multiple objects, you’ll get an NSArray of these things.

Base class for the Maply and WhirlyGlobe view controllers.

The Maply Base View Controller is where most of the functionality lives. For the most part Maply and WhirlyGlobe share methods and data structures. This view controller sets up the rendering, the threading, basically everything that makes WhirlyGlobe-Maply work.

Don’t create one of these directly, instead use the MaplyViewController or the WhirlyGlobeViewController.

The View Controller Layer is a base class for other display layers.

You don’t create these directly. This is a base class for other things. Its hooks into the rest of the system are hidden.

Animation State used by the WhirlyGlobeViewControllerAnimationDelegate.

You fill out one of these when you’re implementing the animation delegate. Return it and the view controller will set the respective values to match.

The Globe Render Controller is a standalone renderer for the globe. This is separate from the WhirlyGlobeViewController, but performs a similar function for offline rendering.

The Render Controller is a standalone WhirlyGlobe-Maply renderer.

This Render Controller is used for offline rendering.

An encapsulation of where the viewer is and what they’re looking at.

This wraps information about where the viewer is currently looking from and at.

This layer will call a delegate as the user moves around, but constrained to distance and time.

This layer is responsible for calling a delegate you provide as the user moves their viewpoint around. You’ll be called if they move from than a certain amount, but not more often than the minimum time.

Animation State used by the MaplyViewControllerAnimationDelegate.

You fill out one of these when you’re implementing the animation delegate. Return it and the view controller will set the respective values to match.

A simple animation delegate for moving the map around.

The animation delegate support provides a lot of flexibility. This version just provides all the standard fields and interpolates from beginning to end.

This view controller implements a map.

This is the main entry point for displaying a 2D or 3D map. Create one of these, fill it with data and let your users mess around with it.

You can display a variety of features on the map, including tile base maps (MaplyQuadImageTilesLayer), vectors (MaplyVectorObject), shapes (MaplyShape), and others. Check out the add calls in the MaplyBaseViewController for details.

The Maply View Controller can be initialized in 3D map, 2D map mode. The 2D mode can be tethered to a UIScrollView if you want to handle gestures that way. That mode is very specific at the moment.

To get selection and tap callbacks, fill out the MaplyViewControllerDelegate and assign the delegate.

Most of the functionality is shared with MaplyBaseViewController. Be sure to look in there first.

The View Tracker associates a view with a geographic location.

The Maply View Tracker will move a UIView around to keep track of a geographic location. This is basically used for popups. The system will move the view around at the end of the frame render. It will hide the UIView if needed or make it reappear. The UIView should be a child of view controller’s view.

A simple animation delegate for moving the globe around.

The animation delegate support provides a lot of flexibility. This version just provides all the standard fields and interpolates from beginning to end.

This view controller implements a 3D interactive globe.

This is the main entry point for displaying a globe. Create one of these, fill it with data and let your users mess around with it.

You can display a variety of features on the globe, including tiled base maps (MaplyQuadImageTilesLayer), vectors (MaplyVectorObject), shapes (MaplyShape), and others. Check out the add calls in the MaplyBaseViewController for details.

To get selection and tap callbacks, fill out the WhirlyGlobeViewControllerDelegate and assign the delegate.

Most of the functionality is shared with MaplyBaseViewController. Be sure to look in there first.

MBTiles tile fetcher.

This tile fetcher focuses on a single MBTiles file. You mate this with a QuadImageLoader to do the actual work.

Will work for image or vector MBTiles files.

A bounding box for a specific CRS in that coordinate system. This is part of the Web Map Server parser.

Style of a WMS layer as returned by GetCapabilities. This is part of the Web Map Service parser.

Description of a WMS layer as returned by a GetCapabilities call. This is part of the Web Map Service parser.

Encapsulates the capabilities coming back from a WMS server. We can query this to see what layers and coordinate systems are available. Part of the Web Map Service parser.

This is a MaplyTileSource that works with a remote Web Map Service implementation. WMS is not the most efficient way to access remote image data, but there are still a few places that use it.

Geometry State is used to describe the visual look of objects as they’re added.

Set the various fields in the geometry state to control how geometry looks when you add it. There are defaults for all of these fields.

The geometry builder is used to construct 3D models.

You use the geometry builder when you have a custom 3D model to build. This can include things like airport runways, buildings, or anything else that’s particular to a certain location.

Start by construting the builder and then adding polygons and strings to it.

You can combine multiple geometry builders together to build up repeated portions of a model.

The builder has an “immediate mode” where you add points individually to build up polygons and then add those. This is one of the simpler ways to use the system.

Holds info about a single style from the MaplySimpleStyleManager. This is enough to build a marker (or other thing, if you like).

Used to generate icons and parse styles for the GeoJSON simple Style spec. https://github.com/mapbox/simplestyle-spec

Can also be used to define some very simple icon styles directly.

Undocumented

The Maply Linear Texture Builder is used to construct linear textures for use on widened vectors.

Linear textures of this type are used to represent dotted and dashed lines. These may come from Mapnik configuration files or you can just make them up yourself.

After creating an image with this object, you’ll want to pass it as a parameter to the widened vector add method.

This class will read GeoJSON via URL with an associated Styled Layer Descriptor via URL. It will then parse both of them and apply the SLD style to the GeoJSON data. This results in visual data in much the same way as loading vector tiles would.

Describes a single tile worth of data, which may be multiple images.

Delegates can pass back a single UIImage or NSData object, but if they want to do anything more complex, they need to do it with this.

Quad Image FrameAnimation runs through the frames in a Quad Image Frame loader over time.

Set this up with a MaplyQuadImageFrameLoader and it’ll run through the available frames from start to finish. At the end it will snap back to the beginning.

The Maply Quad Image Frame Loader can generation per-frame stats. These are them.

Stats generated by the Maply Quad Image Frame Loader.

The Maply Quad Image Frame Loader is for paging individual frames of image pyramids.

This works much like the Quad Image Loader, but handles more than one frame. You can animate between the frames with the QuadImageFrameAnimator

This version of the loader return is used by the MaplyImageLoaderInterpreter.

When image tiles load, the interpeter fills in these contents, which can include any sort of ComponentObject and, of course, images.

Image loader intrepreter turns NSData objects into MaplyImageTiles.

This is the default interpreter used by the MaplyQuadImageLoader.

This loader interpreter sticks a designator in the middle of tiles and a line around the edge. Nice for debugging.

This loader interpreter makes up an image for the given frame/tile and returns that. It doesn’t use any returned data.

This loader interpreter treats input image data objects as PNGs containing raw data. The difference is we’ll use a direct PNG reader to tease it out, rather than UIImage.

Base object for Maply Quad Image loader.

Look to the subclasses for actual functionality. This holds methods they share.

The Maply Quad Image Loader is for paging image pyramids local or remote.

This layer pages image pyramids. They can be local or remote, in any coordinate system Maply supports and you provide a MaplyTileInfoNew conformant object to do the actual image tile fetching.

You probably don’t have to implement your own tile source. Go look at the MaplyRemoteTileFetcher and MaplyMBTileFetcher objects. Those will do remote and local fetching.

Passed in to and returned by the Loader Interpreter.

We pass this into the interpreter with the unparsed data. It parses it and passes that data back, possibly with an error.

Base class for the quad loaders.

The image, frame, and data paging loaders all share much of the same functionality.

This version of the loader return is used by the MaplyQuadPagingLoader.

The Object pager is only expecting Component Objects and will manage those as things are loaded in and out.

General purpose quad paging loader.

This quadtree based paging loader is for fetching and load general geometry.
There are other loaders that handle images and image animations.  This one is
purely for geometry.

You need to fill in at least a MaplyLoaderInterpreter, which is probably your own
implementation.

This replaces the QuadPagingLayer from WhirlyGlobe-Maply 2.x.

Sampling parameters.

These are used to describe how we want to break down the globe or flat projection onto the globe.

Remote Tile Info Object (New)

Not to be confused with the old one, which works with the older loading subsystem, the new remote tile info object contains min/max zoom, coordinate system and URL information for fetching individual data tiles.

Fetch Info for remote tile fetches.

The URL (required) and cacheFile (optional) for the given fetch. This is the object the RemoteTileFetcher expects for the fetchInfo member of the TileFetchRequest.

Remote Tile fetcher fetches tiles from remote URLs.

The tile fetcher interacts with loaders that want tiles, as demanded by samplers. It’s complicated. There’s a default one of these that will get used if you pass in nil to the MaplyQuadImageLoader.

Stats collected by the fetcher

Single entry for the logging. Reports on the status of a specific fetch.

Log of remote fetches, how long they took, their results and so on

Simple Tile Fetcher is meant for sub classing.

Some data sources aren't all that complex.  You read from a local source,
you return the data.  Something else turns it into visible objects.  Simple.

To implement one of those, subclass the Simple Tile Fetcher and let it do the
tricky bits.

A tile source that just returns nil. You can use this like a tile source where you need one that doesn’t do anything.

Generic Tile fetcher request.

A single request for a single tile of data from a single source. The tile fetcher will… fetch this and call the success or failure callback.

An NSObject based wrapper for 3D coordinates.

This wrapper encapsulates a MaplyCoordinate3d so we can pass them around in NSDictionary objects.

An NSObject based wrapper for 3D coordinates.

This wrapper encapsulates a MaplyCoordinate3d so we can pass them around in NSDictionary objects.

Coordinate system for tiling systems and data sources and such.

This object represents the spatial reference system and bounding box for objects like the MaplyTileSource or vectors or other things. Not all data is in lat/lon geographic (actually MaplyPlateCaree) nor is it always in MaplySphericalMercator. Sometimes it’s in one or the other, or a bit of both.

We use this base class to express the coordinate system and we threw in the bounding box, which we will surely come to regret. Oh well, it’s in there.

This object gets passed around to tell us what coordinate system data is in or how we’re displaying things. Right now only MaplySphericalMercator and MaplyPlateCarree are represented. In the future, there will be more.

Plate Carree is lat/lon stretched out to its full extents.

This coordinate system is used when we’re tiling things over the whole earth, from -180 to +180 and from -90 to +90. Use this if you chopped up your data in that way.

Spherical Mercator is what you’ll most commonly see on web maps.

The Spherical Mercator system, with web extents is what MapBox, Google, Bing, etc. use for their maps. If you ever want to annoy a cartographer, suggest that spherical mercator is all you ever really need.

The drawback with Spherical Mercator is that it doesn’t cover the poles and it distorts (and how) its north and south extents. Web Standard refers to the extents you’ll find in most online maps. This is probably want you want.

A generic coordinate system wrapper around proj4.

You create one of these with a proj4 string. It’ll act like a normal MaplyCoordinateSysterm after that.

Be sure to check that the system is valid. The proj4 string could be wrong.

Represents a matrix for position manipulation.

Encapsulates a 4x4 matrix used for object placement and other things. This is more a wrapper than a full service object.

Sets up the objects and shaders to implement an atmosphere.

This object sets up a shader implementation of the simple atmosphere from GPU Gems 2 http://http.developer.nvidia.com/GPUGems2/gpugems2_chapter16.html

The color ramp generator will take a set of color values and generate a linear ramp of those colors in an output image. You typically feed the color ramp image into a shader.

The Light provides a simple interface to basic lighting within the toolkit.

You can have up to 8 lights in the current version of the toolkit. Obviously this is all shader implementation with OpenGL ES 2.0, so you can always just bypass this and do what you like. However, the default shaders will look for these lights.

The lights are very simple, suitable for the globe, and contain a position, a couple of colors, and a view dependent flag.

Represents a render target (other than the screen)

Individual objects can ask to be drawn somewhere other than the screen. This is how we do that.

A render target is just a link between a render every frame and a MaplyTexture. To get at the actual image you use the MaplyTexture.

At the moment a render target can only draw the full screen, possibly at a lower resolution.

The shader is a direct interface to OpenGL ES 2.0 shader language.

You can set your own shader programs in the toolkit!  Yeah, that's as complex as it sounds.

The underyling toolkit makes a distinction between the name of the shader and the scene name.  The scene name is used as a way to replace the default shaders we use for triangles and lines.  This would let you replace the shaders you're already using with your own.  See the addShaderProgram: method in the MaplyBaseViewController.

You can also add your own shader and hook it up to any features that can call out a specific shader, such as the MaplyQuadImageTilesLayer.

When writing a new shader, go take a look at DefaultShaderPrograms.mm, particularly the vertexShaderTri and fragmentShaderTri.  The documentation here is for the uniforms and attributes the system is going to hook up for you.  All of these are optional, but obviously nothing much will happen if you don't use the vertices.

Uniform Values

These are uniform values provided to each shader, if requested.

|uniform|type|description| |:——|:—|:———-| |u_mvpMatrix|mat4| The model/view/projection matrix. Shaders typically run vertices through this. | |u_mvMatrix|mat4| The model/view matrix. Less comonly used. | |u_mvNormalMatrix|mat4| The model/view matrix for normals. A shader typically uses this when we want view dependent lighting. | |u_fade|float| Available in regular drawables, but not yet in big drawables (e.g. atlases). This is intended to fade geometry in and out over time. | |u_interp|float| If we’re doing multiple textures, this is how to interpolate them. | |u_numLights|int| The number of active lights to use. | |light[8]|directional_light| A data structure for each active light. See the table below. | |material|material_properties| Material information used to calculate lighting. See the table below. | |u_hasTexture|bool| True if there’s a texture available to fetch data from. | |s_baseMapX|sampler2D| s_baseMap0, s_baseMap1 and so forth are references to texture data. |

Material properties

These are the fields for the material properties.

Light properties

These are the fields for each individual light.

|field|type|description| |:—-|:—|:———-| |direction|vec3| The light’s direction, used in diffuse lighting. | |halfplane|vec3| This would be used in specular lighting. | |ambient|vec4| The ambient value of the light. | |diffuse|vec4| The diffuse value of the light. | |specular|vec4| Not currently used. | |viewdepend|float| If greater than 0.0, the shader should run each normal through the u_mvNormalMatrix. |

Attributes

These are the per vertex attributes provided to each vertex shader.

|field|type|description| |:—-|:—|:———-| |a_position|vec3| The position in display space for a vertex. Shaders typically multiply this by u_mvpMatrix. | |a_texCoord0|vec2| If textures are present, this is the texture coordinate for the first one. | |a_texCoord1|vec2| If two textures are present, this is the texture coordinate for the second. | |a_color|vec4| An RGBA color for the vertex. | |a_normal|vec3| A normal in display space. This is used purely for lighting and often run through u_mvNormalMatrix. | |a_elev|float| An optional elevation value provided by the MaplyQuadImageTiles layer. You can use it to do elevation dependent shading. |

A variable target manages two pass rendering for one type of variable.

Set up the variable target

Vertex Attributes are passed all the way though on objects to shaders.

If you have your own custom shader, you often need a way to feed it data. The toolkit will set up the standard data, like vertices, texture coordinates and normals, but sometimes you need something custom.

Vertex attributes are the mechanism you use to pass that custom data all the way down to the shader.

How the vertex attributes are used depends on the data type, so consult the appropriate object.

A single entry in the legend array returned by

@brief The Mapbox Vector Style Set parses Mapbox GL Style sheets and turns them into Maply compatible styles. @details A style delegate is required by the Mapnik parser to build geometry out of Mapnik vector tiles. This style delegate can read a Mapbox GL Style sheet and produce compatible styles.

Undocumented

Settings that control how vector tiles look in relation to their styles.

These are set based on the sort of device we’re on, particularly retina vs. non-retina. They can be manipulated directly as well for your needs.

Simple default style to see something in vector tile data.

A simple vector style that displays each layer in a random color. Use this as a starting point for your own style.

Base class for the simple vector style.

Simple filled polygon with a random color.

Simple point we’ll convert to a label.

Simple linear with a random color.

Implementation of the line style symbolizer for Maply Vector Tiles.

Implementation of the marker style symbolizer for Maply Vector Tiles.

Implementation of the polygon style symbolizer for Maply Vector Tiles.

The Maply Vector Tile Style is an internal representation of the style JSON coming out of a Maply Vector Tile database.

Implementation of the text style symbolizer for Maply Vector Tiles.

Undocumented

Undocumented

Undocumented

@brief Base class for elements derived from the ogc:expression abstract element.

@brief Class corresponding to the ogc:PropertyName element

@brief Class corresponding to the ogc:Literal element

@brief Class corresponding to the ogc:BinaryOperatorType elements

@brief Base class for elements of ogc:comparisonOps or ogc:logicOps.

Elements of ogc:spatialOps are not supported.

@brief Class corresponding to the ogc:BinaryComparisonOpType elements

Undocumented

Undocumented

Undocumented

@brief Class corresponding to the ogc:Not element

@brief Class corresponding to the ogc:BinaryLogicOpType elements

@brief Class corresponding to the sld:NamedLayer element

@brief Class corresponding to the sld:UserStyle element

@brief Class corresponding to the se:FeatureTypeStyle element

@brief Class corresponding to the se:Rule element

@brief Class corresponding to the ogc:Filter element

@brief Class corresponding to the sld:StyledLayerDescriptor element

The sld:StyledLayerDescriptor element is the root element of the Styled Layer Descriptor document.

Implements the MaplyVectorStyleDelegate protocol for matching and applying styles to vector objects.

@brief Base class for Symbolizer elements

@brief Class corresponding to the LineSymbolizer element

@brief Class corresponding to the PolygonSymbolizer element

@brief Class corresponding to the PointSymbolizer element

@brief Class corresponding to the TextSymbolizer element

Class for generating images corresponding to WellKnownName elements.

Each static method uses low-level Core Graphics calls to generate an appropriate UIImage object.

An interpreter for Mapbox Vector Tiles.

This will turn vector tiles into images, visual objects, or a combination of the two. Loader interpreters like this one can be used by Loaders that talk to ondevice objects (such as MBTiles files) or remote tile sources.

Container for data parsed out of a Mapbox Vector Tile stream.

This holds the parsed data as well as post-constructed data. You will likely be handed one of these if you see it at all. There are few cases where you might construct one.

A billboard is tied to a specific point, but rotates to face the user.

The billboard object represents a rectangle which is rooted at a specific point, but will rotate to face the user. These are typically used in 3D, when the globe or map has a tilt. They make little sense in 2D.

Information about the group of objects to cluster.

This object is passed in when the developer needs to make an image for a group of objects.

Visual representation for a group of markers.

Fill this in when you’re implementing a MaplyClusterGenerator.

The basic cluster generator installed by default.

This cluster generator will make images for grouped clusters of markers/labels.

Used to represent the view controller resources attached to one or more visual objects.

When you add one or more objects to a view controller, you’ll get a component object back. It’s an opaque object (seriously, don’t look inside) that we use to track various resources within the toolkit.

You can keep these around to remove the visual objects you added earlier, but that’s about all the interaction you’ll have with them.

Contains a big pile of geometry and textures (e.g. a model).

The geometry model

Place a geometry model at a given location

Geometry models tend to be expensive so we load and place them in a two step process. First you create the MaplyGeomModel and then you place it in one or more spots with this MaplyGeomModelInstance.

A version of the geometry model instance that moves.

This version of the geometry model instance can move in a limited way over time.

Sometimes we don’t know how many instances there will be of a model until some logic runs on the GPU. We can then take that number and run that number of instances of the given model. [Metal only]

This is a 3D label.

The Maply Label is a 3D object that sits on top of the globe (or map) at a specified location. If you want a 2D label that sits on top of everything else, you want the MaplyScreenLabel. Seriously, you probably want that.

The Marker places a UIImage on the globe or map at a given location.

The Maply Marker takes a location and image, using those to display a textured rectangle on the globe (or map). Since it’s a real 3D object it will get larger and smaller as the user moves around.

If you want a screen based object that stays the same size and is displayed on top of everything else, look to the MaplyScreenMarker.

Utility for calculating moon position.

This is a utility class that figures out where the moon is at a given data and provides the position.

A particle system is used to spawn large numbers of small moving objects.

The particle system defines what the objects are and how they’re controlled. Actual data is handled through the MaplyParticleBatch.

You set up a particle system and then add MaplyParticleBatches via a view controller.

A particle batch adds a set number of particles to the system.

The particle batch holds the number of particles defined in the MaplyParticleSystem batchSize property. Each attribute array is added individually via an NSData object. All attributes must be present or the batch is invalid and won’t be passed through the system.

The Maply Points object is used to add a large number of static points to the scene.

Rather than add a single 3D point we assume you want to add a lot of them all at once. This object lets you do that and lets you assign the various data values to input attributes in your custom shader.

All the cool kids have custom shaders.

The Screen Label is a 2D label that tracks a given geographic location.

This screen label will track the given geographic position. If it’s behind the globe it will disappear. The label is rendered in a fixed size and will always appear on top of other geometry.

A version of the maply screen label that moves.

This version of the screen label can move in a limited way over time.

The Screen Marker is a 2D object that displays an image on the screen tracking a given location.

The screen marker will track the given geographic location and display a centered rectangle with the given image. Essentially it’s a free floating icon, similar to the MaplyScreenLabel and it will always be drawn on top of other objects. If the location would be behind the globe (in globe mode), the marker will disappear.

If you’re looking for a 3D marker object, that’s the MaplyMarker.

A version of the maply screen marker that moves.

This version of the screen marker can move in a limited way over time.

The Maply Screen Object is used to build up a more complex screen object from multiple pieces.

You can use one or more of these to build up a combination of labels and images that form a single marker, label, or billboard.

Maply Shape is the base class for the actual shape objects.

The maply shape is just the base class. Look to MaplyShapeCircle, MaplyShapeCylinder, MaplyShapeSphere, MaplyShapeGreatCircle, and MaplyShapeLinear.

Shows a circle at the given location on the globe or map.

This object represents a circle at the given geographic location. It needs a radius (in display coordinates) and can optionally have a height above the globe or map.

Display a sphere at the given location with the given radius.

This object represents a sphere at the

Represent a cyclinder on the globe or map.

This object represents a cylinder with it’s base tied to the surface of the globe or map and it’s top pointed outward (on the globe anyway). The base can be offset and the overall radius and height are adjustable.

Represents an great circle or great circle with height.

Great circles are the shortest distance between two points on a globe. We extend that a bit here, by adding height. The result is a curved object that can either sit on top of the globe or rise above it. In either case it begins and ends at the specified points on the globe.

Represents a simple rectangle in 3D.

The rectangle is a 2D object in 3D. Specify the lower left and upper right coordinates as well as an optional texture.

A linear feature offset from the globe.

The main difference between this object and a regular MaplyVectorObject is that you specify coordiantes in 3D. You can use this to create linear features that are offset from the globe.

An extruded shape with an arbitrary outline.

This object represents an extruded shape with the given thickness. It can be oriented according to the pitch, roll, yaw and height.

The Stars Model parses and then displays a star field.

This is used to display a star field around the earth.

Stickers are rectangles placed on the globe with an image.

The Maply Sticker will stretch a rectangle (in geographic) over the given extents and tack the given image on top of it. Stickers differ from MaplyMarker objects in that they’re big. They can stretch over a larger are and need to be subdivided as such.

Utility for calculating sun position and shading info.

This is a utility class that figures out where the sun is at a given date and provides positional information for lighting calculations.

Represents an OpenGL texture.

The MaplyTexture is an opaque object used to track OpenGL ES textures. You create one from the MaplyBaseViewController’s addImage call. Then that texture will live until this object is released.

These can be used in place of UIImages in the various objects (e.g. MaplyScreenMarker).

Maply Vector Object represents zero or more vector features.

The Vector Object can hold several vector features of the same or different types. It’s meant to be a fairly opaque structure, often read from GeoJSON or Shapefiles. It’s less opaque than originally planned, however, and sports a number of specific methods.

If you’re doing real vector manipulation, it’s best to do it somewhere else and then create one of these as needed for display.

Vector Objects can be created directly or read from a MaplyVectorDatabase. They are typically then displayed on top of a MaplyViewController or WhirlyGlobeViewController as vectors.

Vector Objects vertices are always in geographic, with longitude = x and latitude = y.