Android OpenGL ES und 2D

Nun, hier ist meine Bitte. Ich kenne OpenGL noch nicht, und ich bin nicht bereit, es zu lernen, ich möchte OpenGL ES direkt lernen, da ich meine Entwicklung jedoch auf Android ausrichte. Ich möchte OpenGL ES lernen, um meine zu entwickeln 2D Spiele. Ich habe es für Leistungszwecke ausgewählt (da das grundlegende SurfaceView-Zeichnen bei RT-Spielen nicht so effizient ist). Meine Frage ist: wo anfangen? Ich habe über einen Monat damit verbracht, Google zu durchsuchen und einige Tutorials/Beispiele zu lesen/auszuprobieren, die ich irgendwo gefunden habe, aber um ehrlich zu sein, es hat nicht viel geholfen, und das aus zwei Gründen:

1. Fast alle Die Artikel/Tutorials, auf die ich gestoßen bin, beziehen sich auf 3D (ich möchte nur lernen, wie ich meine 2D-Sprites-Zeichnung mache).
2. Es gibt keine Ausgangsbasis, da alle Artikel auf bestimmte Dinge abzielen wie: „Wie man ein Dreieck zeichnet (mit Scheitelpunkten)“, „Wie man ein Netz erstellt“ usw.

Ich habe auch versucht, Quellcode zu lesen (z. B.: Replica Island), aber die Codes sind zu kompliziert und enthalten viele Dinge, die nicht notwendig sind. Ergebnis: Ich verliere mich zwischen 100 .java-Dateien mit seltsamen Klassennamen und so.

Ich denke, es gibt keinen Kurs wie den, den ich suche, aber ich wäre sehr froh, wenn mir jemand einige Richtlinien und einige geben könnte Verknüpfungen vielleicht um zu lernen, was ich vorhabe (nur OpenGL ES 2D-Sprites-Rendering! nichts 3D).

Ich war in einer ähnlichen Situation.
Die Art und Weise, wie ich mit OpenGL begonnen habe, begann mit einem Blick auf die sehr einfachen GLSurfaceView-Beispiele/Demos.

Beginnen Sie mit der Einrichtung Ihrer App-Aktivität und richten Sie die grundlegende Leinwand ein.

Werfen Sie einen Blick auf die Quellcodedatei der Replikinsel: GameRenderer.java, um zu erfahren, wie Sie Ihre Leinwand mit den richtigen GL-Flags für das 2D-Rendering (Sprite) einrichten. Sie sollten sich unbedingt den SpriteMethodTest des gleichen Autors von Replica Island ansehen: http://code.google.com/p/apps-for-android/source/browse/trunk/SpriteMethodTest

Sehen Sie sich diese Frage an, in der ich meinen eigenen Code gepostet habe: Verwenden von OpenGL zum Ersetzen von Canvas – Android

Nachdem Sie Ihre Leinwand eingerichtet haben, rufen Sie so etwas wie: gl.glClear(GL10.GL_COLOR_BUFFER_BIT);

Danach können Sie ein Sprite rendern. Zuerst müssen Sie das Sprite in eine Textur laden: http://qdevarena.blogspot.com/2009/02/how-to-load-texture-in-android-opengl.html

Dies ist jedoch das Tutorial, das mir beim Laden von Sprites wirklich geholfen hat:
http://tkcodesharing.blogspot.com/2008/05/working-with-textures-in-androids.html

So mache ich es, ich habe eine Klasse namens 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;
 }
}

Dann mache ich in meiner onDrawFrame() Methode einfach:

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

Das sollte Sie dazu bringen, 2D-Sprites auf einer OpenGL-Leinwand zu zeichnen. Mir ist aufgefallen, dass es dazu kein wirklich einfaches Tutorial gibt. Hoffentlich werde ich in Zukunft einen in meinem Dev-Blog posten: http://developingthedream.blogspot.com/

2D-Programmierung ist nur 3D-Programmierung, die auf eine Ebene beschränkt ist. Sie haben keine andere Wahl, als 3D zu lernen, aber wenn Sie es verwenden, setzen Sie einfach z = 0.

Es gibt ein offizielles Buch zu OpenGL ES. Das könnte Ihnen die Einführung geben, nach der Sie suchen: http://www.amazon.com/OpenGL-ES-2-0-Programming-Guide/dp/0321502795/

Ich würde Android definitiv auschecken – Chris Pruett Google IO-Vorlesung Schreiben von Echtzeitspielen für Android Redux

schnapp dir auch das PDF

Es ist auf vielen Ebenen wirklich hilfreich, Chris hat wirklich großartige Erfahrung mit der Entwicklung von Spielen für mobile Geräte

Wenn Sie sich jedoch wirklich auf 2D konzentrieren, beginnen Sie mit Canvas
http://developer.android.com/guide/topics/graphics/index.html#drawing-with-canvas

Eine andere Option hängt vom Können ab und ist Flash + AdobeAIR für Android. Ich selbst mag und liebe das Programmierniveau, und wenn Sie mit der Entwicklung beginnen, werden Sie herausfinden, warum.

OpenGL: Suchen Sie nach – Nehe Productions

Ein paar Apps, die Sie vielleicht auf Ihr Telefon installieren möchten, die sich lohnen und die kostenlos sind, sind: OpenGL Demo, min3d Framework, RedBook Sample

Sie können das Projekt sehen:
https://github.com/ChillingVan/android-openGL-canvas/blob/master/README-en.md
Dies implementiert Canvas mit OpenGL. Es ist reines Java. Es implementiert Teile dessen, was normale Leinwand tun kann.

Es gibt viele Online-Tutorials, denen Sie folgen können, aber für einen Anfänger kann nichts dieses ersetzen: Ein echtes Open GL ES 2.0 2D-Tutorial