No se encuentra un ejemplo adecuado para la clase de sprite de Android 2d OpenGL que no utiliza GL11Ext para el dibujo

Question

Como SpriteMethodTest dice que hay muchas formas de dibujar los sprites. Primero probé el lienzo y tuve algunos problemas de rendimiento. Entonces decidí aprender OpenGL. Hice mis primeros logros usando la extensión GL11Ext. pero usted sabe de forma predeterminada que cuando dibuja texturas se invierten y los ejes xey tienen cero en la esquina inferior izquierda de la pantalla del dispositivo (en modo horizontal) no como el lienzo y no se pueden rotar los sprites.

Que intenté afectar esta vista del eje usando la vista de GLU. Pero no tuvo efecto.

De lo que quería girar mis sprites y no tuvo efecto causa de GL11Ext como dicen.

así que tengo la condición importante StackOverflow ahora y la pregunta básica es:

1. ¿Qué método a utilizar para lograr el zoom, Rotación y efectos en los sprites de rebote y por mirar ejes X e Y EN OLD SWEET ¿MANERA [(0,0) ESTÁ EN LA PARTE SUPERIOR IZQUIERDA EN MODO PAISAJE]?

2. ¿Y HAY ALGÚN EJEMPLO DE LA CLASE DE SPRITE EN EL UNIVERSO QUE SE USA ÚNICAMENTE EN 1 BUEN CAMINO DE SPRITE RENDERING? (SpriteMethodTest me confunde mucho)

Answer 1

EVRIKA !!!

¡Estaba casi matándome! después de 3 días de abandonar Canvas y aprender métodos OpenGL para implementar el motor del juego.

La web está llena de tutoriales OpenGL llenos de basura y muchos de ellos no están terminados y muchos de ellos conducen a un camino equivocado para la implementación de motor de juego 2D OpenGL. El gran punto equivocado es usar G11Ext para hacer juegos. Ya que te GIRAR: D

Annd annd Entonces me encontré con este tutorial de otro tutorial que me pareció de youtube muestra de juego enlace de video lol:

no confundir a los espectadores aquí es

Capítulo 1: http://obviam.net/index.php/opengl-es-with-android-switching-from-canvas-to-opengl/

Capítulo 2: http://obviam.net/index.php/opengl-es-android-displaying-graphical-elements-primitives/

Capítulo 3: http://obviam.net/index.php/texture-mapping-opengl-android-displaying-images-using-opengl-and-squares/

¡Y hace solo 15 minutos que descubrí la forma en que puedo GIRAR, MOVER Y REDIMENSTRAR formas con sus sprites! ! ! hahah

Así que muchos lectores están preguntando después de leer este GRAN tutorial cómo mover y cambiar el tamaño y rotar los sprites.Así que trabajé a cabo un cierto código de este lío de ejemplos y tutoriales:

Esta clase se utiliza para algunas manipulaciones de vértices

public class Vertex 
{ 
    public FloatBuffer buffer; // buffer holding the vertices 
    public float vertex[]; 
    public Vertex (float[] vertex) 
    { 
     this.vertex = vertex; 
     this.prepare(); 
    } 
    private void prepare() 
    { 
     // a float has 4 bytes so we allocate for each coordinate 4 bytes 
     ByteBuffer factory = ByteBuffer.allocateDirect (vertex.length * 4); 
     factory.order (ByteOrder.nativeOrder()); 
     // allocates the memory from the byte buffer 
     buffer = factory.asFloatBuffer(); 
     // fill the vertexBuffer with the vertices 
     buffer.put (vertex); 
     // set the cursor position to the beginning of the buffer 
     buffer.position (0);   
    } 
} 

y esta clase se utiliza para dibujar la forma con la textura capaz de moverse de rotación y la posición

public class Square 
{ 
    Vertex shape,texture; 
    int corner=0; 
    float x=0; 

    public Square() 
    { 
     shape = new Vertex (new float[] 
       { 
       1f,1f,0f, 
       0f,1f,0f, 
       1f,0f,0f, 
       0f,0f,0f, 
       }); 

     texture = new Vertex (new float[] 
       { 
       1.0f, 0.0f, 
       0.0f, 0.0f, 
       1.0f, 1.0f, 
       0.0f, 1.0f, 
       });  
    } 

    /** The draw method for the square with the GL context */ 
    public void draw (GL10 gl, int image, float x, float y, float width, float height, float corner) 
    { 
     if (corner>=0) 
     { 
      corner += 1;  
     } 
     if (corner>360) 
     { 
      corner = -1; 
     } 
     gl.glPushMatrix(); 

     x += 1f; 
     if (x>800) 
     { 
      x = 0; 
     } 

     position (gl, 0, 0, width, height, corner); 

     // bind the previously generated texture 
     gl.glBindTexture(GL10.GL_TEXTURE_2D, image); 

     // Point to our buffers 
     gl.glEnableClientState(GL10.GL_VERTEX_ARRAY); 
     gl.glEnableClientState(GL10.GL_TEXTURE_COORD_ARRAY); 

     // set the colour for the square 
     gl.glColor4f (0.0f, 1.0f, 0.0f, 0.5f); 

     // Set the face rotation 
     gl.glFrontFace(GL10.GL_CW);  

     // Point to our vertex buffer 
     gl.glVertexPointer (3, GL10.GL_FLOAT, 0, shape.buffer); 
     gl.glTexCoordPointer(2, GL10.GL_FLOAT, 0, texture.buffer); 

     // Draw the vertices as triangle strip 
     gl.glDrawArrays (GL10.GL_TRIANGLE_STRIP, 0, shape.vertex.length/3); 

     // Disable the client state before leaving 
     gl.glDisableClientState (GL10.GL_VERTEX_ARRAY); 
     gl.glDisableClientState(GL10.GL_TEXTURE_COORD_ARRAY); 

     gl.glPopMatrix();  
    } 

    public void position (GL10 gl, float x, float y, float width, float height, float corner) 
    { 
     gl.glTranslatef (x, y, 0f); //MOVE !!! 1f is size of figure if called after scaling, 1f is pixel if called before scaling 

     if (corner>0) 
     { 
      gl.glTranslatef (width/2, height/2, 0f); 
      gl.glRotatef (corner, 0f, 0f, 1f); // ROTATE !!! 
      gl.glTranslatef (-width/2, -height/2, 0f);   

     } 

     gl.glScalef (width, height, 0f); // ADJUST SIZE !!! 

    } 
} 

y lo más importante cómo configurar la cámara de manera que 1 unidad de OpenGL == 1 annd píxeles cómo cargar texturas

public class Scene implements Renderer 
{ 
    public Context context; 
    public Resources resources; 
    public SparseIntArray images = new SparseIntArray(); 
    public float width; 
    public float height; 

    public Scene (Context context) 
    { 
     this.context = context; 
     this.resources = context.getResources(); 
    } 

    @Override 
    public void onDrawFrame (GL10 gl) 
    { 
//  // clear Screen and Depth Buffer 
     gl.glClear (GL10.GL_COLOR_BUFFER_BIT | GL10.GL_DEPTH_BUFFER_BIT); 
     gl.glMatrixMode(GL10.GL_MODELVIEW); 
//  // Reset the Modelview Matrix 
     gl.glLoadIdentity(); 
     draw (gl); 

    } 

    @Override 
    public void onSurfaceChanged (GL10 gl, int width, int height) 
    { 
     this.width = width; 
     this.height = height; 

     gl.glViewport (0, 0, width, height); // Reset The Current Viewport 
     gl.glMatrixMode (GL10.GL_PROJECTION); // Select The Projection Matrix 
     gl.glLoadIdentity(); // Reset The Projection Matrix 

     gl.glOrthof (0, width, 0, height, -1f, 1f); 
     //gl.glTranslatef (0f, -height/2, 0.0f); // move the camera !! 


     gl.glMatrixMode (GL10.GL_MODELVIEW); // Select The Modelview Matrix 
     gl.glLoadIdentity(); // Reset The Modelview Matrix 

     load (gl); 
    } 

    public void onSurfaceCreated(GL10 gl, EGLConfig config) 
    { 
     gl.glEnable(GL10.GL_TEXTURE_2D);   //Enable Texture Mapping (NEW) 
     gl.glShadeModel(GL10.GL_SMOOTH);   //Enable Smooth Shading 
     gl.glClearColor(0.0f, 0.0f, 0.0f, 0.5f); //Black Background 
     gl.glClearDepthf(1.0f);      //Depth Buffer Setup 
     gl.glEnable(GL10.GL_DEPTH_TEST);   //Enables Depth Testing 
     gl.glDepthFunc(GL10.GL_LEQUAL);    //The Type Of Depth Testing To Do 

     gl.glBlendFunc(GL10.GL_SRC_ALPHA, GL10.GL_ONE_MINUS_SRC_ALPHA); 
     gl.glEnable(GL10.GL_BLEND); 


     //Really Nice Perspective Calculations 
     gl.glHint(GL10.GL_PERSPECTIVE_CORRECTION_HINT, GL10.GL_NICEST); 

     init (gl); 
    } 


    public void init (GL10 gl) 
    { 

    } 

    public void load (GL10 gl) 
    { 

    } 

    public void draw (GL10 gl) 
    { 

    } 

    private static int next (GL10 gl) 
    { 
     int[] temp = new int[1]; 
     gl.glGenTextures (1, temp, 0); 
     return temp[0]; 
    } 

    public int image (GL10 gl, int resource) 
    { 
     int id = next (gl); 
     images.put (resource, id); 

     gl.glBindTexture (GL10.GL_TEXTURE_2D, id); 

     gl.glTexParameterf (GL10.GL_TEXTURE_2D, GL10.GL_TEXTURE_MIN_FILTER, GL10.GL_LINEAR); 
     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); 

     BitmapFactory.Options options = new BitmapFactory.Options(); 
     options.inScaled = false; 

     InputStream input = resources.openRawResource (resource); 
     Bitmap bitmap; 
     try 
     { 
      bitmap = BitmapFactory.decodeStream (input, null, options); 
     } 
     finally 
     { 
      try 
      { 
       input.close(); 
      } 
      catch (IOException e) 
      { 
       // Ignore. 
      } 
     } 

//  Matrix flip = new Matrix(); 
//  flip.postScale (1f, -1f); 
//  bitmap = Bitmap.createBitmap (bitmap, 0, 0, bitmap.getWidth(), bitmap.getHeight(), flip, true); 

     GLUtils.texImage2D (GL10.GL_TEXTURE_2D, 0, bitmap, 0);  
     return id; 
    } 

} 

y un cierto uso

public class Scene2 extends Scene 
{ 
    Square square1, square2; 

    public Scene2(Context context) 
    { 
     super (context); 
     // TODO Auto-generated constructor stub 
    } 

    public void init (GL10 gl) 
    { 
     square1 = new Square(); 
     square2 = new Square(); 
    } 

    public void load (GL10 gl) 
    { 
     image (gl, R.drawable.s1_clouds); 
     image (gl, R.drawable.s1_ground); 
    } 

    public void draw (GL10 gl) 
    { 
     square1.draw (gl, images.get(R.drawable.s1_clouds), 0, 0, width, height, 0); 
     square1.draw (gl, images.get(R.drawable.s1_ground), 0, 0, width, height, 0); 
    } 

} 

lo principal que quería poner en práctica e implementada es que el eje X e Y son como en el lienzo:

(0,0) 
--------------------------------- X axis 
| 
| 
| 
| 
| 
| 
| 
| 
Y axis 

Yo escribiré algún tutorial completo después de esta y me gusta anunciar que logré todos los objetivos que quería lograr, es decir: eje X en la parte superior, eje Y en la izquierda, unidad abierta = píxel, establecer el tamaño del objeto en píxeles, rotar el objeto, moverlo todo en píxeles. Ahora i ll encargo de la animación de sprites y los hacemos en las clases más finas y eso es la nueva base 2d marco juego de OpenGL ...

descubrir esto funciona me ayudó a tutorial http://www.morrowland.com/apron/tutorials/gl/gl_matrix.php

Así que muchas gracias a este blog para señalar sacarme la único camino verdadero ...

1 androide motor de juego OpenGL 2d más simple en 1 semana ...

mente feliz soplando ...

: P

Editar: Después de años tengo un buen marco https://github.com/hazardland/game.android usando los conceptos aquí descritos y juego de muestra con los posibles ejemplos de uso aquí marco https://github.com/hazardland/ferry.android (ver las pantallas en el mercado https://play.google.com/store/apps/details?id=hazardland.borani)