Bonsoir,

Je suis entrain de porter ma petite démo 3d sur nintendo ds. J'ai porté le loader de fichier MD5 de David Henry vers cette plateforme.

En faisant des modifications/optimisations (principalement en passant les calculs de floattant vers du fixed point), j'ai réussi diviser par dix les temps de calcul. Et je suis confronté à un problème : la console est très peu puissante (avec 67Mhz). Avec un modèle de 33 bones, 875 vertices et 1027 triangles, j'arrive à un temps de calcul de 17-18 ms. C'est énorme car je veux faire tourner ma démo de jeu à 60fps (soit moins de 16.66ms pour effectuer des calculs). De plus, je dois aussi faire les calculs de collisions.

J'ai déjà fait des jeux ds en utilisant les libs fournises par nintendo. Les libs sont très bien en terme de performance par contre elles sont compliquée à utiliser pour attacher des objets ou accéder à des bones. J'ai vu dans leur libs qu'il utilise des matrices. Je suppose qu'il faut transformer les quaternions en matrices puis faire les calculs???

Ma question est : comment accélérer le skinning pour avoir une animation moins couteuse en temps de calcul ? car le calcul par vertex est très couteux avec la méthode de David Henry. Un ami m'a évoqué la méthode du stiching mais j'ai du mal à l'implémenter.

ps : J'ai la possibilier d'utiliser les displays lists et de les générer à la volé. je connais très bien toutes les commandes sur ds.

ps : c'est pas le cacul/evaluation des bones qui est couteux mais bien le rendu

Très cordialement,
Emotion Engine



Voici le code :
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
/**
 * Prepare a mesh for drawing.  Compute mesh's final vertex positions
 * given a skeleton.  Put the vertices in vertex arrays.
 */
void
PrepareMesh (const struct md5_mesh_t *mesh,
         const struct md5_joint_t *skeleton)
 
{
  int i, j, k;
 
    int num_tris = mesh->num_tris;
  /* Setup vertex indices */
  for (k = 0, i = 0; i < num_tris; ++i)
    {
      vertexIndices[k++] = mesh->triangles[i].index[j++];
      vertexIndices[k++] = mesh->triangles[i].index[j++];
      vertexIndices[k++] = mesh->triangles[i].index[j++];
    }
 
    int num_verts = mesh->num_verts;
    struct md5_vertex_t *vertices = &mesh->vertices[0];
  /* Setup vertices */
  for (i = 0; i < num_verts; ++i, ++vertices)
    {
      vec3_t finalVertex = { 0, 0, 0 };
        int count = vertices->count;
        int start = vertices->start;
       struct md5_weight_t *weight = &mesh->weights[start];
      /* Calculate final vertex to draw with weights */
      for (j = 0; j < count; ++j, ++weight)
    {
      struct md5_joint_t *joint
        = &skeleton[weight->joint];
 
      /* Calculate transformed vertex for this weight */
      vec3_t wv;
      Quat_rotatePoint (joint->orient, weight->pos, wv);
 
      /* The sum of all weight->bias should be 1.0 */
      finalVertex[0] += FP_Mul(joint->pos[0] + wv[0], weight->bias);
      finalVertex[1] += FP_Mul(joint->pos[1] + wv[1], weight->bias);
      finalVertex[2] += FP_Mul(joint->pos[2] + wv[2], weight->bias);
    }
 
      vertexArray[i][0] = finalVertex[0];
      vertexArray[i][1] = finalVertex[1];
      vertexArray[i][2] = finalVertex[2];
  }
}
 
void
Quat_rotatePoint (const quat4_t q, const vec3_t in, vec3_t out)
{
  quat4_t tmp, inv, final;
 
  inv[X] = -q[X]; inv[Y] = -q[Y];
  inv[Z] = -q[Z]; inv[W] =  q[W];
 
  Quat_normalize (inv);
 
  Quat_multVec (q, in, tmp);
  Quat_multQuat (tmp, inv, final);
 
  out[X] = final[X];
  out[Y] = final[Y];
  out[Z] = final[Z];
}
Voici un lien vers la page concernant le format de fichier MD5 (utilisé dans DOOM 3) et aussi du loader de fichier MD5 de David Henry :
http://tfc.duke.free.fr/coding/md5-specs-fr.html