Cette page date, les informations sont à prendre avec recul ; en 2018, le projet est de créer un outil de leveldesign intégré à Blender, qui s'interfacerait avec des librairies python, qui, elles, feraient la moulinettes pour passer au format Nel.
Vous avez le droit de mettre cette page à jour !
Documentez au maximum ce qu'il faut pour ce plugin. Ceci est un document à affiner, toute aide est bienvenue. La traduction en anglais de ce document est vitale (pluginblender).
D'autres approches ont été explorées puis abandonnées :
Document de travail pour le développement d'une extension destinée à aider la création de modèles 3D NEL dans Blender.
Le succès d'un projet libre se mesure dans la capacité de la communauté à se l'approprier et à le faire vivre. Un énorme travail a été effectué par l'équipe Ryzom Core pour fournir une chaîne de production libre nécessaire à la genèse d'un monde. Il manque encore à cet ensemble un élément essentiel : un outil libre pour la modélisation 3D des objets de l'univers. Ce document est une proposition qui vise à combler ce manque.
L'application propriétaire 3D Studio Max est l'outil utilisé en amont pour la création de l'ensemble des éléments 3d du moteur de jeu (terrain, bâtiment, personnage et animation, micro-végétation, billboard, etc…). Une extension dédiée https://ryzomcore.atlassian.net/wiki/display/RC/Installing+the+Max+Plugins permet de :
3D Studio Max est un outil de qualité, reconnu par les professionnels et répondant parfaitement à la problématique de modélisation 3D. Cependant dans le cadre d'un projet libre, il est source de contraintes fortes :
Il existe dans le monde libre un outil capable de rivaliser sans rougir avec des logiciels commerciaux comme 3D Studio Max. Il s'agit de la suite d’outils de modélisation 3D et de rendu dénommée Blender.
L'application Blender s'articule autours du langage de scripting Python. Les dernières versions de l'application utilisent le langage python pour construire l'interface utilisateur au dessus du noyau de la suite. L'API python permet d'accéder à toutes les fonctions internes de Blender depuis ce langage. Ainsi les scripts écrits dans ce langage étendent les fonctionnalités de Blender sans avoir à recompiler/“linker” le code source du programme en binaire.
Ce projet consiste donc à développer une extension Blender en python pour :
Le plugin Nel3DSMax est composé d'une librairie écrite en C++, et de scripts utilisant le langage maxscript spécifique à 3D Studio Max. La librairie C++ s'appuie sur le SDK1 de 3D Studio Max pour accéder aux structures de données internes de l'application et reconstruite à partir de celles-ci les objets 3D NEL avant de les sérialiser dans les différents formats propres à NEL. Les scripts servent essentiellement à initialiser l'environnement et fournissent des outils de manipulation des assets graphiques.
Contenu des dossiers du plugin Nel3DSMax (dans code/nel/tools/3d/plugin_max
) : *
Code à analyser : en 3D les surfaces sont modélisées par un maillage de triangles. Le concept de patch fait référence à l'utilisation des courbes bezier ou autres pour modéliser une surface. Même si au final l'affichage se fera par dessin d'un maillage de triangles (en calculant les positions des sommets des triangles via les valeurs de ces courbes à ces points), l'utilisateur manipule directement un courbe. Ce code C++ semble offrir des fonctionnalités pour faciliter la manipulation de ces surfaces dans 3D Studio Max.
Extrait du code code/nel/tools/3d/plugin_max/nel_export/nel_export.cpp
. Il définit les formats de fichiers sélectionnables dans la boite de dialogue d'export :
CNelExportClassDesc CNelExportDesc; ClassDesc2* GetCNelExportDesc() {return &CNelExportDesc;} static const char *zoneFilter="NeL zone file (*.zone)\0*.zone\0All files (*.*)\0*.*\0"; static const char *meshFilter="NeL shape file (*.shape)\0*.shape\0All files (*.*)\0*.*\0"; static const char *collisionFilter="NeL collision file (*.cmb)\0*.cmb\0All files (*.*)\0*.*\0"; static const char *animModelFilter="NeL model animation file (*.anim)\0*.anim\0All files (*.*)\0*.*\0"; static const char *SWTFilter="NeL Skeleton Weight Template file (*.swt)\0*.swt\0All files (*.*)\0*.*\0"; static const char *InstanceGroupFilter="NeL Instance Group file (*.ig)\0*.ig\0All files (*.*)\0*.*\0"; static const char *skeletonFilter="NeL Skeleton file (*.skel)\0*.skel\0All files (*.*)\0*.*\0"; static const char *vegetableFilter="NeL Vegetable file (*.veget)\0*.veget\0All files (*.*)\0*.*\0"; static const char *lodCharacterFilter="NeL LodCharacter file (*.clod)\0*.clod\0All files (*.*)\0*.*\0";
Extrait du code code/nel/tools/3d/plugin_max/nel_export/nel_export_script.cpp
. Ce code définit les fonctions C++ accessibles au langage de script maxscript de 3D Studio Max.
/*===========================================================================*\ | Define our new functions | These will turn on texture map display at all levels for a given object \*===========================================================================*/ def_visible_primitive ( export_shape, "NelExportShape"); def_visible_primitive ( export_shape_ex, "NelExportShapeEx"); def_visible_primitive ( export_skeleton, "NelExportSkeleton"); def_visible_primitive ( export_animation, "NelExportAnimation"); def_visible_primitive ( export_ig, "NelExportInstanceGroup"); def_visible_primitive ( export_skeleton_weight, "NelExportSkeletonWeight"); def_visible_primitive ( view_shape, "NelViewShape"); def_visible_primitive ( test_file_date, "NeLTestFileDate"); def_visible_primitive ( export_vegetable, "NelExportVegetable"); def_visible_primitive ( reload_texture, "NelReloadTexture" ); def_visible_primitive ( export_collision, "NelExportCollision" ); def_visible_primitive ( export_pacs_primitives, "NelExportPACSPrimitives" ); def_visible_primitive ( export_lod_character, "NelExportLodCharacter" ); def_visible_primitive ( node_properties, "NelNodeProperties" ); def_visible_primitive ( mirror_physique, "NelMirrorPhysique" ); def_visible_primitive ( get_file_modification_date, "NeLGetFileModificationDate" ); def_visible_primitive ( set_file_modification_date, "NeLSetFileModificationDate" );
Note : il n'est pas nécessaire d'étudier ce code en détail. Une bonne partie du code C++ a trait à la manipulation des structures de données propres à « 3D Studio Max ». Ces structures de donnés ne correspondent pas à celles qu'utilisent Blender pour représenter en interne les scènes 3D. Ce qu'il est important d'étudier dans ce code, ce sont les classes NEL utilisées par le plugin pour construire les objets 3D équivalents de NEL.
A ce jour, les fichiers .max servent pour la génération des fichiers NEL natifs suivants : .anim, .clodbank, .cmb, .ig, .pacs_prim, .shape, .skel, .swt, .zone, .veget.
Définition : Un système de particules est une technique d'animation 3D qui utilise un grand nombre de petits sprites (ou autres objets graphiques) pour simuler des phénomènes semi-chaotiques. Ainsi dans Ryzom des phénomènes tels que feu, bancs de poissons, effet de sort, fumée, neige, feux d'artifices sont simulés par cette technique.
Pour faire simple, utilisons un exemple de neige. Tout système de particules possède une entité émettrice (ici le rectangle haut d'un cube modélisant l'espace où il neige). Cette entité génère les particules (ici des sprites représentants des flocons de neige) et pas nécessairement au même moment. Chaque particule évoluera selon différents paramètres (vitesse, gravité, durée de vie…) dans l'espace et dans le temps.
Implémentation de l'export .ps sous Blender : l'éditeur Objet Viewer QT issu du Google summer code intègre à présent un éditeur de particules. Il n'est plus nécessaire de prévoir ce cas de figure dans le projet.
Un triangle est une primitive formée par trois sommets (vertices, vertex). Il s'agit de la surface 2D avec le plus petit nombre de sommets et constitue la primitive de base utilisée par les cartes graphiques 3d modernes. Ainsi les scènes 3d sont en fait constituées de maillages de triangles. Ce maillage est facile à spécifier via un tableau de triplet (vertices) décrivant les sommets de ces triangles. Exemple de la figure ci-dessous, le tableau de sommets pour le GL_TRIANGLE_STRIP serait : { V0(x0,y0,z0), V1(x1,y1,z1), … , V6(x6,y6,z6) }
Au final, toute application 3D manipule ces tableaux de sommets que l'on nomme “Vertex Array” ou “Vertex Buffer”. À charge à la carte graphique (ou la librairie OpenGL, DirectX, etc…) de calculer la projection de ces surfaces composées de milliers de petits triangles (comme la théière ci-dessus) sur un plan 2D représentant nos écrans.
Il va sans dire que la réalité est plus complexe, il faut notamment compléter ces tableaux de vertex par des informations de rendu : la position, l'échelle, la couleur diffuse, la normale, la texture associée à cette surface, etc. La brique de base de toute application 3D reste cependant ce fameux tableau de sommets spécifiant les surfaces des modèles 3D.
La classe NEL dénommée IShape est une abstraction de cette notion de maillage. Un fichier NEL .shape permet et la sauvegarde sur disque d'un objet NEL IShape (un .shape est la sérialisation d'un IShape), c'est-à-dire un maillage de vertex représentant une surface 3D, la/les texture(s) associée(s), ainsi que d'autres informations de rendu. Notons que les textures ne sont pas sauvegardées dans le fichier .shape, elles apparaissent sous la forme de références (c'est-à-dire les noms des fichiers images : .tga, .png ou .dds).
Un fichier .ig (Instance Group) est juste un rassemblement dans un même fichier de plusieurs “shape” (maillages).
Cf. dans nel/3d
class CMeshBase : public IShape class CMesh : public CMeshBase class IMeshGeom : public NLMISC:IStreamable class CMeshMRMGeom : public IMeshGeom class CMeshBaseInstance : public CTransformShape class CSkeletonShape : public IShape class CFlareShape : public IShape class CLodCharacterShape class CParticleSystemShape : public IShape class CSegRemanenceShape : public IShape /** Shape for the remanence of a segment (sword stroke ..) */ class CTransformShape : public CTransform /* A transform which "is an instance of"/"point to" a Ishape. */
Si dans la théorie on doit fournir à la carte graphique les surfaces à dessiner sous la forme d'une suite de triangles, dans la pratique, ils sont rarement sauvegardés sous la forme d'une série de sommets. Parfois il est plus efficace de les calculer dynamiquement. Ainsi on peut définir ces surfaces à partir de courbes mathématiques. La plus employée dans ce cas est la courbe de Bézier. De telles surfaces sont appelées dans le jargon 3D des “patches”. Pour faire le parallèle avec les images 2D : une surface définie par un tableaux de vertex est l'équivalent d'une image bitmap, une surface type patches est l'équivalent d'une image vectorielle. Ainsi par exemple les surfaces représentant le terrain sont formées de patche. Ce qui permet d'adapter le nombre de triangle du maillage en fonction de la distance, assurant un rendue toujours lisse même de près.
Lister les classes NEL de ligo Regarder le code d'export de 3dsmax-nel5)
Exporter une scène 3d construite dans Blender vers le format NEL afin d'être réutilisée par le moteur RyzomCore. Cela concerne :
Aide à la création de modèles 3d conformes aux contraintes de NEL
Scripts d'initialisation de la scène 3d pour des cas particuliers. Liste des scripts existant sous 3dsmax. Apparemment ces scripts ajoutent des boites de dialogues pour manipuler des éléments de la scène, permettant de saisir des données spécifiques aux modèles NEL.
Voir la sérialisation dans NEL.
Liens à ajouter vers les tutos de ryzomcore7) et autres. Détailler un peu plus.
Lister les éléments de scène 3d manipulables par la bibliothèque NEL avec leurs caractéristiques
Lister les formats de fichiers utilisés par la bibliothèque pour sérialiser des éléments 3d (.ps .shape .squelette, etc…)
Faire un tour des caractéristiques de l'outil Blender, et s'assurer qu'il peut manipuler tous les types d'objets de NEL (en général c'est plutôt l'inverse, il faudra plutôt à veiller à ne pas utiliser certaines caractéristiques de Blender dans les objets qui ne sont pas exploitables par NEL).
http://www.blender.org/documentation/blender_python_api_2_65_10/info_quickstart.html
The Blender/Python API can do the following:
The Blender/Python API can’t (yet)…
Exemple de script basique d'export du manuel de blender
http://en.wikibooks.org/wiki/Blender_3D:_Noob_to_Pro/Advanced_Tutorials/Python_Scripting/Export_scripts
Un exemple concret et expliqué d'un script python d'export pour Blender. L'auteur démonte un à un les mécanismes pour parcourir les représentations internes des objets 3D de Blender et la manière de les enregistrer dans un fichier d'export.
( essayer d'ajouter ici des liens vers wikipédia ou des introductions bien faites mais en anglais8))
(cf. max_animation_support.txt)
Animation des nœuds du squelettes [inode]
Animation du matériel (textures)
L'interpolation entre deux états de l'animation peut se faire de manière :
(cf. max_ligh_support.txt)
Modèles de lumières supportés pour les objets 3d
Paramètres de ces lumières pris en compte par NEL
(cf. max_lightmap_support.txt)
Il s'agit d'un texture qu'on applique à un objet 3d pour simuler des effets de lumière : ombres,…
Caractéristiques prises en compte :
(cf. max_matérial_support.txt)
Il s'agit des informations concernant la couleur des objets. Exemple : mapping d'une texture sur le modèle 3d, définition de la couleur de chaque sommet de la surface, etc… Éléments supportés par NEL :
Caractéristiques prises en compte :
(cf. nel_water_material.txt)
Une surface “Eau” est modélisée par un polygone convexe sur lequel on plaque des textures. Le package “texture eau de NEL” est constitué de :
Il possible de simuler une transition entre texture 1 et texture 2 pour simuler la transition jour/nuit.
Attention, certains chemins d'accès aux Assets ryzom sont codé en dur dans le script même !
Pour certains de ces scripts, il s'agirait de définir des boites de dialogue afin de manipuler les caractéristiques des objets utiles à NEL. À confirmer par un programmeur de maxscript.
Ce sont des extraits d'une vieille ML, les informations peuvent être sujet à modification/réinterprétation, à vérifier. Néanmoins on y trouve énormément d'informations de base sur le moteur de jeu.
Message de Cyril Hulud Corvazier du 13 décembre 2001
The NeL 3d library has several user level.
Using the user interface (all u_headers.h in the 3d lib) of the library, you can only load and display a landscape. This level is used by the game developper to abstract the game engine from the technology implementation.
Using the 3d lib at lowlevel (all the others header files) allow you to quilckly create patches and landscape zones. It is really simple to export some bezier quad patches from Blender (does blender have bezier patches ?) into a .zone file using a small plugin.
Simple C++ classes are provided to “Builb” the “.zone” c++ objects. Then serialisation is used to save them in binary files.
The hardest part is the patch painter that allow you to paint tiles, vertex color and displacement map over the landscape zone patches. At nevrax, this is done by the artists using a 3dsmax plugin (nel_patch_paint). If you can't use 3dsmax, you can perhaps generate the painting or rewrite a little ingame zone painter or why not, a blender painter plugin…
You have to know that the painter algorithm that put tiles over the landscape is not trivial at all.
If you are short on time, a good solution is to generate painting, as most of the heightfield landscapes do.
The postprocess to weld the zones together and compute the lighting will stay the same as far as you generate “.zone” files.
Message de Cyril Hulud Corvazier du 13 janvier 2002
We have unified the export / bulid process for all NeL 3d media. It is done in the folder build_gamedata. It provids for each NeL 3d media type, an export process (from 3dsmax or directly from the artist database), a build process to make the final data and an install process to copy data into the final client directories. All is done with batch files. Each process is incremental, i-e, build only modified data.
In build_gamedata/processes/, you will find the build environement for each NeL3d media. In build_gamedata/cfg/ you will find some configuration files.
In build_gamedata/processes/zone, you will find a build environnement for the landscape