home *** CD-ROM | disk | FTP | other *** search
/ Resource for Source: C/C++ / Resource for Source - C-C++.iso / codelib9 / v_11_03 / 1103054a < prev    next >
Encoding:
Text File  |  1995-11-01  |  17.0 KB  |  452 lines
  1. #include "windows.h"
  2. #include <math.h>
  3. #include <stdlib.h>
  4.  
  5. //******************************************************************
  6. //Title:        3D.C
  7. //Author:       Thomas W. Olsen
  8. //Version:      1.0
  9. //Compiler:     Microsoft C/C++ 7.0
  10. //              rc /r 3d.rc
  11. //              cl /c /AL /Gsw /W3 /Oas /Zpe /Zi /FPi 3d.c
  12. //              link /CO /NOD 3d,,, libw llibcew win87em, 3d.def
  13. //              rc 3d.exe
  14. //******************************************************************
  15.  
  16. //*********************** Various Constants ************************
  17.  
  18. #define CENTER              0
  19. #define PI                  3.141593
  20. #define RADIANS(a)          (a * (PI / 180.0))
  21. #define DEGREES(a)          (a * (180.0 / PI))
  22. #define NO_OF_VERTICES      66
  23. #define NO_OF_SURFACES      45
  24. #define NO_OF_SURFACE_VERTICES 220
  25. #define VIEW_RATIO      (40 / 10)
  26. #define MIN_DEGREES          0
  27. #define MAX_DEGREES        359
  28. #define ROTATE_DEGREES       5
  29.  
  30. //********************* Structure Definitions **********************
  31.  
  32. typedef struct tagPOINT3D
  33. {
  34.     double x;
  35.     double y;
  36.     double z;
  37. } POINT3D;
  38.  
  39. typedef struct tagVERTEX
  40. {
  41.     POINT3D world;                      // World Coordinates
  42.     POINT3D eye;                        // Eye Coordinates
  43.     POINT   screen;                     // Screen Coordinates
  44. } VERTEX;
  45.  
  46. typedef struct tagSURFACE
  47. {
  48.     int mapIndex;                       // Index Into the Surface Map Array
  49.     int noOfVertices;                   // No of Vertices Forming the Surface
  50.     int depthIndex;                     // Used in Determining Depth of Surface
  51.     int brushColor;
  52. } SURFACE;
  53.  
  54. typedef struct tagOBJECT
  55. {
  56.     VERTEX  vertex[NO_OF_VERTICES];
  57.     SURFACE info[NO_OF_SURFACES];
  58.     int     map[NO_OF_SURFACE_VERTICES];
  59. } OBJECT;
  60.  
  61. //************************** Static Data ***************************
  62.  
  63. OBJECT f16 = 
  64. {   
  65.     {   // Vertex Array
  66.         {  0.00,  0.00, 0.00 },                             //Center
  67.         { 0.00, -17.00, 9.00 }, {  0.00, -13.00, 9.00 },    //Tail
  68.         { 0.00, -14.50, 3.00 }, { 0.00, -8.00,  3.00 },
  69.         { 0.00, -14.50,  2.00 }, { 0.00, -5.00,  2.00 },
  70.         { -0.50, -16.00,  1.00 }, { -1.00, -16.00,  0.00 }, //Exhaust
  71.         { -0.50, -16.00, -0.50 }, { 0.00, -16.00, -1.00 },
  72.         { 0.50, -16.00, -0.50 }, { 1.00, -16.00,  0.00 },
  73.         { 0.50, -16.00,  1.00 },
  74.         { -1.00, -13.00,  2.00 }, { -2.00, -13.00,  0.00 }, //Fuse
  75.         { -1.50, -13.00, -1.50 }, { 0.00, -13.00, -2.00 },
  76.         { 1.50, -13.00, -1.50 }, { 2.00, -13.00,  0.00 },
  77.         { 1.00, -13.00,  2.00 }, { -1.00,  7.00,  2.00 },
  78.         { -2.00,  7.00,  0.00 }, { -1.50,  7.00, -1.50 },
  79.         { 0.00,  7.00, -2.00 },  { 1.50,  7.00, -1.50 },
  80.         { 2.00,  7.00,  0.00 }, { 1.00,  7.00,  2.00 },
  81.         { 2.00, -8.00,  0.00 }, { 11.00, -8.00,  0.00 },    //Wings
  82.         { 11.00, -5.00,  0.00 }, { 5.00,  0.00,  0.00 },
  83.         { 2.00,  7.00,  0.00 }, { -2.00, -8.00,  0.00 },
  84.         { -11.00, -8.00,  0.00 }, { -11.00, -5.00,  0.00 },
  85.         { -5.00,  0.00,  0.00 }, { -2.00,  7.00,  0.00 },
  86.         { 0.50,  2.00,  2.00 }, { -0.50,  2.00,  2.00 },    //Cockpit
  87.         { 1.00,  5.00,  2.00 }, { 0.50,  5.00,  3.50 },
  88.         { -0.50,  5.00,  3.50 }, { -1.00,  5.00,  2.00 },
  89.         { 1.00,  8.00,  2.00 }, { 0.50,  8.00,  3.50 },
  90.         { -0.50,  8.00,  3.50 }, { -1.00,  8.00,  2.00 },
  91.         { 0.50, 11.00,  2.00 }, { -0.50, 11.00,  2.00 },
  92.         { 0.00,  7.00, -1.00 }, { -1.00, 11.00,  2.00 },    //Subfuse
  93.         { -2.00, 11.00,  0.00 }, { 0.00, 11.00, -1.00 },
  94.         { 2.00, 11.00,  0.00 }, { 1.00, 11.00,  2.00 },
  95.         { 0.00, 11.00, -1.00 }, { 0.00, 17.00,  0.00 },     //Nose
  96.         { -2.00, -16.00, 0.00 }, { -8.00, -16.00,  0.00 },  //Elevators
  97.         { -8.00, -14.00,  0.00 }, { -2.00, -10.00, 0.00 },
  98.         { 2.00, -16.00, 0.00 }, { 8.00, -16.00, 0.00 },
  99.         { 8.00, -14.00, 0.00 }, { 2.00, -10.00, 0.00 }
  100.     },
  101.     {   // Surface Info ... (Points to Surface Map)
  102.         { 0,  5, 60,  DKGRAY_BRUSH }, { 5,  5, 64,  DKGRAY_BRUSH }, //Elevators
  103.         { 10, 5, 60,  DKGRAY_BRUSH }, { 15, 5, 64,  DKGRAY_BRUSH },
  104.         { 20, 5,  1,  GRAY_BRUSH },   { 25, 5,  4,  LTGRAY_BRUSH },   //Tail
  105.         { 30, 5,  1,  GRAY_BRUSH },   { 35, 5,  4,  LTGRAY_BRUSH },
  106.         { 40, 5, 14,  BLACK_BRUSH },  { 45, 5, 15,  DKGRAY_BRUSH },   //Exhaust
  107.         { 50, 5, 16,  BLACK_BRUSH },  { 55, 5, 17,  BLACK_BRUSH },
  108.         { 60, 5, 18,  DKGRAY_BRUSH }, { 65, 5, 19,  BLACK_BRUSH },
  109.         { 70, 5,  20, DKGRAY_BRUSH },
  110.         { 75, 5,  22, DKGRAY_BRUSH }, { 80, 5,  23, GRAY_BRUSH },   //Fuse
  111.         { 85, 5,  24, DKGRAY_BRUSH }, { 90, 5,  25, DKGRAY_BRUSH },
  112.         { 95, 5,  26, GRAY_BRUSH },   { 100, 5, 27, DKGRAY_BRUSH },
  113.         { 105, 5, 20, GRAY_BRUSH, },
  114.         { 110, 6, 30, DKGRAY_BRUSH }, { 116, 6, 35, DKGRAY_BRUSH }, //Wings
  115.         { 122, 6, 30, DKGRAY_BRUSH }, { 128, 6, 35, DKGRAY_BRUSH },
  116.         { 134, 5, 21, LTGRAY_BRUSH }, { 139, 5, 22, LTGRAY_BRUSH }, //Subfuse
  117.         { 144, 5, 50, LTGRAY_BRUSH }, { 149, 5, 26, LTGRAY_BRUSH },
  118.         { 154, 5, 27, LTGRAY_BRUSH },
  119.         { 159, 4, 55, GRAY_BRUSH },   { 163, 4, 54, GRAY_BRUSH },   //Nose
  120.         { 167, 4, 56, GRAY_BRUSH },   { 171, 4, 52, GRAY_BRUSH },
  121.         { 175, 4, 51, LTGRAY_BRUSH },
  122.         { 179, 5, 41, WHITE_BRUSH },  { 184, 5, 45, WHITE_BRUSH },   //Cockpit
  123.         { 189, 5, 46, WHITE_BRUSH },  { 194, 4, 41, WHITE_BRUSH },
  124.         { 198, 4, 42, WHITE_BRUSH },  { 202, 5, 41, WHITE_BRUSH },
  125.         { 207, 5, 46, WHITE_BRUSH },  { 212, 4, 45, WHITE_BRUSH },
  126.         { 216, 4, 46, WHITE_BRUSH }
  127.     },
  128.     {   // Surface Map ... (Points to Vertex Array)
  129.         58, 61, 60, 59, 58, 62, 63, 64, 65, 62, 58, 59, 60, 61, 58, // Elevators
  130.         62, 65, 64, 63, 62,
  131.          1,  3,  4,  2,  1, 3,  5,  6,  4,  3, 1,  2,  4,  3,  1,   // Tail
  132.          3,  4,  6,  5,  3,
  133.         14, 15,  8,  7, 14, 15, 16,  9,  8, 15, 16, 17, 10,  9, 16, // Exhaust
  134.         17, 18, 11, 10, 17, 18, 19, 12, 11, 18, 19, 20, 13, 12, 19,
  135.         20, 14,  7, 13, 20,
  136.         14, 21, 22, 15, 14, 15, 22, 23, 16, 15, 16, 23, 24, 17, 16, // Fuse
  137.         17, 24, 25, 18, 17, 18, 25, 26, 19, 18, 19, 26, 27, 20, 19,
  138.         20, 27, 21, 14, 20,
  139.         28, 29, 30, 31, 32, 28, 33, 37, 36, 35, 34, 33, 28, 32, 31, // Wings
  140.         30, 29, 28, 33, 34, 35, 36, 37, 33,
  141.         21, 51, 52, 22, 21, 22, 52, 53, 50, 22, 50, 53, 54, 26, 50, // Subfuse
  142.         26, 54, 55, 27, 26, 27, 55, 51, 21, 27,
  143.         55, 54, 57, 55, 54, 56, 57, 54, 56, 52, 57, 56, 52, 51, 57, 52, // Nose
  144.         51, 55, 57, 51,
  145.         41, 42, 39, 38, 41, 45, 46, 42, 41, 45, 48, 49, 46, 45, 48, // Cockpit
  146.         40, 41, 38, 40, 42, 43, 39, 42, 44, 45, 41, 40, 44,
  147.         46, 47, 43, 42, 46, 48, 45, 44, 48, 49, 47, 46, 49
  148.     }
  149. };
  150.  
  151. BOOL wireFrame = FALSE;
  152. double distance = 75, thetaDegrees = 90, phiDegrees = 60;
  153.  
  154. //************************** Static Data ***************************
  155.  
  156. LONG FAR PASCAL WindowProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam);
  157. void DrawObject(HWND hWnd, HDC hDC, OBJECT *object );
  158. int __cdecl compareProc( const void *elem1, const void *elem2 );
  159.  
  160. //************************** Program Begin *************************
  161.  
  162. int PASCAL WinMain(HANDLE hInst, HANDLE hPrevInst, LPSTR lpCmdLine, int numCmdShow )
  163. {
  164.     MSG       msg;
  165.     HWND      hWnd;
  166.     WNDCLASS  wc;
  167.  
  168.     //************************* Setup Window ************************
  169.  
  170.     wc.style         = (UINT) NULL;
  171.     wc.lpfnWndProc   = WindowProc;
  172.     wc.cbClsExtra    = 0;
  173.     wc.cbWndExtra    = 0;
  174.     wc.hInstance     = hInst;
  175.     wc.hIcon         = LoadIcon( NULL, IDI_APPLICATION);
  176.     wc.hCursor       = LoadCursor( NULL, IDC_ARROW);
  177.     wc.hbrBackground = GetStockObject(BLACK_BRUSH);
  178.     wc.lpszMenuName  = (LPSTR) "Menu";
  179.     wc.lpszClassName = (LPSTR) "3DClass";
  180.  
  181.     if (!RegisterClass(&wc))
  182.         return(FALSE);
  183.  
  184.     hWnd = CreateWindow( "3DClass", "3D Modeling Example",
  185.                           WS_OVERLAPPEDWINDOW | WS_VSCROLL | WS_HSCROLL,
  186.                           CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT,
  187.                           CW_USEDEFAULT, NULL, NULL, hInst, NULL );
  188.     if (!hWnd)
  189.         return (FALSE);
  190.  
  191.     SetScrollRange( hWnd, SB_HORZ, MIN_DEGREES, MAX_DEGREES, TRUE );
  192.     SetScrollRange( hWnd, SB_VERT, MIN_DEGREES, MAX_DEGREES, TRUE );
  193.     SetScrollPos( hWnd, SB_HORZ, (int) thetaDegrees, TRUE );
  194.     SetScrollPos( hWnd, SB_VERT, (int) phiDegrees, TRUE );
  195.  
  196.     ShowWindow( hWnd, numCmdShow );
  197.  
  198.     while (GetMessage(&msg, NULL, NULL, NULL))  /* Typical Message Loop */
  199.     {
  200.         TranslateMessage(&msg);
  201.         DispatchMessage(&msg);
  202.     }
  203.  
  204.     return (msg.wParam);
  205. }
  206.  
  207.  
  208. LONG FAR PASCAL WindowProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
  209. {
  210.     PAINTSTRUCT paint;
  211.     HDC hDC;
  212.     HMENU hMenu;
  213.     int vPos, hPos;
  214.  
  215.     switch (message)
  216.     {
  217.         case WM_COMMAND:
  218.             hMenu = GetMenu( hWnd );
  219.             CheckMenuItem( hMenu, wParam, MF_CHECKED);
  220.  
  221.             if (wParam == 1)
  222.             {
  223.                 CheckMenuItem( hMenu, 2, MF_UNCHECKED);
  224.                 wireFrame = TRUE;
  225.             }
  226.             else
  227.             {
  228.                 CheckMenuItem( hMenu, 1, MF_UNCHECKED);
  229.                 wireFrame = FALSE;
  230.             }
  231.  
  232.             InvalidateRect( hWnd, NULL, TRUE );
  233.             break;
  234.  
  235.         case WM_DESTROY:
  236.             PostQuitMessage( NULL );
  237.             break;
  238.  
  239.         case WM_HSCROLL:
  240.             if (wParam == SB_THUMBTRACK)
  241.                 break;
  242.  
  243.             hPos = GetScrollPos( hWnd, SB_HORZ);
  244.  
  245.             switch( wParam )
  246.             {
  247.                 case SB_TOP:
  248.                     hPos = MIN_DEGREES;
  249.                     break;
  250.                 case SB_BOTTOM:
  251.                     hPos = MAX_DEGREES;
  252.                     break;
  253.                 case SB_LINEUP:
  254.                 case SB_PAGEUP:
  255.                     hPos -= ROTATE_DEGREES;
  256.                     break;
  257.                 case SB_PAGEDOWN:
  258.                 case SB_LINEDOWN:
  259.                     hPos += ROTATE_DEGREES;
  260.                     break;
  261.                 case SB_THUMBPOSITION:
  262.                     hPos = LOWORD(lParam);
  263.                     break;
  264.             }
  265.  
  266.             if (hPos < MIN_DEGREES)
  267.                 hPos = MAX_DEGREES;
  268.             else
  269.             if (hPos > MAX_DEGREES)
  270.                 hPos = MIN_DEGREES;
  271.  
  272.             SetScrollPos( hWnd, SB_HORZ, hPos, TRUE );
  273.             thetaDegrees = (double) hPos;
  274.             InvalidateRect( hWnd, NULL, TRUE );
  275.             break;
  276.  
  277.         case WM_VSCROLL:
  278.             if (wParam == SB_THUMBTRACK)
  279.                 break;
  280.  
  281.             vPos = GetScrollPos( hWnd, SB_VERT );
  282.  
  283.             switch( wParam )
  284.             {
  285.                 case SB_TOP:
  286.                     vPos = MIN_DEGREES;
  287.                     break;
  288.                 case SB_BOTTOM:
  289.                     vPos = MAX_DEGREES;
  290.                     break;
  291.                 case SB_LINEUP:
  292.                 case SB_PAGEUP:
  293.                     vPos -= ROTATE_DEGREES;
  294.                     break;
  295.                 case SB_PAGEDOWN:
  296.                 case SB_LINEDOWN:
  297.                     vPos += ROTATE_DEGREES;
  298.                     break;
  299.                 case SB_THUMBPOSITION:
  300.                     vPos = LOWORD(lParam);
  301.                     break;
  302.             }
  303.  
  304.             if (vPos < MIN_DEGREES)
  305.                 vPos = MAX_DEGREES;
  306.             else
  307.             if (vPos > MAX_DEGREES)
  308.                 vPos = MIN_DEGREES;
  309.  
  310.             SetScrollPos( hWnd, SB_VERT, vPos, TRUE );
  311.             phiDegrees = (double) vPos;
  312.             InvalidateRect( hWnd, NULL, TRUE );
  313.             break;
  314.  
  315.         case WM_SIZE:
  316.             InvalidateRect( hWnd, NULL, TRUE );
  317.             break;
  318.  
  319.  
  320.         case WM_PAINT:
  321.             hDC = BeginPaint( hWnd, &paint );
  322.             DrawObject(hWnd, hDC, &f16);
  323.             ReleaseDC( hWnd, hDC );
  324.             EndPaint( hWnd, &paint );
  325.             break;
  326.  
  327.         default:
  328.             return (DefWindowProc(hWnd, message, wParam, lParam));
  329.     }
  330. }
  331.  
  332.  
  333. void DrawObject(HWND hWnd, HDC hDC, OBJECT *object)
  334. {
  335.     double  sinTheta, cosTheta, sinPhi, cosPhi;
  336.     double  s1, s2, s3;
  337.     POINT3D *v1, *v2, *v3;
  338.     POINT   center;
  339.     RECT    rect;
  340.     POINT   points[10];
  341.     HBITMAP hBitmap, hOldBitmap;
  342.     HRGN    hRgn;
  343.     HDC     hMemDC;
  344.     int     surface, vertex, mapIndex, vertexIndex, loop;
  345.  
  346.     GetClientRect( hWnd, &rect);            // Determine Size of Client Area
  347.     center.x = (rect.right / 2);            // Calculate X-Centerpoint
  348.     center.y = (rect.bottom / 2);           // Calculate Y-Centerpoint
  349.  
  350.     hRgn       = CreateRectRgn( rect.left, rect.top, rect.right, rect.bottom );
  351.     hMemDC     = CreateCompatibleDC( hDC );
  352.     hBitmap    = CreateCompatibleBitmap( hDC, rect.right, rect.bottom);
  353.     hOldBitmap = SelectObject( hMemDC, hBitmap );
  354.  
  355.     //**********************************************************************
  356.     //*                  Precalculate SIN(x) and COS(x)                    *
  357.     //**********************************************************************
  358.  
  359.     cosTheta = cos( RADIANS(thetaDegrees) );
  360.     sinTheta = sin( RADIANS(thetaDegrees) );
  361.     cosPhi   = cos( RADIANS(phiDegrees) );
  362.     sinPhi   = sin( RADIANS(phiDegrees) );
  363.  
  364.     //******************************************************************
  365.     //*              Calculate Eye and Screen Coordinates              *
  366.     //******************************************************************
  367.  
  368.     for (loop = 1; loop < NO_OF_VERTICES; loop++)
  369.     {
  370.         object->vertex[loop].eye.x =
  371.                             (-object->vertex[loop].world.x * sinTheta) +
  372.                             (object->vertex[loop].world.y * cosTheta);
  373.         object->vertex[loop].eye.y =
  374.                             (-object->vertex[loop].world.x * cosTheta * cosPhi) -
  375.                             (object->vertex[loop].world.y * sinTheta * cosPhi) +
  376.                             (object->vertex[loop].world.z * sinPhi);
  377.         object->vertex[loop].eye.z =
  378.                             (-object->vertex[loop].world.x * sinPhi * cosTheta) -
  379.                             (object->vertex[loop].world.y * sinTheta * sinPhi) -
  380.                             (object->vertex[loop].world.z * cosPhi) + distance;
  381.  
  382.         object->vertex[loop].screen.x = (int)
  383.             (VIEW_RATIO * (object->vertex[loop].eye.x / object->vertex[loop].eye.z) * center.y + center.x);
  384.         object->vertex[loop].screen.y = (int)
  385.             (-VIEW_RATIO * (object->vertex[loop].eye.y / object->vertex[loop].eye.z) * center.y + center.y);
  386.     }
  387.  
  388.     //******************************************************************
  389.     //*                         Draw Object                            *
  390.     //******************************************************************
  391.  
  392.     FillRgn( hMemDC, hRgn, GetStockObject(BLACK_BRUSH));
  393.     SelectObject( hMemDC, GetStockObject(wireFrame == TRUE ? WHITE_PEN:BLACK_PEN) );
  394.  
  395.     if (wireFrame == FALSE)
  396.         qsort( object->info, NO_OF_SURFACES, sizeof(SURFACE), compareProc );
  397.  
  398.     for (surface = 0; surface < NO_OF_SURFACES; surface++)
  399.     {
  400.         mapIndex = object->info[surface].mapIndex;
  401.  
  402.         if (wireFrame == FALSE)  // No Hidden Surface Removal For Wire Frame
  403.         {
  404.             v1 = &object->vertex[ object->map[ mapIndex   ] ].eye;  // Setup pointers to three
  405.             v2 = &object->vertex[ object->map[ mapIndex+1 ] ].eye;  // surface vertices
  406.             v3 = &object->vertex[ object->map[ mapIndex+2 ] ].eye;
  407.  
  408.             s1 = v1->x * (v2->y * v3->z - v3->y * v2->z); s1 = (-1) * s1;
  409.             s2 = v2->x * (v3->y * v1->z - v1->y * v3->z); // Perform dot product on surface
  410.             s3 = v3->x * (v1->y * v2->z - v2->y * v1->z); // vectors to find normal vector
  411.         }
  412.  
  413.         if (wireFrame == TRUE || s1 - s2 - s3 <= 0.0)
  414.         {
  415.             for (vertex = 0; vertex < object->info[surface].noOfVertices; vertex++, mapIndex++)
  416.             {
  417.                 vertexIndex = object->map[mapIndex];
  418.                 points[vertex].x = object->vertex[vertexIndex].screen.x;
  419.                 points[vertex].y = object->vertex[vertexIndex].screen.y;
  420.             }
  421.  
  422.             if (wireFrame == TRUE)
  423.                 Polyline( hMemDC, &points[0], vertex);
  424.             else
  425.             {
  426.                 SelectObject( hMemDC, GetStockObject(object->info[surface].brushColor) );
  427.                 Polygon( hMemDC, &points[0], vertex);
  428.             }
  429.         }
  430.     }
  431.     BitBlt( hDC, 0, 0, rect.right, rect.bottom, hMemDC, 0, 0, SRCCOPY);
  432.  
  433.     SelectObject( hMemDC, hOldBitmap );
  434.     DeleteObject( hBitmap );
  435.     DeleteObject( hRgn );
  436.     DeleteDC( hMemDC );
  437. }
  438.  
  439.  
  440. int __cdecl compareProc( const void *elem1, const void *elem2 )
  441. {
  442.     if( f16.vertex[((SURFACE *) elem1)->depthIndex].eye.z >
  443.         f16.vertex[((SURFACE *) elem2)->depthIndex].eye.z )
  444.         return -1;
  445.     if( f16.vertex[((SURFACE *) elem1)->depthIndex].eye.z <
  446.         f16.vertex[((SURFACE *) elem2)->depthIndex].eye.z )
  447.         return 1;
  448.     else
  449.         return 0;
  450. }
  451. 
  452.