Android OpenGL ES und 2D

Hier ist meine Bitte. Ich kenne OpenGL noch nicht und 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 2D- Spiele zu entwickeln . Ich habe es für Aufführungszwecke ausgewählt (da das einfache SurfaceView-Zeichnen bei RT-Spielen nicht so effizient ist). Meine Frage ist: Wo soll ich anfangen? Ich habe über einen Monat damit verbracht, bei Google zu surfen und einige Tutorials / Beispiele zu lesen / auszuprobieren, die ich irgendwo gefunden habe, aber um ehrlich zu sein, es hat nicht viel geholfen, und das hat zwei Gründe:

1. Fast alle Artikel / Tutorials, auf die ich gestoßen bin, beziehen sich auf 3D (ich möchte nur lernen, wie ich meine 2D-Sprites zeichne).
2. Es gibt keine Basis, von der aus man beginnen kann, da alle Artikel auf bestimmte Dinge abzielen wie: "Wie zeichnet man ein Dreieck (mit Eckpunkten)", "Wie erstelle ich ein Netz" ... usw.

Ich habe versucht, auch einen Quellcode zu lesen (z. B. Replik-Insel), aber die Codes sind zu kompliziert und enthalten viele Dinge, die nicht notwendig sind. Ergebnis: Ich verliere mich unter 100 Java-Dateien mit seltsamen Klassennamen und so.

Ich denke, es gibt keinen Kurs wie den, den ich suche, aber ich bin sehr froh, wenn mir jemand einige Richtlinien und Links geben könnte, um zu erfahren, was ich vorhabe (nur OpenGL ES 2D Sprites-Rendering! Nichts 3D ).

Ich war in einer ähnlichen Situation.
So wie ich mit openGL angefangen habe, habe ich mir zunächst die sehr grundlegenden GLSurfaceView-Beispiele / -Demos angesehen.

Beginnen Sie, indem Sie Ihre App-Aktivität einrichten und die grundlegende Zeichenfläche einrichten.

Machen Sie eine Beute in der 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 SpriteMethodTest des gleichen Autors von Replica Island unbedingt ansehen: http://code.google.com/p/apps-for-android/source/browse/trunk/SpriteMethodTest

In dieser Frage habe ich meinen eigenen Code gepostet: Verwenden von OpenGL als Ersatz für Canvas - Android

Nachdem Sie Ihre Zeichenfläche eingerichtet haben, rufen Sie zunächst Folgendes auf: 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 das, 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);

Damit sollten Sie 2D-Sprites auf einer openGL-Leinwand zeichnen können. Mir ist aufgefallen, dass es dazu wirklich kein einfaches Tutorial gibt. Hoffentlich werde ich in Zukunft einen in meinem Entwickler-Blog veröffentlichen: 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 über OpenGL ES. Das könnte Ihnen das Intro geben, nach dem Sie suchen: http://www.amazon.com/OpenGL-ES-2-0-Programming-Guide/dp/0321502795/

Ich würde auf jeden Fall Android - Chris Pruett Google IO Vortrag schreiben. Schreiben von Echtzeitspielen für Android Redux

Holen Sie sich auch das PDF

Es ist auf vielen Ebenen sehr hilfreich. Chris hat wirklich großartige Erfahrungen mit der Erstellung 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, die vom Kenntnisstand abhängt, ist Flash + AdobeAIR für Android. Ich selbst mag und luv Programmierstufe. Wenn Sie mit der Weiterentwicklung beginnen, werden Sie herausfinden, warum.

OpenGL: Nach - Nehe Productions suchen

Einige Apps, die Sie möglicherweise auf Ihr Telefon laden 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 kann.

Ich sehe, dass viele gute Informationen bereits bereitgestellt wurden. Ich wollte eine Seite teilen, die mir geholfen hat, mich schnell mit OpenGLE vertraut zu machen! Es dauerte nur wenige Monate und hatte ein benutzerdefiniertes Koordinatensystem, das auf dem kartesischen Koordinatensystem basierte. Mit Augmented Reality-Techniken konnte ich 3D-Objekte ohne Kamera rendern.

Ich habe nur mit Programmiererfahrung begonnen, ohne OpenGL-Erfahrung. Ich habe Ray Wenderlichs Tutorials-Seite benutzt. Die dort bereitgestellten Informationen sind erstklassig und leicht zu verstehen. Er schneidet die meisten überflüssigen Informationen durch und liefert alles, was Sie wissen müssen, um schnell produktiv zu sein. Ich empfehle dieses Tutorial als Ausgangspunkt: http://www.raywenderlich.com/5223/beginning-opengl-es-2-0-with-glkit-part-1

Die andere Ressource, die ich empfehlen würde, ist ein Buch von Erik M Buck mit dem Titel Learning OpenGL ES für iOS.

Einige kritisierten es als zu simpel. Aber genau das habe ich gesucht. Es half mir, alle Grundlagen zu verstehen und gab mir eine Idee, wohin ich als nächstes gehen sollte, um fortgeschrittenere Dinge zu lernen. Aber es war nicht überraschend, dass ich meine Augmented Reality-App mit den einfachen Techniken erstellen konnte, die ich von Rays Website und Eriks Buch gelernt hatte. Vielen Dank an beide fürs Teilen !!!

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