Cant znaleźć odpowiedni przykład dla Androida 2d OpenGL sprite klasy, która nie używa GL11Ext do rysowania

Question

Jak SpriteMethodTest mówi, istnieje wiele sposobów na rysunek duszków. Najpierw próbowałem płótna i miałem pewne problemy z wydajnością. Potem zdecydowałem się nauczyć opengl. Osiągnąłem pierwsze sukcesy używając rozszerzenia GL11Ext. ale domyślnie wiesz, kiedy rysujesz tekstury, które są odwrócone, a oś x i y mają zero w lewym dolnym rogu ekranu urządzenia (w trybie poziomym), a nie jak płótno i nie możesz obracać duszek.

Niż próbowałem wpłynąć na ten widok osi używając GLU spojrzeć na. Ale nie działał.

Niż chciałem obrócić moje duszki i nie wywoływały skutków GL11Ext, jak to mówią.

Więc mam poważny stan stackoverflow i teraz podstawowe pytanie brzmi:

1. Jakie metody użyć, aby osiągnąć powiększanie, obracanie i odbijając wpływ na duchy i do oglądania X i Y osi w STARYM SWEET WAY [(0,0) JEST NA GÓRNEGO LEWEGO TRYBU KRAJOBRAZU]?

2. i czy istnieje jakiś przykład SPRITE CLASS we wszechświecie Wich używa tylko 1 dobry sposób SPRITE WYPRAWĄ? (SpriteMethodTest bardzo mnie myli)

Answer 1

EVRIKA !!!

Prawie zabiłem się! po 3 dniach opuszczania Canvas i uczeniu się metod OpenGL w celu implementacji silnika gry.

Sieć jest pełna samouczków OpenGL pełnych śmieci, a wiele z nich jest niedokończonych, a wiele z nich prowadzi do niewłaściwego sposobu implementacji silnika gier OpenGL w 2D OpenGL. Wielkim błędem jest używanie G11Ext do tworzenia gier. Jak nie naprzemiennie: D

annd annd Potem znalazłem ten poradnik z innego samouczka, który znalazłem z youtube próbki gra łącza wideo lol:

nie mylić widzów tutaj jest

Rozdział 1: http://obviam.net/index.php/opengl-es-with-android-switching-from-canvas-to-opengl/

Rozdział 2 http://obviam.net/index.php/opengl-es-android-displaying-graphical-elements-primitives/

Rozdział 3 http://obviam.net/index.php/texture-mapping-opengl-android-displaying-images-using-opengl-and-squares/

Annd zaledwie 15 minut temu odkryłem sposób, w jaki mogę OBRÓĆ, PRZENIEŚĆ I ZMIEŃ ROZMIARY kształtów za pomocą ikonek! ! ! hahah

Tak wielu czytelników pyta po przeczytaniu tego WSPANIAŁEGO samouczka, jak poruszać i zmieniać rozmiar i obracać duszki.Więc wypracowane pewne kod z tego bałaganu przykładów i tutoriali:

Ta klasa jest używana do pewnych manipulacji wierzchołków

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

i klasa ta służy do kształtu rysowanie tekstur w stanie poruszać się obracać i pozycję

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 !!! 

    } 
} 

i najważniejsze, jak ustawić aparat w taki sposób, że 1 jednostka OpenGL == 1 piksel annd jak załadować tekstury

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

} 

a niektóre Wykorzystanie

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

} 

najważniejsze tutaj chciałem wdrożyć i realizowane jest to, że oś X i Y są jak w płótnie:

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

ll napisać pełną samouczek po tym i lubię ogłaszać, że osiągnąłem wszystkie cele, które chciałem osiągnąć, tj .: oś X na górze, oś Y na lewo, jednostka opengl = piksel, ustawić rozmiar obiektu w pikselach, obrócić obiekt, przenieść obiekt wszystko w pikselach. teraz ll obsłużyć animowanie ikonek i uczynić je w klasach drobniejszych i ów nowy 2d podstawę ramowej OpenGL gra ...

odkrywanie tej funkcji pomógł mi samouczek http://www.morrowland.com/apron/tutorials/gl/gl_matrix.php

Tak wiele dzięki tym blogu za wskazanie mi się z jedyny prawdziwy sposób ...

+1 android simpliest 2d silnik OpenGL gra w 1 tygodniu ...

szczęśliwy umysł dmuchanie ...

: P

Edycja: Po roku mam piękny ramy https://github.com/hazardland/game.android używając pojęć opisanych tu i próbki grę z ewentualnych przykłady stosowania ramy tutaj https://github.com/hazardland/ferry.android (zobacz Ekrany na rynku https://play.google.com/store/apps/details?id=hazardland.borani)