Android OpenGL ES e 2D


95

Bene, ecco la mia richiesta. Non conosco già OpenGL e non sono disposto a impararlo, voglio imparare OpenGL ES direttamente poiché sto indirizzando il mio sviluppo su Android, tuttavia. Voglio imparare OpenGL ES per sviluppare i miei giochi 2D . L'ho scelto per motivi di prestazioni (poiché il disegno di SurfaceView di base non è così efficiente quando si tratta di giochi RT). La mia domanda è: da dove cominciare? Ho trascorso più di un mese navigando su Google e leggendo / provando alcuni tutorial / esempi che ho trovato ovunque, ma ad essere onesti, non è stato di grande aiuto e questo per due motivi:

  1. Quasi tutti gli articoli / tutorial in cui mi sono imbattuto sono relativi al 3D (voglio solo imparare a disegnare i miei sprite 2D)
  2. Non c'è una base da cui partire poiché tutti gli articoli si rivolgono a cose specifiche come: "Come disegnare un triangolo (con vertici)", "Come creare una Mesh" ... ecc.

Ho provato anche a leggere del codice sorgente (es .: replica island) ma i codici sono troppo complicati e contengono molte cose che non sono necessarie; risultato: mi perdo tra 100 file .java con nomi di classi strani e cose del genere.

Immagino che non ci sia un corso come quello che sto cercando, ma sarò molto contento se qualcuno potesse darmi alcune linee guida e alcuni link magari per imparare cosa sto facendo (solo OpenGL ES 2D Sprites rendering! Niente 3D ).


33
and I'm not willing to learn itNon è un modo molto buono per iniziare una domanda qui
Falmarri

62
Per favore leggi tutta la mia domanda, ne hai preso una parte sensibile e hai lasciato il completamento più importante: "Non conosco già OpenGL e non sono disposto a impararlo, voglio imparare OpenGL ES direttamente poiché sono indirizzare il mio sviluppo ad Android "Qual è il punto di imparare OpenGL se ho intenzione di lavorare solo con OpenGL ES su dispositivi embedded? Saluti
CoolStraw

5
Dato che OpenGL ES è principalmente un sottoinsieme di OpenGL, non vedo il motivo di dire che non imparerai OpenGL, poiché per definizione dovrai farlo.
dash-tom-bang

2
BTW- Replica Island è praticamente il posto dove guardare. Potresti iniziare con quello e iniziare apportando modifiche. Elimina le cose che non vuoi o non ti servono, e poi 100 lezioni diventano 99, poi 98 e poi 97 ...
dash-tom-bang

Risposte:


85

Sono stato in una situazione simile.
Il modo in cui ho iniziato con openGL è iniziato guardando i campioni / demo GLSurfaceView di base.

Inizia impostando l'attività dell'app e la tela di base.

Prendi un bottino al file del codice sorgente dell'isola di replica: GameRenderer.java per come impostare la tua tela con i flag GL appropriati per il rendering 2D (sprite). Dovresti davvero dare un'occhiata a SpriteMethodTest dello stesso autore di replica island: http://code.google.com/p/apps-for-android/source/browse/trunk/SpriteMethodTest

Vedi questa domanda dove ho pubblicato il mio codice: Uso di OpenGL per sostituire Canvas - Android

Dopo aver impostato la tua tela, inizi chiamando qualcosa come: gl.glClear (GL10.GL_COLOR_BUFFER_BIT);

Dopo di che sei pronto per eseguire il rendering di uno sprite. Per prima cosa, dovrai caricare lo sprite in una texture: http://qdevarena.blogspot.com/2009/02/how-to-load-texture-in-android-opengl.html

Tuttavia, questo è il tutorial che mi ha davvero aiutato a caricare gli sprite: http://tkcodesharing.blogspot.com/2008/05/working-with-textures-in-androids.html

Ecco come lo faccio, ho una classe chiamata 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;
 }
}

Quindi nel mio metodo onDrawFrame () faccio semplicemente:

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

Questo dovrebbe aiutarti a disegnare sprite 2D su una tela openGL. Ho notato che non esiste davvero un tutorial semplice su questo. Spero che in futuro ne pubblicherò uno nel mio blog di sviluppo: http://developingthedream.blogspot.com/


7
Amico grazie mille! Non ho mai ricevuto indicazioni come queste, è esattamente quello che stavo cercando! E terrò d'occhio il tuo blog, speriamo che in futuro ci
fornirai

1
Nella stessa situazione di OP e grato come lui per la tua risposta. Buona fortuna con il tuo gioco / blog. grazie ancora
unR

1
Grazie @Miguel Morales Ero stanco di cercare il disegno 2D con GL. Come ha detto CoolStraw, ci sono troppi tutorial con molte cose non necessarie. Quella risposta era chiara come un cristallo.
Evren Ozturk

@Miguel Morales Dopo molti tentativi non riesco a disegnare nulla perché le mie trame risultano nere. Ho posto una domanda stackoverflow.com/questions/9624260/… puoi dare un'occhiata?
Evren Ozturk

12

La programmazione 2D è solo una programmazione 3D vincolata a un piano. Non avrai altra scelta che imparare il 3D, ma quando lo usi imposta z = 0.

C'è un libro ufficiale su OpenGL ES. Questo potrebbe darti l'intro che stai cercando: http://www.amazon.com/OpenGL-ES-2-0-Programming-Guide/dp/0321502795/


8
Per essere pedante, usi comunque Z in modo da poter lasciare che l'hardware esegua l'ordinamento per te. Il grande cambiamento è che (probabilmente) l'applicazione 2D utilizzerà una vista ortografica invece di una prospettiva.
dash-tom-bang

Grazie mille per la tua risposta, la tua dichiarazione mi mostra che mi sbagliavo sulla definizione di Opengl e Opengl ES.
CoolStraw

3

Vorrei sicuramente controllare Android - Conferenza di Chris Pruett Google IO Scrivere giochi in tempo reale per Android redux

prendi anche il PDF

è davvero utile a molti livelli, Chris ha davvero una grande esperienza nella creazione di giochi per dispositivi mobili

ma se sei veramente concentrato sul 2D, inizia con Canvas http://developer.android.com/guide/topics/graphics/index.html#drawing-with-canvas

Un'altra opzione dipende dal livello di abilità è Flash + AdobeAIR per Android, mi piace e amo il livello di programmazione e mentre inizi a sviluppare ulteriormente scoprirai perché.

OpenGL: Controlla - Nehe Productions

un paio di app che potresti voler mettere sul tuo telefono che ne vale la pena e sono gratuite sono: OpenGL Demo, min3d Framework, RedBook Sample



0

Vedo che sono già state fornite molte informazioni utili. Volevo condividere un sito che mi aiutasse a diventare rapidamente aggiornato su OpenGLE! Ci sono voluti solo pochi mesi e aveva un sistema di coordinate personalizzato basato sul sistema di coordinate cartesiane. Sono stato in grado di eseguire il rendering di oggetti 3D senza fotocamera utilizzando le tecniche di realtà aumentata.

Ho iniziato con la sola esperienza di programmazione, senza esperienza OpenGL. Ho usato il sito dei tutorial di Ray Wenderlich. Le informazioni fornite sono di prim'ordine e facili da comprendere. Elimina la maggior parte delle informazioni superflue e fornisce ciò di cui hai bisogno per essere produttivo rapidamente. Consiglio vivamente questo tutorial come punto di partenza: http://www.raywenderlich.com/5223/beginning-opengl-es-2-0-with-glkit-part-1

L'altra risorsa che consiglierei è un libro di Erik M Buck, intitolato Learning OpenGL ES per iOS.

Imparare OpenGL ES per la copertina del libro iOS

Alcuni lo hanno criticato dicendo che era troppo semplicistico. Ma è esattamente quello che stavo cercando. Mi ha aiutato a capire tutte le basi e mi ha dato un'idea su dove dovrei andare per imparare cose più avanzate. Ma non a caso, sono stato in grado di creare la mia app di realtà aumentata utilizzando le semplici tecniche che avevo imparato dal sito di Ray e dal libro di Erik. Grazie ad entrambi per la condivisione !!!


Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.