MS3D

[modifier] Description

Les fichiers Milkeshape 3d contiennent des informations sur des objets en trois dimensions, ainsi que sur leurs textures et les animations correspondantes.

[modifier] Structure des fichiers

[modifier] Taille des champs

Tout d'abord, je vous donne ci-dessous un tableau récapitulatif pour les tailles et les types en Visual Basic et en C.

Pour les utilisateurs de C voici les types Word et Bytes :

#ifndef byte
typedef unsigned char byte;
#endif
 
#ifndef word
typedef unsigned short word;
#endif

[modifier] Définition

• 4 vertices (pluriel), 1 vertex (singulier).
• 1 vertex est un point dans l'espace (3 coordonnées, x,y,z).
• 3 vertices forment 1 triangle
• Un vecteur est composé de trois variables :
  • x = 4 bytes floating
  • y = 4 bytes floating
  • z = 4 bytes floating
• floating précise qu'il s'agit de nombres réels, c'est-à-dire par forcément entiers.

[modifier] Structure d'un fichier MilkShape 3d

Dans l'ensemble du fichier il y a des drapeaux (flags), ils représentent les différentes façon d'apparaitre à l'écran, voici les définitions en C :

#define SELECTED        1
#define HIDDEN          2
#define SELECTED2       4
#define DIRTY           8

[modifier] En-tête

Les premiers bytes d'un fichier MilkShape 3d forment une en-tête, ou header. Dix bytes sont réservés pour une identification, de valeur égale à "MS3D000000".

En VB on écrit : Dim Id as String * 10 et en C :

char Id[10]

• 2 bytes sont utilisés pour la version du fichier, qui est égale à 8.

Ce qui, en C, donne :

typdef struct {
char    id[10];
int     version;
} ms3d_header_t;

[modifier] Récupération des vertices

• 2 bytes sont réservés à une utilisation ultérieure (dans la plupart des cas c'est 0).
• Ensuite 2 bytes donnent le nombres total de vertices (short en C).
• Puis pour chaque vertex :
  • un drapeau As Byte
  • x As Single
  • y As Single
  • z As Single
  • Bone As Byte (comprendre squelette ou structure)
  • reference As Byte

Application en C :

word unknow;
 
word nNumVertices;
 
typedef struct {
byte    Drapeau;
float   vertex[3];
char    boneId;
byte    referenceCount;
} ms3d_vertex_t;

[modifier] Récupération des Triangles

• Les 2 premiers bytes donnent le nombre total de triangles
  
• Puis pour chaque triangle :
  
  • Drapeau As Integer
    
  • IndiceVertex0 As Integer
    
  • IndiceVertex1 As Integer
    
  • IndiceVertex2 As Integer
    

• Les bytes suivant peuvent être ordonnés comme montré dans ce tableau :

En fait, il y a 3 vecteurs pour donner la normale du triangle , au format Single :

• s1 As Single
• s2 As Single
• t1 As Single
• t2 As Single
• SmoothingGroup As Byte
• IndexGroup As Byte

Application à C :

word nNumTriangles;
 
typedef struct {
word    flags;
word    vertexIndices[3];
float   vertexNormals[3][3];
float   s[3];
float   t[3];
byte    smoothingGroup;
byte    groupIndex;
} ms3d_triangle_t;

[modifier] Récupération des Groupes  :

Les Groupes sont aussi appelés Mesh

• Comme précédement le nombre total de groupes est codé sur 2 bytes
• Puis pour chaque groupe ::
  • Drapeau As Integer
  • Nom as string (32 bytes max)
  • NumberTriangles As Integer
  • TrianglesIndices as Integer, c'est un grand tableau avec les dimensions de NumberTriangles - 1
  • MaterialIndex as byte, si c'est égale à -1 il n'y a pas de matériaux

Application en C :

word nNumGroups;
 
typedef struct {
byte            Drapeau;
char            name[32];
word            numtriangles;
word            triangleIndices[numtriangles];
char            materialIndex;
} ms3d_group_t;

[modifier] Récupération des Matériaux (si il y en a)  :

• Number of Material As Integer : Seulement si Number est supérieur à 1 alors pour chaque vertex il y a :
  • Nom As String (32 bytes max)
  • Ambient :
    • Ambient X As Single
    • Ambient Y As Single
    • Ambient Z As Single
  • Diffus :
    • Diffus X As Single
    • Diffus Y As Single
    • Diffus Z As Single
  • Speculaire :
    • Speculaire X As Single
    • Speculaire Y As Single
    • Speculaire Z As Single
  • Emetteur :
    • Emetteur X As Single
    • Emetteur Y As Single
    • Emetteur Z As Single
  • Glow As Single
  • Transparency As Single
  • Mode As String
  • Texture As String (128 bytes max)
  • MapAlpha As String (128 bytes max)

Application en C :

word nNumMaterials;
 
typedef struct {
char            name[32];
float           ambient[4];
float           diffuse[4];
float           specular[4];
float           emissive[4];
float           shininess;
float           transparency;
char            mode;
char            texture[128];
char            alphamap[128];
} ms3d_material_t;

[modifier] Récupération des Animations :

• Nombre d'images par seconde As Single
• Temps Courant As Single

Le temps où le fichier 3d est enregistré (l'image selectionnée à l'enregistrement)

• Nombre d'images As Integer :

Presque fini !! Il faut imaginer qu'une structure c'est un arbre généalogique avec au centre tous les points qui se relient, exemple : la colone vertébrale..

• Nombre de structures (Bone) As Integer
• Drapeau As Byte
• Nom As String (32 byte max)
• Nom du parent As String (32 byte max)
• Rotation :
  • RotationX As Single
  • RotationY As Single
  • RotationZ As Single
• Position :
  • PositionX As Single
  • PositionY As Single
  • PositionZ As Single
• Nombre de frame clé par rotation As Integer
• Nombre de frame clé par translation As Integer
• Pour chaque frame clé de rotation :
  • Temps as Single ---- Temps en seconde
  • Rotation :
    • X as Single
    • Y as Single
    • Z as Single
• Pour chaque frame clé de translation :
  • Temps as Single ---- Temps en seconde
  • Translation :
    • X as Single
    • Y as Single
    • Z as Single

Application en C:

float fAnimationFPS;
float fCurrentTime;
int iTotalFrames;
 
word nNumJoints;
 
typedef struct {
float           Temps;
float           rotation[3];
} ms3d_keyframe_rot_t;
 
typedef struct {
float           time;
float           position[3];
} ms3d_keyframe_pos_t;
 
typedef struct {
byte            Drapeau;
char            name[32];
char            parentName[32];
float           rotation[3];
float           position[3];
 
word            numKeyFramesRot;
word            numKeyFramesTrans;
 
ms3d_keyframe_rot_t keyFramesRot[numKeyFramesRot];
ms3d_keyframe_pos_t keyFramesTrans[numKeyFramesTrans];
} ms3d_joint_t;

[modifier] Les quelques mots de la fin

Pour obtenir la transformation liée à l'animation, il faut :

• construire les matrices à partir de la rotation et de la position
• multiplier les vertices
• translater le résultat avec les frames clés de translation et de rotation.