分類: OpenGL

『觸屏坐標』『x,y』坐標轉『正交投影』坐標, 『視錐體解像』寬高, 比例需手機解像寬高比壹致.

計屏幕寬高比

『視錐體解像』寬高,此時定義『高』800pix

『正交投影』代碼

重置視區尺寸, 值係手機解像寬高

設定投影矩陣

載入單位矩陣

正交投影, 游戲坐標原點(0,0,0)為於屏幕中心

設定模型視圖矩陣

載入單位矩陣

手指触摸手機屏幕onTouch() 所得坐標需轉游戲世界坐標,正交投影OpenGL游㱆+Z軸指向屏幕深處.

計3D相機位置

游戲坐標原點(0,0,0)為於屏幕中心

『漢字字庫』同 『ASCII字庫』原理同, 字庫『竪排』, 漢字『32*32』pixel, 『竪』32漢字.

由上至下,由右至左排列.可填1024字符,每色8Bit. 即『索引色』『調色板』.

准備庫位圖

1. 白紙黑字,
2. 白色係透明色. 黑色係變換色.

Photoshop轉為『索引色』

1. 『影像』->『模色』->『索引色』
2. 『色盤』揀『正確』.
3. 『顏色』量3
4. 『强制』揀『黑白』
5. 『透明』勾選
6. 存為『.pcx』或『.bmp』

止時圖檔『調色板』共有三色『黑』『白』『透明』.

『調色板』結构同DirextX唔同, 將flags存alpha『透明值』0~255,0係『透明』,255係『實心』

設置『調色板』顏色

黑字『調色板』設置

白字『調色板』設置

半透明,激活混合

設混合模式, 渲染時Alpha值混合.

激活透明测试

Alpha=0時, 過濾背影色

初台Android手機己采用『單點』触摸, 直至Android2.0(SDK version 5) 先支持『多點』触摸.

1. Android觸摸監聽『OnTouchListener』 監聽 『触屏』事件.

2. 通過『onTouch()』獲取『触屏』信息.

3. 0(ÉCLAIR)(API 5) 先支持多點触摸

4. 處理『多點』触摸

5. 處理『單點』触摸

6. 返回false, 繼續處理觸摸事件.

1. 生成觸摸監聽

2. 為OpenGL View注冊触摸监听,

3. 通過OnTouch()(View v, MotionEvent event) 獲取『触屏』坐標 . 『触屏』原點(0,0) 係左上角, 單位象素

4. 獲取『触屏』事件類型 . MotionEvent.getAction()

5. 『触屏』類型簡化為『撳』『鬆』『拖』三類

處理『單點』触摸

6. 提取『触屏』事件類型

7. 處理『撳』類型

8. 處理『撳』類型

9. 處理『拖』類型

處理『多點』触摸

10. 處理多手指触摸, 提取触摸事件索引

11. 通過触摸事件索引,『触屏』原點(0,0) 係左上角, 單位象素

12. 提取『触屏』事件類型

13. 處理多手指触摸, 提取触摸事件索引

14. 提取觸摸事件量

15. 遍歷冚觸摸事件

16. 跳過冇關觸摸事件

17. 處理『撳』類型

18. 處理『撳』類型

19. 處理『拖』類型

係C++緩存『触屏』信息Lib.setTouch();

『触屏座標』轉『熒屏座標』

係游戲渲染文本,『點陣字體』係遠古技術, 係位圖繪畫ASCII字符, 哎『位圖字符glyph』,標准ASCII字符128,有96拉丁字母可渲染,從32到126.『32』係『吉格』.

位圖每行16字符. 位圖寬高符合2ⁿ.位圖『256256』每字符『1616』像素, 位圖『512512』每字符『3232』像素.

定義位圖字符

1. 拉丁字母

2. 生成ASCII字符UV 紋理坐標,『width, height』字符寬高,

3. 移動X坐標

4. 換行

渲染位圖字庫

5. 2D頂點座標數組

6. UV紋理座標數組

7. 啟用2D紋理映射

8. 禁用法線

9. 啓用透明測試

10. 指定透明色

11. 綁定紋理

12. 啟用頂點座標數組

13. 啟用紋理座標數組

因為OpenGL『2D相機』原點『0,0』係『左下角』, 返䡛Y軸.

14. 逐字渲染『ASCII碼』

15. 『ASCII碼』轉『紋理索引』, 首ASCII碼係『吉格』,

16. 可渲染拉丁字母96, 『紋理索引』小於0大於96皆唔渲染.

17. 得到紋理坐標

18. 計算2D頂點坐標, 雙『三角形』.

19. 計算UV紋理坐標, 雙『三角形』.

20. 指定頂點數組

21. 指定紋理座標

22. 繪畫頂點數組,雙『三角形』.

23. 移動下壹渲染位, 分『橫排』同『縱排』

24. 禁用透明測試

25. 當前矩陣堆棧出棧

OpenGL有『平行投影』同『透視投影』, 2D相機係『平行投影』生成方盒『視體』, 愛蒞剪裁物體, 唔係『視體』內唔『渲染』. 愛蒞『等比例游戲』『平面游戲』

OpenGL『2D相機』原點『0,0』係『左下角』, z軸遠端係負,近端正.

Android『熒屏』原點『0,0』係『左上角』,

1. 首先指定『矩陣堆棧』為『投影矩陣堆棧』

2. 清除殘留矩陣并載入『單位矩陣』,.

3. 重置視區尺寸,『視區』變換係『投影』變換之後,『x,y』左下角『0,0』. 『width,height』同視窗尺寸相應『熒屏像素』, 除非想係視窗一部分區域繪畫, 可設較定較細『視區』.

4. 『平行投影』定方盒『視體』愛蒞剪裁物體, 而唔係3D相機錐形.『left, bottom』指左下角『0, 0』,『right, top』指右上角『width, height』. 熒屏尺寸設『800,600』或『640,480』. 游戲世界尺寸設『80,60』或『64,48』. OpenGL會自動放大與視區相配.『near, far』z軸剪裁面『1, -1』

5. 指定『視體』中心『x, y』.移動2D相機

6. 恢復『矩陣堆棧』為『視圖矩陣堆棧』

7. 載入『單位矩陣』,清除殘留矩陣

示例

3D游戲基于『透視投影』產生立體效果, 而2D游戲戲用『正交投影』產生平面效果, 生成等比例游戲.

1. 指定視區像素尺碼, 『x』 『y』視區左下角,『width』 『height』視區寬高

2. 設定『矩陣堆栈』為『投影矩陣堆栈』

3. 載入單位矩陣, 清除『堆栈』残留『矩陣』,以此唔受先前變换運算影响.

4. 『正交投影』運算, Y軸視角『fovy』,Z軸視角『aspect』, 『zNear』近裁剪面距离约摸箱機方向Y軸加 『zFar』远裁剪面距离設較大数值.

5. 設定『矩陣堆栈』為『模型視圖矩陣堆栈』

6. 載入單位矩陣

基於視角『正交投影』

Android Studio設置全屏,通過編輯『themes.xml』

編輯『AndroidManifest.xml』

代碼係『eclipse』移稙過蒞, 『Android Studio』程式閃退. 因『MainActivity』繼承『AppCompatActivity』造成. 改為繼承『Activity』.

OpenGL EGL作為平臺冇関 API, 今程序冇視『Linux X Window』『Microsoft Windows』『Mac OS X Quatz』差異.用統壹接口同原生視窗聯接. 跨平臺API更易於移值. 所以OpenGL比DirectX更得人鐘意.

1. 使用NDK
2. 編譯OpenGL ES
3. 布局OpenGL ES
4. 先加入頭文檔

5. 冚辦爛EGL程式首先調用『eglGetDisplay()』, 得到『EGLDisplay』等同『原生視窗』, 『EGLDisplay』係整數索引.

6. 索引大於零即成功, 因為等於零失敗.

7. 初始EGL程式, 幷獲得『major』主版號 , 『minor』副版號

8. 失敗返回EGL_FALSE, 查錯誤碼eglGetError()

9. 穩『surface』渲染配置

10. EglChooseConfig()函式參數

11. 『EGLConfig』屬性

屬性列表

12. 設定『EGLConfig』屬性

13. 據 attrib_array 返回最隹配置config

14. 匹配最佳配置

15. 生成渲染視窗

16. eglCreateWindowSurface()函式參數

17. 渲染視窗屬性

18. 屬性

19. 生成渲染視窗

20. 獲得錯誤碼

21. 關聯描述表, 将『EGLContext』『EGLSurface』與當前線程關聯, 『EGL』同『OpenGL』代碼需擺同壹綫程. 唔系eglSwapBuffers()返回

22. 『Native』層用『ANativeWindow 』蒞渲染.通過『Surface』得到『ANativeWindow』.

23. Android 『java』層用『SurfaceView』蒞渲染, 提取『Surface』畀『Native』

『Android Studio NDK』提供『EGL』連接『OpenGL』, 『EGL』被設計出來,作爲 OpenGL 和原生窗口系統之間的橋梁『Microsoft Windows』『Mac OS X Quatz』差異.用統壹接口同原生視窗聯接. 跨平臺API更易於移值. 所以OpenGL比DirectX更得人鐘意.

1. 使用NDK
2. 編譯OpenGL ES
3. 載入共享庫”app.so”,『app』系你庫名.

4. 首先修改布局『xml』添加『SurfaceView』,而非『GLSurfaceView』.

5. 係『xml』添加『全屏樣式』

6. 係『java』加『android.view.SurfaceHolder.Callback』用蒞行『SurfaceView』『創建』『改變』『銷毀』

7. 係『java』加『Runnable』用蒞行OpenGL 渲染線程, 『EGL』同『OpenGL』代碼需擺同壹綫程. 唔系eglSwapBuffers()返回EGL_BAD_SURFACE.

8. 係『xml』為Google Play加版本過濾

9. 係『txt』穩庫文檔

10. 係『txt』連連接庫文檔

11. 加入頭文檔

將『OpenGL』移稙過『Andord』. 但OpenGL ES偏偏冇gluPerspective()視錐投影.但有glFrustumf()設定視口.

3D相機投影代碼

將『風水羅盤』由『Windows』移稙過『Andord』. 係交換緩存畫面『eglSwapBuffers()』返回『EGL_FALSE』, 『eglGetError()』返回『EGL_BAD_SURFACE』.

係『Windows』有『Winmain()』入口. 可以控制冚個整游戲運作, 係 『Winmain()』 游戲『運行』『渲染』都係主線程行.

而 『Andord』冇『Winmain()』. 游戲『運行』『渲染』要係新線程『Thread()』行. 而『EGLContext』同『EGLSurface』需係同壹線程『Thread()』生成, 唔係『eglSwapBuffers()』投『EGL_BAD_SURFACE』錯誤碼.

知錯係邊就易整, 將egl()程式擺係新線程『Thread()』行,而非『 onSurfaceCreated()』.

係Android游戲唔將游戲資源擺係『res』而係『assets』, 事因『res』限制層次結構, 而『assets』允許任意檔案資料夾層次結構.位於『assets』檔案只讀唔寫. NDK需android 9版先支持.

係『CMakeLists.txt』添加『libandroid.so』庫

係c檔案加入頭檔

『assets』檔通過『AssetManager』訪問

係『NDK』『assets』檔通過『AAssetManager』訪問, 『AAssetManager』接口

將『AssetManager』傳過去獲得『AAssetManager』

開啟『assets』檔, 冇需畀絕對路徑, 而係畀『assets』相對路俓

檔长度

分配記憶體

讀『assets』檔

載入分析

释放记忆体

閂『assets』檔

將游戲資源擺係『assets』下,『assets』『res』同位於『app\src\main』之下.

gluLookAt()  UVN相機模型,設定視點(相機)位置和視綫方向(矩陣運算).

OpenGL ES冇gluLookAt() , 手工生成『旋轉矩陣』『相機位置』函式

當相機遠離模型時,模型也會變小.其紋理渲染採樣時會顆粒狀失真.解決失真問題關鍵在於讓屏幕中體積較小物體或遠離視點時.使用低分辯率『紋理Texture』圖像.稱值為紋理鏈.首先獲取紋理尺寸.然後創建比小分辨率紋理圖,把分辨率縮小一半.重複這一過程直到分辨率為1.為了在OpenGL ES使用紋理鏈,需要執行以下兩步

1. 將縮小係數過濾器設置為GL_XXX_MIPMAP_XXX這裡設置為如果不使用MIPMAP.只會使用首個紋理
2. 通過縮小紋理創建圖鏈.並將圖片上傳提交給OpenGL ES.作為當前圖層.圖層從0開此,0圖層為原始圖層,然後上傳圖層.然後將其寬度與高除以2不斷創建縮小圖層並上傳.回收位圖.直到寬與高等於零.最後一張紋理1*1像素.則退出循環.並且紋理鏈只能綁定單一紋理
3. 對於3D模形使用紋理鏈mipmap,而在2D材質無需應用
4. 若啟用mipmap所繪製物較小.性能提升較明顯.因為GPU只需從小圖片中提取紋理元素
5. 若啟用mipmap紋理鏈會比沒有使用多佔用33%記憶體.但可換來視角效果提升.特別對遠景物體可修正粒狀失真.
6. mipmap紋理鏈僅對正方形紋理有效.並且僅在OpenGL ES 1.x獲得支持.

紋理位圖載入與綁定.在其基礎加入紋理鏈代碼

GL10 gl = GRAPHICS.gl;

生成空的紋理對象,並獲取id

gl.glGenTextures(1, ids,0);

int id = ids[0];

讀取紋理圖

Bitmap  bitmap = BITMAP.Read(file_name);

綁定紋理ID

gl.glBindTexture(GL10.GL_TEXTURE_2D, id);

設置紋理屬性,紋理過濾器,指定縮小倍數過濾器

gl.glTexParameterf(GL10.GL_TEXTURE_2D, GL10.GL_TEXTURE_MIN_FILTER, GL10.GL_LINEAR_MIPMAP_NEAREST);

指定放大倍數過濾器

gl.glTexParameterf(GL10.GL_TEXTURE_2D, GL10.GL_TEXTURE_MAG_FILTER, GL10.GL_LINEAR);

獲取紋理寬度與高度

int    width = bitmap.getWidth();

int    height = bitmap.getHeight();

原始圖層索引為0

int level = 0;

while(true) {

上傳紋理

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

圖層索引號加一

++level;

計算縮小一半紋理位圖寬與高

int newWidth = bitmap.getWidth()/2;

int newHeight = bitmap.getHeight()/2;

寬與高等於零時跳出循環

if(newWidth == 0)

break;

創建縮小一半紋理位圖

Bitmap  newBitmap = Bitmap.createBitmap(newWidth,newHeight,bitmap.getConfig());

Canvas canvas = new Canvas(newBitmap);

canvas.drawBitmap(bitmap,

new Rect(0,0,bitmap.getWidth(),bitmap.getHeight()),

new Rect(0,0,newWidth,newHeight),

null);

回收位圖資源

bitmap.recycle();

bitmap = newBitmap;

}

取消邦定紋理ID

gl.glBindTexture(GL10.GL_TEXTURE_2D, 0);

回收位圖資源

bitmap.recycle();

射燈是OpenGL ES中燈光中最耗GPU資源燈光.但其3D效果十分逼真.睇上圖.射燈有多個參數需指定.『位置』『照射方向』『照射角度』小於180度、『衰減指數』小於零,若設為0則亮度不衰減,實制『衰減值』與遊戲3D空間尺寸有關.這裡設為0.01.以及三個光照顏色『環境色』『漫反射色』『鏡面反射色』

public class LightSpot {

private float[] ambient  = {1.0f, 1.0f, 1.0f, 1.0f};// 射燈-環境色

private float[] diffuse  = {1.0f, 1.0f, 1.0f, 1.0f};// 射燈-漫反射色

private float[] specular = {0.0f, 0.0f, 0.0f, 1.0f};// 射燈-高光顏色

private float[] position = {0.0f, 3.0f, 0.0f, 1.0f};// 射燈-位置

private float[] direction = {0.0f, -1.0f, 0.0f, 0.0f};// 射燈-方向

private float  cutoff    = 45;// 射燈-角度範圍,缺省為180.0

private float  exponent  = 0.01f;// 衰減指數,缺省為0.0f

int     id = 0;// 光照ID

// 射燈ID 輸入:GL10.GL_LIGHT0至GL10.GL_LIGHT7

LightSpot(int ID){

this.id = ID;

}

//設置射燈方向,轉換為方向向量.最後w分量設0,代表方向

public void setDirection(float x,float y,float z){

direction[0] = x – position[0];

direction[1] = y – position[1];

direction[2] = z – position[2];

direction[3] = 0;

}

// 設定射燈位置.w分量設為1代表位置向量

public void setPosition(float x,float y,float z){

position[0] = x;

position[1] = y;

position[2] = z;

position[3] = 1;

}

// 設定射燈顏色

public void setColor(float r,float g,float b){

ambient[0] = r;

ambient[1] = g;

ambient[2] = b;

ambient[3] = 1;

}

//使能射燈

public void enable(){

GL10 gl = GRAPHICS.gl;

gl.glEnable(id);//使能

gl.glLightfv(id,GL10.GL_AMBIENT, ambient, 0);// 射燈-環境色

gl.glLightfv(id,GL10.GL_DIFFUSE, diffuse, 0);// 射燈-漫反射色

gl.glLightfv(id,GL10.GL_SPECULAR, specular, 0);// 射燈-高光顏色

gl.glLightfv(id,GL10.GL_POSITION, position, 0);// 位置

gl.glLightfv(id,GL10.GL_SPOT_DIRECTION, direction, 0);// 方向

gl.glLightf(id,GL10.GL_SPOT_CUTOFF,cutoff); //  角度範圍

gl.glLightf(id,GL10.GL_SPOT_EXPONENT,exponent);// 衰減指數

}

// 屏蔽射燈

public void disable(){

GL10 gl = GRAPHICS.gl;

gl.glDisable(id);

}

}

物體都由特定材質構成.材質決定照射在物體上光返射方式並會改變反射光顏色.材質為多邊形設置材質屬性用於光照計算,它是全域性影響所有繪製多邊形,直到它在次調用.OpenGL ES中需要為每種材質指定『環境色』『漫反射色』『鏡面反射色』RGBA顏色值.此材質吸收光.只有『光源顏色』與『材質顏色』最小值運算(RGB值)得到『反射光顏色』

材質類代碼

public class Material {

private float[] ambient  = {1.0f, 1.0f, 1.0f, 1.0f};// 材質-環境色

private float[] diffuse  = {1.0f, 1.0f, 1.0f,  1.0f};// 材質-漫反射色

private float[] specular = {1.0f, 1.0f, 1.0f, 1.0f};// 材質-鏡面顏色

//設置材質環境色

public void setAmbient(float r,float g,float b){

ambient[0]=r;

ambient[1]=g;

ambient[2]=b;

ambient[3]=1;

}

// 設置材質漫反射色

public void setDiffuse(float r,float g,float b){

diffuse[0]=r;

diffuse[1]=g;

diffuse[2]=b;

diffuse[3]=1;

}

// 設置材質鏡面反射色

public void setSpecular(float r,float g,float b){

specular[0]=r;

specular[1]=g;

specular[2]=b;

specular[3]=1;

}

//使能材質

public void enable(){

GL10 gl = GRAPHICS.gl;

gl.glMaterialfv(GL10.GL_FRONT_AND_BACK,GL10.GL_AMBIENT,  ambient, 0);// 環境色

gl.glMaterialfv(GL10.GL_FRONT_AND_BACK,GL10.GL_DIFFUSE,  diffuse, 0);//  漫反射色

gl.glMaterialfv(GL10.GL_FRONT_AND_BACK,GL10.GL_SPECULAR, specular,0);//  鏡面反射色

}

}

環境光是一種特殊光.它沒有位置和方向.它只會均勻照射3D空間中所有物體.在OpenGL ES中啟用全域環境光.

啟用光照

gl.glEnable(GL10.GL_LIGHTING);

環境光純白色,色域範圍為0~1浮點數.影射對應0~255整數

float[] color = {1.0f,1.0f,1.0f,1f};// 環境光浮點數組

設定環境光最後參數color偏移量通常設為0

gl.glLightModelfv(GL10.GL_LIGHT_MODEL_AMBIENT, color, 0);

全域環境光代碼

public class LightAmbient {

static private float[] color = {1.0f,1.0f,1.0f,1f};// 環境光

//設定環境光

static public void setColor(float r,float g,float b ){

color[0] = r;

color[1] = g;

color[2] = b;

color[3] = 1;

}

//使能環境光

static public void enable(){

GL10 gl = GRAPHICS.gl;

gl.glLightModelfv(GL10.GL_LIGHT_MODEL_AMBIENT, color, 0);

}

}

光照系統它可以令3D遊戲更加逼真.要模擬光照需要光源發射光線.和被光照照射物.最後需要一台相機捕足光源發射光以及被物體反射光.光照會改變觀察者對被觀察者物體顏色感受.取卻於以下幾個因素

1. 光源類型
2. 光源顏色和強度
3. 光源相對於被照射物體位置和方向
4. 被照射物材質和紋理

被照射物體反射光強度取決於光照射到至物體平面時光與物體平面夾角.光與其所照射平面越接近垂直,物體表面反射光強度越大

一旦光照射到平面它會以兩種方式反射.鏡面反射會物體上表現出強光效果.物體鏡面反射效果取決於材質.

漫反射:大部分反射光線會因為物體不規則表面而隨機地發散開來,具有光滑表面

鏡面反射:光照射到光滑鏡面後返射回來,具有粗糙不平整表面是不可能形成

而光照射到表面時反射光顏色還取決於光源和材質顏色.

OpenGL ES可以創建出四種不同光源

環境光源:環境光本身非光源,而是由所在環境中其它光源發出光反射在周圍得到.這些環境光混合形成照明效果.環境光無方向並且被環境光照射所有物體都有共同亮度.

點光源:點光源在空間中有固定位置,並且向個方向照射.如燈泡

定向光源:定向光需要一個方向並延伸至無限遠.如太陽是標準定向光源

投射光源:在3D空間中有固定位置.並且有個照射方向.並且具有錐形照射區域.如街燈就是標準投射光.但很耗GPU資源.

OpenGL ES允許指定光顏色與強度,使用RGBA指定顏色

環境光色:被照射無體整體受到光色.物體將會接受這種顏色照射.並且與光源位置和方向無關.

漫反射色:物體反射時受到光色.背著光源另一面不會被照射到

鏡面反射色:鏡面反射色僅僅影響面向觀察者和光源面

投射色:僅影響錐型照射物

啟用光照,一旦開啟光照系統將被應用於所有渲染.你還需要指定光源與材質以及頂點法線確定最後光照效果

GL10.glEnable(GL10.GL_LIGHTING);

渲染完成必需關閉光照.否則影響之後GUI渲染.

GL10.glDisable(GL10.GL_LIGHTING);

OpenGL ES允許每個場景中最多使用8個光源,外加一個全域光源.光源ID從GL10.GL_LIGHT0至GL10.GL_LIGHT7

光源0使能並將其應用所有渲染物

GL10.glEnable(GL10.GL_LIGHT0);

若想單獨禁用某光源

GL10.glDisable(GL10.GL_LIGHT0);

OpenGL ES矩陣提供以下運算能力

1. 『矩陣』可將『頂點』移動glTranslatef()
2. 『矩陣』縮放『頂點』,即將『頂點』個座標分量剩以縮放值glScalef()
3. 『矩陣』可令『頂點』繞某軸旋轉glRotatef()
4. 『頂點』剩以『單位矩陣』相當於剩 glLoadIdentity()
5. 兩個『矩陣』相剩得到新『矩陣』剩以某個頂點.相當於兩『矩陣』剩以頂點後再相剩glMultMatrixf()

OpenGL ES提供有三種『矩陣』

投影矩陣:建立視錐體形狀和尺寸.它決定投影類型和睇到範圍

模型視圖矩陣:在模型空間中用該矩陣變換3D模型.並將其在3D空間中移動

紋理矩陣:用於動態操縱紋理矩陣

設置當前矩陣為『投影矩陣』

GL10.glMatrixMode(GL10.GL_PROJECTION);

在棧頂載入單位據陣

GL10.glLoadIdentity();

然後剩以正交投影矩陣

GL10.glOrthof(-1,1,-1,1, 1, -1);

設置當前矩陣『模型視圖矩陣』

GL10.glMatrixMode(GL10.GL_PROJECTION);

在棧頂載入單位據陣

GL10.glLoadIdentity();

3D空間中平移

GL10.glTranslatef(x,y,z);

繞Y軸旋轉

GL10.glRoate(angle,0,1,0);

將當前棧頂拷貝並壓入棧頂

GL10.glPushMatrix();

矩陣棧頂出棧

GL10.glPopMatrix();

OpenGL要啟用混合,要將每個頂點顏色ALPHA分量置設為0.5f.這樣模型後方對象都能透過模型睇到

1.       OpenGL ES 將在『深度緩存Z-Buffer』和『幀緩存』中渲染模型

2.       當OpenGL ES結合z-buffer啟用混合時.必需確保所有透面對象跟據其距離照相機遠近按升序排序.並且從後往線渲染對象.所有非透明必須在透明對象之前被渲染,而非透明對象不需要經過排序

啟用混合:

1.       啟用深度檢測(Z軸緩存)一定要調用glEnable(GL_DEPTH_TEST);.保證光照正確繪製和模形前後正確繪製

2.       啟用混合gl.glEnable(GL10.GL_BLEND);

3.       設定混合方程式gl.glBlendFunc(GL10.GL_SRC_ALPHA,GL10.GL_ONE_MINUS_SRC_ALPHA);

4.       設定模型透明度gl.glColor4f(1.0f, 1.0f, 1.0f,0.5f);

5.       完成渲染後禁用混合glDisable(GL_BLEND);

當需要在OpenGL ES中啟用混合.需要按以下方式渲染

1.       首先渲染所有不透明對象

2.       將所有透明對象按照其與相機距離運近排序(由遠及近)

3.       渲染排好序透明對象(由遠及近)

OpenGL中『幀緩存』用於儲存屏幕每個像素.而z-buffer『深度緩存』則儲存像素『深度值』.『深度值』為3D空間中對應點與相機『近裁剪面』距離.

OpenGL ES將z-buffer『深度緩存』為每個像素寫入深度值.OpenGL ES會初此『深度緩存』每個深度值為無窮大(大數).

gl.glEnable(GL10.GL_DEPTH_TEST);

每當渲染像素時將像素深度值和『深度緩存』深度值進行比較.如果深度值更小則表示它接近於『近裁剪面』則更新『幀緩存』像素與『深度緩存』深度值.這一過程稱為『深度測試』.如果未能通過『深度測試』則像素與深度值均不寫入『幀緩存』與『深度測試』

每幀渲染時『幀緩存』與『深度緩存』均需清零.否則上一幀數據會被保留下來

gl.glClear(GL10.GL_COLOR_BUFFER_BIT | GL10.GL_DEPTH_BUFFER_BIT);

在渲染所有3D場景後需關閉『深度測試』.因為渲染2D圖形UI元素無Z軸座標.更無需深度測試.渲染順序由代碼繪製順序決定.

gl.glDisable(GL10.GL_DEPTH_TEST);

2D遊戲使用『正交投影』這意味著模型與視點距離無論多遠,其屏幕尺寸大小總為一至.而3D遊戲則使用『透視投影』模型離視點越近其屏幕尺寸越大.而模型離視點越遠其屏幕尺寸越細.

在『正交投影』就像置身於『矩形盒』.而『透視投影』就像切掉『金字塔』頂部,頂部為『近裁剪面』底部為『遠裁剪面』.而另外四面則分別為『左裁剪面』『右裁剪面』『頂裁剪面』『底裁剪面』

透視錐體由四個參數組成

1.『近裁剪面』與相機矩離

2.『遠裁剪面』與相機矩離

3.視口縱橫比,即視口『近裁剪面』寬高比

4.『視場』指定視錐體寬,也就是它所容納場景

桌面OpenGL帶有GLU輔助函式庫.而Android系統也含有GLU庫.設置投影矩陣

GLU.gluPerspective(GL10 gl,float fieldOfView,float aspectRatio,float near,flat far);

該函式將『透視投影矩陣』與當前矩陣相乘.

gl:為GL10實例

fieldOfView:視場角度,人眼視場角大約67度.加減此值可調整橫向視察範圍

aspectRatio:視口縱橫比,此值為一浮點數

near:遠裁剪面與相機距離

far:近裁剪面與相機距離

『透視投影』代碼

GL10 gl = GRAPHICS.GetGL();

清屏

gl.glClear(GL10.GL_COLOR_BUFFER_BIT | GL10.GL_DEPTH_BUFFER_BIT);

設定視口

gl.glViewport(0,0, GRAPHICS.GetWidth(),GRAPHICS.GetHeight());

設定當前矩陣為投影矩陣

gl.glMatrixMode(GL10.GL_PROJECTION);

載入單位矩陣

gl.glLoadIdentity();

設置投視投影

GLU.gluPerspective(gl, fieldOfView, aspectRatio, near, far);

設定當前矩陣為模型視圖矩陣

gl.glMatrixMode(GL10.GL_MODELVIEW);

載入單位矩陣

gl.glLoadIdentity();

2D遊戲紋理渲染必須將『背景色』去除.JPEG格式不支持存儲像素點alpha值.將透明色alpha值設為零.需使用PNG格式.若紋理圖像沒有alpha通道時OpenGL ES自動將alpha設為1.但混合開銷很大而目前手機上GPU都不能對大量像素禁行混合.所以在需要時才啟用Blend『混合』.在OpenGL ES中啟動半透明混合處理
gl.glEnable(GL10.GL_BLEND);
設定『來源色』和『目標色』組合方程.
gl.glBlendFunc(GL10.GL_SRC_ALPHA, GL10.GL_ONE_MINUS_SRC_ALPHA);
啟用2D紋理渲染
gl.glEnable(GL10.GL_TEXTURE_2D);
渲染三角形
…
禁用2D紋理渲染
gl.glDisable(GL10.GL_TEXTURE_2D);
結束渲染後禁用混合
gl.glDisable(GL10. GL_BLEND);

遊戲設計中通常『更新』『渲染』放在同一線程中.在Windows可以在主線程將『消息驅動』改為『實時驅動』.把『更新』『渲染』放在主線程中.而Android卻無法做到這點.但提供GLSurfaceView可建立獨立線程在背後實現『更新』『渲染』.你需要實現監聽接口GLSurfaceView.Renderer.並註冊到GLSurfaceView中.監聽接口需要分別重寫『創建』『調整大細』『渲染』.GLSurfaceView.Renderer可獲得GL10.通過它方可訪問OpenGL ES API.而GL10中10代表OpenGL ES 1.0標準.可以將GLSurfaceView封裝成獨立控件.從而在layout『佈局』中嵌入.

public class RenderView extends GLSurfaceView implements GLSurfaceView.Renderer {

每當Activity恢復或啟動創建. EGLConfig設置Surface顏色與深度

public void onSurfaceCreated(GL10 gl10, EGLConfig eglConfig);

當view尺寸發生改變時調用,傳入寬與高

public void onSurfaceChanged(GL10 gl10, int width, int height);

調用『渲染』『更新』完成幀繪製.但每秒不超過60幀.

public void onDrawFrame(GL10 gl10);

令外還需重寫『恢復』『暫停』

『恢復』重啟渲染線程,在Activity恢復顯示時在Activity.onResume()中調用

public void onResume();

『暫停』退出渲染線程,當Activity進入後臺時在Activity.onPause()中調用

public void onPause();

}

編輯layout『佈局』文檔main.xml添加

<net.bookcard.aa.RenderView

android:id=”@+id/render_view”

android:layout_width=”fill_parent”

android:layout_height=”fill_parent” />

定義view狀態

public static final int       STATE_INIT       = 0;// 初此

public static final int  STATE_RUN       = 1;// 運行

public static final int  STATE_PAUSED    = 2;// 暫停

public static final int  STATE_FINISHED  = 3;// 結束

public static final int  STATE_IDLE       = 4;// 閒置

int view_width,view_height;// 寬與高

int state = STATE_INIT;// 初此狀態

long    startTime ;// 啟動時間

創建Surface獲取屏幕

public void onSurfaceCreated(GL10 gl, EGLConfig eglConfig){

SCREEN  screen = GAME.getCurrentScreen();// 當前屏幕

if(state == STATE_INIT) {// 初此

Init(gl, this);

screen = GAME.getMainScreen();

GAME.setCurrentScreen(screen);

}

else {//  重新載入資源

ASSETS.reload();

}

screen = GAME.getCurrentScreen();

state = STATE_RUN;// 運行

startTime = System.nanoTime();// 獲取啟動時間

}

大小發生改變

public void onSurfaceChanged(GL10 gl, int width, int height){

this.view_width = width;// 寬

this.view_height = height;// 高

}

更新並渲染.System.nanoTime()返回納秒, 1000000000納秒=1秒.通過兩次時間測量計算間隔時間

public void onDrawFrame(GL10 gl){

SCREEN screen = GAME.getCurrentScreen();

if(state == STATE_RUN){// 運行

float deltaTime = (System.nanoTime()-startTime) / 1000000000.0f;

startTime = System.nanoTime();// 獲取當前時間

screen.update(deltaTime);// 更新

screen.present(deltaTime);// 渲染

}

else

if(state == STATE_PAUSED) {// 暫停

screen.pause();

}

else

if(state == STATE_FINISHED) {// 結束

screen.pause();

screen.dispose();

}

}

恢復渲染在Activity.onResume()中調用

public void onResume(){

super.onResume();

MUSIC.Resume();

}

暫停渲染在Activity.onPause()中調用

public void onPause(){

state = STATE_PAUSED;// 暫停

super.onPause();

MUSIC.Pause();

}

初此遊戲系統個部件

void Init(GL10 gl, GLSurfaceView view){

GRAPHICS.Init(gl,view);

SYSTEM.Init(context);// 系統

FileIO.Init(context);// 文件讀寫

BITMAP.Init(context);// 位圖

SOUND.Init(context,100);// 聲音

MUSIC.Init(context,100);// 音樂

TOUCH.Init(this);// 觸摸模塊

GAME.Init();//  屏幕切換系統

BATCHER.Init(1500);// 精靈批處理

ASSETS.load();// 資源

}

OpenGL ES盡可能每次渲染多個精靈.以提高渲染性能.為此需要知道精靈『位置』『尺寸』『紋理區域』.『批處理』將多個渲染合拼在一起.這對GPU有利.批處理設立浮點數『緩存』保存頂點.該緩存區初此時需清空.定義『批處理』結構BATCHER.

public class BATCHER {

成員Buffer為浮點型數組用於存儲頂點.

private static float[] buffer;

成員indices為短整形索引.以三角形排列用於儲存頂點.

public static short[] indices ;

頂點列表用於批處理渲染

private static VERTICES vertices;

緩存寫入索引初此為零

private static int index = 0;

精零數量初此為零

public static int num = 0;

初次批處理.max精靈為最大量.

public static void Init(int max){

分配2D精靈頂點緩存,每個精靈有4頂點,每頂點要4個浮點數(空間坐標x,y兩個,紋理坐標u,v兩個)

buffer = new float[max44];

分配頂點緩存.『頂點』『紋理座標』『索引』

vertices = new VERTICES(max * 4, max*6, false,true);

分配索引每個精靈6個索引

indices = new short[max*6];

int len = indices.length;// 索引數組長度

index = 0;// 緩存寫入索引

num = 0;//  精零數量

生成頂點索引

for (int i=0,j=0; i < len; i += 6, j += 4) {

indices[i + 0] = (short)(j + 0);

indices[i + 1] = (short)(j + 1);

indices[i + 2] = (short)(j + 2);

indices[i + 3] = (short)(j + 2);

indices[i + 4] = (short)(j + 3);

indices[i + 5] = (short)(j + 0);

}

設置頂點索引

vertices.SetIndices(indices, 0, indices.length);

}

準備進行批處理渲染.首先綁定紋理.並將『精零數量』『緩存索引』置零

public static void Begin(TEXTURE texture){

texture.Bind();// 綁定紋理

num = 0;//  精零數量

index = 0;// 緩存寫入索引

}

結束批處理渲染.將頂點提交給OpenGL數組並觸發.綁定頂點數據後進形三角形渲染.然後取消數據綁定.每次調用繪畫時.向緩存區中添加4個頂點參數為『位置』『顏色』『索引』『紋理區域』

public void boolean End(){

vertices.SetVertices(buffer,0,index);

vertices.Bind();

vertices.Draw(GL10.GL_TRIANGLES, 0, num * 6);

vertices.Unbind();

}

批處理繪畫計算精靈中心『位置』及『寬和高』.和『紋理區域』.生成精靈『左下角』與『右上角』『空間座標』與『紋理座標』

public static void Draw(float x,float y,float width,float height,REGION region){

float halfWidth = width/2.0f;// 寬度一半

float halfHeight = height/2.0f;//高度一半

float x1 = x – halfWidth;

float y1 = y – halfHeight;

float x2 = x + halfWidth;

float y2 = y + halfHeight;

buffer[index++] = x1;

buffer[index++] = y1;

buffer[index++] = region.u1;

buffer[index++] = region.v2;

buffer[index++] = x2;

buffer[index++] = y1;

buffer[index++] = region.u2;

buffer[index++] = region.v2;

buffer[index++] = x2;

buffer[index++] = y2;

buffer[index++] = region.u2;

buffer[index++] = region.v1;

buffer[index++] = x1;

buffer[index++] = y2;

buffer[index++] = region.u1;

buffer[index++] = region.v1;

++num;

}

}

在調用時首先清理緩存並存入紋理.但只能對使用同一紋理精靈進行批處理.最後結束渲染.如下:

BATCHER.Begin(Texture);

BATCHER.Draw(X,Y,WIDTH,HEIGHT,Region);

BATCHER.End();

定義2D相機即設定『投影矩陣』與『視口』

『視口』用於控制輸出圖像尺寸與渲染幀緩存位置.OpenGL ES使用『視口』將投影到『近裁剪面』點座標變換為『幀緩存』像素座標

GL10.glViewport(int x,int y,int width,int height);

x和y座標為幀緩存區視口左上角.width和height為視口大小.單位為像素.幀緩存座標原點為屏幕左下角.通常將x和y設為0.width和height設為屏幕分辨率.即設為全屏.

gl.glViewport(0, 0, view.getWidth(), view.getHeight());

『投影矩陣』在2D相機中只使用『平行投影』.首先將當前矩陣設為『投影矩陣』

gl.glMatrixMode(GL10.GL_PROJECTION);

載入單位矩陣

gl.glLoadIdentity();

設置正交投影矩陣

GL10. glOrthof(int left,int right,int bottom,int top,int near,int far);

OpenGL ES座標系統正X軸指向右,正Y軸指向上.正Z軸指向我.left與right為X軸左右兩條邊.bottom與 top為Y軸上下兩條邊.near為近端裁剪面.far為遠端裁剪面.若設2D橫向相機左下角(0,0)右上角(480,320)視錐深度為2

gl.glOrthof(0,480,0,320,1, -1);

重設為模型視圖矩陣

gl.glMatrixMode(GL10.GL_MODELVIEW);

gl.glLoadIdentity();

2D相機將『觸屏』坐標轉『世界』坐標.首先設定視錐體寬為15高為10.

float frustum_width = 15;

float frustum_height = 10;

設縮放係數為1.用於放大屏幕大於1,縮小屏幕小於1

float zoom = 1;

首先將『觸屏』位置歸範圍(0~1).然後乘以視錐體寬和高

touch.x = (touch.x / view.getWidth()) * frustum_width * zoom;

因為觸屏座標原點位於屏幕左上角.需倒轉Y軸

touch.y = (1-touch.y /view.getHeight()) * frustum_height * zoom;

與相機位置相機

touch.add(position);

最後減於視錐體中心位置.得到遊戲『世界』坐標

touch.x = touch.x – frustum_width*zoom/2f;

touch.y = touch.y – frustum_height*zoom/2f;

OpenGL ES專為移動與嵌入設備設計之圖形編程接口. 它並非由ARB委員會定義.而是由Khronos組織定義.該組織包括ATI、NVIDIA、Intel等組成.雖然『OpenGL』與『OpenGL ES』來自兩個不同組織. 『OpenGL ES』係『OpenGL』刪減板.但你依然可寫出在兩種標準下都可運行之程式.這對於移植遊戲很重要.OpenGL ES同樣以C文檔發佈API.而代碼實現由硬件廠商完成.

如果AndroidManifest.xml中無配置glEsVersion,則表示支持OpenGL ES 1.0但所有Android系統都支持.若支持OpenGL ES 2.0需在AndroidManifest.xml中添加:

<uses-feature  android:required=”false”  android:glEsVersion=”0x00020000″ />

OpenGL ES版本號為32位整數.高16位表示OpenGL ES大版本,低16位表示OpenGL ES小版本.

將『Bitmap』加載給OpenGL ES然後加載到圖形卡記憶體重,並最終交給GPU渲染.因為OpenGL最終以三角形為單位進行渲染.而將『Bitmap』映射到三角形上.需要為三角形每個頂點設定紋理座標(texture coordinates).3D座標(x,y,z)和2D座標(x,y)對應紋理座標(u,v)位圖頂點.而(u,v)座標相當於(橫,縱)座標.紋理寬與高必需是2倍數.

生成紋理隊列,用於保存紋理ID

int[] ids = new int[1];

生成紋理並獲取id.紋理依然為空

gl.glGenTextures(1, ids,0);

紋理id

int id = ids[0];

讀取位圖

Bitmap bitmap = BITMAP.Read(file_name);

獲取位圖寬度

int   width = bitmap.getWidth();

獲取位圖高度

int   height = bitmap.getHeight();

綁定2D紋理

gl.glBindTexture(GL10.GL_TEXTURE_2D, id);

上傳2D紋理

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

設置紋理屬性指定縮小倍數過濾器

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

取消綁定紋理ID

gl.glBindTexture(GL10.GL_TEXTURE_2D, 0);

回收位圖.以免浪費記憶體

bitmap.recycle();

每當Activity被暫停(APP切換)GLSurfaceView都會被銷毀.每當Activity恢復時調用GLSurfaceView. onResume()讓GLSurfaceView重構渲染界面.但OpenGL ES中上傳紋理都會丟失.你需要在onSurfaceCreated()中需重新載入並上傳紋理.

重新載入代碼見上文

Texture.load(filen_ame);

重新綁定紋理後設置紋理屬性

gl.glBindTexture(GL10.GL_TEXTURE_2D, id);

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

取消綁定紋理

gl.glBindTexture(GL10.GL_TEXTURE_2D, 0);

當遊戲退出.便要刪除紋理釋放記憶體.首先取消紋理邦定

gl.glBindTexture(GL10.GL_TEXTURE_2D, id);

刪除紋理

int[] ids = { id };

gl.glDeleteTextures(1,ids,0);

渲染三角形時要告知OpenGL要啟用紋理渲染

gl.glEnable(GL10.GL_TEXTURE_2D);

完成渲染後禁用紋理渲染

gl.glDisable(GL10.GL_TEXTURE_2D);

2D遊戲通常只佔用圖像一小片區域.需要將像素座標(x,y)轉換為紋理座標(u,v)

計算紋理座標左上角

u1 = x/texture.width;

v1 = y/texture.height;

計算紋理座標右下角

u2 = u1 + width/texture.width;

v2 = v1 + height/texture.height;

遊戲由『背景』與『角色』『植物』『房舍』等圖檔組成.在C時代要逐個寫圖檔分析器.而在java可以通過BitmapFactory讀取Bitmap『位圖』.幾乎支持所有常見圖檔『jpg』『png』『bmp』『png』.把所有『位圖』保存到『ASSETS』目錄下

資源管理器用於訪問『ASSETS』目錄

AssetManager asset_manager = context.getAssets();

指定『位圖名』並返回輸入流

InputStream input_stream = asset_manager.open(file_name);

讀取Bitmap默認轉換為RGB_565色

Bitmap bitamp = BitmapFactory.decodeStream(input_stream);

關閉輸入流

Input_Stream.close();

獲取位圖寬度

int width = bitmap.getWidth();

讀取位圖寬度

int height = bitmap.getHeight();

獲取位圖顏色格式.

Bitmap.Config config = bitamp.getConfig();

以特定顏色格式進行讀取.但渲染時最終要與OpenGL ES顏色格式一致

設定顏色格式為ARGB_8888

BitmapFactory.Options options = new BitmapFactory.Options();

options.inPreferredConfig = Bitmap.Config.ARGB_8888;

指定『位圖名』並返回輸入流

InputStream Input_Stream = asset_manager.open(file_name);

讀取Bitmap並轉換為ARGB_8888色

Bitmap bitamp = BitmapFactory.decodeStream(Input_Stream, null, options);

關閉輸入流

Input_Stream.close();