Wikilaran participation_au_projet:graphismes

participation_au_projet:graphismes:cal3d_fileformats-0_10_0

anonymous@undisclosed.example.com (Anonymous) — Sat, 13 Aug 2011 12:59:59 +0000

o------------------------------------------------------------------------------o
|                                                                              |
|                       cal3d fileformat description                           |
|                                                                              |
|                                Version 0.10.0                                |
|                             (12. january 2005)                               |
|                                                                              |
|        Copyright (C) 2001, 2002, 2003 Bruno 'Beosil' Heidelberger            |
|                                                                              |
o------------------------------------------------------------------------------o

o------------------------------------------------------------------------------o
| Table of Contents                                                            |
o------------------------------------------------------------------------------o

  1 What is this document for?
  2 cal3d skeleton file (.csf)
  3 cal3d animation file (.caf)
  4 cal3d mesh file (.cmf)
  5 cal3d material file (.crf)
  6 cal3d skeleton xml file (.xsf)
  7 cal3d animation xml file (.xaf)
  8 cal3d mesh xml file (.xmf)
  9 cal3d material xml file (.xrf)
  10 Website
  11 Author


o------------------------------------------------------------------------------o
| 1 What is this document for?                                                 |
o------------------------------------------------------------------------------o

This document describes the format of the different files used in the cal3d
character animation library version 0.10.0.

********************************************************************************
********************************************************************************
********************************************************************************

 IMPORTANT: As the cal3d library is still in heavy development, the fileformats
 described in this document will most likely become obsolete as soon as a new
 version of the library is released. Furthermore, the fileformat itself is not
 yet big-/little-endian independent and may contain fields that are either
 ignored or misinterpreted by the library.

********************************************************************************
********************************************************************************
********************************************************************************


o------------------------------------------------------------------------------o
| 2 cal3d skeleton file (.csf)                                                 |
o------------------------------------------------------------------------------o

Stored in this file is the hierarchy of bones that composes the skeleton.


description                length  type      comments
-------------------------  ------  --------  -----------------------------------
[header]
  magic token              4       const     "CSF\0"
  file version             4       integer   700
  number of bones          4       integer

[first bone]
  length of bone name      4       integer
  bone name                var     string
  translation x            4       float     relative translation to parent bone
  translation y            4       float
  translation z            4       float
  rotation x               4       float     relative rotation to parent bone
  rotation y               4       float     stored as a quaternion
  rotation z               4       float
  rotation w               4       float
  local translation x      4       float     translation to bring a vertex from
  local translation y      4       float     model space into bone space
  local translation z      4       float
  local rotation x         4       float     rotation to bring a vertex from
  local rotation y         4       float     model space into bone space
  local rotation z         4       float
  local rotation w         4       float
  parent bone id           4       integer   index to parent bone
  number of children       4       integer

  [first child]
    child bone id          4       integer   index to child bone

  [all other children]
    ...

[all other bones]
  ...


o------------------------------------------------------------------------------o
| 3 cal3d animation file (.caf)                                                |
o------------------------------------------------------------------------------o

All the keyframes of an animation are stored in this file. They are grouped by
tracks (one track per animated bone) and contain the time, the relative position
and the relative rotation to the parent bone.


description                length  type      comments
-------------------------  ------  --------  -----------------------------------
[header]
  magic token              4       const     "CAF\0"
  file version             4       integer   700
  duration                 4       float     length of animation in seconds
  number of tracks         4       integer

[first track]
  bone id                  4       integer   index to bone
  number of keyframes      4       integer

  [first keyframe]
    time                   4       float     time of keyframe in seconds
    translation x          4       float     relative translation to parent bone
    translation y          4       float
    translation z          4       float
    rotation x             4       float     relative rotation to parent bone
    rotation y             4       float     stored as a quaternion
    rotation z             4       float
    rotation w             4       float

  [all other keyframes]
    ...

[all other tracks]
  ...


o------------------------------------------------------------------------------o
| 4 cal3d mesh file (.cmf)                                                     |
o------------------------------------------------------------------------------o

This file contains all the mesh data, such as the weighted influences of the
bones on each vertex. The mesh is splitted into submeshes to group faces with
the same material thread.


description                length  type      comments
-------------------------  ------  --------  -----------------------------------
[header]
  magic token              4       const     "CMF\0"
  file version             4       integer   700
  number of submeshes      4       integer

[first submesh]
  material thread id       4       integer
  number of vertices       4       integer
  number of faces          4       integer
  number of lod steps      4       integer   number of vertices to collapse
  number of springs        4       integer   number of springs
  number of maps           4       integer

  [first vertex]
    position x             4       float     position in model space
    position y             4       float
    position z             4       float
    normal x               4       float     normal in model space
    normal y               4       float
    normal z               4       float
    collapse id            4       integer   index to vertex to collapse to
    face collapse count    4       integer   number of collapsing faces when
                                             this vertex gets collapsed

    [first map]
      u coordinate         4       float     map coordinates
      v coordinate         4       float

    [all other maps]
      ...

    number of influences   4       integer

    [first influence]
      bone id              4       integer   index to bone
      weight               4       float     weight of influence (1.0 == 100%)

    [all other influences]
      ...

    {physical property (only stored when #springs > 0 !)]
      weight               4       float     weight of vertex for cloth-/hair-
                                             animation (0.0 == rigid)

  [all other vertices]
    ...

  [first spring]
    vertex id 1            4       integer   index to vertex
    vertex id 2            4       integer   "
    spring coefficient     4       float
    idle length            4       float     rest length of the spring

  [all other springs]
    ...

  [first face]
    vertex id 1            4       integer   index to vertex
    vertex id 2            4       integer   "
    vertex id 3            4       integer   "

  [all other faces]
    ...

[all other submeshes]
  ...


o------------------------------------------------------------------------------o
| 5 cal3d material file (.crf)                                                 |
o------------------------------------------------------------------------------o

Material properties like ambient, diffuse and specular color and the shininess
factor are stored in this file. If the material contains texture maps, the
(file-)names of the textures are stored here too.


description                length  type      comments
-------------------------  ------  --------  -----------------------------------
[header]
  magic token              4       const     "CRF\0"
  file version             4       integer   700
  ambient color red        1       byte
  ambient color green      1       byte
  ambient color blue       1       byte
  ambient color alpha      1       byte
  diffuse color red        1       byte
  diffuse color green      1       byte
  diffuse color blue       1       byte
  diffuse color alpha      1       byte
  specular color red       1       byte
  specular color green     1       byte
  specular color blue      1       byte
  specular color alpha     1       byte
  shininess                4       float
  number of maps           4       integer

  [first map]
    length of texture name 4       integer
    texture name           var     string    most likely a filename

  {all other maps]
    ...

o-----------------------------------------------------------------------------o
| 6 skeleton Xml file (.xsf)                                                  |
o-----------------------------------------------------------------------------o

this is the text/Xml file format of cal3d skeleton file, 
see cal3d skeleton file (.csf) for more information

<HEADER MAGIC="XFS" VERSION="900"/>
<SKELETON NUMBONES="INT">
   <BONE ID="INT" NAME="STRING" NUMCHILD="INT">
      <TRANSLATION>FLOAT FLOAT FLOAT</TRANSLATION>
      <ROTATION>FLOAT FLOAT FLOAT FLOAT</ROTATION>
      <LOCALTRANSLATION>FLOAT FLOAT FLOAT</LOCALTRANSLATION>
      <LOCALROTATION>FLOAT FLOAT FLOAT FLOAT</LOCALROTATION>
      <PARENTID>INT</PARENTID>
      <CHILDID>INT</CHILDID>
      ...             		{all other childs}
    </BONE>
    ...				{all other bones}
</SKELETON>


o-----------------------------------------------------------------------------o
| 7 cal3d xml animation file (.xaf)                                           |
o-----------------------------------------------------------------------------o

this is the text/Xml file format of cal3d animation file, 
see cal3d skeleton file (.csf) for more information

<ANIMATION VERSION="1000" DURATION="FLOAT" NUMTRACKS="INT">
   <TRACK BONEID="INT" NUMKEYFRAMES="INT">
      <KEYFRAME TIME="FLOAT">
         <TRANSLATION>FLOAT FLOAT FLOAT</TRANSLATION>
         <ROTATION>FLOAT FLOAT FLOAT FLOAT</ROTATION>
      </KEYFRAME>
      ....                      {all other keyframes}
   </TRACK>
   ....                         {all other animation}
</ANIMATION>

o-----------------------------------------------------------------------------o
| 8 cal3d xml mesh file (.xmf)                                                |
o-----------------------------------------------------------------------------o

this is the text/Xml file format of cal3d mesh file, 
see cal3d mesh file (.cmf) for more information

<MESH VERSION="1000" NUMSUBMESH="INT">
   <SUBMESH MATERIAL="INT" NUMVERTICES="INT" NUMFACES="INT" NUMLODSTEPS="INT" NUMSPRINGS="INT" NUMTEXCOORDS="INT">
       <VERTEX ID="INT" NUMINFLUENCES="INT">
          <POS>FLOAT FLOAT FLOAT</POS>
          <NORMFLOAT FLOAT FLOAT</NORM>
          [<COLLAPSEID>INT</COLLAPSEID>]
          [<COLLAPSECOUNT>INT</COLLAPSECOUNT>]
          <TEXCOORD>FLOAT FLOAT</TEXCOORD>
          ...                                 {all the other texture coordinates}
          <INFLUENCE ID="INT">FLOAT FLOAT FLOAT</INFLUENCE>
          ...                                 {all the other bone influances}
          [<PHYSIQUE>FLOAT</PHYSIQUE>]
       </VERTEX>
       ....                                   {all the other vertices}
       <SPRING VERTEXID="INT INT" COEF="FLOAT" LENGTH ="FLOAT"/>
       ...                                    {all the other springs}
       <FACE VERTEXID="INT INT INT"/>
       ...                                    {all the other faces}
    </SUBMESH>
    ...
</MESH>

o-----------------------------------------------------------------------------o
| 9 cal3d xml material file (.xrf)                                            |
o-----------------------------------------------------------------------------o

this is the text/Xml file format of cal3d material file, 
see cal3d material file (.crf) for more information

<MATERIAL VERSION="1000" NUMMAPS="INT">
   <AMBIENT>FLOAT FLOAT FLOAT FLOAT</AMBIENT>
   <DIFFUSE>FLOAT FLOAT FLOAT FLOAT</DIFFUSE>
   <SPECULAR>FLOAT FLOAT FLOAT FLOAT</SPECULAR>
   <SHININESS>FLOAT</SHININESS>
   <MAP>STRING</MAP>
   ...                     {all other maps}
</MATERIAL>

o-----------------------------------------------------------------------------o
| 10 Website                                                                  |
o-----------------------------------------------------------------------------o

  The official website of cal3d can be found at: http://cal3d.sourceforge.net


o-----------------------------------------------------------------------------o
| 11 Author                                                                   |
o-----------------------------------------------------------------------------o

  This document was written by Bruno 'Beosil' Heidelberger.
  the Xml format has been added by Laurent Desmecht


o-----------------------------------------------------------------------------o

Tutoriel d’export de Blender vers cal3D

anonymous@undisclosed.example.com (Anonymous) — Sat, 13 Aug 2011 12:59:59 +0000

Tutoriel d’export de Blender vers cal3D

A REFAIRE

Tutoriel sur l’export d’objet créés dans Blender vers le format cal3D utilisable par le client du jeu Landes Eternelles. Pour rappel, Cal3D est une librairie de programmation qui permet d’animer des objets 3D et qui est utilisée par le client du jeu Landes Eternelles.

J’ai trouvé ce tutoriel, écrit par Bagalad pour XlurP, à cette page Tutoriel d’export de Blender vers cal3D et je vous le transpose tel quel.

Mes commentaires sont en italique et le fichier Blender n’est plus disponible sur le site de Landes Eternelles.

Bonjour,

Puisque la demande se fait grande je me lance donc dans un tutoriel rapide que j’aurais voulu plus soigné , mais tant pis, la force de l’urgence aura raison de la qualité …

Outils nécessaires :

Un minimum de connaissances de blender ( je ne souhaite pas faire un tutoriel sur blender )

Blender http://blender.org/

The Gimp http://www.gimp-fr.org/

Fichier blender de l’objet a exporter vers le jeu :

Fichier perso landes eternelles humain mâle : http://www.landes-eternelles.com/client/human_male.zip (lien mort, ce modèle n’est plus d’actualité qui plus est)

Script python d’export blender vers CAL3D (blender2cal3D_3.py) (il est préférable d’utiliser celui-ci : blender2cal3d_el.py.zip)

Image de base pour les textures http://home.tele2.fr/moravel/Tutor%20blender/textureformat%5b1%5d.bmp ou

Maintenant que nous avons le nécessaire, allons y :

copiez le script python dans le répertoire de blender dans .blender/script/

Ouvrez le fichier blender de l’humain
Faites SHIFT+F1
Choisissez le fichier blender où se trouve votre création, choisissez objet et enfin l’objet visé , puis cliquer sur load librairie
Votre objet est désormais dans le fichier blender ouvert, il vous reste à le redimensionner et à le placer sur le personnage de base.
Nous allons désormais affilier les vertices du mesh de l’objet a exporter à un ou des os du squelette du personnage :
- sélectionnez votre objet , sélectionnez l’armature du personnage , presser crtl+P, choisissez armature, puis name group
- sélectionner votre objet , passez en mode édition, affiliez vos points au bones de l’armature correspondants ( exemple pour un casque vous rendez les points du casque dépendants de l’os de la tête ( nommé head ) )
vous sortez du mode édition et replacez correctement votre objet ( il a souvent un peu bougé )
il faut maintenant faire correspondre le centre de votre objet avec le centre de référence ( centre de l’humain )
sélectionner par exemple le pantalon du personnage allez dans objet>snap>cursor à sélection
sélectionner votre objet, et dans le menu des boutons cliquez sur le bouton “ centre cursor ”
il faut maintenant éditer les coordonnées UV de l’objet :
- sélectionner l’objet
- dans la fenêtre 3D , changez le mode pour Uv face select
- tapez u puis sélectionnez une méthode de projection des faces de l’objet
vous voyez dans la fenêtre uv mapping la forme de votre objet.
Sauvegardez une image de votre projection dans la fenêtre uv faite uv>save face layout
Vous obtenez un fichier .tga contenant la projection de votre objet, éditez le dans un logiciel d’image ( the gimp ) et creez votre texture.
Vous mettrez votre texture aux dimensions mentionnées sur ce fichier :
vous transformer votre texture en bitmap, vous la copiez dans le presse papier
vous ouvrez ce fichier BMP , vous copiez votre presse papier dans ce fichier en prenant soin de la placer a son emplacement prévu , une épée a la place de l’arme, un casque à la place d’un casque …
vous sauvegardez
vous repassez dans votre fichier blender
dans la fenêtre uv mapping vous faites image>open> vous ouvrez votre image créez précédemment
vous ajustez les faces de votre objets ( redimension “ s ”, déplacement “ g ” ) pour qu’elles s’ajustent à la ta bonne texture.
Vous faites dans blender : file>export>cal 3d exporter 3 v1.1
Vous choisissez votre répertoire de destination , vous cochez uniquement le bouton _mf ( nous n’avons besoin que du mesh )
Vous exportez
Vous sauvegardez, et fermez blender
Vous allez dans le répertoire d’export, il s’y trouve un .cmf qui porte le nom de votre objet.
Il faut le placer avec un nom correct dans le dossier du jeu “ meshes ” ( pour un outil par exemple remplacez le fichier le la pioche qui est pickaxe1.cmf )
Ré ouvrez le .bmp que vous avez créé pour votre objet ( la texture) , pas celui qui contient tous les objets mais celui qui contient seulement le votre.
Il faut ouvrir la texture d’origine correspondante dans le répertoire du jeu et y coller la texture que vous avez créez ( pas l’échantillon totale mais uniquement le .bmp de votre objet )
Voilà il n’y a plus qu’a relancer le jeu.

Exporter un objet statique (e3d) de Blender

anonymous@undisclosed.example.com (Anonymous) — Sat, 13 Aug 2011 12:59:59 +0000

Exporter un objet statique (e3d) de Blender

Le script el3d_export.py permet d’exporter les objets créés ou modifiés dans Blender dans un format de fichier utilisable dans l’éditeur de carte et le jeu.

Les objets ainsi créés peuvent être ensuite proposés à l’équipe, en général en même temps qu’une nouvelle carte ou une carte modifiée.

Si vous avez créé ou modifié des textures, il ne faudra pas oublier de convertir les textures pour que celles-ci soient également compatible avec le jeu.

Installation du script d'export

Après avoir téléchargé le script, copiez le dans le répertoire des scripts de Blender

Sous Linux : dans $HOME/.blender/scripts
Sous Windows : dans C:\Program Files\Blender Foundation\.blender\scripts ou dans le dossier spécifié dans les préférences de l’utilisateur.

Au prochain lancement de Blender, vous pourrez importer directement un objet du jeu grâce au menu Fichier|export

Conversion des textures dans un format compréhensible par le jeu

Le fichiers BMP utilisé dans le jeu sont au format BMP mais en mode couleurs indexées. Blender n’étant pas capable de lire ces fichiers BMP, il a fallut mettre ces textures au format RVB (Rouge Vert Bleu). Il faut donc les reconvertir en couleurs indexées, avec The Gimp par exemple, avant de pouvoir les utiliser dans le jeu.

Dans The Gimp, ouvrez l’image et dans le menu Image|mode choisissez couleurs indexées à la place de RVB. Sauvegardez l’image au format BMP.

Pour ne pas avoir de surprise, …

Import de l'objet dans Blender

Sélectionnez l’objet à exporter (clic droit)

Puis exportez l’objet au format e3d en utilisant le menu Fichier|export|Eternal lands files (e3d) :

Les options d’export sont :

GZIP Compression : Permet de compresser le fichier e3d au format GZIP (plus performant que ZIP en terme de compression et surtout libre de droit).
Save Normals : Permet de sauvegarder en plus du mesh, les normales de son maillage (triangle). Cette option doit être absolument sélectionnée (bouton gris foncé) car elle impacte le rendu de la lumière et des transparences sur les objets dans le jeu
Save Tangentes : Option non encore activée dans la version actuelle du jeu qui permettra de sauver les tangentes de chaque point (vertex) du mesh. Si je ne me trompe pas, cela devrait permettre d’avoir un rendu plus adouci notamment avec les formes rondes (tonneaux, vases, sphères, …)

Un deuxième bloc d’option permet d’indiquer sur quelle texture on peut appliquer des transparences (remplacement de la couleur noire). Dans le cas de notre tapisserie, nous allons sélectionner la texture tapestry5.bmp pour la rendre transparente et donc faire disparaître les contours noir.

Une fois les options choisies, cliquez sur le bouton export et indiquez le nom du nouveau fichier e3d.

Installation des fichiers dans les répertoires du Jeu

Pour pouvoir utiliser ce nouvel objet, rien de plus simple, il suffit de copier le fichier e3d et ses textures dans l’un des sous-répertoires du répertoire 3dobjects. Si vous ne savez pas lequel, demandez conseil à l’équipe lors de la proposition de l’objet.

Surtout n’utilisez pas de nom de fichier existant (fichiers e3d ou bmp), à moins de vouloir le remplacer complètement dans la totalité du jeu.

Pour utiliser ce nouvel objet, à partir de l’éditeur de carte, il faut passer en mode objet 3D (outil cube) et faire nouvel objet (outil flèche noire avec une étoile blanche). Une fenêtre apparaît alors et vous pouvez aller chercher l’objet dans le répertoire où il a été copié.

Fichiers du jeu à modifier :

3dobjets.txt : Permet de donner la description de l’objet quand on clique avec l’œil dessus dans le jeu. Exemple :

\[name\]
file_name: tapestry5.e3d
object_name: Vous voyez une tapisserie du Terd Seglet.
\[/name\]

browser.lst : Permet de rajouter l’objet dans le menu du CONTROL-B de l’éditeur de carte. Exemple :

Category Etory
SubCategory Tapisserie et Banniere
Tapisserie du Terd Seglet,/3dobjects/etory/tapestry5.e3d,0,0,30,4.0

harvestable.lst : liste des objets pouvant être récolté (curseur pioche quand il survole l’objet)
entrable.lst : liste des objets pouvant servir d’entrée (curseur porte quand il survole l’objet)

Le fichier e3dlist.txt serait devenu obsolète.

Importer des meshes Cal3D dans Blender

anonymous@undisclosed.example.com (Anonymous) — Sat, 13 Aug 2011 12:59:59 +0000

Importer des meshes Cal3D dans Blender

On a vu qu’il était possible facilement d’importer ou d’exporter des objets statiques E3D dans Blender et donc de créer de nouveaux objets pour le jeu.

Par contre si il existe un script d’export Blender vers Cal3D, l’inverse n’existe pas. Après plusieurs recherches sur la toile, j’ai bien trouvé 2 programmes qui sont capables de convertir les fichiers meshes (cmf ou xmf) dans un autre format 3D importable dans Blender. Le hic est que ces programmes ne sont capables que de récupérer simplement le mesh mais pas l’UV mapping (la texture) sans compter la perte de l’armature (squelette).

Comment importer le mesh et la texture d'un fichier CMF

Connaissant le format du fichier CMF (cf le format des fichiers Cal3D ), j’ai écrit un petit programme en langage python (mais indépendant de Blender) qui permet de convertir le fichier CMF en format OBJ utilisé par Wavefront et facilement importable dans Blender. L’intérêt de ce format est qu’il est en format texte et qu’il permet de conserver les informations de texture uv mapping.

téléchargement : conv_cmf_obj_0.2.zip

Pour l’utiliser, il faut installer python (site officiel) et lancer la commande

python conv_cmf_obj.py nom_du_fichier.cmf

le programme a été testé sous Linux et Windows mais devrait fonctionner sous MacOSX. Pour windows, il faudra ajouter le chemin du programme python.exe. Exemple :

c:\python25\python.exe conv_cmf_obj.py nom_du_fichier.cmf

Limitations

Le format OBJ ne permet pas de gérer les animations et les armatures (squelettes) donc ces informations ne sont pas reprises dans la conversion.
Le format Cal3D permet de gérer plusieurs couches de textures uv mapping mais pas le format OBJ donc un objet avec plusieurs textures superposées ne peuvent être convertis pas ce programme.

Importation dans Blender

Dans Blender, il suffit d’importer l’objet par le menu fichier|importer|Wavefront (.obj). Choisissez le fichier et importer le (les options par défaut sont correctes).

A noter que le programme conv_cmf_obj.py repositionne correctement l’objet dans l’espace ( z|_ x ) pour que vous ne soyez pas obligés de faire une rotation après l’import dans Blender.

Sélectionnez l’objet (clic droit) et choisissez le mode Face UV

toutes les faces sont sélectionnées par défaut, changez le type de la fenêtre en Editeur UV/image :

On voit donc la mise à plat du mesh sur la texture UV. Dans le sous menu Image, ouvrez une image pour affecter un fichier BMP à votre texture et le tour est joué.

Et ensuite

Ensuite, il faudra ré-associer le mesh avec le squelette … enfin quand on aura réussi à l’importer d’une manière ou d’une autre.

Importer un objet statique (e3d) dans Blender

anonymous@undisclosed.example.com (Anonymous) — Sat, 13 Aug 2011 12:59:59 +0000

Importer un objet statique (e3d) dans Blender

Grâce au script el3d_import.py, il est possible d’importer des objets du jeu dans le logiciel Blender.

Ensuite vous pourrez soit les modifier ou soit les utiliser dans d’autres objets.

Le soucis vient de l’incompatibilité des formats de fichiers texture géré par Blender et par Landes Eternelles. Il faut donc utiliser une astuce pour pouvoir afficher correctement les textures des objets importés dans Blender.

Installation du script d'import

Après avoir téléchargé le script, copiez le dans le répertoire des scripts de Blender

Sous Linux : dans $HOME/.blender/scripts
Sous Windows : dans C:\Program Files\Blender Foundation\.blender\scripts ou dans le dossier spécifié dans les préférences de l’utilisateur (fenêtre User Preferences, bouton File Paths, champ texte Python:).

Au prochain lancement de Blender, vous pourrez importer directement un objet du jeu grâce au menu File|import

Récupération de l'objet et de ses textures

Tout d’abord, ne travaillez pas sur les fichiers du jeu sinon vous risquez d’avoir des problèmes avec le jeu. Nous allons donc créer un répertoire de travail et y placer notre fichier e3d ainsi que ses fichiers textures.

Copions-y le fichier house32.e3d contenu dans le répertoire 3dobjects/structures du jeu. Pour connaître les fichiers de texture nous allons ouvrir le fichier avec un éditeur hexadécimal comme ghex ou khexedit sous Linux ou notepad++ sous Windows.

Allez à la fin du fichier et remontez progressivement pour trouver tous les fichiers BMP utilisés comme texture. Exemple :

Le fichier house32.e3d utilise les fichiers textures suivants :

stucco3.bmp
shingles6.bmp
doorwindows8.bm
stonewall5.bmp

Ces fichiers sont dans le même répertoire que le fichier e3d. Copiez ces fichiers dans le répertoire de travail et vous devez obtenir ça :

Conversion des textures dans un format compréhensible par Blender

Le fichiers BMP utilisé dans le jeu sont au format BMP mais en mode couleurs indexées. Blender n’est capable de lire que les fichiers BMP au format RVB (Rouge Vert Bleu), il faut donc les convertir, avec The Gimp par exemple, avant de les utiliser.

Dans The Gimp, ouvrez l’image et dans le menu Image|mode choisissez RVB à la place de couleurs indexées. Sauvegardez l’image au format BMP.

A noter que si vous modifiez une texture, il ne faut pas oublier de reconvertir cette texture en mode couleurs indexés sinon les couleurs seront faussées dans le jeu.

Import de l'objet dans Blender

Ouvrez Blender et vous obtiendrez la scène par défaut de Blender :

Appuyez sur la touche suppr pour effacer le cube de la scène par défaut (clic droit sur le cube pour le sélectionner avant si besoin est). Puis importez le fichier e3d en utilisant le menu File|import|Eternal lands files (e3d) :

Cliquez sur le bouton Import e3d après avec avoir sélectionné le fichier house32.e3d. Le script vous pose alors la question load file ou load dir. Répondez load file et vous obtenez alors la scène suivante :

Ensuite

Et bien dans le prochain article nous verrons comment changer certaines textures d’un objet existant (par exemple pour créer une nouvelle maison avec des murs différents ou des toitures différentes). Puis nous verrons comment l’exporter à nouveau au format du Jeu pour pouvoir l’utiliser dans l’éditeur de carte du jeu.

Scripts Blender

anonymous@undisclosed.example.com (Anonymous) — Sat, 24 Aug 2013 15:11:01 +0000

Scripts Blender

Blender est un logiciel Open Source qui permet de réaliser des objets et scènes en 3D.

L’artiste de Eternal Lands, Roja, utilise Blender pour réaliser les objets 3D et les créatures qui peuples le monde de Landes Eternelles.

Il existe 2 types d’objets :

Les objets inanimés qui sont utilisés pour créer les cartes
Les personnages, les équipements et les créatures qui peuplent le jeu

Les objets inanimés

Les scripts Blender qui permettent d’importer et d’exporter les objets de LE sont :

el3d_export.py: pour exporter un objet créé dans Blender dans un fichier compréhensible par le jeu.
el3d_import.py : pour importer un objet du jeu dans Blender afin de pouvoir le modifier. Attention, si vous voulez importer les textures dans Blender alors il faut convertir les fichiers BMP en couleur indexé en fichier BMP RVB (en utilisant The Gimp par exemple). Si vous ne faites pas cela, Blender ne sera pas capable d’importer les textures.(Les textures sont aujourd’hui gérée en .dds et peuvent etre importée de la sorte dans blender)

L’intérêt de ces scripts Blender est de pouvoir créer (à partir de zéro ou d’un objet existant) de nouveaux objets pour réaliser des cartes.

Depuis les modifications du client sur les e3d, cartes etc… (à partir de la version 1.6.2), il faut de nouveaux scripts d’import/export adaptés que vous trouverez ici :

el3d.zip: tout le contenu de l’archive doit être copié dans le dossier “scripts” de Blender.

Il faut également rester sur la version 2.49b de Blender au maximum, et utiliser Python 2.5 ou 2.6 (selon ce que Blender demande lors du chargement).

Les personnages et les créatures

Le jeu utilise la bibliothèque Cal3d pour gérer toutes les créatures capables de se mouvoir. Cette bibliothèque gère ces objets sous un format de fichier différent de celui des objets inanimés. En fait, il y a plusieurs fichiers pour une créature : un ou plusieurs fichiers de meshes (la forme en 3d), un fichier squelette (les articulations), plusieurs fichiers d’animation du squelette (les gestes qu’il peut faire).

Il existe un script (blender2cal3d_EL.py) qui permet de convertir une créature créée sous Blender en fichiers compréhensibles par le jeu.

L’inverse (jeu vers Blender) n’est pas possible ou tout au moins ce n’est pas évident à faire.

L’intérêt de ce script est de pouvoir créer de nouvelles créatures et de nouveaux équipements (habits, armures, armes, outils). Attention c’est plus difficile à faire que pour les objets inanimés.

A noter que les scripts disponibles ici ont été trouvé sur le forum du jeu anglophone Eternal Lands.

Le squelette d'un avatar ou d'une créature

anonymous@undisclosed.example.com (Anonymous) — Sat, 13 Aug 2011 12:59:59 +0000

Le squelette d'un avatar ou d'une créature

Actuellement, le seul moyen de donner vie à vos avatars et aux créatures est de créer des animations dans Blender et de les exporter au format Cal3D.

Tous les squelettes sont définis du côté client dans les fichiers au format .CSF du répertoire skeletons. Ce fichier étant au format binaire, il n’est pas humainement lisible. Cal3D offre des outils pour convertir ces fichiers en format XML (humainement lisible … enfin supposé l’être).

Vous trouverez les programmes de conversion déjà compilé pour windows ici.

Nous allons dans un premier temps essayer de comprendre comment fonctionnent les animations dans le jeu.

Le squelette et les os

Non, il ne s’agit pas de ne parler que des mort-vivants mais aussi de toute les créatures des Landes, avatars compris. En fait, pour pouvoir animer un objet 3D aussi complexe qu’une créature, il convient de lui associer un squelette. Le squelette est composé d’os et d’articulations permettant de bouger telle ou telle partie du corps. Les squelettes ont été créés dans Blender et pour chaque créature on a associé telle ou telle partie du mesh à un os.

Roja, l’artiste de la version US, a préféré ne créer que quelques squelettes lui permettant ainsi de limiter le nombre d’animation à créer. On retrouvera donc les squelettes par catégorie, par exemple le fichier medium.csf est utilisé par tous les avatars quelques soient leurs races et leurs tailles. L’avantage est qu’il n’a créé qu’une seule animation pour saluer, par exemple, qui s’appliquera à tous les avatars.

exemple, le squelette des avatars :

Chaque os possède un nom pour faciliter le travail de l’animateur (celui qui va créer les mouvements, pas les animateurs du jeu). Ces noms sont connus dans Blender et mais dans les fichiers Cal3D on utilise également un identifiant numérique. Cet identifiant numérique est utilisé à la fois dans les meshes et dans les animations.

Actuellement, il y a 19 squelettes différents dans le jeu :

bear.csf : les ours.
bird.csf : les aigles, les faucons.
bird2.csf : les cockatrices
boar.csf : les sangliers.
canine.csf : les chimériens, les renard, les loups.
deer.csf : les cerfs.
dragon.csf : les dragons (non utilisés).
feline.csf : Les férans, les leopards, les lions, les panthères, les pumas, les tigres.
gargoyle1.csf : non utilisés.
horse.csf : les chevaux (non utilisés), les licornes.
medium.csf : les Nains, Les Elfes, les Humains (homme bleu inclus), les Kultars (fichiers nommés gnome), les Galdurs (fichiers nommés orchan) et les Draegonites (non utilisé dans la VF).
monster1.csf : les lutins, les cyclopes, les démons D’jhis (feros), les gargouilles, les Géants, les goblins, les hobgoblins, les farfadets, les leprechauns, les ogres, Les orcs, les combattants fantômes, les squelettes, les trolls, les diablotins, les yetis.
penguin.csf : les pingouins.
puma.csf : non utilisé.
rabbit.csf : les lapins, les démons lapins.
rat.csf : les rats, les castors, les raton-laveurs, les putois.
snake.csf : les serpents.
spider.csf : les araignées.
wraith.csf : l’Esprit, celui qui donne la force et la volonté de vaincre les Landes…

Au niveau du jeu, c’est dans les fichiers XML du répertoire actor_defs que l’on associe le fichier squelette (CSF) au fichier mesh (CMF). En fait ces fichiers XML définissent tout les avatars, les équipements et les créatures du jeu.

Pour associer un squelette à un mesh :

 <actor type="beaver" id="8">
 	<skin>./meshes/animals2.bmp</skin>
 	<skeleton>./skeletons/rat.csf</skeleton>
         <mesh>./meshes/beaver.cmf</mesh>
 	<scale>1.6</scale>
 	<bone_scale>1.6</bone_scale>
 ...
 ...
 </actor>

Dans cet exemple, on associe le mesh beaver.cmf avec la texture animal2.bmp et le squelette rat.csf. On remarquera les mots clés scale et bone_scale qui servent à mettre à l’échelle le mesh et le squelette (ici un castor est 1,6 fois plus grand qu’un rat).

Conversion du fichier de squelette au format XSF (forme XML du CSF)

Le fichier CSF peut être converti au format XSF par la commande suivante :

cal3d_converter medium.csf meduim.xsf

Vous obtenez un fichier contenant (Début seulement car le fichier fait 13ko) :

 <SKELETON VERSION="1000" NUMBONES="30">
     <BONE ID="0" NAME="root" NUMCHILDS="3">
         <TRANSLATION>0.00216135 0.000226406 0.780926</TRANSLATION>
         <ROTATION>0.706989 -0.0128938 0.00183134 -0.707104</ROTATION>
         <LOCALTRANSLATION>-0.018419 -0.780712 0.00026022</LOCALTRANSLATION>
         <LOCALROTATION>-0.706989 0.0128938 -0.00183134 -0.707104</LOCALROTATION>
         <PARENTID>-1</PARENTID>
         <CHILDID>1</CHILDID>
         <CHILDID>6</CHILDID>
         <CHILDID>11</CHILDID>
     </BONE>
     <BONE ID="1" NAME="hipR" NUMCHILDS="1">
         <TRANSLATION>-0.012525 0.143171 -0.000657582</TRANSLATION>
         <ROTATION>-0.174697 0.00373261 0.890854 -0.41934</ROTATION>
         <LOCALTRANSLATION>-0.685893 0.603218 -0.138829</LOCALTRANSLATION>
         <LOCALROTATION>-0.161447 0.632912 -0.631081 -0.418442</LOCALROTATION>
         <PARENTID>0</PARENTID>
         <CHILDID>2</CHILDID>
     </BONE>
     <BONE ID="2" NAME="thighR" NUMCHILDS="1">
         <TRANSLATION>-0.000194804 0.132073 -0.000106222</TRANSLATION>
         <ROTATION>-0.418871 0.890689 0.0999228 -0.145722</ROTATION>
         <LOCALTRANSLATION>0.125751 0.820266 0.150843</LOCALTRANSLATION>
         <LOCALROTATION>0.777087 1.34489e-006 -0.0124644 -0.62927</LOCALROTATION>
         <PARENTID>1</PARENTID>
         <CHILDID>3</CHILDID>
     </BONE>
     <BONE ID="3" NAME="calfR" NUMCHILDS="1">
         <TRANSLATION>6.68953e-017 0.301088 -1.41312e-016</TRANSLATION>
         <ROTATION>0.195613 0.0100634 -0.0112865 -0.980565</ROTATION>
         <LOCALTRANSLATION>0.112602 0.540425 -0.0580916</LOCALTRANSLATION>
         <LOCALROTATION>0.639016 1.17141e-006 0.00270002 -0.769189</LOCALROTATION>
         <PARENTID>2</PARENTID>
         <CHILDID>4</CHILDID>
     </BONE>
 ...
 ...
 </SKELETON>

On trouve comme information :

BONE : définition de chaque OS avec son identifiant (ID=0, 1, …), son nom Blender et le nombre d’os fils (NUMCHILDS).
- Déplacement de l’os par rapport à son père.
  - TRANSLATION : déplacement selon les axes X, Y et Z par rapport à l’os père
  - ROTATION : rotation par rapport à l’os père stockée comme quaternion
- Transformation à apporter aux points du mesh par rapport à l’os
  - LOCALTRANSLATION : déplacement selon les axes X, Y et Z.
  - LOCALROTATION : rotation stockée comme quaternion
- PARENTID : Numéro ID de son os père (-1 si pas de père)
- CHILDID : Numéro ID de l’os fils, il y a un paramètre CHILDID par fils (NUMCHILDS).

Ce qui peut nous intéresser dans ce fichier c’est l’organisation des os de père en fils car le reste c’est plus pour les matheux. Nous laisserons Blender faire la partie mathématique pour nous.

Ce qui nous donne dans l’exemple ci-dessus :

root (Id=0) : départ du squelette (ici on pourrait dire que c’est le nombril).
- hipR (Id=1) : Hanche droite.
  - thighR (Id=2) : Cuisse droite
    - calfR (Id=3) : Jambe droite
      - … (Id=4) : Cheville droite
… (Id=6) …
- …
… (Id=11) …
- …

Les fichiers squelettes ne sont pas à modifier mais comprendre leurs fonctionnement, ainsi que les os qui les composent, permettra de passer à l’étape suivante : les fichiers d’animation d’un avatar ou d’une créature.

Les images viennent de la version US, il y a donc quelques os en plus comme arrow pour le carquois de flèches et ne sont pas (encore) dans le modèle actuellement géré par le jeu Landes Eternelles’’.

Informations sur les quaternions

http://www.euclideanspace.com/maths/algebra/realNormedAlgebra/quaternions/index.htm

q = cos(a/2) + i ( x * sin(a/2)) + j (y * sin(a/2)) + k ( z * sin(a/2))

où :

a=angle of rotation.
x,y,z = vector representing axis of rotation.

q = w + x i + y j + z k

Conversion en angle :

angle = 2 * acos(qw)
x = qx / sqrt(1-qw*qw)
y = qy / sqrt(1-qw*qw)
z = qz / sqrt(1-qw*qw)

programme php :

<?php
 
$qx=-0.161447;
$qy=0.632912;
$qz=-0.631081;
$qw=-0.418442;
 
$angle = 2 * acos($qw);
$x = $qx / sqrt(1-$qw*$qw);
$y = $qy / sqrt(1-$qw*$qw);
$z = $qz / sqrt(1-$qw*$qw);
 
echo "$angle $x $y $z";
 
?>

Modélisation d'une table lowpoly pas à pas (partie 1)

anonymous@undisclosed.example.com (Anonymous) — Sat, 13 Aug 2011 12:59:59 +0000

Modélisation d'une table lowpoly pas à pas (partie 1)

Pour commencer nous allons modéliser un objet composée de primitives simples : une table.

Dans le jeu, il existe déjà quelques tables de tailles et de formes diverses.

Nous allons nous attacher à créer une table un peu plus réaliste que les tables rectangulaires déjà existantes.

Construire une table avec Blender est assez simple mais nous allons passer par une étape préalable, la réalisation d’une esquisse.

Pourquoi une esquisse ?

Bien sûr pour une forme simple, faire une esquisse peut paraître inutile mais, si vous n’êtes pas familier des logiciels 3D, l’esquisse vous permettra de visualiser votre objet dans les vues 3D.

Pour faciliter les choses, l’esquisse doit représenter notre objet sous 3 vues différentes afin de dimensionner et de placer correctement les différentes parties de notre objet. En fait cette esquisse, au moins pour les objets simples, se rapprochera des techniques de dessin industriel où l’on représente sur un calque la vue de face, la vue de côté et la vue de dessus (ou dessous selon la partie la plus intéressante pour la modélisation).

Cette esquisse peut être faite à la main (et scannée), dans un logiciel de 2D bitmap (exemple The Gimp) ou dans un logiciel de dessin vectoriel (exemple Inkscape).

Pour ma part j’ai utilisé Inkscape, logiciel de dessin vectoriel Open Source.

Comment dimensionner notre table ?

Je voulais avoir une table de la même taille que la table de l’auberge de Reca, j’ai donc importé l’object e3d dans Blender. Ensuite sur une fenêtre 3D je me suis mis en vue orthogonale et fait une copie d’écran (CTRL F3) pour chaque vue : face, dessus et côté. Il est impératif de ne pas changer ni la taille de la fenêtre ni son zoom sinon nous auront un problème d’échelle. Le changement se fait par le menu vue de la fenêtre (ici en bas à droite dans le bandeau de la fenêtre 3D de Blender).

En plus avec la grille de Blender, ces copies d’écran nous servirons à dimensionner correctement l’esquisse pour en faire un gabarit de modélisation.

J’ai ensuite importé dans Inkscape chaque image pour re-dessiner une vue de type dessin industriel de la table :

Note : la diagonale bleu ne sert que pour reporter correctement les dimensions entre la vue de dessus et la vue de côté.

Si vous faite le dessin à la main (papier crayon), imprimez ces 3 images à la même échelle (impératif) et utilisez du papier calque.

Création de l'esquisse

J’ai utilisé mes anciennes connaissances de dessin industriel pour dessiner dans Inkscape l’esquisse de notre nouvelle table :

Les horizontales et verticales bleus permettent de s’assurer que les objets sont bien positionnés et de la bonne taille dans chacune des vues. J’ai également triché sur la vue de dessus pour faire apparaître (par transparence … ;) ) le dessous de la table (les pieds et les barres).

Le résultat obtenu est :

Le dessin est ensuite exporté en format jpg, png ou autre bitmap pour servir d’image d’arrière plan dans Blender.

Le gabarit à importer est :

Note : sur l’esquisse il manque deux barres de pieds dans la vue de dessus.

Si vous avez fait votre esquisse à la main, prêtez une attention particulière à la façon dont est placée votre feuille de papier lors du scan du document. Si la feuille n’est pas parfaitement perpendiculaire alors il faudra redresser correctement votre dessin avec un logiciel comme The Gimp avant de pouvoir l’utiliser comme Gabarit dans Blender.

Préparation dans Blender

D’abord, modifiez votre espace de travail pour obtenir 3 vues 3D. Personnellement j’ai fait 2 grandes vues, face et côté, et une petite vue pour la vue de dessus afin de contrôler le bon positionnement des objets dans l’espace par rapport au gabarit de la table.

Dans chacune des vues il faudra spécifier l’image d’arrière plan, la mettre à la bonne taille et la déplacer au bon endroit. Pour cela dans le menu vue de la fenêtre 3D, cliquez sur image d’arrière plan et chargez l’image (load).

Pour information voici les paramètres adéquates pour que notre esquisse puisse être utilisée comme gabarit :

Vue de face :

Vue de côté :

Size : mise à l’échelle du gabarit pour que la taille soit correcte par rapport à la taille de l’objet dans Blender (et donc dans le jeu)
X offset et Y offset : déplacement du gabarit pour placer correctement l’objet selon la vue.

J’ai utilisé les captures de la table originale pour placer correctement le gabarit de ma table dans l’espace.

Comme entraînement je vous laisse placer le gabarit dans la vue de dessus

Ensuite

Dans la deuxième partie de cet article nous verrons comment modéliser simplement notre table à partir de la primitive cube dans Blender.

Gestion des textures pour les avatars

anonymous@undisclosed.example.com (Anonymous) — Fri, 18 Apr 2014 20:29:13 +0000

Gestion des textures pour les avatars

Dans le jeu, les créatures (monstres ou animaux) utilisent tous des textures d’une taille de 512×512 pixels. Suivant la complexité de la créature et sa taille, on trouvera sur un fichier DDS de 1 à plusieurs créatures.

Pour les personnages, là on trouve dans le répertoire meshes une multitude de petits fichiers DDS, l’un étant la texture d’un bras, l’autre le pantalon, etc …

Chose étonnante, leur tailles qui n’ont rien à voir avec les valeurs puissance 2 (comme on le voit beaucoup en informatique). En fait cela cache une astuce que nous allons découvrir ici.

Cet article a été tiré à l’origine de l’ancien blog d’Etory (Terd Seglet). Il est à compléter et à corriger si besoin est.

Les textures des objets Cal3D dans LE

La plupart des cartes graphiques 3D permettent de gérer des textures que l’on applique sur les triangles composant les meshes. Pour cela on aplatit le maillage pour pouvoir indiquer les textures de chaque triangle. Pour ceux qui seraient intéressés, cette technique est appelée UV mapping (lien en anglais). Ces textures ont pour tailles maximales 256×256, 512×512 ou 1024×1024 suivant la puissance de la carte graphique. Il est à noter que si les cartes modernes acceptes des textures de taille différente de 2^X, ce n’est pas la cas des cartes plus anciennes. Dans le jeu, les textures les plus grandes font 512×512 pour fonctionner avec le maximum de carte même plus ancienne mais aussi pour des questions de place mémoire (256×256 prend 4 fois moins de place en mémoire que 512×512 par exemple).

Par exemple la texture pour les tigres est :

Cette texture est commune au deux tigres (normal et des neiges). Chose intéressante également est que la texture sera plaquée de chaque côté du tigre de manière symétrique afin de gagner de la place sur la texture.

Donc chaque créature est décorée comme cela dans le jeu.

Et les avatars et leurs équipements ...

Oui les avatars eux aussi utilisent le même principe de texture mais avec une astuce supplémentaire. Comment faire cohabiter différentes couleurs de peau, différentes armures ou chemises, différents pantalons et bottes, etc … sur une texture de 512×512 pixels.

Les combinaisons sont multiples et si on devait créer une texture pour chacune d’elles, le jeu serait trop gros à télécharger.

D’abord voyons quelles sont les textures qui compose un avatar :

un couvre-chef: un casque, chapeau	une tête	les cheveux	le torse
les bras	les mains	les jambes	les bottes
l’arme	le bouclier	la cape

Et un jour peut être le carquois de flèches. Les US gère la texture du carquois et des flèches dans l’emplacement du bouclier car il est vrai qu’il est impossible de se servir d’un arc quand on porte un bouclier. Comme pour le tigre, on retrouve ici le principe de symétrie dans les textures. Par exemple le côté gauche du torse est la symétrie du côté droit, pareil pour le visage, le pantalon …

Cela permet de gagner de la place mais au détriment de l’apparence de l’avatar. Par exemple, n’espérez pas mettre un beau blason de lion sur votre torse car celui-ci n’est pas symétrique. Dommage mais bon c’est comme ça.

Oui mais la texture 256x256 c'est où ?

Et bien l’astuce est dans le programme du client, plus exactement dans la fonction load_bmp8_enhanced_actor du fichier textures.c (dans le code source du client).

Cette fonction va, pour chaque avatar affiché à l’écran, reconstituer la texture 256×256 à partir des caractéristiques de l’avatar et de son équipement. En fait la texture reconstituée est la suivante :

Ce programme recrée la texture ci-dessus en plaçant les différents fichiers textures dans les positions suivantes :

pantalons (pants) : 78,175
bottes (boots) : 0,175
torse (torso) : 158,149
manches (arms) : 0,96
mains (hands) : 67,64
tête (head) : 67,0
cheveux (hair) : 0,0
arme (weapon) : 178,77
bouclier (shield) : 100,77
casque (helmet) ou chapeau (hat): 80,149
cape : 131,0

exemple :

Cela explique la taille de chaque texture individuelle. Il ne reste d’ailleurs plus beaucoup de place (zone blanche) pour rajouter de nouveaux objets sur les avatars. Créer de nouveaux équipements, impose de se conformer à ces tailles de texture. Toutes les armes ou les boucliers, par exemple, devront avoir une texture de 78×72 quelque soit la taille du mesh par rapport au reste de l’avatar.

Ce sont des limitations imposées par le programme et si on devait les modifier, il faudrait modifier cette fonction load_bmp8_enhanced_actor du programme client.

Créer un nouveau bouclier en modifiant une texture

anonymous@undisclosed.example.com (Anonymous) — Sat, 13 Aug 2011 12:59:59 +0000

Créer un nouveau bouclier en modifiant une texture

La modélisation de nouveaux objets “portables” par les avatars est complexe notamment si l’on ne dispose pas des objets au format Blender. Pour contourner ce problème, il est possible de créer de nouveaux objets à partir d’objet existant en modifiant simplement leur texture.

Partant du constat que tous les boucliers ronds du jeu utilisent la même mesh (objet en 3D), nous allons montrer comment créer un nouveau bouclier rond avec de belles armoiries.

Exemple de modification de la texture d’un objet existant.

Tous les objets utilisent des textures au format BMP (compression RLE et palette de couleur). Il est donc facile de modifier leur apparence en modifiant l’image utilisée dans la texture.

Cet article a été tiré à l’origine de l’ancien blog d’Etory (Terd Seglet). Il est à compléter et à corriger si besoin est.

Avertissement

Avant tout, il faut bien comprendre que ce que l’on crée ne peut pas se retrouver comme par magie dans le jeu. Il y a le côté serveur qui est géré par les administrateurs et développeurs du jeu et le côté client. Un objet ne peut se trouver dans le jeu que si les développeurs le crée côté serveur et là on ne peut rien y faire.

Donc, ce que nous allons faire c’est montrer comment créer de nouveaux objets afin de pouvoir les proposer aux administrateurs du jeu. On va créer des boucliers mais la même technique pourrait s’appliquer aussi à des habits et autres objets.

Introduction : la description d'un objet équipable, d'un avatar ou d'un monstre

Description des objets côté client

Les avatars et les objets équipables sont au format CALD3D. Il sont composés de plusieurs fichiers :

Un ou plusieurs fichiers de meshes (forme 3D), meshes étant un terme anglo-saxon d’infographie désignant le maillage composant la forme de l’objet. Ces fichiers sont dans le répertoire meshes du jeu et sont au format CMF (extension .cmf).
Un ou plusieurs fichier de textures au format BMP. Il y a un fichier de texture par fichier de meshes et ils sont également dans le répertoire meshes du jeu.
Un fichier squelette au format CSF. Ces fichiers sont comme leurs noms l’indiquent les squelettes des avatars et des monstres utilisés lors des animations (marche, combat, salut, etc …). Ils sont stockés dans le répertoire skeletons.
Des fichiers d’animations (un par type de mouvement) au format CAF. Ces fichiers indiquent comment animer le squelette d’un avatar ou d’un monstre. Ils sont stockés dans le répertoire animations du jeu.

Pour permettre de fédérer tout cela, il y a un autre type de fichier (au format XML) qui permet d’associer les meshes, les textures, les squelettes et les animations afin de donner vie aux créatures et avatars du jeu. Ces fichiers stockés dans le répertoire actor_defs permettent de définir tous les êtres vivants (ou mort vivant) et leurs équipements. C’est en consultant le fichier shield.xml que l’on va pouvoir voir comment sont créés les boucliers du jeu (enfin d’un point de vue graphique car le reste est géré au niveau du serveur).

Le fichier "shield.xml"

 <shield type="wood" id="0">
        <mesh>./meshes/shield1.cmf</mesh>
        <skin>./meshes/shield1_wood1.bmp</skin>
        <glow>none</glow>
 </shield>
 
 <shield type="wood enhanced" id="1">
        <mesh>./meshes/shield1.cmf</mesh>
        <skin>./meshes/shield1_wood2.bmp</skin>
        <glow>none</glow>
 </shield>
 
 <shield type="iron" id="2">
        <mesh>./meshes/shield1.cmf</mesh>
        <skin>./meshes/shield1_iron.bmp</skin>
        <glow>none</glow>
 </shield>
 
 <shield type="steel" id="3">
        <mesh>./meshes/shield1.cmf</mesh>
        <skin>./meshes/shield1_steel.bmp</skin>
        <glow>none</glow>
 </shield>
 
 <shield type="titanium" id="4">
        <mesh>./meshes/shield2.cmf</mesh>
        <skin>./meshes/shield2_titanium.bmp</skin>
        <glow>none</glow>
 </shield>
 
 <shield type="bronze" id="5">
        <mesh>./meshes/shield3.cmf</mesh>
        <skin>./meshes/shield3_bronze.bmp</skin>
        <glow>none</glow>
 </shield>

On constate que les 4 premiers boucliers (bois, bois renforcé, fer et acier) sont tous basés sur le même meshes ( shield1.cmf ) mais chacun avec untre textu (skin) différente. Sur se principe on voit qu’il est possible de rajouter facilement (d’un point de vue graphique) un nouveau bouclier rond en utilisant une autre texture. C’est comme cela que les armures en cuir Sinan ont été créées à partir des armures en cuir normal.

Création du bouclier

Première tentative

Allez je me suis lancé dans le test et j’ai créé en prenant exemple sur la texture du bouclier en acier une nouvelle texture :

Le bouclier d’origine : en acier et le premier essai :

Pour tester ce que cela rendait dans le jeu, j’ai simplement remplacé le fichier shield1_steel.bmp par le nouveau et j’ai relancé le jeu (attention de bien sauvegarder le fichier d’origine pour le remettre après) :

Le bouclier d’origine : et le nouveau :

Super (à part une mauvaise orientation) me voilà avec un super bouclier à tête de mort … que seul moi peut voir ! En effet les autres joueurs continuent de voir le bouclier en acier standard.

Autres exemples

Voici d’autres exemples :

Bon il y a encore du travail car les textures sont trop propres pour être utilisables mais voilà le principe. A noter que sur le bouclier avec le loup, la couleur rouge a débordée sur le contour gris alors que ce n’est pas le cas sur la texture.

Conclusion

C’est de cette manière que les boucliers de peuples ont été réalisé. Enfin presque car un nouveau mesh a quand même été créé pour l’occasion afin de cacher l’arrière du bouclier et de lui donner une attache en “cuir”.

Création de nouveaux objets statiques (e3d) par modification de texture

anonymous@undisclosed.example.com (Anonymous) — Sat, 13 Aug 2011 12:59:59 +0000

Création de nouveaux objets statiques (e3d) par modification de texture

Dans l’article précédent nous avons vu comment importer dans Blender un objet statique au format e3d utilisé pour décorer les nombreuses cartes du jeu.

Le jeu propose déjà un grand nombre d’objets du plus grand (bâtiment, rempart, tour, etc …) au plus petit (verre, assiette, livre, etc …). Dans certain cas, il sera plus intéressant d’en créer de nouveaux soit pour apporter une touche d’originalité soit pour conserver une certaine cohérence avec le reste de la carte.

Parfois, l’objet qui nous intéresse existe déjà mais dans des coloris inadaptés. Ce peut être le cas des bâtiments qui en règle général utilise les mêmes pierres et les mêmes tuiles que les autres bâtiments environnant.

Nous allons voir ici comment créer de nouveaux objets en modifiant simplement une ou plusieurs de ses textures.

Introduction

Pour illustrer cet article nous allons modifier une tapisserie existante pour créer une nouvelle tapisserie avec le motif du Terd Seglet (le crane avec la larme de sang).

Dans un premier temps il faut créer la texture mais on peut simplement utiliser une texture existante pour modifier l’apparence de l’objet. C’est le cas par exemple quand on change la couleur du toit d’une maison ou la teinte du bois d’une table. Pour créer notre tapisserie, il n’y a pas de texture utilisable alors on va en créer une de toute pièce.

Création de la texture

J’ai utilisé The Gimp pour créer un motif pour notre nouvelle tapisserie :

A noter que les zones en noire devront être transparentes dans le jeu (option à l’export au format e3d).

Surtout quand vous sauvegardez au format BMP, il faut choisir les options avancées et le format 24 bits (sans canal alpha) sinon le résultat dans Blender sera surprenant.

Je ne détaille pas l’étape de création du motif car ce n’est pas le but de cet article. Vous pouvez utiliser toute sorte d’image, là j’ai réutilisé un motif déjà créé auparavant. L’idéal aurait été de créer un motif à la tablette graphique pour conserver le style “peinture” du jeu.

Importation de l'objet dans Blender

on va importer par la méthode précédemment décrite l’objet 3dobjects/interiors/tapestry2.e3d.

nous obtenons donc la scène suivante :

Sélection de la texture de l'objet

Sélectionnez l’objet tapisserie (par un clic droit sur l’objet 3d), choisissez le mode textured ( )pour voir la texture UV mapping s’afficher sur l’objet.

Passez en mode édition (edit mode) par la touche TAB et choisissez le mode UV Face Select

Vous devez obtenir cette scène

Sur une autre fenêtre de Blender, changer le type de fenêtre pour y mettre UV/Image editor

Maintenant quand vous sélectionnez un ou plusieurs triangles du mesh de l’objet (clic droit ou shift + clic droit pour sélectionner plusieurs triangles) vous voyez apparaître dans la deuxième fenêtre le fichier de texture (au format BMP) et le ou les triangles sélectionnés.

Dans la barre de la fenêtre on peut remarquer plusieurs zone intéressante :

Le nom de l’image. En fait une liste déroulante qui permet de changer la texture a appliquer au(x) triangle(s) sélectionné(s). Par défaut, pour cet objet, vous trouverez tapestry2.bmp et wooda.bmp.
Le menu image avec les options suivantes :
1. Load : qui permet de charger un fichier texture supplémentaire pour cet objet (intéressant dans le cas où l’on ne veut changer la texture que de certains triangles du mesh)
2. Replace : qui permet de changer le fichier de texture sélectionné par un autre. Dans ce cas tous les triangles du mesh ayant ce fichier de texture seront modifiés.
3. New : qui permet de créer une nouvelle texture vide (utile dans la création de nouveaux objets ou pour la création de nouvelles textures).

Remplacement de la texture

Ici on veut changer la totalité de la texture du motif de la tapisserie par un nouveau motif, nous allons donc choisir le menu image|replace, choisissez notre fichier BMP correspondant à la nouvelle texture et on obtient :

Et ensuite

Dans le prochain article nous verrons comment exporter notre objet Blender au format e3d pour pouvoir l’utiliser dans le jeu.

L’image suivante, issue de l’éditeur de carte, donne une idée du résultat de notre travail :

Création d'habits à partir de nouvelles textures

anonymous@undisclosed.example.com (Anonymous) — Sat, 13 Aug 2011 12:59:59 +0000

Création d'habits à partir de nouvelles textures

Après avoir abordé la manière dont sont composées les textures des personnages et avoir montré comment créer rapidement un nouveau bouclier, ce nouvel article vous montrera les possibilités offertes par les textures pour créer facilement de nouveaux habits en utilisant les formes de corps existantes. Nous n’aborderons pas les couvre-chefs (casque, chapeau, bandeau, masque, …), les armes ou les capes mais le principe est toujours le même.

Article en cours d’écriture

Les possibilités existantes

Dans un premier temps nous allons décrire les différentes formes d’habits existants et la manière dont ils sont implémentés dans le jeu.

Les 3 formes d'habits existantes

Les 3 formes d’habits existantes sont :

Le corps “basic”
	Il est utilisé par un grand nombre d’habit en tout genre. Des guenilles des aventuriers à leur arrivé à la tenue en peau en passant par les armures de cuir et les cottes de maille. Il a servi également à créer les 2 autres corps dont le dépliage UV de la texture est quasi identique.
Le corps avec des épaulières
	Il est utilisé par les armures de plate en métal. Le seul ajout sont les épaulières. Il est plus adapté à la réalisation d’armure que d’habit normaux.
Le corps avec des épaulières et des piques
	Il est utilisé par l’armure dragon rouge. Comme les Dragons n’existent pas (et n’existeront pas) dans LE, cette armure n’est pas disponible dans le jeu et à priori ne le sera jamais. Il est également plus adapté à la réalisation d’armure que d’habits normaux.

Comment cela se traduit-il dans les fichiers du jeu

Les fichiers objets 3D (les cmf) sont stockés dans le répertoire meshes du jeu ainsi que les images des textures. C’est donc là dedans que nous allons trouver notre bonheur.

Pour les corps nous avons un fichier cmf différent par type d’habit, par sexe et également par race. pour les différentes races c’est seulement la taille du corps qui change et donc la texture ne change pas. Autre point important c’est qu’actuellement, le fichier texture d’un habit est le même quelque soit la race mais aussi le sexe du personnage. C’est dans le répertoire actor_defs que sont décrites les associations entre les objets 3d, les textures et les “objets” du jeu. Néanmoins rien n’empêche de faire des textures plus en rapport avec le sexe du personnage mais cela nécessiterait un travail de révision de la définition des objets du jeu au niveau de l’actor_def si on veut différencier les textures hommes des textures femmes.

Dans le répertoire meshes les fichiers cmf qui nous intéressent sont :

	Humain		Elfes		Nains		Galdurs¹⁾		Kultars²⁾
	Homme	Femme	Homme	Femme	Homme	Femme	Homme	Femme	Homme	Femme
les jambes	legs1_humanm.cmf	legs1_humanf.cmf	legs1_elfm.cmf	legs1_elff.cmf	legs1_dwarfm.cmf	legs1_dwarff.cmf	legs1_orchanm.cmf	legs1_orchanf.cmf	legs1_gnomem.cmf	legs1_gnomef.cmf
le torse “basic”	torso1_humanm.cmf	torso1_humanf.cmf	torso1_elfm.cmf	torso1_elff.cmf	torso1_dwarfm.cmf	torso1_dwarff.cmf	torso1_orchanm.cmf	torso1_orchanf.cmf	torso1_gnomem.cmf	torso1_gnomef.cmf
le torse avec épaulières	torso2_humanm.cmf	torso2_humanf.cmf	torso2_elfm.cmf	torso2_elff.cmf	torso2_dwarfm.cmf	torso2_dwarff.cmf	torso2_orchanm.cmf	torso2_orchanf.cmf	torso2_gnomem.cmf	torso2_gnomef.cmf
le torse avec épaulières et piques	torso3_humanm.cmf	torso3_humanf.cmf	torso3_elfm.cmf	torso3_elff.cmf	torso3_dwarfm.cmf	torso3_dwarff.cmf	torso3_orchanm.cmf	torso3_orchanf.cmf	torso3_gnomem.cmf	torso3_gnomef.cmf

Il existe aussi des corps nommés draegoni qui correspondent à la race des Draegoni dans la version US. Ils ne sont pas utilisés dans LE.

Du côté des textures, il faut savoir qu’un objet 3d peut utiliser plusieurs textures différentes suivant la partie du corps.

Textures utilisées pour les jambes
Le pantalon / les jambes Taille 80×80	Les bottes taille 78×80
Textures utilisées pour le haut du corps
Le torse taille 98×107	Les bras taille 80×80	Les mains / les gants taille 32×32

Les images sont des fichiers BMP en mode palette (nommé aussi indexé). Elles portent le nom que l’on veut. Exemple le torse de l’armure de cuir renforcé s’appelle torso9.bmp.

Comme c’est déjà indiqué dans les articles précédents, l’apparence du personnage est symétrique. C’est un choix fait par les US pour limiter la taille des textures. Ainsi, quand vous faites votre texture n’oubliez pas que :

la texture du torse est symétrique c’est à dire que la partie droite est un miroir de la partie gauche. Donc vous ne pourrez pas mettre d’armoiries à moins que celles-ci soient également symétriques.
la texture du bras correspond à celle d’un seul bras. Les deux bras utilisent la même texture.
la texture du pantalon est également symétrique.

Comment tester un nouvel habit

Il est fortement conseillé d’installer un 2ième client LE dans un autre répertoire et de ne faire les modifications que dans celui-ci. Le premier client vous servira pour jouer, le deuxième pour tester. En effet, si vous modifiez mal les fichiers Actor_defs vous pouvez planter votre client et cela vous empêchera de jouer. Dans tous les cas, si vous modifiez un fichier du client, sauvegarder le fichier d’origine sous un autre nom. Ceci est valable également pour la création ou la modification d’objets 3d ou de cartes

Pour tester un habit, vous avez 2 méthodes :

Posséder un habit de la même forme que celui désiré et copier les textures dans le client avec le nom des textures de cet habit. Par exemple, pour tester sur un haut en cuir renforcé, remplacez les textures torso9.bmp et arms9.bmp par vos images de textures.
Modifier dans l’actor_defs la définition d’un habit en y plaçant les bons noms de textures et de cmf.

Exemple de modification de //l'actor_defs// en prenant comme base de test l'armure de cuir renforcée

Dans player_shirts.xml, la définition de la veste de l’armure de cuir renforcée est

<shirt color="augmented leather" id="17">
	<arms>./meshes/arms9.bmp</arms>
	<torso>./meshes/torso9.bmp</torso>
</shirt>

Pour changer le nom du fichier texture, il suffit de changer les noms des fichiers BMP.

Pour changer la forme du torse, il suffit de modifier aussi ce fichier en ajoutant le texte group=“torso2” ou group=“torso3” comme dans l’exemple suivant :

<shirt color="augmented leather" group="torso2" id="17">
	<arms>./meshes/arms9.bmp</arms>
	<torso>./meshes/torso9.bmp</torso>
</shirt>

Dans player_legs.xml, la définition du pantalon de l’armure de cuir renforcée est

<legs color="augmented leather" id="15">
	<skin>./meshes/pants6.bmp</skin>
	<glow>none</glow>
</legs>

Dans player_legs.xml, la définition des bottes de cuir est

<boots color="leather" id="6">
	<skin>./meshes/boots2.bmp</skin>
	<glow>none</glow>
</boots>

Modifier l'apparence de sexe ou de race

C’est possible, il suffit simplement de remplacer le fichier XML définissant la race et le sexe de son personnage par le fichier XML de celui que l’on veut tester.

Race	Homme	Femme
Humains	human_male.xml	human_female.xml
Elfes	elf_male.xml	elf_female.xml
Nains	dwarf_male.xml	dwarf_female.xml
Galdurs	orchan_male.xml	orchan_female.xml
Kultars	gnome_male.xml	gnome_female.xml

Par exemple, je suis un galdur et je veux tester les habits sur une femme elfe, il suffit, dans l’actor_defs, de copier le fichier elf_female.xml à la place du fichier orchan_male.xml

Je voudrais utiliser des habits de la version US

La manière de composer les personnages dans LE correspond à des choix techniques qui ne sont plus utilisés par les US depuis quelques versions déjà. Pour éviter de devoir maintenir une fichier cmf par race et par habit, ils ont modifié tous les modèles pour n’avoir qu’un fichier cmf par habit, le même pour toutes les races mais simplement mit à l’échelle dans les fichiers actor_defs.

Malheureusement, nous nous sommes aperçu que les nouveaux modèles US étaient incompatibles avec les anciens modèles que nous utilisons. Il ne nous est donc pas possible d’implémenter les nouveaux habits US sans devoir refaire toutes les races spécifiques à LE. C’est un travail que nous n’avons pas jugé intéressant de faire car nous voulons nous focaliser sur d’autres aspects du développement du jeu.

Donc toutes demandes de ce type ne pourra pas être honorée pour les raisons citées ci-dessus.

Description des différentes parties des habits

Nous allons maintenant décrire ce qui est nécessaire, élément par élément, pour réaliser la texture d’un habit. Le but est de fournir une petite boîte à outils afin de se faciliter la vie dans la réalisation des textures. Vous y trouverez des conseils et plusieurs fichiers images destinés à vous faciliter le travail.

Parmi les fichiers images mis à disposition, vous trouverez :

L’image du dépliage UV qui correspond aux contours de chaque triangle composant l’objet 3D mis à plat sur une image 2D.
L’image d’occlusion ambiante, calculée par Blender et légèrement modifiée, destinée à faciliter l’ombrage de la texture à la lumière ambiante et ainsi augmenter son réalisme.

L’utilisation de ces images sera décrite dans le chapitre suivant : Un exemple de réalisation pas à pas

Le torse et les bras

Pour la partie haute des habits, nous avons actuellement 3 possibilités. L’habit de base qui est utilisé pour la plupart des habits (tenue basique, armures de cuir, habits de peau, …) est le plus simple à utiliser pour créer une texture. Les deux autres ont une petite contrainte qui peuvent gêner la réalisation d’une nouvelle texture. En effet, la textures des épaulettes et des piques reprend une partie de l’image déjà utilisé par la manche. Ce n’est pas bloquant mais il faut en tenir compte si on ne veut pas avoir un résultat bizarre.

Autre point dont il faut tenir compte, le torse rentre dans le pantalon. Donc le bas de la texture du torse sera partielement recouverte par la texture du pantalon. Si vous voulez mettre une ceinture, faite le sur la texture du pantalon.

Dans le cas d’un habit destiné aux deux sexes, prennez les fichiers homme.

Habits de base

	Image UV	Occlusion ambiante
Partie du corps	taille normale	taille normale
Torse Homme
Bras Homme
Torse Femme
Bras Femme

Habits avec épaulettes

Pour le haut de corps avec les épaulettes, il faut prendre garde au fait que la texture des épaulettes est superposée avec la texture des avant-bras :

Dans l’exemple ci-dessus nous avons teinté en orange l’emplacement utilisé par les épaulettes sur l’image texture de gauche. A droite, le résultat sur le modèle dnas Blender. On remarque que la couleur orange se trouve à deux endroits : les avant-bras et les épaulières. C’est donc la même zone de l’image qui texture c’est deux parties du corps. Il est important de bien concevoir votre texture en tenant compte de cette contrainte sinon le résultat sera bizarre.

	Image UV	Occlusion ambiante
Partie du corps	taille normale
Torse homme		idem habits de base
Bras homme		idem habits de base
Torse femme		idem habits de base
Bras femme		idem habits de base

Habits avec piques

Comme pour le torse 2, ce nouveau torse (non utilisé dans le jeu) réutilise des zones de l’image de texture déjà utilisé par d’autres parties du corps que les épaulières :

Dans l’exemple ci-dessus, les épaulières ont été coloriées en orange, les piques en rouges et les protections des mains en bleu. L’épaule ainsi que le haut du bras se retrouvent également orange. Ils partagent donc la même texture que l’épaulière. Au contraire les piques sont à part et donc peuvent avoir leurs propres textures. Les protection des mains recouvrent légèrement les aisselles. Pour cette dernière partie, il conviendra de faire attention pour que les couleurs ne se voient pas trop si le personnage lève le bras.

	Image UV	Occlusion ambiante
Partie du corps	taille normale
Torse homme		idem habits de base
Bras homme		idem habits de base
Torse femme		idem habits de base
Bras femme		idem habits de base

Les mains / les gants

	Image UV	Occlusion ambiante
Partie du corps	taille normale	taille normale
main

Les jambes / le pantalon

	Image UV	Occlusion ambiante
Partie du corps	taille normale	taille normale
jambe

Les bottes

	Image UV	Occlusion ambiante
Partie du corps	taille normale	taille normale
Bottes

Un exemple de réalisation pas à pas

Nous allons réaliser un chemisier féminin pour Réca. Pour cela nous allons utiliser le haut du corps standard de la femme.

Le logiciel utilisé dans cet exemple est The Gimp. C’est un logiciel libre et gratuit fonctionnant sous Linux, Windows et Mac OSX. Vous pouvez donc l’utiliser mais ce n’est pas une obligation. D’autres logiciels existent et peuvent être utilisé. Le point important si vous utilisez un autre logiciel, c’est que celui-ci gère la notion de calque car sinon ce sera plus difficile. Pour ceux qui veulent utiliser ms-paint, je leur souhaite bon courage car celui-ci ne gère pas les calques.