J'ai un cube en 3D fait avec opengl qui tourne de manière aléatoire et des arrêts montrant parfois jusqu'à 3 de ses côtés. Je voudrais que le cube tombe sur l'un des côtés (x, -x, y, -y, z, -z). Je l'ai réussi jusqu'à présent à identifier le côté supérieur du cube - celui à être montré. Cependant, je ne suis pas en mesure de manipuler la matrice que le cube "retombe". Disons que je peux voir les côtés X, Y et Z du cube et que je voudrais faire pivoter le cube de sorte que je ne puisse voir que le côté X. Pour autant que je comprenne, pour y parvenir, je dois faites pivoter le cube autour des axes Y et Z.Cube rotatif pour montrer un seul côté
Comme exemple je voudrais tourner matrice suivant sur l'axe y et z:
[0] = 0,90366703 [1] = - 0,4241817 [2] = - 0,058799066 [3] = 0,0 [4] = -0,3704742 [5] = - 0,70550096 [6] = - 0,6041675 [7] = 0,0 [8] = 0,21479362 [9] = 0,56774914 [10] = - 0,7946859 [12] = 0,0 [13] = 0,0 [14] = 0.0 [15] = 1,0
Voilà comment je suis en train de définir l'angle:
float[] camera_org = new float[3];
GL11 gl11 = (GL11) gl;
gl11.glGetFloatv(GL11.GL_MODELVIEW_MATRIX, mdl);
camera_org[0] = -(mdl.get(0) * mdl.get(12) + mdl.get(1) * mdl.get(13) + mdl.get(2) * mdl.get(14));
camera_org[1] = -(mdl.get(4) * mdl.get(12) + mdl.get(5) * mdl.get(13) + mdl.get(6) * mdl.get(14));
camera_org[2] = -(mdl.get(8) * mdl.get(12) + mdl.get(9) * mdl.get(13) + mdl.get(10) * mdl.get(14));
Log.i("CubeOrientation", camera_org[0] + " " + camera_org[1] + " " + camera_org[2]
+ " "+ 90/6 * camera_org[0] + "° " + 90/6 * camera_org[1] + "° " + 90/6 * camera_org[2] + "°");
float angle_x = camera_org[0] < 0 ? 90/6 * camera_org[0] : -90/6 * camera_org[0];
float angle_y = camera_org[1] < 0 ? 90/6 * camera_org[1] : -90/6 * camera_org[1];
float angle_z = camera_org[2] < 0 ? 90/6 * camera_org[2] : -90/6 * camera_org[2];
angle_x = angle_x < 0 ? angle_x + 90 : angle_x - 90;
angle_y = angle_y < 0 ? angle_y + 90 : angle_y - 90;
angle_z = angle_z < 0 ? angle_z + 90 : angle_z - 90;
Voilà comment je suis en train de faire les calculs:
float x1 = matrix[0];
float y1 = matrix[1];
float z1 = matrix[2];
float x2 = matrix[4];
float y2 = matrix[5];
float z2 = matrix[6];
float x3 = matrix[8];
float y3 = matrix[9];
float z3 = matrix[10];
float[] xz1 = rotateY(angle_y, x1, z1);
float[] xz2 = rotateY(angle_y, x2, z2);
float[] xz3 = rotateY(angle_y, x3, z3);
matrix[0] = xz1[0]; // x
x1 = xz1[0];
matrix[2] = xz1[1]; // z
matrix[4] = xz2[0]; // x
x2 = xz2[0];
matrix[6] = xz2[1]; // z
matrix[8] = xz3[0]; // x
x3 = xz3[0];
matrix[10] = xz3[1]; // z
float[] xy1 = rotateZ(angle_z, x1, y1);
float[] xy2 = rotateZ(angle_z, x2, y2);
float[] xy3 = rotateZ(angle_z, x3, y3);
matrix[0] = xy1[0]; // x
matrix[1] = xy1[1]; // y
matrix[4] = xy2[0]; // x
matrix[5] = xy2[1]; // y
matrix[8] = xy3[0]; // x
matrix[9] = xy3[1]; // y
Et voilà comment je suis en train de calculer les rotations:
/**
* Rotate X.
*
* @param angle_x
* @param y
* @param z
* @return [0] = y, [1] = z
*/
private float[] rotateX(float angle_x, float y, float z)
{
float[] res = new float[2];
res[0] = (float) (y * Math.cos(angle_x) - z * Math.sin(angle_x));
res[1] = (float) (y * Math.sin(angle_x) + z * Math.cos(angle_x));
return res;
}
/**
* Rotate Y.
*
* @param angle_y
* @param x
* @param z
* @return [0] = x, [1] = z
*/
private float[] rotateY(float angle_y, float x, float z)
{
float[] res = new float[2];
res[0] = (float) (x * Math.cos(angle_y) + z * Math.sin(angle_y));
res[1] = (float) (-x * Math.sin(angle_y) + z * Math.cos(angle_y));
return res;
}
/**
* Rotate Z.
*
* @param angle_z
* @param x
* @param y
* @return [0] = x, [1] = y
*/
private float[] rotateZ(float angle_z, float x, float y)
{
float[] res = new float[2];
res[0] = (float) (x * Math.cos(angle_z) - y * Math.sin(angle_z));
res[1] = (float) (y * Math.cos(angle_z) + x * Math.sin(angle_z));
return res;
}
Quelqu'un at-il fait quelque chose de semblable quelque temps ou pourrait me aider?
Merci beaucoup!