RenderController

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

All Implemented Interfaces:

RenderControllerInterface
```
public class RenderController
extends java.lang.Object
implements RenderControllerInterface
```
The Render Controller handles the object manipulation and rendering interface. It can be a standalone object, doing offline rendering or it can be attached to a BaseController and used to manage that controller's rendering.

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`static class`	`RenderController.ImageFormat` Enumerated values for image types.
`static interface`	`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.

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
`protected BillboardManager`	`billboardManager`
`protected ComponentManager`	`componentManager`
`javax.microedition.khronos.egl.EGLConfig`	`config`
`javax.microedition.khronos.egl.EGLContext`	`context`
`com.mousebird.maply.CoordSystemDisplayAdapter`	`coordAdapter`
`javax.microedition.khronos.egl.EGLDisplay`	`display`
`boolean`	`disposeAfterRemoval` If set, we'll explicitly call dispose on any objects that were being kept around for selection.
`static long`	`EmptyIdentity`
`static int`	`FeatureDrawPriorityBase`
`protected GeometryManager`	`geomManager`
`static int`	`ImageLayerDrawPriorityDefault`
`static java.lang.String`	`kToolkitDefaultTriangleNoLightingProgram`
`static int`	`LabelDrawPriorityDefault`
`protected com.mousebird.maply.LabelManager`	`labelManager`
`protected com.mousebird.maply.LayoutLayer`	`layoutLayer`
`protected com.mousebird.maply.LayoutManager`	`layoutManager`
`protected com.mousebird.maply.LoftedPolyManager`	`loftManager`
`static int`	`MarkerDrawPriorityDefault`
`protected com.mousebird.maply.MarkerManager`	`markerManager`
`protected boolean`	`offlineMode`
`static int`	`ParticleDrawPriorityDefault`
`protected ParticleSystemManager`	`particleSystemManager`
`Scene`	`scene`
`protected com.mousebird.maply.SelectionManager`	`selectionManager`
`protected ShapeManager`	`shapeManager`
`protected StickerManager`	`stickerManager`
`protected com.mousebird.maply.VectorManager`	`vecManager`
`protected WideVectorManager`	`wideVecManager`

Constructor Summary

Constructors
Constructor and Description
`RenderController(int width, int height)` This constructor sets up its own render target.
`RenderController(RenderController baseControl, int width, int height)`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`boolean`	`activeObjectsHaveChanges()` Check if any of the active objects have changes for the next frame.
`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`	`addLight(com.mousebird.maply.DirectionalLight light)`
`void`	`addLight(Light light)` Add the given light to the list of active lights.
`ComponentObject`	`addLoftedPolys(java.util.List<VectorObject> vecs, LoftedPolyInfo loftInfo, RenderControllerInterface.ThreadMode mode)` Add Lofted Polygons to the MaplyController to display.
`ComponentObject`	`addMarkers(java.util.List<Marker> markers, MarkerInfo markerInfo, RenderControllerInterface.ThreadMode mode)` Add screen markers to the visual display.
`ComponentObject`	`addPoints(java.util.List<Points> ptList, GeometryInfo geomInfo, RenderControllerInterface.ThreadMode mode)` Add the geometry points.
`protected void`	`addPreBuiltShader(Shader shader)` In the render controller setup, we stand up the full set of default shaders used by the system.
`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`	`addScreenLabels(java.util.List<ScreenLabel> labels, LabelInfo labelInfo, RenderControllerInterface.ThreadMode mode)` Add screen labels to the display.
`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.
`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.
`ComponentObject`	`addVectors(java.util.List<VectorObject> vecs, VectorInfo vecInfo, RenderControllerInterface.ThreadMode mode)` Add 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`	`clearContext()` In offline render mode, clear the context Only do this if you're working in offline mode
`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()`
`double`	`currentMapZoom(Point2d geoCoord)`
`void`	`disableObjects(java.util.List<ComponentObject> compObjs, RenderControllerInterface.ThreadMode mode)` Disable the given objects.
`void`	`doRender()`
`void`	`enableObjects(ComponentObject[] compObjs, RenderControllerInterface.ThreadMode mode)` Enable the display for the given objects.
`void`	`enableObjects(java.util.List<ComponentObject> compObjs, RenderControllerInterface.ThreadMode mode)` Enable the display for the given objects.
`void`	`finalize()`
`CoordSystem`	`getCoordSystem()` Return the current coordinate system.
`static RenderControllerInterface.ContextInfo`	`getEGLContext()`
`int[]`	`getFrameBufferSize()` Returns the framebuffer size as ints.
`boolean`	`getOfflineMode()` If true, the renderer was set up as offline.
`Scene`	`getScene()` Return the current scene.
`Shader`	`getShader(java.lang.String name)` Find a shader by name
`protected boolean`	`hasChanges()`
`double`	`heightForMapScale(double scale)`
`void`	`Init(Scene inScene, com.mousebird.maply.CoordSystemDisplayAdapter inCoordAdapter, RenderController.TaskManager inTaskMan)`
`ComponentObject`	`instanceVectors(ComponentObject vecObj, 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.
`void`	`processChangeSet(ChangeSet changes)`
`void`	`removeActiveObject(ActiveObject activeObject)` Remove an active object added 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 simple object from the display.
`void`	`removeObjects(ComponentObject[] compObjs, RenderControllerInterface.ThreadMode mode)` Remove the given component 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)` Remove the given shader from active use.
`void`	`removeTexture(MaplyTexture tex, RenderControllerInterface.ThreadMode mode)`
`void`	`removeTextures(java.util.List<MaplyTexture> texs, RenderControllerInterface.ThreadMode mode)` Remove a texture from the scene.
`void`	`removeTexturesByID(java.util.List<java.lang.Long> texIDs, RenderControllerInterface.ThreadMode mode)` This version of removeTexture takes texture IDs.
`protected void`	`render()`
`android.graphics.Bitmap`	`renderToBitmap()` Render to and return a Bitmap You should have already set the context at this point
`protected void`	`renderToBitmapNative(android.graphics.Bitmap outBitmap)`
`void`	`replaceLights(com.mousebird.maply.DirectionalLight[] lights)`
`void`	`requestRender()`
`void`	`resetLights()` Reset the lighting back to its default state at startup.
`protected boolean`	`resize(int width, int height)`
`void`	`setClearColor(float r, float g, float b, float a)`
`void`	`setClearColor(int color)` Set the color for the OpenGL ES background.
`void`	`setConfig(RenderController otherControl, javax.microedition.khronos.egl.EGLConfig inConfig)`
`boolean`	`setEGLContext(RenderControllerInterface.ContextInfo cInfo)`
`void`	`setPerfInterval(int perfInterval)`
`void`	`setScene(Scene scene)`
`void`	`setupShadersNative()`
`RenderControllerInterface.ContextInfo`	`setupTempContext(RenderControllerInterface.ThreadMode threadMode)`
`void`	`setView(View inView)`
`void`	`setViewNative(View view)`
`void`	`shutdown()`
`boolean`	`surfaceChanged(int width, int height)`
`protected boolean`	`teardown()`

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

- Field Detail
  - kToolkitDefaultTriangleNoLightingProgram
```
public static final java.lang.String kToolkitDefaultTriangleNoLightingProgram
```
    See Also:
    
    Constant Field Values
  - ImageLayerDrawPriorityDefault
```
public static final int ImageLayerDrawPriorityDefault
```
    See Also:
    
    Constant Field Values
  - FeatureDrawPriorityBase
```
public static final int FeatureDrawPriorityBase
```
    See Also:
    
    Constant Field Values
  - MarkerDrawPriorityDefault
```
public static final int MarkerDrawPriorityDefault
```
    See Also:
    
    Constant Field Values
  - LabelDrawPriorityDefault
```
public static final int LabelDrawPriorityDefault
```
    See Also:
    
    Constant Field Values
  - ParticleDrawPriorityDefault
```
public static final int ParticleDrawPriorityDefault
```
    See Also:
    
    Constant Field Values
  - EmptyIdentity
```
public static long EmptyIdentity
```
  - disposeAfterRemoval
```
public boolean disposeAfterRemoval
```
    If set, we'll explicitly call dispose on any objects that were being kept around for selection.
  - scene
```
public Scene scene
```
  - coordAdapter
```
public com.mousebird.maply.CoordSystemDisplayAdapter coordAdapter
```
  - offlineMode
```
protected boolean offlineMode
```
  - display
```
public javax.microedition.khronos.egl.EGLDisplay display
```
  - config
```
public javax.microedition.khronos.egl.EGLConfig config
```
  - context
```
public javax.microedition.khronos.egl.EGLContext context
```
  - vecManager
```
protected com.mousebird.maply.VectorManager vecManager
```
  - loftManager
```
protected com.mousebird.maply.LoftedPolyManager loftManager
```
  - wideVecManager
```
protected WideVectorManager wideVecManager
```
  - markerManager
```
protected com.mousebird.maply.MarkerManager markerManager
```
  - stickerManager
```
protected StickerManager stickerManager
```
  - labelManager
```
protected com.mousebird.maply.LabelManager labelManager
```
  - selectionManager
```
protected com.mousebird.maply.SelectionManager selectionManager
```
  - componentManager
```
protected ComponentManager componentManager
```
  - layoutManager
```
protected com.mousebird.maply.LayoutManager layoutManager
```
  - particleSystemManager
```
protected ParticleSystemManager particleSystemManager
```
  - layoutLayer
```
protected com.mousebird.maply.LayoutLayer layoutLayer
```
  - shapeManager
```
protected ShapeManager shapeManager
```
  - billboardManager
```
protected BillboardManager billboardManager
```
  - geomManager
```
protected GeometryManager geomManager
```
- Constructor Detail
  - RenderController
```
public RenderController(RenderController baseControl,
                        int width,
                        int height)
```
  - RenderController
```
public RenderController(int width,
                        int height)
```
    This constructor sets up its own render target. Used for offline rendering.
- 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
  - getOfflineMode
```
public boolean getOfflineMode()
```
    If true, the renderer was set up as offline.
    
    Specified by:
    
    getOfflineMode in interface RenderControllerInterface
  - Init
```
public void Init(Scene inScene,
                 com.mousebird.maply.CoordSystemDisplayAdapter inCoordAdapter,
                 RenderController.TaskManager inTaskMan)
```
  - setView
```
public void setView(View inView)
```
  - 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.
  - activeObjectsHaveChanges
```
public boolean activeObjectsHaveChanges()
```
    Check if any of the active objects have changes for the next frame.
  - surfaceChanged
```
public boolean surfaceChanged(int width,
                              int height)
```
  - doRender
```
public void doRender()
```
  - setConfig
```
public void setConfig(RenderController otherControl,
                      javax.microedition.khronos.egl.EGLConfig inConfig)
```
  - shutdown
```
public void shutdown()
```
  - 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
  - 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
  - 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.
  - 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.
  - 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.
  - 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.
  - 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.
  - instanceVectors
```
public ComponentObject instanceVectors(ComponentObject vecObj,
                                       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
  - 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.
  - 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.
  - 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.
  - 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.
  - 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
  - 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.
  - 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.
  - 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.
  - 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)
  - removeTextures
```
public void removeTextures(java.util.List<MaplyTexture> texs,
                           RenderControllerInterface.ThreadMode mode)
```
    Remove a texture from the scene.
    
    Specified by:
    
    removeTextures in interface RenderControllerInterface
    
    Parameters:
    
    texs - Textures to remove.
    
    mode - Remove immediately (current thread) or elsewhere.
  - removeTexture
```
public void removeTexture(MaplyTexture tex,
                          RenderControllerInterface.ThreadMode mode)
```
    Specified by:
    
    removeTexture in interface RenderControllerInterface
  - 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
  - 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
  - clearRenderTarget
```
public void clearRenderTarget(RenderTarget renderTarget,
                              RenderControllerInterface.ThreadMode mode)
```
    Ask the render target to clear itself.
  - 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.
  - 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.
  - enableObjects
```
public void enableObjects(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().
    
    Parameters:
    
    compObjs - Objects to enable disable.
    
    mode - Where to execute the enable. Choose ThreadAny by default.
  - 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 remove. Choose ThreadAny by default.
  - removeObjects
```
public void removeObjects(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.
    
    Parameters:
    
    compObjs - Component Objects to remove.
    
    mode - Where to execute the remove. Choose ThreadAny by default.
  - removeObject
```
public void removeObject(ComponentObject compObj,
                         RenderControllerInterface.ThreadMode mode)
```
    Remove a simple object from the display.
    
    Specified by:
    
    removeObject in interface RenderControllerInterface
    
    Parameters:
    
    compObj - Component Object to remove.
    
    mode - Where to execute the remove. Choose ThreadAny by default.
  - 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.
  - addPreBuiltShader
```
protected void addPreBuiltShader(Shader shader)
```
    In the render controller setup, we stand up the full set of default shaders used by the system. To reflect things on this side, we'll add them to this array as well.
  - 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)
```
    Remove the given shader from active use.
    
    Specified by:
    
    removeShader in interface RenderControllerInterface
  - setClearColor
```
public void setClearColor(int color)
```
    Set the color for the OpenGL ES background.
    
    Specified by:
    
    setClearColor in interface RenderControllerInterface
  - heightForMapScale
```
public double heightForMapScale(double scale)
```
    Specified by:
    
    heightForMapScale in interface RenderControllerInterface
  - currentMapZoom
```
public double currentMapZoom(Point2d geoCoord)
```
    Specified by:
    
    currentMapZoom in interface RenderControllerInterface
  - currentMapScale
```
public double currentMapScale()
```
    Specified by:
    
    currentMapScale in interface RenderControllerInterface
  - getFrameBufferSize
```
public int[] getFrameBufferSize()
```
    Returns the framebuffer size as ints.
    
    Specified by:
    
    getFrameBufferSize in interface RenderControllerInterface
  - requestRender
```
public void requestRender()
```
    Specified by:
    
    requestRender in interface RenderControllerInterface
  - setEGLContext
```
public boolean setEGLContext(RenderControllerInterface.ContextInfo cInfo)
```
    Specified by:
    
    setEGLContext in interface RenderControllerInterface
  - getEGLContext
```
public static RenderControllerInterface.ContextInfo getEGLContext()
```
  - processChangeSet
```
public void processChangeSet(ChangeSet changes)
```
    Specified by:
    
    processChangeSet in interface RenderControllerInterface
  - 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
  - clearContext
```
public void clearContext()
```
    In offline render mode, clear the context Only do this if you're working in offline mode
  - renderToBitmap
```
public android.graphics.Bitmap renderToBitmap()
```
    Render to and return a Bitmap You should have already set the context at this point
  - setScene
```
public void setScene(Scene scene)
```
  - setupShadersNative
```
public void setupShadersNative()
```
  - setViewNative
```
public void setViewNative(View view)
```
  - setClearColor
```
public void setClearColor(float r,
                          float g,
                          float b,
                          float a)
```
  - teardown
```
protected boolean teardown()
```
  - resize
```
protected boolean resize(int width,
                         int height)
```
  - render
```
protected void render()
```
  - hasChanges
```
protected boolean hasChanges()
```
  - setPerfInterval
```
public void setPerfInterval(int perfInterval)
```
  - addLight
```
public void addLight(com.mousebird.maply.DirectionalLight light)
```
  - replaceLights
```
public void replaceLights(com.mousebird.maply.DirectionalLight[] lights)
```
  - renderToBitmapNative
```
protected void renderToBitmapNative(android.graphics.Bitmap outBitmap)
```
  - finalize
```
public void finalize()
```
    Overrides:
    
    finalize in class java.lang.Object

Class RenderController

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

kToolkitDefaultTriangleNoLightingProgram

ImageLayerDrawPriorityDefault

FeatureDrawPriorityBase

MarkerDrawPriorityDefault

LabelDrawPriorityDefault

ParticleDrawPriorityDefault

EmptyIdentity

disposeAfterRemoval

scene

coordAdapter

offlineMode

display

config

context

vecManager

loftManager

wideVecManager

markerManager

stickerManager

labelManager

selectionManager

componentManager

layoutManager

particleSystemManager

layoutLayer

shapeManager

billboardManager

geomManager

Constructor Detail

RenderController

RenderController

Method Detail

getScene

getCoordSystem

getOfflineMode

Init

setView

addActiveObject

addActiveObjectAtStart

removeActiveObject

activeObjectsHaveChanges

surfaceChanged

doRender

setConfig

shutdown

addLight

removeLight

clearLights

resetLights

addScreenMarkers

addScreenMovingMarkers

addMarkers

addScreenLabels

addScreenMovingLabels

addVectors

addLoftedPolys

changeVector

instanceVectors

addWideVectors

instanceWideVectors

addShapes

addStickers

changeSticker

addBillboards

addPoints

addTexture

addTexture

createTexture

removeTextures

removeTexture

removeTexturesByID

addRenderTarget