1

Licence Professionnelle SIL- Arles

G. Gesquière

Création de Plug-in sous 3dsMax

2

I. INTRODUCTION

Ce manuel a été crée dans le but de permettre la création de plug-ins dans le logiciel 3D studio max. En effet, il a été conçu afin de permettre à des développeurs de rajouter de nouvelles fonctionnalités à un logiciel d’infographie performant. Vous trouverez dans ce manuel une explication simple pour comprendre la création des plug-ins sous 3DSMax.

Nous avons porté notre attention sur les objets procéduraux et les fichiers d’importations.

II. GENERALITE SUR LES PLUG-INS 1- VISUALISATION DES HERITAGES

Les plug-ins de 3DSMax sont réalisées dans le langage C++ ; ils utilisent donc toutes les caractéristiques de la programmation orientée objet (classes, héritages, polymorphisme…).

Le schéma ci dessous représente les classes les plus importantes pour 3DSMax ainsi que les liens d’héritages qui existent entre elles.

3

Hiérarchie des différentes classes :

Fig. 1 Hiérarchie des classes

4

2- TYPES DE PLUG-INS Qu’est ce qu’un Plug-in ? Un plug-in est un programme qui permet d’ajouter une ou plusieurs fonctionnalités à un autre programme plus important et généralement autonome. Les plug-ins, pour 3DSMax, sont des DLL (Dynamic Link Library) de différents types : DLO Objets procéduraux DLU Utilitaire DLC Contrôleur DLE Exportation de scène DLI Importation de scène DLM Modificateur DLR Rendus (visualisation) DLT Textures et matériaux DLF Polices d’écriture FLT Filtre pour image BMI Gestionnaire d’entrée/sortie pour Bitmap BMF Gestionnaire de filtre pour Bitmap BMS Gestionnaire de stockage de Bitmap Tous ces formats sont utilisables sous 3DSMax et sont spécifiques à un type de plug-in. Pour les inclure dans 3DSMax, il faut installer ces fichiers dans l’un des répertoires appropriés : Rep.3dsmax /Stdplugs Rep.3dsmax /Plugins Les plug-ins seront pris en compte par au prochain démarrage de 3DSMax Il est possible de vérifier qu’un Plugin a été pris en charge en allant dans Fichier / résumé, puis dans « Information sur les modules d’extension ».

5

2- MISE A JOUR DE APPWIZARD Les plug-ins sont des programmes écrit en C++. Nous allons les créer en utilisant Visual C++ 6 (D’après les newsGroups, il y a des problèmes avec visual C++ 7). Nous allons utiliser l’AppWizard qui permet de créer automatiquement du code c++ pour les plug-ins qu’il faut compléter ensuite. Pour installer la mise à jour de AppWizard de Visual C++, afin qu’il puisse autogénérer un environnement de travail pour la création de plug-in, vous devez copier le fichier \MaxSDK\Help\SDKAPWZ.zip dans le répertoire temporaire du ‘developer studio’ de Microsoft qui se situe dans C:\Program Files\Microsoft Visual Studio\Common\MSDev98\Bin\IDE. Ensuite, vous devez dézipper le fichier que vous venez de copier dans le répertoire où vous vous trouvez. Vous n’avez plus qu’à lancer Visual C++ puis allez dans File /new … et vous verrez apparaître, dans les choix de projet, le projet 3D Studio MAX Plugin AppWizard.

6

Dans la zone de texte Project name, vous devez entrer le nom du projet (dans notre exemple, le nom du projet est projet_plug). Dans la zone Location, vous devez indiquer à Visual C++ où il doit créer le répertoire de travail (dans notre exemple, le repertoire est : D:\projet_plug). Enfin, vous devez sélectionner le projets 3D Studio MAX Plugin AppWizard –Beta puis, cliquer sur OK pour valider les informations.

7

Ensuite, vous voyez apparaître la fenêtre suivante

Dans cette fenêtre, vous devez sélectionner quel type de plug-in vous désirez créer. Dans ce manuel, nous nous intéresserons principalement aux plug-ins de type « Procedural Objects » ainsi qu’aux plug-ins d’importation et d’exportation. Une fois le type de plug-in choisi, vous devez cliquer sur le bouton Next pour passer à la fenêtre suivante et ainsi valider les informations que vous avez inséré. Vous pouvez également retourner à la fenêtre précédente grâce au bouton Back. Vous pouvez aussi valider la création du plug-in par AppWizzard en appuyant sur la touche Finish, où alors abandonner la création du programme en cliquant sur le bouton cancel. Remarque : certains type de plug-in engendre un code minimun. Pour plus d’information, vous pouvez cliquer sur le bouton Help. Vous devez ensuite spécifier le nom de la classe du plug-in ainsi que la classe dont il dérive dans la fenêtre suivante :

8

Remarque : les classes proposées dans la zone de texte de la classe dérivé sont spécifiques au type du plug-in. Vous pouvez également entrer la catégorie du plug-in dans la zone de texte adéquate. Vous pouvez aussi entrer une description du plug-in. Remarque : Pour certains plug- in, les implémentations ne sont pas terminées. Un message vous le signalera si vous essayez de le créer. Vous devez ensuite indiquer le chemin des répertoires Max SDK ainsi que le chemin où trouver l’exécutable de 3D Studio Max.

Class_Projet

9

Remarque : normalement, vous n’avez pas à changer les informations de cette fenêtre et vous pouvez cliquer directement sur finish. Une fois toutes les informations collectées, la fenêtre suivante apparaît :

10

Cette fenêtre permet de connaître quels sont les fichiers qui ont été généré grâce à

AppWizard. Elle donne également certaines instructions qu’il faut suivre avant d’implémenter du code dans le plug-in. Exemple de message :

11

Ce message indique que AppWizard a crée les fichiers :

PROJET_PLUG.cpp PROJET_PLUG.def PROJET_PLUG.h PROJET_PLUG.rc resource.h

Il indique ensuite les choses qu’il faut faire manuellement avant d’utiliser l’espace de travail. - aller dans Projet/Setting

General - ne pas utiliser le MFC

Debug - Indiquer l’emplacement de l’exécutable de 3DSMax

C/C++ - Utiliser l’un des différents type de génération de code

Multithreaded DLL (pour la configuration Release)

MaxSdk AppWizard will create project: Named: OUR2PLUG.mak Features: Your plugin project will have: PROJET_PLUG.cpp PROJET_PLUG.def PROJET_PLUG.h PROJET_PLUG.rc resource.h Note: After the workspace is created you have do the following things manually: Create a hybrid configuration for debugging your plugin with release MAX. General Tab: Microsoft Foundation Classes to "Not Using MFC" Debug Tab: Executable for debug session to "3dsmax.exe" C/C++ Tab: Code Generation -> Use run-time library to Multithreaded DLL (for Release configuration) Multithreaded DLL (for Hybrid configuration) Debug Multithreaded DLL (for Debug configuration)

12

Multithreaded DLL (pour la configuration Hybrid) Debug Multithreaded DLL (pour la configuration Debug)

3- LA CLASSE DESCRIPTOR Lorsque vous créer un nouveau plug-in grâce à l’AppWizard, un objet de la classe descriptor est créé. Cette classe permet d’envoyer des informations sur le plug-in pour 3DSMax. Ces informations sont commentées dans le code suivant :

Normalement vous n’avez pas à changer les informations de cette classe car elles sont initialisées lors de la création de l’environnement de travail grâce à AppWizard.

// Cette classe permet d’envoyer des informations à 3DSMax class MonPlugClassDesc:public ClassDesc { public: // Le plug-in peut-il être utilisé par d’autres plug-ins ?

int IsPublic() {return 1;} // La création a-t-elle réussi ?

void * Create(BOOL loading = FALSE) {return new MonPlug();} // Donne le nom de l’objet à 3DSMax const TCHAR * ClassName() {return GetString(IDS_CLASS_NAME);}

// Donne le nom de la super classe dont l’objet hérite SClass_ID SuperClassID() {return GEOMOBJECT_CLASS_ID;}

// Donne l’ID de l’objet à 3DSMax Class_ID ClassID() {return MONPLUG_CLASS_ID;}

// Donne la catégorie de l’objet à 3DSMax const TCHAR* Category() {return GetString(IDS_CATEGORY);} // Fournit les initialisations des paramètres et variables lors d’un reset de 3DSMax const TCHAR* InternalName() { return _T("Tp1"); } // returns fixed parsable name (scripter-visible name) HINSTANCE HInstance() { return hInstance; }

// returns owning module handle }; static MonPlugClassDesc MonPlugDesc; ClassDesc* GetMonPlugDesc() {return &MonPlugDesc;}

13

III. GESTION DES OBJETS PAR 3DSMax Un objet sous 3D peut-être décrit par des sommets, des arêtes et des faces. Afin de créer un maillage, on peut utiliser la classe Mesh.

Fig 2 : Constitution d’un Mesh Rappel : - Un sommet est représenté dans l’espace par trois coordonnées X, Y et Z - Une arête est représentée par 2 sommets - Une face est représentée par 3 sommets Remarques : - une face peut être représentée par plus de 3 sommets mais on se ramène toujours à des faces de trois sommets. Par exemple, pour une face de 4 sommets, on se ramène à deux faces de trois sommets. - quand on crée un plug-in, un objet Mesh est déjà déclaré dans la classe GeomObject

(classe qui est hérité par tout objet procédural). Si vous déclarez en local un objet nommé mesh de la classe Mesh, cela inhiberait l’action du premier ce qui aurait pour conséquence le non- affichage de l’objet.

1- LA CLASSE MESH

3DSMax organise dans la classe Mesh la description de l’objet sous forme de tableau. Il existe deux tableaux principaux : - un tableau de sommets - un tableau de faces chacun de ces tableaux est accessible grâce à un pointeur :

Point3 *verts Face *faces

Ces deux tableaux sont formés chacun de 4 parties :

Sommet

Arête

Face

14

- Pour le tableau de sommets: l’indice du sommet et ses cordonnées X, Y, Z. - Pour le tableau de faces : l’indice de la face et les indices des 3 sommets le composant. Exemple de tableau de sommets: INDICE DU SOMMET

COORD X COORD Y COORD Z

0 12.25 53.75 27.33 1 44.5 55.9 99.2 … … … … Exemple de tableau de faces : INDICE DE FACE IND 1er SOMMET IND 2ème SOMMET IND 3ème SOMMET 0 0 1 2 1 2 5 9 … … … … Il faut, avant de remplir ces deux tableaux, appeler les deux méthodes suivantes qui permettent d’initialiser le nombre de sommets et de faces qui se trouvent dans les tableaux. - mesh.setNumVerts (int NbPoints) ; - mesh.setNumFaces (int NbFaces) ; Ensuite, on remplit le tableau de points grâce à la méthode suivante : mesh.setVert (int Indice, float X, float Y, float Z) ; avec Indice l’indice du point à initialiser dans le tableau et X, Y, Z les coordonnées du sommet dans l’espace. rem : X, Y et Z sont des float et cela pose un problème quand on veut utiliser des doubles. Puis, on remplit le tableau de faces grâce à la méthode : mesh.faces[Ind].setVerts (int P1, int P2, int P3) ; avec P1, P2, P3 les indices des sommets composant la face et Ind l’indice de la face dans le tableau. Après avoir initialisé les tableaux de sommets et de faces, il faut encore appeler les méthodes suivantes pour rendre visible l’objet : - mesh.faces[Ind].setEdgeVisFlags (int a, int b, int c) ; Cette méthode permet de rendre visible les arêtes de la face. Ind est l’indice de face pour laquelle on veut rendre visible les arêtes et les paramètres a, b, c servent à savoir si l’arête doit être visible ou non (1 visible, 0, invisible). Les arêtes de la face (P1, P2, P3) sont prises dans le sens trigonométrique comme le présente le schéma ci dessous :

15

Représentation des Arêtes dans une face. - mesh.InvalidateGeomCache() Cette méthode est appelée pour rafraîchir l’ensemble des fenêtres de 3DSMax lorsque l’objet est modifié ou déplacé. - mesh.BuildStripsAndEdges() Cette méthode permet de construire l’objet dans les fenêtres. Elle met à jour les arêtes et le maillage surfacique du mesh.

Fig. 4 BuildStripsAndEdges

Pour afficher un nouvel objet Mesh crée par un développeur, toutes ces méthodes doivent être absolument appelées.

Pour mieux visualiser la gestion des objets par 3DSMax, nous allons vous montrer un

exemple commenté de code permettant de créer un objet simple de type parallélépipède rectangle

void CUBE::BuildMesh(TimeValue t) { // On récupère les valeurs des paramètres du panel

//(panneau de contrôle des paramètres de l’objet) de création de notre cube (voir gestion des panels)

ivalid = FOREVER; pblock->GetValue(PB_LONGUEUR,0,longueur, ivalid); pblock->GetValue(PB_LARGEUR,0,largeur, ivalid); pblock->GetValue(PB_HAUTEUR,0,hauteur, ivalid); // Déclaration et initialisation des points constituants le cube Point3 a(0.0f,0.0f,0.0f) , b(longueur,0.0f,0.0f), c(longueur, largeur, 0.0f), d(0.0f,largeur,0.0f),

a

b

c

P1 P2

P3 Sens trigonométrique

Suite à l’appel de la méthode

16

e(longueur,0.0f,hauteur), f(longueur, largeur, hauteur), g(0.0f,largeur,hauteur), h(0.0f,0.0f,hauteur); // Initialisation du nombre de points et de faces dans les tableaux du Mesh mesh.setNumVerts(8); mesh.setNumFaces(12); // On remplit les tableaux du Mesh mesh.setVert(0, a); mesh.setVert(1, b); mesh.setVert(2, c); mesh.setVert(3, d); mesh.setVert(4, e); mesh.setVert(5, f); mesh.setVert(6, g); mesh.setVert(7, h);

// la déclaration des faces est très importante car si elle est mal faite, // le cube peut avoir une diagonale de trop // faces de devant mesh.faces[0].setVerts(1,2,0); mesh.faces[1].setVerts(3,0,2); // faces arrière mesh.faces[2].setVerts(7,6,4); mesh.faces[3].setVerts(5,4,6); // faces de côté mesh.faces[4].setVerts(4,5,1); mesh.faces[5].setVerts(2,1,5); // faces de côté mesh.faces[6].setVerts(0,3,7); mesh.faces[7].setVerts(6,7,3); // faces haut mesh.faces[8].setVerts(2,5,3); mesh.faces[9].setVerts(6,3,5); // faces bas mesh.faces[10].setVerts(4,1,7); mesh.faces[11].setVerts(0,7,1); for (int i =0; i<12; i++) { // On rend seulement deux arêtes visibles

17

mesh.faces[i].setEdgeVisFlags(1,0,1); }

mesh.InvalidateTopologyCache(); // sert à rendre visible les arêtes

// lorsque l’on déplace l’objet mesh.InvalidateGeomCache(); // rafraîchit la géométrie de l’objet mesh.BuildStripsAndEdges(); // construction du maillage

// surfacique et des arêtes }

18

IV. GESTION DES PANELS DE CONTROLES Un panel est un panneau de contrôle composé de plusieurs éléments qui permettent

d’agir sur les paramètres d’un objet. Sur la figure ci dessous, vous pouvez voir le panel de contrôle de l’objet sphère

Pour créer un plug-in, il faut utiliser l’AppWizard (l’assistant d’aide à la création

d’application) de 3DSMax pour générer un nouvel espace de travail dans Visual C++. Celui ci se compose, hormis les fichiers propres à Visual C++, d’un .CPP, d’un .H et d’un .RC à implémenter suivant les besoins du développeur.

Panel de contrôle de la sphère

19

1- Les Fichiers .RC Ces fichiers sont spécifiques à Visual C++ et permettent de créer des interfaces

graphiques de manière conviviale. Ces interfaces graphiques peuvent être constituées des éléments suivants : - bouton (button) - incrémenteur (spinner control) - zone de texte modifiable (Edit box) - zone de texte statique (Static text) - bouton radio (radio button) - case à cocher (check box) - image (Picture) - encadrement titré (Groupe Box) - barre de défilement verticale(Vetical Scroll Bar) - barre de défilement horizontale (Horizontal Scroll Bar) - barre de progression (Progress) - barre de contrôle de volume (Slider) - liste de contrôle (List Control) - arbre de contrôle (Tree Control) - onglets de contrôle (Tab Control) - animation (Animate) - action (Custom Control) - et tous les autres standards graphiques… remarque :

On ne peut pas utiliser les classes MFC de Microsoft. Elles permettent normalement de simplifier la gestion des actions et des autres événements des interfaces graphiques. La gestion des événements se fera grâce à des classes et des méthodes spécifiques à 3DSMax.

2- CREATION D’UN PANEL

Un panel est composé de plusieurs éléments qu’il faut impérativement implémenter.

20

Ces composants sont les suivants :

� Des ressources � Les identifiants des ressources � Des méthodes associées.

2.1- Ressource

A l’aide du constructeur de ressource ont fabrique les éléments de contrôles des différents paramètres auquel on veut pouvoir accéder sous 3DSMax.

Nom de la ressource

Constructeur de ressource

Par exemple pour créer le panel ci-contre on utilise le constructeur ‘custom control’ afin d’obtenir les éléments ci-contre.

21

Nous sommes obligés d’utiliser les contrôles personnalisés car 3DSMax ne gère pas les MFC. Quand on veut, par exemple créer une zone de texte modifiable avec un spinner de contrôle, il faut utiliser le custom control. Après avoir placé l’élément sur le panel, il faut double cliquer dessus afin de voir apparaître la fenêtre suivante :

Dans la zone de texte ID, vous devez inscrire le nom identifiant de l’élément (dans l’exemple : IDC_X). On doit ensuite spécifier de quel type est l’élément que l’on vient d’insérer (bouton, zone de texte, etc …) Dans l’exemple ci dessus, l’objet est de type CustEdit ce qui signifie zone de texte. La liste suivante donne les différents types d’objets que l’on peut inclure :

2.2- GESTION DES PARAMETRES Après avoir créé le ou les panel(s) de contrôles, il faut encore implémenter du code dans le plug-in afin qu’il puisse les inclure dans 3D Studio Max. L’exemple qui suit permet de définir les éléments composant ce panel. Le code est expliqué juste après.

Custom Edit control zone de texte - CustEdit Custom Spinner Control incrémenteur - SpinnerControl Custom Button control bouton - CustButton Custom Toolbar control barre d’outils - CustToolbar Custom Image control image - CustImage Custom Status control contrôle de statuts - CustStatus Color Swatch control identifiant couleur - ColorSwatch Custom Rollup Window page déroulante - RollupWindow Custom DragAndDrop Window control glisser/déplacer - DragDropWindow Custom TCB Graph contrôle de graphe - TCBGraph

22

// définition des noms des Blocs de paramètres #define PB_X 0 #define PB_Y 1 #define PB_Z 2 #define PB_NOMBRE 3 #define PB_PRECISION 4 #define PB_GRAIN 5 #define PB_NUMERO 6 #define PB_X_CREATE 7 #define PB_Y_CREATE 8 #define PB_Z_CREATE 9 // longueur des panels #define LongueurModifier 7 #define LongueurCreation 3 // substitut #define MIN_COOR (float)-99999.9 #define MAX_COOR (float) 99999.9 #define MIN_NB 0 #define MAX_NB 10 #define MIN_GRAINS 0 #define MAX_GRAINS 10 #define MIN_PRECISION 1 #define MAX_PRECISION 10 #define MIN_NUM 0 #define MAX_NUM 10 // définition des panels static ParamUIDesc ModifParamDesc[] = { // Coordonnées en X,Y et Z. ParamUIDesc( PB_X, EDITTYPE_FLOAT, IDC_X,IDC_SPIN_X, MIN_COOR,MAX_COOR, SPIN_AUTOSCALE),

23

ParamUIDesc( PB_Z, EDITTYPE_FLOAT, IDC_Z,IDC_SPIN_Z, MIN_COOR,MAX_COOR,

SPIN_AUTOSCALE), // Nombre de Blobs ParamUIDesc( PB_NOMBRE, EDITTYPE_INT, IDC_NB_BLOB,IDC_SPIN_NB_BLOB, MIN_NB,MAX_NB, SPIN_AUTOSCALE), // Précision ParamUIDesc( PB_PRECISION, EDITTYPE_INT, IDC_PRECISION,IDC_SPIN_PRECISION, MIN_PRECISION,MAX_PRECISION, SPIN_AUTOSCALE), // Grains ParamUIDesc( PB_GRAIN, EDITTYPE_INT, IDC_GRAIN,IDC_SPIN_GRAIN, MIN_GRAINS,MAX_GRAINS, SPIN_AUTOSCALE), // Nombre de blobs ParamUIDesc( PB_NUMERO, EDITTYPE_INT, IDC_NUM_BLOB,IDC_SPIN_NUM_BLOB, MIN_NUM,MAX_NUM, SPIN_AUTOSCALE), }; static ParamUIDesc CreateParamDesc[] = { // Coordonnées en X,Y et Z. ParamUIDesc( PB_X_CREATE, EDITTYPE_FLOAT, IDC_X_CREATE,IDC_SPIN_X_CREATE, MIN_COOR,MAX_COOR, SPIN_AUTOSCALE), ParamUIDesc( PB_Y_CREATE, EDITTYPE_FLOAT,

24

Ce code permet d’utiliser les deux panels suivants dans 3D Studio max .

Panel de création Panel de modification

SPIN_AUTOSCALE),} static ParamBlockDescID descVer1[] = { { TYPE_FLOAT, NULL, TRUE, 0 }, // X { TYPE_FLOAT, NULL, TRUE, 1 }, // Y { TYPE_FLOAT, NULL, TRUE, 2 }, // Z { TYPE_INT , NULL, TRUE, 3 }, // Nombre Blob { TYPE_INT , NULL, TRUE, 4 }, // Précision { TYPE_INT , NULL, TRUE, 5 }, // Grain { TYPE_INT , NULL, TRUE, 6 }, // Numéro { TYPE_FLOAT, NULL, TRUE, 7 }, // X { TYPE_FLOAT, NULL, TRUE, 8 }, // Y { TYPE_FLOAT, NULL, TRUE, 9 }, // Z }; #define CURRENT_DESCRIPTOR descVer1 #define PBLOCK_LENGTH 10

25

2.3- EXPLICATION DU CODE : Tout d’abord, le développeur doit définir les blocs de paramètres : Ex :

# define PB_X 0 Une fois les blocs de paramètres définis, il faut définir la longueur de chaque panels Ex :

#define LongueurModifier 7 #define LongueurCreation 3

Pour chaque panel (create et modifier), on définit la longueur du panel, ce qui signifie le nombre de blocs de paramètres qui constitue le panel. Par exemple, le panel de création à une longueur de 3 car il est formé des blocs de paramètres PB_X_CREATE, PB_Y_CREATE, et PB_Z_CREATE. On définit ensuite la constitution de chaque panel à l’aide d’un tableau d’objet ParamUIDesc :

static ParamUIDesc CreateParamDesc[] = { // Coordonnées en X,Y et Z. ParamUIDesc( PB_X_CREATE, EDITTYPE_FLOAT, IDC_X_CREATE,IDC_SPIN_X_CREATE, MIN_COOR,MAX_COOR, SPIN_AUTOSCALE), ParamUIDesc( PB_Y_CREATE, EDITTYPE_FLOAT, IDC_Y_CREATE,IDC_SPIN_Y_CREATE, MIN_COOR,MAX_COOR, SPIN_AUTOSCALE), ParamUIDesc( PB_Z_CREATE, EDITTYPE_FLOAT, IDC_Z_CREATE,IDC_SPIN_Z_CREATE, MIN_COOR,MAX_COOR,

SPIN_AUTOSCALE),} Les objets ParamUIDesc sont construit de la manière suivante :

- Un identifiant d’un bloc de paramètre - du type de données en entrée - du ou des identifiants constituants le blocs de paramètres

(IDC_Y_CREATE,IDC_SPIN_Y_CREATE) - des coordonnées minimum et maximum des données - de l’écart entre deux valeurs

Les différents types d’entrée :

26

EDITTYPE_INT entier EDITTYPE_FLOAT nombre réel (float) EDITTYPE_UNIVERSE entier ou float EDITTYPE_POS_INT entier >= 0 EDITTYPE_POS_FLOAT float >= 0.0 EDITTYPE_POS_UNIVERSE entier ou float >0.0 EDITTYPE_TIME le temps (système) Remarque : pour l’écart entre deux valeurs, on peut utiliser SPIN_AUTOSCALE qui ajuste automatiquement l’incrémentation et la décrémentatation, ou alors utiliser directement une valeur (par exemple, 0.001) Il faut définir ensuite un tableau d’objet ParamBlockDescID. Ces objets décrivent chaque paramètres dans le bloc de paramètres. Format :

class ParamBlockDescID { public:

ParamType type; UserType *user; BOOL animatable; DWORD id;

}; avec : ParamType type : le type de paramètre UserType *user : pointeur qui n’est pas très couramment utilisé. Il doit toujours être mis à NULL. BOOL animatable : booléen indiquant si le paramètre peut être modifié ou non.

Si TRUE le paramètre peut être modifié Si FALSE, si la valeur du paramètre est constant.

DWORD id : le numéro d’ID du paramètre Il faut ensuite définir la taille du tableau de bloc de paramètres #define PBLOCK_LENGTH 10 Exemple : static ParamBlockDescID descVer1[] = { { TYPE_FLOAT , NULL, TRUE, 0 }, // X { TYPE_FLOAT , NULL, TRUE, 1 }, // Y { TYPE_FLOAT , NULL, TRUE, 2 }, // Z { TYPE_INT , NULL, TRUE, 3 }, // Nombre Blob { TYPE_INT , NULL, TRUE, 4 }, // Précision

27

{ TYPE_INT , NULL, TRUE, 5 }, // Grain { TYPE_INT , NULL, TRUE, 6 }, // Numéro { TYPE_FLOAT , NULL, TRUE, 7 }, // X { TYPE_FLOAT , NULL, TRUE, 8 }, // Y { TYPE_FLOAT , NULL, TRUE, 9 }, // Z }; #define CURRENT_DESCRIPTOR descVer1 #define PBLOCK_LENGTH 10

2.4- METHODE D’INITIALISATION DES PARAMETRES Après avoir créé le(s) panel(s) et après l(es) avoir déclaré, il faut explicitement déclencher

la création du ou des panel(s) grâce à la méthode BeginEditParamEnfin.

// exemple du cube // construction void CUBE::BeginEditParams(IObjParam *ip,ULONG flags,Animatable *prev) { this->ip = ip; // ip est un pointeur sur l’interface

// c’est un membre de // la classe CUBE

SimpleObject::BeginEditParams(ip,flags,prev); if(pmapParam) { // pmapParam est un pointeur sur

// le panel, c’est un membre de // la classe CUBE

pmapParam->SetParamBlock(pblock); // pbloc est hérité de // la classe Object il est utilisé // pour pointer sur les différents // paramètres

} else { pmapParam = CreateCPParamMap( // On créé le panel. descParam, // nom de la description du panel

PARAMDESC_LENGTH, // longueur du panel pblock, // pointeur à l’intérieur du panel ip, // pointeur sur l’interface hInstance, // l’instance dont il fait partie MAKEINTRESOURCE(IDD_PANEL),// visualisation graphique GetString(IDS_PARAMS), // nom qui apparaîtra sur le panel APPENDROLL_CLOSED); // mode d’apparition

// (déroulé ou enroulé) } }

28

Dans l’exemple de la création du panel d’un cube, nous faisons pointer ip vers un objet de type cube, puis on vérifie si le panel est déjà crée ou non grâce au pointeur pmapParam qui est un pointeur sur un objet de la classe IparamMap ce qui permet de pointer le panel (pmapParam est un membre de la classe CUBE).

Si le panel n’existe pas, il faut le crée grâce à la méthode CreateCPParamMap

pmapParam = CreateCPParamMap( . descParam, // nom de la description du

panel PARAMDESC_LENGTH, // longueur du panel

pblock, // pointeur à l’intérieur du panel

ip, // pointeur sur l’interface hInstance, // l’instance dont il fait partie MAKEINTRESOURCE(IDD_PANEL), // visualisation graphique GetString(IDS_PARAMS), // nom qui apparaîtra sur

le panel APPENDROLL_CLOSED); // mode d’apparition

// (déroulé ou enroulé)

si le panel existe déjà, on utilise la méthode SetParamBlock(pblock) qui réinitialise le

panel (par exemple, quand on passe d’un objet cube à un autre objet cube, ce n’est pas la peine de recréer un panel puisque il existe déjà. Par contre, il faudra mettre à jour les données du panel par rapport au nouveau cube).

2.5- METHODE DE DESTRUCTION DES PARAMETRES

La méthode EndEditParams est toute aussi importante que la précédente car elle gère la destruction des panels. En effet, elle est appelée quand l’utilisateur a fini d’éditer les paramètres de l’objet. le système passe alors un flag à la méthode pour indiquer si le panel doit être enlevé. Si ce flag vaut TRUE, alors le plug-in doit l’invalider et l’effacer.

// destruction void CUBE::EndEditParams( IObjParam *ip, ULONG flags,Animatable *next ) { SimpleObject::EndEditParams(ip,flags,next); if (flags&END_EDIT_REMOVEUI ) { // Si on ferme 3DSMax

// ou si l’on supprime l’objet // ou que l’on change de plug-in // ou d’onglets de commande

DestroyCPParamMap(pmapParam); // destruction du panel pmapParam = NULL; // pointeur ‘désactivé’ } this->ip = NULL; }

29

Remarque : Dans le constructeur de l’objet, on initialise le pointeur pblock grâce à la méthode CreateParameterBlock. Lorsque vous utilisez AppWizard, cette partie du programme est déjà implémenté et ce n’est généralement pas la peine de la modifier.

2.6- ACCES AUX BLOCS DE PARAMETRES Pour pouvoir modifier la valeur des paramètres de l’exemple de notre cube après

l’avoir construit, nous devons pouvoir agir directement sur les éléments déterminant la forme de l’objet lui même c’est à dire la longueur, la largeur et la hauteur de notre objet. Pour ce faire nous utilisons les méthodes suivantes :

BOOL CUBE::SetValue(int i, TimeValue t, int v) {return TRUE;} BOOL CUBE::SetValue(int i, TimeValue t, float v){return TRUE ;} BOOL CUBE::SetValue(int i, TimeValue t, Point3 &v) {return TRUE;}

BOOL CUBE::GetValue(int i, TimeValue t, int &v, Interval &ivalid) {return TRUE;} BOOL CUBE::GetValue(int i, TimeValue t, float &v, Interval &ivalid) {return TRUE;} BOOL CUBE::GetValue(int i, TimeValue t, Point3 &v, Interval &ivalid){return TRUE;}

Avec comme paramètres :

- int i l’indice du bloc de paramètre (ex : PB_LONGUEUR) - TimeValue t Instant de la modification (généralement 0) - int v, float v ou Point3 v la valeur ou variable de réception du paramètre - Interval &ivalid Intervalle de validité (généralement FOREVER)

Ces méthodes SetValue et GetValue sont générés automatiquement par l’AppWizard Ces méthodes sont héritées de la classe IParamArray. Celles-ci permettent de récupérer

(GetValue) ou de fixer (SetValue) les valeurs du panel de contrôle. En effet, grâce à ces méthodes, il est possible de modifier les données spécifiques à la construction du cube en les appelant dans la (les) méthode(s) qui utilise(nt) les valeurs du panel.

pblock = CreateParameterBlock( CURRENT_DESCRIPTOR, PBLOCK_LENGTH, CURRENT_VERSION); assert(pblock); MakeRefByID(FOREVER, 0, pblock); }

30

3- GESTION DE L’EVENEMENT CLIC DE BOUTON L’événement « cliquer sur un bouton » est géré par une classe particulière qu’il faut ajouter au plug-in (sinon, on ne déclenche aucune action. Cette classe doit hériter de la classe ParamMapUserDlgProc et se présente sous la forme suivante :

Cette classe est formé d’un pointeur sur l’objet (dans l’exemple du dessus, il s’agit d’un objet blobbis que nous avons créé), et de quelques méthodes. La méthode la plus importante est la méthode BOOL DlgProc(TimeValue t,IParamMap *map,HWND hWnd,UINT msg,WPARAM wParam,LPARAM lParam). En effet, c’est elle qui permet de gérer les différents événements sur les boutons des panels. Selon l’IDC du bouton qui à été cliqué, on ajoute des événements

class ButtonDlgProc : public ParamMapUserDlgProc { public: Blobbis *ob; ButtonDlgProc(Blobbis *o) {ob=o;} BOOL DlgProc(TimeValue t,IParamMap *map,HWND hWnd,UINT msg,WPARAM wParam,LPARAM lParam); void DeleteThis() {delete this;} };

BOOL ButtonDlgProc::DlgProc( TimeValue t,IParamMap *map,HWND hWnd,UINT msg,WPARAM wParam,LPARAM lParam){ switch (msg) { case WM_COMMAND: switch (LOWORD(wParam)) { case IDC_ENREGISTER: … case IDC_VALIDER: … case IDC_BUTTON_CREATE: … case IDC_SUIVI: … case IDC_PAS_SUIVI: … default: break; } break; … default:

31

4- GESTION SOURIS LORS DE LA CREATION DE L’OBJET Lorsque l’on crée un objet dans 3D Studio Max, on peut soit utiliser la gestion par les

panels, soit utiliser directement la souris dans l’espace de travail afin de créer interactivement un objet (pour l’exemple du cube, cliquer une fois pour connaître les coordonnées d’un point, cliquer une deuxième fois afin de connaître la longueur, puis la largeur et enfin la hauteur).

La gestion souris lors de la création de l’objet se fait grâce à une classe qui hérite de la

classe CreateMouseCallBack

Cette classe est crée par défaut lors de la création d’un plug-in d’objet procédural. Vous

devez simplement implémenter la méthode proc afin de la rendre spécifique à votre création interactive de l’objet.

Voici un exemple d’implémentation de la méthode proc à travers l’exemple de la création d’un cube à la souris.

// Création du cube par l’intermédiaire de la souris class CUBECreateCallBack : public CreateMouseCallBack { IPoint2 sp0,sp1; // Coordonnés en 2D BOX_GI *ob; // Pointeur sur l’objet Point3 p0, p1, p2, p3; // Points 3D public: int proc( ViewExp *vpt,int msg, int point, int flags, IPoint2 m, Matrix3& mat); void SetObj(BOX_GI *obj) {ob = obj;} };

int CUBECreateCallBack::proc(ViewExp *vpt ,int msg, int point, int flags, IPoint2 m, Matrix3& mat )

{ if (msg==MOUSE_FREEMOVE) // Si la souris est en mouvement libre { vpt->SnapPreview(m,m,NULL,SNAP_IN_3D); }

32

Les paramètres de la méthode : ViewExp *vpt

Ce paramètre représente le Viewport (vue sous 3D)dans lequel l’utilisateur est en train de créer l’objet.

if (msg==MOUSE_POINT || msg==MOUSE_MOVE) // si l’on a au moins // un bouton souris appuyé

{ switch(point) { // effectué dès que l’on a cliqué case 0: ob->suspendSnap = TRUE; sp0 = m; p0 = vpt->SnapPoint(m,m,NULL,SNAP_IN_3D); mat.SetTrans(p0); // initialisation du repère

// de référence break;

case 1: // On capture le premier point p1 = vpt->SnapPoint(m,m,NULL,SNAP_IN_3D); ob->longueur = p1.x-p0.x; // on met à jour le bloc de paramètre appelé PB_LONGUEUR ob->pblock->SetValue(PB_LONGUEUR,0,ob->longueur); ob->pmapParam->Invalidate(); break;

case 2 : // On capture le deuxième point p1 = vpt->SnapPoint(m,m,NULL,SNAP_IN_3D); ob->largeur=p1.y-p0.y; // on met à jour le bloc de paramètre appelé PB_LARGEUR ob->pblock->SetValue(PB_LARGEUR,0,ob->largeur); ob->pmapParam->Invalidate(); break;

case 3 : p2 = vpt-> SnapPoint(m,m,NULL,SNAP_IN_3D); ob->hauteur=p1.z-p0.z;

// on met à jour le bloc de paramètre appelé PB_HAUTEUR ob->pblock->SetValue(PB_HAUTEUR,0,ob->hauteur); ob->pmapParam->Invalidate(); // On arrête la création de l’objet puisqu’on a récupéré

// toutes les informations dont on a besoin pour la création du Mesh. ob->suspendSnap = FALSE; return CREATE_STOP; }

else // Si l’on abandonne la création de l’objet sans le terminer if (msg == MOUSE_ABORT) return CREATE_ABORT;

return TRUE;

33

int msg

ce message décrit le type d’événement qui est en train de ce produire. Voici la liste des différents événements :

MOUSE_ABORT Quand l’utilisateur abandonne la création de l’objet en cliquant sur le bouton droit, ce message est envoyé

MOUSE_IDLE Ce message est utilisé en interne dans 3DSMax MOUSE_POINT Ce message est envoyé quand l’utilisateur clique sur le bouton gauche de la

souris MOUSE_MOVE Ce message est envoyé quand la souris se trouve dans un viewport et qu’elle

se déplace après avoir effectué un clic de souris.

MOUSE_DBLCLICK Ce message est envoyé quand l’utilisateur fait un double clic.

MOUSE_FREEMOVE Ce message est similaire à MOUSE_MOVE sauf que ce n’est pas la peine de cliquer avant.

MOUSE_KEYBOARD Ce message n’est pas très utilisé. Il sert notamment à créer et à utiliser des raccourci clavier.

int point

Ce paramètre indique le nombre de fois que l’utilisateur à cliqué. Au départ, ce nombre est à zero, puis 1, etc… IPoint2 m

Ce paramètre correspond à la coordonnée en 2D du point quand on clique avec la souris. En effet, quand on clique avec la souris, on clique dans une fenêtre (un viewport) de 3D Studio Max qui est en deux dimensions.

Remarque : pour retrouver les coordonnées en 3 dimensions, il faut utiliser différentes méthodes afin de convertir le point 2D en un point 3D.

Lorsqu’on récupère une coordonnées dans 3DSMax à l’aide de la méthode ‘MapScreenToView’ on obtient un point 3D dont les coordonnées X et Y correspondent au coordonnées correctes des fenêtres de 3DSMax (rappelons que 3DSMax ne gère en réalité que des données 2D). La coordonnée Z étant erronée nous la forçons à 0. Pour obtenir les coordonnées dans le repère de l’objet nous passons par la méthode ‘MapCPToWorld’.

Matrix3& mat

Ce paramètre représente le référentiel de l’objet. il est généralement initialisé lors du premier clic de souris.