diff --git a/src/org/oscim/renderer/BaseLayer.java b/src/org/oscim/renderer/BaseLayer.java new file mode 100644 index 00000000..f9d77a95 --- /dev/null +++ b/src/org/oscim/renderer/BaseLayer.java @@ -0,0 +1,215 @@ +/* + * Copyright 2013 OpenScienceMap + * + * 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 . + */ +package org.oscim.renderer; + +import static android.opengl.GLES20.GL_ARRAY_BUFFER; +import static android.opengl.GLES20.GL_BLEND; +import static android.opengl.GLES20.GL_DEPTH_TEST; +import static android.opengl.GLES20.GL_POLYGON_OFFSET_FILL; +import static org.oscim.generator.JobTile.STATE_READY; + +import org.oscim.core.MapPosition; +import org.oscim.renderer.layer.Layer; +import org.oscim.utils.FastMath; + +import android.opengl.GLES20; +import android.opengl.Matrix; + +/** + * @author Hannes Janetzek + */ +public class BaseLayer { + + // used to not draw a tile twice per frame. + private static int mDrawSerial = 0; + private static float[] mMVPMatrix = new float[16]; + + private static float[] mVPMatrix = new float[16]; + private static float[] mfProjMatrix = new float[16]; + + static void setProjection(float[] projMatrix) { + System.arraycopy(projMatrix, 0, mfProjMatrix, 0, 16); + // set to zero: we modify the z value with polygon-offset for clipping + mfProjMatrix[10] = 0; + mfProjMatrix[14] = 0; + } + + static void draw(MapTile[] tiles, int tileCnt, MapPosition pos) { + + Matrix.multiplyMM(mVPMatrix, 0, mfProjMatrix, 0, pos.viewMatrix, 0); + + /* draw base layer */ + GLES20.glEnable(GL_DEPTH_TEST); + GLES20.glEnable(GL_POLYGON_OFFSET_FILL); + // mDrawCount = 0; + + for (int i = 0; i < tileCnt; i++) { + MapTile t = tiles[i]; + if (t.isVisible && t.state == STATE_READY) + drawTile(t, pos); + } + + // proxies are clipped to the region where nothing was drawn to depth + // buffer. + // TODO draw all parent before grandparent + // TODO draw proxies for placeholder... + for (int i = 0; i < tileCnt; i++) { + MapTile t = tiles[i]; + if (t.isVisible && (t.state != STATE_READY) && (t.holder == null)) + drawProxyTile(t, pos); + } + + GLES20.glDisable(GL_POLYGON_OFFSET_FILL); + GLES20.glDisable(GL_DEPTH_TEST); + mDrawSerial++; + } + + private static void drawTile(MapTile tile, MapPosition pos) { + // draw parents only once + if (tile.lastDraw == mDrawSerial) + return; + + float div = FastMath.pow(tile.zoomLevel - pos.zoomLevel); + + tile.lastDraw = mDrawSerial; + + float[] mvp = mMVPMatrix; + setMatrix(mvp, tile, div, pos); + + if (tile.holder != null) + tile = tile.holder; + + if (tile.layers == null) + return; + + GLES20.glPolygonOffset(0, GLRenderer.depthOffset(tile)); + + GLES20.glBindBuffer(GL_ARRAY_BUFFER, tile.vbo.id); + + boolean clipped = false; + int simpleShader = 0; // mRotate ? 0 : 1; + + for (Layer l = tile.layers.layers; l != null;) { + + switch (l.type) { + case Layer.POLYGON: + + GLES20.glDisable(GL_BLEND); + l = PolygonRenderer.draw(pos, l, mvp, !clipped, true); + clipped = true; + break; + + case Layer.LINE: + if (!clipped) { + PolygonRenderer.draw(pos, null, mvp, true, true); + clipped = true; + } + + GLES20.glEnable(GL_BLEND); + l = LineRenderer.draw(pos, l, mvp, div, simpleShader, + tile.layers.lineOffset); + break; + } + } + + // if (tile.layers.textureLayers != null) { + // setMatrix(mvp, tile, div, false); + // + // for (Layer l = tile.layers.textureLayers; l != null;) { + // l = TextureRenderer.draw(l, 1, mProjMatrix, mvp, + // tile.layers.texOffset); + // } + // } + } + + private static void setMatrix(float[] matrix, MapTile tile, + float div, MapPosition pos) { + + float x = (float) (tile.pixelX - pos.x * div); + float y = (float) (tile.pixelY - pos.y * div); + float scale = pos.scale / div; + + Matrix.setIdentityM(matrix, 0); + + // translate relative to map center + matrix[12] = x * scale; + matrix[13] = y * scale; + + // scale to tile to world coordinates + scale /= GLRenderer.COORD_MULTIPLIER; + matrix[0] = scale; + matrix[5] = scale; + + // Matrix.multiplyMM(matrix, 0, pos.viewMatrix, 0, matrix, 0); + // Matrix.multiplyMM(matrix, 0, mfProjMatrix, 0, matrix, 0); + Matrix.multiplyMM(matrix, 0, mVPMatrix, 0, matrix, 0); + } + + private static boolean drawProxyChild(MapTile tile, MapPosition pos) { + int drawn = 0; + for (int i = 0; i < 4; i++) { + if ((tile.proxies & 1 << i) == 0) + continue; + + MapTile c = tile.rel.child[i].tile; + + if (c.state == STATE_READY) { + drawTile(c, pos); + drawn++; + } + } + return drawn == 4; + } + + private static void drawProxyTile(MapTile tile, MapPosition pos) { + int diff = pos.zoomLevel - tile.zoomLevel; + + boolean drawn = false; + if (pos.scale > 1.5f || diff < 0) { + // prefer drawing children + if (!drawProxyChild(tile, pos)) { + if ((tile.proxies & MapTile.PROXY_PARENT) != 0) { + MapTile t = tile.rel.parent.tile; + if (t.state == STATE_READY) { + drawTile(t, pos); + drawn = true; + } + } + + if (!drawn && (tile.proxies & MapTile.PROXY_GRAMPA) != 0) { + MapTile t = tile.rel.parent.parent.tile; + if (t.state == STATE_READY) + drawTile(t, pos); + + } + } + } else { + // prefer drawing parent + MapTile t = tile.rel.parent.tile; + + if (t != null && t.state == STATE_READY) { + drawTile(t, pos); + + } else if (!drawProxyChild(tile, pos)) { + + if ((tile.proxies & MapTile.PROXY_GRAMPA) != 0) { + t = tile.rel.parent.parent.tile; + if (t.state == STATE_READY) + drawTile(t, pos); + } + } + } + } +} diff --git a/src/org/oscim/renderer/GLRenderer.java b/src/org/oscim/renderer/GLRenderer.java index b27f439f..c58bd797 100644 --- a/src/org/oscim/renderer/GLRenderer.java +++ b/src/org/oscim/renderer/GLRenderer.java @@ -16,11 +16,9 @@ package org.oscim.renderer; import static android.opengl.GLES20.GL_ARRAY_BUFFER; import static android.opengl.GLES20.GL_BLEND; -import static android.opengl.GLES20.GL_DEPTH_TEST; import static android.opengl.GLES20.GL_DYNAMIC_DRAW; import static android.opengl.GLES20.GL_ONE; import static android.opengl.GLES20.GL_ONE_MINUS_SRC_ALPHA; -import static android.opengl.GLES20.GL_POLYGON_OFFSET_FILL; import static org.oscim.generator.JobTile.STATE_NEW_DATA; import static org.oscim.generator.JobTile.STATE_READY; @@ -35,7 +33,6 @@ import javax.microedition.khronos.opengles.GL10; import org.oscim.core.MapPosition; import org.oscim.core.Tile; -import org.oscim.renderer.layer.Layer; import org.oscim.renderer.layer.Layers; import org.oscim.renderer.overlays.RenderOverlay; import org.oscim.theme.RenderTheme; @@ -81,17 +78,11 @@ public class GLRenderer implements GLSurfaceView.Renderer { private static float[] mMVPMatrix = new float[16]; private static float[] mProjMatrix = new float[16]; - // 'flat' projection used for clipping by depth buffer - private static float[] mfProjMatrix = new float[16]; private static float[] mTmpMatrix = new float[16]; private static float[] mTileCoords = new float[8]; private static float[] mDebugCoords = new float[8]; private static float[] mClearColor = null; - - // number of tiles drawn in one frame - //private static short mDrawCount = 0; - private static boolean mUpdateColor = false; // drawlock to synchronize Main- and GL-Thread @@ -108,14 +99,6 @@ public class GLRenderer implements GLSurfaceView.Renderer { /* package */static int mHolderCount; /* package */static TileSet mDrawTiles; - static boolean[] vertexArray = { false, false }; - - // TODO - final class GLState { - boolean blend = false; - boolean depth = false; - } - // scanline fill class used to check tile visibility private static ScanBox mScanBox = new ScanBox() { @Override @@ -334,32 +317,6 @@ public class GLRenderer implements GLSurfaceView.Renderer { CACHE_TILES -= 50; } - private static void setMatrix(float[] matrix, MapTile tile, - float div, boolean project) { - - MapPosition mapPosition = mMapPosition; - - float x = (float) (tile.pixelX - mapPosition.x * div); - float y = (float) (tile.pixelY - mapPosition.y * div); - float scale = mapPosition.scale / div; - - Matrix.setIdentityM(matrix, 0); - - // translate relative to map center - matrix[12] = x * scale; - matrix[13] = y * scale; - - // scale to tile to world coordinates - scale /= COORD_MULTIPLIER; - matrix[0] = scale; - matrix[5] = scale; - - Matrix.multiplyMM(matrix, 0, mapPosition.viewMatrix, 0, matrix, 0); - - if (project) - Matrix.multiplyMM(matrix, 0, mfProjMatrix, 0, matrix, 0); - } - @Override public void onDrawFrame(GL10 glUnused) { @@ -415,9 +372,9 @@ public class GLRenderer implements GLSurfaceView.Renderer { // get current MapPosition, set mTileCoords (mapping of screen to model // coordinates) - MapPosition mapPosition = mMapPosition; + MapPosition pos = mMapPosition; float[] coords = mTileCoords; - boolean changed = mMapViewPosition.getMapPosition(mapPosition, coords); + boolean changed = mMapViewPosition.getMapPosition(pos, coords); int tileCnt = mDrawTiles.cnt; MapTile[] tiles = mDrawTiles.tiles; @@ -430,12 +387,12 @@ public class GLRenderer implements GLSurfaceView.Renderer { // relative zoom-level, 'tiles' could not have been updated after // zoom-level changed. byte z = tiles[0].zoomLevel; - float div = FastMath.pow(z - mapPosition.zoomLevel); + float div = FastMath.pow(z - pos.zoomLevel); // transform screen coordinates to tile coordinates - float scale = mapPosition.scale / div; - float px = (float) mapPosition.x * div; - float py = (float) mapPosition.y * div; + float scale = pos.scale / div; + float px = (float) pos.x * div; + float py = (float) pos.y * div; for (int i = 0; i < 8; i += 2) { coords[i + 0] = (px + coords[i + 0] / scale) / Tile.TILE_SIZE; @@ -500,34 +457,16 @@ public class GLRenderer implements GLSurfaceView.Renderer { overlays.get(i).update(mMapPosition, changed, tilesChanged); /* draw base layer */ - GLES20.glEnable(GL_DEPTH_TEST); - GLES20.glEnable(GL_POLYGON_OFFSET_FILL); - // mDrawCount = 0; + BaseLayer.draw(tiles, tileCnt, pos); - for (int i = 0; i < tileCnt; i++) { - MapTile t = tiles[i]; - if (t.isVisible && t.state == STATE_READY) - drawTile(t); - } - - // proxies are clipped to the region where nothing was drawn to depth - // buffer. - // TODO draw all parent before grandparent - // TODO draw proxies for placeholder... - for (int i = 0; i < tileCnt; i++) { - MapTile t = tiles[i]; - if (t.isVisible && (t.state != STATE_READY) && (t.holder == null)) - drawProxyTile(t); - } - - GLES20.glDisable(GL_POLYGON_OFFSET_FILL); - GLES20.glDisable(GL_DEPTH_TEST); - mDrawSerial++; + // start drawing while overlays uploading textures, etc + GLES20.glFlush(); /* draw overlays */ + + //GLState.blend(true); GLES20.glEnable(GL_BLEND); - // call overlay renderer for (int i = 0, n = overlays.size(); i < n; i++) { RenderOverlay renderOverlay = overlays.get(i); @@ -570,10 +509,10 @@ public class GLRenderer implements GLSurfaceView.Renderer { PolygonRenderer.debugDraw(mProjMatrix, mDebugCoords, 0); - mapPosition.zoomLevel = -1; - mMapViewPosition.getMapPosition(mapPosition, mDebugCoords); + pos.zoomLevel = -1; + mMapViewPosition.getMapPosition(pos, mDebugCoords); Matrix.multiplyMM(mMVPMatrix, 0, mProjMatrix, 0, - mapPosition.viewMatrix, 0); + pos.viewMatrix, 0); PolygonRenderer.debugDraw(mMVPMatrix, mDebugCoords, 1); } @@ -588,125 +527,6 @@ public class GLRenderer implements GLSurfaceView.Renderer { return ((t.tileX % 4) + (t.tileY % 4 * 4) * 2) * 20; } - // used to not draw a tile twice per frame. - private static int mDrawSerial = 0; - - private static void drawTile(MapTile tile) { - // draw parents only once - if (tile.lastDraw == mDrawSerial) - return; - - float[] mvp = mMVPMatrix; - MapPosition pos = mMapPosition; - - float div = FastMath.pow(tile.zoomLevel - pos.zoomLevel); - - tile.lastDraw = mDrawSerial; - - setMatrix(mvp, tile, div, true); - - if (tile.holder != null) - tile = tile.holder; - - if (tile.layers == null) - return; - - GLES20.glPolygonOffset(0, depthOffset(tile)); - - GLES20.glBindBuffer(GL_ARRAY_BUFFER, tile.vbo.id); - - boolean clipped = false; - int simpleShader = 0; // mRotate ? 0 : 1; - - for (Layer l = tile.layers.layers; l != null;) { - - switch (l.type) { - case Layer.POLYGON: - - GLES20.glDisable(GL_BLEND); - l = PolygonRenderer.draw(pos, l, mvp, !clipped, true); - clipped = true; - break; - - case Layer.LINE: - if (!clipped) { - PolygonRenderer.draw(pos, null, mvp, true, true); - clipped = true; - } - - GLES20.glEnable(GL_BLEND); - l = LineRenderer.draw(pos, l, mvp, div, simpleShader, - tile.layers.lineOffset); - break; - } - } - - // if (tile.layers.textureLayers != null) { - // setMatrix(mvp, tile, div, false); - // - // for (Layer l = tile.layers.textureLayers; l != null;) { - // l = TextureRenderer.draw(l, 1, mProjMatrix, mvp, - // tile.layers.texOffset); - // } - // } - } - - private static boolean drawProxyChild(MapTile tile) { - int drawn = 0; - for (int i = 0; i < 4; i++) { - if ((tile.proxies & 1 << i) == 0) - continue; - - MapTile c = tile.rel.child[i].tile; - - if (c.state == STATE_READY) { - drawTile(c); - drawn++; - } - } - return drawn == 4; - } - - private static void drawProxyTile(MapTile tile) { - int diff = mMapPosition.zoomLevel - tile.zoomLevel; - - boolean drawn = false; - if (mMapPosition.scale > 1.5f || diff < 0) { - // prefer drawing children - if (!drawProxyChild(tile)) { - if ((tile.proxies & MapTile.PROXY_PARENT) != 0) { - MapTile t = tile.rel.parent.tile; - if (t.state == STATE_READY) { - drawTile(t); - drawn = true; - } - } - - if (!drawn && (tile.proxies & MapTile.PROXY_GRAMPA) != 0) { - MapTile t = tile.rel.parent.parent.tile; - if (t.state == STATE_READY) - drawTile(t); - - } - } - } else { - // prefer drawing parent - MapTile t = tile.rel.parent.tile; - - if (t != null && t.state == STATE_READY) { - drawTile(t); - - } else if (!drawProxyChild(tile)) { - - if ((tile.proxies & MapTile.PROXY_GRAMPA) != 0) { - t = tile.rel.parent.parent.tile; - if (t.state == STATE_READY) - drawTile(t); - } - } - } - } - @Override public void onSurfaceChanged(GL10 glUnused, int width, int height) { Log.d(TAG, "SurfaceChanged:" + mNewSurface + " " + width + " " + height); @@ -738,10 +558,7 @@ public class GLRenderer implements GLSurfaceView.Renderer { Matrix.multiplyMM(mProjMatrix, 0, mMVPMatrix, 0, mProjMatrix, 0); } - System.arraycopy(mProjMatrix, 0, mfProjMatrix, 0, 16); - // set to zero: we modify the z value with polygon-offset for clipping - mfProjMatrix[10] = 0; - mfProjMatrix[14] = 0; + BaseLayer.setProjection(mProjMatrix); GLES20.glViewport(0, 0, width, height); @@ -767,8 +584,10 @@ public class GLRenderer implements GLSurfaceView.Renderer { if (mClearColor != null) mUpdateColor = true; - vertexArray[0] = false; - vertexArray[1] = false; + GLState.init(); + + //vertexArray[0] = false; + //vertexArray[1] = false; mMapView.redrawMap(); } @@ -797,33 +616,4 @@ public class GLRenderer implements GLSurfaceView.Renderer { void clearBuffer() { mNewSurface = true; } - - public static void enableVertexArrays(int va1, int va2) { - if (va1 > 1 || va2 > 1) - Log.d(TAG, "FIXME: enableVertexArrays..."); - - if ((va1 == 0 || va2 == 0)) { - if (!vertexArray[0]) { - GLES20.glEnableVertexAttribArray(0); - vertexArray[0] = true; - } - } else { - if (vertexArray[0]) { - GLES20.glDisableVertexAttribArray(0); - vertexArray[0] = false; - } - } - - if ((va1 == 1 || va2 == 1)) { - if (!vertexArray[1]) { - GLES20.glEnableVertexAttribArray(1); - vertexArray[1] = true; - } - } else { - if (vertexArray[1]) { - GLES20.glDisableVertexAttribArray(1); - vertexArray[1] = false; - } - } - } } diff --git a/src/org/oscim/renderer/GLState.java b/src/org/oscim/renderer/GLState.java new file mode 100644 index 00000000..4817b34f --- /dev/null +++ b/src/org/oscim/renderer/GLState.java @@ -0,0 +1,99 @@ +/* + * Copyright 2013 OpenScienceMap + * + * 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 . + */ +package org.oscim.renderer; + +import android.opengl.GLES20; +import android.util.Log; + +/** + * @author Hannes Janetzek + */ +public class GLState { + private final static String TAG = GLState.class.getName(); + + private final static boolean[] vertexArray = { false, false }; + private static boolean blend = false; + private static boolean depth = false; + private static boolean stencil = false; + + public static void init() { + vertexArray[0] = false; + vertexArray[1] = false; + blend = false; + depth = false; + stencil = false; + } + + // public static void blend(boolean enable) { + // if (blend == enable) + // return; + // + // if (blend) + // GLES20.glEnable(GLES20.GL_BLEND); + // else + // GLES20.glDisable(GLES20.GL_BLEND); + // } + // + // public static void test(boolean depthTest, boolean stencilTest) { + // if (depth != depthTest) { + // + // if (depthTest) + // GLES20.glEnable(GLES20.GL_DEPTH_TEST); + // else + // GLES20.glDisable(GLES20.GL_DEPTH_TEST); + // + // depth = depthTest; + // } + // + // if (stencil != stencilTest) { + // + // if (stencilTest) + // GLES20.glEnable(GLES20.GL_STENCIL_TEST); + // else + // GLES20.glDisable(GLES20.GL_STENCIL_TEST); + // + // stencil = stencilTest; + // } + // } + + public static void enableVertexArrays(int va1, int va2) { + if (va1 > 1 || va2 > 1) + Log.d(TAG, "FIXME: enableVertexArrays..."); + + if ((va1 == 0 || va2 == 0)) { + if (!vertexArray[0]) { + GLES20.glEnableVertexAttribArray(0); + vertexArray[0] = true; + } + } else { + if (vertexArray[0]) { + GLES20.glDisableVertexAttribArray(0); + vertexArray[0] = false; + } + } + + if ((va1 == 1 || va2 == 1)) { + if (!vertexArray[1]) { + GLES20.glEnableVertexAttribArray(1); + vertexArray[1] = true; + } + } else { + if (vertexArray[1]) { + GLES20.glDisableVertexAttribArray(1); + vertexArray[1] = false; + } + } + } +} diff --git a/src/org/oscim/renderer/LineRenderer.java b/src/org/oscim/renderer/LineRenderer.java index 5ad454e5..377fd8f7 100644 --- a/src/org/oscim/renderer/LineRenderer.java +++ b/src/org/oscim/renderer/LineRenderer.java @@ -98,7 +98,7 @@ public final class LineRenderer { int uLineColor = hLineColor[mode]; int uLineWidth = hLineWidth[mode]; - GLRenderer.enableVertexArrays(hLineVertexPosition[mode], hLineTexturePosition[mode]); + GLState.enableVertexArrays(hLineVertexPosition[mode], hLineTexturePosition[mode]); glVertexAttribPointer(hLineVertexPosition[mode], 2, GL_SHORT, false, 8, bufferOffset + LINE_VERTICES_DATA_POS_OFFSET); diff --git a/src/org/oscim/renderer/PolygonRenderer.java b/src/org/oscim/renderer/PolygonRenderer.java index 63cdbac6..fe81d7e2 100644 --- a/src/org/oscim/renderer/PolygonRenderer.java +++ b/src/org/oscim/renderer/PolygonRenderer.java @@ -175,7 +175,7 @@ public final class PolygonRenderer { glUseProgram(polygonProgram); - GLRenderer.enableVertexArrays(hPolygonVertexPosition, -1); + GLState.enableVertexArrays(hPolygonVertexPosition, -1); glVertexAttribPointer(hPolygonVertexPosition, 2, GL_SHORT, false, 0, POLYGON_VERTICES_DATA_POS_OFFSET); @@ -184,6 +184,7 @@ public final class PolygonRenderer { // use stencilbuffer method for polygon drawing glEnable(GL_STENCIL_TEST); + //GLState.stencilTest(true); if (first) { mCount = 0; diff --git a/src/org/oscim/renderer/TextureRenderer.java b/src/org/oscim/renderer/TextureRenderer.java index 3e4d0129..c4ca4844 100644 --- a/src/org/oscim/renderer/TextureRenderer.java +++ b/src/org/oscim/renderer/TextureRenderer.java @@ -94,7 +94,7 @@ public final class TextureRenderer { // GlUtils.checkGlError("draw texture >"); GLES20.glUseProgram(mTextureProgram); - GLRenderer.enableVertexArrays(hTextureTexCoord, hTextureVertex); + GLState.enableVertexArrays(hTextureTexCoord, hTextureVertex); TextureLayer tl = (TextureLayer) layer; diff --git a/src/org/oscim/renderer/overlays/BuildingOverlay.java b/src/org/oscim/renderer/overlays/BuildingOverlay.java index cd59c5d7..4dd4aa5b 100644 --- a/src/org/oscim/renderer/overlays/BuildingOverlay.java +++ b/src/org/oscim/renderer/overlays/BuildingOverlay.java @@ -21,6 +21,7 @@ import java.nio.ShortBuffer; import org.oscim.core.MapPosition; import org.oscim.core.Tile; import org.oscim.renderer.GLRenderer; +import org.oscim.renderer.GLState; import org.oscim.renderer.layer.VertexPool; import org.oscim.renderer.layer.VertexPoolItem; import org.oscim.utils.FastMath; @@ -354,7 +355,7 @@ public class BuildingOverlay extends RenderOverlay { GLES20.glUniformMatrix4fv(hBuildingMatrix, 1, false, mv, 0); GLES20.glUniform4f(hBuildingColor, 0.5f, 0.5f, 0.5f, 0.7f); - GLRenderer.enableVertexArrays(hBuildingVertexPosition, hBuildingLightPosition); + GLState.enableVertexArrays(hBuildingVertexPosition, hBuildingLightPosition); GLES20.glBindBuffer(GLES20.GL_ELEMENT_ARRAY_BUFFER, mIndicesBufferID); GLES20.glBindBuffer(GLES20.GL_ARRAY_BUFFER, mVertexBufferID); diff --git a/src/org/oscim/renderer/overlays/ExtrusionOverlay.java b/src/org/oscim/renderer/overlays/ExtrusionOverlay.java index f267452f..69127d7e 100644 --- a/src/org/oscim/renderer/overlays/ExtrusionOverlay.java +++ b/src/org/oscim/renderer/overlays/ExtrusionOverlay.java @@ -20,6 +20,7 @@ import java.nio.ShortBuffer; import org.oscim.core.MapPosition; import org.oscim.renderer.GLRenderer; +import org.oscim.renderer.GLState; import org.oscim.renderer.MapTile; import org.oscim.renderer.TileManager; import org.oscim.renderer.TileSet; @@ -144,8 +145,8 @@ public class ExtrusionOverlay extends RenderOverlay { } // sligthly differ adjacent faces to improve contrast - float mColor[] = { 0.71872549f, 0.701960784f, 0.690196078f, 0.7f }; - float mColor2[] = { 0.71372549f, 0.701960784f, 0.695196078f, 0.7f }; + float mColor[] = { 0.76872549f, 0.751960784f, 0.740196078f, 0.8f }; + float mColor2[] = { 0.76372549f, 0.751960784f, 0.745196078f, 0.8f }; float mRoofColor[] = { 0.895f, 0.89f, 0.88f, 0.9f }; boolean debug = false; @@ -161,8 +162,7 @@ public class ExtrusionOverlay extends RenderOverlay { if (debug) { GLES20.glUseProgram(extrusionProgram); - GLRenderer - .enableVertexArrays(hExtrusionVertexPosition, hExtrusionLightPosition); + GLState.enableVertexArrays(hExtrusionVertexPosition, hExtrusionLightPosition); GLES20.glUniform1i(hExtrusionMode, 0); GLES20.glUniform4f(hExtrusionColor, 0.6f, 0.6f, 0.6f, 0.8f); @@ -201,7 +201,7 @@ public class ExtrusionOverlay extends RenderOverlay { GLES20.glClear(GLES20.GL_DEPTH_BUFFER_BIT); GLES20.glUseProgram(extrusionProgram); - GLRenderer.enableVertexArrays(hExtrusionVertexPosition, -1); + GLState.enableVertexArrays(hExtrusionVertexPosition, -1); GLES20.glEnable(GLES20.GL_CULL_FACE); GLES20.glCullFace(GLES20.GL_FRONT); @@ -233,7 +233,7 @@ public class ExtrusionOverlay extends RenderOverlay { } // enable color buffer, use depth mask - GLRenderer.enableVertexArrays(hExtrusionVertexPosition, hExtrusionLightPosition); + GLState.enableVertexArrays(hExtrusionVertexPosition, hExtrusionLightPosition); GLES20.glColorMask(true, true, true, true); GLES20.glDepthMask(false); GLES20.glDepthFunc(GLES20.GL_EQUAL); diff --git a/src/org/oscim/renderer/overlays/ModelOverlay.java b/src/org/oscim/renderer/overlays/ModelOverlay.java index b2f85c2a..84f2b950 100644 --- a/src/org/oscim/renderer/overlays/ModelOverlay.java +++ b/src/org/oscim/renderer/overlays/ModelOverlay.java @@ -22,6 +22,7 @@ import java.nio.ShortBuffer; import org.oscim.core.MapPosition; import org.oscim.core.Tile; import org.oscim.renderer.GLRenderer; +import org.oscim.renderer.GLState; import org.oscim.utils.FastMath; import org.oscim.utils.GlUtils; import org.oscim.view.MapView; @@ -173,7 +174,7 @@ public class ModelOverlay extends RenderOverlay { GLES20.glUseProgram(polygonProgram); - GLRenderer.enableVertexArrays(hPolygonVertexPosition, hPolygonLightPosition); + GLState.enableVertexArrays(hPolygonVertexPosition, hPolygonLightPosition); GLES20.glBindBuffer(GLES20.GL_ELEMENT_ARRAY_BUFFER, mIndicesBufferID); GLES20.glBindBuffer(GLES20.GL_ARRAY_BUFFER, mVertexBufferID);