android-developers
[Arriba] [Todas las Listas]

[android-developers] Puede hago que un polígono llena el 80% del ancho

To: Android Developers <android-developers@xxxxxxxxxxxxxxxx>
Subject: [android-developers] Puede hago que un polígono llena el 80% del ancho de la pantalla?
From: saex <elpablosaez@xxxxxxxxx>
Date: Mon, 31 Oct 2011 04:12:56 -0700 (PDT)
Delivery-date: Mon, 31 Oct 2011 07:13:16 -0400
Dkim-signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=googlegroups.com; s=beta; h=x-beenthere:mime-version:date:user-agent:x-http-useragent :message-id:subject:from:to:x-original-sender :x-original-authentication-results:reply-to:precedence:mailing-list :list-id:x-google-group-id:list-post:list-help:list-archive:sender :list-subscribe:list-unsubscribe:content-type :content-transfer-encoding; bh=SSO/TzcryhyzLLVW3p+3qqWD0aF4nr1vzBU3ovmfMd0=; b=X5zlFULGsp3Mw2Eu0VCJQ8vifcx5uHF1jF0Lefhe+q9iYVorwSK0O54zpNgL8vubRV omJy8mgdmovH/VwO9bZ1sL9OR8eTIQKrhSgmTJ0Rs5+Y4zD0uNF2KZ2XpP92m3Em6ml6 2xt338nf4p1v16k2W19Vek1l7jzS0fffo7eNw=
Envelope-to: traductor@xxxxxxxxxxx
List-archive: <http://groups.google.com/group/android-developers?hl=en_US>
List-help: <http://groups.google.com/support/?hl=en_US>, <mailto:android-developers+help@googlegroups.com>
List-id: <android-developers.googlegroups.com>
List-post: <http://groups.google.com/group/android-developers/post?hl=en_US>, <mailto:android-developers@googlegroups.com>
List-subscribe: <http://groups.google.com/group/android-developers/subscribe?hl=en_US>, <mailto:android-developers+subscribe@googlegroups.com>
List-unsubscribe: <http://groups.google.com/group/android-developers/subscribe?hl=en_US>, <mailto:android-developers+unsubscribe@googlegroups.com>
Mailing-list: list android-developers@xxxxxxxxxxxxxxxx; contact android-developers+owners@xxxxxxxxxxxxxxxx
Reply-to: android-developers@xxxxxxxxxxxxxxxx
Sender: android-developers@xxxxxxxxxxxxxxxx
User-agent: G2/1.0
Tengo una plaza sencilla (polígono), y *i quiere que llena el 80% del
ancho de la pantalla

En otras palabras, *i quiere colocar la plaza en el centro en
el centro de la pantalla, pero con un ancho del 80% del ancho total
de la pantalla

Cómo puede *i  él? No puedo encontrar ejemplos/*tutorials sobre este

*thanks

Esto es el código para mi plaza:

    Plaza de clase pública
        //#unknown{^*Buffer *de
        *vertices privado *FloatBuffer *vertexBuffer;
        //*Buffer *de *coordenadas *de
        *texturas privado *FloatBuffer *textureBuffer;
        //*Puntero *de
        *texturas privado *int[] *textures = nuevo *int[3];
        //*El elemento un *representar
        privado *int *resourceId;
        //*Definición *de
        *vertices privado *float *vertices[]
                #default{^-1.0*f, -1.0*f, 0.0*f,     //el Fondo Dejó
                1.0*f, -1.0*f, 0.0*f,              //Inferior Correcto
                -1.0*f, 1.0*f, 0.0*f,              //la Parte superior Dejó
                1.0*f, 1.0*f, 0.0*f                //Derecho Superior
        };
        //*Coordenadas (*u, *v) *de *las *texturas
        /*
        privado *float *texture[]
                //#unknown{^*Mapping coordenadas para el *vertices
                0.0*f, 0.0*f,
                0.0*f, 1.0*f,
                1.0*f, 0.0*f,
                1.0*f, 1.0*f
        };
        */
        privado *float *texture[]
                //#unknown{^*Mapping coordenadas para el *vertices
                0.0*f, 1.0*f,
                1.0*f, 1.0*f,
                0.0*f, 0.0*f,
                1.0*f, 0.0*f
        };
        //*Inicializamos *los *buffers
        Plaza pública(*int *resourceId)
                #unknown{^*ByteBuffer *byteBuf =
*ByteBuffer.*allocateDirect(*vertices.Longitud *
4);
                *byteBuf.Orden(*ByteOrder.*nativeOrder());
                *vertexBuffer = *byteBuf.*asFloatBuffer();
                *vertexBuffer.Puesto(*vertices);
                *vertexBuffer.Posición(0);

                *byteBuf = *ByteBuffer.*allocateDirect(*texture.Longitud *
4);
                *byteBuf.Orden(*ByteOrder.*nativeOrder());
                *textureBuffer = *byteBuf.*asFloatBuffer();
                *textureBuffer.Puesto(*texture);
                *textureBuffer.Posición(0);

                esto.*resourceId=*resourceId;
        }
        //*Funcion *de
        *dibujado Público *void sorteo(GL10 *gl)
                #unknown{^*gl.*glFrontFace(GL10.CCW_de GL);
                //*gl.*glEnable(GL10.GL_*BLEND);
                //Ligar nuestro único anteriormente generado *texture en
este caso
                *gl.*glBindTexture(GL10.GL_*TEXTURE_2*D, *textures[0]);
                //Punto a nuestro *vertex *buffer
                *gl.*glVertexPointer(3, GL10.GL_*FLOAT, 0, *vertexBuffer);
                *gl.*glTexCoordPointer(2, GL10.GL_*FLOAT, 0,
*textureBuffer);
                //Habilita *vertex *buffer
                *gl.*glEnableClientState(GL10.GL_*VERTEX_VARIEDAD);
                *gl.*glEnableClientState(GL10.GL_*TEXTURE_*COORD_VARIEDAD);
                //Sorteo el *vertices como cinta de triángulo
                *gl.*glDrawArrays(GL10.CINTA_de TRIÁNGULO_del GL, 0,
*vertices.Longitud / 3);
                //Imposibilitar el estado de cliente antes de dejar
                *gl.*glDisableClientState(GL10.GL_*VERTEX_VARIEDAD);
                *gl.*glDisableClientState(GL10.GL_*TEXTURE_*COORD_VARIEDAD);
                //*gl.*glDisable(GL10.GL_*BLEND);

        }
        //*Carga *de
        *texturas público *void *loadGLTexture(GL10 *gl, contexto de Contexto)
                //#unknown{^*Generamos *un *puntero *de
                *texturas *gl.*glGenTextures(1, *textures, 0);
                //*y *se *lo *asignamos un *nuestro variedad
                *gl.*glBindTexture(GL10.GL_*TEXTURE_2*D, *textures[0]);
                //*Creamos *filtros *de
                *texturas *gl.*glTexParameterf(GL10.GL_*TEXTURE_2*D,
GL10.GL_*TEXTURE_*MIN_FILTRO, GL10.el GL_más CERCANO);
                *gl.*glTexParameterf(GL10.GL_*TEXTURE_2*D,
GL10.GL_*TEXTURE_FILTRO_de MAG, GL10.el GL_LINEAL);
                //*Diferentes *parametros *de *textura *posibles
GL10.GL_*CLAMP_A_BORDE
                *gl.*glTexParameterf(GL10.GL_*TEXTURE_2*D,
GL10.GL_*TEXTURE_WRAP_*S,
GL10.el GL_REPITE);
                *gl.*glTexParameterf(GL10.GL_*TEXTURE_2*D,
GL10.GL_*TEXTURE_WRAP_*T,
GL10.el GL_REPITE);

                /*
                Cadena *imagePath = "*radiocd5.*png";
            *AssetManager *mngr = Contexto.*getAssets();
            *InputStream Es=*null;
                prueba
                        #be = *mngr.Abierto(*imagePath);
                } coge (*IOException *e1)      #unknown{^*e1.*printStackTrace();   }
                */
                //Conseguir el *texture del *Android directorio de recurso
                *InputStream es=*null;
            /*
                si (elemento.*equals("*rim"))
                Es =
contexto.*getResources().*openRawResource(*R.*drawable.*rueda);
            Más si (elemento.*equals("*selector"))
                Es =
contexto.*getResources().*openRawResource(*R.*drawable.*selector);
                */
                Es =
contexto.*getResources().*openRawResource(*resourceId);
                *Bitmap *bitmap = *null;
                Prueba
                        #unknown{^*bitmap = *BitmapFactory.*decodeStream(Es);
                } finalmente
                        #inf
                                #be.Cercano();
                                es = *null;
                        } coge (*IOException *e) {
                        }
                }

                //*con *el *siguiente *código *redimensionamos *las *imágenes
*que *sean
*mas *grandes *de 256*x256.
                *int *newW=*bitmap.*getWidth();
                *int *newH=*bitmap.*getHeight();
                *float Hecho;
                si (*newH>256 || *newW>256)
                        #cnj (*newH>256)
                                #nom=(*float)255/(*float)*newH; //
*porcentaje *por *el *que
*multiplicar *para *ser *tamaño 256
                                *newH=(*int)(*newH*hecho); //*altura
*reducida *al *porcentaje
*necesario
                                *newW=(*int)(*newW*hecho); //*anchura
*reducida *al *porcentaje
*necesario
                        }
                        si (*newW>256)
                                #nom=(*float)255/(*float)*newW; //
*porcentaje *por *el *que
*multiplicar *para *ser *tamaño 256
                                *newH=(*int)(*newH*hecho); //*altura
*reducida *al *porcentaje
*necesario
                                *newW=(*int)(*newW*hecho); //*anchura
*reducida *al *porcentaje
*necesario
                        }
                        *bitmap=*Bitmap.*createScaledBitmap(*bitmap, *newW,
*newH, cierto);
                }

                //*con *el *siguiente *código *transformamos *imágenes no
*potencia *de
2 *en *imágenes *potencia *de 2 (tarro)
                //*meto *el *bitmap *NOPOT *en *un *bitmap TARRO *para *que no
*aparezcan
*texturas *blancas.
                *int *nextPot=256;
                *int *h = *bitmap.*getHeight();
                *int *w = *bitmap.*getWidth();
                *int *offx=(*nextPot-*w)/2; //*distancia *respecto un *la
*izquierda,
*para *que *la *imagen *quede *centrada *en *la *nueva *imagen TARRO
                *int *offy=(*nextPot-*h)/2; //*distancia *respecto un *arriba,
*para *que
*la *imagen *quede *centrada *en *la *nueva *imagen TARRO
                *Bitmap *bitmap2 = *Bitmap.*createBitmap(*nextPot, *nextPot,
*Bitmap.*Config.*ARGB_8888); //*crea *un *bitmap *transparente *gracias *al
*ARGB_8888
                Tela *comboImage = Tela nueva(*bitmap2);
                *comboImage.*drawBitmap(*bitmap, *offx, *offy, *null);
                *comboImage.Salva();

                //*Usamos *Android *GLUtils *para *espcificar *una *textura
*de 2
*dimensiones *para *nuestro *bitmap
                *GLUtils.*texImage2*D(GL10.GL_*TEXTURE_2*D, 0, *bitmap2, 0);

                //*Checkeamos *si *el contexto de GL *es *versión 1.1 *y
*generamos *los
*Mipmaps *por Bandera. *Si No, *llamamos un *nuestra *propia *implementación
                si(*gl *instanceof GL11)
                        #unknown{^*gl.*glTexParameterf(GL11.GL_*TEXTURE_2*D,
GL11.el GL_GENERA_*MIPMAP,
GL11.el GL_CIERTO);
                        *GLUtils.*texImage2*D(GL10.GL_*TEXTURE_2*D, 0,
*bitmap2, 0);
                } más
                        #unknown{^*buildMipmap(*gl, *bitmap2);
                }
                //*Limpiamos *los *bitmaps
                *bitmap.Recicla();
                *bitmap2.Recicla();
        }
        //*Nuestra *implementación *de *MipMap. *Escalamos *el *bitmap
Original
*hacia *abajo *por factor *de 2 *y *lo *asignamos *como *nuevo *nivel *de
        *mipmap privado *void *buildMipmap(GL10 *gl, *Bitmap *bitmap)
                #unknown{^*int nivel = 0;
                *int alzada = *bitmap.*getHeight();
                *int Ancho = *bitmap.*getWidth();
                Mientras(alzada >= 1 || ancho >= 1)
                        #unknown{^*GLUtils.*texImage2*D(GL10.GL_*TEXTURE_2*D, nivel,
*bitmap, 0);
                        si(alzada == 1 || ancho == 1)
                                #nom;
                        }
                        nivel++;
                        alzada /= 2;
                        ancho /= 2;
                        *Bitmap *bitmap2 =
*Bitmap.*createScaledBitmap(*bitmap, ancho,
alzada, cierto);
                        *bitmap.Recicla();
                        *bitmap = *bitmap2;
                }
        }
        }

-- 
recibiste este mensaje porque eres *subscribed al *Google
Grupos "*Android *Developers" grupo.
A correo a este grupo, envía *email a *android-developers@xxxxxxxxxxxxxxxx
A *unsubscribe de este grupo, envía *email a *android-*developers+unsubscribe@xxxxxxxxxxxxxxxx

Puesto que más opciones, visita este grupo en
*http://grupos.*google.*com/Grupo/*android-*developers?*hl=*en

I have a simple square (polygon), and i want that it fills the 80% of
the width of the screen

In other words, i want to position the square on the center on the
center of the screen, but with a width of the 80% of the total width
of the screen

How can i do it? I can't find examples/tutorials about this

thanks

THis is the code for my square:

    public class Square {
        //Buffer de vertices
        private FloatBuffer vertexBuffer;
        //Buffer de coordenadas de texturas
        private FloatBuffer textureBuffer;
        //Puntero de texturas
        private int[] textures = new int[3];
        //El item a representar
        private int resourceId;
        //Definición de vertices
        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
        };
        //Coordenadas (u, v) de las texturas
        /*
        private float texture[] =
        {
                //Mapping coordinates for the vertices
                0.0f, 0.0f,
                0.0f, 1.0f,
                1.0f, 0.0f,
                1.0f, 1.0f
        };
        */
        private float texture[] =
        {
                //Mapping coordinates for the vertices
                0.0f, 1.0f,
                1.0f, 1.0f,
                0.0f, 0.0f,
                1.0f, 0.0f
        };
        //Inicializamos los buffers
        public Square(int resourceId) {
                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);

                this.resourceId=resourceId;
        }
        //Funcion de dibujado
        public void draw(GL10 gl) {
                gl.glFrontFace(GL10.GL_CCW);
                //gl.glEnable(GL10.GL_BLEND);
                //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);
                //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);
                //gl.glDisable(GL10.GL_BLEND);

        }
        //Carga de texturas
        public void loadGLTexture(GL10 gl, Context context) {
                //Generamos un puntero de texturas
                gl.glGenTextures(1, textures, 0);
                //y se lo asignamos a nuestro array
                gl.glBindTexture(GL10.GL_TEXTURE_2D, textures[0]);
                //Creamos filtros de texturas
                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);
                //Diferentes parametros de textura posibles
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);

                /*
                String imagePath = "radiocd5.png";
            AssetManager mngr = context.getAssets();
            InputStream is=null;
                try {
                        is = mngr.open(imagePath);
                } catch (IOException e1)
{      e1.printStackTrace();   }
                */
                //Get the texture from the Android resource directory
                InputStream is=null;
            /*
                if (item.equals("rim"))
                is =
context.getResources().openRawResource(R.drawable.rueda);
            else if (item.equals("selector"))
                is =
context.getResources().openRawResource(R.drawable.selector);
                */
                is =
context.getResources().openRawResource(resourceId);
                Bitmap bitmap = null;
                try {
                        bitmap = BitmapFactory.decodeStream(is);
                } finally {
                        try {
                                is.close();
                                is = null;
                        } catch (IOException e) {
                        }
                }

                //con el siguiente código redimensionamos las imágenes
que sean
mas grandes de 256x256.
                int newW=bitmap.getWidth();
                int newH=bitmap.getHeight();
                float fact;
                if (newH>256 || newW>256)
                {
                        if (newH>256)
                        {
                                fact=(float)255/(float)newH; //
porcentaje por el que
multiplicar para ser tamaño 256
                                newH=(int)(newH*fact); //altura
reducida al porcentaje
necesario
                                newW=(int)(newW*fact); //anchura
reducida al porcentaje
necesario
                        }
                        if (newW>256)
                        {
                                fact=(float)255/(float)newW; //
porcentaje por el que
multiplicar para ser tamaño 256
                                newH=(int)(newH*fact); //altura
reducida al porcentaje
necesario
                                newW=(int)(newW*fact); //anchura
reducida al porcentaje
necesario
                        }
                        bitmap=Bitmap.createScaledBitmap(bitmap, newW,
newH, true);
                }

                //con el siguiente código transformamos imágenes no
potencia de
2 en imágenes potencia de 2 (pot)
                //meto el bitmap NOPOT en un bitmap POT para que no
aparezcan
texturas blancas.
                int nextPot=256;
                int h = bitmap.getHeight();
                int w = bitmap.getWidth();
                int offx=(nextPot-w)/2; //distancia respecto a la
izquierda,
para que la imagen quede centrada en la nueva imagen POT
                int offy=(nextPot-h)/2; //distancia respecto a arriba,
para que
la imagen quede centrada en la nueva imagen POT
                Bitmap bitmap2 = Bitmap.createBitmap(nextPot, nextPot,
Bitmap.Config.ARGB_8888); //crea un bitmap transparente gracias al
ARGB_8888
                Canvas comboImage = new Canvas(bitmap2);
                comboImage.drawBitmap(bitmap, offx, offy, null);
                comboImage.save();

                //Usamos Android GLUtils para espcificar una textura
de 2
dimensiones para nuestro bitmap
                GLUtils.texImage2D(GL10.GL_TEXTURE_2D, 0, bitmap2, 0);

                //Checkeamos si el GL context es versión 1.1 y
generamos los
Mipmaps por Flag. Si no, llamamos a nuestra propia implementación
                if(gl instanceof GL11) {
                        gl.glTexParameterf(GL11.GL_TEXTURE_2D,
GL11.GL_GENERATE_MIPMAP,
GL11.GL_TRUE);
                        GLUtils.texImage2D(GL10.GL_TEXTURE_2D, 0,
bitmap2, 0);
                } else {
                        buildMipmap(gl, bitmap2);
                }
                //Limpiamos los bitmaps
                bitmap.recycle();
                bitmap2.recycle();
        }
        //Nuestra implementación de MipMap. Escalamos el bitmap
original
hacia abajo por factor de 2 y lo asignamos como nuevo nivel de mipmap
        private void buildMipmap(GL10 gl, Bitmap bitmap) {
                int level = 0;
                int height = bitmap.getHeight();
                int width = bitmap.getWidth();
                while(height >= 1 || width >= 1) {
                        GLUtils.texImage2D(GL10.GL_TEXTURE_2D, level,
bitmap, 0);
                        if(height == 1 || width == 1) {
                                break;
                        }
                        level++;
                        height /= 2;
                        width /= 2;
                        Bitmap bitmap2 =
Bitmap.createScaledBitmap(bitmap, width,
height, true);
                        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-developers@xxxxxxxxxxxxxxxx
To unsubscribe from this group, send email to
android-developers+unsubscribe@xxxxxxxxxxxxxxxx
For more options, visit this group at
http://groups.google.com/group/android-developers?hl=en

<Anterior por Tema] Tema Actual [Siguiente por Tema>
  • [android-developers] Puede hago que un polígono llena el 80% del ancho de la pantalla?, saex <=