• 0
zakaria28

مساعدة في مذكرة تخرج

سؤال

السلام عليكم ورحمة الله وبركاته

 

انا ادرس في السنة الاخيرة معلوماتية وعندي مذكرة تخرج عنوانها تطبيقة لعبة روبيك كيب على اجهزة الاندرويد واردت ان اشارككم في ملفات الجافا لتشرحو لي الدوال لانني ضعيف في الجافا حيث انني سوف اقسم لكم الكود الى كلاسات

 

ارجو ان لا تبخلو عليا بمساعداتكم ولو بالشرح السطحي وشكرا لكم

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;                                           //  }                                                                //  ///////////////////////////////////////////////////////////////////}

ملاحضة لقد استعملنا مكتبة اوبن جيال

0

شارك هذا الرد


رابط المشاركة
شارك الرد من خلال المواقع ادناه

1 إجابات على هذا السؤال .

  • 0

-----

تم تعديل بواسطه وَدَق.
0

شارك هذا الرد


رابط المشاركة
شارك الرد من خلال المواقع ادناه

من فضلك سجل دخول لتتمكن من التعليق

ستتمكن من اضافه تعليقات بعد التسجيل



سجل دخولك الان

  • يستعرض القسم حالياً   0 members

    لا يوجد أعضاء مسجلين يشاهدون هذه الصفحة .