Monday, October 3, 2011

Re: [android-developers] White (error) textures on Android 2.2, but working normal textures on Android 1.5 to 2.1... ¿why?

I concur with this as well from experience.  Non powers of 2 textures are supported by some implementations on some devices, but to be safe, always use powers of 2 textures.  In your case if you want to draw something that is 180x140, just draw that part of the texture, while having the full texture you load be a power of two (256x256 would be the minimum enclosing size, as has been suggested by others here).

handy chart for you, though us computer geeks should know these cold! :)
http://www.vaughns-1-pagers.com/computer/powers-of-2.htm



On Monday, October 3, 2011 11:56:06 AM UTC-4, latimerius wrote:
In my experience, the classic cause of "white" textures on some hardware but not other is a non-power-of-two texture.  Your code doesn't seem to enforce POT texture dimensions, are your assets POT?

On Mon, Oct 3, 2011 at 5:43 PM, saex <elpab...@gmail.com> wrote:
i have an app that draws a square on the screen with a texture, and
the user can rotate the square touching the screen. It works fine with
android 1.5 to 2.1. But when i test the App on a Motorola Droid with
android 2.2.2 something is failing because the square is loaded with a
white texture.

What is wrong?

This is the code of my class square:

   public class Square {

       /** The buffer holding the vertices */
       private FloatBuffer vertexBuffer;
       /** The buffer holding the texture coordinates */
       private FloatBuffer textureBuffer;
       /** Our texture pointer */
       private int[] textures = new int[3];

       /** The initial vertex definition */
       private float vertices[] = {
                                               -1.0f, -1.0f, 0.0f,     //Bottom Left
                                               1.0f, -1.0f, 0.0f,              //Bottom Right
                                               -1.0f, 1.0f, 0.0f,              //Top Left
                                               1.0f, 1.0f, 0.0f                //Top Right
                                                                               };
       /** The initial texture coordinates (u, v) */

       private float texture[] = {
                                       //Mapping coordinates for the vertices
                                       0.0f, 0.0f,
                                       0.0f, 1.0f,
                                       1.0f, 0.0f,
                                       1.0f, 1.0f
                                       };

       /**
        * The Square constructor.
        *
        * Initiate the buffers.
        */
       public Square() {
               //
               ByteBuffer byteBuf = ByteBuffer.allocateDirect(vertices.length * 4);
               byteBuf.order(ByteOrder.nativeOrder());
               vertexBuffer = byteBuf.asFloatBuffer();
               vertexBuffer.put(vertices);
               vertexBuffer.position(0);
               //
               byteBuf = ByteBuffer.allocateDirect(texture.length * 4);
               byteBuf.order(ByteOrder.nativeOrder());
               textureBuffer = byteBuf.asFloatBuffer();
               textureBuffer.put(texture);
               textureBuffer.position(0);
       }

       /**
        * The object own drawing function.
        * Called from the renderer to redraw this instance
        * with possible changes in values.
        *
        * @param gl - The GL Context
        */
       public void draw(GL10 gl) {
               //Set the face rotation
               //gl.glFrontFace(GL10.GL_CW);
               gl.glFrontFace(GL10.GL_CCW);
               //Bind our only previously generated texture in this case
               gl.glBindTexture(GL10.GL_TEXTURE_2D, textures[0]);
               //Point to our vertex buffer
               gl.glVertexPointer(3, GL10.GL_FLOAT, 0, vertexBuffer);
               gl.glTexCoordPointer(2, GL10.GL_FLOAT, 0, textureBuffer);
               //Enable vertex buffer
               gl.glEnableClientState(GL10.GL_VERTEX_ARRAY);
               gl.glEnableClientState(GL10.GL_TEXTURE_COORD_ARRAY);
               //Set The Color To Blue
               //gl.glColor4f(0.5f, 0.5f, 1.0f, 1.0f);
               //Draw the vertices as triangle strip
               gl.glDrawArrays(GL10.GL_TRIANGLE_STRIP, 0, vertices.length / 3);
               //Disable the client state before leaving
               gl.glDisableClientState(GL10.GL_VERTEX_ARRAY);
               gl.glDisableClientState(GL10.GL_TEXTURE_COORD_ARRAY);

               ///
               //Bind the texture according to the set texture filter
               //gl.glBindTexture(GL10.GL_TEXTURE_2D, textures[filter]);
       }

       /**
        * Load the textures
        *
        * @param gl - The GL Context
        * @param context - The Activity context
        */
       public void loadGLTexture(GL10 gl, Context context) {
               //Generate one texture pointer...
               gl.glGenTextures(1, textures, 0);
               //...and bind it to our array
               gl.glBindTexture(GL10.GL_TEXTURE_2D, textures[0]);
               //Create Nearest Filtered Texture
               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);

               //Different possible texture parameters, e.g. GL10.GL_CLAMP_TO_EDGE
               gl.glTexParameterf(GL10.GL_TEXTURE_2D, GL10.GL_TEXTURE_WRAP_S,
GL10.GL_REPEAT);
               gl.glTexParameterf(GL10.GL_TEXTURE_2D, GL10.GL_TEXTURE_WRAP_T,
GL10.GL_REPEAT);

               //Get the texture from the Android resource directory
               InputStream is =
context.getResources().openRawResource(R.drawable.radiocd2);
               Bitmap bitmap = null;
               try {
                       //BitmapFactory is an Android graphics utility for images
                       bitmap = BitmapFactory.decodeStream(is);

               } finally {
                       //Always clear and close
                       try {
                               is.close();
                               is = null;
                       } catch (IOException e) {
                       }
               }

               //Use the Android GLUtils to specify a two-dimensional texture image
from our bitmap
               GLUtils.texImage2D(GL10.GL_TEXTURE_2D, 0, bitmap, 0);

               /*
                * This is a change to the original tutorial, as buildMipMap does
not exist anymore
                * in the Android SDK.
                *
                * We check if the GL context is version 1.1 and generate MipMaps by
flag.
                * Otherwise we call our own buildMipMap implementation
                */
               if(gl instanceof GL11) {
                       gl.glTexParameterf(GL11.GL_TEXTURE_2D, GL11.GL_GENERATE_MIPMAP,
GL11.GL_TRUE);
                       GLUtils.texImage2D(GL10.GL_TEXTURE_2D, 0, bitmap, 0);

               //
               } else {
                       buildMipmap(gl, bitmap);
               }

               //Clean up
               bitmap.recycle();
       }

       /**
        * Our own MipMap generation implementation.
        * Scale the original bitmap down, always by factor two,
        * and set it as new mipmap level.
        *
        * Thanks to Mike Miller (with minor changes)!
        *
        * @param gl - The GL Context
        * @param bitmap - The bitmap to mipmap
        */
       private void buildMipmap(GL10 gl, Bitmap bitmap) {
               //
               int level = 0;
               //
               int height = bitmap.getHeight();
               int width = bitmap.getWidth();

               //
               while(height >= 1 || width >= 1) {
                       //First of all, generate the texture from our bitmap and set it to
the according level
                       GLUtils.texImage2D(GL10.GL_TEXTURE_2D, level, bitmap, 0);

                       //
                       if(height == 1 || width == 1) {
                               break;
                       }

                       //Increase the mipmap level
                       level++;

                       //
                       height /= 2;
                       width /= 2;
                       Bitmap bitmap2 = Bitmap.createScaledBitmap(bitmap, width, height,
true);

                       //Clean up
                       bitmap.recycle();
                       bitmap = bitmap2;
               }
       }
   }

--
You received this message because you are subscribed to the Google
Groups "Android Developers" group.
To post to this group, send email to android-d...@googlegroups.com
To unsubscribe from this group, send email to
android-develop...@googlegroups.com
For more options, visit this group at
http://groups.google.com/group/android-developers?hl=en

--
You received this message because you are subscribed to the Google
Groups "Android Developers" group.
To post to this group, send email to android-developers@googlegroups.com
To unsubscribe from this group, send email to
android-developers+unsubscribe@googlegroups.com
For more options, visit this group at
http://groups.google.com/group/android-developers?hl=en

No comments:

Post a Comment