xiaoyan159/vtm
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

- started to move Matrices to MapViewPosition as these can be shared with

Browse Source 
MapRenderer(TileLoader) and GLRenderer.
- using inverse projection to determine visible tiles and mapping screen-coordinates to model
- making MapPosition not final, reuse instance to get Position in Map-/GLRender

added: ScanBox scanline fill used for calculating visible tiles

rename:
- ShortPool -> VertexPool
- tile.isActive -> isLocked
This commit is contained in:
Hannes Janetzek 2012-09-26 17:02:03 +02:00
parent 8ec405cf5c
commit c5e3be9d2b
26 changed files with 1281 additions and 865 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/org/oscim/app/LocationHandler.java
View File

@ -15,7 +15,7 @@
package org.oscim.app;
import org.oscim.core.GeoPoint;
import org.oscim.core.MapPosition;
import org.oscim.view.MapPosition;
import android.content.Context;
import android.location.Criteria;

2
src/org/oscim/app/TileMap.java
View File

@ -9,12 +9,12 @@ import org.oscim.app.filefilter.ValidRenderTheme;
import org.oscim.app.filepicker.FilePicker;
import org.oscim.app.preferences.EditPreferences;
import org.oscim.core.GeoPoint;
import org.oscim.core.MapPosition;
import org.oscim.database.MapDatabases;
import org.oscim.theme.InternalRenderTheme;
import org.oscim.utils.AndroidUtils;
import org.oscim.view.DebugSettings;
import org.oscim.view.MapActivity;
import org.oscim.view.MapPosition;
import org.oscim.view.MapView;
import android.annotation.TargetApi;

2
src/org/oscim/core/MercatorProjection.java
View File

@ -14,6 +14,8 @@
*/
package org.oscim.core;
import org.oscim.view.MapPosition;
/**
* An implementation of the spherical Mercator projection.
*/

3
src/org/oscim/core/Tag.java
View File

@ -17,6 +17,9 @@ package org.oscim.core;
/**
* A tag represents an immutable key-value pair.
*/
// TODO: use own stringshare method instead of internalized strings
public class Tag {
private static final char KEY_VALUE_SEPARATOR = '=';
/**

4
src/org/oscim/database/oscimap/MapDatabase.java
View File

@ -65,8 +65,8 @@ public class MapDatabase implements IMapDatabase {
private static final String CACHE_FILE = "%d-%d-%d.tile";
private static final String SERVER_ADDR = "city.informatik.uni-bremen.de";
// private static final String URL = "/osci/map-live/";
private static final String URL = "/osci/oscim/";
private static final String URL = "/osci/map-live/";
// private static final String URL = "/osci/oscim/";
private final static float REF_TILE_SIZE = 4096.0f;

431
src/org/oscim/utils/GLSurfaceView.java
View File

@ -1,17 +1,3 @@
/*
* Copyright 2010, 2011, 2012 mapsforge.org
*
* This program is free software: you can redistribute it and/or modify it under the
* terms of the GNU Lesser General Public License as published by the Free Software
* Foundation, either version 3 of the License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful, but WITHOUT ANY
* WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
* PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License along with
* this program. If not, see <http://www.gnu.org/licenses/>.
*/
package org.oscim.utils;
/*
@ -53,17 +39,21 @@ import android.view.SurfaceHolder;
import android.view.SurfaceView;
/**
* An implementation of SurfaceView that uses the dedicated surface for displaying OpenGL rendering.
* An implementation of SurfaceView that uses the dedicated surface for
* displaying OpenGL rendering.
* <p>
* A GLSurfaceView provides the following features:
* <p>
* <ul>
* <li>Manages a surface, which is a special piece of memory that can be composited into the Android view system.
* <li>Manages a surface, which is a special piece of memory that can be
* composited into the Android view system.
* <li>Manages an EGL display, which enables OpenGL to render into a surface.
* <li>Accepts a user-provided Renderer object that does the actual rendering.
* <li>Renders on a dedicated thread to decouple rendering performance from the UI thread.
* <li>Renders on a dedicated thread to decouple rendering performance from the
* UI thread.
* <li>Supports both on-demand and continuous rendering.
* <li>Optionally wraps, traces, and/or error-checks the renderer's OpenGL calls.
* <li>Optionally wraps, traces, and/or error-checks the renderer's OpenGL
* calls.
* </ul>
* <div class="special reference">
* <h3>Developer Guides</h3>
@ -73,15 +63,18 @@ import android.view.SurfaceView;
* </p>
* </div> <h3>Using GLSurfaceView</h3>
* <p>
* Typically you use GLSurfaceView by subclassing it and overriding one or more of the View system input event methods.
* If your application does not need to override event methods then GLSurfaceView can be used as-is. For the most part
* GLSurfaceView behavior is customized by calling "set" methods rather than by subclassing. For example, unlike a
* regular View, drawing is delegated to a separate Renderer object which is registered with the GLSurfaceView using the
* {@link #setRenderer(Renderer)} call.
* Typically you use GLSurfaceView by subclassing it and overriding one or more
* of the View system input event methods. If your application does not need to
* override event methods then GLSurfaceView can be used as-is. For the most
* part GLSurfaceView behavior is customized by calling "set" methods rather
* than by subclassing. For example, unlike a regular View, drawing is delegated
* to a separate Renderer object which is registered with the GLSurfaceView
* using the {@link #setRenderer(Renderer)} call.
* <p>
* <h3>Initializing GLSurfaceView</h3> All you have to do to initialize a GLSurfaceView is call
* {@link #setRenderer(Renderer)}. However, if desired, you can modify the default behavior of GLSurfaceView by calling
* one or more of these methods before calling setRenderer:
* <h3>Initializing GLSurfaceView</h3> All you have to do to initialize a
* GLSurfaceView is call {@link #setRenderer(Renderer)}. However, if desired,
* you can modify the default behavior of GLSurfaceView by calling one or more
* of these methods before calling setRenderer:
* <ul>
* <li>{@link #setDebugFlags(int)}
* <li>{@link #setEGLConfigChooser(boolean)}
@ -90,43 +83,54 @@ import android.view.SurfaceView;
* <li>{@link #setGLWrapper(GLWrapper)}
* </ul>
* <p>
* <h4>Specifying the android.view.Surface</h4> By default GLSurfaceView will create a PixelFormat.RGB_565 format
* surface. If a translucent surface is required, call getHolder().setFormat(PixelFormat.TRANSLUCENT). The exact format
* of a TRANSLUCENT surface is device dependent, but it will be a 32-bit-per-pixel surface with 8 bits per component.
* <h4>Specifying the android.view.Surface</h4> By default GLSurfaceView will
* create a PixelFormat.RGB_565 format surface. If a translucent surface is
* required, call getHolder().setFormat(PixelFormat.TRANSLUCENT). The exact
* format of a TRANSLUCENT surface is device dependent, but it will be a
* 32-bit-per-pixel surface with 8 bits per component.
* <p>
* <h4>Choosing an EGL Configuration</h4> A given Android device may support multiple EGLConfig rendering
* configurations. The available configurations may differ in how may channels of data are present, as well as how many
* bits are allocated to each channel. Therefore, the first thing GLSurfaceView has to do when starting to render is
* choose what EGLConfig to use.
* <h4>Choosing an EGL Configuration</h4> A given Android device may support
* multiple EGLConfig rendering configurations. The available configurations may
* differ in how may channels of data are present, as well as how many bits are
* allocated to each channel. Therefore, the first thing GLSurfaceView has to do
* when starting to render is choose what EGLConfig to use.
* <p>
* By default GLSurfaceView chooses a EGLConfig that has an RGB_565 pixel format, with at least a 16-bit depth buffer
* and no stencil.
* By default GLSurfaceView chooses a EGLConfig that has an RGB_565 pixel
* format, with at least a 16-bit depth buffer and no stencil.
* <p>
* If you would prefer a different EGLConfig you can override the default behavior by calling one of the
* setEGLConfigChooser methods.
* If you would prefer a different EGLConfig you can override the default
* behavior by calling one of the setEGLConfigChooser methods.
* <p>
* <h4>Debug Behavior</h4> You can optionally modify the behavior of GLSurfaceView by calling one or more of the
* debugging methods {@link #setDebugFlags(int)}, and {@link #setGLWrapper}. These methods may be called before and/or
* after setRenderer, but typically they are called before setRenderer so that they take effect immediately.
* <h4>Debug Behavior</h4> You can optionally modify the behavior of
* GLSurfaceView by calling one or more of the debugging methods
* {@link #setDebugFlags(int)}, and {@link #setGLWrapper}. These methods may be
* called before and/or after setRenderer, but typically they are called before
* setRenderer so that they take effect immediately.
* <p>
* <h4>Setting a Renderer</h4> Finally, you must call {@link #setRenderer} to register a {@link Renderer}. The renderer
* is responsible for doing the actual OpenGL rendering.
* <h4>Setting a Renderer</h4> Finally, you must call {@link #setRenderer} to
* register a {@link Renderer}. The renderer is responsible for doing the actual
* OpenGL rendering.
* <p>
* <h3>Rendering Mode</h3> Once the renderer is set, you can control whether the renderer draws continuously or
* on-demand by calling {@link #setRenderMode}. The default is continuous rendering.
* <h3>Rendering Mode</h3> Once the renderer is set, you can control whether the
* renderer draws continuously or on-demand by calling {@link #setRenderMode}.
* The default is continuous rendering.
* <p>
* <h3>Activity Life-cycle</h3> A GLSurfaceView must be notified when the activity is paused and resumed. GLSurfaceView
* clients are required to call {@link #onPause()} when the activity pauses and {@link #onResume()} when the activity
* resumes. These calls allow GLSurfaceView to pause and resume the rendering thread, and also allow GLSurfaceView to
* release and recreate the OpenGL display.
* <h3>Activity Life-cycle</h3> A GLSurfaceView must be notified when the
* activity is paused and resumed. GLSurfaceView clients are required to call
* {@link #onPause()} when the activity pauses and {@link #onResume()} when the
* activity resumes. These calls allow GLSurfaceView to pause and resume the
* rendering thread, and also allow GLSurfaceView to release and recreate the
* OpenGL display.
* <p>
* <h3>Handling events</h3>
* <p>
* To handle an event you will typically subclass GLSurfaceView and override the appropriate method, just as you would
* with any other View. However, when handling the event, you may need to communicate with the Renderer object that's
* running in the rendering thread. You can do this using any standard Java cross-thread communication mechanism. In
* addition, one relatively easy way to communicate with your renderer is to call {@link #queueEvent(Runnable)}. For
* example:
* To handle an event you will typically subclass GLSurfaceView and override the
* appropriate method, just as you would with any other View. However, when
* handling the event, you may need to communicate with the Renderer object
* that's running in the rendering thread. You can do this using any standard
* Java cross-thread communication mechanism. In addition, one relatively easy
* way to communicate with your renderer is to call
* {@link #queueEvent(Runnable)}. For example:
*
* <pre class="prettyprint">
* class MyGLSurfaceView extends GLSurfaceView {
@ -154,9 +158,6 @@ import android.view.SurfaceView;
* }
*
*
*
*
*
* </pre>
*/
public class GLSurfaceView extends SurfaceView implements SurfaceHolder.Callback {
@ -169,7 +170,8 @@ public class GLSurfaceView extends SurfaceView implements SurfaceHolder.Callback
private final static boolean LOG_RENDERER_DRAW_FRAME = false;
private final static boolean LOG_EGL = false;
/**
* The renderer only renders when the surface is created, or when {@link #requestRender} is called.
* The renderer only renders when the surface is created, or when
* {@link #requestRender} is called.
*
* @see #getRenderMode()
* @see #setRenderMode(int)
@ -185,8 +187,9 @@ public class GLSurfaceView extends SurfaceView implements SurfaceHolder.Callback
public final static int RENDERMODE_CONTINUOUSLY = 1;
/**
* Check glError() after every GL call and throw an exception if glError indicates that an error has occurred. This
* can be used to help track down which OpenGL ES call is causing an error.
* Check glError() after every GL call and throw an exception if glError
* indicates that an error has occurred. This can be used to help track down
* which OpenGL ES call is causing an error.
*
* @see #getDebugFlags
* @see #setDebugFlags
@ -194,7 +197,8 @@ public class GLSurfaceView extends SurfaceView implements SurfaceHolder.Callback
public final static int DEBUG_CHECK_GL_ERROR = 1;
/**
* Log GL calls to the system log at "verbose" level with tag "GLSurfaceView".
* Log GL calls to the system log at "verbose" level with tag
* "GLSurfaceView".
*
* @see #getDebugFlags
* @see #setDebugFlags
@ -202,8 +206,11 @@ public class GLSurfaceView extends SurfaceView implements SurfaceHolder.Callback
public final static int DEBUG_LOG_GL_CALLS = 2;
/**
* Standard View constructor. In order to render something, you must call {@link #setRenderer} to register a
* renderer.
* Standard View constructor. In order to render something, you must call
* {@link #setRenderer} to register a renderer.
*
* @param context
* ...
*/
public GLSurfaceView(Context context) {
super(context);
@ -211,8 +218,13 @@ public class GLSurfaceView extends SurfaceView implements SurfaceHolder.Callback
}
/**
* Standard View constructor. In order to render something, you must call {@link #setRenderer} to register a
* renderer.
* Standard View constructor. In order to render something, you must call
* {@link #setRenderer} to register a renderer.
*
* @param context
* ....
* @param attrs
* ...
*/
public GLSurfaceView(Context context, AttributeSet attrs) {
super(context, attrs);
@ -247,9 +259,11 @@ public class GLSurfaceView extends SurfaceView implements SurfaceHolder.Callback
}
/**
* Set the glWrapper. If the glWrapper is not null, its {@link GLWrapper#wrap(GL)} method is called whenever a
* surface is created. A GLWrapper can be used to wrap the GL object that's passed to the renderer. Wrapping a GL
* object enables examining and modifying the behavior of the GL calls made by the renderer.
* Set the glWrapper. If the glWrapper is not null, its
* {@link GLWrapper#wrap(GL)} method is called whenever a surface is
* created. A GLWrapper can be used to wrap the GL object that's passed to
* the renderer. Wrapping a GL object enables examining and modifying the
* behavior of the GL calls made by the renderer.
* <p>
* Wrapping is typically used for debugging purposes.
* <p>
@ -263,8 +277,9 @@ public class GLSurfaceView extends SurfaceView implements SurfaceHolder.Callback
}
/**
* Set the debug flags to a new value. The value is constructed by OR-together zero or more of the DEBUG_CHECK_*
* constants. The debug flags take effect whenever a surface is created. The default value is zero.
* Set the debug flags to a new value. The value is constructed by
* OR-together zero or more of the DEBUG_CHECK_* constants. The debug flags
* take effect whenever a surface is created. The default value is zero.
*
* @param debugFlags
* the new debug flags
@ -285,15 +300,18 @@ public class GLSurfaceView extends SurfaceView implements SurfaceHolder.Callback
}
/**
* Control whether the EGL context is preserved when the GLSurfaceView is paused and resumed.
* Control whether the EGL context is preserved when the GLSurfaceView is
* paused and resumed.
* <p>
* If set to true, then the EGL context may be preserved when the GLSurfaceView is paused. Whether the EGL context
* is actually preserved or not depends upon whether the Android device that the program is running on can support
* an arbitrary number of EGL contexts or not. Devices that can only support a limited number of EGL contexts must
* release the EGL context in order to allow multiple applications to share the GPU.
* If set to true, then the EGL context may be preserved when the
* GLSurfaceView is paused. Whether the EGL context is actually preserved or
* not depends upon whether the Android device that the program is running
* on can support an arbitrary number of EGL contexts or not. Devices that
* can only support a limited number of EGL contexts must release the EGL
* context in order to allow multiple applications to share the GPU.
* <p>
* If set to false, the EGL context will be released when the GLSurfaceView is paused, and recreated when the
* GLSurfaceView is resumed.
* If set to false, the EGL context will be released when the GLSurfaceView
* is paused, and recreated when the GLSurfaceView is resumed.
* <p>
* The default is false.
*
@ -312,19 +330,22 @@ public class GLSurfaceView extends SurfaceView implements SurfaceHolder.Callback
}
/**
* Set the renderer associated with this view. Also starts the thread that will call the renderer, which in turn
* causes the rendering to start.
* Set the renderer associated with this view. Also starts the thread that
* will call the renderer, which in turn causes the rendering to start.
* <p>
* This method should be called once and only once in the life-cycle of a GLSurfaceView.
* This method should be called once and only once in the life-cycle of a
* GLSurfaceView.
* <p>
* The following GLSurfaceView methods can only be called <em>before</em> setRenderer is called:
* The following GLSurfaceView methods can only be called <em>before</em>
* setRenderer is called:
* <ul>
* <li>{@link #setEGLConfigChooser(boolean)}
* <li>{@link #setEGLConfigChooser(EGLConfigChooser)}
* <li>{@link #setEGLConfigChooser(int, int, int, int, int, int)}
* </ul>
* <p>
* The following GLSurfaceView methods can only be called <em>after</em> setRenderer is called:
* The following GLSurfaceView methods can only be called <em>after</em>
* setRenderer is called:
* <ul>
* <li>{@link #getRenderMode()}
* <li>{@link #onPause()}
@ -356,10 +377,11 @@ public class GLSurfaceView extends SurfaceView implements SurfaceHolder.Callback
/**
* Install a custom EGLContextFactory.
* <p>
* If this method is called, it must be called before {@link #setRenderer(Renderer)} is called.
* If this method is called, it must be called before
* {@link #setRenderer(Renderer)} is called.
* <p>
* If this method is not called, then by default a context will be created with no shared context and with a null
* attribute list.
* If this method is not called, then by default a context will be created
* with no shared context and with a null attribute list.
*/
public void setEGLContextFactory(EGLContextFactory factory) {
checkRenderThreadState();
@ -369,9 +391,11 @@ public class GLSurfaceView extends SurfaceView implements SurfaceHolder.Callback
/**
* Install a custom EGLWindowSurfaceFactory.
* <p>
* If this method is called, it must be called before {@link #setRenderer(Renderer)} is called.
* If this method is called, it must be called before
* {@link #setRenderer(Renderer)} is called.
* <p>
* If this method is not called, then by default a window surface will be created with a null attribute list.
* If this method is not called, then by default a window surface will be
* created with a null attribute list.
*/
public void setEGLWindowSurfaceFactory(EGLWindowSurfaceFactory factory) {
checkRenderThreadState();
@ -381,10 +405,12 @@ public class GLSurfaceView extends SurfaceView implements SurfaceHolder.Callback
/**
* Install a custom EGLConfigChooser.
* <p>
* If this method is called, it must be called before {@link #setRenderer(Renderer)} is called.
* If this method is called, it must be called before
* {@link #setRenderer(Renderer)} is called.
* <p>
* If no setEGLConfigChooser method is called, then by default the view will choose an EGLConfig that is compatible
* with the current android.view.Surface, with a depth buffer depth of at least 16 bits.
* If no setEGLConfigChooser method is called, then by default the view will
* choose an EGLConfig that is compatible with the current
* android.view.Surface, with a depth buffer depth of at least 16 bits.
*
* @param configChooser
*/
@ -394,13 +420,15 @@ public class GLSurfaceView extends SurfaceView implements SurfaceHolder.Callback
}
/**
* Install a config chooser which will choose a config as close to 16-bit RGB as possible, with or without an
* optional depth buffer as close to 16-bits as possible.
* Install a config chooser which will choose a config as close to 16-bit
* RGB as possible, with or without an optional depth buffer as close to
* 16-bits as possible.
* <p>
* If this method is called, it must be called before {@link #setRenderer(Renderer)} is called.
* If this method is called, it must be called before
* {@link #setRenderer(Renderer)} is called.
* <p>
* If no setEGLConfigChooser method is called, then by default the view will choose an RGB_565 surface with a depth
* buffer depth of at least 16 bits.
* If no setEGLConfigChooser method is called, then by default the view will
* choose an RGB_565 surface with a depth buffer depth of at least 16 bits.
*
* @param needDepth
*/
@ -409,13 +437,15 @@ public class GLSurfaceView extends SurfaceView implements SurfaceHolder.Callback
}
/**
* Install a config chooser which will choose a config with at least the specified depthSize and stencilSize, and
* exactly the specified redSize, greenSize, blueSize and alphaSize.
* Install a config chooser which will choose a config with at least the
* specified depthSize and stencilSize, and exactly the specified redSize,
* greenSize, blueSize and alphaSize.
* <p>
* If this method is called, it must be called before {@link #setRenderer(Renderer)} is called.
* If this method is called, it must be called before
* {@link #setRenderer(Renderer)} is called.
* <p>
* If no setEGLConfigChooser method is called, then by default the view will choose an RGB_565 surface with a depth
* buffer depth of at least 16 bits.
* If no setEGLConfigChooser method is called, then by default the view will
* choose an RGB_565 surface with a depth buffer depth of at least 16 bits.
*/
public void setEGLConfigChooser(int redSize, int greenSize, int blueSize,
int alphaSize, int depthSize, int stencilSize) {
@ -424,7 +454,8 @@ public class GLSurfaceView extends SurfaceView implements SurfaceHolder.Callback
}
/**
* Inform the default EGLContextFactory and default EGLConfigChooser which EGLContext client version to pick.
* Inform the default EGLContextFactory and default EGLConfigChooser which
* EGLContext client version to pick.
* <p>
* Use this method to create an OpenGL ES 2.0-compatible context. Example:
*
@ -436,19 +467,24 @@ public class GLSurfaceView extends SurfaceView implements SurfaceHolder.Callback
* }
* </pre>
* <p>
* Note: Activities which require OpenGL ES 2.0 should indicate this by setting @lt;uses-feature
* android:glEsVersion="0x00020000" /> in the activity's AndroidManifest.xml file.
* Note: Activities which require OpenGL ES 2.0 should indicate this by
* setting @lt;uses-feature android:glEsVersion="0x00020000" /> in the
* activity's AndroidManifest.xml file.
* <p>
* If this method is called, it must be called before {@link #setRenderer(Renderer)} is called.
* If this method is called, it must be called before
* {@link #setRenderer(Renderer)} is called.
* <p>
* This method only affects the behavior of the default EGLContexFactory and the default EGLConfigChooser. If
* {@link #setEGLContextFactory(EGLContextFactory)} has been called, then the supplied EGLContextFactory is
* responsible for creating an OpenGL ES 2.0-compatible context. If {@link #setEGLConfigChooser(EGLConfigChooser)}
* has been called, then the supplied EGLConfigChooser is responsible for choosing an OpenGL ES 2.0-compatible
* config.
* This method only affects the behavior of the default EGLContexFactory and
* the default EGLConfigChooser. If
* {@link #setEGLContextFactory(EGLContextFactory)} has been called, then
* the supplied EGLContextFactory is responsible for creating an OpenGL ES
* 2.0-compatible context. If {@link #setEGLConfigChooser(EGLConfigChooser)}
* has been called, then the supplied EGLConfigChooser is responsible for
* choosing an OpenGL ES 2.0-compatible config.
*
* @param version
* The EGLContext client version to choose. Use 2 for OpenGL ES 2.0
* The EGLContext client version to choose. Use 2 for OpenGL ES
* 2.0
*/
public void setEGLContextClientVersion(int version) {
checkRenderThreadState();
@ -456,12 +492,15 @@ public class GLSurfaceView extends SurfaceView implements SurfaceHolder.Callback
}
/**
* Set the rendering mode. When renderMode is RENDERMODE_CONTINUOUSLY, the renderer is called repeatedly to
* re-render the scene. When renderMode is RENDERMODE_WHEN_DIRTY, the renderer only rendered when the surface is
* created, or when {@link #requestRender} is called. Defaults to RENDERMODE_CONTINUOUSLY.
* Set the rendering mode. When renderMode is RENDERMODE_CONTINUOUSLY, the
* renderer is called repeatedly to re-render the scene. When renderMode is
* RENDERMODE_WHEN_DIRTY, the renderer only rendered when the surface is
* created, or when {@link #requestRender} is called. Defaults to
* RENDERMODE_CONTINUOUSLY.
* <p>
* Using RENDERMODE_WHEN_DIRTY can improve battery life and overall system performance by allowing the GPU and CPU
* to idle when the view does not need to be updated.
* Using RENDERMODE_WHEN_DIRTY can improve battery life and overall system
* performance by allowing the GPU and CPU to idle when the view does not
* need to be updated.
* <p>
* This method can only be called after {@link #setRenderer(Renderer)}
*
@ -475,7 +514,8 @@ public class GLSurfaceView extends SurfaceView implements SurfaceHolder.Callback
}
/**
* Get the current rendering mode. May be called from any thread. Must not be called before a renderer has been set.
* Get the current rendering mode. May be called from any thread. Must not
* be called before a renderer has been set.
*
* @return the current rendering mode.
* @see #RENDERMODE_CONTINUOUSLY
@ -486,25 +526,26 @@ public class GLSurfaceView extends SurfaceView implements SurfaceHolder.Callback
}
/**
* Request that the renderer render a frame. This method is typically used when the render mode has been set to
* {@link #RENDERMODE_WHEN_DIRTY}, so that frames are only rendered on demand. May be called from any thread. Must
* not be called before a renderer has been set.
* Request that the renderer render a frame. This method is typically used
* when the render mode has been set to {@link #RENDERMODE_WHEN_DIRTY}, so
* that frames are only rendered on demand. May be called from any thread.
* Must not be called before a renderer has been set.
*/
public void requestRender() {
mGLThread.requestRender();
}
/**
* This method is part of the SurfaceHolder.Callback interface, and is not normally called or subclassed by clients
* of GLSurfaceView.
* This method is part of the SurfaceHolder.Callback interface, and is not
* normally called or subclassed by clients of GLSurfaceView.
*/
public void surfaceCreated(SurfaceHolder holder) {
mGLThread.surfaceCreated();
}
/**
* This method is part of the SurfaceHolder.Callback interface, and is not normally called or subclassed by clients
* of GLSurfaceView.
* This method is part of the SurfaceHolder.Callback interface, and is not
* normally called or subclassed by clients of GLSurfaceView.
*/
public void surfaceDestroyed(SurfaceHolder holder) {
// Surface will be destroyed when we return
@ -512,33 +553,37 @@ public class GLSurfaceView extends SurfaceView implements SurfaceHolder.Callback
}
/**
* This method is part of the SurfaceHolder.Callback interface, and is not normally called or subclassed by clients
* of GLSurfaceView.
* This method is part of the SurfaceHolder.Callback interface, and is not
* normally called or subclassed by clients of GLSurfaceView.
*/
public void surfaceChanged(SurfaceHolder holder, int format, int w, int h) {
mGLThread.onWindowResize(w, h);
}
/**
* Inform the view that the activity is paused. The owner of this view must call this method when the activity is
* paused. Calling this method will pause the rendering thread. Must not be called before a renderer has been set.
* Inform the view that the activity is paused. The owner of this view must
* call this method when the activity is paused. Calling this method will
* pause the rendering thread. Must not be called before a renderer has been
* set.
*/
public void onPause() {
mGLThread.onPause();
}
/**
* Inform the view that the activity is resumed. The owner of this view must call this method when the activity is
* resumed. Calling this method will recreate the OpenGL display and resume the rendering thread. Must not be called
* before a renderer has been set.
* Inform the view that the activity is resumed. The owner of this view must
* call this method when the activity is resumed. Calling this method will
* recreate the OpenGL display and resume the rendering thread. Must not be
* called before a renderer has been set.
*/
public void onResume() {
mGLThread.onResume();
}
/**
* Queue a runnable to be run on the GL rendering thread. This can be used to communicate with the Renderer on the
* rendering thread. Must not be called before a renderer has been set.
* Queue a runnable to be run on the GL rendering thread. This can be used
* to communicate with the Renderer on the rendering thread. Must not be
* called before a renderer has been set.
*
* @param r
* the runnable to be run on the GL rendering thread.
@ -548,8 +593,8 @@ public class GLSurfaceView extends SurfaceView implements SurfaceHolder.Callback
}
/**
* This method is used as part of the View class and is not normally called or subclassed by clients of
* GLSurfaceView.
* This method is used as part of the View class and is not normally called
* or subclassed by clients of GLSurfaceView.
*/
@Override
protected void onAttachedToWindow() {
@ -572,8 +617,9 @@ public class GLSurfaceView extends SurfaceView implements SurfaceHolder.Callback
}
/**
* This method is used as part of the View class and is not normally called or subclassed by clients of
* GLSurfaceView. Must not be called before a renderer has been set.
* This method is used as part of the View class and is not normally called
* or subclassed by clients of GLSurfaceView. Must not be called before a
* renderer has been set.
*/
@Override
protected void onDetachedFromWindow() {
@ -592,10 +638,12 @@ public class GLSurfaceView extends SurfaceView implements SurfaceHolder.Callback
/**
* An interface used to wrap a GL interface.
* <p>
* Typically used for implementing debugging and tracing on top of the default GL interface. You would typically use
* this by creating your own class that implemented all the GL methods by delegating to another GL instance. Then
* you could add your own behavior before or after calling the delegate. All the GLWrapper would do was instantiate
* and return the wrapper GL instance:
* Typically used for implementing debugging and tracing on top of the
* default GL interface. You would typically use this by creating your own
* class that implemented all the GL methods by delegating to another GL
* instance. Then you could add your own behavior before or after calling
* the delegate. All the GLWrapper would do was instantiate and return the
* wrapper GL instance:
*
* <pre class="prettyprint">
* class MyGLWrapper implements GLWrapper {
@ -616,13 +664,15 @@ public class GLSurfaceView extends SurfaceView implements SurfaceHolder.Callback
*
* @param gl
* a GL interface that is to be wrapped.
* @return either the input argument or another GL object that wraps the input argument.
* @return either the input argument or another GL object that wraps the
* input argument.
*/
GL wrap(GL gl);
}
/**
* An interface for customizing the eglCreateContext and eglDestroyContext calls.
* An interface for customizing the eglCreateContext and eglDestroyContext
* calls.
* <p>
* This interface must be implemented by clients wishing to call
* {@link GLSurfaceView#setEGLContextFactory(EGLContextFactory)}
@ -633,9 +683,10 @@ public class GLSurfaceView extends SurfaceView implements SurfaceHolder.Callback
void destroyContext(EGL10 egl, EGLDisplay display, EGLContext context);
}
private class DefaultContextFactory implements EGLContextFactory {
private final class DefaultContextFactory implements EGLContextFactory {
private int EGL_CONTEXT_CLIENT_VERSION = 0x3098;
@Override
public EGLContext createContext(EGL10 egl, EGLDisplay display, EGLConfig config) {
int[] attrib_list = { EGL_CONTEXT_CLIENT_VERSION, mEGLContextClientVersion,
EGL10.EGL_NONE };
@ -644,6 +695,7 @@ public class GLSurfaceView extends SurfaceView implements SurfaceHolder.Callback
mEGLContextClientVersion != 0 ? attrib_list : null);
}
@Override
public void destroyContext(EGL10 egl, EGLDisplay display,
EGLContext context) {
if (!egl.eglDestroyContext(display, context)) {
@ -659,13 +711,22 @@ public class GLSurfaceView extends SurfaceView implements SurfaceHolder.Callback
}
/**
* An interface for customizing the eglCreateWindowSurface and eglDestroySurface calls.
* An interface for customizing the eglCreateWindowSurface and
* eglDestroySurface calls.
* <p>
* This interface must be implemented by clients wishing to call
* {@link GLSurfaceView#setEGLWindowSurfaceFactory(EGLWindowSurfaceFactory)}
*/
public interface EGLWindowSurfaceFactory {
/**
* @param egl
* ...
* @param display
* ...
* @param config
* ...
* @param nativeWindow
* ...
* @return null if the surface cannot be constructed.
*/
EGLSurface createWindowSurface(EGL10 egl, EGLDisplay display, EGLConfig config,
@ -676,6 +737,7 @@ public class GLSurfaceView extends SurfaceView implements SurfaceHolder.Callback
private static class DefaultWindowSurfaceFactory implements EGLWindowSurfaceFactory {
@Override
public EGLSurface createWindowSurface(EGL10 egl, EGLDisplay display,
EGLConfig config, Object nativeWindow) {
EGLSurface result = null;
@ -683,7 +745,8 @@ public class GLSurfaceView extends SurfaceView implements SurfaceHolder.Callback
result = egl.eglCreateWindowSurface(display, config, nativeWindow, null);
} catch (IllegalArgumentException e) {
// This exception indicates that the surface flinger surface
// is not valid. This can happen if the surface flinger surface has
// is not valid. This can happen if the surface flinger surface
// has
// been torn down, but the application has not yet been
// notified via SurfaceHolder.Callback.surfaceDestroyed.
// In theory the application should be notified first,
@ -693,6 +756,7 @@ public class GLSurfaceView extends SurfaceView implements SurfaceHolder.Callback
return result;
}
@Override
public void destroySurface(EGL10 egl, EGLDisplay display,
EGLSurface surface) {
egl.eglDestroySurface(display, surface);
@ -705,6 +769,7 @@ public class GLSurfaceView extends SurfaceView implements SurfaceHolder.Callback
mConfigSpec = filterConfigSpec(configSpec);
}
@Override
public EGLConfig chooseConfig(EGL10 egl, EGLDisplay display) {
int[] num_config = new int[1];
if (!egl.eglChooseConfig(display, mConfigSpec, null, 0,
@ -741,7 +806,8 @@ public class GLSurfaceView extends SurfaceView implements SurfaceHolder.Callback
return configSpec;
}
/*
* We know none of the subclasses define EGL_RENDERABLE_TYPE. And we know the configSpec is well formed.
* We know none of the subclasses define EGL_RENDERABLE_TYPE. And we
* know the configSpec is well formed.
*/
int len = configSpec.length;
int[] newConfigSpec = new int[len + 2];
@ -754,8 +820,8 @@ public class GLSurfaceView extends SurfaceView implements SurfaceHolder.Callback
}
/**
* Choose a configuration with exactly the specified r,g,b,a sizes, and at least the specified depth and stencil
* sizes.
* Choose a configuration with exactly the specified r,g,b,a sizes, and at
* least the specified depth and stencil sizes.
*/
private class ComponentSizeChooser extends BaseConfigChooser {
public ComponentSizeChooser(int redSize, int greenSize, int blueSize,
@ -842,8 +908,6 @@ public class GLSurfaceView extends SurfaceView implements SurfaceHolder.Callback
/**
* Initialize EGL for a given configuration spec.
*
* @param configSpec
*/
public void start() {
if (LOG_EGL) {
@ -878,8 +942,8 @@ public class GLSurfaceView extends SurfaceView implements SurfaceHolder.Callback
mEglConfig = view.mEGLConfigChooser.chooseConfig(mEgl, mEglDisplay);
/*
* Create an EGL context. We want to do this as rarely as we can, because an EGL context is a somewhat
* heavy object.
* Create an EGL context. We want to do this as rarely as we
* can, because an EGL context is a somewhat heavy object.
*/
mEglContext = view.mEGLContextFactory.createContext(mEgl, mEglDisplay,
mEglConfig);
@ -897,8 +961,8 @@ public class GLSurfaceView extends SurfaceView implements SurfaceHolder.Callback
}
/**
* Create an egl surface for the current SurfaceHolder surface. If a surface already exists, destroy it before
* creating the new surface.
* Create an egl surface for the current SurfaceHolder surface. If a
* surface already exists, destroy it before creating the new surface.
*
* @return true if the surface was created successfully.
*/
@ -946,12 +1010,13 @@ public class GLSurfaceView extends SurfaceView implements SurfaceHolder.Callback
}
/*
* Before we can issue GL commands, we need to make sure the context is current and bound to a surface.
* Before we can issue GL commands, we need to make sure the context
* is current and bound to a surface.
*/
if (!mEgl.eglMakeCurrent(mEglDisplay, mEglSurface, mEglSurface, mEglContext)) {
/*
* Could not make the context current, probably because the underlying SurfaceView surface has been
* destroyed.
* Could not make the context current, probably because the
* underlying SurfaceView surface has been destroyed.
*/
logEglErrorAsWarning("EGLHelper", "eglMakeCurrent", mEgl.eglGetError());
return false;
@ -963,7 +1028,7 @@ public class GLSurfaceView extends SurfaceView implements SurfaceHolder.Callback
/**
* Create a GL object for the current EGL context.
*
* @return
* @return ...
*/
GL createGL() {
@ -1060,7 +1125,8 @@ public class GLSurfaceView extends SurfaceView implements SurfaceHolder.Callback
}
public static String formatEglError(String function, int error) {
return function + " failed: "; // + EGLLogWrapper.getErrorString(error);
return function + " failed: "; // +
// EGLLogWrapper.getErrorString(error);
}
private WeakReference<GLSurfaceView> mGLSurfaceViewWeakRef;
@ -1073,9 +1139,11 @@ public class GLSurfaceView extends SurfaceView implements SurfaceHolder.Callback
}
/**
* A generic GL Thread. Takes care of initializing EGL and GL. Delegates to a Renderer instance to do the actual
* drawing. Can be configured to render continuously or on request. All potentially blocking synchronization is done
* through the sGLThreadManager object. This avoids multiple-lock ordering issues.
* A generic GL Thread. Takes care of initializing EGL and GL. Delegates to
* a Renderer instance to do the actual drawing. Can be configured to render
* continuously or on request. All potentially blocking synchronization is
* done through the sGLThreadManager object. This avoids multiple-lock
* ordering issues.
*/
static class GLThread extends Thread {
GLThread(WeakReference<GLSurfaceView> glSurfaceViewWeakRef) {
@ -1104,7 +1172,8 @@ public class GLSurfaceView extends SurfaceView implements SurfaceHolder.Callback
}
/*
* This private method should only be called inside a synchronized(sGLThreadManager) block.
* This private method should only be called inside a
* synchronized(sGLThreadManager) block.
*/
private void stopEglSurfaceLocked() {
if (mHaveEglSurface) {
@ -1114,7 +1183,8 @@ public class GLSurfaceView extends SurfaceView implements SurfaceHolder.Callback
}
/*
* This private method should only be called inside a synchronized(sGLThreadManager) block.
* This private method should only be called inside a
* synchronized(sGLThreadManager) block.
*/
private void stopEglContextLocked() {
if (mHaveEglContext) {
@ -1265,7 +1335,8 @@ public class GLSurfaceView extends SurfaceView implements SurfaceHolder.Callback
// Ready to draw?
if (readyToDraw()) {
// If we don't have an EGL context, try to acquire one.
// If we don't have an EGL context, try to
// acquire one.
if (!mHaveEglContext) {
if (askedToReleaseEglContext) {
askedToReleaseEglContext = false;
@ -1315,7 +1386,8 @@ public class GLSurfaceView extends SurfaceView implements SurfaceHolder.Callback
}
}
// By design, this is the only place in a GLThread thread where we wait().
// By design, this is the only place in a GLThread
// thread where we wait().
if (LOG_THREADS) {
Log.i("GLThread", "waiting tid=" + getId()
+ " mHaveEglContext: " + mHaveEglContext
@ -1402,10 +1474,13 @@ public class GLSurfaceView extends SurfaceView implements SurfaceHolder.Callback
lostEglContext = true;
break;
default:
// Other errors typically mean that the current surface is bad,
// probably because the SurfaceView surface has been destroyed,
// Other errors typically mean that the current
// surface is bad,
// probably because the SurfaceView surface has been
// destroyed,
// but we haven't been notified yet.
// Log the error to help developers understand why rendering stopped.
// Log the error to help developers understand why
// rendering stopped.
EglHelper.logEglErrorAsWarning("GLThread", "eglSwapBuffers",
swapError);
@ -1629,8 +1704,9 @@ public class GLSurfaceView extends SurfaceView implements SurfaceHolder.Callback
private EglHelper mEglHelper;
/**
* Set once at thread construction time, nulled out when the parent view is garbage called. This weak reference
* allows the GLSurfaceView to be garbage collected while the GLThread is still alive.
* Set once at thread construction time, nulled out when the parent view
* is garbage called. This weak reference allows the GLSurfaceView to be
* garbage collected while the GLThread is still alive.
*/
private WeakReference<GLSurfaceView> mGLSurfaceViewWeakRef;
@ -1693,8 +1769,9 @@ public class GLSurfaceView extends SurfaceView implements SurfaceHolder.Callback
}
/*
* Tries once to acquire the right to use an EGL context. Does not block. Requires that we are already in the
* sGLThreadManager monitor when this is called.
* Tries once to acquire the right to use an EGL context. Does not
* block. Requires that we are already in the sGLThreadManager monitor
* when this is called.
* @return true if the right to use an EGL context was acquired.
*/
public boolean tryAcquireEglContextLocked(GLThread thread) {
@ -1718,7 +1795,8 @@ public class GLSurfaceView extends SurfaceView implements SurfaceHolder.Callback
}
/*
* Releases the EGL context. Requires that we are already in the sGLThreadManager monitor when this is called.
* Releases the EGL context. Requires that we are already in the
* sGLThreadManager monitor when this is called.
*/
public void releaseEglContextLocked(GLThread thread) {
if (mEglOwner == thread) {
@ -1777,8 +1855,9 @@ public class GLSurfaceView extends SurfaceView implements SurfaceHolder.Callback
}
/**
* This check was required for some pre-Android-3.0 hardware. Android 3.0 provides support for
* hardware-accelerated views, therefore multiple EGL contexts are supported on all Android 3.0+ EGL drivers.
* This check was required for some pre-Android-3.0 hardware. Android
* 3.0 provides support for hardware-accelerated views, therefore
* multiple EGL contexts are supported on all Android 3.0+ EGL drivers.
*/
private boolean mGLESVersionCheckComplete;
private int mGLESVersion;
@ -1791,7 +1870,7 @@ public class GLSurfaceView extends SurfaceView implements SurfaceHolder.Callback
private GLThread mEglOwner;
}
private static final GLThreadManager sGLThreadManager = new GLThreadManager();
/* package */static final GLThreadManager sGLThreadManager = new GLThreadManager();
private final WeakReference<GLSurfaceView> mThisWeakRef =
new WeakReference<GLSurfaceView>(this);

1
src/org/oscim/view/MapActivity.java
View File

@ -17,7 +17,6 @@ package org.oscim.view;
import java.io.FileNotFoundException;
import org.oscim.core.GeoPoint;
import org.oscim.core.MapPosition;
import org.oscim.theme.InternalRenderTheme;
import android.app.Activity;

40
src/org/oscim/core/MapPosition.java → src/org/oscim/view/MapPosition.java
View File

@ -12,34 +12,29 @@
* You should have received a copy of the GNU Lesser General Public License along with
* this program. If not, see <http://www.gnu.org/licenses/>.
*/
package org.oscim.core;
package org.oscim.view;
import org.oscim.core.GeoPoint;
import org.oscim.core.MercatorProjection;
import android.opengl.Matrix;
/**
* A MapPosition represents an immutable pair of {@link GeoPoint} and zoom level.
* A MapPosition Container.
*/
public class MapPosition {
/**
* The map position.
*/
// public final GeoPoint geoPoint;
public final double lon;
public final double lat;
public double lon;
public double lat;
/**
* The zoom level.
*/
public final byte zoomLevel;
public byte zoomLevel;
public float scale;
public float angle;
/**
* 1.0 - 2.0 scale of current zoomlevel
*/
public final float scale;
public double x;
public double y;
public final float angle;
public final double x;
public final double y;
public float[] rotation;
public MapPosition() {
this.zoomLevel = (byte) 1;
@ -51,6 +46,11 @@ public class MapPosition {
this.y = MercatorProjection.latitudeToPixelY(this.lat, zoomLevel);
}
public void init() {
rotation = new float[16];
Matrix.setIdentityM(rotation, 0);
}
/**
* @param geoPoint
* the map position.

1
src/org/oscim/view/MapScaleBar.java
View File

@ -17,7 +17,6 @@ package org.oscim.view;
import java.util.HashMap;
import java.util.Map;
import org.oscim.core.MapPosition;
import org.oscim.core.MercatorProjection;
import android.graphics.Bitmap;

16
src/org/oscim/view/MapView.java
View File

@ -23,7 +23,6 @@ import java.util.Map;
import javax.xml.parsers.ParserConfigurationException;
import org.oscim.core.GeoPoint;
import org.oscim.core.MapPosition;
import org.oscim.core.Tile;
import org.oscim.database.IMapDatabase;
import org.oscim.database.MapDatabaseFactory;
@ -56,9 +55,9 @@ public class MapView extends FrameLayout {
final static String TAG = "MapView";
public final static boolean debugFrameTime = false;
public final static boolean testRegionZoom = false;
private final boolean mDebugDatabase = false;
public static final boolean debugFrameTime = false;
public static final boolean testRegionZoom = false;
private static final boolean debugDatabase = false;
RegionLookup mRegionLookup;
@ -146,7 +145,7 @@ public class MapView extends FrameLayout {
for (int i = 0; i < mNumMapWorkers; i++) {
IMapDatabase mapDatabase;
if (mDebugDatabase) {
if (debugDatabase) {
// mapDatabase = MapDatabaseFactory
// .createMapDatabase(MapDatabases.TEST_READER);
mapDatabase = MapDatabaseFactory
@ -188,7 +187,7 @@ public class MapView extends FrameLayout {
mMapZoomControls = new MapZoomControls(mapActivity, this);
mMapZoomControls.setShowMapZoomControls(true);
// enableRotation = true;
enableRotation = true;
for (MapWorker worker : mMapWorkers)
worker.start();
@ -353,7 +352,7 @@ public class MapView extends FrameLayout {
*/
public void setMapDatabase(MapDatabases mapDatabaseType) {
if (mDebugDatabase)
if (debugDatabase)
return;
TileGenerator tileGenerator;
@ -470,6 +469,9 @@ public class MapView extends FrameLayout {
Log.d(TAG, "onSizeChanged" + width + " " + height);
super.onSizeChanged(width, height, oldWidth, oldHeight);
if (width != 0 && height != 0)
mMapViewPosition.setViewport(width, height);
mapWorkersProceed();
}

236
src/org/oscim/view/MapViewPosition.java
View File

@ -1,5 +1,5 @@
/*
* Copyright 2010, 2011, 2012 mapsforge.org
* Copyright 2010, 2011, 2012 mapsforge.org, 2012 Hannes Janetzek
*
* This program is free software: you can redistribute it and/or modify it under the
* terms of the GNU Lesser General Public License as published by the Free Software
@ -15,36 +15,36 @@
package org.oscim.view;
import org.oscim.core.GeoPoint;
import org.oscim.core.MapPosition;
import org.oscim.core.MercatorProjection;
import org.oscim.utils.FastMath;
import android.opengl.Matrix;
import android.util.FloatMath;
import android.util.Log;
/**
* A MapPosition stores the latitude and longitude coordinate of a MapView
* together with its zoom level.
*/
public class MapViewPosition {
private static final String TAG = "MapViewPosition";
// private static final String TAG = "MapViewPosition";
public final static int MAX_ZOOMLEVEL = 16;
public final static int MAX_ZOOMLEVEL = 17;
private final static float MAX_SCALE = 2.0f;
private final static float MIN_SCALE = 1.0f;
private final static float MAX_ANGLE = 20;
private final MapView mMapView;
private double mLatitude;
private double mLongitude;
private byte mZoomLevel;
// 1.0 - 2.0 scale per level
private float mScale;
private float mRotation;
public float mTilt;
// 2^mZoomLevel * mScale;
private float mMapScale;
// private final static float MAP_SIZE = 1000000;
// private final static float MAP_SIZE2 = 1000000 >> 1;
private float mRotation;
public float mTilt;
MapViewPosition(MapView mapView) {
mMapView = mapView;
@ -58,20 +58,158 @@ public class MapViewPosition {
mMapScale = 1;
}
// private static double latitudeToMapView(double latitude) {
// double sinLatitude = Math.sin(latitude * (Math.PI / 180));
// return (0.5 - Math.log((1 + sinLatitude) / (1 - sinLatitude)) / (4 *
// Math.PI))
// * MAP_SIZE;
// }
//
// public static double longitudeToMapView(double longitude) {
// return (longitude + 180) / 360 * MAP_SIZE;
// }
//
// private static double pixelXToLongitude(double pixelX, byte zoomLevel) {
// return 360 * ((pixelX / ((long) Tile.TILE_SIZE << zoomLevel)) - 0.5);
// }
private float[] mProjMatrix = new float[16];
private float[] mProjMatrixI = new float[16];
private float[] mUnprojMatrix = new float[16];
private float[] mRotateMatrix = new float[16];
private float[] mTmpMatrix = new float[16];
private int mHeight, mWidth;
void setViewport(int width, int height) {
Matrix.frustumM(mProjMatrix, 0, -0.5f * width, 0.5f * width,
-0.5f * height, 0.5f * height, 1, 2);
Matrix.translateM(mProjMatrix, 0, 0, 0, -1);
Matrix.invertM(mProjMatrixI, 0, mProjMatrix, 0);
Matrix.invertM(mUnprojMatrix, 0, mProjMatrix, 0);
Matrix.setIdentityM(mRotateMatrix, 0);
mHeight = height;
mWidth = width;
}
public synchronized boolean getMapPosition(final MapPosition mapPosition,
final float[] coords) {
// if (!isValid())
// return false;
// if (mapPosition.lat == mLatitude
// && mapPosition.lon == mLongitude
// && mapPosition.zoomLevel == mZoomLevel
// && mapPosition.scale == mScale
// && mapPosition.angle == mRotation)
// return false;
mapPosition.lat = mLatitude;
mapPosition.lon = mLongitude;
mapPosition.angle = mRotation;
mapPosition.zoomLevel = mZoomLevel;
mapPosition.scale = mScale;
byte z = mZoomLevel;
mapPosition.x = MercatorProjection.longitudeToPixelX(mLongitude, z);
mapPosition.y = MercatorProjection.latitudeToPixelY(mLatitude, z);
if (mapPosition.rotation != null) {
// updateMatrix();
System.arraycopy(mRotateMatrix, 0, mapPosition.rotation, 0, 16);
}
if (coords == null)
return true;
// if (mapPosition.rotation == null)
// updateMatrix();
// not so sure about this, but works...
float tilt = FloatMath.sin((float) Math.toRadians(mTilt)) * 4;
unproject(-1, 1, tilt, coords, 0); // top-left
unproject(1, 1, tilt, coords, 2); // top-right
unproject(1, -1, -tilt, coords, 4); // bottom-right
unproject(-1, -1, -tilt, coords, 6); // bottom-left
return true;
}
private float[] mv = { 0, 0, 0, 1 };
private float[] mBBoxCoords = new float[8];
private void unproject(float x, float y, float z, float[] coords, int position) {
mv[0] = x;
mv[1] = y;
mv[2] = z - 1;
mv[3] = 1;
Matrix.multiplyMV(mv, 0, mUnprojMatrix, 0, mv, 0);
if (mv[3] != 0) {
float w = 1 / mv[3];
float xx = mv[0] * w;
float yy = mv[1] * w;
coords[position] = xx;
coords[position + 1] = yy;
}
// else what?
}
private void updateMatrix() {
Matrix.setRotateM(mRotateMatrix, 0, mRotation, 0, 0, 1);
// tilt map
float tilt = mTilt;
Matrix.setRotateM(mTmpMatrix, 0, -tilt / (mHeight / 2), 1, 0, 0);
// apply first rotation, then tilt
Matrix.multiplyMM(mRotateMatrix, 0, mTmpMatrix, 0, mRotateMatrix, 0);
// get unproject matrix:
// (transpose of rotation is its inverse)
Matrix.transposeM(mTmpMatrix, 0, mRotateMatrix, 0);
// (AB)^-1 = B^-1*A^-1
Matrix.multiplyMM(mUnprojMatrix, 0, mTmpMatrix, 0, mProjMatrixI, 0);
}
/**
* sets viewBox to visible bounding box, (left,top,right,bottom)
*
* @param viewBox
* ...
*/
public synchronized void getViewBox(final float[] viewBox) {
updateMatrix();
float tilt = FloatMath.sin((float) Math.toRadians(mTilt)) * 4;
unproject(-1, 1, tilt, mBBoxCoords, 0); // top-left
unproject(1, 1, tilt, mBBoxCoords, 2); // top-right
unproject(1, -1, -tilt, mBBoxCoords, 4); // bottom-right
unproject(-1, -1, -tilt, mBBoxCoords, 6); // bottom-left
byte z = mZoomLevel;
double pixelX = MercatorProjection.longitudeToPixelX(mLongitude, z);
double pixelY = MercatorProjection.latitudeToPixelY(mLatitude, z);
double dx = pixelX - mBBoxCoords[0] / mScale;
double dy = pixelY - mBBoxCoords[1] / mScale;
double lon = MercatorProjection.pixelXToLongitude(dx, z);
double lat = MercatorProjection.pixelYToLatitude(dy, z);
Log.d(">>>", "bl:" + lon + " " + lat);
dx = pixelX - mBBoxCoords[2] / mScale;
dy = pixelY - mBBoxCoords[3] / mScale;
lon = MercatorProjection.pixelXToLongitude(dx, z);
lat = MercatorProjection.pixelYToLatitude(dy, z);
Log.d("...", "br:" + lon + " " + lat);
dx = pixelX - mBBoxCoords[4] / mScale;
dy = pixelY - mBBoxCoords[5] / mScale;
lon = MercatorProjection.pixelXToLongitude(dx, z);
lat = MercatorProjection.pixelYToLatitude(dy, z);
Log.d("...", "tl:" + lon + " " + lat);
dx = pixelX - mBBoxCoords[6] / mScale;
dy = pixelY - mBBoxCoords[7] / mScale;
lon = MercatorProjection.pixelXToLongitude(dx, z);
lat = MercatorProjection.pixelYToLatitude(dy, z);
Log.d("...", "tr:" + lon + " " + lat);
}
/**
* @return the current center point of the MapView.
@ -168,6 +306,15 @@ public class MapViewPosition {
return new GeoPoint(latitude, longitude);
}
// public static double pixelXToLongitude(double pixelX, byte zoomLevel) {
// return 360 * ((pixelX / ((long) Tile.TILE_SIZE << zoomLevel)) - 0.5);
// }
//
// public static double pixelYToLatitude(double pixelY, byte zoomLevel) {
// double y = 0.5 - (pixelY / ((long) Tile.TILE_SIZE << zoomLevel));
// return 90 - 360 * Math.atan(Math.exp(-y * (2 * Math.PI))) / Math.PI;
// }
/**
* Moves this MapViewPosition by the given amount of pixels.
*
@ -187,14 +334,13 @@ public class MapViewPosition {
double rad = Math.toRadians(mRotation);
double x = dx * Math.cos(rad) + dy * -Math.sin(rad);
double y = dx * Math.sin(rad) + dy * Math.cos(rad);
dx = pixelX - x;
dy = pixelY - y;
dx = x;
dy = y;
}
else {
dx = pixelX - dx;
dy = pixelY - dy;
}
mLatitude = MercatorProjection.pixelYToLatitude(dy, mZoomLevel);
mLatitude = MercatorProjection.limitLatitude(mLatitude);
@ -202,6 +348,8 @@ public class MapViewPosition {
mLongitude = MercatorProjection.wrapLongitude(mLongitude);
// mLongitude = MercatorProjection.limitLongitude(mLongitude);
// getViewBox(null);
}
public synchronized void rotateMap(float angle, float cx, float cy) {
@ -209,14 +357,17 @@ public class MapViewPosition {
// Log.d("MapViewPosition", "rotate:" + angle + " " + (mRotation -
// angle));
mRotation -= angle;
updateMatrix();
}
public void setRotation(float f) {
mRotation = f;
updateMatrix();
}
public void setTilt(float f) {
mTilt = f;
updateMatrix();
}
synchronized void setMapCenter(GeoPoint geoPoint) {
@ -251,38 +402,41 @@ public class MapViewPosition {
* ...
* @param pivotY
* ...
* @return true if scale was changed
*/
public synchronized void scaleMap(float scale, float pivotX, float pivotY) {
if (pivotY != 0 || pivotY != 0)
moveMap(pivotX * (1.0f - scale),
pivotY * (1.0f - scale));
public synchronized boolean scaleMap(float scale, float pivotX, float pivotY) {
float newScale = mMapScale * scale;
int z = FastMath.log2((int) newScale);
if (z <= 0 || (z >= MAX_ZOOMLEVEL && mScale >= 8))
return;
return false;
if (z > MAX_ZOOMLEVEL) {
// z16 shows everything, just increase scaling
if (mScale * scale > 8)
return;
return false;
mScale *= scale;
mMapScale = newScale;
return;
}
} else {
mZoomLevel = (byte) z;
mScale = newScale / (1 << z);
mMapScale = newScale;
}
if (pivotY != 0 || pivotY != 0)
moveMap(pivotX * (1.0f - scale),
pivotY * (1.0f - scale));
return true;
}
public boolean tilt(float moveX) {
float tilt = mTilt + moveX;
if (tilt > 25)
tilt = 25;
if (tilt > MAX_ANGLE)
tilt = MAX_ANGLE;
else if (tilt < 0)
tilt = 0;
if (mTilt == tilt)

25
src/org/oscim/view/MapZoomControls.java
View File

@ -123,7 +123,7 @@ public class MapZoomControls {
mShowMapZoomControls = true;
mZoomLevelMax = DEFAULT_ZOOM_LEVEL_MAX;
mZoomLevelMin = DEFAULT_ZOOM_LEVEL_MIN;
if (!MapView.testRegionZoom)
// if (!MapView.testRegionZoom)
mZoomControls.setVisibility(View.GONE);
mZoomControlsGravity = DEFAULT_ZOOM_CONTROLS_GRAVITY;
@ -203,12 +203,14 @@ public class MapZoomControls {
}
/**
* Sets the gravity for the placing of the zoom controls. Supported values are {@link Gravity#TOP},
* {@link Gravity#CENTER_VERTICAL}, {@link Gravity#BOTTOM}, {@link Gravity#LEFT}, {@link Gravity#CENTER_HORIZONTAL}
* and {@link Gravity#RIGHT}.
* Sets the gravity for the placing of the zoom controls. Supported values
* are {@link Gravity#TOP}, {@link Gravity#CENTER_VERTICAL},
* {@link Gravity#BOTTOM}, {@link Gravity#LEFT},
* {@link Gravity#CENTER_HORIZONTAL} and {@link Gravity#RIGHT}.
*
* @param zoomControlsGravity
* a combination of {@link Gravity} constants describing the desired placement.
* a combination of {@link Gravity} constants describing the
* desired placement.
*/
public void setZoomControlsGravity(int zoomControlsGravity) {
if (mZoomControlsGravity != zoomControlsGravity) {
@ -220,14 +222,16 @@ public class MapZoomControls {
/**
* Sets the maximum zoom level of the map.
* <p>
* The maximum possible zoom level of the MapView depends also on the current {@link TileGenerator}. For example,
* downloading map tiles may only be possible up to a certain zoom level. Setting a higher maximum zoom level has no
* effect in this case.
* The maximum possible zoom level of the MapView depends also on the
* current {@link TileGenerator}. For example, downloading map tiles may
* only be possible up to a certain zoom level. Setting a higher maximum
* zoom level has no effect in this case.
*
* @param zoomLevelMax
* the maximum zoom level.
* @throws IllegalArgumentException
* if the maximum zoom level is smaller than the current minimum zoom level.
* if the maximum zoom level is smaller than the current minimum
* zoom level.
*/
public void setZoomLevelMax(byte zoomLevelMax) {
if (zoomLevelMax < mZoomLevelMin) {
@ -242,7 +246,8 @@ public class MapZoomControls {
* @param zoomLevelMin
* the minimum zoom level.
* @throws IllegalArgumentException
* if the minimum zoom level is larger than the current maximum zoom level.
* if the minimum zoom level is larger than the current maximum
* zoom level.
*/
public void setZoomLevelMin(byte zoomLevelMin) {
if (zoomLevelMin > mZoomLevelMax) {

1
src/org/oscim/view/RegionLookup.java
View File

@ -23,7 +23,6 @@ import java.util.ArrayList;
import java.util.Properties;
import org.oscim.core.GeoPoint;
import org.oscim.core.MapPosition;
import org.oscim.core.MercatorProjection;
import android.os.AsyncTask;

137
src/org/oscim/view/TouchHandler.java
View File

@ -32,20 +32,24 @@ import android.widget.Scroller;
* Implementation for multi-touch capable devices. TODO write a AnimationTimer
* instead of using CountDownTimer
*/
public class TouchHandler {
public class TouchHandler
extends SimpleOnGestureListener
implements ScaleGestureDetector.OnScaleGestureListener {
private static final float SCALE_DURATION = 450;
private static final int INVALID_POINTER_ID = -1;
/* package */final MapView mMapView;
/* package */final MapViewPosition mMapPosition;
/* package */final DecelerateInterpolator mInterpolator = new DecelerateInterpolator();
/* package */boolean mBeginScale;
/* package */float mSumScale;
private final MapView mMapView;
private final MapViewPosition mMapPosition;
private final DecelerateInterpolator mInterpolator = new DecelerateInterpolator();
private boolean mBeginScale;
private float mSumScale;
private final float mMapMoveDelta;
private boolean mMoveStart;
private boolean mBeginRotate;
/* package */float mPosX;
/* package */float mPosY;
private float mPosX;
private float mPosY;
private double mAngle;
private int mActivePointerId;
@ -65,9 +69,47 @@ public class TouchHandler {
mMapPosition = mapView.getMapPosition();
mMapMoveDelta = viewConfiguration.getScaledTouchSlop();
mActivePointerId = INVALID_POINTER_ID;
mScaleGestureDetector = new ScaleGestureDetector(context, new ScaleListener());
mGestureDetector = new GestureDetector(context, new MapGestureDetector());
mScaleGestureDetector = new ScaleGestureDetector(context, this);
mGestureDetector = new GestureDetector(context, this);
mScroller = new Scroller(mMapView.getContext(),
new android.view.animation.LinearInterpolator());
}
/**
* @param event
* ...
* @return ...
*/
public boolean handleMotionEvent(MotionEvent event) {
// workaround for a bug in the ScaleGestureDetector, see Android issue
// #12976
// if (event.getAction() != MotionEvent.ACTION_MOVE
// || event.getPointerCount() > 1) {
mScaleGestureDetector.onTouchEvent(event);
// }
if (!mScaling)
mGestureDetector.onTouchEvent(event);
int action = getAction(event);
boolean ret = false;
if (action == MotionEvent.ACTION_DOWN) {
ret = onActionDown(event);
} else if (action == MotionEvent.ACTION_MOVE) {
ret = onActionMove(event);
} else if (action == MotionEvent.ACTION_UP) {
ret = onActionUp(event);
} else if (action == MotionEvent.ACTION_CANCEL) {
ret = onActionCancel();
} else if (action == MotionEvent.ACTION_POINTER_DOWN) {
return onActionPointerDown(event);
} else if (action == MotionEvent.ACTION_POINTER_UP) {
ret = onActionPointerUp(event);
}
return ret;
}
private static int getAction(MotionEvent motionEvent) {
@ -131,8 +173,9 @@ public class TouchHandler {
return true;
}
if (mMapView.enableRotation) {
if (multi > 0) {
if (!mMapView.enableRotation || multi < 1)
return true;
double x1 = event.getX(0);
double x2 = event.getX(1);
double y1 = event.getY(0);
@ -170,9 +213,6 @@ public class TouchHandler {
mMapView.redrawMap();
}
}
}
return true;
}
@ -225,53 +265,12 @@ public class TouchHandler {
return true;
}
/**
* @param event
* ...
* @return ...
*/
public boolean handleMotionEvent(MotionEvent event) {
/******************* SimpleOnGestureListener *******************/
// workaround for a bug in the ScaleGestureDetector, see Android issue
// #12976
// if (event.getAction() != MotionEvent.ACTION_MOVE
// || event.getPointerCount() > 1) {
mScaleGestureDetector.onTouchEvent(event);
// }
if (!mScaling)
mGestureDetector.onTouchEvent(event);
int action = getAction(event);
boolean ret = false;
if (action == MotionEvent.ACTION_DOWN) {
ret = onActionDown(event);
} else if (action == MotionEvent.ACTION_MOVE) {
ret = onActionMove(event);
} else if (action == MotionEvent.ACTION_UP) {
ret = onActionUp(event);
} else if (action == MotionEvent.ACTION_CANCEL) {
ret = onActionCancel();
} else if (action == MotionEvent.ACTION_POINTER_DOWN) {
return onActionPointerDown(event);
} else if (action == MotionEvent.ACTION_POINTER_UP) {
ret = onActionPointerUp(event);
}
return ret;
}
class MapGestureDetector extends SimpleOnGestureListener {
private Scroller mScroller;
private float mScrollX, mScrollY, mPrevScale;
private CountDownTimer mTimer = null;
private float mScrollX, mScrollY;
private boolean fling = false;
public MapGestureDetector() {
mScroller = new Scroller(mMapView.getContext(),
new android.view.animation.LinearInterpolator());
}
@Override
public boolean onDown(MotionEvent e) {
if (fling) {
@ -346,14 +345,12 @@ public class TouchHandler {
}
}
private final float mScaleDuration = 300;
boolean scale(long tick) {
boolean scale2(long tick) {
fling = true;
if (mPrevScale >= 1)
return false;
float adv = (mScaleDuration - tick) / mScaleDuration;
float adv = (SCALE_DURATION - tick) / SCALE_DURATION;
adv = mInterpolator.getInterpolation(adv);
float scale = adv - mPrevScale;
@ -381,10 +378,10 @@ public class TouchHandler {
mScrollY = (e.getY(0) - (mMapView.getHeight() >> 1)) * 2f;
mPrevScale = 0;
mTimer = new CountDownTimer((int) mScaleDuration, 30) {
mTimer = new CountDownTimer((int) SCALE_DURATION, 30) {
@Override
public void onTick(long tick) {
scale(tick);
scale2(tick);
}
@Override
@ -395,9 +392,9 @@ public class TouchHandler {
}
return true;
}
}
class ScaleListener implements ScaleGestureDetector.OnScaleGestureListener {
/******************* ScaleListener *******************/
private float mCenterX;
private float mCenterY;
private float mFocusX;
@ -425,7 +422,7 @@ public class TouchHandler {
return true;
}
mMapPosition.scaleMap(scale, mFocusX, mFocusY);
if (mMapPosition.scaleMap(scale, mFocusX, mFocusY))
mMapView.redrawMap();
return true;
@ -458,7 +455,7 @@ public class TouchHandler {
mZooutOut = mSumScale < 0.99;
mTimer = new CountDownTimer((int) mScaleDuration, 15) {
mTimer = new CountDownTimer((int) SCALE_DURATION, 15) {
@Override
public void onTick(long tick) {
scale(tick);
@ -477,7 +474,6 @@ public class TouchHandler {
private float mPrevScale;
private CountDownTimer mTimer;
boolean mZooutOut;
private final float mScaleDuration = 450;
boolean scale(long tick) {
@ -486,7 +482,7 @@ public class TouchHandler {
return false;
}
float adv = (mScaleDuration - tick) / mScaleDuration;
float adv = (SCALE_DURATION - tick) / SCALE_DURATION;
adv = mInterpolator.getInterpolation(adv);
float scale = adv - mPrevScale;
@ -506,4 +502,3 @@ public class TouchHandler {
return true;
}
}
}

12
src/org/oscim/view/generator/MapWorker.java
View File

@ -15,12 +15,12 @@
package org.oscim.view.generator;
import org.oscim.utils.PausableThread;
import org.oscim.view.renderer.TileGenerator;
import org.oscim.view.renderer.MapRenderer;
import org.oscim.view.renderer.TileGenerator;
/**
* A MapWorker uses a {@link IMapGenerator} to generate map tiles. It runs in a separate thread to avoid blocking the UI
* thread.
* A MapWorker uses a {@link TileGenerator} to generate map tiles. It runs in a
* separate thread to avoid blocking the UI thread.
*/
public class MapWorker extends PausableThread {
private final String THREAD_NAME;
@ -28,11 +28,11 @@ public class MapWorker extends PausableThread {
private final TileGenerator mMapGenerator;
private final MapRenderer mMapRenderer;
// private final int mPrio;
/**
* @param id
* thread id
* @param jobQueue
* ...
* @param tileGenerator
* ...
* @param mapRenderer
@ -46,7 +46,6 @@ public class MapWorker extends PausableThread {
mMapRenderer = mapRenderer;
THREAD_NAME = "MapWorker" + id;
// mPrio = Math.max(Thread.MIN_PRIORITY + id, Thread.NORM_PRIORITY - 1);
}
public TileGenerator getMapGenerator() {
@ -85,7 +84,6 @@ public class MapWorker extends PausableThread {
@Override
protected int getThreadPriority() {
return (Thread.NORM_PRIORITY + Thread.MIN_PRIORITY) / 3;
// return mPrio;
}
@Override

282
src/org/oscim/view/renderer/GLRenderer.java
View File

@ -32,11 +32,13 @@ import java.util.concurrent.locks.ReentrantLock;
import javax.microedition.khronos.egl.EGLConfig;
import javax.microedition.khronos.opengles.GL10;
import org.oscim.core.MapPosition;
import org.oscim.core.Tile;
import org.oscim.theme.RenderTheme;
import org.oscim.utils.GlUtils;
import org.oscim.view.MapPosition;
import org.oscim.view.MapView;
import org.oscim.view.MapViewPosition;
import org.oscim.view.renderer.MapRenderer.TilesData;
import android.opengl.GLES20;
import android.opengl.GLSurfaceView;
@ -59,6 +61,10 @@ public class GLRenderer implements GLSurfaceView.Renderer {
static int CACHE_TILES = CACHE_TILES_MAX;
private final MapView mMapView;
private final MapViewPosition mMapViewPosition;
private static final MapPosition mMapPosition = new MapPosition();
private static ArrayList<VertexBufferObject> mVBOs;
private static int mWidth, mHeight;
@ -71,12 +77,8 @@ public class GLRenderer implements GLSurfaceView.Renderer {
private static int mBufferMemoryUsage;
private static float[] mMVPMatrix = new float[16];
private static float[] mRotateMatrix = new float[16];
private static float[] mTmpMatrix = new float[16];
private static float[] mTmp2Matrix = new float[16];
private static float[] mProjMatrix = new float[16];
private static float[] mProjMatrixI = new float[16];
private static float[] mTileCoords = new float[8];
// mNextTiles is set by TileLoader and swapped with
// mDrawTiles in onDrawFrame in GL thread.
@ -86,8 +88,6 @@ public class GLRenderer implements GLSurfaceView.Renderer {
// changed. used in onDrawFrame to flip mNextTiles/mDrawTiles
private static boolean mUpdateTiles;
private static MapPosition mCurPosition;
private float[] mClearColor = null;
// number of tiles drawn in one frame
@ -98,17 +98,6 @@ public class GLRenderer implements GLSurfaceView.Renderer {
// lock to synchronize Main- and GL-Thread
static ReentrantLock tilelock = new ReentrantLock();
// used for passing tiles to be rendered from TileLoader(Main-Thread) to
// GLThread
static class TilesData {
int cnt = 0;
final MapTile[] tiles;
TilesData(int numTiles) {
tiles = new MapTile[numTiles];
}
}
/**
* @param mapView
* the MapView
@ -117,34 +106,27 @@ public class GLRenderer implements GLSurfaceView.Renderer {
Log.d(TAG, "init MapRenderer");
mMapView = mapView;
mMapViewPosition = mapView.getMapViewPosition();
// mMapPosition = new MapPosition();
mMapPosition.init();
Matrix.setIdentityM(mMVPMatrix, 0);
mUpdateTiles = false;
}
/**
* called by TileLoader when only position changed
*
* @param mapPosition
* current MapPosition
*/
static void updatePosition(MapPosition mapPosition) {
mCurPosition = mapPosition;
}
/**
* called by TileLoader when list of active tiles changed
*
* @param mapPosition
* current MapPosition
* @param tiles
* active tiles
* @return mNextTiles (the previously active tiles)
*/
static TilesData updateTiles(MapPosition mapPosition, TilesData tiles) {
static TilesData updateTiles(TilesData tiles) {
GLRenderer.tilelock.lock();
mCurPosition = mapPosition;
// mCurPosition = mapPosition;
// unlock previously active tiles
for (int i = 0; i < mNextTiles.cnt; i++) {
@ -178,13 +160,13 @@ public class GLRenderer implements GLSurfaceView.Renderer {
// lock tiles (and their proxies) to not be removed from cache
for (int i = 0; i < mNextTiles.cnt; i++) {
MapTile t = mNextTiles.tiles[i];
if (!t.isActive)
if (!t.isLocked)
t.lock();
}
for (int j = 0; j < mDrawTiles.cnt; j++) {
MapTile t = mDrawTiles.tiles[j];
if (!t.isActive)
if (!t.isLocked)
t.lock();
}
@ -386,8 +368,9 @@ public class GLRenderer implements GLSurfaceView.Renderer {
CACHE_TILES -= 50;
}
private static boolean isVisible(MapPosition mapPosition, MapTile tile) {
private static boolean isVisible(MapTile tile) {
float dx, dy, scale, div = 1;
MapPosition mapPosition = mMapPosition;
int diff = mapPosition.zoomLevel - tile.zoomLevel;
if (diff < 0)
@ -407,7 +390,7 @@ public class GLRenderer implements GLSurfaceView.Renderer {
// this kindof works for typical screen aspect
if (mRotate) {
int ssize = mWidth > mHeight ? mWidth : mHeight;
ssize += Tile.TILE_SIZE;
if (sy > ssize / 2 || sx > ssize / 2
|| sx + size * scale < -ssize / 2
|| sy + size * scale < -ssize / 2) {
@ -429,10 +412,12 @@ public class GLRenderer implements GLSurfaceView.Renderer {
private static boolean mRotate = false;
private static void setMatrix(float[] matrix, MapPosition mapPosition, MapTile tile,
private static void setMatrix(float[] matrix, MapTile tile,
float div, boolean project) {
float x, y, scale;
MapPosition mapPosition = mMapPosition;
scale = mapPosition.scale / (div * COORD_MULTIPLIER);
x = (float) (tile.pixelX - mapPosition.x * div);
y = (float) (tile.pixelY - mapPosition.y * div);
@ -443,48 +428,30 @@ public class GLRenderer implements GLSurfaceView.Renderer {
Matrix.scaleM(matrix, 0, scale, scale, 1);
// translate relative to map center
Matrix.translateM(matrix, 0,
x * COORD_MULTIPLIER,
-(y + Tile.TILE_SIZE) * COORD_MULTIPLIER,
-1); // put on near plane
Matrix.translateM(matrix, 0, x * COORD_MULTIPLIER,
-(y + Tile.TILE_SIZE) * COORD_MULTIPLIER, 0);
if (mRotate)
Matrix.multiplyMM(matrix, 0, mRotateMatrix, 0, matrix, 0);
Matrix.multiplyMM(matrix, 0, mapPosition.rotation, 0, matrix, 0);
if (project)
Matrix.multiplyMM(matrix, 0, mProjMatrix, 0, matrix, 0);
}
// private float[] mv = new float[4];
// private float[] mu = { 1, 1, -1, 1 };
//
// private float[] mUnprojMatrix = new float[16];
//
// private void unproject(MapPosition pos, float x, float y) {
// mu[0] = x;
// mu[1] = y;
// mu[2] = -1;
//
// // add tilt
// Matrix.multiplyMV(mv, 0, mTmpMatrix, 0, mu, 0);
// // Log.d(TAG, ">> " + mv[0] + " " + mv[1] + " " + mv[2]);
//
// Matrix.multiplyMV(mv, 0, mUnprojMatrix, 0, mv, 0);
// float size = Tile.TILE_SIZE * pos.scale;
// if (mv[3] != 0) {
// float w = 1 / mv[3];
// float xx = Math.round(((mv[0] * w) / size) * 100) / 100f;
// float yy = Math.round(((mv[1] * w) / size) * 100) / 100f;
// Log.d(TAG, " " + xx + " " + yy);
// }
// }
private static float scaleDiv(MapTile t) {
float div = 1;
int diff = mMapPosition.zoomLevel - t.zoomLevel;
if (diff < 0)
div = (1 << -diff);
else if (diff > 0)
div = (1.0f / (1 << diff));
return div;
}
@Override
public void onDrawFrame(GL10 glUnused) {
long start = 0;
MapPosition mapPosition;
if (MapView.debugFrameTime)
start = SystemClock.uptimeMillis();
@ -498,66 +465,55 @@ public class GLRenderer implements GLSurfaceView.Renderer {
| GLES20.GL_STENCIL_BUFFER_BIT);
// get position and current tiles to draw
GLRenderer.tilelock.lock();
mapPosition = mCurPosition;
// mapPosition = mCurPosition;
if (mUpdateTiles) {
GLRenderer.tilelock.lock();
TilesData tmp = mDrawTiles;
mDrawTiles = mNextTiles;
mNextTiles = tmp;
mUpdateTiles = false;
}
GLRenderer.tilelock.unlock();
}
if (mDrawTiles == null)
if (mDrawTiles == null || mDrawTiles.cnt == 0)
return;
// if (mRotate != (mMapView.enableRotation || mMapView.enableCompass)) {
// Matrix.setIdentityM(mMVPMatrix, 0);
// mRotate = mMapView.enableRotation || mMapView.enableCompass;
// }
// MapPosition mapPosition =
// mMapView.getMapViewPosition().getMapPosition();
MapPosition mapPosition = mMapPosition;
boolean changed = mMapViewPosition.getMapPosition(mapPosition, mTileCoords);
int tileCnt = mDrawTiles.cnt;
MapTile[] tiles = mDrawTiles.tiles;
if (changed) {
for (int i = 0; i < tileCnt; i++)
tiles[i].isVisible = false;
// get relative zoom-level, tiles could not have been updated after
// zoom-level changed.
float div = scaleDiv(tiles[0]);
mRotate = mMapView.enableRotation || mMapView.enableCompass;
if (mRotate) {
// rotate map
Matrix.setRotateM(mRotateMatrix, 0, mapPosition.angle, 0, 0, 1);
float s = Tile.TILE_SIZE;
float scale = mapPosition.scale / div;
float px = (float) (mapPosition.x * div);
float py = (float) (mapPosition.y * div);
// tilt map
// mMapView.getMapViewPosition().mTilt;
mTileCoords[0] = (px + mTileCoords[0] / scale) / s;
mTileCoords[1] = (py - mTileCoords[1] / scale) / s;
mTileCoords[2] = (px + mTileCoords[2] / scale) / s;
mTileCoords[3] = (py - mTileCoords[3] / scale) / s;
mTileCoords[4] = (px + mTileCoords[4] / scale) / s;
mTileCoords[5] = (py - mTileCoords[5] / scale) / s;
mTileCoords[6] = (px + mTileCoords[6] / scale) / s;
mTileCoords[7] = (py - mTileCoords[7] / scale) / s;
float angle = mMapView.getMapViewPosition().mTilt / (mHeight / 2);
Matrix.setRotateM(mTmpMatrix, 0, -angle, 1, 0, 0);
// move camera center back to map center
Matrix.translateM(mTmpMatrix, 0,
0, (float) Math.tan(Math.toRadians(angle)), 0);
// apply first rotation, then tilt
Matrix.multiplyMM(mRotateMatrix, 0, mTmpMatrix, 0, mRotateMatrix, 0);
// // get unproject matrix
// Matrix.setIdentityM(mTmp2Matrix, 0);
// float s = mapPosition.scale;
// Matrix.translateM(mTmp2Matrix, 0,
// (float) (mapPosition.x * s),
// (float) (mapPosition.y * s), 0);
//
// Matrix.multiplyMM(mTmp2Matrix, 0, mRotateMatrix, 0, mTmp2Matrix,
// 0);
//
// // Matrix.invertM(mTmpMatrix, 0, mTmp2Matrix, 0);
// // (AB)^-1 = B^-1*A^-1
// Matrix.multiplyMM(mUnprojMatrix, 0, mTmp2Matrix, 0, mProjMatrixI,
// 0);
//
// // set tilt of screen coords
// Matrix.setRotateM(mTmpMatrix, 0, -15, 1, 0, 0);
//
// // unproject(mapPosition, 0, 0);
// unproject(mapPosition, -1, -1); // top-left
// unproject(mapPosition, 1, -1); // top-right
// unproject(mapPosition, -1, 1); // bottom-left
// unproject(mapPosition, 1, 1); // bottom-right
byte z = tiles[0].zoomLevel;
ScanBox.scan(mTileCoords, mDrawTiles, 1 << z);
}
if (mUpdateColor && mClearColor != null) {
@ -566,9 +522,6 @@ public class GLRenderer implements GLSurfaceView.Renderer {
mUpdateColor = false;
}
int tileCnt = mDrawTiles.cnt;
MapTile[] tiles = mDrawTiles.tiles;
uploadCnt = 0;
int updateTextures = 0;
@ -576,7 +529,9 @@ public class GLRenderer implements GLSurfaceView.Renderer {
for (int i = 0; i < tileCnt; i++) {
MapTile tile = tiles[i];
if (!isVisible(mapPosition, tile))
// if (!isVisible(mapPosition, tile))
// continue;
if (!tile.isVisible)
continue;
if (tile.texture == null && TextRenderer.drawToTexture(tile))
@ -616,14 +571,14 @@ public class GLRenderer implements GLSurfaceView.Renderer {
for (int i = 0; i < tileCnt; i++) {
if (tiles[i].isVisible && tiles[i].isReady)
drawTile(mapPosition, tiles[i]);
drawTile(tiles[i]);
}
// proxies are clipped to the region where nothing was drawn to depth
// buffer. TODO draw all parent before grandparent
for (int i = 0; i < tileCnt; i++) {
if (tiles[i].isVisible && !tiles[i].isReady)
drawProxyTile(mapPosition, tiles[i]);
drawProxyTile(tiles[i]);
}
// GlUtils.checkGlError("end draw");
@ -647,19 +602,32 @@ public class GLRenderer implements GLSurfaceView.Renderer {
else
TextRenderer.beginDraw(s, mProjMatrix);
// s = (float) 1.0 / COORD_MULTIPLIER;
// TextRenderer.beginDraw(s, mProjMatrix);
for (int i = 0; i < tileCnt; i++) {
if (!tiles[i].isVisible || tiles[i].texture == null)
continue;
setMatrix(mMVPMatrix, mapPosition, tiles[i], 1, false);
setMatrix(mMVPMatrix, tiles[i], 1, false);
TextRenderer.drawTile(tiles[i], mMVPMatrix);
}
TextRenderer.endDraw();
// TODO call overlay renderer
// TODO call overlay renderer here
// s = 0.5f;
// mTileCoords[0] = -s;
// mTileCoords[1] = s;
// mTileCoords[2] = s;
// mTileCoords[3] = s;
// mTileCoords[4] = -s;
// mTileCoords[5] = -s;
// mTileCoords[6] = s;
// mTileCoords[7] = -s;
//
// Matrix.setIdentityM(mMVPMatrix, 0);
// // Matrix.scaleM(mMVPMatrix, 0, 0.99f, 0.99f, 1);
// // Matrix.multiplyMM(mMVPMatrix, 0, mRotateMatrix, 0, mMVPMatrix, 0);
// // Matrix.multiplyMM(mMVPMatrix, 0, mProjMatrix, 0, mMVPMatrix, 0);
// PolygonRenderer.debugDraw(mMVPMatrix, mTileCoords);
if (MapView.debugFrameTime) {
GLES20.glFinish();
@ -670,27 +638,26 @@ public class GLRenderer implements GLSurfaceView.Renderer {
// used to not draw a tile twice per frame...
private static byte mDrawSerial = 0;
private static void drawTile(MapPosition mapPosition, MapTile tile) {
private static void drawTile(MapTile tile) {
// draw parents only once
if (tile.lastDraw == mDrawSerial)
return;
float div = 1;
int diff = mapPosition.zoomLevel - tile.zoomLevel;
if (diff < 0)
div = (1 << -diff);
else if (diff > 0)
div = (1.0f / (1 << diff));
float div = scaleDiv(tile);
// float div = 1;
// int diff = mapPosition.zoomLevel - tile.zoomLevel;
// if (diff < 0)
// div = (1 << -diff);
// else if (diff > 0)
// div = (1.0f / (1 << diff));
tile.lastDraw = mDrawSerial;
int z = mapPosition.zoomLevel;
float s = mapPosition.scale;
int z = mMapPosition.zoomLevel;
float s = mMapPosition.scale;
float[] mvp = mMVPMatrix;
setMatrix(mvp, mapPosition, tile, div, true);
setMatrix(mvp, tile, div, true);
GLES20.glPolygonOffset(0, mDrawCount++);
@ -734,7 +701,7 @@ public class GLRenderer implements GLSurfaceView.Renderer {
}
// TODO could use tile.proxies here
private static boolean drawProxyChild(MapPosition mapPosition, MapTile tile) {
private static boolean drawProxyChild(MapTile tile) {
int drawn = 0;
for (int i = 0; i < 4; i++) {
if (tile.rel.child[i] == null)
@ -744,13 +711,13 @@ public class GLRenderer implements GLSurfaceView.Renderer {
if (c == null)
continue;
if (!isVisible(mapPosition, c)) {
if (!isVisible(c)) {
drawn++;
continue;
}
if (c.isReady) {
drawTile(mapPosition, c);
drawTile(c);
drawn++;
}
}
@ -758,17 +725,17 @@ public class GLRenderer implements GLSurfaceView.Renderer {
}
// TODO could use tile.proxies here
private static void drawProxyTile(MapPosition mapPosition, MapTile tile) {
int diff = mapPosition.zoomLevel - tile.zoomLevel;
private static void drawProxyTile(MapTile tile) {
int diff = mMapPosition.zoomLevel - tile.zoomLevel;
boolean drawn = false;
if (mapPosition.scale > 1.5f || diff < 0) {
if (mMapPosition.scale > 1.5f || diff < 0) {
// prefer drawing children
if (!drawProxyChild(mapPosition, tile)) {
if (!drawProxyChild(tile)) {
if ((tile.proxies & MapTile.PROXY_PARENT) != 0) {
MapTile t = tile.rel.parent.tile;
if (t.isReady) {
drawTile(mapPosition, t);
drawTile(t);
drawn = true;
}
}
@ -776,7 +743,7 @@ public class GLRenderer implements GLSurfaceView.Renderer {
if (!drawn && (tile.proxies & MapTile.PROXY_GRAMPA) != 0) {
MapTile t = tile.rel.parent.parent.tile;
if (t.isReady)
drawTile(mapPosition, t);
drawTile(t);
}
}
@ -785,14 +752,14 @@ public class GLRenderer implements GLSurfaceView.Renderer {
MapTile t = tile.rel.parent.tile;
if (t != null && t.isReady) {
drawTile(mapPosition, t);
drawTile(t);
} else if (!drawProxyChild(mapPosition, tile)) {
} else if (!drawProxyChild(tile)) {
if ((tile.proxies & MapTile.PROXY_GRAMPA) != 0) {
t = tile.rel.parent.parent.tile;
if (t.isReady)
drawTile(mapPosition, t);
drawTile(t);
}
}
}
@ -814,14 +781,18 @@ public class GLRenderer implements GLSurfaceView.Renderer {
// Matrix.orthoM(mProjMatrix, 0, -0.5f / mAspect, 0.5f / mAspect, -0.5f,
// 0.5f, -1, 1);
float s = 0.5f;
Matrix.frustumM(mProjMatrix, 0, -s * width, s * width,
-s * height, s * height, 1, 2);
Matrix.translateM(mProjMatrix, 0, 0, 0, -1);
Matrix.frustumM(mProjMatrix, 0,
-0.5f * width,
0.5f * width,
-0.5f * height,
0.5f * height, 1, 2);
// Matrix.invertM(mProjMatrixI, 0, mProjMatrix, 0);
Matrix.invertM(mProjMatrixI, 0, mProjMatrix, 0);
// use this to scale only the view to see which tiles are rendered
// s = 1.0f;
// Matrix.frustumM(mProjMatrix, 0, -s * width, s * width,
// -s * height, s * height, 1, 2);
// Matrix.translateM(mProjMatrix, 0, 0, 0, -1);
// set to zero: we modify the z value with polygon-offset for clipping
mProjMatrix[10] = 0;
@ -869,6 +840,7 @@ public class GLRenderer implements GLSurfaceView.Renderer {
mMapView.redrawMap();
}
// FIXME this is a bit too spaghetti
void clearTiles(int numTiles) {
mDrawTiles = new TilesData(numTiles);
mNextTiles = new TilesData(numTiles);

76
src/org/oscim/view/renderer/LineLayer.java
View File

@ -40,8 +40,8 @@ class LineLayer {
boolean isOutline;
int layer;
ShortItem pool;
protected ShortItem curItem;
VertexPoolItem pool;
protected VertexPoolItem curItem;
// number of vertices this layer holds
int verticesCnt;
@ -85,10 +85,10 @@ class LineLayer {
squared = true;
if (pool == null) {
pool = curItem = ShortPool.get();
pool = curItem = VertexPool.get();
}
ShortItem si = curItem;
VertexPoolItem si = curItem;
short v[] = si.vertices;
int opos = si.used;
@ -137,8 +137,8 @@ class LineLayer {
ux = -vy;
uy = vx;
if (opos == ShortItem.SIZE) {
si = si.next = ShortPool.get();
if (opos == VertexPoolItem.SIZE) {
si = si.next = VertexPool.get();
v = si.vertices;
opos = 0;
}
@ -151,8 +151,8 @@ class LineLayer {
boolean outside = (x < tmin || x > tmax || y < tmin || y > tmax);
if (opos == ShortItem.SIZE) {
si = si.next = ShortPool.get();
if (opos == VertexPoolItem.SIZE) {
si = si.next = VertexPool.get();
v = si.vertices;
opos = 0;
}
@ -170,8 +170,8 @@ class LineLayer {
v[opos++] = dx;
v[opos++] = dy;
if (opos == ShortItem.SIZE) {
si = si.next = ShortPool.get();
if (opos == VertexPoolItem.SIZE) {
si = si.next = VertexPool.get();
v = si.vertices;
opos = 0;
}
@ -181,8 +181,8 @@ class LineLayer {
v[opos++] = dx;
v[opos++] = dy;
if (opos == ShortItem.SIZE) {
si = si.next = ShortPool.get();
if (opos == VertexPoolItem.SIZE) {
si = si.next = VertexPool.get();
v = si.vertices;
opos = 0;
}
@ -195,8 +195,8 @@ class LineLayer {
v[opos++] = (short) (2 | ddx & DIR_MASK);
v[opos++] = (short) (2 | ddy & DIR_MASK);
if (opos == ShortItem.SIZE) {
si = si.next = ShortPool.get();
if (opos == VertexPoolItem.SIZE) {
si = si.next = VertexPool.get();
v = si.vertices;
opos = 0;
}
@ -210,8 +210,8 @@ class LineLayer {
v[opos++] = (short) (0 | ddx & DIR_MASK);
v[opos++] = (short) (1 | ddy & DIR_MASK);
if (opos == ShortItem.SIZE) {
si = si.next = ShortPool.get();
if (opos == VertexPoolItem.SIZE) {
si = si.next = VertexPool.get();
v = si.vertices;
opos = 0;
}
@ -248,8 +248,8 @@ class LineLayer {
v[opos++] = dx;
v[opos++] = dy;
if (opos == ShortItem.SIZE) {
si = si.next = ShortPool.get();
if (opos == VertexPoolItem.SIZE) {
si = si.next = VertexPool.get();
v = si.vertices;
opos = 0;
}
@ -259,8 +259,8 @@ class LineLayer {
v[opos++] = dx;
v[opos++] = dy;
if (opos == ShortItem.SIZE) {
si = si.next = ShortPool.get();
if (opos == VertexPoolItem.SIZE) {
si = si.next = VertexPool.get();
v = si.vertices;
opos = 0;
}
@ -334,8 +334,8 @@ class LineLayer {
ddx = (int) (ux * DIR_SCALE);
ddy = (int) (uy * DIR_SCALE);
if (opos == ShortItem.SIZE) {
si = si.next = ShortPool.get();
if (opos == VertexPoolItem.SIZE) {
si = si.next = VertexPool.get();
v = si.vertices;
opos = 0;
}
@ -345,8 +345,8 @@ class LineLayer {
v[opos++] = (short) (0 | ddx & DIR_MASK);
v[opos++] = (short) (1 | ddy & DIR_MASK);
if (opos == ShortItem.SIZE) {
si = si.next = ShortPool.get();
if (opos == VertexPoolItem.SIZE) {
si = si.next = VertexPool.get();
v = si.vertices;
opos = 0;
}
@ -375,8 +375,8 @@ class LineLayer {
outside = (x < tmin || x > tmax || y < tmin || y > tmax);
if (opos == ShortItem.SIZE) {
si.next = ShortPool.get();
if (opos == VertexPoolItem.SIZE) {
si.next = VertexPool.get();
si = si.next;
opos = 0;
v = si.vertices;
@ -394,8 +394,8 @@ class LineLayer {
v[opos++] = (short) (0 | ddx & DIR_MASK);
v[opos++] = (short) (1 | ddy & DIR_MASK);
if (opos == ShortItem.SIZE) {
si = si.next = ShortPool.get();
if (opos == VertexPoolItem.SIZE) {
si = si.next = VertexPool.get();
v = si.vertices;
opos = 0;
}
@ -405,8 +405,8 @@ class LineLayer {
v[opos++] = (short) (2 | -ddx & DIR_MASK);
v[opos++] = (short) (1 | -ddy & DIR_MASK);
if (opos == ShortItem.SIZE) {
si = si.next = ShortPool.get();
if (opos == VertexPoolItem.SIZE) {
si = si.next = VertexPool.get();
v = si.vertices;
opos = 0;
}
@ -422,8 +422,8 @@ class LineLayer {
v[opos++] = dx;
v[opos++] = dy;
if (opos == ShortItem.SIZE) {
si = si.next = ShortPool.get();
if (opos == VertexPoolItem.SIZE) {
si = si.next = VertexPool.get();
v = si.vertices;
opos = 0;
}
@ -439,8 +439,8 @@ class LineLayer {
v[opos++] = dx;
v[opos++] = dy;
if (opos == ShortItem.SIZE) {
si = si.next = ShortPool.get();
if (opos == VertexPoolItem.SIZE) {
si = si.next = VertexPool.get();
v = si.vertices;
opos = 0;
}
@ -470,8 +470,8 @@ class LineLayer {
v[opos++] = (short) (0 | ddx & DIR_MASK);
v[opos++] = (short) (1 | ddy & DIR_MASK);
if (opos == ShortItem.SIZE) {
si = si.next = ShortPool.get();
if (opos == VertexPoolItem.SIZE) {
si = si.next = VertexPool.get();
v = si.vertices;
opos = 0;
}
@ -487,8 +487,8 @@ class LineLayer {
v[opos++] = dx;
v[opos++] = dy;
if (opos == ShortItem.SIZE) {
si = si.next = ShortPool.get();
if (opos == VertexPoolItem.SIZE) {
si = si.next = VertexPool.get();
v = si.vertices;
opos = 0;
}

10
src/org/oscim/view/renderer/LineRenderer.java
View File

@ -183,18 +183,18 @@ class LineRenderer {
static void compileLayerData(LineLayer layers, ShortBuffer sbuf) {
int pos = 0;
ShortItem last = null, items = null;
VertexPoolItem last = null, items = null;
for (LineLayer l = layers; l != null; l = l.next) {
if (l.isOutline)
continue;
for (ShortItem item = l.pool; item != null; item = item.next) {
for (VertexPoolItem item = l.pool; item != null; item = item.next) {
if (item.next == null) {
sbuf.put(item.vertices, 0, item.used);
} else {
// item.used = ShortItem.SIZE;
// item.used = VertexPoolItem.SIZE;
sbuf.put(item.vertices);
}
@ -213,7 +213,7 @@ class LineRenderer {
l.curItem = null;
}
ShortPool.add(items);
VertexPool.add(items);
}
// @SuppressLint("UseValueOf")
@ -310,7 +310,7 @@ class LineRenderer {
static void clear(LineLayer layer) {
for (LineLayer l = layer; l != null; l = l.next) {
if (l.pool != null) {
ShortPool.add(l.pool);
VertexPool.add(l.pool);
l.pool = null;
l.curItem = null;
}

122
src/org/oscim/view/renderer/MapRenderer.java
View File

@ -17,21 +17,21 @@ package org.oscim.view.renderer;
import java.util.ArrayList;
import java.util.Collections;
import org.oscim.core.MapPosition;
import org.oscim.core.MercatorProjection;
import org.oscim.core.Tile;
import org.oscim.database.MapInfo;
import org.oscim.theme.RenderTheme;
import org.oscim.utils.GlConfigChooser;
import org.oscim.view.MapPosition;
import org.oscim.view.MapView;
import org.oscim.view.generator.JobTile;
import org.oscim.view.renderer.GLRenderer.TilesData;
import android.content.Context;
import android.opengl.GLSurfaceView;
import android.util.FloatMath;
import android.util.Log;
// FIXME to many 'Renderer', this one needs a better name.. TileLoader?
public class MapRenderer extends GLSurfaceView {
private final static String TAG = "MapRenderer";
private GLRenderer mRenderer;
@ -45,7 +45,7 @@ public class MapRenderer extends GLSurfaceView {
// all tiles currently referenced
private static ArrayList<MapTile> mTiles;
// private static ArrayList<MapTile> mTilesActive;
// tiles that have new data to upload, see passTile()
private static ArrayList<MapTile> mTilesLoaded;
@ -59,9 +59,20 @@ public class MapRenderer extends GLSurfaceView {
// private static MapPosition mCurPosition, mDrawPosition;
private static int mWidth = 0, mHeight = 0;
// used for passing tiles to be rendered from TileLoader(Main-Thread) to
// GLThread
static final class TilesData {
int cnt = 0;
final MapTile[] tiles;
TilesData(int numTiles) {
tiles = new MapTile[numTiles];
}
}
private static TilesData mCurrentTiles;
// map zoom-level to available zoom-levels in MapDatabase
// maps zoom-level to available zoom-levels in MapDatabase
// e.g. 16->16, 15->16, 14->13, 13->13, 12->13,....
private static int[] mZoomLevels;
@ -85,7 +96,7 @@ public class MapRenderer extends GLSurfaceView {
mTiles = new ArrayList<MapTile>();
mTilesLoaded = new ArrayList<MapTile>(30);
ShortPool.init();
VertexPool.init();
QuadTree.init();
mInitial = true;
@ -97,13 +108,10 @@ public class MapRenderer extends GLSurfaceView {
* loading by TileGenerator class
*
* @param clear
* ...
* whether to clear and reload all tiles
*/
public synchronized void updateMap(boolean clear) {
boolean changedPos = false;
boolean changedZoom = false;
if (mMapView == null)
return;
@ -155,24 +163,20 @@ public class MapRenderer extends GLSurfaceView {
int zdir = 0;
if (mInitial || mPrevZoom != zoomLevel) {
changedZoom = true;
mPrevScale = scale;
}
else if (tileX != mTileX || tileY != mTileY) {
if (mPrevScale - scale > 0 && scale > 1.2)
zdir = 1;
mPrevScale = scale;
changedPos = true;
}
else if (mPrevScale - scale > 0.2 || mPrevScale - scale < -0.2) {
} else if (tileX != mTileX || tileY != mTileY) {
if (mPrevScale - scale > 0 && scale > 1.2)
zdir = 1;
changedPos = true;
} else if (mPrevScale - scale > 0.2 || mPrevScale - scale < -0.2) {
if (mPrevScale - scale > 0 && scale > 1.2)
zdir = 1;
mPrevScale = scale;
changedPos = true;
}
if (mInitial) {
// mCurPosition = mapPosition;
mInitial = false;
}
@ -180,30 +184,19 @@ public class MapRenderer extends GLSurfaceView {
mTileY = tileY;
mPrevZoom = zoomLevel;
GLRenderer.updatePosition(mapPosition);
// GLRenderer.updatePosition(mapPosition);
if (!MapView.debugFrameTime)
requestRender();
if (changedZoom || changedPos) {
// need to update visible list first when zoom level changes
// as scaling is relative to the tiles of current zoom-level
if (changedPos) {
mPrevScale = scale;
updateVisibleList(mapPosition, zdir);
if (!MapView.debugFrameTime)
requestRender();
}
// else {
// // pass new position to glThread
// GLRenderer.updatePosition(mapPosition);
// }
// if (!MapView.debugFrameTime)
// requestRender();
// if (changedPos)
// updateVisibleList(mapPosition, zdir);
if (changedPos || changedZoom) {
int remove = mTiles.size() - GLRenderer.CACHE_TILES;
if (remove > 50)
limitCache(mapPosition, remove);
@ -256,15 +249,15 @@ public class MapRenderer extends GLSurfaceView {
// check MapDatabase zoom-level-mapping
if (mZoomLevels[zoomLevel] == 0) {
mCurrentTiles.cnt = 0;
mCurrentTiles = GLRenderer.updateTiles(mapPosition, mCurrentTiles);
mCurrentTiles = GLRenderer.updateTiles(mCurrentTiles);
return;
}
if (mZoomLevels[zoomLevel] > zoomLevel) {
fetchChildren = true;
fetchProxy = true;
}
else if (mZoomLevels[zoomLevel] < zoomLevel) {
} else if (mZoomLevels[zoomLevel] < zoomLevel) {
fetchParent = true;
fetchProxy = true;
}
@ -285,12 +278,12 @@ public class MapRenderer extends GLSurfaceView {
mTiles.add(tile);
}
mCurrentTiles.tiles[tiles++] = tile;
if (!fetchProxy && !(tile.isLoading || tile.newData || tile.isReady)) {
if (!fetchProxy && !tile.isActive()) {
mJobList.add(tile);
}
mCurrentTiles.tiles[tiles++] = tile;
if (fetchChildren) {
byte z = (byte) (zoomLevel + 1);
for (int i = 0; i < 4; i++) {
@ -306,7 +299,7 @@ public class MapRenderer extends GLSurfaceView {
mTiles.add(c);
}
if (!(c.isLoading || c.newData || c.isReady)) {
if (!c.isActive()) {
mJobList.add(c);
}
}
@ -314,18 +307,18 @@ public class MapRenderer extends GLSurfaceView {
if (fetchParent || (!fetchProxy && zdir > 0 && zoomLevel > 0)) {
// prefetch parent
MapTile parent = tile.rel.parent.tile;
MapTile p = tile.rel.parent.tile;
if (parent == null) {
parent = new MapTile(xx >> 1, yy >> 1, (byte) (zoomLevel - 1));
if (p == null) {
p = new MapTile(xx >> 1, yy >> 1, (byte) (zoomLevel - 1));
QuadTree.add(parent);
mTiles.add(parent);
}
QuadTree.add(p);
mTiles.add(p);
mJobList.add(p);
if (!(parent.isLoading || parent.isReady || parent.newData)) {
if (!mJobList.contains(parent))
mJobList.add(parent);
} else if (!p.isActive()) {
if (!mJobList.contains(p))
mJobList.add(p);
}
}
}
@ -333,7 +326,7 @@ public class MapRenderer extends GLSurfaceView {
// pass new tile list to glThread
mCurrentTiles.cnt = tiles;
mCurrentTiles = GLRenderer.updateTiles(mapPosition, mCurrentTiles);
mCurrentTiles = GLRenderer.updateTiles(mCurrentTiles);
// note: this sets isLoading == true for all job tiles
if (mJobList.size() > 0) {
@ -366,8 +359,7 @@ public class MapRenderer extends GLSurfaceView {
QuadTree.remove(t);
}
private static void updateTileDistances(ArrayList<?> tiles,
MapPosition mapPosition) {
private static void updateTileDistances(ArrayList<?> tiles, MapPosition mapPosition) {
int h = (Tile.TILE_SIZE >> 1);
byte zoom = mapPosition.zoomLevel;
long x = (long) mapPosition.x;
@ -422,18 +414,17 @@ public class MapRenderer extends GLSurfaceView {
// remove orphaned tiles
for (int i = 0; i < size;) {
MapTile cur = mTiles.get(i);
MapTile t = mTiles.get(i);
// make sure tile cannot be used by GL or MapWorker Thread
if (!cur.isLocked() && !cur.isLoading && !cur.newData && !cur.isReady) {
clearTile(cur);
if (t.isLocked() || t.isActive()) {
i++;
} else {
// Log.d(TAG, "remove empty tile" + cur);
clearTile(t);
mTiles.remove(i);
removes--;
size--;
// Log.d(TAG, "remove empty tile" + cur);
continue;
}
i++;
}
// Log.d(TAG, "remove tiles: " + removes + " " + size);
@ -451,7 +442,7 @@ public class MapRenderer extends GLSurfaceView {
synchronized (t) {
if (t.isLocked()) {
// dont remove tile used by renderthread
Log.d(TAG, "X not removing " + t + " " + t.isActive + " "
Log.d(TAG, "X not removing " + t + " " + t.isLocked + " "
+ t.distance);
mTiles.add(t);
@ -478,7 +469,7 @@ public class MapRenderer extends GLSurfaceView {
synchronized (mTilesLoaded) {
// remove uploaded tiles
// remove tiles uploaded to vbo
for (int i = 0; i < size;) {
MapTile t = mTilesLoaded.get(i);
// rel == null means tile is already removed by limitCache
@ -535,8 +526,7 @@ public class MapRenderer extends GLSurfaceView {
if (!tile.isLoading) {
// no one should be able to use this tile now, mapgenerator passed
// it,
// glthread does nothing until newdata is set.
// it, glthread does nothing until newdata is set.
Log.d(TAG, "passTile: canceled " + tile);
synchronized (mTilesLoaded) {
mTilesLoaded.add(tile);

13
src/org/oscim/view/renderer/MapTile.java
View File

@ -41,7 +41,7 @@ class MapTile extends JobTile {
/**
* tile is used by render thread. set by updateVisibleList (main thread).
*/
boolean isActive;
boolean isLocked;
/**
* tile has new data to upload to gl
@ -74,13 +74,16 @@ class MapTile extends JobTile {
// counting the tiles that use this tile as proxy
byte refs;
boolean isActive() {
return isLoading || newData || isReady;
}
boolean isLocked() {
return isActive || refs > 0;
return isLocked || refs > 0;
}
void lock() {
isActive = true;
isLocked = true;
if (isReady || newData)
return;
@ -110,7 +113,7 @@ class MapTile extends JobTile {
}
void unlock() {
isActive = false;
isLocked = false;
if (proxies == 0)
return;

20
src/org/oscim/view/renderer/PolygonLayer.java
View File

@ -23,8 +23,8 @@ class PolygonLayer {
PolygonLayer next;
Area area;
ShortItem pool;
protected ShortItem curItem;
VertexPoolItem pool;
protected VertexPoolItem curItem;
int verticesCnt;
int offset;
@ -33,14 +33,14 @@ class PolygonLayer {
PolygonLayer(int layer, Area area) {
this.layer = layer;
this.area = area;
curItem = ShortPool.get();
curItem = VertexPool.get();
pool = curItem;
}
void addPolygon(float[] points, short[] index) {
short center = (short) ((Tile.TILE_SIZE >> 1) * S);
ShortItem si = curItem;
VertexPoolItem si = curItem;
short[] v = si.vertices;
int outPos = si.used;
@ -59,8 +59,8 @@ class PolygonLayer {
int inPos = pos;
if (outPos == ShortItem.SIZE) {
si = si.next = ShortPool.get();
if (outPos == VertexPoolItem.SIZE) {
si = si.next = VertexPool.get();
v = si.vertices;
outPos = 0;
}
@ -69,8 +69,8 @@ class PolygonLayer {
v[outPos++] = center;
for (int j = 0; j < length; j += 2) {
if (outPos == ShortItem.SIZE) {
si = si.next = ShortPool.get();
if (outPos == VertexPoolItem.SIZE) {
si = si.next = VertexPool.get();
v = si.vertices;
outPos = 0;
}
@ -78,8 +78,8 @@ class PolygonLayer {
v[outPos++] = (short) (points[inPos++] * S);
}
if (outPos == ShortItem.SIZE) {
si = si.next = ShortPool.get();
if (outPos == VertexPoolItem.SIZE) {
si = si.next = VertexPool.get();
v = si.vertices;
outPos = 0;
}

44
src/org/oscim/view/renderer/PolygonRenderer.java
View File

@ -35,6 +35,9 @@ import static android.opengl.GLES20.glUniformMatrix4fv;
import static android.opengl.GLES20.glUseProgram;
import static android.opengl.GLES20.glVertexAttribPointer;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.nio.FloatBuffer;
import java.nio.ShortBuffer;
import org.oscim.utils.GlUtils;
@ -257,7 +260,7 @@ class PolygonRenderer {
if (mCount > 0)
fillPolygons(zoom, scale);
//
// maybe reset start when only few layers left in stencil buffer
// if (mCount > 5){
// mCount = 0;
// mStart = 0;
@ -273,6 +276,35 @@ class PolygonRenderer {
return l;
}
private static float[] debugFillColor = { 0.3f, 0.0f, 0.0f, 0.3f };
private static ByteBuffer mDebugFill;
static void debugDraw(float[] matrix, float[] coords) {
mDebugFill = ByteBuffer.allocateDirect(32).order(ByteOrder.nativeOrder());
FloatBuffer buf = mDebugFill.asFloatBuffer();
buf.put(coords);
GLES20.glBindBuffer(GLES20.GL_ARRAY_BUFFER, 0);
mDebugFill.position(0);
glUseProgram(polygonProgram);
GLES20.glEnableVertexAttribArray(hPolygonVertexPosition);
glVertexAttribPointer(hPolygonVertexPosition, 2, GLES20.GL_FLOAT,
false, 0, mDebugFill);
glUniformMatrix4fv(hPolygonMatrix, 1, false, matrix, 0);
glUniform4fv(hPolygonColor, 1, debugFillColor, 0);
glDrawArrays(GLES20.GL_TRIANGLE_STRIP, 0, 4);
GlUtils.checkGlError("draw debug");
GLES20.glDisableVertexAttribArray(hPolygonVertexPosition);
}
static void drawDepthClip() {
glColorMask(false, false, false, false);
GLES20.glDepthMask(true);
@ -299,16 +331,16 @@ class PolygonRenderer {
static void compileLayerData(PolygonLayer layers, ShortBuffer sbuf) {
int pos = 4;
ShortItem last = null, items = null;
VertexPoolItem last = null, items = null;
for (PolygonLayer l = layers; l != null; l = l.next) {
for (ShortItem item = l.pool; item != null; item = item.next) {
for (VertexPoolItem item = l.pool; item != null; item = item.next) {
if (item.next == null) {
sbuf.put(item.vertices, 0, item.used);
} else {
// item.used = ShortItem.SIZE;
// item.used = VertexPoolItem.SIZE;
sbuf.put(item.vertices);
}
@ -326,13 +358,13 @@ class PolygonRenderer {
l.pool = null;
}
ShortPool.add(items);
VertexPool.add(items);
}
static void clear(PolygonLayer layers) {
for (PolygonLayer l = layers; l != null; l = l.next) {
if (l.pool != null)
ShortPool.add(l.pool);
VertexPool.add(l.pool);
}
}
}

184
src/org/oscim/view/renderer/ScanBox.java Normal file
View File

@ -0,0 +1,184 @@
/*
* Copyright 2012 Hannes Janetzek
*
* This program is free software: you can redistribute it and/or modify it under the
* terms of the GNU Lesser General License as published by the Free Software
* Foundation, either version 3 of the License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful, but WITHOUT ANY
* WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
* PARTICULAR PURPOSE. See the GNU Lesser General License for more details.
*
* You should have received a copy of the GNU Lesser General License along with
* this program. If not, see <http://www.gnu.org/licenses/>.
*/
/* ported from Polymaps: Layer.js */
package org.oscim.view.renderer;
import org.oscim.view.renderer.MapRenderer.TilesData;
import android.util.FloatMath;
public class ScanBox {
interface Callback {
void call(MapTile tile);
}
class SetVisible implements Callback {
@Override
public void call(MapTile tile) {
tile.isVisible = true;
}
}
static class Edge {
float x0, y0, x1, y1, dx, dy;
void set(float x0, float y0, float x1, float y1) {
if (y0 <= y1) {
this.x0 = x0;
this.y0 = y0;
this.x1 = x1;
this.y1 = y1;
this.dx = x1 - x0;
this.dy = y1 - y0;
} else {
this.x0 = x1;
this.y0 = y1;
this.x1 = x0;
this.y1 = y0;
this.dx = x0 - x1;
this.dy = y0 - y1;
}
}
}
static Edge ab = new Edge();
static Edge bc = new Edge();
static Edge ca = new Edge();
static void scanSpans(Edge e0, Edge e1, float ymin, float ymax) {
// sort edge by x-coordinate
if (e0.x0 == e1.x0 && e0.y0 == e1.y0) {
if (e0.x0 + e1.dy / e0.dy * e0.dx < e1.x1) {
Edge t = e0;
e0 = e1;
e1 = t;
}
} else {
if (e0.x1 - e1.dy / e0.dy * e0.dx < e1.x0) {
Edge t = e0;
e0 = e1;
e1 = t;
}
}
float m0 = e0.dx / e0.dy;
float m1 = e1.dx / e1.dy;
int d0 = e0.dx > 0 ? 1 : 0;// use y + 1 to compute x0
int d1 = e1.dx < 0 ? 1 : 0; // use y + 1 to compute x1
float x0, x1;
int y = (int) Math.max(ymin, FloatMath.floor(e1.y0));
int bottom = (int) Math.min(ymax, FloatMath.ceil(e1.y1));
for (; y < bottom; y++) {
// float x0 = (m0 * Math.min(e0.dy, y + d0 - e0.y0) + e0.x0);
// float x1 = (m1 * Math.min(e1.dy, y + d1 - e1.y0) + e1.x0);
x0 = y + d0 - e0.y0;
if (e0.dy < x0)
x0 = e0.dy;
x0 = m0 * x0 + e0.x0;
if (x0 < 0)
x0 = 0;
else
x0 = FloatMath.ceil(x0);
x1 = y + d1 - e1.y0;
if (e1.dy < x1)
x1 = e1.dy;
x1 = m1 * x1 + e1.x0;
if (x1 < 0)
x1 = 0;
else
x1 = FloatMath.floor(x1);
setVisible(y, (int) x1, (int) x0);
// setVisible(y, (int) (x1 - 0.5f), (int) (x0 + 0.5f));
}
}
static void scanTriangle(float ymin, float ymax) {
if (ab.dy > bc.dy) {
Edge t = ab;
ab = bc;
bc = t;
}
if (ab.dy > ca.dy) {
Edge t = ab;
ab = ca;
ca = t;
}
if (bc.dy > ca.dy) {
Edge t = bc;
bc = ca;
ca = t;
}
if (ab.dy != 0)
scanSpans(ca, ab, ymin, ymax);
if (bc.dy != 0)
scanSpans(ca, bc, ymin, ymax);
}
public static void scan(float[] coords, TilesData tiles, int max) {
sTiles = tiles;
cntDoubles = 0;
ab.set(coords[0], coords[1], coords[2], coords[3]);
bc.set(coords[2], coords[3], coords[4], coords[5]);
ca.set(coords[4], coords[5], coords[0], coords[1]);
scanTriangle(0, max);
// Log.d("..", ">doubles " + cntDoubles);
ab.set(coords[4], coords[5], coords[6], coords[7]);
bc.set(coords[6], coords[7], coords[0], coords[1]);
ca.set(coords[0], coords[1], coords[4], coords[5]);
scanTriangle(0, max);
// Log.d("..", "<doubles " + cntDoubles);
}
private static TilesData sTiles;
private static int cntDoubles;
private static void setVisible(int y, int x1, int x2) {
MapTile[] tiles = sTiles.tiles;
for (int i = 0, n = sTiles.cnt; i < n; i++) {
if (tiles[i].tileY == y) {
if (tiles[i].tileX >= x1 && tiles[i].tileX < x2) {
// if (tiles[i].isVisible) {
// Log.d("..", ">>>" + y + " " + tiles[i].tileX);
// cntDoubles++;
// }
tiles[i].isVisible = true;
}
}
}
}
}

4
src/org/oscim/view/renderer/TextRenderer.java
View File

@ -192,7 +192,7 @@ public class TextRenderer {
if (tex.tile == null)
break;
if (!tex.tile.isActive)
if (!tex.tile.isLocked)
break;
tex = null;
@ -412,7 +412,7 @@ public class TextRenderer {
for (int i = 0; i < mTextures.length; i++) {
tex = mTextures[i];
if (tex.tile == null || !tex.tile.isActive)
if (tex.tile == null || !tex.tile.isLocked)
continue;
mShortBuffer.put(tex.vertices, 0, tex.length);

28
src/org/oscim/view/renderer/ShortPool.java → src/org/oscim/view/renderer/VertexPool.java
View File

@ -16,10 +16,10 @@ package org.oscim.view.renderer;
import android.util.Log;
public class ShortPool {
public class VertexPool {
private static final int POOL_LIMIT = 6000;
static private ShortItem pool = null;
static private VertexPoolItem pool = null;
static private int count = 0;
static private int countAll = 0;
@ -29,14 +29,14 @@ public class ShortPool {
pool = null;
}
static synchronized ShortItem get() {
static synchronized VertexPoolItem get() {
if (pool == null && count > 0) {
Log.d("ShortPool", "XXX wrong count: " + count);
Log.d("VertexPool", "XXX wrong count: " + count);
}
if (pool == null) {
countAll++;
return new ShortItem();
return new VertexPoolItem();
}
count--;
@ -44,14 +44,14 @@ public class ShortPool {
if (count < 0) {
int c = 0;
for (ShortItem tmp = pool; tmp != null; tmp = tmp.next)
for (VertexPoolItem tmp = pool; tmp != null; tmp = tmp.next)
c++;
Log.d("ShortPool", "XXX wrong count: " + count + " left" + c);
return new ShortItem();
Log.d("VertexPool", "XXX wrong count: " + count + " left" + c);
return new VertexPoolItem();
}
ShortItem it = pool;
VertexPoolItem it = pool;
pool = pool.next;
it.used = 0;
it.next = null;
@ -61,7 +61,7 @@ public class ShortPool {
// private static float load = 1.0f;
// private static int loadCount = 0;
static synchronized void add(ShortItem items) {
static synchronized void add(VertexPoolItem items) {
if (items == null)
return;
@ -71,11 +71,11 @@ public class ShortPool {
// limit pool items
if (countAll < POOL_LIMIT) {
ShortItem last = items;
VertexPoolItem last = items;
while (true) {
count++;
// load += (float) last.used / ShortItem.SIZE;
// load += (float) last.used / VertexPoolItem.SIZE;
// loadCount++;
if (last.next == null)
@ -91,14 +91,14 @@ public class ShortPool {
} else {
// int cleared = 0;
ShortItem prev, tmp = items;
VertexPoolItem prev, tmp = items;
while (tmp != null) {
prev = tmp;
tmp = tmp.next;
countAll--;
// load += (float) prev.used / ShortItem.SIZE;
// load += (float) prev.used / VertexPoolItem.SIZE;
// loadCount++;
prev.next = null;

6
src/org/oscim/view/renderer/ShortItem.java → src/org/oscim/view/renderer/VertexPoolItem.java
View File

@ -14,12 +14,12 @@
*/
package org.oscim.view.renderer;
public class ShortItem {
public class VertexPoolItem {
final short[] vertices;
int used;
ShortItem next;
VertexPoolItem next;
ShortItem() {
VertexPoolItem() {
vertices = new short[SIZE];
used = 0;
}