BaseController

java.lang.Object
- com.mousebird.maply.BaseController

All Implemented Interfaces:

RenderController.TaskManager, RenderControllerInterface

Direct Known Subclasses:

GlobeController, MapController
```
public class BaseController
extends java.lang.Object
implements RenderController.TaskManager, RenderControllerInterface
```
The base controller is a base class for both Maply and WhirlyGlobe controllers.
Most of the functionality is shared between the 2D and 3D maps and so it is implemented here.

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`static interface`	`BaseController.ScreenshotListener` Listener to receive the screenshot in an asynchronous way.
`static class`	`BaseController.Settings` These are settings passed on construction.

Nested classes/interfaces inherited from interface com.mousebird.maply.RenderControllerInterface
RenderControllerInterface.ContextInfo, RenderControllerInterface.TextureSettings, RenderControllerInterface.ThreadMode

Field Summary

Fields
Modifier and Type	Field and Description
`android.app.Activity`	`activity`
`protected com.mousebird.maply.CoordSystemDisplayAdapter`	`coordAdapter`
`int`	`frameInterval` This is how often we'll kick off a render when the frame sync comes in.
`okhttp3.OkHttpClient`	`httpClient`
`protected MetroThread`	`metroThread`
`RenderController`	`renderControl` The render controller handles marshalling objects and the actual run loop.
`protected com.mousebird.maply.RendererWrapper`	`renderWrapper`
`protected boolean`	`running`
`Scene`	`scene`
`protected View`	`view`

Constructor Summary

Constructors
Constructor and Description

BaseController(android.app.Activity mainActivity, BaseController.Settings settings)
Construct the maply controller with an Activity.

Constructors
Constructor and Description
`BaseController(android.app.Activity mainActivity, BaseController.Settings settings)` Construct the maply controller with an Activity.

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`addActiveObject(ActiveObject activeObject)` Add an active object that will be called right before the render (on the render thread).
`void`	`addActiveObjectAtStart(ActiveObject activeObject)` Add an active object to the beginning of the list.
`ComponentObject`	`addBillboards(java.util.List<Billboard> bills, BillboardInfo info, RenderControllerInterface.ThreadMode threadMode)` Billboards are rectangles pointed toward the viewer.
`void`	`addClusterGenerator(ClusterGenerator generator)` When the layout system clusters a bunch of markers or labels together, it needs new images to represent the cluster.
`void`	`addLayer(Layer layer)` Add a single layer.
`void`	`addLight(Light light)` Add the given light to the list of active lights.
`ComponentObject`	`addLoftedPoly(VectorObject vec, LoftedPolyInfo loftInfo, RenderControllerInterface.ThreadMode mode)` Add a single Lofted Polygon.
`ComponentObject`	`addLoftedPolys(java.util.List<VectorObject> vecs, LoftedPolyInfo loftInfo, RenderControllerInterface.ThreadMode mode)` Add Lofted Polygons to the MaplyController to display.
`void`	`addMainThreadTask(java.lang.Runnable run)` Utility routine to run a task on the main thread.
`void`	`addMainThreadTaskAfter(double when, java.lang.Runnable run)` Utility routine to run a task on the main thread after a period of time.
`ComponentObject`	`addMarker(Marker marker, MarkerInfo markerInfo, RenderControllerInterface.ThreadMode mode)` Add a single screen marker.
`ComponentObject`	`addMarkers(java.util.List<Marker> markers, MarkerInfo markerInfo, RenderControllerInterface.ThreadMode mode)` Add screen markers to the visual display.
`void`	`addParticleBatch(ParticleBatch particleBatch, RenderControllerInterface.ThreadMode mode)` Particles are short term objects, typically very small.
`ComponentObject`	`addParticleSystem(ParticleSystem particleSystem, RenderControllerInterface.ThreadMode mode)` This adds a particle system to the scene, but does not kick off any particles.
`ComponentObject`	`addPoints(java.util.List<Points> ptList, GeometryInfo geomInfo, RenderControllerInterface.ThreadMode mode)` Add the geometry points.
`ComponentObject`	`addPoints(Points pts, GeometryInfo geomInfo, RenderControllerInterface.ThreadMode mode)` Add the geometry points.
`void`	`addPostSurfaceRunnable(java.lang.Runnable run)` Add a runnable to be executed after the OpenGL surface is created.
`void`	`addRenderTarget(RenderTarget renderTarget)` Add a render target to the system Sets up a render target and will start rendering to it on the next frame.
`ComponentObject`	`addScreenLabel(ScreenLabel label, LabelInfo labelInfo, RenderControllerInterface.ThreadMode mode)` Add a single screen label.
`ComponentObject`	`addScreenLabels(java.util.List<ScreenLabel> labels, LabelInfo labelInfo, RenderControllerInterface.ThreadMode mode)` Add screen labels to the display.
`ComponentObject`	`addScreenMarker(ScreenMarker marker, MarkerInfo markerInfo, RenderControllerInterface.ThreadMode mode)` Add a single screen marker.
`ComponentObject`	`addScreenMarkers(java.util.List<ScreenMarker> markers, MarkerInfo markerInfo, RenderControllerInterface.ThreadMode mode)` Add screen markers to the visual display.
`ComponentObject`	`addScreenMovingLabels(java.util.List<ScreenMovingLabel> labels, LabelInfo labelInfo, RenderControllerInterface.ThreadMode mode)` Add screen labels to the display.
`ComponentObject`	`addScreenMovingMarkers(java.util.List<ScreenMovingMarker> markers, MarkerInfo markerInfo, RenderControllerInterface.ThreadMode mode)` Add moving screen markers to the visual display.
`void`	`addShaderProgram(Shader shader)` Associate a shader with the given scene name.
`ComponentObject`	`addShapes(java.util.List<Shape> shapes, ShapeInfo shapeInfo, RenderControllerInterface.ThreadMode mode)` This method will add the given MaplyShape derived objects to the current scene.
`ComponentObject`	`addStickers(java.util.List<Sticker> stickers, StickerInfo stickerInfo, RenderControllerInterface.ThreadMode mode)` Add stickers on top of the globe or map.
`void`	`addTask(java.lang.Runnable run, RenderControllerInterface.ThreadMode mode)` Add a task according to the thread mode.
`MaplyTexture`	`addTexture(android.graphics.Bitmap image, RenderControllerInterface.TextureSettings settings, RenderControllerInterface.ThreadMode mode)` Add texture to the system with the given settings.
`MaplyTexture`	`addTexture(com.mousebird.maply.Texture rawTex, RenderControllerInterface.TextureSettings settings, RenderControllerInterface.ThreadMode mode)` Add texture to the system with the given settings.
`RemoteTileFetcher`	`addTileFetcher(java.lang.String name)` Either returns a RemoteTileFetcher with the given name or it creates one and then returns the same.
`ComponentObject`	`addVector(VectorObject vec, VectorInfo vecInfo, RenderControllerInterface.ThreadMode mode)` Add a single VectorObject.
`ComponentObject`	`addVectors(java.util.List<VectorObject> vecs, VectorInfo vecInfo, RenderControllerInterface.ThreadMode mode)` Add vectors to the MaplyController to display.
`ComponentObject`	`addWideVector(VectorObject vec, WideVectorInfo wideVecInfo, RenderControllerInterface.ThreadMode mode)` Add wide vectors to the MaplyController to display.
`ComponentObject`	`addWideVectors(java.util.List<VectorObject> vecs, WideVectorInfo wideVecInfo, RenderControllerInterface.ThreadMode mode)` Add wide vectors to the MaplyController to display.
`void`	`changeRenderTarget(RenderTarget renderTarget, MaplyTexture tex)` Point the render target at a different texture.
`ComponentObject`	`changeSticker(ComponentObject stickerObj, StickerInfo stickerInfo, RenderControllerInterface.ThreadMode mode)` Change the visual representation for the given sticker.
`void`	`changeVector(ComponentObject vecObj, VectorInfo vecInfo, RenderControllerInterface.ThreadMode mode)` Change the visual representation of the given vectors.
`void`	`clearLights()` Clear all the currently active lights.
`void`	`clearRenderTarget(RenderTarget renderTarget, RenderControllerInterface.ThreadMode mode)` Ask the render target to clear itself.
`void`	`clearTempContext(RenderControllerInterface.ContextInfo cInfo)`
`MaplyTexture`	`createTexture(int width, int height, RenderControllerInterface.TextureSettings settings, RenderControllerInterface.ThreadMode mode)` Create an empty texture of the given size.
`double`	`currentMapScale()` Return the current scale denominator (Mapnik).
`double`	`currentMapZoom(Point2d geoCoord)` Return the current map zoom from the viewpoint.
`void`	`disableObject(ComponentObject compObj, RenderControllerInterface.ThreadMode mode)` Disable the display for the given object.
`void`	`disableObjects(java.util.List<ComponentObject> compObjs, RenderControllerInterface.ThreadMode mode)` Disable the given objects.
`Point3d`	`displayCoord(Point3d localCoord, CoordSystem fromSystem)`
`void`	`enableObject(ComponentObject compObj, RenderControllerInterface.ThreadMode mode)` Enable the display for the given object.
`void`	`enableObjects(java.util.List<ComponentObject> compObjs, RenderControllerInterface.ThreadMode mode)` Enable the display for the given objects.
`QuadSamplingLayer`	`findSamplingLayer(SamplingParams params, QuadSamplingLayer.ClientInterface user)` Look for a sampling layer that matches the parameters given.
`Point2d`	`geoPointFromScreen(Point2d screenPt)`
`boolean`	`geoPointFromScreenBatch(double[] inX, double[] inY, double[] outX, double[] outY)` Batch version of the geoPointFromScreen method.
`android.app.Activity`	`getActivity()` Activity for the whole app.
`android.view.View`	`getContentView()` Return the main content view used to represent the Maply Control.
`CoordSystem`	`getCoordSystem()` Return the current coordinate system.
`int[]`	`getFrameBufferSize()` Return the current framebuffer size as ints.
`Point2d`	`getFrameSize()` Return the frame size we're rendering to.
`okhttp3.OkHttpClient`	`getHttpClient()` Return an HTTP Client for use in fetching data, probably tiles.
`LayerThread`	`getLayerThread()` Returns the layer thread we used for processing requests.
`float`	`getMaxLineWidth()` Returns the maximum line width on the current device.
`protected java.lang.Object`	`getObjectAtScreenLoc(Point2d screenLoc)` Returns an object (if any) at a given screen location
`protected SelectedObject[]`	`getObjectsAtScreenLoc(Point2d screenLoc)`
`boolean`	`getOfflineMode()` True if the renderer was set up as offline.
`RenderController`	`getRenderController()` The underlying render controller.
`Scene`	`getScene()` Return the current scene.
`Shader`	`getShader(java.lang.String name)` Find a shader by name
`Point2d`	`getViewSize()` Return the Android view size, rather than the frame size.
`LayerThread`	`getWorkingThread()` Returns a layer thread you can do whatever you like on.
`double`	`heightForMapScale(double scale)` Calculate the height that corresponds to a given Mapnik-style map scale.
`protected void`	`Init()`
`ComponentObject`	`instanceVectors(ComponentObject inCompObj, VectorInfo vecInfo, RenderControllerInterface.ThreadMode mode)` Instance an existing set of vectors and modify various parameters for reuse.
`ComponentObject`	`instanceWideVectors(ComponentObject inCompObj, WideVectorInfo wideVecInfo, RenderControllerInterface.ThreadMode mode)` Instance an existing set of wide vectors but change their parameters.
`LayerThread`	`makeLayerThread(boolean handlesViewUpdates)` Makes a new layer thread for toolkit related tasks.
`void`	`processChangeSet(ChangeSet changes)`
`void`	`releaseSamplingLayer(QuadSamplingLayer samplingLayer, QuadSamplingLayer.ClientInterface user)` Release the given sampling layer
`void`	`removeActiveObject(ActiveObject activeObject)` Remove an active object added earlier.
`void`	`removeLayer(Layer layer)` Remove a single layer.
`void`	`removeLayerThread(LayerThread layerThread)` Remove a layer thread you had created earlier.
`void`	`removeLight(Light light)` Remove the given light (assuming it's active) from the list of lights.
`void`	`removeObject(ComponentObject compObj, RenderControllerInterface.ThreadMode mode)` Remove a single objects from the display.
`void`	`removeObjects(java.util.List<ComponentObject> compObjs, RenderControllerInterface.ThreadMode mode)` Remove the given component objects from the display.
`void`	`removeRenderTarget(RenderTarget renderTarget)` Remove the given render target from the system.
`void`	`removeShader(Shader shader)` Take the given shader out of active use.
`void`	`removeTexture(MaplyTexture tex, RenderControllerInterface.ThreadMode mode)` Remove a texture from the scene.
`void`	`removeTextures(java.util.List<MaplyTexture> texs, RenderControllerInterface.ThreadMode mode)` Remove a whole group of textures from the scene.
`void`	`removeTexturesByID(java.util.List<java.lang.Long> texIDs, RenderControllerInterface.ThreadMode mode)` This version of removeTexture takes texture IDs.
`boolean`	`rendererIsAttached()` Set if the renderer is set up and running.
`void`	`requestRender()` Force a render on the next frame.
`void`	`resetLights()` Reset the lighting back to its default state at startup.
`Point2d`	`screenPointFromGeo(Point2d geoCoord)`
`boolean`	`screenPointFromGeoBatch(double[] inX, double[] inY, double[] inZ, double[] outX, double[] outY)` Batch version of the screenPointFromGeo method.
`void`	`setClearColor(int color)` Set the color for the OpenGL ES background.
`void`	`setDisplayRate(int inRate)` Set the display rate for the GL render.
`boolean`	`setEGLContext(RenderControllerInterface.ContextInfo cInfo)` Set the EGL Context we created for the main thread, if we can.
`void`	`setPerfInterval(int inPerfInterval)` Report performance stats in the console ever few frames.
`RenderControllerInterface.ContextInfo`	`setupTempContext(RenderControllerInterface.ThreadMode threadMode)`
`void`	`setViewExtents(Point2d ll, Point2d ur)` Set the viewport the user is allowed to move within.
`void`	`shutdown()` Call shutdown when you're done with the MaplyController.
`void`	`takeScreenshot(BaseController.ScreenshotListener listener)`
`boolean`	`usesTextureView()` Returns true if we set up a TextureView rather than a SurfaceView.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - activity
```
public android.app.Activity activity
```
  - httpClient
```
public okhttp3.OkHttpClient httpClient
```
  - frameInterval
```
public int frameInterval
```
    This is how often we'll kick off a render when the frame sync comes in. We get a notification when the render for a given frame starts, this is usually 60 times a second. This tells us how many to skip to achieve our desired frame rate. 2 means 30hz. 3 means 20hz and so forth.
  - running
```
protected boolean running
```
  - renderWrapper
```
protected com.mousebird.maply.RendererWrapper renderWrapper
```
  - coordAdapter
```
protected com.mousebird.maply.CoordSystemDisplayAdapter coordAdapter
```
  - scene
```
public Scene scene
```
  - view
```
protected View view
```
  - renderControl
```
public RenderController renderControl
```
    The render controller handles marshalling objects and the actual run loop.
  - metroThread
```
protected MetroThread metroThread
```
- Constructor Detail
  - BaseController
```
public BaseController(android.app.Activity mainActivity,
                      BaseController.Settings settings)
```
    Construct the maply controller with an Activity. We need access to a few of the usual Android resources.
    On construction the Controller will create the scene, the view, kick off the OpenGL ES surface, and construct a layer thread for handling data requests.
    The controller also sets up some default gestures and handles those callbacks.
    
    Parameters:
    
    mainActivity - Your main activity that we'll attach ourselves to.
- Method Detail
  - getScene
```
public Scene getScene()
```
    Return the current scene. Only for sure within the library.
    
    Specified by:
    
    getScene in interface RenderControllerInterface
  - getCoordSystem
```
public CoordSystem getCoordSystem()
```
    Return the current coordinate system.
    
    Specified by:
    
    getCoordSystem in interface RenderControllerInterface
  - takeScreenshot
```
public void takeScreenshot(BaseController.ScreenshotListener listener)
```
  - getHttpClient
```
public okhttp3.OkHttpClient getHttpClient()
```
    Return an HTTP Client for use in fetching data, probably tiles.
  - getLayerThread
```
public LayerThread getLayerThread()
```
    Returns the layer thread we used for processing requests.
  - addMainThreadTask
```
public void addMainThreadTask(java.lang.Runnable run)
```
    Utility routine to run a task on the main thread. Doesn't do anything clever, but it does end up looking very simple in Kotlin.
  - addMainThreadTaskAfter
```
public void addMainThreadTaskAfter(double when,
                                   java.lang.Runnable run)
```
    Utility routine to run a task on the main thread after a period of time. Doesn't do anything clever, but it does end up looking very simple in Kotlin.
  - getActivity
```
public android.app.Activity getActivity()
```
    Activity for the whole app.
  - getWorkingThread
```
public LayerThread getWorkingThread()
```
    Returns a layer thread you can do whatever you like on. You don't have to be particularly fast about it, it won't hold up the main layer thread. These layer threads are set up with the proper OpenGL contexts so they're fast to add new geometry using the ThreadCurrent option.
  - usesTextureView
```
public boolean usesTextureView()
```
    Returns true if we set up a TextureView rather than a SurfaceView.
  - getRenderController
```
public RenderController getRenderController()
```
    The underlying render controller. Only get this if you know what it does.
  - Init
```
protected void Init()
```
  - makeLayerThread
```
public LayerThread makeLayerThread(boolean handlesViewUpdates)
```
    Makes a new layer thread for toolkit related tasks.
    
    Parameters:
    
    handlesViewUpdates - If set, the layer thread will deal with view updates. If not set, it's a simpler layer thread.
  - removeLayerThread
```
public void removeLayerThread(LayerThread layerThread)
```
    Remove a layer thread you had created earlier. This is serious stuff. Only do this if you know why you're doing it.
  - displayCoord
```
public Point3d displayCoord(Point3d localCoord,
                            CoordSystem fromSystem)
```
  - getContentView
```
public android.view.View getContentView()
```
    Return the main content view used to represent the Maply Control.
  - getViewSize
```
public Point2d getViewSize()
```
    Return the Android view size, rather than the frame size.
  - shutdown
```
public void shutdown()
```
    Call shutdown when you're done with the MaplyController. It will shut down the layer thread(s) and all the associated logic.
  - setupTempContext
```
public RenderControllerInterface.ContextInfo setupTempContext(RenderControllerInterface.ThreadMode threadMode)
```
    Specified by:
    
    setupTempContext in interface RenderControllerInterface
  - clearTempContext
```
public void clearTempContext(RenderControllerInterface.ContextInfo cInfo)
```
    Specified by:
    
    clearTempContext in interface RenderControllerInterface
  - rendererIsAttached
```
public boolean rendererIsAttached()
```
    Set if the renderer is set up and running.
  - addPostSurfaceRunnable
```
public void addPostSurfaceRunnable(java.lang.Runnable run)
```
    Add a runnable to be executed after the OpenGL surface is created.
  - setDisplayRate
```
public void setDisplayRate(int inRate)
```
    Set the display rate for the GL render. 1 means 60fps. 2 means 30fps. 3 means 20fps.
  - requestRender
```
public void requestRender()
```
    Force a render on the next frame. Mostly used internally.
    
    Specified by:
    
    requestRender in interface RenderControllerInterface
  - setEGLContext
```
public boolean setEGLContext(RenderControllerInterface.ContextInfo cInfo)
```
    Set the EGL Context we created for the main thread, if we can.
    
    Specified by:
    
    setEGLContext in interface RenderControllerInterface
  - setClearColor
```
public void setClearColor(int color)
```
    Set the color for the OpenGL ES background.
    
    Specified by:
    
    setClearColor in interface RenderControllerInterface
  - setViewExtents
```
public void setViewExtents(Point2d ll,
                           Point2d ur)
```
    Set the viewport the user is allowed to move within. These are lat/lon coordinates in radians.
    
    Parameters:
    
    ll - Lower left corner.
    
    ur - Upper right corner.
  - screenPointFromGeoBatch
```
public boolean screenPointFromGeoBatch(double[] inX,
                                       double[] inY,
                                       double[] inZ,
                                       double[] outX,
                                       double[] outY)
```
    Batch version of the screenPointFromGeo method. This version is here for users to convert a whole group of coordinates all at once. Doing it individually is just too slow in Java.
    
    Parameters:
    
    inX - Longitude in radians.
    
    inY - Latitude in radians.
    
    inZ - Z value. Set this to zero most of the time.
    
    outX - X point on screen. MAXFLOAT if this is behind the globe.
    
    outY - Y point on screen. MAXFLOAT if this is behind the globe.
  - geoPointFromScreenBatch
```
public boolean geoPointFromScreenBatch(double[] inX,
                                       double[] inY,
                                       double[] outX,
                                       double[] outY)
```
    Batch version of the geoPointFromScreen method. This version is here for users to convert a whole group of coordinates all at once. Doing it individually is just too slow in Java.
  - setPerfInterval
```
public void setPerfInterval(int inPerfInterval)
```
    Report performance stats in the console ever few frames. Setting this to zero turns it off.
    
    Parameters:
    
    inPerfInterval -
  - heightForMapScale
```
public double heightForMapScale(double scale)
```
    Calculate the height that corresponds to a given Mapnik-style map scale.
    Figure out the viewer height that corresponds to a given scale denominator (ala Mapnik). This height will probably be use for visibility ranges on geometry. This works as a mechanism for making geometry appear at certain map scales and disappear at others.
    
    Specified by:
    
    heightForMapScale in interface RenderControllerInterface
    
    Returns:
    
    Returns the height or 0.0 if the system isn't initialized yet.
  - currentMapZoom
```
public double currentMapZoom(Point2d geoCoord)
```
    Return the current map zoom from the viewpoint.
    Calculate the map zoom (TMS) based on the current screen size and the 3D viewport.
    
    Specified by:
    
    currentMapZoom in interface RenderControllerInterface
    
    Parameters:
    
    geoCoord - the location to calculate for. This is needed because zoom is dependant on latitude.
    
    Returns:
    
    Returns the map zoom or 0.0 if the system is not yet initialized.
  - currentMapScale
```
public double currentMapScale()
```
    Return the current scale denominator (Mapnik).
    See https://github.com/mapnik/mapnik/wiki/ScaleAndPpi for a definition of the Mapnik scale denominator.
    
    Specified by:
    
    currentMapScale in interface RenderControllerInterface
    
    Returns:
    
    Returns the current scale denominator or 0.0 if the system is not yet initialized.
  - addLayer
```
public void addLayer(Layer layer)
```
    Add a single layer. This will start processing its data on the layer thread at some point in the near future.
  - removeLayer
```
public void removeLayer(Layer layer)
```
    Remove a single layer. The layer will stop receiving data and be shut down shortly after you call this.
  - findSamplingLayer
```
public QuadSamplingLayer findSamplingLayer(SamplingParams params,
                                           QuadSamplingLayer.ClientInterface user)
```
    Look for a sampling layer that matches the parameters given. Sampling layers can be shared for efficiency. Don't be calling this yourself. The loaders do it for you.
  - releaseSamplingLayer
```
public void releaseSamplingLayer(QuadSamplingLayer samplingLayer,
                                 QuadSamplingLayer.ClientInterface user)
```
    Release the given sampling layer
    
    Parameters:
    
    samplingLayer -
    
    user -
  - addTileFetcher
```
public RemoteTileFetcher addTileFetcher(java.lang.String name)
```
    Either returns a RemoteTileFetcher with the given name or it creates one and then returns the same.
  - addTask
```
public void addTask(java.lang.Runnable run,
                    RenderControllerInterface.ThreadMode mode)
```
    Add a task according to the thread mode. If it's ThreadAny, we'll put it on the layer thread. If it's ThreadCurrent, we'll do it immediately.
    
    Specified by:
    
    addTask in interface RenderController.TaskManager
    
    Parameters:
    
    run - Runnable to execute.
    
    mode - Where to execute it.
  - addVector
```
public ComponentObject addVector(VectorObject vec,
                                 VectorInfo vecInfo,
                                 RenderControllerInterface.ThreadMode mode)
```
    Add a single VectorObject. See addVectors() for details.
  - addVectors
```
public ComponentObject addVectors(java.util.List<VectorObject> vecs,
                                  VectorInfo vecInfo,
                                  RenderControllerInterface.ThreadMode mode)
```
    Add vectors to the MaplyController to display. Vectors are linear or areal features with line width, filled style, color and so forth defined by the VectorInfo class.
    
    Specified by:
    
    addVectors in interface RenderControllerInterface
    
    Parameters:
    
    vecs - A list of VectorObject's created by the user or read in from various sources.
    
    vecInfo - A description of how the vectors should look.
    
    mode - Where to execute the add. Choose ThreadAny by default.
    
    Returns:
    
    The ComponentObject representing the vectors. This is necessary for modifying or deleting the vectors once created.
  - instanceVectors
```
public ComponentObject instanceVectors(ComponentObject inCompObj,
                                       VectorInfo vecInfo,
                                       RenderControllerInterface.ThreadMode mode)
```
    Instance an existing set of vectors and modify various parameters for reuse. This is useful if you want to overlay the same vectors twice with different widths, for example.
    
    Specified by:
    
    instanceVectors in interface RenderControllerInterface
  - changeVector
```
public void changeVector(ComponentObject vecObj,
                         VectorInfo vecInfo,
                         RenderControllerInterface.ThreadMode mode)
```
    Change the visual representation of the given vectors.
    
    Specified by:
    
    changeVector in interface RenderControllerInterface
    
    Parameters:
    
    vecObj - The component object returned by the original addVectors() call.
    
    vecInfo - Visual representation to use for the changes.
    
    mode - Where to execute the add. Choose ThreadAny by default.
  - addWideVectors
```
public ComponentObject addWideVectors(java.util.List<VectorObject> vecs,
                                      WideVectorInfo wideVecInfo,
                                      RenderControllerInterface.ThreadMode mode)
```
    Add wide vectors to the MaplyController to display. Vectors are linear or areal features with line width, filled style, color and so forth defined by the WideVectorInfo class.
    Wide vectors differ from regular lines in that they're implemented with a more complicated shader. They can be arbitrarily large, have textures, and have a transparent falloff at the edges. This makes them look anti-aliased.
    
    Specified by:
    
    addWideVectors in interface RenderControllerInterface
    
    Parameters:
    
    vecs - A list of VectorObject's created by the user or read in from various sources.
    
    wideVecInfo - A description of how the vectors should look.
    
    mode - Where to execute the add. Choose ThreadAny by default.
    
    Returns:
    
    The ComponentObject representing the vectors. This is necessary for modifying or deleting the vectors once created.
  - addWideVector
```
public ComponentObject addWideVector(VectorObject vec,
                                     WideVectorInfo wideVecInfo,
                                     RenderControllerInterface.ThreadMode mode)
```
    Add wide vectors to the MaplyController to display. Vectors are linear or areal features with line width, filled style, color and so forth defined by the WideVectorInfo class.
    Wide vectors differ from regular lines in that they're implemented with a more complicated shader. They can be arbitrarily large, have textures, and have a transparent falloff at the edges. This makes them look anti-aliased.
    
    Parameters:
    
    vec - The vector object to turn into wide vectors.
    
    wideVecInfo - A description of how the vectors should look.
    
    mode - Where to execute the add. Choose ThreadAny by default.
    
    Returns:
    
    The ComponentObject representing the vectors. This is necessary for modifying or deleting the vectors once created.
  - instanceWideVectors
```
public ComponentObject instanceWideVectors(ComponentObject inCompObj,
                                           WideVectorInfo wideVecInfo,
                                           RenderControllerInterface.ThreadMode mode)
```
    Instance an existing set of wide vectors but change their parameters.
    Wide vectors can take up a lot of memory. So if you want to display the same set with different parameters (e.g. width, color) this is the way to do it.
    
    Specified by:
    
    instanceWideVectors in interface RenderControllerInterface
    
    Parameters:
    
    inCompObj - The Component Object returned by an addWideVectors call.
    
    wideVecInfo - How we want the vectors to look.
    
    mode - Where to execute the add. Choose ThreadAny by default.
    
    Returns:
    
    The ComponentObject representing the instanced wide vectors. This is necessary for modifying or deleting the instance once created.
  - addLoftedPoly
```
public ComponentObject addLoftedPoly(VectorObject vec,
                                     LoftedPolyInfo loftInfo,
                                     RenderControllerInterface.ThreadMode mode)
```
    Add a single Lofted Polygon. See addLoftedPolys() for details.
  - addLoftedPolys
```
public ComponentObject addLoftedPolys(java.util.List<VectorObject> vecs,
                                      LoftedPolyInfo loftInfo,
                                      RenderControllerInterface.ThreadMode mode)
```
    Add Lofted Polygons to the MaplyController to display.
    Lofted polygons require areal features as outlines. The result will be a tent-like visual with optional sides and a top.
    
    Specified by:
    
    addLoftedPolys in interface RenderControllerInterface
    
    Parameters:
    
    vecs - A list of VectorObject's created by the user or read in from various sources.
    
    loftInfo - A description of how the lofted polygons should look.
    
    mode - Where to execute the add. Choose ThreadAny by default.
    
    Returns:
    
    The ComponentObject representing the vectors. This is necessary for modifying or deleting the features once created.
  - addScreenMarker
```
public ComponentObject addScreenMarker(ScreenMarker marker,
                                       MarkerInfo markerInfo,
                                       RenderControllerInterface.ThreadMode mode)
```
    Add a single screen marker. See addScreenMarkers() for details.
  - addScreenMarkers
```
public ComponentObject addScreenMarkers(java.util.List<ScreenMarker> markers,
                                        MarkerInfo markerInfo,
                                        RenderControllerInterface.ThreadMode mode)
```
    Add screen markers to the visual display. Screen markers are 2D markers that sit on top of the screen display, rather than interacting with the geometry. Their visual look is defined by the MarkerInfo class.
    
    Specified by:
    
    addScreenMarkers in interface RenderControllerInterface
    
    Parameters:
    
    markers - The markers to add to the display
    
    markerInfo - How the markers should look.
    
    mode - Where to execute the add. Choose ThreadAny by default.
    
    Returns:
    
    This represents the screen markers for later modification or deletion.
  - addScreenMovingMarkers
```
public ComponentObject addScreenMovingMarkers(java.util.List<ScreenMovingMarker> markers,
                                              MarkerInfo markerInfo,
                                              RenderControllerInterface.ThreadMode mode)
```
    Add moving screen markers to the visual display. These are the same as the regular screen markers, but they have a start and end point and a duration.
    
    Specified by:
    
    addScreenMovingMarkers in interface RenderControllerInterface
  - addMarker
```
public ComponentObject addMarker(Marker marker,
                                 MarkerInfo markerInfo,
                                 RenderControllerInterface.ThreadMode mode)
```
    Add a single screen marker. See addMarkers() for details.
  - addMarkers
```
public ComponentObject addMarkers(java.util.List<Marker> markers,
                                  MarkerInfo markerInfo,
                                  RenderControllerInterface.ThreadMode mode)
```
    Add screen markers to the visual display. Screen markers are 2D markers that sit on top of the screen display, rather than interacting with the geometry. Their visual look is defined by the MarkerInfo class.
    
    Specified by:
    
    addMarkers in interface RenderControllerInterface
    
    Parameters:
    
    markers - The markers to add to the display
    
    markerInfo - How the markers should look.
    
    mode - Where to execute the add. Choose ThreadAny by default.
    
    Returns:
    
    This represents the screen markers for later modification or deletion.
  - addStickers
```
public ComponentObject addStickers(java.util.List<Sticker> stickers,
                                   StickerInfo stickerInfo,
                                   RenderControllerInterface.ThreadMode mode)
```
    Add stickers on top of the globe or map. Stickers are 2D objects that drape over a defined area.
    
    Specified by:
    
    addStickers in interface RenderControllerInterface
    
    Parameters:
    
    stickers - The list of stickers to apply.
    
    stickerInfo - Parameters that cover all the stickers in question.
    
    mode - Where to execute the add. Choose ThreadAny by default.
    
    Returns:
    
    This represents the stickers for later modification or deletion.
  - changeSticker
```
public ComponentObject changeSticker(ComponentObject stickerObj,
                                     StickerInfo stickerInfo,
                                     RenderControllerInterface.ThreadMode mode)
```
    Change the visual representation for the given sticker.
    
    Specified by:
    
    changeSticker in interface RenderControllerInterface
    
    Parameters:
    
    stickerObj - The sticker to change.
    
    stickerInfo - Parameters to change.
    
    mode - Where to execute the add. Choose ThreadAny by default.
    
    Returns:
    
    This represents the stickers for later modification or deletion.
  - addPoints
```
public ComponentObject addPoints(java.util.List<Points> ptList,
                                 GeometryInfo geomInfo,
                                 RenderControllerInterface.ThreadMode mode)
```
    Add the geometry points. These are raw points that get fed to a shader.
    
    Specified by:
    
    addPoints in interface RenderControllerInterface
    
    Parameters:
    
    ptList - The points to add.
    
    geomInfo - Parameters to set things up with.
    
    mode - Where to execute the add. Choose ThreadAny by default.
    
    Returns:
    
    This represents the geometry points for later modifictation or deletion.
  - addPoints
```
public ComponentObject addPoints(Points pts,
                                 GeometryInfo geomInfo,
                                 RenderControllerInterface.ThreadMode mode)
```
    Add the geometry points. These are raw points that get fed to a shader.
    
    Parameters:
    
    pts - The points to add.
    
    geomInfo - Parameters to set things up with.
    
    mode - Where to execute the add. Choose ThreadAny by default.
    
    Returns:
    
    This represents the geometry points for later modifictation or deletion.
  - geoPointFromScreen
```
public Point2d geoPointFromScreen(Point2d screenPt)
```
  - screenPointFromGeo
```
public Point2d screenPointFromGeo(Point2d geoCoord)
```
  - getObjectsAtScreenLoc
```
protected SelectedObject[] getObjectsAtScreenLoc(Point2d screenLoc)
```
  - getObjectAtScreenLoc
```
protected java.lang.Object getObjectAtScreenLoc(Point2d screenLoc)
```
    Returns an object (if any) at a given screen location
    
    Parameters:
    
    screenLoc - the screen location to be considered
    
    Returns:
    
    teh object at screenLoc or null if none was there
  - addScreenLabel
```
public ComponentObject addScreenLabel(ScreenLabel label,
                                      LabelInfo labelInfo,
                                      RenderControllerInterface.ThreadMode mode)
```
    Add a single screen label. See addScreenLabels() for details.
  - addScreenLabels
```
public ComponentObject addScreenLabels(java.util.List<ScreenLabel> labels,
                                       LabelInfo labelInfo,
                                       RenderControllerInterface.ThreadMode mode)
```
    Add screen labels to the display. Screen labels are 2D labels that float above the 3D geometry and stay fixed in size no matter how the user zoom in or out. Their visual appearance is controlled by the LabelInfo class.
    
    Specified by:
    
    addScreenLabels in interface RenderControllerInterface
    
    Parameters:
    
    labels - Labels to add to the display.
    
    labelInfo - The visual appearance of the labels.
    
    mode - Where to execute the add. Choose ThreadAny by default.
    
    Returns:
    
    This represents the labels for modification or deletion.
  - addScreenMovingLabels
```
public ComponentObject addScreenMovingLabels(java.util.List<ScreenMovingLabel> labels,
                                             LabelInfo labelInfo,
                                             RenderControllerInterface.ThreadMode mode)
```
    Add screen labels to the display. Screen labels are 2D labels that float above the 3D geometry and stay fixed in size no matter how the user zoom in or out. Their visual appearance is controlled by the LabelInfo class.
    
    Specified by:
    
    addScreenMovingLabels in interface RenderControllerInterface
    
    Parameters:
    
    labels - Labels to add to the display.
    
    labelInfo - The visual appearance of the labels.
    
    mode - Where to execute the add. Choose ThreadAny by default.
    
    Returns:
    
    This represents the labels for modification or deletion.
  - addTexture
```
public MaplyTexture addTexture(android.graphics.Bitmap image,
                               RenderControllerInterface.TextureSettings settings,
                               RenderControllerInterface.ThreadMode mode)
```
    Add texture to the system with the given settings.
    
    Specified by:
    
    addTexture in interface RenderControllerInterface
    
    Parameters:
    
    image - Image to add.
    
    settings - Settings to use.
    
    mode - Add on the current thread or elsewhere.
  - createTexture
```
public MaplyTexture createTexture(int width,
                                  int height,
                                  RenderControllerInterface.TextureSettings settings,
                                  RenderControllerInterface.ThreadMode mode)
```
    Create an empty texture of the given size.
    
    Specified by:
    
    createTexture in interface RenderControllerInterface
    
    Parameters:
    
    width - Width of the resulting texture
    
    height - Height of the resulting texture
    
    settings - Other texture related settings
    
    mode - Which thread to do the work on
    
    Returns:
    
    The new texture (or a reference to it, anyway)
  - addTexture
```
public MaplyTexture addTexture(com.mousebird.maply.Texture rawTex,
                               RenderControllerInterface.TextureSettings settings,
                               RenderControllerInterface.ThreadMode mode)
```
    Add texture to the system with the given settings.
    
    Specified by:
    
    addTexture in interface RenderControllerInterface
    
    Parameters:
    
    rawTex - Texture to add.
    
    settings - Settings to use.
    
    mode - Add on the current thread or elsewhere.
  - removeTexture
```
public void removeTexture(MaplyTexture tex,
                          RenderControllerInterface.ThreadMode mode)
```
    Remove a texture from the scene.
    
    Specified by:
    
    removeTexture in interface RenderControllerInterface
    
    Parameters:
    
    tex - Texture to remove.
    
    mode - Remove immediately (current thread) or elsewhere.
  - removeTextures
```
public void removeTextures(java.util.List<MaplyTexture> texs,
                           RenderControllerInterface.ThreadMode mode)
```
    Remove a whole group of textures from the scene.
    
    Specified by:
    
    removeTextures in interface RenderControllerInterface
    
    Parameters:
    
    texs - Textures to remove.
    
    mode - Remove immediately (current thread) or elsewhere.
  - removeTexturesByID
```
public void removeTexturesByID(java.util.List<java.lang.Long> texIDs,
                               RenderControllerInterface.ThreadMode mode)
```
    This version of removeTexture takes texture IDs. Thus you don't have to keep the MaplyTexture around.
    
    Specified by:
    
    removeTexturesByID in interface RenderControllerInterface
    
    Parameters:
    
    texIDs - Textures to remove
    
    mode - Remove immediately (current thread) or elsewhere.
  - addRenderTarget
```
public void addRenderTarget(RenderTarget renderTarget)
```
    Add a render target to the system
    Sets up a render target and will start rendering to it on the next frame. Keep the render target around so you can remove it later.
    
    Specified by:
    
    addRenderTarget in interface RenderControllerInterface
  - changeRenderTarget
```
public void changeRenderTarget(RenderTarget renderTarget,
                               MaplyTexture tex)
```
    Point the render target at a different texture.
    
    Specified by:
    
    changeRenderTarget in interface RenderControllerInterface
  - clearRenderTarget
```
public void clearRenderTarget(RenderTarget renderTarget,
                              RenderControllerInterface.ThreadMode mode)
```
    Ask the render target to clear itself.
  - removeRenderTarget
```
public void removeRenderTarget(RenderTarget renderTarget)
```
    Remove the given render target from the system.
    Ask the system to stop drawing to the given render target. It will do this on the next frame.
    
    Specified by:
    
    removeRenderTarget in interface RenderControllerInterface
  - addShaderProgram
```
public void addShaderProgram(Shader shader)
```
    Associate a shader with the given scene name. These names let us override existing shaders, as well as adding our own.
    
    Specified by:
    
    addShaderProgram in interface RenderControllerInterface
    
    Parameters:
    
    shader - The shader to add.
  - getShader
```
public Shader getShader(java.lang.String name)
```
    Find a shader by name
    
    Specified by:
    
    getShader in interface RenderControllerInterface
    
    Parameters:
    
    name - Name of the shader to return
    
    Returns:
    
    The shader with the name or null
  - removeShader
```
public void removeShader(Shader shader)
```
    Take the given shader out of active use.
    
    Specified by:
    
    removeShader in interface RenderControllerInterface
  - addActiveObject
```
public void addActiveObject(ActiveObject activeObject)
```
    Add an active object that will be called right before the render (on the render thread).
  - addActiveObjectAtStart
```
public void addActiveObjectAtStart(ActiveObject activeObject)
```
    Add an active object to the beginning of the list. Do this if you want to make sure yours is run first.
  - removeActiveObject
```
public void removeActiveObject(ActiveObject activeObject)
```
    Remove an active object added earlier.
  - disableObjects
```
public void disableObjects(java.util.List<ComponentObject> compObjs,
                           RenderControllerInterface.ThreadMode mode)
```
    Disable the given objects. These were the objects returned by the various add calls. Once called, the objects will be invisible, but can be made visible once again with enableObjects()
    
    Specified by:
    
    disableObjects in interface RenderControllerInterface
    
    Parameters:
    
    compObjs - Objects to disable in the display.
    
    mode - Where to execute the add. Choose ThreadAny by default.
  - disableObject
```
public void disableObject(ComponentObject compObj,
                          RenderControllerInterface.ThreadMode mode)
```
    Disable the display for the given object.
    
    Parameters:
    
    compObj - Object to disable
    
    mode - Where to execute the enable. Choose ThreadAny by default.
  - enableObjects
```
public void enableObjects(java.util.List<ComponentObject> compObjs,
                          RenderControllerInterface.ThreadMode mode)
```
    Enable the display for the given objects. These objects were returned by the various add calls. To disable the display, call disableObjects().
    
    Specified by:
    
    enableObjects in interface RenderControllerInterface
    
    Parameters:
    
    compObjs - Objects to enable disable.
    
    mode - Where to execute the enable. Choose ThreadAny by default.
  - enableObject
```
public void enableObject(ComponentObject compObj,
                         RenderControllerInterface.ThreadMode mode)
```
    Enable the display for the given object.
    
    Parameters:
    
    compObj - Object to enable.
    
    mode - Where to execute the enable. Choose ThreadAny by default.
  - removeObject
```
public void removeObject(ComponentObject compObj,
                         RenderControllerInterface.ThreadMode mode)
```
    Remove a single objects from the display. See removeObjects() for details.
    
    Specified by:
    
    removeObject in interface RenderControllerInterface
  - removeObjects
```
public void removeObjects(java.util.List<ComponentObject> compObjs,
                          RenderControllerInterface.ThreadMode mode)
```
    Remove the given component objects from the display. This will permanently remove them from Maply. The component objects were returned from the various add calls.
    
    Specified by:
    
    removeObjects in interface RenderControllerInterface
    
    Parameters:
    
    compObjs - Component Objects to remove.
    
    mode - Where to execute the add. Choose ThreadAny by default.
  - addParticleSystem
```
public ComponentObject addParticleSystem(ParticleSystem particleSystem,
                                         RenderControllerInterface.ThreadMode mode)
```
    This adds a particle system to the scene, but does not kick off any particles.
    
    Parameters:
    
    particleSystem - The particle system to start.
    
    mode - Where to execute the add. Choose ThreadAny by default.
  - addParticleBatch
```
public void addParticleBatch(ParticleBatch particleBatch,
                             RenderControllerInterface.ThreadMode mode)
```
    Particles are short term objects, typically very small. We create them in large groups for efficience. You'll need to fill out the MaplyParticleSystem initially and then the MaplyParticleBatch to create them.
    
    Parameters:
    
    particleBatch - The batch of particles to add to an active particle system.
    
    mode - Where to execute the add. Choose ThreadAny by default.
  - addClusterGenerator
```
public void addClusterGenerator(ClusterGenerator generator)
```
    When the layout system clusters a bunch of markers or labels together, it needs new images to represent the cluster. You can provide a custom image for each group of markers by filling in one of these generates and passing it in.
  - addShapes
```
public ComponentObject addShapes(java.util.List<Shape> shapes,
                                 ShapeInfo shapeInfo,
                                 RenderControllerInterface.ThreadMode mode)
```
    This method will add the given MaplyShape derived objects to the current scene. It will use the parameters in the description dictionary and it will do it on the thread specified.
    
    Specified by:
    
    addShapes in interface RenderControllerInterface
    
    Parameters:
    
    shapes - An array of Shape derived objects
    
    shapeInfo - Info controlling how the shapes look
    
    mode - Where to execute the add. Choose ThreadAny by default.
  - addLight
```
public void addLight(Light light)
```
    Add the given light to the list of active lights.
    This method will add the given light to our active lights. Most shaders will recognize these lights and do the calculations. If you have a custom shader in place, it may or may not use these. Triangle shaders use the lights, but line shaders do not.
    
    Specified by:
    
    addLight in interface RenderControllerInterface
    
    Parameters:
    
    light - Light to add.
  - removeLight
```
public void removeLight(Light light)
```
    Remove the given light (assuming it's active) from the list of lights.
    
    Specified by:
    
    removeLight in interface RenderControllerInterface
    
    Parameters:
    
    light - Light to remove.
  - clearLights
```
public void clearLights()
```
    Clear all the currently active lights.
    There are a default set of lights, so you'll want to do this before adding your own.
    
    Specified by:
    
    clearLights in interface RenderControllerInterface
  - resetLights
```
public void resetLights()
```
    Reset the lighting back to its default state at startup.
    This clears out all the lights and adds in the default starting light source.
    
    Specified by:
    
    resetLights in interface RenderControllerInterface
  - addBillboards
```
public ComponentObject addBillboards(java.util.List<Billboard> bills,
                                     BillboardInfo info,
                                     RenderControllerInterface.ThreadMode threadMode)
```
    Billboards are rectangles pointed toward the viewer. They can either be upright, tied to a surface, or oriented completely toward the user.
    
    Specified by:
    
    addBillboards in interface RenderControllerInterface
  - getMaxLineWidth
```
public float getMaxLineWidth()
```
    Returns the maximum line width on the current device.
  - getFrameSize
```
public Point2d getFrameSize()
```
    Return the frame size we're rendering to.
  - getFrameBufferSize
```
public int[] getFrameBufferSize()
```
    Return the current framebuffer size as ints.
    
    Specified by:
    
    getFrameBufferSize in interface RenderControllerInterface
  - processChangeSet
```
public void processChangeSet(ChangeSet changes)
```
    Specified by:
    
    processChangeSet in interface RenderControllerInterface
  - getOfflineMode
```
public boolean getOfflineMode()
```
    True if the renderer was set up as offline. Never going to be true for this.
    
    Specified by:
    
    getOfflineMode in interface RenderControllerInterface

Class BaseController

Nested Class Summary

Nested classes/interfaces inherited from interface com.mousebird.maply.RenderControllerInterface

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

activity

httpClient

frameInterval

running

renderWrapper

coordAdapter

scene

view

renderControl

metroThread

Constructor Detail

BaseController

Method Detail

getScene

getCoordSystem

takeScreenshot

getHttpClient

getLayerThread

addMainThreadTask

addMainThreadTaskAfter

getActivity

getWorkingThread

usesTextureView

getRenderController

Init

makeLayerThread

removeLayerThread

displayCoord

getContentView

getViewSize

shutdown

setupTempContext

clearTempContext

rendererIsAttached

addPostSurfaceRunnable

setDisplayRate

requestRender

setEGLContext

setClearColor

setViewExtents

screenPointFromGeoBatch

geoPointFromScreenBatch

setPerfInterval

heightForMapScale

currentMapZoom

currentMapScale

addLayer

removeLayer

findSamplingLayer

releaseSamplingLayer

addTileFetcher

addTask

addVector

addVectors

instanceVectors

changeVector

addWideVectors

addWideVector

instanceWideVectors

addLoftedPoly

addLoftedPolys

addScreenMarker

addScreenMarkers

addScreenMovingMarkers

addMarker

addMarkers

addStickers

changeSticker

addPoints

addPoints

geoPointFromScreen

screenPointFromGeo