Android OpenGL ES y 2D

Bueno, aquí está mi solicitud. No conozco OpenGL ya, y no estoy dispuesto a aprenderlo, pero quiero aprender OpenGL ES directamente ya que estoy apuntando mi desarrollo a Android. Quiero aprender OpenGL ES para poder desarrollar mis juegos 2D . Lo elegí por motivos de rendimiento (ya que el dibujo básico de SurfaceView no es tan eficiente cuando se trata de juegos RT). Mi pregunta es: ¿por dónde empezar? Pasé más de un mes navegando en Google y leyendo / probando algunos tutoriales / ejemplos que encontré en todas partes, pero para ser honesto, no ayudó mucho y esto se debe a dos razones:

1. Casi todos los artículos / tutoriales que he encontrado están relacionados con 3D (solo quiero aprender a hacer mis dibujos de Sprites en 2D)
2. No hay una base desde la que empezar, ya que todos los artículos apuntan a cosas específicas como: "Cómo dibujar un triángulo (con vértices)", "Cómo crear una malla" ... etc.

También he intentado leer algo de código fuente (por ejemplo: isla de réplica) pero los códigos son demasiado complicados y contienen muchas cosas que no son necesarias; resultado: me pierdo entre 100 archivos .java con nombres de clases extraños y esas cosas.

Supongo que no hay un curso como el que estoy buscando, pero me alegraría mucho si alguien me pudiera dar algunas pautas y algunos enlaces, tal vez para aprender lo que estoy haciendo (¡solo renderizado OpenGL ES 2D Sprites! Nada 3D ).

Yo estaba en una situación similar.
La forma en que comencé con openGL comenzó mirando las muestras / demostraciones de GLSurfaceView muy básicas.

Para comenzar, configure la actividad de su aplicación y configure el lienzo básico.

Obtenga un botín en el archivo de código fuente de la réplica de la isla: GameRenderer.java para saber cómo configurar su lienzo con las banderas GL adecuadas para la representación 2D (sprite). Realmente debería echar un vistazo a SpriteMethodTest por el mismo autor de la isla de réplicas: http://code.google.com/p/apps-for-android/source/browse/trunk/SpriteMethodTest

Vea esta pregunta donde publiqué mi propio código: Uso de OpenGL para reemplazar Canvas - Android

Una vez que haya configurado su lienzo, comience llamando a algo como: gl.glClear (GL10.GL_COLOR_BUFFER_BIT);

Después de eso, estará listo para renderizar un objeto. Primero, necesitarás cargar el sprite en una textura: http://qdevarena.blogspot.com/2009/02/how-to-load-texture-in-android-opengl.html

Sin embargo, este es el tutorial que realmente me ayudó con la carga de sprites: http://tkcodesharing.blogspot.com/2008/05/working-with-textures-in-androids.html

Así es como lo hago, tengo una clase llamada Texture.java:

public class Texture
{
    /*Begin public declarations*/
    public float x = 0;
    public float y = 0;
    public float z = 0;
    public float width = 0;
    public float height = 0;
    /*Begin Private Declarations*/
    private GL10 gl;
    public int[] texture;    //holds the texture in integer form
    private int texture_name;
    private int[] mCropWorkspace;
    private final BitmapFactory.Options sBitmapOptions;


/*Begin Methods*/
public Texture( GL10 gl_obj )
{
    gl = gl_obj;
    texture = new int[1];
    mCropWorkspace = new int[4];
    sBitmapOptions = new BitmapFactory.Options();
    sBitmapOptions.inPreferredConfig = Bitmap.Config.RGB_565;
    //Log.d(TAG, "Initializing Texture Object");
}    
public int get_texture_name( )
{
    return texture_name;
}

/*Loads the resource to memory*/
public boolean Load( Bitmap bitmap ) //rename this to glLoad and don't have it as an initializer parameter
{
    /*many thanks to sprite method test if this works*/
    if ( gl == null )
    {
        Log.e(TAG, "Failed to load resource.  Context/GL is NULL");
        return false;
    }
    int error;

    int textureName = -1;
    gl.glGenTextures(1, texture, 0);
    textureName = texture[0];

    //Log.d(TAG, "Generated texture: " + textureName);
    gl.glBindTexture(GL10.GL_TEXTURE_2D, textureName);
    gl.glTexParameterf(GL10.GL_TEXTURE_2D, GL10.GL_TEXTURE_MIN_FILTER, GL10.GL_NEAREST);
    gl.glTexParameterf(GL10.GL_TEXTURE_2D, GL10.GL_TEXTURE_MAG_FILTER, GL10.GL_LINEAR);
    gl.glTexParameterf(GL10.GL_TEXTURE_2D, GL10.GL_TEXTURE_WRAP_S, GL10.GL_CLAMP_TO_EDGE);
    gl.glTexParameterf(GL10.GL_TEXTURE_2D, GL10.GL_TEXTURE_WRAP_T, GL10.GL_CLAMP_TO_EDGE);
    gl.glTexEnvf(GL10.GL_TEXTURE_ENV, GL10.GL_TEXTURE_ENV_MODE, GL10.GL_REPLACE);

    GLUtils.texImage2D(GL10.GL_TEXTURE_2D, 0, bitmap, 0);

    mCropWorkspace[0] = 0;
    mCropWorkspace[1] = bitmap.getHeight();
    mCropWorkspace[2] = bitmap.getWidth();
    mCropWorkspace[3] = -bitmap.getHeight();

    ((GL11) gl).glTexParameteriv(GL10.GL_TEXTURE_2D, 
            GL11Ext.GL_TEXTURE_CROP_RECT_OES, mCropWorkspace, 0);

    error = gl.glGetError();
    if (error != GL10.GL_NO_ERROR)
    { 
        Log.e(TAG, "GL Texture Load Error: " + error);

    }
    //Log.d(TAG, "Loaded texture: " + textureName);
    return true;
 }
}

Luego, en mi método onDrawFrame () simplemente hago:

Texture texture = ...
gl.glBindTexture(GL10.GL_TEXTURE_2D, texture.texture[0]);
((GL11Ext) gl).glDrawTexfOES((float)(draw_x + 0.5), (float)(draw_y + 0.5), 0, tile_width, tile_height);

Eso debería ayudarte a dibujar sprites 2D en un lienzo OpenGL. He notado que realmente no hay un tutorial sencillo sobre esto. Espero que en el futuro publique uno en mi blog de desarrollo: http://developingthedream.blogspot.com/

La programación 2D es solo programación 3D restringida a un plano. No tendrá más remedio que aprender 3D, pero cuando lo esté usando, configure z = 0.

Hay un libro oficial sobre OpenGL ES. Eso podría darle la introducción que está buscando: http://www.amazon.com/OpenGL-ES-2-0-Programming-Guide/dp/0321502795/

Definitivamente revisaría Android - Chris Pruett Google IO lecture Cómo escribir juegos en tiempo real para Android redux

coge el PDF también

es realmente útil en muchos niveles, Chris tiene una gran experiencia en la creación de juegos para dispositivos móviles

pero si está realmente enfocado en 2D, comience con Canvas http://developer.android.com/guide/topics/graphics/index.html#drawing-with-canvas

Otra opción que depende del nivel de habilidad es Flash + AdobeAIR para Android, a mí me gusta y me encanta el nivel de programación y, a medida que comiences a desarrollar, descubrirás por qué.

OpenGL: Verificar - Nehe Productions

Un par de aplicaciones que puede querer poner en su teléfono que valen la pena y son gratuitas son: OpenGL Demo, min3d Framework, RedBook Sample

Puede ver el proyecto: https://github.com/ChillingVan/android-openGL-canvas/blob/master/README-en.md Esto implementa lienzo con OpenGL. Es Java puro. Implementa partes de lo que puede hacer el lienzo normal.

Veo que ya se ha proporcionado mucha información buena. ¡Quería compartir un sitio que ayudó a ponerme al día con OpenGLE rápidamente! Solo tomó unos meses y tenía un sistema de coordenadas personalizado basado en el sistema de coordenadas cartesiano. Pude renderizar objetos 3D sin cámara usando técnicas de realidad aumentada.

Comencé solo con experiencia en programación, sin experiencia en OpenGL. Usé el sitio de tutoriales de Ray Wenderlich. La información proporcionada allí es de primera categoría y fácil de comprender. Corta la mayor parte de la información superflua y proporciona lo que necesita saber para ser productivo rápidamente. Recomiendo este tutorial como punto de partida: http://www.raywenderlich.com/5223/beginning-opengl-es-2-0-with-glkit-part-1

El otro recurso que recomendaría es un libro de Erik M Buck, titulado Learning OpenGL ES para iOS.

Algunos lo criticaron diciendo que era demasiado simplista. Pero eso es exactamente lo que estaba buscando. Me ayudó a comprender todos los conceptos básicos y me dio una idea de adónde debería ir para aprender cosas más avanzadas. Pero como era de esperar, pude crear mi aplicación de realidad aumentada usando las técnicas simples que había aprendido del sitio de Ray y del libro de Erik. Gracias a ambos por compartir !!!

Hay muchos tutoriales en línea que puede seguir, pero para un principiante nada puede reemplazar este: Un verdadero tutorial de Open GL ES 2.0 2D