ראינו שלא פשוט לבנות קובייה ועוד יותר מסובך לצבוע אותה, אבל שוב חוזרים לאותה שאלה מה קורה כאשר האובייקט מורכב מיותר מ 6 משטחים? גם הפעם עולם התלת מימד נותן לנו כלים להתמודד עם אובייקטים מורכבים בעזרת שיטת ה UV Map שמאפשרת לצבוע אותם בצורה יעילה וחסכונית.
UV Map
*.OBJ
שיטה לפריסת אובייקט תלת מימדי לדו מימד, עד עכשיו חיברנו משטח בודד לטקסטורה בודדת שזה לא הפתרון המושלם והוא בזבזני ולא ידידותי, בעזרת UV Coordinates ניתן לחבר מספר משטחים לנקודות ספציפיות בטקסטורה עצמה כך שכל משולש \ מרובע יצייר רק את התחום שלו, עוד יתרון מאוד חושב שניתן לשלב באותה טקסטורה מספר אבייקטים שונים ולחסוך מקום וקבצים.
 |
| חבית בדו מימד |
ניתן לראות שכל משטחי החבית נפרסים על על תמונה בודדת עם קואורדינטות עבור כל Vertex, התמונה תתלבש על האובייקט כשנטען אותה ל OpenGL, זו שיטה שמתאימה למשחקים ומאוד פופלרית, חשוב מאוד לדעת שיש חלק מאוד אומנותי שמצריך קישורי ציור בתהליך הכנת הטקסטורה ויש המון שיטות וטכניקות בקיצור עולם ומלואו ,מי שמעוניין להיכנס אליו יותר לעומק מומלץ למצוא תוכנת תלת מימד ולחפור אותה עד שיצא עשן ולמי שזה לא מתאים לא חסר מודלים שמוכנים מראש.
 |
| חבית בתוכנת תלת מימד |
לפני שניכנס לפורמט פעם נוספת חשוב להדגיש שחלק מתוכנות התלת מימד שומרות בקובץ את המידע של ה 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
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;
}
}
התוכנית עוברת מתיחת פנים מהפעם האחרונה,נוספו מחלקות חדשות ומספר פונקציות נוספות על מנת להשלים את התהליך, יש לסדר את האינדקסים ולהכין את ה Buffers לקראת הכנסה ל OpenGL, נא לעקוב אחרי ההערות בקוד.
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 ע"פ האידקסים שלהם.
דוגמה מהמכשיר
 |
| חבית במכשיר |
הורדת הפרוייקט
סיכום
ראינו כמה העסק מסובך אבל מאוד מאתגר, עכשיו אפשר לתכנן אובייקטים מורכבים ולצבוע אותם,ניתן להתחיל להכין את הסביבה עבור משחק התלת מימד הראשון שנעשה באנדרואיד.
בהצלחה.
אין תגובות:
הוסף רשומת תגובה