Android遊戲之點光

Android遊戲之點光

點光(燈光)特點是有固定3D位置.首先你需要啟用0號燈光

gl.glEnable(GL10.GL_LIGHT0);

設定燈光顏色,燈光索引為0,最後一個參數是顏色數組偏移量.

float[] ambient = {1.0f, 1.0f, 1.0f, 1.0f};// 點光-環境色

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

float[] specular = {0.0f, 0.0f, 0.0f, 1.0f};// 點光-高亮顏色

gl.glLightfv(GL10.GL_LIGHT0,GL10.GL_AMBIENT, ambient, 0);

gl.glLightfv(GL10.GL_LIGHT0,GL10.GL_DIFFUSE, diffuse, 0);

gl.glLightfv(GL10.GL_LIGHT0,GL10.GL_SPECULAR, specular, 0);

設定燈光位置,設定3D空間xyz座標,第四個元素必須設置為1,即光源有位置.

float[] position = {0, 0, 0, 1};// 點光-位置

gl.glLightfv(GL10.GL_LIGHT0,GL10.GL_POSITION, position, 0);

完成渲染後關閉燈光

gl.glDisable(GL10.GL_LIGHT0);

燈光類代碼

public class LightPoint {

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, 0, 0, 1};// 燈光位置

int id = 0;//  燈光ID

構造點光(燈泡) 燈光ID輸入:GL10.GL_LIGHT0至GL10.GL_LIGHT7

public LightPoint(int ID ){

this.id = ID;//  燈光ID

}

設定點光(燈泡)位置

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

}

屏蔽點光(燈泡)

public void disable(){

GL10 gl = GRAPHICS.gl;

gl.glDisable(id);

}

}

Android遊戲之環境光

Android遊戲之環境光

環境光是一種特殊光.它沒有位置和方向.它只會均勻照射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);

}

}

Android遊戲之光照

Android遊戲之光照

光照系統它可以令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);

光源實現代碼
環境光
定向光
燈光
射燈
材質

 

 

Android遊戲之矩陣和變換

Android遊戲之矩陣和變換

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

Android遊戲之透明混合

Android遊戲之透明混合

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.       渲染排好序透明對象(由遠及近)

混合係數

簡介

GL_ZERO

將顏色設為{0,0,0,0}

GL_ONE

不改變當前顏色(r,g,b,a)*(1,1,1,1)

GL_SRC_COLOR

目標與來源相乘dest (r,g,b,a)* sour (r,g,b,a)

GL_DST_COLOR

來源與目標相乘sour (r,g,b,a)* dest (r,g,b,a)

GL_ONE_MINUS_SRC_COLOR

(r,g,b,a)*((1,1,1,1)- sour(r,g,b,a))

GL_ONE_MINUS_DST_COLOR

(r,g,b,a)*((1,1,1,1)- dest(r,g,b,a))

GL_SRC_ALPHA

(r,g,b,a) * sour(alpha)

GL_DST_ALPHA

(r,g,b,a) * dest(alpha)

GL_ONE_MINUS_SRC_ALPHA

(r,g,b,a) * (1- sour(alpha))

GL_ONE_MINUS_DST_ALPHA

(r,g,b,a) * (1- dest(alpha))

GL_SRC_ALPHA_SATURATE

(r,g,b,a) *MIN (sour(alpha),1-dest(alpha))

 

Android遊戲之z-buffer

Android遊戲之z-buffer

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

Android遊戲之透視投影

Android遊戲之透視投影

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

 

 

 

 

Android遊戲之3D頂點索引

Android遊戲之3D頂點索引

在進入豐富多彩3D世界中需要定以『視錐體』和『精靈頂點』.3D空間中頂點需有xyz座標.並且使用『透視投影』.距離相機越遠,物體越小.離相機較近對象覆蓋較進隊象.3D頂點包含『位置(xyz)』『顏色(rgba)』『法線(x,y,z)』並且完成3D頂點『模型』渲染

public class VERTICES3D {

擁有頂點顏色

boolean hasColor = false;

擁有紋理坐標

boolean hasTexCoord =false;

擁有法線

boolean hasNormal = false;

每個頂點所占空間

int vertex_size = 0;

最大頂點量

int vertex_max = 0;

最大索引量

int index_max = 0;

頂點數組

IntBuffer vertex_array = null;

索引數組

ShortBuffer index_array = null;

頂點緩存

int[] vertex_Buffer;

構造函式分配頂點記憶體,vertex_max為最大頂點量,index_max為最大索引量

VERTICES3D(int vertex_max,int index_max,boolean hasColor,boolean hasTexCoord,boolean hasNormal){

ByteBuffer buffer = null;

this.vertex_max    = vertex_max;

this.index_max     = index_max;

this.hasColor  = hasColor;//  是否擁有頂點顏色

this.hasTexCoord = hasTexCoord;// 是否擁有紋理坐標

this.hasNormal = hasNormal;// 是否擁有法線

計算每頂點所占大小.顏色(rgbs)占4單元.紋理座標(uv)占2單元.3D座標(xyz)占3單元.每個整數占4字節

this.vertex_size = (3 + (hasColor ? 4 : 0) + (hasTexCoord ? 2 : 0) + (hasNormal ? 3: 0)) * 4;

vertex_Buffer = new int[vertex_max * vertex_size / 4];

因為OpenGL ES是以C API結口提供.無法直接使用JAVA數組.因此你需要C數組系統堆棧記憶體.而非JAVA虛擬機記憶體.需要 FloatBuffer分配頂點記憶體.vertex_max為最大頂點量.

buffer = ByteBuffer.allocateDirect(vertex_size * vertex_max);

將『網絡字節』改為『主機字節』或稱為『CPU字節』

buffer.order(ByteOrder.nativeOrder());

獲取頂點整數數組

vertex_array = buffer.asIntBuffer();

每索引占兩BYTE.即OpenGL ES每次最多渲染65536個頂點.

if(index_max > 0){

每個短整形占兩個字節.index_max為最大索引量

buffer = ByteBuffer.allocateDirect(index_max * Short.SIZE/8);

將『網絡字節』改為『主機字節』

buffer.order(ByteOrder.nativeOrder());

獲取頂點短整數數組

index_array = buffer.asShortBuffer();

}

}

將頂點提交給OpenGL數組並觸發

public void setVertices(float[] vertices,int offset,int count){

清空緩存.設定當前位置

vertex_array.clear();

int len = offset + count;

for(int i=offset, j=0; i < len; i++, j++)

vertex_Buffer[j] = Float.floatToRawIntBits(vertices[i]);

寫入數據.移動當前位置

vertex_array.put(vertex_Buffer, 0, count);

觸發

vertex_array.flip();

}

將頂點索引提交給OpenGL數組

public void setIndices(short[] indices,int offset,int count) {

清空緩存.設定當前位置

index_array.clear();

寫入數據.移動當前位置

index_array.put(indices, offset, count);

觸發

index_array.flip();

}

 

獲取索引量

public int getNumIndices(){

return index_array.limit();

}

獲取頂點量

public int getNumVertices(){

return    vertex_array.limit() / (vertex_size/4);

}

綁定頂點數據

public void Bind(){

GL10 gl = GRAPHICS.gl;

啟用頂點數組

gl.glEnableClientState(GL10.GL_VERTEX_ARRAY);

設置當前寫入位置0

vertex_array.position(0);

設置頂點指針,每個頂點包含xyz分量

gl.glVertexPointer(3, GL10.GL_FLOAT, vertex_size, vertex_array);

擁有頂點顏色

if(hasColor == true) {

啟用頂點顏色數組

gl.glEnableClientState(GL10.GL_COLOR_ARRAY);

設置當前寫入位置3

vertex_array.position(3);

設置顏色指針,RGBA四分量

gl.glColorPointer(4, GL10.GL_FLOAT, vertex_size, vertex_array);

}

擁有紋理坐標

if(hasTexCoord == true){

啟用紋理坐標

gl.glEnableClientState(GL10.GL_TEXTURE_COORD_ARRAY);

設置當前寫入位置

vertex_array.position(hasColor?7:3);

設置紋理坐標指針UV分量

gl.glTexCoordPointer(2, GL10.GL_FLOAT, vertex_size, vertex_array);

}

擁有法線

if (hasNormal = true) {

啟用法線

gl.glEnableClientState(GL10.GL_NORMAL_ARRAY);

int offset = 3;

if (hasColor)

offset += 4;

if (hasTexCoord)

offset += 2;

設置當前寫入位置

vertex_array.position(offset);

設置法線指針,xyz分量

gl.glNormalPointer(GL10.GL_FLOAT, vertex_size, vertex_array);

}

}

取消綁定數據

public void Unbind(){

GL10 gl = GRAPHICS.gl;

關閉頂點紋理數組

if(hasColor)

gl.glDisableClientState(GL10.GL_COLOR_ARRAY );

關閉頂點顏色數組

if(hasTexCoord)

gl.glDisableClientState(GL10.GL_TEXTURE_COORD_ARRAY);

關閉法線數組

if (hasNormal)

gl.glDisableClientState(GL10.GL_NORMAL_ARRAY);

}

繪畫3D模型.需要先綁3D頂點

public void Draw(int mode,int offset,int count){

GL10 gl = GRAPHICS.gl;

繪畫頂點

if(index_array != null) {// 繪畫

index_array.position(offset);

gl.glDrawElements(mode, count, GL10.GL_UNSIGNED_SHORT, index_array);

}

else {

gl.glDrawArrays(mode, offset, count);

}

}

}

Android遊戲之3D矢量

Android遊戲之3D矢量

與『2D矢量』相比『3D矢量』僅是在x,y軸座標加上z軸座標.還有『點積』和『叉積』運算.與繞軸旋轉算法. 無左計算向量角度函式.

public class VECTOR3D {

3D浮點數座標

public float x,y,z;

角度轉弧度

public static float DEGREES_TO_RADIANS = ((1.0f/180.0f)* (float)Math.PI);

弧度轉角度

public static float RADIANS_TO_DEGREES = ((1.0f/(float)Math.PI)*180.0f);

用於繞軸旋轉

private static final float[] matrix = new float[16];

private static final float[] inVec = new float[16];

private static final float[] outVec = new float[16];

購造函式並設定x,y,z

public VECTOR3D(float x, float y,float z){

this.x = x;

this.y = y;

this.z = z;

}

拷貝3D矢量

public VECTOR3D Copy(){

VECTOR3D v;

v=new VECTOR3D(x,y,z);

return v;

}

重設3D矢量數值

public VECTOR3D set(VECTOR3D v){

this.x = v.x;

this.y = v.y;

this.z = v.z;

return this;

}

3D矢量加法運算

public VECTOR3D add(VECTOR3D v){

this.x = this.x + v.x;

this.y = this.y + v.y;

this.z = this.z + v.z;

return this;

}

3D矢量減法運算

public VECTOR3D sub(VECTOR3D v){

this.x = this.x – v.x;

this.y = this.y – v.y;

this.z = this.z – v.z;

return this;

}

3D矢量乘法(即縮放)

public VECTOR3D mul(float scalar){

this.x = this.x * scalar;

this.y = this.y * scalar;

this.z = this.z * scalar;

return this;

}

計算3D矢量長度

public float Len(){

float len;

len = (float) Math.sqrt(x*x+y*y+z*z);

return len;

}

3D矢量單位化,長度為1

public VECTOR3D normer(){

float len;

len = Len();

if(len != 0){

x = x / len;

y = y / len;

z = z / len;

}

return this;

}

繞某軸旋轉,先定義3D矢量,然後設置矩陣為零,然後用rotateM()旋轉,在乘以3D向量

public VECTOR3D rotate(float angle,float axisX,float axisY,float axisZ){

inVec[0] = x;

inVec[1] = y;

inVec[2] = z;

inVec[4] = 1;

Matrix.setIdentityM(matrix, 0);

Matrix.rotateM(outVec,0, angle, axisX, axisY, axisZ);// 選轉

Matrix.multiplyMV(outVec, 0, matrix, 0, inVec, 0);

x = outVec[0];

y = outVec[1];

z = outVec[2];

return this;

}

計算兩3D矢量之間距離

public float Dist(VECTOR3D v){

float distX = this.x – v.x;

float distY = this.y – v.y;

float distZ = this.z – v.z;

float dist = (float)Math.sqrt(distX*distX + distY*distY + distZ*distZ);

return dist;

}

計算兩個3D矢量之間距離平方

public float DistSquared(VECTOR3D v){

float distX = this.x – v.x;

float distY = this.y – v.y;

float distZ = this.z – v.z;

float dist = distX*distX + distY*distY + distZ*distZ;

return dist;

}

計算兩個3D向量叉積,叉積是一個向量,它與va和vb垂直.

void cross(VECTOR3D va, VECTOR3D vb){

x =  ( (va.y * vb.z) – (va.z * vb.y) );

y = -( (va.x * vb.z) – (va.z * vb.x) );

z =  ( (va.x * vb.y) – (va.y * vb.x) );

}

計算3D向量點積.返回值為浮點數

float dot(VECTOR3D v){

return( (x * v.x) + (y * v.y) + (z * v.z) );

}

3D向量取反數

VECTOR3D inverse(){

this.x = -this.x ;

this.y = -this.y ;

this.z = -this.z ;

return this;

}

}

 

Photoshop之刪除背景色

Photoshop之刪除背景色

照片素材大都有純色背景.可以通過Photoshop魔法捧選擇背景範圍並刪除.但對於大量細小單獨背景魔法捧則略有不足.Photoshop有另一高效工具『顏色範圍』幫你完成所有工作.

  1. Photoshop打開圖片素材
  2. 選取->顏色範圍
  3. 勾選『選取範圍』
  4. 勾選『負片效果』
  5. 縮略圖中白色區域即你想要區域.按確定選定範圍.
  6. 複製選定範圍並新建圖層.按『Ctrl+C』複製、『Ctrl+V』貼上