home *** CD-ROM | disk | FTP | other *** search
/ AmigActive 26 / AACD 26.iso / AACD / Graphics / sKulpt / skulpt-src / MenuWProc.cpp < prev    next >
Encoding:
C/C++ Source or Header  |  2000-08-30  |  49.7 KB  |  1,269 lines
  1. #define STRICT
  2.  
  3. // Includes standard Windows
  4. #include <windows.h>
  5. #include <windowsx.h>
  6. #include <time.h>
  7. #include <stdlib.h>
  8. #include <malloc.h>
  9. #include <memory.h>
  10. #include <stdio.h>
  11.  
  12. // Includes D3D
  13. #define  D3D_OVERLOADS
  14. #include <ddraw.h>
  15. #include <d3d.h>
  16. #include <d3dx.h>
  17.  
  18. // Includes utilitaires D3D
  19. #include "d3dmath.h"
  20. #include "d3dutil.h"
  21. #include "D3DEnum.h"
  22.  
  23. // Ids Resources
  24. #include "resource.h"
  25.  
  26. // Constantes
  27. #include "const.h"
  28.  
  29. // Types
  30. #include "types.h"
  31.  
  32. // Variables globales projet
  33. #include "vars.h"
  34.  
  35. // Prototypes fonctions autres modules
  36. #include "proto.h"
  37.  
  38. // Macros
  39. #include "macros.h"
  40.  
  41. // Sortir un résumé de la scène dans la fenêtre de trace
  42. void vDescribe(void)
  43. {
  44.     int iCnt,
  45.         iVertices = 0,
  46.         iSelectedVertices = 0,
  47.         iHiddenVertices = 0,
  48.         iTriangles = 0,
  49.         iHiddenTriangles = 0,
  50.         iEdges = 0,
  51.         iHiddenEdges = 0,
  52.         iLamps = 0,
  53.         iSelectedLamps = 0,
  54.         iLitLamps = 0,
  55.         iObjects = 0,
  56.         iSelectedObjects = 0,
  57.         iMaterials = 0,
  58.         iHiddenObjects = 0;
  59.  
  60.     vTrace("*** Résumé scène courante :");
  61.  
  62.     // Compter les points
  63.     for (iCnt = 0 ; iCnt <= iVertLastUsed ; iCnt++)
  64.         if (Vertices[iCnt].bEnabled)
  65.         {
  66.             iVertices++;
  67.             if (bIsVertexSelected(iCnt)) iSelectedVertices++;
  68.             if (Vertices[iCnt].bHidden) iHiddenVertices++;
  69.         }
  70.  
  71.     // Compter les lampes
  72.     for (iCnt = 0 ; iCnt <= iLampLastUsed ; iCnt++)
  73.         if (Lampes[iCnt].bEnabled)
  74.         {
  75.             iLamps++;
  76.             if (Lampes[iCnt].bSelected) iSelectedLamps++;
  77.             if (Lampes[iCnt].bLit) iLitLamps++;
  78.         }
  79.  
  80.     // Compter les objets
  81.     for (iCnt = 0 ; iCnt <= iObjtLastUsed ; iCnt++)
  82.         if (Objects[iCnt].bEnabled)
  83.         {
  84.             iObjects++;
  85.             if (Objects[iCnt].bSelected) iSelectedObjects++;
  86.             if (Objects[iCnt].bHidden) iHiddenObjects++;
  87.         }
  88.  
  89.     // Compter les arêtes
  90.     for (iCnt = 0 ; iCnt <= iEdgeLastUsed ; iCnt++)
  91.         if (Edges[iCnt].bEnabled)
  92.         {
  93.             iEdges++;
  94.             if (Edges[iCnt].bHidden) iHiddenEdges++;
  95.         }
  96.  
  97.     // Compter les triangles
  98.     for (iCnt = 0 ; iCnt <= iTriaLastUsed ; iCnt++)
  99.         if (Triangles[iCnt].bEnabled)
  100.         {
  101.             iTriangles++;
  102.             if (Triangles[iCnt].bHidden) iHiddenTriangles++;
  103.         }
  104.  
  105.     // Compter les matériaux
  106.     for (iCnt = 0 ; iCnt <= iMtrlLastUsed ; iCnt++)
  107.         if (Materials[iCnt].bEnabled)
  108.             iMaterials++;
  109.  
  110.     vTrace("Taille buffers en Ko : sommets %d, arêtes %d, triangles %d, objets %d, matériaux %d, total %d.", sizeof(Vertices) / 1024, sizeof(Edges) / 1024, sizeof(Triangles) / 1024, sizeof(Objects) / 1024, sizeof(Materials) / 1024, (sizeof(Vertices) + sizeof(Edges) + sizeof(Triangles) + sizeof(Objects) + sizeof(Materials)) / 1024);
  111.     if (iVertices) vTrace("Points : %d (%d sélectionnés, %d cachés). Dernier utilisé : %d, premier dispo : %d (frag : %d%%)", iVertices, iSelectedVertices, iHiddenVertices, iVertLastUsed, iVertFirstAvailable, 100 * ((iVertLastUsed + 1) - iVertices) / iVertices);
  112.     if (iEdges) vTrace("Arêtes : %d (%d cachées). Dernier utilisé : %d, premier dispo : %d (frag : %d%%)", iEdges, iHiddenEdges, iEdgeLastUsed, iEdgeFirstAvailable, 100 * ((iEdgeLastUsed + 1) - iEdges) / iEdges);
  113.     if (iTriangles) vTrace("Triangles : %d (%d cachés). Dernier utilisé : %d, premier dispo : %d (frag : %d%%)", iTriangles, iHiddenTriangles, iTriaLastUsed, iTriaFirstAvailable, 100 * ((iTriaLastUsed + 1) - iTriangles) / iTriangles);
  114.     if (iObjects) vTrace("Objets : %d (%d sélectionnés, %d cachés). Dernier utilisé : %d, premier dispo : %d (frag : %d%%)", iObjects, iSelectedObjects, iHiddenObjects, iObjtLastUsed, iObjtFirstAvailable, 100 * ((iObjtLastUsed + 1) - iObjects) / iObjects);
  115.     if (iLamps) vTrace("Lampes : %d (%d sélectionnées, %d allumées). Dernière utilisée : %d, premier dispo : %d (frag : %d%%)", iLamps, iSelectedLamps, iLitLamps, iLampLastUsed, iLampFirstAvailable, 100 * ((iLampLastUsed + 1) - iLamps) / iLamps);
  116.     if (iMaterials) vTrace("Matériaux : %d. Dernier utilisé : %d, premier dispo : %d (frag : %d%%)", iMaterials, iMtrlLastUsed, iMtrlFirstAvailable, 100 * ((iMtrlLastUsed + 1) - iMaterials) / iMaterials);
  117. }
  118.  
  119. // Redimensionner la triview
  120. void vRemakeTriview(LPARAM lParam)
  121. {
  122.     int iScreenWidth, iScreenHeight;
  123. #ifndef _AMIGA_
  124.     HDC hdcScreen;
  125.  
  126.     if (!lParam)
  127.     {
  128.         hdcScreen = GetDC(NULL);
  129.         iScreenWidth = GetDeviceCaps(hdcScreen, HORZRES);
  130.         iScreenHeight = GetDeviceCaps(hdcScreen, VERTRES);
  131.     }
  132.     else
  133.     {
  134.         iScreenWidth = LOWORD(lParam);
  135.         iScreenHeight = HIWORD(lParam);
  136.     }
  137.  
  138.     vTrace("Réorganisation des fenêtres (écran %d x %d)", iScreenWidth, iScreenHeight);
  139.  
  140.     MoveWindow(hWndMenu, 0, 0, iScreenWidth, iScreenHeight / 9, TRUE);
  141.     MoveWindow(hWndPersp, iScreenWidth/2, iScreenHeight / 9, iScreenWidth/2, 4 * iScreenHeight / 9, TRUE);
  142.     MoveWindow(hWndTop, 0, iScreenHeight / 9, iScreenWidth/2, 4 * iScreenHeight / 9, TRUE);
  143.     MoveWindow(hWndFace, 0, 5 * iScreenHeight / 9, iScreenWidth/2, 4 * iScreenHeight / 9, TRUE);
  144.     MoveWindow(hWndRight, iScreenWidth/2, 5 * iScreenHeight / 9, iScreenWidth/2, 4 * iScreenHeight / 9, TRUE);
  145.  
  146.     if (!lParam) ReleaseDC(NULL, hdcScreen);
  147. #else
  148.     iScreenWidth = hInst -> Width;
  149.     iScreenHeight = hInst -> Height;
  150.  
  151.     vTrace("Réorganisation des fenêtres (écran %d x %d)", iScreenWidth, iScreenHeight);
  152.  
  153.     ChangeWindowBox(hWndMenu, 0, 0, iScreenWidth, iScreenHeight / 9);
  154.     ChangeWindowBox(hWndPersp, iScreenWidth/2, iScreenHeight / 9, iScreenWidth/2, 4 * iScreenHeight / 9);
  155.     ChangeWindowBox(hWndTop, 0, iScreenHeight / 9, iScreenWidth/2, 4 * iScreenHeight / 9);
  156.     ChangeWindowBox(hWndFace, 0, 5 * iScreenHeight / 9, iScreenWidth/2, 4 * iScreenHeight / 9);
  157.     ChangeWindowBox(hWndRight, iScreenWidth/2, 5 * iScreenHeight / 9, iScreenWidth/2, 4 * iScreenHeight / 9);
  158.  
  159.     // Laisser à Intuition le temps de flusher ses buffers de rendering
  160.     Delay(5); // * 20 ms soit 100 ms
  161. #endif
  162. }
  163.  
  164. // Mettre à jour les menus en fonction des variables de mode courant
  165. void vUpdateMenu(void)
  166. {
  167. /*
  168.     HMENU hMenu = GetMenu(hWndMenu);
  169.     CheckMenuItem(hMenu, ID_EDITION_GRILLE, MF_BYCOMMAND | (bGrid ? MF_CHECKED : MF_UNCHECKED));
  170.     CheckMenuItem(hMenu, ID_EDITION_COORDONNES, MF_BYCOMMAND | (bCoords ? MF_CHECKED : MF_UNCHECKED));
  171.     CheckMenuItem(hMenu, ID_OBSERVATEUR_MODE_POINT, MF_BYCOMMAND | (dFillMode == D3DFILL_POINT ? MF_CHECKED : MF_UNCHECKED));
  172.     CheckMenuItem(hMenu, ID_OBSERVATEUR_MODE_FILDEFERF, MF_BYCOMMAND | (dFillMode == D3DFILL_WIREFRAME ? MF_CHECKED : MF_UNCHECKED));
  173.     CheckMenuItem(hMenu, ID_OBSERVATEUR_MODE_FACETTES, MF_BYCOMMAND | (dFillMode == D3DFILL_SOLID ? MF_CHECKED : MF_UNCHECKED));
  174.     CheckMenuItem(hMenu, ID_OBSERVATEUR_MODE_ZBUFFER, (dZBuf == D3DZB_TRUE ? MF_CHECKED : MF_UNCHECKED));
  175.     CheckMenuItem(hMenu, ID_OBSERVATEUR_MODE_TRANSPARENCEALPHABLENDING, (bAlpha ? MF_CHECKED : MF_UNCHECKED));
  176.     CheckMenuItem(hMenu, ID_OBSERVATEUR_MODE_ECLAIRAGESPCULAIRE, (bSpecular ? MF_CHECKED : MF_UNCHECKED));
  177.  
  178.     CheckMenuItem(hMenu, ID_OUTILS_AUCUN, MF_BYCOMMAND | MF_UNCHECKED);
  179.     CheckMenuItem(hMenu, ID_OUTILS_SLECTEUR, MF_BYCOMMAND | MF_UNCHECKED);
  180.     CheckMenuItem(hMenu, ID_OUTILS_DSLECTEUR, MF_BYCOMMAND | MF_UNCHECKED);
  181.     CheckMenuItem(hMenu, ID_OUTILS_AIMANT, MF_BYCOMMAND | MF_UNCHECKED);
  182.     CheckMenuItem(hMenu, ID_OUTILS_COURBE, MF_BYCOMMAND | MF_UNCHECKED);
  183.     CheckMenuItem(hMenu, ID_OUTILS_EXTRUDEUR, MF_BYCOMMAND | MF_UNCHECKED);
  184.     CheckMenuItem(hMenu, ID_OUTILS_ARTES, MF_BYCOMMAND | MF_UNCHECKED);
  185.     CheckMenuItem(hMenu, ID_OUTILS_PINCE, MF_BYCOMMAND | MF_UNCHECKED);
  186.  
  187.     CheckMenuItem(hMenu, ID_SPCIFICITSDX7D3DIM_RENDERSTATE_BACKFACECULLINGMODE_NONE, MF_BYCOMMAND | MF_UNCHECKED);
  188.     CheckMenuItem(hMenu, ID_SPCIFICITSDX7D3DIM_RENDERSTATE_BACKFACECULLINGMODE_CW, MF_BYCOMMAND | MF_UNCHECKED);
  189.     CheckMenuItem(hMenu, ID_SPCIFICITSDX7D3DIM_RENDERSTATE_BACKFACECULLINGMODE_CCW, MF_BYCOMMAND | MF_UNCHECKED);
  190.     CheckMenuItem(hMenu, ID_SPCIFICITSDX7D3DIM_RENDERSTATE_ANTIALIAS, (bAntialias ? MF_CHECKED : MF_UNCHECKED));
  191.  
  192.     switch(dCull)
  193.     {
  194.         case D3DCULL_NONE:
  195.             CheckMenuItem(hMenu, ID_SPCIFICITSDX7D3DIM_RENDERSTATE_BACKFACECULLINGMODE_NONE, MF_BYCOMMAND | MF_CHECKED);
  196.             break;
  197.  
  198.         case D3DCULL_CW:
  199.             CheckMenuItem(hMenu, ID_SPCIFICITSDX7D3DIM_RENDERSTATE_BACKFACECULLINGMODE_CW, MF_BYCOMMAND | MF_CHECKED);
  200.             break;
  201.  
  202.         case D3DCULL_CCW:
  203.             CheckMenuItem(hMenu, ID_SPCIFICITSDX7D3DIM_RENDERSTATE_BACKFACECULLINGMODE_CCW, MF_BYCOMMAND | MF_CHECKED);
  204.             break;
  205.     }
  206.  
  207.     switch(cTool)
  208.     {
  209.         case XDC_TOOL_NONE:
  210.             CheckMenuItem(hMenu, ID_OUTILS_AUCUN, MF_BYCOMMAND | MF_CHECKED);
  211.             break;
  212.  
  213.         case XDC_TOOL_SELECT:
  214.             CheckMenuItem(hMenu, ID_OUTILS_SLECTEUR, MF_BYCOMMAND | MF_CHECKED);
  215.             break;
  216.  
  217.         case XDC_TOOL_UNSELECT:
  218.             CheckMenuItem(hMenu, ID_OUTILS_DSLECTEUR, MF_BYCOMMAND | MF_CHECKED);
  219.             break;
  220.  
  221.         case XDC_TOOL_MAGNET:
  222.             CheckMenuItem(hMenu, ID_OUTILS_AIMANT, MF_BYCOMMAND | MF_CHECKED);
  223.             break;
  224.  
  225.         case XDC_TOOL_CURVE:
  226.             CheckMenuItem(hMenu, ID_OUTILS_COURBE, MF_BYCOMMAND | MF_CHECKED);
  227.             break;
  228.  
  229.         case XDC_TOOL_EXTRUDE:
  230.             CheckMenuItem(hMenu, ID_OUTILS_EXTRUDEUR, MF_BYCOMMAND | MF_CHECKED);
  231.             break;
  232.  
  233.         case XDC_TOOL_EDGE:
  234.             CheckMenuItem(hMenu, ID_OUTILS_ARTES, MF_BYCOMMAND | MF_CHECKED);
  235.             break;
  236.  
  237.         case XDC_TOOL_GRAB:
  238.             CheckMenuItem(hMenu, ID_OUTILS_PINCE, MF_BYCOMMAND | MF_CHECKED);
  239.             break;
  240.     }
  241. */
  242. }
  243.  
  244.  
  245. // Gérer les messages de la fenêtre menu / trace
  246. LRESULT CALLBACK lrMenuWndProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
  247. {
  248.     static int iCurveStartVertex, iCurveLastVertex;
  249.     int wmId, wmEvent, iCnt, jCnt;
  250.     float fDist;
  251.     SMALLBOOL bShouldRedraw, bSelectState;
  252.     char cKey;
  253.     DWORD dwTime;
  254.     D3DCOLORVALUE   dcvDiffuse  = {1.f, 1.f, 1.f, 0.f},
  255.                     dcvSpecular = {1.f, 1.f, 1.f, 0.f},
  256.                     dcvAmbient  = {1.f, 1.f, 1.f, 0.f};
  257.  
  258.     // vTrace("Message fenêtre menu type %d, wP %d, lP %d", uMsg, wParam, lParam);
  259.  
  260.     switch( uMsg )
  261.     {
  262. /*
  263.     case WM_CREATE :
  264.         // Mettre à jour les toggle flags des menus en fonction de l'état des variables de mode
  265.         vUpdateMenu();
  266.         break;
  267. */
  268.     case WM_COMMAND :
  269.          wmId    = LOWORD(wParam);
  270.          wmEvent = HIWORD(wParam);
  271.  
  272.          switch (wmId) {
  273.  
  274.             //////////////////////////////////// M E N U  P R O J E T ///////////////
  275.             case ID_PROJET_CHARGER_SCNESCULPT :
  276.                 // Charger la scène Sculpt
  277.                 vLoadSculpt();
  278.  
  279.                 // Mettre à jour les variables d'état du pipe D3D et tout redessiner
  280.                 vSetD3DState();
  281.                 goto _RedrawAll;
  282.  
  283.             case ID_PROJET_CHARGER_SCNESKULPTD3DW3D :
  284.                 // Charger la scène
  285.                 vLoadBin();
  286.  
  287.                 // Mettre à jour les variables d'état du pipe D3D et tout redessiner
  288.                 vSetD3DState();
  289.                 goto _RedrawAll;
  290.  
  291.             case ID_PROJET_CHARGER_SCNEDIRECTX :
  292.                 // Charger la scène
  293.                 vLoadDirectX();
  294.  
  295.                 // Mettre à jour les variables d'état du pipe D3D et tout redessiner
  296.                 vSetD3DState();
  297.                 goto _RedrawAll;
  298.  
  299.             case ID_PROJET_SAUVER_SCNESCULPT :
  300.                 // Sauver la scène Sculpt
  301.                 vSaveSculpt();
  302.                 break;
  303.  
  304.             case ID_PROJET_SAUVER_SCNESKULPTD3DW3D :
  305.                 // Sauver la scène
  306.                 vSaveBin();
  307.                 break;
  308.  
  309.             case ID_PROJET_SAUVER_SCNEDIRECTX :
  310.                 // Sauver la scène
  311.                 vSaveDirectX();
  312.                 break;
  313.  
  314.             case ID_PROJET_APROPOS:
  315.                 vLogo();
  316.                 break;
  317.  
  318.             case ID_PROJET_RSUM :
  319.                 vDescribe();
  320.                 break;
  321.  
  322.             case ID_PROJET_QUITTER:
  323.                DestroyWindow (hWnd);
  324.                break;
  325.  
  326.             //////////////////////////////////// M E N U  E D I T I O N ///////////////
  327.             case ID_EDITION_SLECTIONNER_TOUT:
  328.             case ID_EDITION_DSLECTIONNER_TOUT:
  329.                 // (Dé)Sélectionner les sommets
  330.                 for (iCnt = 0 ; iCnt <= iVertLastUsed ; iCnt++)
  331.                 {
  332.                     if (Vertices[iCnt].bEnabled == FALSE) continue;
  333.                     if (Vertices[iCnt].bHidden == TRUE) continue;
  334.  
  335.                     Vertices[iCnt].bSelected = (wmId == ID_EDITION_SLECTIONNER_TOUT ? TRUE : FALSE);
  336.                 }
  337.  
  338.                 // (Dé)Sélectionner les objets D3D
  339.                 for (iCnt = 0 ; iCnt <= iObjtLastUsed ; iCnt++)
  340.                 {
  341.                     if (Objects[iCnt].bEnabled == FALSE) continue;
  342.                     if (Objects[iCnt].bHidden == TRUE) continue;
  343.  
  344.                     Objects[iCnt].bSelected = (wmId == ID_EDITION_SLECTIONNER_TOUT ? TRUE : FALSE);
  345.                 }
  346.  
  347.                 // Ne pas sélectionner les lampes
  348.                 if (wmId == ID_EDITION_SLECTIONNER_TOUT) goto _SelectDone;
  349.  
  350.                 // Désélectionner les lampes
  351.                 for (iCnt = 0 ; iCnt <= iLampLastUsed ; iCnt++)
  352.                 {
  353.                     if (Lampes[iCnt].bEnabled == FALSE) continue;
  354.  
  355.                     Lampes[iCnt].bSelected = (wmId == ID_EDITION_SLECTIONNER_TOUT ? TRUE : FALSE);
  356.                 }
  357. _SelectDone:
  358.                 vForce2DRefresh(XDC_MODE_COMPLET);
  359.                 break;
  360.  
  361.             case ID_EDITION_SLECTIONNER_NOEUDSCONNEXES:
  362.                 vCollect();
  363.                 vPropagateSelection();
  364.                 vForce2DRefresh(XDC_MODE_COMPLET);
  365.                 break;
  366.  
  367.             case ID_EDITION_SLECTIONNER_NOEUDINDIQU:
  368.             case ID_EDITION_DSLECTIONNER_NOEUDINDIQU:
  369.                 // Attention : en mode menu, ce traitement sélectionne le noeud indiqué.
  370.                 // Il peut aussi être appelé par 2nwndproc.c en mode dé/sélecteur, avec lParam != 0.
  371.                 // Il faut alors dé/sélectionner tous les points dans la zone de tolérance et pas seulement le
  372.                 // premier
  373.  
  374.                 // Chercher le premier point dans la zone curseur
  375.                 iCnt = iFindVertex(Cursor1, -1);
  376.                 bShouldRedraw = FALSE; // Si true à l'issue du traitement alors il faut redessiner la 2D car des points ont changé d'état de sélection
  377.  
  378.                 // Si on n'a pas trouvé alors on cherche une lampe
  379.                 if (iCnt == -1)
  380.                 {
  381.                     PostMessage(hWnd, WM_COMMAND, ID_EDITION_SLECTIONNER_LAMPEINDIQUE, lParam);
  382.                     break;
  383.                 }
  384.  
  385.                 switch(lParam)
  386.                 {
  387.                 case 0: bSelectState = (wmId == ID_EDITION_SLECTIONNER_NOEUDINDIQU ? TRUE : FALSE); break;
  388.                 case XDC_SINGLETOGGLE: bSelectState = !Vertices[iCnt].bSelected; break;
  389.                 case XDC_SELECTALL: bSelectState = TRUE; break;
  390.                 case XDC_DESELECTALL: bSelectState = FALSE; break;
  391.                 }
  392.  
  393.                 while (iCnt != -1)
  394.                 {
  395.                     if (Vertices[iCnt].bSelected != bSelectState)
  396.                     {
  397.                         Vertices[iCnt].bSelected = bSelectState;
  398.                         PostMessage(hWndTop, WM_USER+1, iCnt, 0);
  399.                         PostMessage(hWndFace, WM_USER+1, iCnt, 0);
  400.                         PostMessage(hWndRight, WM_USER+1, iCnt, 0);
  401.                         bShouldRedraw = TRUE;
  402.                     }
  403.  
  404.                     // Trouver le point suivant si on est en mode outil sélecteur (lParam == XDC_SELECTALL)
  405.                     if ((lParam == XDC_SELECTALL) || (lParam == XDC_DESELECTALL))
  406.                         iCnt = iFindVertex(Cursor1, iCnt);
  407.                     else
  408.                         iCnt = -1;
  409.                 }
  410.  
  411.                 // Redessiner partiellement les vues 2D si des points ont été traités
  412.                 if (bShouldRedraw) vForce2DRefresh(XDC_MODE_PARTIEL);
  413.                 break;
  414.  
  415.             case ID_EDITION_SLECTIONNER_LAMPEINDIQUE:
  416.             case ID_EDITION_DSLECTIONNER_LAMPEINDIQUE:
  417.                 // Chercher la lampe dans la zone curseur
  418.                 iCnt = iFindLamp(Cursor1, -1);
  419.                 bShouldRedraw = FALSE; // Si true à l'issue du traitement alors il faut redessiner la 2D car des points ont changé d'état de sélection
  420.  
  421.                 // Si on n'a pas trouvé alors on cherche un objet D3D
  422.                 if (iCnt == -1)
  423.                 {
  424.                     PostMessage(hWnd, WM_COMMAND, ID_EDITION_SLECTIONNER_OBJETD3DINDIQU, lParam);
  425.                     break;
  426.                 }
  427.  
  428.                 switch(lParam)
  429.                 {
  430.                 case 0: bSelectState = (wmId == ID_EDITION_SLECTIONNER_LAMPEINDIQUE ? TRUE : FALSE); break;
  431.                 case XDC_SINGLETOGGLE: bSelectState = !Lampes[iCnt].bSelected; break;
  432.                 case XDC_SELECTALL: bSelectState = TRUE; break;
  433.                 case XDC_DESELECTALL: bSelectState = FALSE; break;
  434.                 }
  435.  
  436.                 while (iCnt != -1)
  437.                 {
  438.                     if (Lampes[iCnt].bSelected != bSelectState)
  439.                     {
  440.                         Lampes[iCnt].bSelected = bSelectState;
  441.                         bShouldRedraw = TRUE;
  442.                     }
  443.                     if ((lParam == XDC_SELECTALL) || (lParam == XDC_DESELECTALL))
  444.                         iCnt = iFindLamp(Cursor1, iCnt);
  445.                     else
  446.                         iCnt = -1;
  447.                 }
  448.                 if (bShouldRedraw) vForce2DRefresh(XDC_MODE_COMPLET);
  449.                 break;
  450.  
  451.             case ID_EDITION_SLECTIONNER_TOUTESLESLAMPES:
  452.             case ID_EDITION_DSLECTIONNER_TOUTESLESLAMPES:
  453.                 for (iCnt = 0 ; iCnt <= iLampLastUsed ; iCnt++)
  454.                     if (Lampes[iCnt].bEnabled)
  455.                         Lampes[iCnt].bSelected = (wmId == ID_EDITION_SLECTIONNER_TOUTESLESLAMPES ? TRUE : FALSE);
  456.                 vForce2DRefresh(XDC_MODE_COMPLET);
  457.                 break;
  458.  
  459.             case ID_EDITION_SLECTIONNER_OBJETD3DINDIQU:
  460.             case ID_EDITION_DSLECTIONNER_OBJETD3DINDIQU:
  461.                 // Chercher le premier point dans la zone curseur
  462.                 iCnt = iFindD3DObject(Cursor1, -1);
  463.                 bShouldRedraw = FALSE; // Si true à l'issue du traitement alors il faut redessiner la 2D car des points ont changé d'état de sélection
  464.  
  465.                 if (iCnt == -1) break;
  466.  
  467.                 switch(lParam)
  468.                 {
  469.                 case 0: bSelectState = (wmId == ID_EDITION_SLECTIONNER_OBJETD3DINDIQU ? TRUE : FALSE); break;
  470.                 case XDC_SINGLETOGGLE: bSelectState = !Objects[iCnt].bSelected; break;
  471.                 case XDC_SELECTALL: bSelectState = TRUE; break;
  472.                 case XDC_DESELECTALL: bSelectState = FALSE; break;
  473.                 }
  474.  
  475.                 while (iCnt != -1)
  476.                 {
  477.                     if (Objects[iCnt].bSelected != bSelectState)
  478.                     {
  479.                         Objects[iCnt].bSelected = bSelectState;
  480.                         bShouldRedraw = TRUE;
  481.                     }
  482.                     if ((lParam == XDC_SELECTALL) || (lParam == XDC_DESELECTALL))
  483.                         iCnt = iFindD3DObject(Cursor1, iCnt);
  484.                     else
  485.                         iCnt = -1;
  486.                 }
  487.                 if (bShouldRedraw) vForce2DRefresh(XDC_MODE_COMPLET);
  488.                 break;
  489.  
  490.             case ID_EDITION_SLECTIONNER_INVERSERLASLECTION:
  491.                 for (iCnt = 0 ; iCnt <= iVertLastUsed ; iCnt++)
  492.                     if (Vertices[iCnt].bEnabled)
  493.                         Vertices[iCnt].bSelected = (Vertices[iCnt].bSelected ? FALSE : TRUE);
  494.                 for (iCnt = 0 ; iCnt <= iObjtLastUsed ; iCnt++)
  495.                     if (Objects[iCnt].bEnabled)
  496.                         Objects[iCnt].bSelected = (Objects[iCnt].bSelected ? FALSE : TRUE);
  497.                 vForce2DRefresh(XDC_MODE_COMPLET);
  498.                 break;
  499.  
  500.             case ID_EDITION_EFFACER_TOUT :
  501.                 vDeleteObjects();
  502.                 goto _RedrawAll;
  503.  
  504.             case ID_EDITION_EFFACER_NOEUDINDIQU:
  505.                 iCnt = iFindVertex(Cursor1, -1);
  506.                 if (iCnt != -1)
  507.                 {
  508.                     if (bDeleteVertex(iCnt))
  509.                         goto _RedrawAll;
  510.                 }
  511.                 else
  512.                     vTrace("*** E0010 : Pas de noeud à proximité du curseur principal");
  513.                 break;
  514.  
  515.             case ID_EDITION_EFFACER_NOAUDSSLECTIONNS:
  516.                 bShouldRedraw = FALSE;
  517.  
  518.                 for (iCnt = 0 ; iCnt <= iVertLastUsed ; iCnt++)
  519.                     if (bIsVertexSelected(iCnt))
  520.                         bShouldRedraw |= bDeleteVertex(iCnt);
  521.                 
  522.                 if (bShouldRedraw)
  523.                     goto _RedrawAll;
  524.                 break;
  525.  
  526.             case ID_EDITION_EFFACER_ARTESSLECTIONNES:
  527.                 bShouldRedraw = FALSE;
  528.                 for (iCnt = 0 ; iCnt <= iEdgeLastUsed ; iCnt++)
  529.                 {
  530.                     if (Edges[iCnt].bEnabled == FALSE) continue;
  531.  
  532.                     if (
  533.                             (Vertices[Edges[iCnt].iSommets[0]].bSelected)
  534.                          && (Vertices[Edges[iCnt].iSommets[1]].bSelected)
  535.                        )
  536.                     {
  537.                        bDeleteEdge(iCnt);
  538.                        bShouldRedraw = TRUE;
  539.                     }
  540.                 }
  541.  
  542.                 if (bShouldRedraw) vForce2DRefresh(XDC_MODE_COMPLET);
  543.                 break;
  544.  
  545.             case ID_EDITION_EFFACER_TRIANGLESSLECTIONNS:
  546.                 bShouldRedraw = FALSE;
  547.                 for (iCnt = 0 ; iCnt <= iTriaLastUsed ; iCnt++)
  548.                 {
  549.                     if (Triangles[iCnt].bEnabled == FALSE) continue;
  550.  
  551.                     if (bIsTriangleSelected(iCnt))
  552.                     {
  553.                        bDeleteTriangle(iCnt);
  554.                        bShouldRedraw = TRUE;
  555.                     }
  556.                 }
  557.  
  558.                 if (bShouldRedraw) goto _RedrawAll;
  559.                 break;
  560.  
  561.             case ID_EDITION_EFFACER_LAMPEINDIQUE:
  562.                 iCnt = iFindLamp(Cursor1, -1);
  563.                 if (iCnt != -1)
  564.                 {
  565.                     if (bDeleteLamp(iCnt))
  566.                         goto _RedrawAll;
  567.                 }
  568.                 else
  569.                     vTrace("*** E0011 : Pas de lampe à proximité du curseur principal");
  570.                 break;
  571.  
  572.             case ID_EDITION_EFFACER_LAMPESSLECTIONNES:
  573.                 bShouldRedraw = FALSE;
  574.                 for (iCnt = 0 ; iCnt <= iLampLastUsed ; iCnt++)
  575.                 {
  576.                     if (Lampes[iCnt].bEnabled == FALSE) continue;
  577.  
  578.                     if (Lampes[iCnt].bSelected)
  579.                     {
  580.                         bDeleteLamp(iCnt);
  581.                         bShouldRedraw = TRUE;
  582.                     }
  583.                 }
  584.  
  585.                 if (bShouldRedraw) goto _RedrawAll;
  586.                 break;
  587.  
  588.             case ID_EDITION_EFFACER_TOUTESLESLAMPES:
  589.                 bShouldRedraw = FALSE;
  590.                 for (iCnt = 0 ; iCnt <= iLampLastUsed ; iCnt++)
  591.                 {
  592.                     if (Lampes[iCnt].bEnabled == FALSE) continue;
  593.                     bDeleteLamp(iCnt);
  594.                     bShouldRedraw = TRUE;
  595.                 }
  596.  
  597.                 if (bShouldRedraw) goto _RedrawAll;
  598.                 break;
  599.  
  600.             case ID_EDITION_MODIFIER_FACETTES :
  601.                 DialogBox(hInst, MAKEINTRESOURCE(IDD_FACE), hWnd, bFaceDlgProc);
  602.                 break;
  603.  
  604.             case ID_EDITION_MODIFIER_LAMPES :
  605.                 DialogBox(hInst, MAKEINTRESOURCE(IDD_LAMP), hWnd, NULL);
  606.                 break;
  607.  
  608.             case ID_EDITION_TRANSFORMER_AGRANDIRRDUIRE:
  609.                 DialogBox(hInst, MAKEINTRESOURCE(IDD_EXPAND), hWnd, bExpandDlgProc);
  610.                 break;
  611.  
  612.             case ID_EDITION_TRANSFORMER_REMPLIR:
  613.                 fill();
  614.                 goto _RedrawAll;
  615.  
  616.             case ID_EDITION_TRANSFORMER_SUBDIVISER:
  617.                 {
  618.                     int iTriNum = iTriaLastUsed;
  619.                     SMALLBOOL *bSubdiv = (SMALLBOOL *) malloc((iTriNum + 1) * sizeof(SMALLBOOL));
  620.                     if (!bSubdiv) break;
  621.                     ZeroMemory(bSubdiv, (iTriNum + 1) * sizeof(SMALLBOOL));
  622.  
  623.                     for (iCnt = 0 ; iCnt <= iTriNum ; iCnt++)
  624.                     {
  625.                         if (Triangles[iCnt].bEnabled == FALSE) continue;
  626.                         bSubdiv[iCnt] = bIsTriangleSelected(iCnt);
  627.                     }
  628.  
  629.                     bShouldRedraw = FALSE;
  630.                     for (iCnt = 0 ; iCnt <= iTriNum ; iCnt++)
  631.                         if (bSubdiv[iCnt])
  632.                         {
  633.                             bSubdivideTriangle(iCnt);
  634.                             bShouldRedraw = TRUE;
  635.                         }
  636.  
  637.                     free(bSubdiv);
  638.  
  639.                     if (bShouldRedraw) goto _RedrawAll;
  640.                 }
  641.                 break;
  642.  
  643.             case ID_EDITION_TRANSFORMER_RPLIQUERSURHLICE:
  644.                 iCnt = DialogBoxParam(hInst, MAKEINTRESOURCE(IDD_HELIX), hWnd, bHelixDlgProc, (LPARAM) 20 << 16 | 20);
  645.                 break;
  646.  
  647. #ifndef _AMIGA_
  648.             case ID_EDITION_TRANSFORMER_LISSERLESNOEUDSSLECTIONNS:
  649.             case ID_EDITION_TRANSFORMER_DLISSERLESNOEUDSSLECTIONNS:
  650.                 bSelectState = (wmId == ID_EDITION_TRANSFORMER_LISSERLESNOEUDSSLECTIONNS);
  651.                 for (iCnt = 0 ; iCnt <= iVertLastUsed ; iCnt++)
  652.                 {
  653.                     if (Vertices[iCnt].bEnabled == FALSE) continue;
  654.                     if (Vertices[iCnt].bSelected == FALSE) continue;
  655.                     if (Vertices[iCnt].bSmooth == bSelectState) continue;
  656.  
  657.                     Vertices[iCnt].bSmooth = bSelectState;
  658.                 }
  659.                 for (iCnt = 0 ; iCnt <= iTriaLastUsed ; iCnt++)
  660.                     if (
  661.                             (Vertices[Triangles[iCnt].iSommets[0]].bSelected)
  662.                          || (Vertices[Triangles[iCnt].iSommets[1]].bSelected)
  663.                          || (Vertices[Triangles[iCnt].iSommets[2]].bSelected)
  664.                        )
  665.                         bUpdateD3DTri(iCnt);
  666.                 goto _RedrawAll;
  667. #endif
  668.  
  669.             case ID_EDITION_TRANSFORMER_CACHERLESNOEUDSSLECTIONNS:
  670.                 vHideSelection();
  671.                 goto _RedrawAll;
  672.  
  673.             case ID_EDITION_TRANSFORMER_RVLERLESNOEUDSCACHS:
  674.                 vRevealHidden();
  675. _RedrawAll:
  676.                 // Tout retracer
  677.                 vForce2DRefresh(XDC_MODE_COMPLET);
  678.                 vForce3DRefresh(XDC_MODE_COMPLET);
  679.                 break;
  680.  
  681.             case ID_EDITION_TRANSFORMER_MULTIVIEW:
  682.                 vRemakeTriview(NULL);
  683.                 break;
  684.  
  685.             case ID_EDITION_AJOUTER_UNCLNE:
  686.                 cTool = XDC_TOOL_GRAB;
  687.                 bCloneSelection(D3DVECTOR(0.f, 0.f, 0.f), XDC_MODE_CLONE);
  688.                 vUpdateMenu();
  689.                 vForce2DRefresh(XDC_MODE_COMPLET);
  690.                 break;
  691.             
  692.             case ID_EDITION_AJOUTER_POINT:
  693.                 iCnt = iMakeVertex(Cursor1, XDC_ALLOWSAME);
  694.                 if (cTool == XDC_TOOL_CURVE)
  695.                 {
  696.                     // Si le vertex n'est pas le premier de la courbe, tracer l'arête et redessiner en mode complet
  697.                     if (iCurveLastVertex != -1)
  698.                     {
  699.                         iMakeEdge(iCurveLastVertex, iCnt);
  700.                         vForce2DRefresh(XDC_MODE_COMPLET);
  701.                     }
  702.                     else // Sinon redessiner en mode partiel après avoir forcé le dessin du point, et mémoriser l'indice du point pour pouvoir refermer la courbe sur 'f'
  703.                     {
  704.                         iCurveStartVertex = iCnt;
  705.                         PostMessage(hWndTop, WM_USER+1, iCnt, 0);
  706.                         PostMessage(hWndFace, WM_USER+1, iCnt, 0);
  707.                         PostMessage(hWndRight, WM_USER+1, iCnt, 0);
  708.                         vForce2DRefresh(XDC_MODE_PARTIEL);
  709.                     }
  710.  
  711.                     iCurveLastVertex = iCnt;
  712.                 }
  713.                 else
  714.                 {
  715.                     // Forcer le dessin du point et rafraichir 2D en mode partiel
  716.                     PostMessage(hWndTop, WM_USER+1, iCnt, 0);
  717.                     PostMessage(hWndFace, WM_USER+1, iCnt, 0);
  718.                     PostMessage(hWndRight, WM_USER+1, iCnt, 0);
  719.                     vForce2DRefresh(XDC_MODE_PARTIEL);
  720.                 }
  721.                 break;
  722.  
  723.             case ID_EDITION_AJOUTER_ARTEOUTRIANGLE:
  724.                 break;
  725.  
  726.             case ID_EDITION_AJOUTER_SPHRE:
  727.             case ID_EDITION_AJOUTER_HMISPHRE:
  728.                 iCnt = DialogBoxParam(hInst, MAKEINTRESOURCE(IDD_SPHERE), hWnd, bSphereDlgProc, (LPARAM) 20 << 16 | 20);
  729.                 if (iCnt == -1) break;
  730.                 
  731.                 // Récupérer le nombre de subdivisions horizontales & verticales
  732.                 // dans le hiword et le loword du code de retour
  733.                 jCnt = HIWORD(iCnt);
  734.                 iCnt = LOWORD(iCnt);
  735.  
  736.                 // Ajouter la sphère
  737.                 vAddSphere(Cursor1, 6.f, iCnt, jCnt, (wmId == ID_EDITION_AJOUTER_HMISPHRE));
  738.                 goto _RedrawAll;
  739.  
  740.             case ID_EDITION_AJOUTER_TORE:
  741.                 iCnt = DialogBoxParam(hInst, MAKEINTRESOURCE(IDD_SPHERE), hWnd, bSphereDlgProc, (LPARAM) 20 << 16 | 20);
  742.                 if (iCnt == -1) break;
  743.                 
  744.                 // Récupérer le nombre de subdivisions horizontales & verticales
  745.                 // dans le hiword et le loword du code de retour
  746.                 jCnt = HIWORD(iCnt);
  747.                 iCnt = LOWORD(iCnt);
  748.  
  749.                 // Ajouter le tore
  750.                 vAddTorus(Cursor1, 7., 6., iCnt, jCnt);
  751.                 goto _RedrawAll;
  752.  
  753.             case ID_EDITION_AJOUTER_BOINGBALL:
  754.                 // Ajouter la boing ball
  755.                 vAddBoing(Cursor1, 6.f);
  756.                 goto _RedrawAll;
  757.  
  758.             case ID_EDITION_AJOUTER_DISQUE:
  759.                 iCnt = DialogBoxParam(hInst, MAKEINTRESOURCE(IDD_SUBDIV), hWnd, bSphereDlgProc, (LPARAM) 20 << 16 | 20);
  760.                 if (iCnt == -1) break;
  761.  
  762.                 // Ajouter le cercle
  763.                 vAddDisk(Cursor1, 6., LOWORD(iCnt));
  764.                 goto _RedrawAll;
  765.  
  766.             case ID_EDITION_AJOUTER_CERCLE:
  767.                 iCnt = DialogBoxParam(hInst, MAKEINTRESOURCE(IDD_SUBDIV), hWnd, bSphereDlgProc, (LPARAM) 20 << 16 | 20);
  768.                 if (iCnt == -1) break;
  769.  
  770.                 // Ajouter le cercle
  771.                 vAddCircle(Cursor1, 6., LOWORD(iCnt));
  772.                 vForce2DRefresh(XDC_MODE_COMPLET);
  773.                 break;
  774.  
  775.             case ID_EDITION_AJOUTER_LAMPE:
  776.                 iMakeLamp(
  777.                         D3DLIGHT_POINT,
  778.                         dcvDiffuse,
  779.                         dcvSpecular,
  780.                         dcvAmbient,
  781.                         Cursor1,
  782.                         D3DVECTOR(0.f, 0.f, 0.f),
  783.                         D3DLIGHT_RANGE_MAX,
  784.                         0.f,
  785.                         0.f,
  786.                         0.1f,
  787.                         0.f,
  788.                         0.f,
  789.                         0.f);
  790.                 goto _RedrawAll;
  791. #ifndef NO3D
  792.             case ID_EDITION_AJOUTER_PRIMITIVESIMPLESHAPED3D_CUBE:
  793.                 if (-1 == (iCnt = iMakeD3DObj())) break;
  794.                 D3DXCreateBox(lpd3dDevice,  5.f, 5.F, 5.f, D3DX_DEFAULT, &Objects[iCnt].pShape);
  795.                 bMoveD3DObj(iCnt, Cursor1);
  796.                 goto _RedrawAll;
  797.  
  798.             case ID_EDITION_AJOUTER_PRIMITIVESIMPLESHAPED3D_CYLINDRE:
  799.                 if (-1 == (iCnt = iMakeD3DObj())) break;
  800.                 D3DXCreateCylinder(lpd3dDevice,  3.f, 3.f, 7.f, D3DX_DEFAULT, D3DX_DEFAULT, D3DX_DEFAULT, &Objects[iCnt].pShape);
  801.                 bMoveD3DObj(iCnt, Cursor1);
  802.                 goto _RedrawAll;
  803.  
  804.             case ID_EDITION_AJOUTER_PRIMITIVESIMPLESHAPED3D_CNE:
  805.                 if (-1 == (iCnt = iMakeD3DObj())) break;
  806.                 D3DXCreateCylinder(lpd3dDevice,  0.f, 4.f, 7.f, D3DX_DEFAULT, D3DX_DEFAULT, D3DX_DEFAULT, &Objects[iCnt].pShape);
  807.                 bMoveD3DObj(iCnt, Cursor1);
  808.                 goto _RedrawAll;
  809.  
  810.             case ID_EDITION_AJOUTER_PRIMITIVESIMPLESHAPED3D_DONUT:
  811.                 if (-1 == (iCnt = iMakeD3DObj())) break;
  812.                 D3DXCreateTorus(lpd3dDevice,  3.f, 7.f, D3DX_DEFAULT, D3DX_DEFAULT, D3DX_DEFAULT, &Objects[iCnt].pShape);
  813.                 bMoveD3DObj(iCnt, Cursor1);
  814.                 goto _RedrawAll;
  815.  
  816.             case ID_EDITION_AJOUTER_PRIMITIVESIMPLESHAPED3D_POLYGONE:
  817.                 if (-1 == (iCnt = iMakeD3DObj())) break;
  818.                 D3DXCreatePolygon(lpd3dDevice,  1.f, 20, D3DX_DEFAULT, &Objects[iCnt].pShape);
  819.                 bMoveD3DObj(iCnt, Cursor1);
  820.                 goto _RedrawAll;
  821.  
  822.             case ID_EDITION_AJOUTER_PRIMITIVESIMPLESHAPED3D_SPHRE:
  823.                 if (-1 == (iCnt = iMakeD3DObj())) break;
  824.                 D3DXCreateSphere(lpd3dDevice,  6.f, D3DX_DEFAULT, D3DX_DEFAULT, D3DX_DEFAULT, &Objects[iCnt].pShape);
  825.                 bMoveD3DObj(iCnt, Cursor1);
  826.                 goto _RedrawAll;
  827.  
  828.             case ID_EDITION_AJOUTER_PRIMITIVESIMPLESHAPED3D_TEAPOT:
  829.                 if (-1 == (iCnt = iMakeD3DObj())) break;
  830.                 D3DXCreateTeapot(lpd3dDevice,  D3DX_DEFAULT, &Objects[iCnt].pShape);
  831.                 bMoveD3DObj(iCnt, Cursor1);
  832.                 if (lParam) // Patch pour ne pas tout redessiner si on est en Timedemo
  833.                     break;
  834.                 goto _RedrawAll;
  835. #endif
  836.  
  837.             case ID_EDITION_AJOUTER_CHANEDECARACTRES:
  838.                 vAddTextOutline();
  839.                 goto _RedrawAll;
  840.  
  841.             case ID_EDITION_COLLER_CURSEURSURNOEUD:
  842.                 jCnt = -1;
  843.                 fDist = 1.0e10f;
  844.  
  845.                 for (iCnt = 0 ; iCnt <= iVertLastUsed ; iCnt++)
  846.                     if ((Vertices[iCnt].bEnabled) && (fDist > SquareMagnitude(Cursor1 - Vertices[iCnt].vPoint)))
  847.                     {
  848.                         jCnt = iCnt;
  849.                         fDist = SquareMagnitude(Cursor1 - Vertices[iCnt].vPoint);
  850.                     }
  851.  
  852.                 if (jCnt > -1)
  853.                 {
  854.                     Cursor1 = Vertices[jCnt].vPoint;
  855.                     vForce2DRefresh(XDC_MODE_PARTIEL);
  856.                 }
  857.                 else
  858.                     vTrace("*** E0012 : Aucun noeud");
  859.                 break;
  860.  
  861.             case ID_EDITION_COLLER_CURSEURSURCENTRE:
  862.                 Cursor1 = vCenter();
  863.                 vForce2DRefresh(XDC_MODE_PARTIEL);
  864.                 break;
  865.  
  866.             case ID_EDITION_GRILLE :
  867.                 bGrid = bGrid ? FALSE : TRUE;
  868.                 vUpdateMenu();
  869.                 vForce2DRefresh(XDC_MODE_COMPLET);
  870.                 break;
  871.  
  872.             case ID_EDITION_GRIDSTEP :
  873.                 iCnt = DialogBoxParam(hInst, MAKEINTRESOURCE(IDD_GRIDSTEP), hWnd, bSphereDlgProc, (LPARAM) (int) (100.f * fGridSize) << 16);
  874.                 if (iCnt == -1) break;
  875.  
  876.                 // Régler pas grille
  877.                 fGridSize = LOWORD(iCnt) / 100.f;
  878.                 vForce2DRefresh(XDC_MODE_COMPLET);
  879.                 break;
  880.  
  881.             case ID_EDITION_COORDONNES :
  882.                 bCoords = bCoords ? FALSE : TRUE;
  883.                 vUpdateMenu();
  884.                 vForce2DRefresh(XDC_MODE_COMPLET);
  885.                 break;
  886.  
  887.             //////////////////////////////////// M E N U  O U T I L ///////////////////////////
  888.             case ID_OUTILS_AUCUN:
  889.                 cTool = XDC_TOOL_NONE;
  890.                 goto _ToolDone;
  891.  
  892.             case ID_OUTILS_SLECTEUR:
  893.                 cTool = XDC_TOOL_SELECT;
  894.                 goto _ToolDone;
  895.  
  896.             case ID_OUTILS_DSLECTEUR:
  897.                 cTool = XDC_TOOL_UNSELECT;
  898.                 goto _ToolDone;
  899.  
  900.             case ID_OUTILS_AIMANT:
  901.                 cTool = XDC_TOOL_MAGNET;
  902.                 goto _ToolDone;
  903.  
  904.             case ID_OUTILS_COURBE:
  905.                 cTool = XDC_TOOL_CURVE;
  906.                 iCurveLastVertex = -1;
  907.                 goto _ToolDone;
  908.  
  909.             case ID_OUTILS_COURBE_FINIRF:
  910.                 if (cTool == XDC_TOOL_CURVE)
  911.                 {
  912.                     // Si la courbe a au moins 2 sommets alors la refermer
  913.                     if (iCurveLastVertex != -1 && iCurveLastVertex != iCurveStartVertex)
  914.                     {
  915.                         if (-1 == iFindEdge(iCurveLastVertex, iCurveStartVertex))
  916.                         {
  917.                             iMakeEdge(iCurveLastVertex, iCurveStartVertex);
  918.                             vForce2DRefresh(XDC_MODE_COMPLET);
  919.                             iCurveLastVertex = -1;
  920.                         }
  921.                         else
  922.                             vTrace("*** E0013 : L'arête de fermeture existe déjà");
  923.                     }
  924.                     else
  925.                         vTrace("*** E0014 : La courbe ne peut être fermée, elle n'a pas au moins 2 points");
  926.                 }
  927.                 goto _ToolDone;
  928.  
  929.             case ID_OUTILS_EXTRUDEUR:
  930.                 cTool = XDC_TOOL_GRAB;
  931.                 bCloneSelection(D3DVECTOR(0.f, 0.0f, 0.f), XDC_MODE_EXTRUDE);
  932.                 vUpdateMenu();
  933.                 vForce2DRefresh(XDC_MODE_COMPLET);
  934.                 break;
  935.  
  936.             case ID_OUTILS_ARTES:
  937.                 cTool = XDC_TOOL_EDGE;
  938.                 goto _ToolDone;
  939.  
  940.             case ID_OUTILS_PINCE:
  941.                 cTool = XDC_TOOL_GRAB;
  942. _ToolDone:
  943.                 vUpdateMenu();
  944. //                vForce2DRefresh(XDC_MODE_PARTIEL);
  945.                 vForce2DRefresh(XDC_MODE_COMPLET);
  946.                 break;
  947.  
  948.             //////////////////////////////////// M E N U  O B S E R V A T E U R ///////////////
  949.             case ID_OBSERVATEUR_DFINIROBSERVATEUR:
  950.                 Observer = Cursor1;
  951.                 D3DUtil_SetViewMatrix(matView,
  952.                       Observer, // From
  953.                       Target,   // To
  954.                       D3DVECTOR(0.f, 0.f, 0.f));
  955.  
  956.                 vForce2DRefresh(XDC_MODE_PARTIEL);
  957.                 goto _ModeDone;
  958.  
  959.             case ID_OBSERVATEUR_DFINIRVISE:
  960.                 Target = Cursor1;
  961.                 D3DUtil_SetViewMatrix(matView,
  962.                       Observer, // From
  963.                       Target,   // To
  964.                       D3DVECTOR(0.f, 0.f, 0.f));
  965.  
  966.                 vForce2DRefresh(XDC_MODE_PARTIEL);
  967.                 goto _ModeDone;
  968.  
  969.             case ID_OBSERVATEUR_MODE_POINT:
  970.                 dFillMode = D3DFILL_POINT;
  971.                 goto _ModeDone;
  972.  
  973.             case ID_OBSERVATEUR_MODE_FILDEFERF:
  974.                 dFillMode = D3DFILL_WIREFRAME;
  975.                 goto _ModeDone;
  976.  
  977.             case ID_OBSERVATEUR_MODE_FACETTES:
  978.                 dFillMode = D3DFILL_SOLID;
  979.                 goto _ModeDone;
  980.  
  981.             case ID_OBSERVATEUR_MODE_ZBUFFER:
  982.                 dZBuf = (dZBuf == D3DZB_TRUE) ? D3DZB_FALSE : D3DZB_TRUE;
  983.                 goto _ModeDone;
  984.  
  985.             //////////////////////////////////// M E N U  M O N D E ///////////////
  986.             case ID_MONDE_ILLUMINATIONGLOBALE :
  987.                 DialogBox(hInst, MAKEINTRESOURCE(IDD_GLOBLIGHT), hWnd, bGlobLightDlgProc);
  988.                 break;
  989.  
  990.             //////////////////////////////////// M E N U  D3D ///////////////
  991.             case ID_SPCIFICITSDX7D3DIM_CHANGERLERENDERDEVICED3D:
  992.                 if (S_OK != D3DEnum_UserChangeDevice(&m_pDeviceInfo))
  993.                     break;
  994.  
  995.                 bReady = FALSE;
  996.  
  997.                 sprintf(cTitle, "%s(%s)", XDC_S_Title3D, m_pDeviceInfo->strDesc);
  998.                 SendMessage(hWndPersp, WM_SETTEXT, 0, (LPARAM)cTitle);
  999.  
  1000.                 if( FAILED( hrCloseD3D(FALSE) ) )
  1001.                     DestroyWindow( hWndMenu );
  1002.  
  1003.                 if( FAILED( hrInitD3D( hWndPersp, m_pDeviceInfo->pDeviceGUID) ) )
  1004.                     DestroyWindow( hWndMenu );
  1005.  
  1006.                 if (FAILED(hrInitWorld( lpd3dDevice )))
  1007.                 {
  1008.                     hrCloseD3D(TRUE);
  1009.                     DestroyWindow( hWndMenu );
  1010.                 }
  1011.  
  1012.                 // Mettre à jour les variables d'état du pipe D3D
  1013.                 vSetD3DState();
  1014.  
  1015.                 // Remettre en service les lampes
  1016.                 for (iCnt = 0 ; iCnt <= iLampLastUsed ; iCnt++)
  1017.                     if (Lampes[iCnt].bEnabled)
  1018.                         bUpdateLamp(iCnt);
  1019.  
  1020.                 bReady = TRUE;
  1021.  
  1022.                 // Redessiner la scène
  1023.                 vForce3DRefresh(XDC_MODE_COMPLET);
  1024.                 break;
  1025.  
  1026.             case ID_SPCIFICITSDX7D3DIM_TRANSPARENCEALPHABLENDING:
  1027.                 bAlpha = bAlpha ? FALSE : TRUE;
  1028.                 goto _ModeDone;
  1029.  
  1030.             case ID_SPCIFICITSDX7D3DIM_ECLAIRAGESPCULAIRE:
  1031.                 bSpecular = bSpecular ? FALSE : TRUE;
  1032. _ModeDone:
  1033.                 // Mettre à jour le menu pour prendre en compte le changement de mode
  1034.                 vUpdateMenu();
  1035.                 
  1036.                 // Mettre à jour les variables d'état du pipe D3D
  1037.                 vSetD3DState();
  1038.                                 
  1039.                 // Redessiner la 3D
  1040.                 vForce3DRefresh(XDC_MODE_COMPLET);
  1041.                 break;
  1042.  
  1043.             case ID_SPCIFICITSDX7D3DIM_RENDERSTATE_ANTIALIAS:
  1044.                 bAntialias = bAntialias ? FALSE:TRUE;
  1045.                 goto _ModeDone;
  1046.                 
  1047.             case ID_SPCIFICITSDX7D3DIM_RENDERSTATE_BACKFACECULLINGMODE_NONE:
  1048.                 dCull = D3DCULL_NONE;
  1049.                 goto _ModeDone;
  1050.  
  1051.             case ID_SPCIFICITSDX7D3DIM_RENDERSTATE_BACKFACECULLINGMODE_CW:
  1052.                 dCull = D3DCULL_CW;
  1053.                 goto _ModeDone;
  1054.  
  1055.             case ID_SPCIFICITSDX7D3DIM_RENDERSTATE_BACKFACECULLINGMODE_CCW:
  1056.                 dCull = D3DCULL_CCW;
  1057.                 goto _ModeDone;
  1058.  
  1059.             case ID_SPCIFICITSDX7D3DIM_TIMEDEMO:
  1060.                 // Tout effacer
  1061.                 SendMessage(hWndMenu, WM_COMMAND, ID_EDITION_EFFACER_TOUT, 0);
  1062.                 
  1063.                 // Recadrer la 2D
  1064.                 fXmin = -10.;                               // Espace de travail triview : X min
  1065.                 fXmax = 10.;                                // Espace de travail triview : X max
  1066.                 fYmin = -10.;                               // Espace de travail triview : Y min
  1067.                 fYmax = 10.;                                // Espace de travail triview : Y max
  1068.                 fZmin = -10.;                               // Espace de travail triview : Z min
  1069.                 fZmax = 10.;                                // Espace de travail triview : Z max
  1070.                 
  1071.                 // Repositionner les fenêtres
  1072.                 SendMessage(hWndMenu, WM_COMMAND, ID_EDITION_TRANSFORMER_MULTIVIEW, 0);
  1073.                 
  1074.                 // Initialiser les matrices view, proj, world
  1075.                 hrInitWorld(lpd3dDevice);
  1076.  
  1077.                 // Prépositionner l'observateur et le target
  1078.                 Target = D3DVECTOR(0.f, 0.f, 0.f);
  1079.                 Observer = D3DVECTOR(7.f, 7.f, 7.f);
  1080.  
  1081.                 // Recalculer les matrices
  1082.                 D3DUtil_SetViewMatrix(matView,
  1083.                           Observer, // From
  1084.                           Target,   // To
  1085.                           D3DVECTOR(0.f, 0.f, 0.f));
  1086.  
  1087.                 // Actualiser les matrices D3D
  1088.                 vSetD3DState();
  1089.  
  1090.                 // Ajouter 3 x 3 x 3 théière
  1091.                 {
  1092.                     int iX, iY, iZ;
  1093.                     for (iX = -3 ; iX < 4 ; iX += 3)
  1094.                         for (iY = -3 ; iY < 4 ; iY += 3)
  1095.                             for (iZ = -3 ; iZ < 4 ; iZ+= 3)
  1096.                             {
  1097.                                 Cursor1 = D3DVECTOR((float) iX, (float) iY, (float) iZ);
  1098.                                 SendMessage(hWndMenu, WM_COMMAND, ID_EDITION_AJOUTER_PRIMITIVESIMPLESHAPED3D_TEAPOT, 1);
  1099.                             }
  1100.                 }
  1101.                 
  1102.                 // Ajouter une lampe
  1103.                 Cursor1 = D3DVECTOR(8.f, 8.f, 8.f);
  1104.                 SendMessage(hWndMenu, WM_COMMAND, ID_EDITION_AJOUTER_LAMPE, 0);
  1105.                 
  1106.                 dwTime = GetTickCount();
  1107.                 for (iCnt = 0 ; iCnt < 90 ; iCnt++)
  1108.                 {
  1109.                     // Repositionner l'observer
  1110.                     Observer = D3DVECTOR(   7.f * sinf(g_2_PI * (float) iCnt / 360.f),
  1111.                                             7.f * cosf(g_2_PI * (float) iCnt / 360.f),
  1112.                                             7.f * sinf(g_2_PI * (float) iCnt / 360.f));
  1113.  
  1114.                     // Recalculer les matrices
  1115.                     D3DUtil_SetViewMatrix(matView,
  1116.                               Observer, // From
  1117.                               Target,   // To
  1118.                               D3DVECTOR(0.f, 0.f, 0.f));
  1119.  
  1120.                     // Actualiser les matrices D3D
  1121.                     vSetD3DState();
  1122.  
  1123.                     // Retracer la 3D
  1124.                     vForce3DRefresh(XDC_MODE_COMPLET);
  1125.                 }
  1126.                 dwTime = GetTickCount() - dwTime;
  1127.                 
  1128.                 // Tout effacer
  1129.                 // SendMessage(hWndMenu, WM_COMMAND, ID_EDITION_EFFACER_TOUT, 0);
  1130.  
  1131.                 vTrace("Timedemo exécutée en %d ms", dwTime);
  1132.                 break;
  1133.  
  1134.             default:
  1135.                 vTrace("*** E0015 : Entrée menu non traitée dans cette version");
  1136.                // return (DefWindowProc(hWnd, uMsg, wParam, lParam));
  1137.          }
  1138.         break;
  1139. /*
  1140.     case WM_MOVE:
  1141.         break;
  1142.  
  1143.     case WM_SIZE:
  1144.         RECT rect;
  1145.  
  1146.         GetClientRect(hWndMenu, &rect);
  1147.         rect.left, rect.top, rect.right, rect.bottom,
  1148.         MoveWindow(hWndTrace, rect.left, rect.top, rect.right - rect.left, rect.bottom - rect.top, TRUE); 
  1149.         break;
  1150.  
  1151.     case WM_GETMINMAXINFO:
  1152.         // Prevent the window from going smaller than some minimum size
  1153.         ((MINMAXINFO*)lParam)->ptMinTrackSize.x = 100;
  1154.         ((MINMAXINFO*)lParam)->ptMinTrackSize.y = 100;
  1155.         break;
  1156. */
  1157.     case WM_CHAR:
  1158.             // Touches clavier :
  1159.             // 'o' : observer <- curseur 1
  1160.             // 't' : target <- curseur 1
  1161.             cKey = (TCHAR) wParam;    // character code 
  1162.             switch(tolower(cKey))
  1163.             {
  1164. #ifdef _DEBUG
  1165.             case 'z' : // Insérer un marqueur de trace
  1166.                 vTrace("********");
  1167.                 break;
  1168. #endif
  1169.             case 4 : // CTRL-D : Magic cookie !
  1170.                 vTrace("Georges, t'es bien curieux !");
  1171.                 vDemo();
  1172.                 break;
  1173.  
  1174.             case 27 :   // ESC : Resizer le triview
  1175.                 PostMessage(hWndMenu, WM_COMMAND, ID_EDITION_TRANSFORMER_MULTIVIEW, 0);
  1176.                 break;
  1177.  
  1178.             case '<' : // Désélectionner tout
  1179.                 PostMessage(hWndMenu, WM_COMMAND, ID_EDITION_DSLECTIONNER_TOUT, 0);
  1180.                 break;
  1181.  
  1182.             case '>' : // Sélectionner tout
  1183.                 PostMessage(hWndMenu, WM_COMMAND, ID_EDITION_SLECTIONNER_TOUT, 0);
  1184.                 break;
  1185.  
  1186.             case '!':
  1187.                 vCollect();
  1188.                 break;
  1189.  
  1190.             case ' ' : // Aucun outil
  1191.                 PostMessage(hWndMenu, WM_COMMAND, ID_OUTILS_AUCUN, 0);
  1192.                 break;
  1193.  
  1194.             case 'c' : // Outil Courbes
  1195.                 PostMessage(hWndMenu, WM_COMMAND, ID_OUTILS_COURBE, 0);
  1196.                 break;
  1197.  
  1198.             case 'f' : // Outil finir courbe
  1199.                 PostMessage(hWndMenu, WM_COMMAND, ID_OUTILS_COURBE_FINIRF, 0);
  1200.                 break;
  1201.  
  1202.             case 'g' : // Outil Grabber
  1203.                 PostMessage(hWndMenu, WM_COMMAND, ID_OUTILS_PINCE, 0);
  1204.                 break;
  1205.  
  1206.             case 'i' : // Inverser la sélection
  1207.                 PostMessage(hWndMenu, WM_COMMAND, ID_EDITION_SLECTIONNER_INVERSERLASLECTION, 0);
  1208.                 break;
  1209.  
  1210.             case 'k' : // Sélectionner les noeuds connexes
  1211.                 PostMessage(hWndMenu, WM_COMMAND, ID_EDITION_SLECTIONNER_NOEUDSCONNEXES, 0);
  1212.                 break;
  1213.  
  1214.             case 'o' :  // Positionner observateur
  1215.                 PostMessage(hWndMenu, WM_COMMAND, ID_OBSERVATEUR_DFINIROBSERVATEUR, 0);
  1216.                 break;
  1217.  
  1218.             case 'p' : // Ajouter point
  1219.                 PostMessage(hWndMenu, WM_COMMAND, ID_EDITION_AJOUTER_POINT, 0);
  1220.                 break;
  1221.  
  1222.             case 'r' :  // Choisir le device de render
  1223.                 PostMessage(hWndMenu, WM_COMMAND, ID_SPCIFICITSDX7D3DIM_CHANGERLERENDERDEVICED3D, 0);
  1224.                 break;
  1225.  
  1226.             case 's' : // Outil Sélecteur
  1227.                 PostMessage(hWndMenu, WM_COMMAND, ID_OUTILS_SLECTEUR, 0);
  1228.                 break;
  1229.  
  1230.             case 't' :  // Positionner cible
  1231.                 PostMessage(hWndMenu, WM_COMMAND, ID_OBSERVATEUR_DFINIRVISE, 0);
  1232.                 break;
  1233.  
  1234.             case 'u' : // Outil Désélecteur
  1235.                 PostMessage(hWndMenu, WM_COMMAND, ID_OUTILS_DSLECTEUR, 0);
  1236.                 break;
  1237.  
  1238.             case 'x' : // Outil Extrudeur
  1239.                 PostMessage(hWndMenu, WM_COMMAND, ID_OUTILS_EXTRUDEUR, 0);
  1240.                 break;
  1241.  
  1242.             default:
  1243.                 vTrace("Code touche '%c' (%d) reçu", cKey, cKey);
  1244.                 break;
  1245.             }
  1246.         break;
  1247. /*
  1248.     case WM_DISPLAYCHANGE:
  1249.         vTrace("*** Changement résolution écran (%d x %d)", LOWORD(lParam), HIWORD(lParam));
  1250.         vRemakeTriview(lParam);
  1251.         break;
  1252. */
  1253.  
  1254.     case WM_CLOSE:
  1255.         DestroyWindow( hWnd );
  1256.         return 0;
  1257.     
  1258.     case WM_DESTROY:
  1259.         PostQuitMessage(0);
  1260.         return 0L;
  1261.     }
  1262. #ifndef _AMIGA_
  1263.     return DefWindowProc( hWnd, uMsg, wParam, lParam );
  1264. #else
  1265.     return 0;
  1266. #endif
  1267. }
  1268.  
  1269.