| Interface | Description |
|---|---|
| ActiveObject |
Active Objects are called right before the render on the render thread.
|
| BaseController.ScreenshotListener |
Listener to receive the screenshot in an asynchronous way.
|
| GlobeController.GestureDelegate |
Use this delegate when you want user interface feedback from the maply controller.
|
| GLTextureView.EGLConfigChooser |
An interface for choosing an EGLConfig configuration from a list of
potential configurations.
|
| GLTextureView.EGLContextFactory |
An interface for customizing the eglCreateContext and eglDestroyContext calls.
|
| GLTextureView.EGLWindowSurfaceFactory |
An interface for customizing the eglCreateWindowSurface and eglDestroySurface calls.
|
| GLTextureView.GLWrapper |
An interface used to wrap a GL interface.
|
| GLTextureView.Renderer |
A generic renderer interface.
|
| LayerThread.ViewWatcherInterface |
Objects that want to be called when the view updates its position
fill out this interface and register with the layer thread.
|
| LoaderInterpreter |
Loader Interpreter converts raw data into images and objects.
|
| MapController.GestureDelegate |
Use this delegate when you want user interface feedback from the maply controller.
|
| QuadSamplingLayer.ClientInterface | |
| RenderController.TaskManager |
We don't want to deal with threads and such down here, so
the controller one level up gives us an addTask method
to hand over the runnables.
|
| RenderControllerInterface |
The Render Controller Interface defines the methods
a renderer has to implement.
|
| TileFetcher |
Tile Fetcher protocol.
|
| TileFetchRequest.Callback | |
| UpdateLayer.Delegate |
Fill in the delegate for callbacks
|
| VectorStyle |
A VectorStyle subclass generates the Maply objects for a given pieces of data.
|
| VectorStyleInterface |
The Vector Style Interface returns Vector Style objects for a given list of attributes.
|
| Class | Description |
|---|---|
| AngleAxis |
The AngleAxis object wraps the C++ Eigen AngleAxisd object.
|
| Atmosphere |
Sets up the objects and shaders to implement an atmosphere.
|
| AttrDictionary |
The attribute dictionary is a collection of name/value pairs.
|
| AttrDictionaryEntry |
A single entry in an AttrDictionary that needs to be handled generically.
|
| BaseController |
The base controller is a base class for both Maply and WhirlyGlobe controllers.
|
| BaseController.Settings |
These are settings passed on construction.
|
| BaseInfo |
This is the base class for all the various Info objects.
|
| BasicClusterGenerator |
The basic cluster generator installed by default.
|
| Billboard |
Single billboard representation.
|
| BillboardInfo |
Parameters used to control billboard display.
|
| BillboardManager |
The Billboard Manager handles billboard related geometry.
|
| ChangeSet |
The change set is a largely opaque object the Maply uses to
track visual changes in the map or globe.
|
| ClusterGenerator |
Fill in this protocol to provide images when individual markers/labels are clustered.
|
| ClusterGroup |
Visual representation for a group of markers.
|
| ClusterInfo |
Information about the group of objects to cluster.
|
| ColorRampGenerator |
The color ramp generator will take a set of color values
and generate a linear ramp of those colors in an output
image.
|
| ComponentManager |
The Component Manager tracks the various low level IDs for
visual geometry that's been added, often as a group.
|
| ComponentObject |
The Component Object tracks the various geometry, textures, and outlines
associated with a given call to addVectors, addScreenMarkers, etc...
|
| CoordSystem |
The coord system is a very simple representation of the coordinate
systems supported by WhirlyGlobe-Maply.
|
| DebugImageLoaderInterpreter |
This loader interpreter makes up an image for the given frame/tile
and returns that.
|
| FakeGeocentricDisplayAdapter | |
| FlatView |
The flat view implements a top down orthogonal projection
which is prefect for doing a straight up 2D map.
|
| GeneralDisplayAdapter |
Created by sjg on 2/13/16.
|
| GeoCoordSystem |
A wrapper around Maply's geo (Plate Carree) coordinate system implementation.
|
| GeoJSONSource |
The GeoJSONSource will load vector features from a GeoJSON document, style them with an
SLD document, and add them to the globe or map.
|
| GeometryInfo |
Parameters used for Geometry display.
|
| GeometryInstance |
Represents a single Geometry Instance
|
| GeometryManager |
The geometry manager interfaces to the Maply C++/JNI side of things
and is invisible to toolkit users.
|
| GeometryRaw |
Raw Geometry object.
|
| GeometryRawPoints |
Raw points passed to geometry manager.
|
| GeometryUtils |
A collection or random geometry utilities that aren't associated with particular objects.
|
| GlobeAnimateMomentum |
Implements a rotation with momentum on the globe.
|
| GlobeAnimateRotation |
Implements a rotation with momentum on the globe.
|
| GlobeController |
The GlobeController is the main object in the Maply library when using a 3D globe.
|
| GlobeController.Settings |
Settings needed on startup so we can create the proper elements.
|
| GlobeGestureHandler |
Implements the various gestures we need and handles conflict between them.
|
| GlobeMapFragment |
A fragment that instantiates either a map or a globe.
|
| GlobeView |
The Globe View handles math related to user position and orientation.
|
| GlobeViewState |
The map view state encapsulates what's in a view at a certain point in time.
|
| GLTextureView |
An implementation of SurfaceView that uses the dedicated surface for
displaying OpenGL rendering.
|
| Identifiable |
Base class for identifiable objects on the Maply side.
|
| ImageLoaderInterpreter |
Image loader intrepreter turns data objects into ImageTiles.
|
| ImageLoaderReturn |
This version of the loader return is used by the ImageLoaderInterpreter.
|
| ImageTile |
The Maply Image Tile represents the image(s) passed back from the network.
|
| LabelInfo |
We use this class to designate attribute shared by a group of labels.
|
| Layer |
The Layer subclass is used by the LayerThread to track Maply
objects that need to be updated on a regular basis.
|
| LayerThread |
The layer thread runs tasks we want off the UI thread, but still need
some control over.
|
| Light |
The Light provides a simple interface to basic lighting within the toolkit.
|
| LinearTextureBuilder |
The Maply Linear Texture Builder is used to construct linear textures
for use on widened vectors.
|
| LoaderReturn |
Passed in to and returned by the Loader Interpreter.
|
| LoftedPolyInfo |
Used to describe how we want to build lofted polygons, including side and top,
colors and such.
|
| MapAnimateTranslate |
Animates a translation (and/or zoom) from the current point to a new one.
|
| MapAnimateTranslateMomentum |
Implements a translation with momentum to a new point.
|
| MapboxVectorInterpreter |
The Mapbox Vector (Tile) Interpreter parses raw vector tile data
and turns it into visual objects.
|
| MapboxVectorStyleSet |
Mapbox Vector Style Set.
|
| MapboxVectorTileParser |
This object parses Mapbox Vector Tile format one tile at a time.
|
| MapController |
The MaplyController is the main object in the Maply library when using a 2D map.
|
| MapController.Settings |
Settings are parameters we need at the very start of the
setup process.
|
| MapGestureHandler |
Implements the various gestures we need and handles conflict between them.
|
| MaplyStarModel | |
| MaplyTexture |
Encapsulates a texture in WhirlyGlobe-Maply toolkit.
|
| MapView |
The Map View handles math related to user position and orientation.
|
| MapViewState |
The map view state encapsulates what's in a view at a certain point in time.
|
| Marker |
The Marker is a 2D rectangle plastered on top of the globe or map.
|
| MarkerInfo |
This class holds the visual information for a set of 2D or 3D markers.
|
| Material |
This is a simple material definition.
|
| Matrix3d | |
| Matrix4d |
This encapsulates a Maply4d matrix.
|
| Mbr |
A simple Maply bounding box.
|
| MBTileFetcher |
MBTiles tile fetcher.
|
| MBTiles |
The MBTiles Source reads Mapbox style MBTiles files.
|
| MetroThread | |
| Moon |
Utility for calculating moon position.
|
| ObjectLoaderReturn |
This version of the loader return is used by the ImageLoaderInterpreter.
|
| OvlDebugImageLoaderInterpreter |
This loader interpreter sticks a designator in the middle of tiles
and a line around the edge.
|
| ParticleBatch |
A particle batch adds a set number of particles to the system.
|
| ParticleSystem |
A particle system is used to spawn large numbers of small moving objects.
|
| ParticleSystemManager |
Particle system manager controls the active particle systems
|
| PassThroughCoordSystem |
This coordinate system literally passes through the values its
given for conversion.
|
| PlateCarreeCoordSystem |
The Plate Carree coordinate system is just a fancy name for
stretching lat/lon out onto a plane in the dumbest way possible.
|
| Point2d |
The Point2d class is the simple, dumb, 2D coordinate
class.
|
| Point3d |
The Point3d class is your standard x,y,z container.
|
| Point4d |
The Point4d class is your standard x,y,z,w container.
|
| Points |
Rather than add a single 3D point we assume you want to add a lot of them all at once.
|
| Proj4CoordSystem |
A wrapper around the Proj4 general scheme for coordinate systems.
|
| QuadImageFrameAnimator |
Quad Image FrameAnimation runs through the frames in a Quad Image Frame loader over time.
|
| QuadImageFrameLoader |
The Maply Quad Image Frame Loader is for paging individual frames of image pyramids.
|
| QuadImageLoader |
The Quad Image Loader is for paging image pyramids local or remote.
|
| QuadImageLoaderBase |
Base object for Maply Quad Image loader.
|
| QuadLoaderBase |
Base class for the quad loaders.
|
| QuadPagingLoader |
General purpose quad paging loader.
|
| QuadSamplingLayer |
The Quad Sampling Layer runs a quad tree which determines what
tiles to load.
|
| Quaternion |
This encapsulates a Quaternion, used in manipulation.
|
| RemoteTileFetcher | |
| RemoteTileFetchInfo |
Fetch Info for remote tile fetches.
|
| RemoteTileInfoNew |
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. |
| RenderController |
The Render Controller handles the object manipulation and rendering interface.
|
| RenderControllerInterface.ContextInfo | |
| RenderControllerInterface.TextureSettings |
Texture settings for adding textures to the system.
|
| RenderTarget |
Represents a render target (other than the screen)
Individual objects can ask to be drawn somewhere other than the screen. |
| SamplingParams |
Sampling parameters.
|
| Scene |
Base class for Scene.
|
| ScreenLabel |
The screen label is a 2D label that tracks a location on the map.
|
| ScreenMarker |
The screen marker is a 2D rectangle that tracks a certain position in
geographic (lon/lat in radians).
|
| ScreenMovingLabel |
The Moving Screen Label has an end location and duration.
|
| ScreenMovingMarker |
The moving version of the screen marker animations from
one location to another over time.
|
| ScreenObject |
The Maply Screen Object is used to build up a more complex screen
object from multiple pieces.
|
| SelectedObject |
Selected Objects are returned by the selection manager when the system wants a
selection return.
|
| Shader |
The shader is a direct interface to OpenGL ES 2.0 shader language.
|
| Shape |
Shape is the base class for the actual shape objects.
|
| ShapeCircle |
Display a circle at the given location.
|
| ShapeCylinder |
Display a cylinder at the given location.
|
| ShapeExtruded |
An extruded shape takes a linear outline which it sweeps from its
base up to a defined height.
|
| ShapeGreatCircle |
Represents an great circle or great circle with height.
|
| ShapeInfo |
Shape Info is used to hold parameter values for a group of Shape objects.
|
| ShapeLinear |
A linear feature offset from the globe.
|
| ShapeManager |
The Shape Manager is used to create and destroy geometry for shapes
like circles, cylinders and so forth.
|
| ShapeRectangle |
Display a rectangle at the given location.
|
| ShapeSphere |
Display a sphere at the given location with the given radius.
|
| SimplePoly |
Extremely simple polygon class
|
| SimpleTileFetcher |
Simple Tile Fetcher is meant for sub classing.
|
| SphericalMercatorCoordSystem |
A wrapper around Maply's spherical mercator coordinate system implementation.
|
| Sticker |
The Sticker class is used to represent a rectangular area we stick on top
of the globe or map.
|
| StickerInfo |
This class holds the visual information for a set of stickers.
|
| StickerManager |
The sticker manager interfaces to the Maply C++/JNI side of things
and is invisible to the toolkit users.
|
| StringWrapper |
Wraps strings with size and translation
|
| Sun | |
| SunUpdater |
This is used internally to update the sun position for an atmospheric shader.
|
| TileFetchRequest |
Generic Tile fetcher request.
|
| TileID |
A tile ID represents a single tile for paging.
|
| TileInfoNew |
TileInfo New Base class.
|
| UpdateLayer |
This layer will call a delegate as the user moves around, but constrained to distance and time.
|
| VariableTarget |
A variable target manages two pass rendering for one type of variable.
|
| VectorInfo |
The Vector Info class holds visual information related to groups of vectors.
|
| VectorIterator |
A VectorObject can contain multiple sub-vectors.
|
| VectorObject |
The Maply VectorObject represents a group of vector features.
|
| VectorStyleProcessor |
Provides a static method to run vectors through a vector style.
|
| VectorStyleSettings |
Settings that control how vector tiles look in relation to their styles.
|
| VectorStyleSimpleGenerator |
Created by sjg on 6/2/16.
|
| VectorStyleWrapper |
Used to wrap a VectorStyle so it can be interfaced from the JNI side.
|
| VectorTileData |
When parsing a tile of vector data, we need to pass input and output data around.
|
| VectorTileLineStyle |
The VectorTileStyle base class for styling line features.
|
| VectorTileMarkerStyle |
The VectorTileStyle base class for styling markers.
|
| VectorTilePolygonStyle |
The VectorTileStyle base class for styling polygon features.
|
| VectorTileStyle |
VectorTileStyle is the base class for full-featured vector geometry styles.
|
| VectorTileStyleEntry |
Created by rghosh on 2017-03-28.
|
| VectorTileTextStyle |
The VectorTileStyle base class for styling labels.
|
| VertexAttribute |
A vertex attribute holds a simple data value which will be passed to a shader
as an attribute.
|
| View |
Base class for 2D and 3D views.
|
| ViewState |
The view state encapsulates what's in a view at a certain point in time.
|
| WideVectorInfo |
The Wide Vector Info class holds visual information related to groups of vectors.
|
| WideVectorManager |
The Wide Vector Manager is an interface to the Maply C++
wide vector manager and should be invisible to toolkit users.
|
| Enum | Description |
|---|---|
| AttrDictionaryEntry.Type | |
| GeometryRaw.GeometryType | |
| GeometryRawPoints.Type | |
| GlobeMapFragment.MapDisplayType | |
| LabelInfo.TextJustify |
Justification values for text.
|
| MapboxVectorStyleSet.SourceType | |
| ParticleSystem.Type | |
| QuadImageFrameLoader.FrameLoadMode | |
| QuadLoaderBase.Mode | |
| RenderController.ImageFormat |
Enumerated values for image types.
|
| RenderControllerInterface.TextureSettings.FilterType | |
| RenderControllerInterface.ThreadMode | |
| Shader.AttributeType | |
| VectorInfo.TextureProjection |
When using textures on areal features, you can project the texture a couple of different ways.
|
| VectorObject.MaplyVectorObjectType | |
| VectorTileTextStyle.Placement |