• الإعلانات

    • فيصل الحربي

      تسجيل عضوية جديدة في المنتدى   01/31/2016

      السلام عليكم ورحمة الله وبركاته  عزيزي العضو الجديد :  حاليا رسالة الإيميل لتأكيد صحة إيميلكم تذهب للبريد العشوائي ( جاري حل المشكلة )  فإذا لم تجد رسالة التحقق من إيميلكم في صندوق الوارد لديكم إتجه للبريد العشوائي ( JUNK)  وقم بتفعيل إشتراككم من هناك   

zakaria28

اعضاء جدد
  • عدد المشاركات

    1
  • تاريخ الانضمام

  • تاريخ اخر زياره

السمعه بالموقع

0 عادي

عن zakaria28

  • الرتبة
    عضو جديد

معلومات الملف الشخصي

  • الجنس ذكر
  1. مساعدة في مذكرة تخرج

    السلام عليكم ورحمة الله وبركاته   انا ادرس في السنة الاخيرة معلوماتية وعندي مذكرة تخرج عنوانها تطبيقة لعبة روبيك كيب على اجهزة الاندرويد واردت ان اشارككم في ملفات الجافا لتشرحو لي الدوال لانني ضعيف في الجافا حيث انني سوف اقسم لكم الكود الى كلاسات   ارجو ان لا تبخلو عليا بمساعداتكم ولو بالشرح السطحي وشكرا لكم public class PointSommet { public float x; public float y; public float z; private PointSommet() {} public PointSommet(float x, float y, float z) { this.x = x; this.y = y; this.z = z; } public float[] ver_tablau3() { return new float[] {x, y, z}; } public float[] ver_tablau4() { return new float[] {x, y, z, 1f}; } public void tablau_ver_point(float[] tab) { x = tab[0]; y = tab[1]; z = tab[2]; } public static PointSommet vide() { return new PointSommet(); }// نقطة تقاطع public static float point_production(PointSommet vecteur1, PointSommet vecteur2) { return vecteur1.x * vecteur2.x + vecteur1.y * vecteur2.y + vecteur1.z * vecteur2.z; }//??????????????????????????????????? public static PointSommet crossProduct(PointSommet vecteur1, PointSommet vecteur2) { PointSommet ret = new PointSommet(); ret.x = (vecteur1.y * vecteur2.z) - (vecteur1.z * vecteur2.y); ret.y = (vecteur1.z * vecteur2.x) - (vecteur1.x * vecteur2.z); ret.z = (vecteur1.x * vecteur2.y) - (vecteur1.y * vecteur2.x); return ret; }// un copier de sommet public PointSommet copier() { return new PointSommet(x, y, z); }// la distance entre 2 poit dans espase public static float distance(PointSommet a, PointSommet b) { float dx = a.x - b.x; float dy = a.y - b.y; float dz = a.z - b.z; // la racine carré return (float) Math.sqrt(dx * dx + dy * dy + dz * dz); }}import java.nio.ByteBuffer;import java.nio.ByteOrder;import java.nio.FloatBuffer;import java.util.ArrayList;import javax.microedition.khronos.opengles.GL10;import android.opengl.Matrix;public class Cubic { private FloatBuffer vertexBuffer; private FloatBuffer colorBuffer; //Position d'un cube private PointSommet transVec= PointSommet.vide(); //Vector contains Cube updated placement in space (Rubik cube) private PointSommet locationVec; public Quatre quatre = Quatre.identity(); public float[] rotMatric = new float[16]; private static final float taill = 0.5f; private int id = 0; private float alpha = 0; private ArrayList<float[]> oryginalVecColors = new ArrayList<float[]>(); private ArrayList<PointSommet> actualVecColors = new ArrayList<PointSommet>(); public Cubic(PointSommet transformVec, int id, int x, int y, int z) { setVertices(); transVec = transformVec; locationVec = transformVec.copier(); Matrix.setIdentityM(rotMatric, 0);//rotMatrix={1 ,0,0,0,0, 1 ,0,0,0,0, 1 ,0,0,0,0, 1 } this.id = id; alpha = (float) id / 255f; ArrayList<float[]> couleur = new ArrayList<float[]>(); //chaque face COLORATION en gris for (int i = 0; i < 24; i++) { couleur.add(new float[] {0.2f, 0.2f, 0.2f, alpha}); } if (x == 0) { oryginalVecColors.add(new float[] { Valeur_de_couleur.VERT, 0, 0, 0});//couleur de face for (int i = 16; i < 20; i++) { couleur.set(i, new float[] {0, 1, 0, alpha});//VERT } } if (y == 0) { oryginalVecColors.add(new float[] {0,Valeur_de_couleur.JAUNE, 0, 0}); for (int i = 4; i < 8; i++) { couleur.set(i, new float[] {1, 1, 0, alpha});//JAUNE } } if (z == 0) { oryginalVecColors.add(new float[] {0, 0,Valeur_de_couleur.ORANGE, 0}); for (int i = 12; i < 16; i++) { couleur.set(i, new float[] {1, 0.5f, 0, alpha});//ORANGE } } if (x == 2) { oryginalVecColors.add(new float[] { Valeur_de_couleur.BLUE, 0, 0, 0}); for (int i = 20; i < 24; i++) { couleur.set(i, new float[] {0, 0, 1, alpha});//BLUE } } if (y == 2) { oryginalVecColors.add(new float[] {0,Valeur_de_couleur.BLANC, 0, 0}); for (int i = 0; i < 4; i++) { couleur.set(i, new float[] {1, 1, 1, alpha});//BLANC } } if (z == 2) { oryginalVecColors.add(new float[] {0, 0,Valeur_de_couleur.ROUGE, 0}); for (int i = 8; i < 12; i++) { couleur.set(i, new float[] {1, 0, 0, alpha});//ROUGE } } ByteBuffer cbb = ByteBuffer.allocateDirect(couleur.size() * 16); cbb.order(ByteOrder.nativeOrder()); colorBuffer = cbb.asFloatBuffer(); for (float[] color : couleur) { colorBuffer.put(color); } colorBuffer.position(0); for (int i = 0; i < oryginalVecColors.size(); i++) { actualVecColors.add(new PointSommet(oryginalVecColors.get(i)[0], oryginalVecColors.get(i)[1], oryginalVecColors.get(i)[2])); } } public void rota_cubic(Quatre quatRotation) { quatre = Quatre.multiply(quatre, quatRotation); Quatre.quatre_a_matrice(rotMatric, quatre); float[] tab = new float[4]; Matrix.multiplyMV(tab, 0, rotMatric, 0, transVec.ver_tablau4(), 0); locationVec.tablau_ver_point(tab); float[] vectorTab = new float[4]; for (int i = 0; i < oryginalVecColors.size(); ++i) { Matrix.multiplyMV(vectorTab, 0, rotMatric, 0, oryginalVecColors.get(i), 0); actualVecColors.get(i).tablau_ver_point(vectorTab); } } public PointSommet getReferenceVec() { return transVec; } public void tempRotation(Quatre quatRotation) { Quatre.quatre_a_matrice(rotMatric, quatRotation); float[] tab = new float[4]; Matrix.multiplyMV(tab, 0, rotMatric, 0, transVec.ver_tablau4(), 0); locationVec.tablau_ver_point(tab); } public ArrayList<PointSommet> getVecColors() { return actualVecColors; } public PointSommet locationVecteur() { return locationVec; } private void setVertices() { PointSommet sommet[] = new PointSommet[24]; //Top sommet[0] = new PointSommet(-taill, taill, taill); sommet[1] = new PointSommet(taill, taill, taill); sommet[2] = new PointSommet(-taill, taill, -taill); sommet[3] = new PointSommet(taill, taill, -taill); //Bottom sommet[4] = new PointSommet(taill, -taill, -taill); sommet[5] = new PointSommet(taill, -taill, taill); sommet[6] = new PointSommet(-taill, -taill, -taill); sommet[7] = new PointSommet(-taill, -taill, taill); //Front sommet[8] = new PointSommet(-taill, -taill, taill); sommet[9] = new PointSommet(taill, -taill, taill); sommet[10] = new PointSommet(-taill, taill, taill); sommet[11] = new PointSommet(taill, taill, taill); //Back sommet[12] = new PointSommet(taill, -taill, -taill); sommet[13] = new PointSommet(-taill, -taill, -taill); sommet[14] = new PointSommet(taill, taill, -taill); sommet[15] = new PointSommet(-taill, taill, -taill); //Left sommet[16] = new PointSommet(-taill, -taill, -taill); sommet[17] = new PointSommet(-taill, -taill, taill); sommet[18] = new PointSommet(-taill, taill, -taill); sommet[19] = new PointSommet(-taill, taill, taill); //Right sommet[20] = new PointSommet(taill, -taill, taill); sommet[21] = new PointSommet(taill, -taill, -taill); sommet[22] = new PointSommet(taill, taill, taill); sommet[23] = new PointSommet(taill, taill, -taill); ByteBuffer byteBuffer = ByteBuffer.allocateDirect(sommet.length * 3 * 4); byteBuffer.order(ByteOrder.nativeOrder()); vertexBuffer = byteBuffer.asFloatBuffer(); for (PointSommet vertex : sommet) { vertexBuffer.put(vertex.ver_tablau3()); } vertexBuffer.position(0); }//affichage de chaque cube public void draw(GL10 gl) { gl.glFrontFace(GL10.GL_CW); //اتجاه الواجهة gl.glEnable(GL10.GL_CULL_FACE); // OpenGL docs gl.glCullFace(GL10.GL_FRONT); // OpenGL docs gl.glPushMatrix(); gl.glMultMatrixf(rotMatric, 0); gl.glTranslatef(transVec.x, transVec.y, transVec.z);//(تحديد المحاور 3 دي) gl.glEnableClientState(GL10.GL_COLOR_ARRAY); gl.glEnableClientState(GL10.GL_VERTEX_ARRAY); gl.glColorPointer(4, GL10.GL_FLOAT, 0, colorBuffer);// اعطاء اين يؤشر الالوان gl.glVertexPointer(3, GL10.GL_FLOAT, 0, vertexBuffer);// اعطاء اين يؤشر الرؤوس gl.glDrawArrays(GL10.GL_TRIANGLE_STRIP, 0, 4);//(نوع الرسم ,تحديد القمة ,عدد القمم) gl.glDrawArrays(GL10.GL_TRIANGLE_STRIP, 4, 4); gl.glDrawArrays(GL10.GL_TRIANGLE_STRIP, 8, 4); gl.glDrawArrays(GL10.GL_TRIANGLE_STRIP, 12, 4); gl.glDrawArrays(GL10.GL_TRIANGLE_STRIP, 16, 4); gl.glDrawArrays(GL10.GL_TRIANGLE_STRIP, 20, 4); gl.glPopMatrix(); gl.glDisableClientState(GL10.GL_VERTEX_ARRAY); gl.glDisableClientState(GL10.GL_COLOR_ARRAY); gl.glDisable(GL10.GL_CULL_FACE); } public int aller_id() { return id; } public static float[] colorToInitialDirection4(Couleur_et_Id color) { int intValue = color.getColor(); if (intValue == Couleur_et_Id.BLANC) { float[] floats = {0, 1, 0, 0}; return floats; } else if (intValue == Couleur_et_Id.JAUNE) { float[] floats = {0, -1, 0, 0}; return floats; } else if (intValue == Couleur_et_Id.ROUGE) { float[] floats = {0, 0, 1, 0}; return floats; } else if (intValue == Couleur_et_Id.ORANGE) { float[] floats = {0, 0, -1, 0}; return floats; } else if (intValue == Couleur_et_Id.VERT) { float[] floats = {-1, 0, 0, 0}; return floats; } else if (intValue == Couleur_et_Id.BLUE) { float[] floats = {1, 0, 0, 0}; return floats; } else { return null; } } private class Valeur_de_couleur { public static final float BLANC = 1f; public static final float JAUNE = 2f; public static final float ROUGE = 3f; public static final float ORANGE= 4f; public static final float VERT = 5f; public static final float BLUE = 6f; }}import java.util.ArrayList;import java.util.List;import java.util.Random;import javax.microedition.khronos.opengles.GL10;import android.opengl.Matrix;import android.util.Log;public class Rubik { private Cubic cubes[]; private Couche durée_de_rotation; private final float espace = 1.1f; //espase entre les cubes munimen=1 private final float delta = 0.3f; private RubiksRandomizer randomizer = new RubiksRandomizer(); public Rubik(boolean k) { cubes = new Cubic[26]; float offset = -(((float) 3) / 2 - 0.5f) * espace; // the middle of rubik's cube is located at 0,0,0; int i = 0; int id = 0; for (int x = 0; x < 3; x++) { for (int y = 0; y < 3; y++) { for (int z = 0; z < 3; z++) { if (x == 0 || x == 2 || y == 0 || y == 2 || z == 0 || z == 2) { cubes[i++] = new Cubic(new PointSommet(offset + x * espace, offset + y * espace, offset + z * espace), id++, x, y, z); } } } } if(k){ randomizer.randomize();} } private boolean aboutEquals(float f1, float f2) { return Math.abs(f1 - f2) < delta; } private boolean aboutEquals(PointSommet v1, PointSommet v2) { return aboutEquals(v1.x, v2.x) && aboutEquals(v1.y, v2.y) && aboutEquals(v1.z, v2.z); }//creer le rubik complet public void dessiner_Rubik(GL10 gl) { for (Cubic cube : cubes) { cube.draw(gl); } } public boolean actualisation_de_rotation(long millis) { if (durée_de_rotation != null) { if (durée_de_rotation.appli_rotation(millis)) { durée_de_rotation = null; return est_Constitué(); } } return false; } public void rotation(Couleur_et_Id source, Couleur_et_Id destination) { if (this.durée_de_rotation != null) { Log.d("Don't even try that. This cube is unbreakable.", ":)"); return; } if (source.equals(Couleur_et_Id.zero)) { return; // ne select pas le cube // اللمس كان عل ىالخلفية السوداء } Cubic sour = recherche_cube(source.getId()); if (sour == null) { return; } if (source.getId() == destination.getId()) { // source et destination est dans meme cube if (source.equals(destination)) { return; // meme couleur . non rotation } else { // ces 2 couleur est meme cube et different face rotateThemCubes(source, destination, sour); } } else { // source et destination est different dans cube if (destination.equals(Couleur_et_Id.zero)) { return; // ne select pas le cube //اللمس كان عل ىالخلفية السوداء } Cubic dest = recherche_cube(destination.getId()); if (dest == null) { return; } else { // 2 different cubes PointSommet f = dest.locationVecteur(); PointSommet t = sour.locationVecteur(); // si les 2 cubes est voisin if (PointSommet.distance(f, t) < espace + delta) { rotateThemCubes(source, destination, sour, dest); } } } } private Cubic recherche_cube(int alphaId) { for (Cubic c : cubes) { if (c.aller_id() == alphaId) { return c; } } return null; } private void rotateThemCubes(Couleur_et_Id sour_coul, Couleur_et_Id dest_coul, Cubic sour_Cube, Cubic dest_Cube) { float[] constVect = Cubic.colorToInitialDirection4(sour_coul); if (constVect == null) { return; } PointSommet sour = sour_Cube.locationVecteur(); PointSommet dest = dest_Cube.locationVecteur(); PointSommet directionVector = new PointSommet(dest.x - sour.x, dest.y - sour.y, dest.z - sour.z); float[] result = new float[4]; Matrix.multiplyMV(result, 0, sour_Cube.rotMatric, 0, constVect, 0); PointSommet resultVector = new PointSommet(result[0], result[1], result[2]); PointSommet axis = PointSommet.crossProduct(directionVector, resultVector); roundToExactAxis(axis); // select de couche Cubic[] couche = select_couche(sour, axis); // dans la fin donc appliquer le rotation durée_de_rotation = new Couche(couche, Quatre.fromAxisAndAngle(axis, (float) Math.toRadians(90))); } private void rotateThemCubes(Couleur_et_Id sour_coul, Couleur_et_Id dest_coul, Cubic le_cube) { float[] constVect; float[] result = new float[4]; constVect = Cubic.colorToInitialDirection4(sour_coul); if (constVect == null) { return; } Matrix.multiplyMV(result, 0, le_cube.rotMatric, 0, constVect, 0); PointSommet resultVector1 = new PointSommet(result[0], result[1], result[2]); constVect = Cubic.colorToInitialDirection4(dest_coul); if (constVect == null) { return; } Matrix.multiplyMV(result, 0, le_cube.rotMatric, 0, constVect, 0); PointSommet resultVector2 = new PointSommet(result[0], result[1], result[2]); PointSommet axis = PointSommet.crossProduct(resultVector2, resultVector1); roundToExactAxis(axis);// pour eveter les virgules(x,225) // select layer Cubic[] couche = select_couche(le_cube.locationVecteur(), axis); // dans la fin donc appliquer le rotation durée_de_rotation = new Couche(couche, Quatre.fromAxisAndAngle(axis, (float) Math.toRadians(90))); } private Cubic[] select_couche(PointSommet location, PointSommet axe) { List<Cubic> list = new ArrayList<Cubic>(9); if (!aboutEquals(axe.x, 0)) {// sélect du axe for (Cubic cube : cubes) { if (aboutEquals(location.x, cube.locationVecteur().x)) {//select des cubes list.add(cube); } } } else if (!aboutEquals(axe.y, 0)) { for (Cubic cube : cubes) { if (aboutEquals(location.y, cube.locationVecteur().y)) { list.add(cube); } } } else if (!aboutEquals(axe.z, 0)) { for (Cubic cube : cubes) { if (aboutEquals(location.z, cube.locationVecteur().z)) { list.add(cube); } } } Cubic[] layer = new Cubic[list.size()]; return list.toArray(layer); } public boolean est_Constitué() { boolean meme_couleur = false; PointSommet middleColor; for (Face_de_rubik face : Face_de_rubik.values()) { Cubic[] couche = couche_Externe(face); middleColor = couche[4].getVecColors().get(0); for (Cubic cube : couche) { meme_couleur = false; for (PointSommet color : cube.getVecColors()) { if (aboutEquals(color, middleColor)) { meme_couleur = true; } } if (meme_couleur == false) { return false; } } Log.d(face.name(), "OK"); } return true; } private Cubic[] couche_Externe(Face_de_rubik face) { Cubic[] couche = new Cubic[9]; int i = 0; PointSommet début = cubes[0].locationVecteur(); // JAUNE/VERT/ORANGE PointSommet fin = cubes[8].locationVecteur(); // BLUE/BLANC/ROUGE switch (face) { case TOP: // BLUE for (Cubic cube : cubes) { if (aboutEquals(cube.locationVecteur().y, fin.y)) { couche[i++] = cube; } } break; case BOTTOM: // JAUNE for (Cubic cube : cubes) { if (aboutEquals(cube.locationVecteur().y, début.y)) { couche[i++] = cube; } } break; case FRONT: // ROUGE for (Cubic cube : cubes) { if (aboutEquals(cube.locationVecteur().z, fin.z)) { couche[i++] = cube; } } break; case BACK: // ORANGE for (Cubic cube : cubes) { if (aboutEquals(cube.locationVecteur().z, début.z)) { couche[i++] = cube; } } break; case LEFT: // VERT for (Cubic cube : cubes) { if (aboutEquals(cube.locationVecteur().x, début.x)) { couche[i++] = cube; } } break; case RIGHT: // BLUE for (Cubic cube : cubes) { if (aboutEquals(cube.locationVecteur().x, fin.x)) { couche[i++] = cube; } } break; } return couche; } private void roundToExactAxis(PointSommet vector) { vector.x = Math.round(vector.x); vector.y = Math.round(vector.y); vector.z = Math.round(vector.z); } private enum Face_de_rubik { TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT; } private class RubiksRandomizer { Random random = new Random(); PointSommet X = new PointSommet(1, 0, 0); PointSommet Y = new PointSommet(0, 1, 0); PointSommet Z = new PointSommet(0, 0, 1); double[] angles = {-90, 180, 90}; public void randomize() { for (int i = 0; i < 9; ++i) { quickRotate(getRandomXLayer(), X, angles[random.nextInt(3)]); quickRotate(getRandomYLayer(), Y, angles[random.nextInt(3)]); quickRotate(getRandomZLayer(), Z, angles[random.nextInt(3)]); } } private Cubic[] getRandomXLayer() { List<Cubic> list = new ArrayList<Cubic>(9); float randomXPos = cubes[0].getReferenceVec().x + random.nextInt(3); for (Cubic cube : cubes) { if (aboutEquals(cube.locationVecteur().x, randomXPos)) { list.add(cube); } } Cubic[] layer = new Cubic[list.size()]; return list.toArray(layer); } private Cubic[] getRandomYLayer() { List<Cubic> list = new ArrayList<Cubic>(9); float randomYPos = cubes[0].getReferenceVec().y + random.nextInt(3); for (Cubic cube : cubes) { if (aboutEquals(cube.locationVecteur().y, randomYPos)) { list.add(cube); } } Cubic[] layer = new Cubic[list.size()]; return list.toArray(layer); } private Cubic[] getRandomZLayer() { List<Cubic> list = new ArrayList<Cubic>(9); float randomZPos = cubes[0].getReferenceVec().z + random.nextInt(3); for (Cubic cube : cubes) { if (aboutEquals(cube.locationVecteur().z, randomZPos)) { list.add(cube); } } Cubic[] layer = new Cubic[list.size()]; return list.toArray(layer); } private void quickRotate(Cubic[] layer, PointSommet axis, double degrees) { for (Cubic cube : layer) { cube.rota_cubic(Quatre.fromAxisAndAngle(axis, (float) Math.toRadians(degrees))); } } }}public class Quatre { private float x; private float y; private float z; private float w; private Quatre() {} public Quatre(float x, float y, float z, float w) { this.x = x; this.y = y; this.z = z; this.w = w; } public Quatre clone() { return new Quatre(x, y, z, w); } public static Quatre identity() { return new Quatre(0, 0, 0, 1); } public static void quatre_a_matrice(float[] matrix, Quatre quat) { matrix[0] = 1.0f - (2.0f * ((quat.y * quat.y) + (quat.z * quat.z))); matrix[1] = 2.0f * ((quat.x * quat.y) - (quat.z * quat.w)); matrix[2] = 2.0f * ((quat.x * quat.z) + (quat.y * quat.w)); matrix[3] = 0.0f; matrix[4] = 2.0f * ((quat.x * quat.y) + (quat.z * quat.w)); matrix[5] = 1.0f - (2.0f * ((quat.x * quat.x) + (quat.z * quat.z))); matrix[6] = 2.0f * ((quat.y * quat.z) - (quat.x * quat.w)); matrix[7] = 0.0f; matrix[8] = 2.0f * ((quat.x * quat.z) - (quat.y * quat.w)); matrix[9] = 2.0f * ((quat.y * quat.z) + (quat.x * quat.w)); matrix[10] = 1.0f - (2.0f * ((quat.x * quat.x) + (quat.y * quat.y))); matrix[11] = 0.0f; matrix[12] = 0.0f; matrix[13] = 0.0f; matrix[14] = 0.0f; matrix[15] = 1.0f; } public static Quatre fromAxisAndAngle(PointSommet axis, float angle) { Quatre quat = new Quatre(); angle *= 0.5f; float sinAngle = (float) Math.sin(angle); quat.x = (axis.x * sinAngle); quat.y = (axis.y * sinAngle); quat.z = (axis.z * sinAngle); quat.w = (float) Math.cos(angle); return quat; } public static float extractAxisAndAngle(Quatre quat, PointSommet axis) {//استخراج الزاوية والمحور float s = (float) Math.sqrt(1.0f - (quat.w * quat.w)); if (Math.abs(s) < 0.0005f) { s = 1.0f; } if (axis != null) { axis.x = (quat.x / s); axis.y = (quat.y / s); axis.z = (quat.z / s); } return (float) (Math.acos(quat.w) * 2.0f); // return angle as float } public static Quatre multiply(Quatre quat1, Quatre quat2) { PointSommet v1 = new PointSommet(quat1.x, quat1.y, quat1.z); PointSommet v2 = new PointSommet(quat2.x, quat2.y, quat2.z); float angle = (quat1.w * quat2.w) - PointSommet.point_production(v1, v2); PointSommet cp = PointSommet.crossProduct(v1, v2); v1.x *= quat2.w; v1.y *= quat2.w; v1.z *= quat2.w; v2.x *= quat1.w; v2.y *= quat1.w; v2.z *= quat1.w; return new Quatre(v1.x + v2.x + cp.x, v1.y + v2.y + cp.y, v1.z + v2.z + cp.z, angle); } public static void invert(Quatre quat) { float length = 1.0f / ((quat.x * quat.x) + (quat.y * quat.y) + (quat.z * quat.z) + (quat.w * quat.w)); quat.x *= -length; quat.y *= -length; quat.z *= -length; quat.w *= length; } public static Quatre fromEulerAngles(float x, float y, float z) { PointSommet vx = new PointSommet(1.f, 0.f, 0.f); PointSommet vy = new PointSommet(0.f, 1.f, 0.f); PointSommet vz = new PointSommet(0.f, 0.f, 1.f); Quatre qx = fromAxisAndAngle(vx, x); Quatre qy = fromAxisAndAngle(vy, y); Quatre qz = fromAxisAndAngle(vz, z); Quatre temp = multiply(qx, qy); return multiply(temp, qz); } public static float dotProduct(Quatre quat1, Quatre quat2) { return quat1.x * quat2.x + quat2.y * quat2.y + quat1.z * quat2.z + quat1.w * quat2.w; } public static Quatre slerp(Quatre start, Quatre finish, float progress) { float startWeight, finishWeight; float difference = (start.x * finish.x) + (start.y * finish.y) + (start.z * finish.z) + (start.w * finish.w); if (1f - Math.abs(difference) > .01f) { float theta = (float) Math.acos(Math.abs(difference)); float oneOverSinTheta = (float) (1.f / Math.sin(theta)); startWeight = (float) (Math.sin(theta * (1.f - progress)) * oneOverSinTheta); finishWeight = (float) (Math.sin(theta * progress) * oneOverSinTheta); if (difference < 0f) { startWeight = -startWeight; } } else { startWeight = (1.f - progress); finishWeight = progress; } Quatre ret = new Quatre(); ret.x = (start.x * startWeight) + (finish.x * finishWeight); ret.y = (start.y * startWeight) + (finish.y * finishWeight); ret.z = (start.z * startWeight) + (finish.z * finishWeight); ret.w = (start.w * startWeight) + (finish.w * finishWeight); return ret; }}import android.graphics.Color;public class Couleur_et_Id { private int coul; private int id; public static Couleur_et_Id zero = new Couleur_et_Id(0, 0, 0, 255); public Couleur_et_Id() {} public Couleur_et_Id(int r, int g, int b, int a) { id = a; coul = Color.rgb(r, g, b); } public void setColor(int r, int g, int b) { coul = Color.rgb(r, g, b); } public int getColor() { return coul; } public void setId(int id) { this.id = id; } public int getId() { return id; } public boolean equals(Object o) { if (o instanceof Couleur_et_Id) { Couleur_et_Id that = (Couleur_et_Id) o; return this.coul == that.coul && this.id == that.id; } return false; } public static final int BLANC = Color.rgb(255, 255, 255); public static final int JAUNE = Color.rgb(255, 255, 0); public static final int ROUGE = Color.rgb(255, 0, 0); public static final int ORANGE= Color.rgb(255, 128, 0); public static final int VERT = Color.rgb(0, 255, 0); public static final int BLUE = Color.rgb(0, 0, 255);}public class Couche { private Cubic[] couche; // 1 couche est 9 cubes private static final long Durée_de_rotation = 700; private long durée_actuel; private Quatre destRotQuat; public Couche(Cubic[] layer, Quatre destRotQuat) { this.couche = layer; this.destRotQuat = destRotQuat; } public boolean appli_rotation(long dt) {// si returner true, est fin de rotation durée_actuel += dt; if (durée_actuel >= Durée_de_rotation) { // appliquer la rotation en (90deg) for (Cubic cube : couche) { cube.rota_cubic(destRotQuat); } return true; } float progrès = (float) durée_actuel / Durée_de_rotation; for (Cubic cube : couche) { Quatre slerped = Quatre.slerp(cube.quatre, Quatre.multiply(cube.quatre, destRotQuat), progrès); cube.tempRotation(slerped); } return false; } }import java.nio.ByteBuffer;import javax.microedition.khronos.egl.EGLConfig;import javax.microedition.khronos.opengles.GL10;import android.graphics.Point;import android.opengl.GLSurfaceView.Renderer;import android.util.DisplayMetrics;public class Rendu_OpenGL implements Renderer { private Quatre rot; private Rubik rubik; private Point port_vue; private volatile Point doigt_prev = null; private volatile Point doigt = null; private volatile Point point_demarer_tirage = null; private volatile Couleur_et_Id couleur_demarer_tirage = Couleur_et_Id.zero; private volatile boolean affect_Traction = false; // rotation de rubik public void rotate1(float dx, float dy, long dt) { Quatre dq = Quatre.fromEulerAngles(-dy * 0.0003f * dt, -dx * 0.0003f * dt, 0); rot = Quatre.multiply(rot, dq); } public Rendu_OpenGL(boolean k, DisplayMetrics displayMetrics) { rubik = new Rubik(k); rot = Quatre.identity(); rotate1(1f, 1f, 1571L); port_vue = new Point(displayMetrics.widthPixels, displayMetrics.heightPixels); } @Override public void onDrawFrame(GL10 gl) { float[] matrix = new float[16]; Quatre.quatre_a_matrice(matrix, rot); gl.glTranslatef(0, 0, -6.5f ); gl.glMultMatrixf(matrix, 0); gl.glScalef(1.2f, 1.2f, 1.2f);// zoomer de rubik gl.glClear(GL10.GL_COLOR_BUFFER_BIT | GL10.GL_DEPTH_BUFFER_BIT); rubik.dessiner_Rubik(gl); gl.glLoadIdentity(); long dt = 100; if (rubik.actualisation_de_rotation(dt)) { RubikActivity.getInstance().cubeSolved(); return; } processDragging(gl, dt); } @Override public void onSurfaceChanged(GL10 gl, int width, int height) {} @Override public void onSurfaceCreated(GL10 gl, EGLConfig config) { gl.glClearColor(0.0f, 0.0f, 0.0f, 1.0f); gl.glShadeModel(GL10.GL_SMOOTH); gl.glEnable(GL10.GL_DEPTH_TEST); gl.glHint(GL10.GL_PERSPECTIVE_CORRECTION_HINT, GL10.GL_NICEST); gl.glViewport(0, 0, port_vue.x, port_vue.y); gl.glMatrixMode(GL10.GL_PROJECTION); gl.glLoadIdentity(); float ratio = (float) port_vue.x / (float) port_vue.y; gl.glFrustumf(-ratio, ratio, -1, 1, 1, 17); gl.glEnable(GL10.GL_DITHER); gl.glMatrixMode(GL10.GL_MODELVIEW); gl.glLoadIdentity(); } private Couleur_et_Id readColorAndId(GL10 gl, Point point) { ByteBuffer buff = ByteBuffer.allocate(4); gl.glReadPixels(point.x, port_vue.y - point.y, 1, 1, GL10.GL_RGBA, GL10.GL_UNSIGNED_BYTE, buff); int r = normalize(buff.get()); int g = normalize(buff.get()); //htc fix int colorFix = 2; int halfColorVal = 128; if (g < halfColorVal + colorFix && g > halfColorVal - colorFix) g = halfColorVal; //htc fix int b = normalize(buff.get()); int a = normalize(buff.get()); return new Couleur_et_Id(r, g, b, a); } private int normalize(int a) { return a & 0xFF; } private synchronized void processDragging(GL10 gl, long dt) { if (affect_Traction && point_demarer_tirage != null) { if (couleur_demarer_tirage == null) { couleur_demarer_tirage = readColorAndId(gl, point_demarer_tirage); } if (Couleur_et_Id.zero.equals(couleur_demarer_tirage)) { // اذا كان يسحب على الخلفية السوداء if (doigt_prev != null && !doigt.equals(doigt_prev)) { rotate1(doigt.x - doigt_prev.x, doigt.y - doigt_prev.y, dt); } } else { // dragging started from one of the cubes Couleur_et_Id read = readColorAndId(gl, doigt); if (!read.equals(couleur_demarer_tirage)) { rubik.rotation(couleur_demarer_tirage, read); point_demarer_tirage = null; } } } affect_Traction = false; } ///////////////////////////////////////////////////////////////// public synchronized void startDrag(Point debut_tirage) { // // affect_Traction = true; // doigt_prev = null; doigt = debut_tirage; point_demarer_tirage = debut_tirage; couleur_demarer_tirage = null; } public synchronized void endDrag(Point fin_tirage) { affect_Traction = false; doigt_prev = null; doigt = null; point_demarer_tirage = null; couleur_demarer_tirage = null; } public synchronized void drag(Point en_cours_tirage) { // // affect_Traction = true; // doigt_prev = doigt; // doigt = en_cours_tirage; // } // ///////////////////////////////////////////////////////////////////}ملاحضة لقد استعملنا مكتبة اوبن جيال