Android OpenGL ES e 2D

Bem, aqui está o meu pedido. Eu ainda não conheço OpenGL e não estou disposto a aprendê-lo. No entanto, quero aprender OpenGL ES diretamente, pois estou direcionando meu desenvolvimento para o Android. Quero aprender OpenGL ES para desenvolver meus jogos 2D . Eu o escolhi para fins de desempenho (já que o desenho básico do SurfaceView não é tão eficiente quando se trata de jogos RT). Minha pergunta é: por onde começar? Passei mais de um mês navegando no Google e lendo / tentando alguns tutoriais / exemplos que encontrei em qualquer lugar, mas para ser honesto, não ajudou muito e isso é por dois motivos:

1. Quase todos os artigos / tutoriais que encontrei são relacionados a 3D (eu só quero aprender como fazer meu desenho de Sprites 2D)
2. Não há base para começar, já que todos os artigos têm como objetivo coisas específicas como: "Como desenhar um triângulo (com vértices)", "Como criar uma malha" ... etc.

Também tentei ler alguns códigos-fonte (ex .: ilha de réplicas) mas os códigos são muito complicados e contêm muitas coisas que não são necessárias; Resultado: eu me perco entre 100 arquivos .java com nomes de classes estranhos e outras coisas.

Acho que não há nenhum curso como o que estou procurando, mas ficaria muito feliz se alguém pudesse me dar algumas orientações e alguns links, talvez para aprender o que estou fazendo (apenas renderização OpenGL ES 2D Sprites! Nada 3D )

Eu estava em uma situação similar.
A maneira como comecei com o openGL, comece olhando os exemplos / demos básicos de GLSurfaceView.

Comece configurando sua atividade de aplicativo e configure a tela básica.

Faça uma recompensa no arquivo de código-fonte da ilha de réplica: GameRenderer.java para saber como configurar sua tela com os sinalizadores GL adequados para renderização 2D (sprite). Você realmente deveria dar uma olhada no SpriteMethodTest do mesmo autor da replica island: http://code.google.com/p/apps-for-android/source/browse/trunk/SpriteMethodTest

Veja esta pergunta onde postei meu próprio código: Usando OpenGL para substituir Canvas - Android

Depois de configurar o canvas, comece chamando algo como: gl.glClear (GL10.GL_COLOR_BUFFER_BIT);

Depois disso, você está pronto para renderizar um sprite. Primeiro, você precisará carregar o sprite em uma textura: http://qdevarena.blogspot.com/2009/02/how-to-load-texture-in-android-opengl.html

No entanto, este é o tutorial que realmente me ajudou a carregar sprites: http://tkcodesharing.blogspot.com/2008/05/working-with-textures-in-androids.html

É assim que eu faço, tenho uma classe chamada 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;
 }
}

Então, em meu método onDrawFrame (), simplesmente faço:

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);

Isso deve ajudá-lo a desenhar sprites 2D em uma tela openGL. Percebi que não há nenhum tutorial direto sobre isso. Espero que no futuro eu poste um no meu blog dev: http://developingthedream.blogspot.com/

A programação 2D é apenas programação 3D restrita a um plano. Você não terá escolha a não ser aprender 3D, mas quando estiver usando, defina z = 0.

Existe um livro oficial sobre OpenGL ES. Isso pode lhe dar a introdução que você está procurando: http://www.amazon.com/OpenGL-ES-2-0-Programming-Guide/dp/0321502795/

Eu definitivamente daria uma olhada no Android - palestra de Chris Pruett Google IO Escrevendo jogos em tempo real para Android redux

pegue o PDF também

é muito útil em muitos níveis, Chris tem uma ótima experiência na criação de jogos para dispositivos móveis

mas se você estiver realmente focado em 2D, comece com Canvas http://developer.android.com/guide/topics/graphics/index.html#drawing-with-canvas

Outra opção depende do nível de habilidade é Flash + AdobeAIR para Android, eu mesmo gosto e amo o nível de programação e conforme você começar a desenvolver, você descobrirá o porquê.

OpenGL: Verificar - Nehe Productions

alguns aplicativos que você pode querer colocar em seu telefone que valem a pena e são gratuitos são: OpenGL Demo, min3d Framework, RedBook Sample

Você pode ver o projeto: https://github.com/ChillingVan/android-openGL-canvas/blob/master/README-en.md Isso implementa o canvas com OpenGL. É Java puro. Ele implementa partes do que o canvas normal pode fazer.

Vejo que muitas informações boas já foram fornecidas. Eu queria compartilhar um site que ajudou a acelerar o OpenGLE rapidamente! Demorou apenas alguns meses e tinha um sistema de coordenadas personalizado baseado no sistema de coordenadas cartesiano. Consegui renderizar objetos 3D sem câmera usando técnicas de Realidade Aumentada.

Comecei apenas com experiência em programação, sem nenhuma experiência em OpenGL. Usei o site de tutoriais de Ray Wenderlich. As informações fornecidas lá são excelentes e fáceis de compreender. Ele corta a maioria das informações supérfluas e fornece o que você precisa saber para ser produtivo rapidamente. Recomendo fortemente este tutorial como ponto de partida: http://www.raywenderlich.com/5223/beginning-opengl-es-2-0-with-glkit-part-1

O outro recurso que recomendo é um livro de Erik M Buck, intitulado Learning OpenGL ES for iOS.

Alguns criticaram dizendo que era muito simplista. Mas isso é exatamente o que eu estava procurando. Isso me ajudou a entender todos os fundamentos e me deu uma ideia de onde devo ir a seguir para aprender coisas mais avançadas. Mas não surpreendentemente, fui capaz de construir meu aplicativo de realidade aumentada usando as técnicas simples que aprendi no site de Ray e no livro de Erik. Obrigado a ambos por compartilharem !!!

Existem muitos tutoriais online que você pode seguir, mas para um iniciante nada pode substituir este: Um verdadeiro tutorial 2D do Open GL ES 2.0