El ejemplo de Android openGL da una pantalla en blanco
Acabo de probar el original GL código de ejemplo abierto de developer.android.com en una galaxia s3 y todo lo que me dio era una pantalla en blanco! Cambié el color claro y el fondo de la pantalla cambiado pero todavía no puedo ver ningún triángulo o cuadrado como el código indica.
Para verificar cualquier problema con la GPU he corrido algunas aplicaciones compiladas de la tienda de juegos y todo funciona bien, entonces he intentado con mi propio código gl después del tutorial y de nuevo Se dio una pantalla en blanco entonces he intentado un código de ejemplo de terceros y adivinar qué otra vez pantalla en blanco !
- No se puede encontrar el diseñador de interfaz de usuario en el nuevo estudio de Android
- Alternativas compactas a Java ArrayList <String>
- No puede ver datos Sqlite con adaptador simple
- ¿Cómo hacer que el código se detenga por un par de segundos en android?
- Android Intent Context Confusing
¿Qué diablos está mal el GL no parece dibujar nada, excepto el color de fondo
Aquí hay un enlace al código de ejemplo de Android que usé
Http://developer.android.com/shareables/training/OpenGLES.zip
Este es el codigo
* * 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; } }
- Cómo utilizar recursos enteros dentro de recursos de cadena en android
- Mapbox infla la vista en el fragmento
- Android Expandible RecyclerView diferente Altura de la tarjeta
- Andtouide edittext minmum y valor máximo
- AudioTrack muestra inconsistencias
- ¿por qué mi aplicación Android es tan lenta?
- Error al instalar parches de reinicio cuando se inicia la aplicación android con Android Studio 2.0
- ¿Cómo puedo eliminar un elemento específico de un JSONArray?
Para mí, la corrección vino de la comparación de estas dos matrices
-
Uno establece la vista (el ojo) para que sea "-3" en el eje Z:
Matrix.setLookAtM (mViewMatrix, 0, 0, 0, -3, 0f, 0f, 0f, 0f, 1,0f, 0,0f);
-
El otro establece el espacio que debe ser visible. En la muestra original de google, el plano "cercano" se establece en 3 y el plano "distante" en 7:
Matrix.frustumM (mMáquina de proyección, 0, -ratio, relación, -1, 1, 3, 7);
Esto pone su triángulo en el borde mismo del espacio visualizado. Parece que estos intervalos están abiertos, ya que estar en el borde mismo no muestra nada.
Para ajustar esto, simplemente cambié la definición de espacio visualizado a "cerca = 2" como sigue: Matrix.frustumM (mMáquina de proyección, 0, -ratio, ratio, -1, 1, 2, 7);
Y el auge, de repente yo estaba en el negocio 😉
No estoy seguro de por qué la muestra de google original está configurado de tal manera que realmente no ver nada. Podría ser que poner un reto para enseñarnos (muy temprano) principiantes 😉 espero que esto ayuda