home *** CD-ROM | disk | FTP | other *** search
/ AmigActive 26 / AACD 26.iso / AACD / Graphics / sKulpt / skulpt-src / triangulate.cpp < prev    next >
Encoding:
C/C++ Source or Header  |  2000-08-30  |  5.5 KB  |  210 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. // Structure d'interface avec le triangulateur Delaunay
  42. #include "triangulator.h"
  43.  
  44. void fill(void)
  45. {
  46.     int iCnt, iVertices, iEdges, iVertex, iEdge, iTriangles, iTriangle, *pTable = NULL;
  47.     struct triangulateio in, out;
  48.  
  49.      vTrace("Triangulation par méthode Voronoi / Delaunay / Shewchuk / Rupert");
  50.  
  51.     // Calculer le nombre de points (touet la sélection : périphérie + trous)
  52.     iVertices = 0;
  53.     for (iVertex = 0 ; iVertex <= iVertLastUsed ; iVertex++)
  54.         if (bIsVertexSelected(iVertex))
  55.             iVertices++;
  56.  
  57.     vTrace(" * Traitement de %d points", iVertices);
  58.  
  59.     // Si on n'a pas au moins 4 sommets on ne peut pas trianguler
  60.     if (iVertices < 4) return;
  61.  
  62.     // Calculer le nombre de segments
  63.     iEdges = 0;
  64.     for (iEdge = 0 ; iEdge <= iEdgeLastUsed ; iEdge++)
  65.         if (bIsEdgeSelected(iEdge))
  66.             iEdges++;
  67.  
  68.     vTrace(" * Traitement de %d arêtes", iEdges);
  69.  
  70.     // Vérifier la cohérence du nombre de segments par rapport au nombre de points...
  71.     if (iVertices != iEdges)
  72.     {
  73.         vTrace("*** E0030 : Incohérence nombre de sommets / nombre d'arêtes : la structure n'est pas fermée");
  74.         return;
  75.     }
  76.  
  77.     // Préparer la structure d'interface triangulateur
  78.     ZeroMemory(&in, sizeof(in));
  79.     ZeroMemory(&out, sizeof(out));
  80.  
  81.     in.numberofpoints = iVertices;
  82.     if (!(in.pointlist = (double *) malloc(in.numberofpoints * 2 * sizeof(double)))) goto _cleanexit;
  83.  
  84.     in.numberofsegments = iEdges;
  85.     if (!(in.segmentlist = (int *) malloc(in.numberofsegments * 2 * sizeof(int)))) goto _cleanexit;
  86.  
  87.     // Cacher les deux fenêtres 2D non actives
  88.     switch(lWActive)
  89.     {
  90.         case XDC_WID_TOP : // X et Z
  91.             ShowWindow(hWndFace, SW_HIDE);
  92.             ShowWindow(hWndRight, SW_HIDE);
  93.             break;
  94.  
  95.         case XDC_WID_FACE : // X et Y
  96.             ShowWindow(hWndTop, SW_HIDE);
  97.             ShowWindow(hWndRight, SW_HIDE);
  98.             break;
  99.                 
  100.         case XDC_WID_SIDE : // Z et Y
  101.             ShowWindow(hWndTop, SW_HIDE);
  102.             ShowWindow(hWndFace, SW_HIDE);
  103.             break;
  104.     }
  105.  
  106.     // Acquérir la position des trous (trick WM_USER+1 entre 2dWndProc et HoleDlg)
  107.     DialogBoxParam(hInst, MAKEINTRESOURCE(IDD_HOLES), NULL, bHoleDlgProc, 0);
  108.  
  109.     // Positionner les trous
  110.     in.numberofholes = iHoles = 0;
  111.     in.holelist = dHoles;
  112.  
  113.     // Ecrire les coordonnées des points en mémorisant le mapping indices internes / externes
  114.     iCnt = 0;
  115.     if (!(pTable = (int *) malloc(iVertices * sizeof(int)))) goto _cleanexit;
  116.     for (iVertex = 0 ; iVertex <= iVertLastUsed ; iVertex++)
  117.         if (bIsVertexSelected(iVertex))
  118.         {
  119.             switch(lWActive)
  120.             {
  121.                 case XDC_WID_TOP : // X et Z
  122.                     in.pointlist[2 * iCnt + 0]    = Vertices[iVertex].vPoint.x;
  123.                     in.pointlist[2 * iCnt + 1]    = Vertices[iVertex].vPoint.z;
  124.                     break;
  125.  
  126.                 case XDC_WID_FACE : // X et Y
  127.                     in.pointlist[2 * iCnt + 0]    = Vertices[iVertex].vPoint.x;
  128.                     in.pointlist[2 * iCnt + 1]    = Vertices[iVertex].vPoint.y;
  129.                     break;
  130.                         
  131.                 case XDC_WID_SIDE : // Z et Y
  132.                     in.pointlist[2 * iCnt + 0]    = Vertices[iVertex].vPoint.z;
  133.                     in.pointlist[2 * iCnt + 1]    = Vertices[iVertex].vPoint.y;
  134.                     break;
  135.             }
  136.             pTable[iCnt++] = iVertex;
  137.         }
  138.  
  139.     // Ecrire les indices des segments
  140.     iCnt = 0;
  141.     for (iEdge = 0 ; iEdge <= iEdgeLastUsed ; iEdge++)
  142.         if (bIsEdgeSelected(iEdge))
  143.         {
  144.             // Déterminer les indices externes des deux sommets du segment
  145.             int iS0 = -1, iS1 = -1, jCnt = 0;
  146.  
  147.             do
  148.             {
  149.                 if (pTable[jCnt] == Edges[iEdge].iSommets[0]) iS0 = jCnt;
  150.                 if (pTable[jCnt] == Edges[iEdge].iSommets[1]) iS1 = jCnt;
  151.                 jCnt++;
  152.             } while (iS0 == -1 || iS1 == -1);
  153.  
  154.             in.segmentlist[2 * iCnt + 0]    = iS0;
  155.             in.segmentlist[2 * iCnt + 1]    = iS1;
  156.  
  157.             iCnt++;
  158.         }
  159.     
  160.     // Trianguler les points
  161.     triangulate("pzPN", &in, &out, NULL);
  162.  
  163.     // 1 - nombre de triangles
  164.     iTriangles = out.numberoftriangles;
  165.     vTrace(" * %d triangle(s) produit(s)", iTriangles);
  166.  
  167.     // 2 - définition des triangles
  168.     for (iTriangle = 0 ; iTriangle < iTriangles ; iTriangle++)
  169.     {
  170.         int is1, is2, is3;
  171.  
  172.         is1 = pTable[out.trianglelist[iTriangle * 3 + 0]];
  173.         is2 = pTable[out.trianglelist[iTriangle * 3 + 1]];
  174.         is3 = pTable[out.trianglelist[iTriangle * 3 + 2]];
  175.  
  176.         iMakeTriangle(is1, is2, is3, 3);
  177.     }
  178.  
  179.     // Si on a triangulé et qu'il faut supprimer les arêtes, on les supprime
  180.     if (iTriangles && bFillAndRemoveEdges)
  181.         for (iEdge = 0 ; iEdge <= iEdgeLastUsed ; iEdge++)
  182.             if (bIsEdgeSelected(iEdge))
  183.                 bDeleteEdge(iEdge);
  184.  
  185.     // Remontrer les deux fenêtres 2D non actives
  186.     switch(lWActive)
  187.     {
  188.         case XDC_WID_TOP : // X et Z
  189.             ShowWindow(hWndFace, SW_SHOWNA);
  190.             ShowWindow(hWndRight, SW_SHOWNA);
  191.             break;
  192.  
  193.         case XDC_WID_FACE : // X et Y
  194.             ShowWindow(hWndTop, SW_SHOWNA);
  195.             ShowWindow(hWndRight, SW_SHOWNA);
  196.             break;
  197.                 
  198.         case XDC_WID_SIDE : // Z et Y
  199.             ShowWindow(hWndTop, SW_SHOWNA);
  200.             ShowWindow(hWndFace, SW_SHOWNA);
  201.             break;
  202.     }
  203.  
  204. _cleanexit:
  205.     if (pTable) free(pTable);
  206.     if (in.pointlist) free(in.pointlist);
  207.     if (in.segmentlist) free(in.segmentlist);
  208.     if (out.trianglelist) free(out.trianglelist);
  209. }
  210.