Android 更改多边形纹理的正确方法是什么？

我需要一些帮助来实现OpenGLES1.1

我有一个简单的方形多边形（来自nehe教程）和纹理

多边形有一个位图，创建多边形时，会调用一次loadGLTexture（GL10 gl，上下文上下文）方法来加载纹理

我需要将该功能添加到我的应用程序中，以更改正方形的纹理

更改多边形纹理的最佳方法是什么？在谷歌上找不到正确的方法

谢谢大家

编辑：

公共类广场{
//顶点缓冲区
公共浮动缓冲区顶点缓冲区；
//纹理缓冲区
私人浮动缓冲器；
//织物平底锅
私有int[]纹理=新int[3]；
//El项目a代表
私有位图；//具有POT尺寸的图像
//多边形的大小：
公共浮动w；
公共浮动h；
//纹理的大小
私人浮动纹理；
私人浮标；
//顶点定义
公共浮点顶点[]=新浮点[12]；
私有浮点顶点_transformed[]=新浮点[12]；
//库德纳达斯（u，v）酒店
私有浮动纹理[]；
//像比
浮动比率；
公共int id；
语境；
//伊尼西莉扎莫斯酒店
公共广场（位图图像，上下文）{
int bitmapW=image.getWidth（）；
int bitmapH=image.getHeight（）；
w=1.00f；
h=（浮点）位图h/位图W；
浮动垂直2[]={
-w、 -h，0.0f，//左下角
w、 -h，0.0f，//右下角
-w、 h，0.0f，//左上角
w、 h，0.0f//右上角
};
顶点=垂直2；
//第二个目标的潜力计算，第二个目标，第二个目标，第三个目标。
int nextPOT；
如果（位图W>位图H）
nextPOT=getNextPOT（位图）；
其他的
nextPOT=getNextPOT（位图）；
//新的点阵图中的奶油是2号药力的一部分
bitmap=bitmap.createBitmap（nextPOT，nextPOT，bitmap.Config.ARGB_8888）；//crea un bitmap transparente gracias al ARGB_8888
画布组合图像=新画布（位图）；
comboImage.drawBitmap（图像，0，0，null）；
comboImage.save（）；
//第二种效力的计算方法
textureX=（浮点）位图w/nextPOT；
textureY=（float）位图/nextPOT；
//质感的乳霜阵列，是一种很好的选择
浮动纹理2[]={
0.0f，纹理，
textureX，textureY，
0.0f，0.0f，
textureX，0.0f
};
System.out.println（“bw:+bitmapW+”nextPOT:+nextPOT+”textx:+textureX”）；
纹理=纹理2；
ByteBuffer byteBuf=ByteBuffer.allocateDirect（顶点.length*4）；
byteBuf.order（ByteOrder.nativeOrder（））；
vertexBuffer=byteBuf.asFloatBuffer（）；
vertexBuffer.put（顶点）；
顶点缓冲区位置（0）；
byteBuf=ByteBuffer.allocateDirect（texture.length*4）；
byteBuf.order（ByteOrder.nativeOrder（））；
textureBuffer=byteBuf.asFloatBuffer（）；
纹理缓冲。放置（纹理）；
纹理缓冲位置（0）；
//设定位置（0,0）；
比率=（浮点）image.getWidth（）/image.getHeight（）；
image.recycle（）；
} 
//迪布加多职能
公共作废提款（GL10 gl）{
gl.glFrontFace（GL10.GLU CCW）；
//glEnable（GL10.Glu混合物）；
//在这种情况下，绑定我们之前生成的唯一纹理
gl.glBindTexture（GL10.gl_TEXTURE_2D，textures[0]）；
//指向我们的顶点缓冲区
gl.glVertexPointer（3，GL10.gl_FLOAT，0，vertexBuffer）；
gl.glTexCoordPointer（2，GL10.gl_FLOAT，0，textureBuffer）；
//启用顶点缓冲区
gl.glEnableClientState（GL10.gl_顶点数组）；
gl.glEnableClientState（GL10.gl_纹理_坐标_数组）；
//将颜色设置为蓝色
//gl.glColor4f（0.5f、0.5f、1.0f、1.0f）；
//将顶点绘制为三角形条
gl.glDrawArray（GL10.gl_三角形_条，0，顶点.length/3）；
//在离开之前禁用客户端状态
gl.glDisableClientState（GL10.gl_顶点数组）；
gl.glDisableClientState（GL10.gl_纹理_坐标_数组）；
//gl.glDisable（GL10.gl\u混合）；
}
//卡加德提普拉斯酒店
公共void loadGLTexture（GL10 gl，上下文上下文）{
//织物一般
gl.glGenTextures（1，纹理，0）；
//y se lo asignamos a nuestro阵列
gl.glBindTexture（GL10.gl_TEXTURE_2D，textures[0]）；
//质地过滤奶油
gl.glTexParameterf（GL10.gl\u纹理\u 2D，GL10.gl\u纹理\u最小\u过滤器，GL10.gl\u最近）；
gl.glTexParameterf（GL10.gl\u纹理\u 2D，GL10.gl\u纹理\u MAG\u过滤器，GL10.gl\u线性）；
//可能的纹理参数不同GL10.GLU夹紧到边缘
gl.glTexParameterf（GL10.gl\u纹理\u 2D、GL10.gl\u纹理\u包裹、GL10.gl\u重复）；
gl.glTexParameterf（GL10.gl\u纹理\u 2D，GL10.gl\u纹理\u包裹，GL10.gl\u重复）；
//Usamos安卓GLUtils二维立体位图
GLUtils.texImage2D（GL10.GL_纹理_2D，0，位图，0）；
//检查1.1版和通用地图的背景。不需要，请使用新的实施方案
if（GL11的gl实例）{
gl.glTexParameterf（GL11.gl\u纹理\u 2D，GL11.gl\u生成\u MIPMAP，GL11.gl\u真）；
GLUtils.texImage2D（GL10.GL_纹理_2D，0，位图，0）；
}否则{
buildMipmap（gl，位图）；
}   
//Limpiamos los位图
bitmap.recycle（）；
}
//Nuestra implementación de MipMap.Escalamos el
public class Square {
    //Buffer de vertices
    public FloatBuffer vertexBuffer;
    //Buffer de coordenadas de texturas
    private FloatBuffer textureBuffer;
    //Puntero de texturas
    private int[] textures = new int[3];
    //El item a representar
    private Bitmap bitmap; //image with POT dimensions
    //size of the polygon:
    public float w;
    public float h;
    //size of the texture
    private float textureX;
    private float textureY; 
    //Definición de vertices    
    public float vertices[] = new float[12];
    private float vertices_transformed[] = new float[12];
    //Coordenadas (u, v) de las texturas    
    private float texture[];    
    // Image ratio
    float ratio;

    public int id;

    Context context;

    //Inicializamos los buffers
    public Square(Bitmap image, Context context) {      
        int bitmapW=image.getWidth();
        int bitmapH=image.getHeight();

            w=1.00f;
            h=(float)bitmapH/bitmapW;       


        float vertices2[] = { 
            -w, -h, 0.0f,   //Bottom Left
            w, -h, 0.0f,    //Bottom Right
            -w, h, 0.0f,    //Top Left
            w, h, 0.0f      //Top Right
        };
        vertices=vertices2;

        //calculamos la siguiente potencia de 2 del lado mas largo del bitmap, alto o ancho.
        int nextPOT; 
        if (bitmapW>bitmapH)
            nextPOT=getNextPOT(bitmapW);
        else
            nextPOT=getNextPOT(bitmapH);

        //creamos un nuevo bitmap cuadrado con dimensiones potencia de 2, y dentro de el metemos la imagen
        bitmap = Bitmap.createBitmap(nextPOT, nextPOT, Bitmap.Config.ARGB_8888); //crea un bitmap transparente gracias al ARGB_8888
        Canvas comboImage = new Canvas(bitmap);
        comboImage.drawBitmap(image, 0, 0, null);
        comboImage.save();      

        //calculamos las coordenadas de la textura dentro del bitmap que es potencia de 2
        textureX = (float)bitmapW / nextPOT;
        textureY = (float)bitmapH / nextPOT;

        //creamos el array de la textura, pasándole las coordenadas ya obtenidos
        float texture2[] ={
                0.0f,textureY,
                textureX, textureY,
                0.0f, 0.0f,
                textureX,0.0f
            };

        System.out.println("bw:"+bitmapW+"   nextPOT:"+nextPOT+"   texX:"+textureX);

        texture=texture2;   


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

        //setPosition(0,0);

        ratio = (float)image.getWidth() / image.getHeight();

        image.recycle();
    } 

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

        //Usamos Android GLUtils para espcificar una textura de 2 dimensiones para nuestro bitmap
        GLUtils.texImage2D(GL10.GL_TEXTURE_2D, 0, bitmap, 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, bitmap, 0);
        } else {
            buildMipmap(gl, bitmap);
        }   
        //Limpiamos los bitmaps
        bitmap.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;
        }
    }

    //returns the next POT
    public static int getNextPOT(int n){
        int i = 1;
        while(i < n)
            i *= 2;      
        return i;
    }

    public void setPosition( float x , float y ){
        vertexBuffer.put( 0 ,  vertices[0]+x );
        vertexBuffer.put( 3 ,  vertices[3]+x );
        vertexBuffer.put( 6 ,  vertices[6]+x );
        vertexBuffer.put( 9 ,  vertices[9]+x );

        vertexBuffer.put( 1 ,  vertices[1]+y );
        vertexBuffer.put( 4 ,  vertices[4]+y );
        vertexBuffer.put( 7 ,  vertices[7]+y );
        vertexBuffer.put( 10 ,  vertices[10]+y );       
    }

    public void move( float dx , float dy ){
        vertexBuffer.put( 0 ,  vertexBuffer.get(0)+dx );
        vertexBuffer.put( 3 ,  vertexBuffer.get(3)+dx );
        vertexBuffer.put( 6 ,  vertexBuffer.get(6)+dx );
        vertexBuffer.put( 9 ,  vertexBuffer.get(9)+dx );

        vertexBuffer.put( 1 ,  vertexBuffer.get(1)+dy );
        vertexBuffer.put( 4 ,  vertexBuffer.get(4)+dy );
        vertexBuffer.put( 7 ,  vertexBuffer.get(7)+dy );
        vertexBuffer.put( 10 ,  vertexBuffer.get(10)+dy );          
    }

    //CARGA DE TEXTURAS DIFERENTES PARA EL POLÍGONO
    static int[] mTextureNameWorkspace= new int[1];
    static int[] mCropWorkspace=new int[4];

    public int loadBitmap(Context context, GL10 gl, String imageName) {
        BitmapFactory.Options sBitmapOptions  = new BitmapFactory.Options();
        sBitmapOptions.inPreferredConfig = Bitmap.Config.RGB_565;
        sBitmapOptions.inScaled=false;

        int textureName = -1;
        if (context != null && gl != null) {
            gl.glGenTextures(1, mTextureNameWorkspace, 0);
            textureName = mTextureNameWorkspace[0];
            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);
            gl.glTexEnvf(GL10.GL_TEXTURE_ENV, GL10.GL_TEXTURE_ENV_MODE, GL10.GL_MODULATE);

            Bitmap bitmap = loadImage(imageName, context);

            GLUtils.texImage2D(GL10.GL_TEXTURE_2D, 0, bitmap, 0);

            mCropWorkspace[0] = 0;
            mCropWorkspace[1] = bitmap.getHeight();
            mCropWorkspace[2] = bitmap.getWidth();
            mCropWorkspace[3] = -bitmap.getHeight();

            bitmap.recycle();

            ((GL11) gl).glTexParameteriv(GL10.GL_TEXTURE_2D, GL11Ext.GL_TEXTURE_CROP_RECT_OES, mCropWorkspace, 0);
            textures[0]=textureName;
        }
        return textureName;
    }

    public static Bitmap loadImage( String imageName, Context context){
        if( imageName.charAt(0) == '/' ) {
            imageName = imageName.substring(1);
        }
        imageName = imageName + ".png";
        Bitmap image = BitmapFactory.decodeStream(getResourceAsStream(imageName, context));
        return image;
    }
    public static InputStream getResourceAsStream( String resourceName, Context context) {
        if( resourceName.charAt(0) == '/' ) {
            resourceName = resourceName.substring(1);
        }

        InputStream is = null;
        try {
            is = context.getAssets().open( resourceName );
        } catch (IOException e) {e.printStackTrace();}
        return is;
    }


}

int txDog=loadBitmap(context,gl,R.drawable.dog);//This generetes an opengl texture id with the given image
int txCat=loadBitmap(context,gl,R.drawable.cat);

public void Render(GL10 gl,int texid);

gl.glBindTexture(GL10.GL_TEXTURE_2D, thetexturenameid);

public void Render(gl,txDog);//if you want the dog texture
public void Render(gl,txCat);//if you want the cat texture




static int[] mTextureNameWorkspace= new int[1];
static int[] mCropWorkspace=new int[4];
public static int loadBitmap(Context context, GL10 gl, int resourceId) {
    BitmapFactory.Options sBitmapOptions  = new BitmapFactory.Options();
    sBitmapOptions.inPreferredConfig = Bitmap.Config.RGB_565;
    sBitmapOptions.inScaled=false;


    int textureName = -1;
    if (context != null && gl != null) {
        gl.glGenTextures(1, mTextureNameWorkspace, 0);

        textureName = mTextureNameWorkspace[0];
        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);
        gl.glTexEnvf(GL10.GL_TEXTURE_ENV, GL10.GL_TEXTURE_ENV_MODE,GL10.GL_MODULATE);


        InputStream is = context.getResources().openRawResource(resourceId);
        Bitmap bitmap;

        bitmap = BitmapFactory.decodeStream(is, null, sBitmapOptions);


        GLUtils.texImage2D(GL10.GL_TEXTURE_2D, 0, bitmap, 0);

        mCropWorkspace[0] = 0;
        mCropWorkspace[1] = bitmap.getHeight();
        mCropWorkspace[2] = bitmap.getWidth();
        mCropWorkspace[3] = -bitmap.getHeight();

        bitmap.recycle();

        ((GL11) gl).glTexParameteriv(GL10.GL_TEXTURE_2D, 
                GL11Ext.GL_TEXTURE_CROP_RECT_OES, mCropWorkspace, 0);




    }

    return textureName;
}