Java Android openGL示例给出了一个空白屏幕

我刚刚在galaxy s3上尝试了developer.android.com的原始OpenGL示例代码，它只给了我一个空白屏幕！我改变了清晰的颜色和屏幕背景，但我仍然看不到任何三角形或正方形的代码指示

为了验证GPU的任何问题，我从play store运行了一些编译过的应用程序，所有这些应用程序都运行良好 然后，我在教程之后尝试使用自己的gl代码，它再次给出了一个空白屏幕，然后我尝试了第三方示例代码，猜猜又是什么空白屏幕

到底怎么了德国劳埃德船级社似乎除了背景色什么都不画

下面是我使用的android示例代码的链接

这是密码

 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package com.example.android.opengl;

import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.nio.FloatBuffer;

import android.opengl.GLES20;

/**
 * A two-dimensional triangle for use as a drawn object in OpenGL ES 2.0.
 */
public class Triangle {

    private final String vertexShaderCode =
            // This matrix member variable provides a hook to manipulate
            // the coordinates of the objects that use this vertex shader
            "uniform mat4 uMVPMatrix;" +
            "attribute vec4 vPosition;" +
            "void main() {" +
            // the matrix must be included as a modifier of gl_Position
            // Note that the uMVPMatrix factor *must be first* in order
            // for the matrix multiplication product to be correct.
            "  gl_Position = uMVPMatrix * vPosition;" +
            "}";

    private final String fragmentShaderCode =
            "precision mediump float;" +
            "uniform vec4 vColor;" +
            "void main() {" +
            "  gl_FragColor = vColor;" +
            "}";

    private final FloatBuffer vertexBuffer;
    private final int mProgram;
    private int mPositionHandle;
    private int mColorHandle;
    private int mMVPMatrixHandle;

    // number of coordinates per vertex in this array
    static final int COORDS_PER_VERTEX = 3;
    static float triangleCoords[] = {
            // in counterclockwise order:
            5.0f,  0.622008459f, 0.0f,   // top
           -5.5f, -0.311004243f, 0.0f,   // bottom left
            5.5f, -0.311004243f, 0.0f    // bottom right
    };
    private final int vertexCount = triangleCoords.length / COORDS_PER_VERTEX;
    private final int vertexStride = COORDS_PER_VERTEX * 4; // 4 bytes per vertex

    float color[] = { 0.63671875f, 0.76953125f, 0.22265625f, 0.0f };

    /**
     * Sets up the drawing object data for use in an OpenGL ES context.
     */
    public Triangle() {
        // initialize vertex byte buffer for shape coordinates
        ByteBuffer bb = ByteBuffer.allocateDirect(
                // (number of coordinate values * 4 bytes per float)
                triangleCoords.length * 4);
        // use the device hardware's native byte order
        bb.order(ByteOrder.nativeOrder());

        // create a floating point buffer from the ByteBuffer
        vertexBuffer = bb.asFloatBuffer();
        // add the coordinates to the FloatBuffer
        vertexBuffer.put(triangleCoords);
        // set the buffer to read the first coordinate
        vertexBuffer.position(0);

        // prepare shaders and OpenGL program
        int vertexShader = MyGLRenderer.loadShader(
                GLES20.GL_VERTEX_SHADER, vertexShaderCode);
        int fragmentShader = MyGLRenderer.loadShader(
                GLES20.GL_FRAGMENT_SHADER, fragmentShaderCode);

        mProgram = GLES20.glCreateProgram();             // create empty OpenGL Program
        GLES20.glAttachShader(mProgram, vertexShader);   // add the vertex shader to program
        GLES20.glAttachShader(mProgram, fragmentShader); // add the fragment shader to program
        GLES20.glLinkProgram(mProgram);                  // create OpenGL program executables

    }

    /**
     * Encapsulates the OpenGL ES instructions for drawing this shape.
     *
     * @param mvpMatrix - The Model View Project matrix in which to draw
     * this shape.
     */
    public void draw(float[] mvpMatrix) {
        // Add program to OpenGL environment
        GLES20.glUseProgram(mProgram);

        // get handle to vertex shader's vPosition member
        mPositionHandle = GLES20.glGetAttribLocation(mProgram, "vPosition");

        // Enable a handle to the triangle vertices
        GLES20.glEnableVertexAttribArray(mPositionHandle);

        // Prepare the triangle coordinate data
        GLES20.glVertexAttribPointer(
                mPositionHandle, COORDS_PER_VERTEX,
                GLES20.GL_FLOAT, false,
                vertexStride, vertexBuffer);

        // get handle to fragment shader's vColor member
        mColorHandle = GLES20.glGetUniformLocation(mProgram, "vColor");

        // Set color for drawing the triangle
        GLES20.glUniform4fv(mColorHandle, 1, color, 0);

        // get handle to shape's transformation matrix
        mMVPMatrixHandle = GLES20.glGetUniformLocation(mProgram, "uMVPMatrix");
        MyGLRenderer.checkGlError("glGetUniformLocation");

        // Apply the projection and view transformation
        GLES20.glUniformMatrix4fv(mMVPMatrixHandle, 1, false, mvpMatrix, 0);
        MyGLRenderer.checkGlError("glUniformMatrix4fv");

        // Draw the triangle
        GLES20.glDrawArrays(GLES20.GL_TRIANGLES, 0, vertexCount);

        // Disable vertex array
        GLES20.glDisableVertexAttribArray(mPositionHandle);
    }

}




/*
 * Copyright (C) 2011 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package com.example.android.opengl;

import javax.microedition.khronos.egl.EGLConfig;
import javax.microedition.khronos.opengles.GL10;

import android.opengl.GLES20;
import android.opengl.GLSurfaceView;
import android.opengl.Matrix;
import android.util.Log;

/**
 * Provides drawing instructions for a GLSurfaceView object. This class
 * must override the OpenGL ES drawing lifecycle methods:
 * <ul>
 *   <li>{@link android.opengl.GLSurfaceView.Renderer#onSurfaceCreated}</li>
 *   <li>{@link android.opengl.GLSurfaceView.Renderer#onDrawFrame}</li>
 *   <li>{@link android.opengl.GLSurfaceView.Renderer#onSurfaceChanged}</li>
 * </ul>
 */
public class MyGLRenderer implements GLSurfaceView.Renderer {

    private static final String TAG = "MyGLRenderer";
    private Triangle mTriangle;
    private Square   mSquare;

    // mMVPMatrix is an abbreviation for "Model View Projection Matrix"
    private final float[] mMVPMatrix = new float[16];
    private final float[] mProjectionMatrix = new float[16];
    private final float[] mViewMatrix = new float[16];
    private final float[] mRotationMatrix = new float[16];

    private float mAngle;

    @Override
    public void onSurfaceCreated(GL10 unused, EGLConfig config) {

        // Set the background frame color
        GLES20.glClearColor(0.0f, 0.0f, 0.2f, 1.0f);

        mTriangle = new Triangle();
        mSquare   = new Square();
    }

    @Override
    public void onDrawFrame(GL10 unused) {
        float[] scratch = new float[16];

        // Draw background color
        GLES20.glClear(GLES20.GL_COLOR_BUFFER_BIT | GLES20.GL_DEPTH_BUFFER_BIT);

        // Set the camera position (View matrix)
        Matrix.setLookAtM(mViewMatrix, 0, 0, 0, -3, 0f, 0f, 0f, 0f, 1.0f, 0.0f);

        // Calculate the projection and view transformation
        Matrix.multiplyMM(mMVPMatrix, 0, mProjectionMatrix, 0, mViewMatrix, 0);

        // Draw square
        mSquare.draw(mMVPMatrix);

        // Create a rotation for the triangle

        // Use the following code to generate constant rotation.
        // Leave this code out when using TouchEvents.
        // long time = SystemClock.uptimeMillis() % 4000L;
        // float angle = 0.090f * ((int) time);

        Matrix.setRotateM(mRotationMatrix, 0, mAngle, 0, 0, 1.0f);

        // Combine the rotation matrix with the projection and camera view
        // Note that the mMVPMatrix factor *must be first* in order
        // for the matrix multiplication product to be correct.
        Matrix.multiplyMM(scratch, 0, mMVPMatrix, 0, mRotationMatrix, 0);

        // Draw triangle
        mTriangle.draw(scratch);
    }

    @Override
    public void onSurfaceChanged(GL10 unused, int width, int height) {
        // Adjust the viewport based on geometry changes,
        // such as screen rotation
        GLES20.glViewport(0, 0, width, height);

        float ratio = (float) width / height;

        // this projection matrix is applied to object coordinates
        // in the onDrawFrame() method
        Matrix.frustumM(mProjectionMatrix, 0, -ratio, ratio, -1, 1, 3, 7);

    }

    /**
     * Utility method for compiling a OpenGL shader.
     *
     * <p><strong>Note:</strong> When developing shaders, use the checkGlError()
     * method to debug shader coding errors.</p>
     *
     * @param type - Vertex or fragment shader type.
     * @param shaderCode - String containing the shader code.
     * @return - Returns an id for the shader.
     */
    public static int loadShader(int type, String shaderCode){

        // create a vertex shader type (GLES20.GL_VERTEX_SHADER)
        // or a fragment shader type (GLES20.GL_FRAGMENT_SHADER)
        int shader = GLES20.glCreateShader(type);

        // add the source code to the shader and compile it
        GLES20.glShaderSource(shader, shaderCode);
        GLES20.glCompileShader(shader);

        return shader;
    }

    /**
    * Utility method for debugging OpenGL calls. Provide the name of the call
    * just after making it:
    *
    * <pre>
    * mColorHandle = GLES20.glGetUniformLocation(mProgram, "vColor");
    * MyGLRenderer.checkGlError("glGetUniformLocation");</pre>
    *
    * If the operation is not successful, the check throws an error.
    *
    * @param glOperation - Name of the OpenGL call to check.
    */
    public static void checkGlError(String glOperation) {
        int error;
        while ((error = GLES20.glGetError()) != GLES20.GL_NO_ERROR) {
            Log.e(TAG, glOperation + ": glError " + error);
            throw new RuntimeException(glOperation + ": glError " + error);
        }
    }

    /**
     * Returns the rotation angle of the triangle shape (mTriangle).
     *
     * @return - A float representing the rotation angle.
     */
    public float getAngle() {
        return mAngle;
    }

    /**
     * Sets the rotation angle of the triangle shape (mTriangle).
     */
    public void setAngle(float angle) {
        mAngle = angle;
    }

}

*
*根据Apache许可证2.0版（以下简称“许可证”）获得许可；
*除非遵守许可证，否则不得使用此文件。
*您可以通过以下方式获得许可证副本：
*
*      http://www.apache.org/licenses/LICENSE-2.0
*
*除非适用法律要求或书面同意，软件
*根据许可证进行的分发是按“原样”进行分发的，
*无任何明示或暗示的保证或条件。
*请参阅许可证以了解管理权限和权限的特定语言
*许可证下的限制。
*/
包com.example.android.opengl；
导入java.nio.ByteBuffer；
导入java.nio.ByteOrder；
导入java.nio.FloatBuffer；
导入android.opengl.GLES20；
/**
*在OpenGL ES 2.0中用作绘制对象的二维三角形。
*/
公共阶级三角{
私有最终字符串vertexShaderCode=
//这个矩阵成员变量提供了一个钩子来操作
//使用此顶点着色器的对象的坐标
“统一mat4 UMVP矩阵；”+
“属性向量4位置；”+
“void main（）{”+
//矩阵必须包含为gl_位置的修改器
//请注意，uMVPMatrix因子*必须是顺序中的第一个*
//为使矩阵乘法乘积正确。
“gl_Position=uMVPMatrix*vpposition；”+
"}";
私有最终字符串碎片ShaderCode=
“精密中泵浮动；”+
“统一vec4彩色；”+
“void main（）{”+
“gl_FragColor=vColor；”+
"}";
私有最终FloatBuffer vertexBuffer；
私人期末考试程序；
私有int-mPositionHandle；
米科洛汉德尔私人酒店；
私有int mMVPMatrixHandle；
//此数组中每个顶点的坐标数
每个顶点的静态最终整数坐标=3；
静态浮点三角形坐标[]={
//按逆时针顺序：
5.0f，0.622008459f，0.0f，//顶部
-5.5f，-0.311004243f，0.0f，//左下角
5.5f，-0.311004243f，0.0f//右下角
};
私有最终int vertexCount=三角形坐标。长度/每个顶点坐标；
private final int vertexStride=COORDS\u PER\u VERTEX*4；//每个顶点4字节
浮动颜色[]={0.63671875f，0.76953125f，0.22265625f，0.0f}；
/**
*设置图形对象数据以在OpenGL ES上下文中使用。
*/
公共三角（）{
//初始化形状坐标的顶点字节缓冲区
ByteBuffer bb=ByteBuffer.allocateDirect(
//（坐标值的数量*4字节/浮点）
三角形坐标。长度*4）；
//使用设备硬件的本机字节顺序
bb.order（ByteOrder.nativeOrder（））；
//从ByteBuffer创建浮点缓冲区
vertexBuffer=bb.asFloatBuffer（）；
//将坐标添加到浮动缓冲区
vertexBuffer.put（三角坐标）；
//设置缓冲区以读取第一个坐标
顶点缓冲区位置（0）；
//准备着色器和OpenGL程序
int vertexShader=MyGLRenderer.loadShader(
GLES20.GL_顶点着色器，vertexShaderCode）；
int fragmentShader=MyGLRenderer.loadShader(
GLES20.GL_FRAGMENT_着色器，fragmentShaderCode）；
mProgram=GLES20.glCreateProgram（）；//创建空的OpenGL程序
GLES20.glAttachShader（mProgram，vertexShader）；//将顶点着色器添加到程序中
GLES20.glAttachShader（mProgram，fragmentShader）；//将片段着色器添加到程序中
GLES20.glLinkProgram（mProgram）；//创建OpenGL程序可执行文件
}
/**
*封装用于绘制此形状的OpenGL ES说明。
*
*@param mvpMatrix-要在其中绘制的模型视图项目矩阵
*这个形状。
*/
公共作废提取（浮动[]MVP矩阵）{
//将程序添加到OpenGL环境中
GLES20.glUseProgram（mProgram）；
//获取顶点着色器的vPosition成员的句柄
mPositionHandle=GLES20.glGetAttriblLocation（mProgram，“vPosition”）；
//启用三角形顶点的控制柄
GLES20.GlenableVertexAttributeArray（mPositionHandle）；
//准备三角形坐标数据
GLES20.GlvertexAttribute指针(
位置句柄，每个顶点的坐标，
GLES20.GL_浮动，错误，
vertexStride，vertexBuffer）；
//获取片段着色器的vColor成员的句柄
mColorHandle=GLES20.glGetUniformLocation（mProgram，“vColor”）；
//设置绘制三角形的颜色
GLES20.glUniform4fv（McColorhandle，1，颜色，0）；
//获取形状变换矩阵的句柄
mMVPMatrixHandle=GLES20.glGetUniformLocation（mProgram，“uMVPMatrix”）；
MyGLRenderer.checklerror（“glGetUniformLocation”）；
//应用投影和视图变换
GLES20.GluniformMatrixHandle，1，false，mvpMatrix，0；
MyGLRenderer.checklerror（“glUniformMatrix4fv”）；
//画三角形
GLES20.GlDrawArray（GLES20.GL_三角形，0，顶点计数）；
//禁用