如何使用OpenGL（ES）2 Android加速渲染
我在Android上使用OpenGL-ES开发了一个地图。它显示我的地图很好，我刚刚添加了触摸事件处理，所以我可以移动并将其四处移动，这也有效。
然而它的延迟时间约为1秒。我希望图像的平移显然尽可能平滑。
我正在显示相当多的矢量数据，但是，仍然必须有替代方案来使交互更顺畅，我有17000个多边形（地块或地块）和大约1500条线（道路中心线），它们两者都被预先加载到应用程序启动时保存FloatBuffers的列表中。当我进入我的地图活动时，渲染器会遍历这些列表，如下面的代码所示。
我真的很感激有关如何加快速度的一些指示。
（请注意，请忽略比例检测器和任何旋转代码，它们不起作用，我现在关注的是平移地图。）
package com.ANDRRA1.utilities;
import android.content.Context;
import android.opengl.GLSurfaceView;
import android.util.AttributeSet;
import android.view.MotionEvent;
import android.view.GestureDetector;
import android.view.ScaleGestureDetector;
import android.view.animation.DecelerateInterpolator;
import android.view.animation.Interpolator;
public class CustomGLView extends GLSurfaceView {
public vboCustomGLRenderer mGLRenderer;
public CustomGLView(Context context){
super(context);
}
public CustomGLView(Context context, AttributeSet attrs)
{
super(context, attrs);
}
// Hides superclass method.
public void setRenderer(vboCustomGLRenderer renderer)
{
mGLRenderer = renderer;
super.setRenderer(renderer);
super.setRenderMode(GLSurfaceView.RENDERMODE_WHEN_DIRTY);
}
private static final int INVALID_POINTER_ID = -1;
private float mPosX;
private float mPosY;
private float mLastTouchX;
private float mLastTouchY;
private float mLastGestureX;
private float mLastGestureY;
private int mActivePointerId = INVALID_POINTER_ID;
private int mActivePointerId2 = INVALID_POINTER_ID;
float oL1X1, oL1Y1, oL1X2, oL1Y2;
private ScaleGestureDetector mScaleDetector = new ScaleGestureDetector(getContext(), new ScaleListener());
private GestureDetector mGestureDetector = new GestureDetector(getContext(), new GestureListener());
private float mScaleFactor = 1.f;
//The following variable control the fling gesture
private Interpolator animateInterpolator;
private long startTime;
private long endTime;
private float totalAnimDx;
private float totalAnimDy;
private float lastAnimDx;
private float lastAnimDy;
@Override
public boolean onTouchEvent(MotionEvent ev) {
// Let the ScaleGestureDetector inspect all events.
mScaleDetector.onTouchEvent(ev);
mGestureDetector.onTouchEvent(ev);
final int action = ev.getAction();
switch (action & MotionEvent.ACTION_MASK) {
case MotionEvent.ACTION_DOWN: {
if (!mScaleDetector.isInProgress()) {
final float x = ev.getX();
final float y = ev.getY();
mLastTouchX = x;
mLastTouchY = y;
mActivePointerId = ev.getPointerId(0);
}
break;
}
case MotionEvent.ACTION_POINTER_DOWN: {
if (mScaleDetector.isInProgress()) {
mActivePointerId2 = ev.getPointerId(1);
mLastGestureX = mScaleDetector.getFocusX();
mLastGestureY = mScaleDetector.getFocusY();
oL1X1 = ev.getX(ev.findPointerIndex(mActivePointerId));
oL1Y1 = ev.getY(ev.findPointerIndex(mActivePointerId));
oL1X2 = ev.getX(ev.findPointerIndex(mActivePointerId2));
oL1Y2 = ev.getY(ev.findPointerIndex(mActivePointerId2));
}
break;
}
case MotionEvent.ACTION_MOVE: {
// Only move if the ScaleGestureDetector isn't processing a gesture.
if (!mScaleDetector.isInProgress()) {
final int pointerIndex = ev.findPointerIndex(mActivePointerId);
final float x = ev.getX(pointerIndex);
final float y = ev.getY(pointerIndex);
final float dx = x - mLastTouchX;
final float dy = y - mLastTouchY;
mPosX += dx;
mPosY += dy;
mGLRenderer.setEye(dx, dy);
requestRender();
mLastTouchX = x;
mLastTouchY = y;
}
else{
final float gx = mScaleDetector.getFocusX();
final float gy = mScaleDetector.getFocusY();
final float gdx = gx - mLastGestureX;
final float gdy = gy - mLastGestureY;
mPosX += gdx;
mPosY += gdy;
mLastGestureX = gx;
mLastGestureY = gy;
}
break;
}
case MotionEvent.ACTION_UP: {
mActivePointerId = INVALID_POINTER_ID;
break;
}
case MotionEvent.ACTION_CANCEL: {
mActivePointerId = INVALID_POINTER_ID;
break;
}
case MotionEvent.ACTION_POINTER_UP: {
final int pointerIndex = (ev.getAction() & MotionEvent.ACTION_POINTER_INDEX_MASK)
>> MotionEvent.ACTION_POINTER_INDEX_SHIFT;
final int pointerId = ev.getPointerId(pointerIndex);
if (pointerId == mActivePointerId) {
// This was our active pointer going up. Choose a new
// active pointer and adjust accordingly.
final int newPointerIndex = pointerIndex == 0 ? 1 : 0;
mLastTouchX = ev.getX(newPointerIndex);
mLastTouchY = ev.getY(newPointerIndex);
mActivePointerId = ev.getPointerId(newPointerIndex);
}
else{
final int tempPointerIndex = ev.findPointerIndex(mActivePointerId);
mLastTouchX = ev.getX(tempPointerIndex);
mLastTouchY = ev.getY(tempPointerIndex);
}
break;
}
}
return true;
}
private class ScaleListener extends ScaleGestureDetector.SimpleOnScaleGestureListener {
@Override
public boolean onScale(ScaleGestureDetector detector) {
mScaleFactor *= detector.getScaleFactor();
// Don't let the object get too small or too large.
mScaleFactor = Math.max(0.1f, Math.min(mScaleFactor, 10000.0f));
//invalidate();
return true;
}
}
private class GestureListener extends GestureDetector.SimpleOnGestureListener {
@Override
public boolean onFling(MotionEvent e1, MotionEvent e2, float velocityX, float velocityY) {
if (e1 == null || e2 == null){
return false;
}
final float distanceTimeFactor = 0.4f;
final float totalDx = (distanceTimeFactor * velocityX/2);
final float totalDy = (distanceTimeFactor * velocityY/2);
onAnimateMove(totalDx, totalDy, (long) (1000 * distanceTimeFactor));
return true;
}
}
public void onAnimateMove(float dx, float dy, long duration) {
animateInterpolator = new DecelerateInterpolator();
startTime = System.currentTimeMillis();
endTime = startTime + duration;
totalAnimDx = dx;
totalAnimDy = dy;
lastAnimDx = 0;
lastAnimDy = 0;
post(new Runnable() {
@Override
public void run() {
onAnimateStep();
}
});
}
private void onAnimateStep() {
long curTime = System.currentTimeMillis();
float percentTime = (float) (curTime - startTime) / (float) (endTime - startTime);
float percentDistance = animateInterpolator.getInterpolation(percentTime);
float curDx = percentDistance * totalAnimDx;
float curDy = percentDistance * totalAnimDy;
float diffCurDx = curDx - lastAnimDx;
float diffCurDy = curDy - lastAnimDy;
lastAnimDx = curDx;
lastAnimDy = curDy;
doAnimation(diffCurDx, diffCurDy);
if (percentTime < 1.0f) {
post(new Runnable() {
@Override
public void run() {
onAnimateStep();
}
});
}
}
public void doAnimation(float diffDx, float diffDy) {
mPosX += diffDx;
mPosY += diffDy;
mGLRenderer.setEye(diffDx, diffDy);
requestRender();
}
public float angleBetween2Lines(float L1X1, float L1Y1, float L1X2, float L1Y2, float L2X1, float L2Y1, float L2X2, float L2Y2)
{
float angle1 = (float) Math.atan2(L1Y1 - L1Y2, L1X1 - L1X2);
float angle2 = (float) Math.atan2(L2Y1 - L2Y2, L2X1 - L2X2);
float angleDelta = findAngleDelta( (float)Math.toDegrees(angle1), (float)Math.toDegrees(angle2));
return -angleDelta;
}
private float findAngleDelta( float angle1, float angle2 )
{
return angle1 - angle2;
}
}
package com.ANDRRA1.utilities;
import java.nio.FloatBuffer;
import java.util.ListIterator;
import javax.microedition.khronos.egl.EGLConfig;
import javax.microedition.khronos.opengles.GL10;
import android.opengl.GLES20;
import android.opengl.GLSurfaceView;
import android.opengl.Matrix;
public class vboCustomGLRenderer implements GLSurfaceView.Renderer {
/**
* Store the model matrix. This matrix is used to move models from object space (where each model can be thought
* of being located at the center of the universe) to world space.
*/
private float[] mModelMatrix = new float[16];
/**
* Store the view matrix. This can be thought of as our camera. This matrix transforms world space to eye space;
* it positions things relative to our eye.
*/
private float[] mViewMatrix = new float[16];
/** Store the projection matrix. This is used to project the scene onto a 2D viewport. */
private float[] mProjectionMatrix = new float[16];
/** Allocate storage for the final combined matrix. This will be passed into the shader program. */
private float[] mMVPMatrix = new float[16];
/** This will be used to pass in the transformation matrix. */
private int mMVPMatrixHandle;
/** This will be used to pass in model position information. */
private int mPositionHandle;
/** This will be used to pass in model color information. */
private int mColorUniformLocation;
/** How many bytes per float. */
private final int mBytesPerFloat = 4;
/** Offset of the position data. */
private final int mPositionOffset = 0;
/** Size of the position data in elements. */
private final int mPositionDataSize = 3;
/** How many elements per vertex for double values. */
private final int mPositionFloatStrideBytes = mPositionDataSize * mBytesPerFloat;
// geometry types
private final byte wkbPoint = 1;
private final byte wkbLineString = 2;
private final byte wkbPolygon = 3;
//private final byte wkbMultiPoint = 4;
//private final byte wkbMultiLineString = 5;
//private final byte wkbMultiPolygon = 6;
//private final byte wkbGeometryCollection = 7;
// Big Endian
final int wkbXDR = 0;
// Little Endian
final int wkbNDR = 1;
float count = 0;
// Position the eye behind the origin.
public volatile float eyeX = default_settings.mbrMinX + ((default_settings.mbrMaxX - default_settings.mbrMinX)/2);
public volatile float eyeY = default_settings.mbrMinY + ((default_settings.mbrMaxY - default_settings.mbrMinY)/2);
// Position the eye behind the origin.
//final float eyeZ = 1.5f;
public volatile float eyeZ = 1.5f;
// We are looking toward the distance
public volatile float lookX = eyeX;
public volatile float lookY = eyeY;
public volatile float lookZ = 0.0f;
// Set our up vector. This is where our head would be pointing were we holding the camera.
public volatile float upX = 0.0f;
public volatile float upY = 1.0f;
public volatile float upZ = 0.0f;
public vboCustomGLRenderer() {
}
public void setEye(float x, float y){
eyeX -= (x/screen_vs_map_horz_ratio);
lookX = eyeX;
eyeY += (y/screen_vs_map_vert_ratio);
lookY = eyeY;
// Set the camera position (View matrix)
Matrix.setLookAtM(mViewMatrix, 0, eyeX, eyeY, eyeZ, lookX, lookY, lookZ, upX, upY, upZ);
}
@Override
public void onSurfaceCreated(GL10 unused, EGLConfig config) {
Thread.currentThread().setPriority(Thread.MIN_PRIORITY);
// Set the background frame color
//White
GLES20.glClearColor(1.0f, 1.0f, 1.0f, 1.0f);
// Set the view matrix. This matrix can be said to represent the camera position.
// NOTE: In OpenGL 1, a ModelView matrix is used, which is a combination of a model and
// view matrix. In OpenGL 2, we can keep track of these matrices separately if we choose.
Matrix.setLookAtM(mViewMatrix, 0, eyeX, eyeY, eyeZ, lookX, lookY, lookZ, upX, upY, upZ);
final String vertexShader =
"uniform mat4 u_MVPMatrix; \n" // A constant representing the combined model/view/projection matrix.
+ "attribute vec4 a_Position; \n" // Per-vertex position information we will pass in.
+ "attribute vec4 a_Color; \n" // Per-vertex color information we will pass in.
+ "varying vec4 v_Color; \n" // This will be passed into the fragment shader.
+ "void main() \n" // The entry point for our vertex shader.
+ "{ \n"
+ " v_Color = a_Color; \n" // Pass the color through to the fragment shader.
// It will be interpolated across the triangle.
+ " gl_Position = u_MVPMatrix \n" // gl_Position is a special variable used to store the final position.
+ " * a_Position; \n" // Multiply the vertex by the matrix to get the final point in
+ "} \n"; // normalized screen coordinates.
final String fragmentShader =
"precision mediump float; \n" // Set the default precision to medium. We don't need as high of a
// precision in the fragment shader.
+ "uniform vec4 u_Color; \n" // This is the color from the vertex shader interpolated across the
// triangle per fragment.
+ "void main() \n" // The entry point for our fragment shader.
+ "{ \n"
+ " gl_FragColor = u_Color; \n" // Pass the color directly through the pipeline.
+ "} \n";
// Load in the vertex shader.
int vertexShaderHandle = GLES20.glCreateShader(GLES20.GL_VERTEX_SHADER);
if (vertexShaderHandle != 0)
{
// Pass in the shader source.
GLES20.glShaderSource(vertexShaderHandle, vertexShader);
// Compile the shader.
GLES20.glCompileShader(vertexShaderHandle);
// Get the compilation status.
final int[] compileStatus = new int[1];
GLES20.glGetShaderiv(vertexShaderHandle, GLES20.GL_COMPILE_STATUS, compileStatus, 0);
// If the compilation failed, delete the shader.
if (compileStatus[0] == 0)
{
GLES20.glDeleteShader(vertexShaderHandle);
vertexShaderHandle = 0;
}
}
if (vertexShaderHandle == 0)
{
throw new RuntimeException("Error creating vertex shader.");
}
// Load in the fragment shader shader.
int fragmentShaderHandle = GLES20.glCreateShader(GLES20.GL_FRAGMENT_SHADER);
if (fragmentShaderHandle != 0)
{
// Pass in the shader source.
GLES20.glShaderSource(fragmentShaderHandle, fragmentShader);
// Compile the shader.
GLES20.glCompileShader(fragmentShaderHandle);
// Get the compilation status.
final int[] compileStatus = new int[1];
GLES20.glGetShaderiv(fragmentShaderHandle, GLES20.GL_COMPILE_STATUS, compileStatus, 0);
// If the compilation failed, delete the shader.
if (compileStatus[0] == 0)
{
GLES20.glDeleteShader(fragmentShaderHandle);
fragmentShaderHandle = 0;
}
}
if (fragmentShaderHandle == 0)
{
throw new RuntimeException("Error creating fragment shader.");
}
// Create a program object and store the handle to it.
int programHandle = GLES20.glCreateProgram();
if (programHandle != 0)
{
// Bind the vertex shader to the program.
GLES20.glAttachShader(programHandle, vertexShaderHandle);
// Bind the fragment shader to the program.
GLES20.glAttachShader(programHandle, fragmentShaderHandle);
// Bind attributes
GLES20.glBindAttribLocation(programHandle, 0, "a_Position");
GLES20.glBindAttribLocation(programHandle, 1, "a_Color");
// Link the two shaders together into a program.
GLES20.glLinkProgram(programHandle);
// Get the link status.
final int[] linkStatus = new int[1];
GLES20.glGetProgramiv(programHandle, GLES20.GL_LINK_STATUS, linkStatus, 0);
// If the link failed, delete the program.
if (linkStatus[0] == 0)
{
GLES20.glDeleteProgram(programHandle);
programHandle = 0;
}
}
if (programHandle == 0)
{
throw new RuntimeException("Error creating program.");
}
// Set program handles. These will later be used to pass in values to the program.
mMVPMatrixHandle = GLES20.glGetUniformLocation(programHandle, "u_MVPMatrix");
mPositionHandle = GLES20.glGetAttribLocation(programHandle, "a_Position");
mColorUniformLocation = GLES20.glGetUniformLocation(programHandle, "u_Color");
// Tell OpenGL to use this program when rendering.
GLES20.glUseProgram(programHandle);
}
static float mWidth = 0;
static float mHeight = 0;
static float mLeft = 0;
static float mRight = 0;
static float mTop = 0;
static float mBottom = 0;
static float mRatio = 0;
float screen_width_height_ratio;
float screen_height_width_ratio;
final float near = 1.5f;
final float far = 10.0f;
double screen_vs_map_horz_ratio = 0;
double screen_vs_map_vert_ratio = 0;
@Override
public void onSurfaceChanged(GL10 unused, int width, int height) {
// Adjust the viewport based on geometry changes,
// such as screen rotation
// Set the OpenGL viewport to the same size as the surface.
GLES20.glViewport(0, 0, width, height);
//Log.d("","onSurfaceChanged");
screen_width_height_ratio = (float) width / height;
screen_height_width_ratio = (float) height / width;
//Initialize
if (mRatio == 0){
mWidth = (float) width;
mHeight = (float) height;
//map height to width ratio
float map_extents_width = default_settings.mbrMaxX - default_settings.mbrMinX;
float map_extents_height = default_settings.mbrMaxY - default_settings.mbrMinY;
float map_width_height_ratio = map_extents_width/map_extents_height;
//float map_height_width_ratio = map_extents_height/map_extents_width;
if (screen_width_height_ratio > map_width_height_ratio){
mRight = (screen_width_height_ratio * map_extents_height)/2;
mLeft = -mRight;
mTop = map_extents_height/2;
mBottom = -mTop;
}
else{
mRight = map_extents_width/2;
mLeft = -mRight;
mTop = (screen_height_width_ratio * map_extents_width)/2;
mBottom = -mTop;
}
mRatio = screen_width_height_ratio;
}
if (screen_width_height_ratio != mRatio){
final float wRatio = width/mWidth;
final float oldWidth = mRight - mLeft;
final float newWidth = wRatio * oldWidth;
final float widthDiff = (newWidth - oldWidth)/2;
mLeft = mLeft - widthDiff;
mRight = mRight + widthDiff;
final float hRatio = height/mHeight;
final float oldHeight = mTop - mBottom;
final float newHeight = hRatio * oldHeight;
final float heightDiff = (newHeight - oldHeight)/2;
mBottom = mBottom - heightDiff;
mTop = mTop + heightDiff;
mWidth = (float) width;
mHeight = (float) height;
mRatio = screen_width_height_ratio;
}
screen_vs_map_horz_ratio = (mWidth/(mRight-mLeft));
screen_vs_map_vert_ratio = (mHeight/(mTop-mBottom));
Matrix.frustumM(mProjectionMatrix, 0, mLeft, mRight, mBottom, mTop, near, far);
}
@Override
public void onDrawFrame(GL10 unused) {
GLES20.glClear(GLES20.GL_DEPTH_BUFFER_BIT | GLES20.GL_COLOR_BUFFER_BIT);
//The following lists hold the vector data in FloatBuffers pre-loaded from when then application starts
ListIterator<mapLayer> orgNonAssetCatLayersList_it = default_settings.orgNonAssetCatMappableLayers.listIterator();
while (orgNonAssetCatLayersList_it.hasNext()) {
mapLayer MapLayer = orgNonAssetCatLayersList_it.next();
ListIterator<FloatBuffer> mapLayerObjectList_it = MapLayer.objFloatBuffer.listIterator();
ListIterator<Byte> mapLayerObjectTypeList_it = MapLayer.objTypeArray.listIterator();
while (mapLayerObjectTypeList_it.hasNext()) {
switch (mapLayerObjectTypeList_it.next()) {
case wkbPoint:
break;
case wkbLineString:
Matrix.setIdentityM(mModelMatrix, 0);
//Matrix.rotateM(mModelMatrix, 0, 0, 0.0f, 0.0f, 1.0f);
drawLineString(mapLayerObjectList_it.next(), MapLayer.lineStringObjColor);
break;
case wkbPolygon:
Matrix.setIdentityM(mModelMatrix, 0);
//Matrix.rotateM(mModelMatrix, 0, 0, 0.0f, 0.0f, 1.0f);
drawPolygon(mapLayerObjectList_it.next(), MapLayer.polygonObjColor);
break;
}
}
}
}
private void drawLineString(final FloatBuffer geometryBuffer, final float[] colorArray)
{
// Pass in the position information
geometryBuffer.position(mPositionOffset);
GLES20.glVertexAttribPointer(mPositionHandle, mPositionDataSize, GLES20.GL_FLOAT, false, mPositionFloatStrideBytes, geometryBuffer);
GLES20.glEnableVertexAttribArray(mPositionHandle);
GLES20.glUniform4f(mColorUniformLocation, colorArray[0], colorArray[1], colorArray[2], 1f);
// This multiplies the view matrix by the model matrix, and stores the result in the MVP matrix
// (which currently contains model * view).
Matrix.multiplyMM(mMVPMatrix, 0, mViewMatrix, 0, mModelMatrix, 0);
// This multiplies the modelview matrix by the projection matrix, and stores the result in the MVP matrix
// (which now contains model * view * projection).
Matrix.multiplyMM(mMVPMatrix, 0, mProjectionMatrix, 0, mMVPMatrix, 0);
GLES20.glUniformMatrix4fv(mMVPMatrixHandle, 1, false, mMVPMatrix, 0);
GLES20.glLineWidth(2.0f);
GLES20.glDrawArrays(GLES20.GL_LINE_STRIP, 0, geometryBuffer.capacity()/mPositionDataSize);
}
private void drawPolygon(final FloatBuffer geometryBuffer, final float[] colorArray)
{
// Pass in the position information
geometryBuffer.position(mPositionOffset);
GLES20.glVertexAttribPointer(mPositionHandle, mPositionDataSize, GLES20.GL_FLOAT, false, mPositionFloatStrideBytes, geometryBuffer);
GLES20.glEnableVertexAttribArray(mPositionHandle);
GLES20.glUniform4f(mColorUniformLocation, colorArray[0], colorArray[1], colorArray[2], 1f);
// This multiplies the view matrix by the model matrix, and stores the result in the MVP matrix
// (which currently contains model * view).
Matrix.multiplyMM(mMVPMatrix, 0, mViewMatrix, 0, mModelMatrix, 0);
// This multiplies the modelview matrix by the projection matrix, and stores the result in the MVP matrix
// (which now contains model * view * projection).
Matrix.multiplyMM(mMVPMatrix, 0, mProjectionMatrix, 0, mMVPMatrix, 0);
GLES20.glUniformMatrix4fv(mMVPMatrixHandle, 1, false, mMVPMatrix, 0);
GLES20.glLineWidth(1.0f);
GLES20.glDrawArrays(GLES20.GL_LINE_LOOP, 0, geometryBuffer.capacity()/mPositionDataSize);
}
}
5 个答案:
答案 0 :(得分：5)
这里的其他答案已经非常好，并显示了要查看的地方和需要改进的地方。我怀疑减速是从每个绘制框架调用drawPolygon和drawLine数千次（如果你有数千个多边形和线条），并且每个方法调用多次调用OpenGL方法。您真的想批量调用这些调用，以便在单个单独的绘制调用中绘制所有多边形和所有行。
根据我的经验，很难准确计算时间，OpenGL会缓冲调用，甚至Android跟踪器也会提供不准确的结果。你可以做的是尝试在运行之间删除和更改代码，计算整个绘制循环的时间，然后看看事情是如何变化的。
尝试删除Thread.currentThread（）。setPriority（Thread.MIN_PRIORITY）;并重新设计应用程序，将数据放入顶点缓冲区对象，并与GL_STATIC_DRAW绑定。通过一次绘制调用绘制所有行。要避免状态更改并分解绘制调用，可以将颜色作为属性而不是作为一个统一。您还可以计算并在每次整体抽取中传递一次矩阵，而不是每行。
答案 1 :(得分：3)
我建议您专注于根据缩放级别和视口限制绘制的数量，而不是尝试优化渲染效率。如果你有多达17,000个具有相当响应时间的多边形，那么你可能无法进行太多低效的渲染调用。
查看您发布的图片。如果你在那里渲染了17,000个多边形和1,500条线，那么大部分细节都被浪费了，因为我们无法看到那么详细的细节吗？我当然看不到17,000个多边形。
相反，保持加载完整的详细信息，并编写代码以根据缩放级别限制细节。毫不奇怪，这种方法称为level of detail算法。如果你曾经使用MipMaps做了很多事情，它基于相同的原则。
我会计算所需缩放级别的详细数据级别，并根据当前缩放级别引用此缓存数据。当用户不处于您的一个离散缩放级别时，只需引用最近的缩放级别并缩放。
如果在更近的缩放级别需要高细节时，您可以使用culling快速Spatial Partitioning使用{{3}}算法在您的细节数据级别中不需要渲染哪些线条和多边形。“ / p>
如果您需要澄清任何要点请告诉我。这个东西很容易谈，但很难编码。祝你好运！
编辑：
一个LoD实现是根据矩阵缩放计算多边形和线条位置。然后，丢弃任何距离不够远的点。我只是将他们的浮点位置投入到一开始，看看它看起来像什么。为多个缩放级别执行此操作。将这些结果存储在一个数组中，然后舍入您所处的任何缩放级别，以选择最近的缓存LoD数据。
答案 2 :(得分：2)
有些事情让我跳了出来。
1）不要在绘图例程中创建对象，例如onDrawFrame。
等迭代器 ListIterator<mapLayer> orgNonAssetCatLayersList_it = default_settings.orgNonAssetCatMappableLayers.listIterator();
创建对象并在绘图例程中创建对象会损害性能。
2）尽可能减少OpenGL调用。当您执行OpenGL调用时，Java仍然需要跨越JNI边界，因此如果您可以将所有内容放在几个大字节缓冲区中并避免更改OpenGL状态。我本来试图将数据组织成尽可能少的绘制线条的缓冲区，另一个设置绘制多边形。
您可能只想考虑以各种缩放级别渲染部分数据。其他人可能有更好的想法，如果你环顾四周或在线，我相信你会找到它们。
3）并始终衡量您的表现，以了解您的真正问题所在。 Android提供了多种工具（Traceview Systrace，OpenGL ES Tracer）。
有关更多常规Android效果提示，请参阅：http://developer.android.com/training/articles/perf-tips.html
答案 3 :(得分：2)
没有人提到FBO的？我的意思是，LOD是一个很好的方法，但在某些情况下你可以使用FBO。这取决于很多事情，但你应该考虑它们！
您可以将孔场景（或部分场景）渲染到帧缓冲区对象并显示图像，而不是每帧绘制场景。这会将多边形数量减少到几个（最佳情况为2，即一个方格）。
一个新的问题是如何处理平移/缩放，因为你需要动态地重新计算fbo。您可以绘制blury图像，直到fbo准备就绪，或者您可以采用更高级的方法进行一些预加载，例如将地图划分为正方形并预加载其中的9个（中心和8个邻居），因为google-maps会加载它地图数据。
你还需要看一下内存消耗情况，你不能只把每个组合画到FBO上。
我再说一遍，FBO不是一个“独立”的解决方案，只要让他们留意，看看你是否可以在某个地方使用它们！
答案 4 :(得分：0)
您是在VM中还是在真实手机上运行它？
您可以添加一些代码来检查函数的执行情况吗？
尝试找出那种花时间的方式。
相关问题
最新问题
- 我写了这段代码，但我无法理解我的错误
- 我无法从一个代码实例的列表中删除 None 值，但我可以在另一个实例中。为什么它适用于一个细分市场而不适用于另一个细分市场？
- 是否有可能使 loadstring 不可能等于打印？卢阿
- java中的random.expovariate()
- Appscript 通过会议在 Google 日历中发送电子邮件和创建活动
- 为什么我的 Onclick 箭头功能在 React 中不起作用？
- 在此代码中是否有使用“this”的替代方法？
- 在 SQL Server 和 PostgreSQL 上查询，我如何从第一个表获得第二个表的可视化
- 每千个数字得到
- 更新了城市边界 KML 文件的来源？