2. 程式人生 > >OpenGL ES 紋理

OpenGL ES 紋理

阿新 • • 發佈：2019-02-08

使用前面學過的技術已經可以利用OpenGL ES構建立體圖形，並通過頂點著色器和片元著色器對其進行各種變化呢和光照等效果使得三維效果更加真實，實際上我看看到很多的3D遊戲漂亮多了，那是因為有各種各樣的漂亮的影象帶給人很多視覺盛宴，這篇文章在前面的基礎上，增加物體的表面貼圖，使得物體更加好看。

紋理概念

紋理用來表示影象照片或者說一系列的資料，使用紋理可以使物體用用更多的細節。OpenGL ES 2.0 中有兩種貼圖：二維紋理和立方體紋理。

每個二維紋理都由許多小的紋理元素組成，類似與片元和畫素，使用紋理最簡單的方式就是直接從一個影象載入資料。在OpenGL中規定紋理影象的左下角由st座標(0.0,0.0)指定，右上角由s

t座標(1.0,1.0)指定，不過超過1.0的座標也是允許的，在該區間之外的紋理在讀取時的時候由紋理拉伸模式決定。

OpenGL ES 2.0不必是正方形，但是每個維度都應該是2的冪

在Android中使用的OpenGL ES的紋理座標系跟官方的紋理座標系統不一樣，在Android中使用官方的紋理座標系統，得到的結果是相反的，而是左上角是st座標(0.0,0.0)點，右下角是st座標(1.0,1.0)點。

二維紋理對映的原理
二維紋理對映示意圖
使用紋理就是在紋理圖中進行取樣，因此需要將選定的紋理座標穿進頂點著色器，經過插值在片元著色器中從紋理圖中的指定位置取樣即可，紋理圖的資料通過往片元插值器傳遞紋理單元指定的。

紋理物件和紋理載入

建立一個紋理物件，儲存渲染所需的紋理資料，例如影象資料、過濾模式、包裝模式。建立生成紋理物件的函式

public static native void glGenTextures(
        int n,  // 指定要生成的紋理物件的數量
        int[] textures,  // 儲存紋理物件ID的陣列
        int offset
    );

紋理物件在應用程式中不再使用時，需要刪除。

public static native void glDeleteTextures(
        int n,  // 指定要刪除的紋理數量
        int
 
[] textures, // 儲存待刪除的紋理ID的陣列
        int offset
    );

紋理物件的 ID 必須是 glGenTextures 產生的，一旦生成紋理ID，就必須繫結紋理物件才能繼續進行後續的操作。後續的操作將影響繫結的紋理物件。一旦紋理被繫結到一個特定的紋理目標，再刪除之前就一直保持著繫結狀態。

public static native void glBindTexture(
        int target, // 繫結紋理物件到目標 GL_TEXTURE_2D 或 GL_TEXTURE_CUBE_MAP
        int texture // 要繫結的紋理物件ID
    );

啟用某個紋理單元

public static native void glActiveTexture(
        int texture  // 要啟用的紋理單元
    );

對這兩個函式的理解：顯示卡中有N個紋理單元（GL_TEXTURE0，GL_TEXTURE1，GL_TEXTURE2…），每個紋理單元中儲存著很多紋理目標（targetTexture1D，targetTexture2D，targetTexture3D，targetTextureCube…），OpenGL ES 2.0貌似只支援了targetTexture2D和targetTextureCube。

紋理單元TextureUnit的定義如下

struct TextureUnit
{
    GLuint targetTexture1D;
    GLuint targetTexture2D;
    GLuint targetTexture3D;
    GLuint targetTextureCube;
    ...
};

glActiveTexture函式就是設定當前活動的紋理單元

TextureUnit textureUnits[GL_MAX_TEXTURE_IMAGE_UNITS]
GLuint currentTextureUnit = 0;
// ...
void glActiveTexture(GLenum textureUnit)
{
    currentTextureUnit = textureUnit  - GL_TEXTURE0 ;
}

glBindTexture函式就是將紋理物件ID賦值給當前活動的紋理單元的對應的目標紋理。

void glBindTexture(GLenum textureTarget, GLuint textureObject)
{
    TextureUnit *texUnit = &textureUnits[currentTextureUnit];
    switch(textureTarget)
    {
    case GL_TEXTURE_1D: texUnit->targetTexture1D = textureObject; break;
    case GL_TEXTURE_2D: texUnit->targetTexture2D = textureObject; break;
    case GL_TEXTURE_3D: texUnit->targetTexture3D = textureObject; break;
    case GL_TEXTURE_CUBEMAP: texUnit->targetTextureCube = textureObject; break;
    }
}

獲取一副圖片的紋理資料

public static void texImage2D(int target,  // 常數GL_TEXTURE_2D
                              int level,  // 表示多級解析度的紋理影象的級數，若只有一種解析度，則level設為0。
                              Bitmap bitmap,
                              int border  // 邊框，一般設為0 
                             )

其他紋理選項的設定使用glTexParameterf系列函式

public static native void glTexParameterf(
        int target, 
        int pname,  // 設定的引數，可以是GL_TEXTURE_MAG_FILTER,GL_TEXTURE_MIN_FILTER,GL_TEXTURE_WRAP_S,GL_TEXTURE_WRAP_T
        float param  // 引數對應的值
    );

應用紋理的例子

對前面的立方體的每個面應用一張圖片作為紋理貼圖，效果圖（這個紋理圖是哪個老師來著？）
應用紋理
Rectangle.java

public class Rectangle {
    private FloatBuffer mVertexBuffer;
    private int mProgram;
    private int mPositionHandle;
    private int muMVPMatrixHandle;
    private int mColorHandle;
    private int muMMatrixHandle;
    private int muLightLocationHandle;
    private int mTextureCoordHandle;
    private int textureId;
    private int muTextureHandle;

    private Context mContext;
    public Rectangle(Context context) {
        this.mContext = context;
        initVetexData();
    }

    public void initVetexData() {
        float vertices[] = new float[] {
                // 頂點   顏色      紋理座標
                //前面
                0, 0, 1,  1,1,1,0,  0.5f, 0.5f,
                1, 1, 1,  1,0,0,0,  1.0f, 0.0f,
                -1, 1, 1,  1,0,0,0,  0.0f, 0.0f,
                0, 0, 1,  1,1,1,0,  0.5f, 0.5f,
                -1, 1, 1,  1,0,0,0,  0.0f, 0.0f,
                -1,-1, 1,  1,0,0,0,  0.0f, 1.0f,
                0, 0, 1,  1,1,1,0,  0.5f, 0.5f,
                -1,-1, 1,  1,0,0,0,  0.0f, 1.0f,
                1,-1, 1,  1,0,0,0,  1.0f, 1.0f,
                0, 0, 1,  1,1,1,0,  0.5f, 0.5f,
                1,-1, 1,  1,0,0,0,  1.0f, 1.0f,
                1, 1, 1,  1,0,0,0,  1.0f, 0.0f,
                //後面
                0, 0,-1,  1,1,1,0,  0.5f, 0.5f,
                1, 1,-1,  1,0,0,0,  1.0f, 0.0f,
                1,-1,-1,  1,0,0,0,   0.0f, 0.0f,
                0, 0,-1,  1,1,1,0,  0.5f, 0.5f,
                1,-1,-1,  1,0,0,0,   0.0f, 0.0f,
                -1,-1,-1,  1,0,0,0,  0.0f, 1.0f,
                0, 0,-1,  1,1,1,0,  0.5f, 0.5f,
                -1,-1,-1,  1,0,0,0,  0.0f, 1.0f,
                -1, 1,-1,  1,0,0,0, 1.0f, 1.0f,
                0, 0,-1,  1,1,1,0,  0.5f, 0.5f,
                -1, 1,-1,  1,0,0,0, 1.0f, 1.0f,
                1, 1,-1,  1,0,0,0,  1.0f, 0.0f,
                //左面
                -1, 0, 0,  1,1,1,0, 0.5f, 0.5f,
                -1, 1, 1,  1,0,0,0, 1.0f, 0.0f,
                -1, 1,-1,  1,0,0,0,  0.0f, 0.0f,
                -1, 0, 0,  1,1,1,0, 0.5f, 0.5f,
                -1, 1,-1,  1,0,0,0,  0.0f, 0.0f,
                -1,-1,-1,  1,0,0,0,  0.0f, 1.0f,
                -1, 0, 0,  1,1,1,0, 0.5f, 0.5f,
                -1,-1,-1,  1,0,0,0,  0.0f, 1.0f,
                -1,-1, 1,  1,0,0,0, 1.0f, 1.0f,
                -1, 0, 0,  1,1,1,0, 0.5f, 0.5f,
                -1,-1, 1,  1,0,0,0, 1.0f, 1.0f,
                -1, 1, 1,  1,0,0,0, 1.0f, 0.0f,
                //右面
                1, 0, 0,  1,1,1,0, 0.5f, 0.5f,
                1, 1, 1,  1,0,0,0, 1.0f, 0.0f,
                1,-1, 1,  1,0,0,0,  0.0f, 0.0f,
                1, 0, 0,  1,1,1,0, 0.5f, 0.5f,
                1,-1, 1,  1,0,0,0,  0.0f, 0.0f,
                1,-1,-1,  1,0,0,0,  0.0f, 1.0f,
                1, 0, 0,  1,1,1,0, 0.5f, 0.5f,
                1,-1,-1,  1,0,0,0,  0.0f, 1.0f,
                1, 1,-1,  1,0,0,0, 1.0f, 1.0f,
                1, 0, 0,  1,1,1,0, 0.5f, 0.5f,
                1, 1,-1,  1,0,0,0, 1.0f, 1.0f,
                1, 1, 1,  1,0,0,0, 1.0f, 0.0f,
                //上面
                0, 1, 0,  1,1,1,0,  0.5f, 0.5f,
                1, 1, 1,  1,0,0,0,  1.0f, 0.0f,
                1, 1,-1,  1,0,0,0,   0.0f, 0.0f,
                0, 1, 0,  1,1,1,0,  0.5f, 0.5f,
                1, 1,-1,  1,0,0,0,   0.0f, 0.0f,
                -1, 1,-1,  1,0,0,0,  0.0f, 1.0f,
                0, 1, 0,  1,1,1,0,  0.5f, 0.5f,
                -1, 1,-1,  1,0,0,0,  0.0f, 1.0f,
                -1, 1, 1,  1,0,0,0, 1.0f, 1.0f,
                0, 1, 0,  1,1,1,0,  0.5f, 0.5f,
                -1, 1, 1,  1,0,0,0, 1.0f, 1.0f,
                1, 1, 1,  1,0,0,0,  1.0f, 0.0f,
                //下面
                0,-1, 0,  1,1,1,0,  0.5f, 0.5f,
                1,-1, 1,  1,0,0,0,  1.0f, 0.0f,
                -1,-1, 1,  1,0,0,0,  0.0f, 0.0f,
                0,-1, 0,  1,1,1,0,  0.5f, 0.5f,
                -1,-1, 1,  1,0,0,0,  0.0f, 0.0f,
                -1,-1,-1,  1,0,0,0,  0.0f, 1.0f,
                0,-1, 0,  1,1,1,0,  0.5f, 0.5f,
                -1,-1,-1,  1,0,0,0,  0.0f, 1.0f,
                1,-1,-1,  1,0,0,0,  1.0f, 1.0f,
                0,-1, 0,  1,1,1,0,  0.5f, 0.5f,
                1,-1,-1,  1,0,0,0,  1.0f, 1.0f,
                1,-1, 1,  1,0,0,0,  1.0f, 0.0f
            };
        ByteBuffer vbb = ByteBuffer.allocateDirect(vertices.length * 4);
        vbb.order(ByteOrder.nativeOrder());
        mVertexBuffer = vbb.asFloatBuffer();
        mVertexBuffer.put(vertices);
        mVertexBuffer.position(0);

        int vertexShader = loaderShader(GLES20.GL_VERTEX_SHADER, vertexShaderCode);
        int fragmentShader = loaderShader(GLES20.GL_FRAGMENT_SHADER, fragmentShaderCode);

        mProgram = GLES20.glCreateProgram();
        GLES20.glAttachShader(mProgram, vertexShader);
        GLES20.glAttachShader(mProgram, fragmentShader);
        GLES20.glLinkProgram(mProgram);

        mPositionHandle = GLES20.glGetAttribLocation(mProgram, "aPosition");
        mColorHandle = GLES20.glGetAttribLocation(mProgram, "aColor");
        mTextureCoordHandle = GLES20.glGetAttribLocation(mProgram, "aTextureCoord");

        muMVPMatrixHandle = GLES20.glGetUniformLocation(mProgram, "uMVPMatrix");
        muMMatrixHandle = GLES20.glGetUniformLocation(mProgram, "uMMatrix");
        muLightLocationHandle = GLES20.glGetUniformLocation(mProgram, "uLightLocation");
        muTextureHandle = GLES20.glGetUniformLocation(mProgram, "uTexture");
        initTexture();
    }

    // 初始化紋理
    public void initTexture() {
        int [] textures = new int[1];
        GLES20.glGenTextures(1, textures, 0);
        textureId = textures[0];
        // 啟用紋理單元,預設啟用的就是0號紋理單元
        //GLES20.glActiveTexture(GLES20.GL_TEXTURE0);
        // 將紋理物件ID繫結到當前活動的紋理單元0上的GL_TEXTURE_2D目標
        GLES20.glBindTexture(GLES20.GL_TEXTURE_2D, textureId);
        // 後面對紋理的設定都是對綁定了的紋理所生效的
        //縮小取樣使用最近點取樣
        GLES20.glTexParameterf(GLES20.GL_TEXTURE_2D, GLES20.GL_TEXTURE_MIN_FILTER,GLES20.GL_NEAREST);
        //縮小取樣使用最近點取樣
        GLES20.glTexParameterf(GLES20.GL_TEXTURE_2D,GLES20.GL_TEXTURE_MAG_FILTER,GLES20.GL_LINEAR);
        //紋理包裹拉伸方式在st軸採用擷取拉伸方式，這些設定指的是對座標範圍超過1的部分的限制
        GLES20.glTexParameterf(GLES20.GL_TEXTURE_2D, GLES20.GL_TEXTURE_WRAP_S,GLES20.GL_CLAMP_TO_EDGE);
        GLES20.glTexParameterf(GLES20.GL_TEXTURE_2D, GLES20.GL_TEXTURE_WRAP_T,GLES20.GL_CLAMP_TO_EDGE);

        Bitmap bitmap = BitmapFactory.decodeResource(mContext.getResources(), R.drawable.texture);
        GLUtils.texImage2D(GLES20.GL_TEXTURE_2D, 0, bitmap, 0);
        // 圖片已經載入到了視訊記憶體，可以回收
        bitmap.recycle();
    }

    public void draw() {
        GLES20.glDrawArrays(GLES20.GL_TRIANGLES, 0, 12*6);
    }

    public void setValue(float[] mvpMatrix, float[] mMatrix) {
        GLES20.glUseProgram(mProgram);
        mVertexBuffer.position(0);
        GLES20.glVertexAttribPointer(mPositionHandle, 3, GLES20.GL_FLOAT, false, (4+3+2) * 4, mVertexBuffer);
        mVertexBuffer.position(3);
        GLES20.glVertexAttribPointer(mColorHandle, 4, GLES20.GL_FLOAT, false, (4+3+2) * 4, mVertexBuffer);
        mVertexBuffer.position(7);
        GLES20.glVertexAttribPointer(mTextureCoordHandle, 2, GLES20.GL_FLOAT, false, (4+3+2) * 4, mVertexBuffer);
        GLES20.glEnableVertexAttribArray(mPositionHandle);
        GLES20.glEnableVertexAttribArray(mColorHandle);
        GLES20.glEnableVertexAttribArray(mTextureCoordHandle);

        GLES20.glUniform3f(muLightLocationHandle, 0, 0, 20);
        GLES20.glUniformMatrix4fv(muMVPMatrixHandle, 1, false, mvpMatrix, 0);
        GLES20.glUniformMatrix4fv(muMMatrixHandle, 1, false, mMatrix, 0);
        // 將使用的紋理單元0傳遞給片元著色器
        GLES20.glUniform1i(muTextureHandle, 0);
    }

    private int loaderShader(int type, String shaderCode) {
        int shader = GLES20.glCreateShader(type);
        GLES20.glShaderSource(shader, shaderCode);
        GLES20.glCompileShader(shader);
        return shader;
    }

    private String vertexShaderCode = "uniform mat4 uMVPMatrix;"
            + "attribute vec2 aTextureCoord;"
            + "varying vec2 vTextureCoord;"
            + "uniform mat4 uMMatrix;"
            + "uniform vec3 uLightLocation;"
            + "attribute vec4 aColor;"
            + "varying  vec4 vColor;"  
            + "varying vec4 vDiffuse;"
            + "attribute vec3 aPosition;"
            + "void main(){"  
            + "vec3 normalVectorOrigin = aPosition;"
            + "vec3 normalVector = normalize((uMMatrix*vec4(normalVectorOrigin,1)).xyz);"
            + "vec3 vectorLight = normalize(uLightLocation - (uMMatrix * vec4(aPosition,1)).xyz);"
            + "float factor = max(0.0, dot(normalVector, vectorLight));"
            + "vDiffuse = factor*vec4(1,1,1,1.0);"
            + "gl_Position = uMVPMatrix * vec4(aPosition,1);"
            + "vColor = aColor;"
            + "vTextureCoord = aTextureCoord;"  // 將紋理座標傳到片元著色器，得到更多的插值紋理座標
            + "}";

    private String fragmentShaderCode = "precision mediump float;"
            + "uniform sampler2D uTexture;"  // 這個uniform變量表示了紋理資料，從java中傳過來的是所在的紋理單元編號
            + "varying vec2 vTextureCoord;"
            + "varying  vec4 vColor;"
            + "varying vec4 vDiffuse;"
            + "void main(){"
            + "gl_FragColor = (vColor*vDiffuse + vColor*vec4(0.6,0.6,0.6,1))*texture2D(uTexture, vTextureCoord);"  // 在紋理的基礎上還考慮到光照，texture2D函式用於紋理取樣
            + "}";
}

需要注意的還是傳入的頂點的時候數組裡麵包含了頂點、顏色和紋理座標，因此要用ByteBuffer的position方法定位。
程式碼下載

相關推薦

OpenGL ES 紋理設定

紋理過濾 紋理取樣 最近點取樣 線性紋理取樣 MIPMAP紋理 紋理過濾 紋理拉伸：重複拉伸和擷取拉伸 用於指定紋理座標超過(00.0,1

OpenGL ES 紋理壓縮之ETC （二）

前面介紹了OpenGL ES2.0 支援的壓縮ETC1;下面我們來學習一下ETC2。 從opengl es3.0 開始支援ETC2紋理壓縮，而這種壓縮可以支援透明通道。 下面看如何使用 載入pkm檔案 public static byte[] loadDataFromAsse

android opengl es--紋理對映，光照

import zhou.ne.he.four.FourRend; import zhou.ne.he.one.OneRend; import zhou.ne.he.thri.ThriRend; import zhou.ne.he.two.TwoRend; import a

OpenGL ES 紋理貼圖

頂點座標和紋理座標 在沒有投影矩陣的情況下，我們要傳給頂點著色器的座標值都在（-1，1）範圍內，超出了這個範圍將不可見。因此對於一個四邊形的繪製，我們經常看到下面的頂點座標： GLfloat vertices[] = { // P

OpenGL ES 紋理

使用前面學過的技術已經可以利用OpenGL ES構建立體圖形，並通過頂點著色器和片元著色器對其進行各種變化呢和光照等效果使得三維效果更加真實，實際上我看看到很多的3D遊戲漂亮多了，那是因為有各種各樣的漂亮的影象帶給人很多視覺盛宴，這篇文章在前面的基礎上，增

Opengl ES 1.x NDK實例開發之六:紋理貼圖

otto absolute decode super rep mit his viewport 一個 開發框架介紹請參見：Opengl ES NDK實例開發之中的一個:搭建開發框架 本章在第三章(Opengl ES 1.x NDK實例開發之三:多邊形的旋轉)的基礎

android平臺下OpenGL ES 3.0實現2D紋理貼圖顯示bitmap

OpenGL ES 3.0學習實踐 android平臺下OpenGL ES 3.0從零開始 android平臺下OpenGL ES 3.0繪製純色背景 android平臺下OpenGL ES 3.0繪製圓點、直線和三角形 android平臺下OpenGL E

OpenGL ES (3):平面圖形-表面紋理貼圖

1.簡介 上一篇已經將一個平面圖形繪製出來了，這一次我們將在上一次繪製出來的圖形的表面上進行紋理貼圖。 圖片準備：（寬高須為2的N次方） 最終圖片是以Bitmap形式。現在考慮如何把這張圖片對映到繪製的平面上？ 所以這裡也需要一個數組float[] 用於設定紋理座

OpenGL ES (16): 紋理貼圖

1.前言 圖片如下：紋理座標為 左上角為（0，0），右下角為（1，1） 我們繪製一個正方形,頂點座標資料如下： 此次程式碼不包含z軸，預設為0。 要做的事就是把圖片貼到正方形的表面，並繪製出正方形。 所以上面的紋理座標和頂點座標的順序要一致。這樣繪製的圖片才

初學Android,OpenGL ES之使用紋理(八十三)

在網上發現這些講紋理的文章,非常不錯android 遊戲導引(4. 簡單紋理貼圖)Android OpenGL es 紋理座標設定與貼圖規則Android OpenGL | ES給立方體進行紋理對映這篇的例子也是立方體的紋理,不過是用手指劃過讓立方體旋轉使用紋理的重要程式碼如

從零開始OpenGL ES(四) 繪製紋理 圖片

理論 首先是兩個座標系 假如現在有一張圖片,是通過紋理座標系繪製出來的,圖片的左上角(0,0),左下角(0,1), 那麼我需要把紋理座標系和頂點座標系對齊, 那麼要把紋理座標系中(0,0)這個點,放到頂點座標系中的(-1,0)這個點. 相應的要把紋理座標系的

Android OpenGL ES 2.0繪圖：繪製紋理

紋理，在OpenGL中，可以理解為載入到顯示卡視訊記憶體中的圖片。 Android裝置在 2.2開始支援OpenGL ES2.0，從前都是ES1.0 和 ES1.1的版本。 簡單來說，OpenGL ES是為了嵌入裝置進行功能剪裁後的OpenGL版本。ES2.0是和1.x版本不相容的，區別和相容性參見

OpenGL ES 理解紋理與紋理過濾

1.理解紋理 OpenGL中的紋理可以用來表示影象，照片，甚至由一個數學演算法生成的分形資料。每個二維的紋理都由許多小的紋理元素組成，它們是小塊的資料，類似於我們前面討論過的片段和畫素。要使用紋理，最常用的方式是直接從一個影象檔案載入資料。 每個二維紋理都有其自己

Android OpenGL ES正方體紋理貼圖(每個面一張)

正方體的紋理貼圖步驟如下： 1.陣列 1.1：頂點陣列 1.2：三角形 1.3：貼圖陣列 2.onSurfaceChanged：與3D的一樣 3.onSurfaceCreated：需要新增東西 3.1允許2D貼圖gl.glEnable(GL10.GL_TEXTURE_2D

初學Android OpenGL ES之使用紋理 八十三

mod frame ava als content detect www 大小 net 在網上發現這些講紋理的文章,非常不錯 android 遊戲導引(4. 簡單紋理貼圖) http://www.cnblogs.com/shengdoushi/archive/2011/0

opengl es 渲染方式與 紋理座標設定 ,OpenGL ES 模型檢視之縮放操作

OpenGl ES關於渲染方式有以下兩種： RENDERMODE_CONTINUOUSLY和RENDERMODE_WHEN_DIRTY。 預設渲染方式為RENDERMODE_CONTINUOUSLY，這兩種渲染的含義是： RENDERMODE_CONTINUOUSL

Android使用OpenGL ES顯示紋理(使用NDK開發）

書上第四章最後開始介紹使用OpenGL來顯示一個2D紋理，其實做音視訊2D基本滿足絕大多數要求了，下面簡單分析一下原始碼中的流程。 EGL環境初始化 首先我們需要在Java環境中初始化一個SurfaceView，然後在回撥中我們傳入surface。這裡我

android opengl es新增紋理，繪製立方體紋理，立方體使用不同紋理

           紋理就是給物體表面新增圖片，色彩之類，可以認為是上色。            基本步驟： 開啟紋理開關建立紋理繫結紋理設定紋理引數生成紋理設定紋理頂點資料 具體看如下程式碼： @Override public void onSurfaceCrea

Android OpenGL ES(七)----理解紋理與紋理過濾

1.理解紋理 OpenGL中的紋理可以用來表示影象，照片，甚至由一個數學演算法生成的分形資料。每個二維的紋理都由許多小的紋理元素組成，它們是小塊的資料，類似於我們前面討論過的片段和畫素。要使用紋理，最常用的方式是直接從一個影象檔案載入資料。 每個二維紋理都有其自己的座標

Android OpenGL ES 2.0繪圖:繪製紋理

http://mobile.51cto.com/aengine-437172.htm publicclass MyGLSurfaceView extends GLSurfaceView { public MyGLSurfaceView(Context context