Android OpenGL And Gyroscope

אחרי שהכרנו כיצד לבנות ולצבוע אובייקטים השלב הבא הוא תנועה במרחב של המנוע אבל לפני שניכנס לכפתורים ולממשק המשתמש נתחיל דווקא עם החיישנים שנמצאים בכל מכשיר מתקדם, אבל חשוב לזכור שהם משתנים ממכשיר למכשיר ולא זמינים בכולם.

שימו לב! - המאמר מתבסס על Samsung Galaxy S3 שבו יש Gyroscope מובנה.

Gyroscope

http://en.wikipedia.org/wiki/Gyroscope

מכשיר מדידה שמאפשר לחשב את זווית הסטייה כאשר הגוף לא במצב אופקי, כלומר כל הטיה של המכשיר תשנה את המיקום על 3 הצירים התלת מימדיים (X,Y,Z),  על מנת להפעיל אותו ב Android עלינו להשתמש במספר מחלקות שיעשנו לנו את העבודה עבור כל החיישנים שנראה במאמרים הבאים:

private SensorManager mSensorManager;
private Sensor mSensor;

אובייקטים שמייצגים את החיישנים.

mSensorManager = (SensorManager)con.getSystemService(Context.SENSOR_SERVICE);

mSensor = mSensorManager.getDefaultSensor(Sensor.TYPE_GYROSCOPE);

מבקשים  את השירות של החיישנים במערכת, מתחברים לחיישן ספציפי שבמקרה שלנו הוא ה Gyroscope אבל ניתן לקבל חיישנים נוספים כמו: Accelerometer, Ambient Temperature,Gravity ועוד (לרשימה המלאה).

לאחר מכן מתחברים ל Event של החיישן בעזרת SensorEventListener ודוגמים אותו, השתמשתי בהגדרה קיימת במערכת שמתאימה למשחקים ודוגמת את החיישן כל 20 ms.

mSensorManager.registerListener(new SensorEventListener() {

@Override

public void onSensorChanged(SensorEvent event) {

// TODO Auto-generated method stub

}

@Override

public void onAccuracyChanged(Sensor sensor, int accuracy) {

// TODO Auto-generated method stub

}

}, mSensor, SensorManager.SENSOR_DELAY_GAME);

OpenGL

אחד השינויים הוא בפונקציה Draw של האובייקט שמוכרת מהמאמרים האחרונים בנושא, נוספו 3 פרמטרים עבור X,Y,Z שאותם נשלח ל OpenGL בעזרת הפונקציה glTranslatef.

public void draw(float x,float y,float z)

{

//set gl focus to cube

gl.glLoadIdentity();

gl.glTranslatef(x, y, z);

   //...

}

קוד

דגימת החיישן מתבצעת ה GLSurfaceView.Renderer בעזרת EventListener שממתין לאירוע מהחיישן ומעדכן פרמטרים גלובלים במחלקה שנשלחים אח"כ לפונקציה Draw של האובייקט.

package com.example.openglgyroscope;

import java.text.DecimalFormat;

import javax.microedition.khronos.egl.EGLConfig;

import javax.microedition.khronos.opengles.GL10;

import android.content.Context;

import android.hardware.Sensor;

import android.hardware.SensorEvent;

import android.hardware.SensorEventListener;

import android.hardware.SensorManager;

import android.opengl.GLSurfaceView;

import android.opengl.GLU;

public class OpenGLSensorRender implements GLSurfaceView.Renderer  {

private CubeNaked mCube;

//remember the last values of the Axis

private float mLastX = 0, mLastY = 0, mLastZ = 0;

Context con;

private SensorManager mSensorManager;

private Sensor mSensor;

public OpenGLSensorRender(Context _con)

{

con = _con;

mSensorManager = (SensorManager)con.getSystemService(Context.SENSOR_SERVICE);

mSensor = mSensorManager.getDefaultSensor(Sensor.TYPE_GYROSCOPE);

mSensorManager.registerListener(new SensorEventListener() {

@Override

public void onSensorChanged(SensorEvent event) {

//taking sample from the sensor

DecimalFormat _fp = new DecimalFormat("#.#");

float x = Float.valueOf( _fp.format(event.values[0]));

float y = Float.valueOf( _fp.format(event.values[1]));

float z = Float.valueOf( _fp.format(event.values[2]));

mLastX = mLastX + x;

mLastY = mLastY+ y;

   //not in use for now

//mLastZ = z;

}

@Override

public void onAccuracyChanged(Sensor sensor, int accuracy) {}

}, mSensor, SensorManager.SENSOR_DELAY_GAME);

}

@Override

public void onDrawFrame(GL10 gl) {

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

//draw the cube ,sending the new axis

mCube.draw(mLastX,mLastY,mLastZ);

}

@Override

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

// TODO Auto-generated method stub

//enter to Perspective Projection Mode Settings

gl.glViewport(0, 0, width, height);

gl.glMatrixMode(GL10.GL_PROJECTION);

gl.glLoadIdentity();

GLU.gluPerspective(gl, 45.0f, (float) width / (float) height, 0.1f,

100.0f);

gl.glViewport(0, 0, width, height);

//enter to ModelView Projection Mode Settings

gl.glMatrixMode(GL10.GL_MODELVIEW);

gl.glLoadIdentity();

}

@Override

public void onSurfaceCreated(GL10 gl, EGLConfig arg1) {

// TODO Auto-generated method stub

//clear the suraface color to black

gl.glClearColor(0.0f, 0.0f, 0.0f, 0.5f);

gl.glClearDepthf(1.0f);

gl.glEnable(GL10.GL_DEPTH_TEST);

gl.glDepthFunc(GL10.GL_LEQUAL);

gl.glHint(GL10.GL_PERSPECTIVE_CORRECTION_HINT, GL10.GL_NICEST);

mCube = new CubeNaked(gl);

}

}

סרט הדגמה

קבצי מקור

https://sourceforge.net/projects/openglcomplexobject/files/openGLgyroscope.rar/download

סיכום:

עבודה עם חיישנים נפוצה מאוד במיוחד במשחקים, הם מאפשרים לנו לשלוט על האובייקטים במשחק מבלי שנצטרך לגעת במסך שגם ככה יחסית קטן וחוסכים לנו ממשק משתמש שמתלבש על המסך שעלול להסתיר חלקים מהמשחק, אבל צריך להתרגל לצורת המשחק החדשה ולא תמיד זה נוח למי שרגיל לכפתורים הסטנדרטים.

שחק איתו!

Android OpenGL UV Mapping

ראינו שלא פשוט לבנות קובייה ועוד יותר מסובך לצבוע אותה, אבל שוב חוזרים לאותה שאלה מה קורה כאשר האובייקט מורכב מיותר מ 6 משטחים? גם הפעם עולם התלת מימד נותן לנו כלים להתמודד עם אובייקטים מורכבים בעזרת שיטת ה UV Map שמאפשרת לצבוע אותם בצורה יעילה וחסכונית.

UV Map

שיטה לפריסת אובייקט תלת מימדי לדו מימד, עד עכשיו חיברנו משטח בודד לטקסטורה בודדת שזה לא הפתרון המושלם והוא בזבזני ולא ידידותי, בעזרת UV Coordinates ניתן לחבר מספר משטחים לנקודות ספציפיות בטקסטורה עצמה כך שכל משולש \ מרובע יצייר רק את התחום שלו, עוד יתרון מאוד חושב שניתן לשלב באותה טקסטורה מספר אבייקטים שונים ולחסוך מקום וקבצים.  

חבית בדו מימד

ניתן לראות שכל משטחי החבית נפרסים על על תמונה בודדת עם קואורדינטות עבור כל Vertex, התמונה תתלבש על האובייקט כשנטען אותה ל OpenGL, זו שיטה שמתאימה למשחקים ומאוד פופלרית, חשוב מאוד לדעת שיש חלק מאוד אומנותי שמצריך קישורי ציור בתהליך הכנת הטקסטורה ויש המון שיטות וטכניקות בקיצור עולם ומלואו ,מי שמעוניין להיכנס אליו יותר לעומק מומלץ למצוא תוכנת תלת מימד ולחפור אותה עד שיצא עשן ולמי שזה לא מתאים לא חסר מודלים שמוכנים מראש.

חבית בתוכנת תלת מימד

*.OBJ

לפני שניכנס לפורמט פעם נוספת חשוב להדגיש שחלק מתוכנות התלת מימד שומרות בקובץ את המידע של ה Vertex כמרובע ולא כמשולש, ברוב המקרים זה בסדר אבל בגלל שאנחנו עובדים על OpenGL ES שמותאם ל Android ולא ניתן לעבוד עם מרובעים, יש להמיר את האובייקט למשולשים ורק אח"כ לשמור את המידע לקובץ, במקרה שלי Modo שומרת את המשטחים כמרובעים ללא אפשרויות נוספות, נאלצתי להוריד סקריפט מיוחד שיעשה זאת, להורדת הסקריפט לחץ כאן.

קובץ ה Obj מכיל את המידע בנוגע לאובייקט, למען הסדר הטוב אני יחזור על דברים שנאמרו באחד המאמרים בנושא על מנת שנשמור על הרצף,בתחילת הקובץ מופיעות נקודות ה Vertex של האובייקט עצמו עם סימון V מדובר על X Y Z עבור כל נקודה, לאחר מכן מגיע רצף נקודות ה Normal שעליהם נפרט במאמרים הבאים.

v -0.0200 0.0400 -1.0200

vn -0.4004 -0.7179 -0.5695

לאחר הקואורדינטות של האובייקט עצמו מתחיל רצף הנקודות של הטקסטורה, בדומה למאמר האחרון בו מערך הקואורדינטות היה כחלק מהקוד במקרה הזה אנחנו שואבים אותו מהקובץ אבל קיים הבדל בהתייחסות בין הסטנדרט של OBJ לבין OpenGL, הקובץ מתייחס לקוארדינטה 0.0 ל Top Left בזמן ש OpenGL מתייחס לקוארדינטה כ Bottom Left לכן עלינו להפוך את הטקסטורה כפי שנראה בקוד.

vt 0.5646 0.9954

הפורמט Obj מכיל בתוכו קישור לקובץ ה Material שמכיל בתוכו קישור לטקסטורה ופרמטרים נוספים.

mtllib barrel1.mtl

בסוף הקובץ מופעים האינדקסים של המשטחים שנצייר על המסך, לכל משטח יש 3 אינדקסים שמצבעים על הנתונים במערכים שנטענו לפני שהגענו לאנידקסים (V,VN,VT) , ניתן לראות בדוגמה שלמשטח באינדקס 20 תואמות הקואורדינטות במיקום 1 במערך של ה Normal Vertex ולמיקום 18 במערך של ה Texture Vertex, אבל גם פה יש מגבלה של ה OpenGL, לא ניתן לעבוד עם יותר מאינדקס אחד ועלינו להכין מראש מערך מסודר שיטען ברצף את הקוארדינטות כפי שנראה בהמשך.

f 20/1/18 8/2/7 21/3/19

ObjectParser

התוכנית עוברת מתיחת פנים מהפעם האחרונה,נוספו מחלקות חדשות ומספר פונקציות נוספות על מנת להשלים את התהליך,  יש לסדר את האינדקסים ולהכין את ה Buffers לקראת הכנסה ל OpenGL, נא לעקוב אחרי ההערות בקוד.

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.nio.FloatBuffer;
import java.nio.ShortBuffer;
import java.util.ArrayList;
import java.util.Vector;
import javax.microedition.khronos.opengles.GL10;
import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.graphics.Matrix;
import android.opengl.GLES20;
import android.opengl.GLUtils;
import android.util.Log;

public class ObjectParser {

//support class
public class vtPoints {
public float V, T;
}

//support class
public class vnPoints {
public float N1, N2;
}

//support class
public class vLayer {
public float X, Y, Z;
public vtPoints vt = new vtPoints();
public vnPoints vn = new vnPoints();
}

//array contains all the sorted information
private ArrayList<vLayer> vSlice = new ArrayList<vLayer>();

// arrays contains all points (vertex/normal)
private ArrayList<vtPoints> vtSlice = new ArrayList<vtPoints>();
private ArrayList<vnPoints> vnSlice = new ArrayList<vnPoints>();

//arrays contains all the indices information
private Vector<Short> vPointer = new Vector<Short>();
private Vector<Short> vtPointer = new Vector<Short>();
private Vector<Short> vnPointer = new Vector<Short>();

//buffers to load to opengl
private FloatBuffer vertexBuffer;
private ShortBuffer faceBuffer;
private FloatBuffer textureBuffer;
private FloatBuffer normalBuffer;

//reader of the file
private BufferedReader reader;

private Context ctx;
private GL10 gl;
private float mCubeRotation;

//textures pointers array
private int texturesPointers[];

public ObjectParser(Context context, String _filename, GL10 _gl) {
gl = _gl;
ctx = context;
try {
reader = new BufferedReader(new InputStreamReader(ctx.getAssets()
.open(_filename)));
} catch (IOException e) {
e.printStackTrace();
}

loadFile();
sortArrays();
}

public void Draw() {

gl.glLoadIdentity();
gl.glTranslatef(0.1f, -0.1f, -10.0f);

// rotate the object
gl.glRotatef(mCubeRotation, 0.0f, 0.5f, 0.1f);
gl.glEnable(GL10.GL_TEXTURE_2D);

//load buffers
gl.glVertexPointer(3, GL10.GL_FLOAT, 0, vertexBuffer);
gl.glEnableClientState(GL10.GL_VERTEX_ARRAY);

gl.glEnableClientState(GL10.GL_NORMAL_ARRAY);
gl.glNormalPointer(GL10.GL_FLOAT, 0, normalBuffer);

gl.glEnableClientState(GL10.GL_TEXTURE_COORD_ARRAY);
gl.glTexCoordPointer(2, GL10.GL_FLOAT, 0, textureBuffer);

if (texturesPointers[0] != 0) {
gl.glBindTexture(GL10.GL_TEXTURE_2D, texturesPointers[0]);
}

gl.glDrawElements(GL10.GL_TRIANGLES, faceBuffer.capacity(),
GL10.GL_UNSIGNED_SHORT, faceBuffer);

gl.glDisableClientState(GL10.GL_VERTEX_ARRAY);
gl.glDisableClientState(GL10.GL_TEXTURE_COORD_ARRAY);
   gl.glDisableClientState(GL10.GL_NORMAL_ARRAY);

mCubeRotation -= 0.25f;
}

private void sortArrays() {
for (int i = 0; i < vPointer.size(); i++) {

// get the vertex by the obj face indices
vLayer _layer = (vLayer) vSlice.get(vPointer.get(i));

// get the texture coordinates from obj texture indices
vtPoints _vt = (vtPoints) vtSlice.get(vtPointer.get(i));

// get the normal coordinates from obj texture indices
vnPoints _vn = (vnPoints) vnSlice.get(vnPointer.get(i));

// update the vertex layer with the new coordinates
_layer.vt = _vt;
_layer.vn = _vn;

}

//rearrange buffers by indices
Vector<Float> v = new Vector<Float>();
Vector<Float> vt = new Vector<Float>();
Vector<Float> vn = new Vector<Float>();

for (int i = 0; i < vSlice.size(); i++) {

vLayer _layer = vSlice.get(i);

v.add(_layer.X);
v.add(_layer.Y);
v.add(_layer.Z);

vt.add(_layer.vt.V);
vt.add(_layer.vt.T);

vn.add(_layer.vn.N1);
vn.add(_layer.vn.N2);

}

loadBuffer(v, vt, vn, vPointer);

}

private void loadBuffer(Vector<Float> v, Vector<Float> vt,
Vector<Float> vn, Vector<Short> f) {

//buffer for vertex
ByteBuffer byteBuf = ByteBuffer.allocateDirect(v.size() * 4);
byteBuf.order(ByteOrder.nativeOrder());
vertexBuffer = byteBuf.asFloatBuffer();
vertexBuffer.put(toPrimitiveArrayF(v));
vertexBuffer.position(0);

//buffer for texture
byteBuf = ByteBuffer.allocateDirect(vt.size() * 4);
byteBuf.order(ByteOrder.nativeOrder());
textureBuffer = byteBuf.asFloatBuffer();
textureBuffer.put(toPrimitiveArrayF(vt));
textureBuffer.position(0);

//buffer for normal
byteBuf = ByteBuffer.allocateDirect(vn.size() * 4 * 3);
byteBuf.order(ByteOrder.nativeOrder());
normalBuffer = byteBuf.asFloatBuffer();
normalBuffer.put(toPrimitiveArrayF(vn));
normalBuffer.position(0);

//buffer for indices -> faces
ByteBuffer fBuf = ByteBuffer.allocateDirect(f.size() * 2);
fBuf.order(ByteOrder.nativeOrder());
faceBuffer = fBuf.asShortBuffer();
faceBuffer.put(toPrimitiveArrayS(f));
faceBuffer.position(0);
}

private void loadFile() {
String line = null;
try {
while ((line = reader.readLine()) != null) {

// faces (3 indices)
if (line.startsWith("f")) {
processFace(line);
Log.d("Face Loaded", line);
}

//texture vertices
else if (line.startsWith("vt")) {
processVT(line);
Log.d("Texture coordinates Loaded", line);
}

//nornal vertices
else if (line.startsWith("vn")) {
processVN(line);
Log.d("Normal coordinates Loaded", line);
}

// vertices
else if (line.startsWith("v")) {
processV(line);
Log.d("Vetex Loaded", line);
}

//material
else if (line.startsWith("mtllib")) {
loadMaterial(line);
Log.d("Material Loaded", line);
}
}
} catch (IOException e) {
e.printStackTrace();
}

}

// load material file
private void loadMaterial(String line) {

String splitter[] = line.split(" ");
String filename = splitter[1];
BufferedReader textureReader;
try {
textureReader = new BufferedReader(new InputStreamReader(ctx
.getAssets().open(filename)));
String tLine = null;

while ((tLine = textureReader.readLine()) != null) {
if (tLine.startsWith("map_Kd")) {
loadTexture(tLine.split(" ")[1]);
}
}

} catch (IOException e) {
e.printStackTrace();
}

}

// load bitmap from the material file
private void loadTexture(String TextureMap) {
Bitmap tMap = null;
try {
// flip image because the different 
//sorting between OpenGL and OBJ standards
tMap = BitmapFactory.decodeStream(ctx.getAssets().open(TextureMap));
Matrix flip = new Matrix();
flip.postScale(1f, -1f);
Bitmap bitmap = Bitmap.createBitmap(tMap, 0, 0, tMap.getWidth(),
tMap.getHeight(), flip, true);
tMap = bitmap;
} catch (IOException e) {
e.printStackTrace();
return;
}

texturesPointers = new int[1];
GLES20.glGenTextures(texturesPointers.length, texturesPointers, 0);
gl.glBindTexture(GL10.GL_TEXTURE_2D, texturesPointers[0]);

// texture behavior
gl.glTexParameterf(GL10.GL_TEXTURE_2D, GL10.GL_TEXTURE_MAG_FILTER,
GL10.GL_LINEAR);
gl.glTexParameterf(GL10.GL_TEXTURE_2D, GL10.GL_TEXTURE_MIN_FILTER,
GL10.GL_LINEAR);
gl.glTexParameterf(GLES20.GL_TEXTURE_2D, GL10.GL_TEXTURE_WRAP_S,
GL10.GL_CLAMP_TO_EDGE);
gl.glTexParameterf(GLES20.GL_TEXTURE_2D, GL10.GL_TEXTURE_WRAP_T,
GL10.GL_CLAMP_TO_EDGE);

// insert the bitmap into open openGL buffer
gl.glTexEnvf(GL10.GL_TEXTURE_ENV, GL10.GL_TEXTURE_ENV_MODE,
GL10.GL_DECAL);
GLUtils.texImage2D(GL10.GL_TEXTURE_2D, 0, tMap, 0);

// no need this anymore...
tMap.recycle();

}

// export indices
private void processFace(String line) {

String[] tokens = line.split("[ ]+");
int c = tokens.length;

Vector<Short> tmpFaces = new Vector<Short>();
Vector<Short> tmpVn = new Vector<Short>();
Vector<Short> tmpVt = new Vector<Short>();
for (int i = 1; i < tokens.length; i++) {

// vertices indices
Short s = Short.valueOf(tokens[i].split("/")[0]);
s--;
tmpFaces.add(s);

// texture indices
s = Short.valueOf(tokens[i].split("/")[1]);
s--;
tmpVt.add(s);

// normal indices
s = Short.valueOf(tokens[i].split("/")[2]);
s--;
tmpVn.add(s);

}
vPointer.addAll(tmpFaces);
vtPointer.addAll(tmpVt);
vnPointer.addAll(tmpVn);

}

// export vertex coordinates
private void processV(String line) {

// split space
String[] tokens = line.split("[ ]+");
vLayer _layer = new vLayer();

int c = tokens.length;
for (int i = 1; i < c; i++) {

switch (i) {
case 1:
_layer.X = Float.valueOf(tokens[i]);
break;
case 2:
_layer.Y = Float.valueOf(tokens[i]);
break;
case 3:
_layer.Z = Float.valueOf(tokens[i]);
break;
default:
break;
}

}
vSlice.add(_layer);
}

// export normal coordinates
private void processVN(String line) {
String[] tokens = line.split("[ ]+");
int c = tokens.length;
vnPoints _layer = new vnPoints();
for (int i = 1; i < c; i++) {

switch (i) {
case 1:
_layer.N1 = Float.valueOf(tokens[i]);
break;
case 2:
_layer.N2 = Float.valueOf(tokens[i]);
break;
default:
break;
}

}
vnSlice.add(_layer);
}

// export texture coordinates
private void processVT(String line) {
String[] tokens = line.split("[ ]+");
int c = tokens.length;
vtPoints _layer = new vtPoints();
for (int i = 1; i < c; i++) {

switch (i) {
case 1:
_layer.V = Float.valueOf(tokens[i]);
break;
case 2:
_layer.T = Float.valueOf(tokens[i]);
break;
default:
break;
}

}

vtSlice.add(_layer);
}

// convert Short Vector to Short Array
private short[] toPrimitiveArrayS(Vector<Short> vector) {
short[] s;
s = new short[vector.size()];
for (int i = 0; i < vector.size(); i++) {
s[i] = vector.get(i);
}
return s;
}

// convert Float Vector to Float Array
private float[] toPrimitiveArrayF(Vector<Float> vector) {
float[] f;
f = new float[vector.size()];
for (int i = 0; i < vector.size(); i++) {
f[i] = vector.get(i);
}
return f;
}

}

המחלקה מקבלת את שם הקובץ ופותחת אותו מתיקיית ה Assets לאחר מכן עוברת שורה שורה בקובץ (LoadFile) ומוצאת את הנתונים של ה Normal, Vertex ו Texture, אוספת את מיקום הטקסטורה מקובץ ה Material ולסיום אוספת את האינדקסים לאחר מכן מייצרת מערך מסוג vLayer עבור שורות ה Vertices , וטוענת לתוכו את הקוראדינטות של ה Normal וה Texture ע"פ האידקסים שלהם.

דוגמה מהמכשיר

חבית במכשיר

הורדת הפרוייקט

https://sourceforge.net/projects/openglcomplexobject/files/uvTexture.rar/download

סיכום

ראינו כמה העסק מסובך אבל מאוד מאתגר, עכשיו אפשר לתכנן אובייקטים מורכבים ולצבוע אותם,ניתן להתחיל להכין את הסביבה עבור משחק התלת מימד הראשון שנעשה באנדרואיד.

בהצלחה.

Android OpenGL Texture

אחרי שלמדנו לטעון אובייקטים למנוע OpenGL במכשיר, השלב הבא הוא להכניס צבע למודלים אבל לפני שנקפוץ למים העמוקים נתחיל עם אובייקט שנראה פשוט כמו קובייה כבר ראינו שגם קובייה זה אובייקט מורכב במיוחד ב OpenGL אז כדאי להכיר אותו לפני שהולכים לאובייקטים מסובכים יותר.

לקובייה יש 6 משטחים שמורכבים מ 12 משולשים כבר דיברנו על זה במאמר הפתיחה, חשוב לחזור על זה כי בנוסף לנקודות ה Vertices נוספות  נקודות חדשות עבור הטקסטורה.

על מנת להבין את הרעיון יש להסתכל על כל משטח באופן עצמי לדוגמה ניקח את המשטח הראשון שאנחנו מציירים ונוסיף לנו נקודות ציון בסדר שאנחנו רוצים שהוא יפרוס את הטקסטורה על גבי המשטח בעזרת מערך ו Buffer שנוסיף לתהליך.

private float texture[] = {

// Mapping coordinates for the vertices

//FaceA

0.0f, 1.0f,//top left

1.0f, 1.0f,//top right

0.0f,0.0f, //bottom left

1.0f, 0.0f,//bottom right

          }

כפי שניתן לראות אנחנו מציבים במערך Texture את הנקודה השמאלית עליונה ואח"כ את הימנית העליונה ובעצם גורמים לטקסטורה להיות מצוירת מלמעלה ללמטה , אם נשנה את הסדר ונטען את הנקודה השמאלית העליונה עם השמאלית התחתונה נצייר את הטקסטורה משמאל לימין.

private float texture[] = {

// Mapping coordinates for the vertices

//FaceA

0.0f, 1.0f,//top left

0.0f,0.0f, //bottom left

1.0f, 1.0f,//top right

1.0f, 0.0f,//bottom right

        }

דוגמה נוספת למה קורה כאשר מציירים את הנקודות התחתונות ואח"כ את הנקודות העליונות.

private float texture[] = {

// Mapping coordinates for the vertices

//FaceA

0.0f,0.0f, //bottom left

1.0f, 0.0f,//bottom right

0.0f, 1.0f,//top left

1.0f, 1.0f,//top right

  }

את השאר תנחשו לבד

אפשר לצייר את הטקסטורה על המשטח עם כיוון השעון או נגד הכל תלוי בסדר הנקודות שנכנס ל Buffer עבור כל משטח כפי שניתן לראות במחלקה CubeTextue.

CubeTexture

import java.io.IOException;

import java.nio.ByteBuffer;

import java.nio.ByteOrder;

import java.nio.FloatBuffer;

import javax.microedition.khronos.opengles.GL10;

import android.content.Context;

import android.graphics.Bitmap;

import android.graphics.BitmapFactory;

import android.opengl.GLES20;

import android.opengl.GLUtils;

public class CubeTexture {

private GL10 gl;

private Context ctx;

private FloatBuffer mVertexBuffer;

private FloatBuffer mTextureBuffer;

private ByteBuffer mIndexBuffer;

private int texturesPointers[];

private Bitmap texturesMaps[];

private float mCubeRotation;

private float vertices[] = {

// Vertices according to faces

//X     Y      Z

-1.0f, -1.0f, 1.0f,

1.0f, -1.0f, 1.0f,

-1.0f, 1.0f, 1.0f,

1.0f,1.0f, 1.0f,

1.0f, -1.0f, 1.0f,

1.0f, -1.0f, -1.0f,

1.0f, 1.0f,1.0f,

1.0f, 1.0f, -1.0f,

1.0f, -1.0f, -1.0f,

-1.0f, -1.0f, -1.0f,

1.0f, 1.0f, -1.0f,

-1.0f, 1.0f, -1.0f,

-1.0f, -1.0f, -1.0f,

-1.0f,-1.0f, 1.0f,

-1.0f, 1.0f, -1.0f,

-1.0f, 1.0f, 1.0f,

-1.0f, -1.0f,-1.0f,

1.0f, -1.0f, -1.0f,

-1.0f, -1.0f, 1.0f,

1.0f, -1.0f, 1.0f,

-1.0f, 1.0f, 1.0f,

1.0f, 1.0f, 1.0f,

-1.0f, 1.0f, -1.0f,

1.0f,1.0f, -1.0f, 

};

private float texture[] = {

// Mapping coordinates for the vertices

//FaceA

0.0f, 1.0f,//top left

1.0f, 1.0f,//top right

0.0f,0.0f, //bottom left

1.0f, 0.0f,//bottom right

//Face B

0.0f, 1.0f,

1.0f, 1.0f,

0.0f,0.0f,

1.0f, 0.0f,

//Face C

0.0f, 1.0f,

1.0f, 1.0f,

0.0f,0.0f,

1.0f, 0.0f,

//Face D

0.0f, 1.0f,

1.0f, 1.0f,

0.0f,0.0f,

1.0f, 0.0f,

//Face E

0.0f, 1.0f,

1.0f, 1.0f,

0.0f,0.0f,

1.0f, 0.0f,

//Face F

0.0f, 1.0f,

1.0f, 1.0f,

0.0f,0.0f,

1.0f, 0.0f,

};

private byte indices[] = {

// Faces definition

0, 1, 3, 0, 3, 2, 4, 5, 7, 4, 7, 6, 8, 9, 11, 8, 11, 10, 12, 13,

15, 12, 15, 14, 16, 17, 19, 16, 19, 18, 20, 21, 23, 20, 23, 22, };

public CubeTexture(Context _ctx, GL10 _gl)

{

ctx = _ctx;

gl = _gl;

init();

}

//load bitmaps into openGL

private void loadTextures()

{

//for each face of the cube

texturesMaps = new Bitmap[6];

try {

//using the assets folder

texturesMaps[0] = BitmapFactory.decodeStream(ctx.getAssets().open("sideA.jpg"));

texturesMaps[1] = BitmapFactory.decodeStream(ctx.getAssets().open("sideB.jpg"));

texturesMaps[2] = BitmapFactory.decodeStream(ctx.getAssets().open("sideC.jpg"));

texturesMaps[3] = BitmapFactory.decodeStream(ctx.getAssets().open("sideD.jpg"));

texturesMaps[4] = BitmapFactory.decodeStream(ctx.getAssets().open("sideE.jpg"));

texturesMaps[5] = BitmapFactory.decodeStream(ctx.getAssets().open("sideF.jpg"));

} catch (IOException e) {

e.printStackTrace();

}

//create pointers to texture buffer

texturesPointers = new int[texturesMaps.length];

//generate the texture in the opengl

GLES20.glGenTextures(texturesPointers.length, texturesPointers, 0);

for (int i = 0; i < texturesMaps.length; i++) {

gl.glBindTexture(GL10.GL_TEXTURE_2D, texturesPointers[i]);

//texture behavior 

gl.glTexParameterf(GL10.GL_TEXTURE_2D, GL10.GL_TEXTURE_MAG_FILTER,

GL10.GL_LINEAR);

gl.glTexParameterf(GL10.GL_TEXTURE_2D, GL10.GL_TEXTURE_MIN_FILTER,

GL10.GL_LINEAR);

gl.glTexParameterf(GLES20.GL_TEXTURE_2D, GL10.GL_TEXTURE_WRAP_S,

GL10.GL_CLAMP_TO_EDGE);

gl.glTexParameterf(GLES20.GL_TEXTURE_2D, GL10.GL_TEXTURE_WRAP_T,

GL10.GL_CLAMP_TO_EDGE);

//insert the bitmap into openGL buffer

GLUtils.texImage2D(GL10.GL_TEXTURE_2D, 0, texturesMaps[i], 0);

//no need anymore

texturesMaps[i].recycle();

}

}

private void init()

{

// buffer for vertex coordinates

ByteBuffer byteBuf = ByteBuffer.allocateDirect(vertices.length * 4);

byteBuf.order(ByteOrder.nativeOrder());

mVertexBuffer = byteBuf.asFloatBuffer();

mVertexBuffer.put(vertices);

mVertexBuffer.position(0);

  // buffer for textures coordinates

byteBuf = ByteBuffer.allocateDirect(texture.length * 4);

byteBuf.order(ByteOrder.nativeOrder());

mTextureBuffer = byteBuf.asFloatBuffer();

mTextureBuffer.put(texture);

mTextureBuffer.position(0);

   // buffer for faces

mIndexBuffer = ByteBuffer.allocateDirect(indices.length);

mIndexBuffer.put(indices);

mIndexBuffer.position(0);

loadTextures();

}

public void Draw()

{

gl.glLoadIdentity();

gl.glTranslatef(0.1f, 0.0f, -10.0f);

gl.glRotatef(mCubeRotation, 1.0f, 1.0f, 1.0f);

gl.glFrontFace(GL10.GL_CW);

gl.glEnableClientState(GL10.GL_VERTEX_ARRAY);

gl.glVertexPointer(3, GL10.GL_FLOAT, 0, mVertexBuffer);

gl.glEnable(GL10.GL_TEXTURE_2D);

gl.glEnableClientState(GL10.GL_TEXTURE_COORD_ARRAY);

gl.glTexCoordPointer(2, GL10.GL_FLOAT, 0, mTextureBuffer);

//texture for each face of the cube

for (int i = 0; i < 6; ++i) {

if (texturesPointers[i] != 0) {

gl.glBindTexture(GL10.GL_TEXTURE_2D, texturesPointers[i]);

}

mIndexBuffer.position(6 * i); 

gl.glDrawElements(GL10.GL_TRIANGLES, 6, GL10.GL_UNSIGNED_BYTE,

mIndexBuffer);

}

gl.glDisableClientState(GL10.GL_VERTEX_ARRAY);

        gl.glDisableClientState(GL10.GL_TEXTURE_COORD_ARRAY);

gl.glDisable(GL10.GL_TEXTURE_2D);

mCubeRotation -= -0.25f;

}

}

טוענים 6 תמונות מתיקיית ה Assets לטיפוסים של Bitmap, מייצרים Buffer בזיכרון של ה OpenGL ובעזרת מערך של  Pointers מצביעים לטקסטורות, מכניסים את ה Bitmap ל Buffer ומשחררים את  ה Bitmap מהזיכרון, בשלב ה Draw מחלקים את המשטחים וטוענים לכל משטח את הטקסטורה מהזיכרון שהגדרנו.

להורדת התוכנית:

https://sourceforge.net/projects/openglcomplexobject/files/cubeTexture.rar/download

סיכום:

אז כמו תמיד מתחילים מהדברים הפשוטים בשלב הבא נטען את נתוני הטקסטורה מקובץ ה OBJ ונשכלל את ה ObjectParser מהמאמר הקודם.

בהצלחה...