home *** CD-ROM | disk | FTP | other *** search
/ Learn 3D Graphics Programming on the PC / Learn_3D_Graphics_Programming_on_the_PC_Ferraro.iso / rwwin / editmat.c_ / editmat.bin
Encoding:
Text File  |  1995-11-14  |  29.0 KB  |  900 lines
  1. /**********************************************************************
  2.  *
  3.  * File :     editmat.c
  4.  *
  5.  * Abstract : RenderWare paint demo. Material editor module
  6.  *
  7.  **********************************************************************
  8.  *
  9.  * This file is a product of Criterion Software Ltd.
  10.  *
  11.  * This file is provided as is with no warranties of any kind and is
  12.  * provided without any obligation on Criterion Software Ltd. or
  13.  * Canon Inc. to assist in its use or modification.
  14.  *
  15.  * Criterion Software Ltd. will not, under any
  16.  * circumstances, be liable for any lost revenue or other damages arising
  17.  * from the use of this file.
  18.  *
  19.  * Copyright (c) 1995 Criterion Software Ltd.
  20.  * All Rights Reserved.
  21.  *
  22.  * RenderWare is a trademark of Canon Inc.
  23.  *
  24.  ************************************************************************/
  25.  
  26. #ifdef   __WINDOWS_386__
  27.  
  28. #define  INCLUDE_SHELLAPI_H
  29. #define  OEMRESOURCE
  30. #include <windows.h>
  31.  
  32. #else /* __WINDOWS_386__ */
  33.  
  34. #include <windows.h>
  35. #include <shellapi.h>
  36.  
  37. #endif /* __WINDOWS_386__ */
  38.  
  39. #include <stdlib.h>
  40. #include <stdio.h>
  41. #include <string.h>
  42. #include <dos.h>
  43.  
  44. #include <rwlib.h>
  45.  
  46. #include "meditres.h"
  47. #include "editmat.h"
  48.  
  49. #define CAMERA_BACK  CREAL(-13.0)
  50. #define SPACING      CREAL(2.5)
  51.  
  52. #define ERROR_DIALOG_TITLE "RenderWare Material Editor Error"
  53.  
  54. typedef struct
  55. {
  56.     RwReal Amb, Diff, Spec;
  57.     RwRGBColor Col;
  58.     RwTexture *Tex;
  59.     int Geom, Light;
  60.     RwTextureModes TextureModes;
  61.     UINT ChangesMessage;
  62.     HWND User;                  /* this window gets sent the above message (if not null) */
  63.     int Flags;                  /* currently unused - send 0 */
  64.     unsigned short int Changes;
  65.     RwReal Opacity;
  66. }
  67. MAT_DATA;
  68.  
  69. static MAT_DATA CurMat;
  70. static HWND MatHnd;
  71. static RwCamera *pCamera, *pComboCam;
  72. static RwScene *pScene, *pComboScene;
  73. static RwClump *pClump, *pBackClump;
  74. static RwClump *pComboClump;
  75. static RwMaterial *Material;
  76.  
  77. static int CurrentTexture;
  78. static long Current = -1, Checksum;
  79.  
  80. LRESULT CALLBACK PosDlgProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam);
  81. static LONG CreateMsg(HWND hWnd);
  82. static void ScrollMsg(HWND hDlg, short ScrollCode, short Pos, HWND ScrollBar);
  83. static void ScrollTextures(HWND hDlg, short ScrollCode, short Pos, HWND ScrollBar);
  84. static void UpdateClump(HWND hWnd, int Send);
  85. static void AddToTextureList(RwTexture * pTex, RwRGBColor * col);
  86. static void UpdatePolygon(RwPolygon3d * Poly);
  87. static void SetScrollBar(int IdScroll, int IdValue, RwReal Value);
  88. static void RebuildTextureScene(void);
  89. static void DlgCommandMsg(HWND hWnd, WPARAM wParam, LPARAM lParam);
  90. static void UpdateTextureBlob(void);
  91.  
  92. void
  93. SetupControls(void)
  94. {
  95.     int Id;
  96.  
  97.     CurMat.Changes = (unsigned short int) -1;
  98.  
  99.     if (Material != NULL)
  100.     {
  101.         CurMat.Amb = RwGetMaterialAmbient(Material);
  102.         CurMat.Diff = RwGetMaterialDiffuse(Material);
  103.         CurMat.Spec = RwGetMaterialSpecular(Material);
  104.         RwGetMaterialColor(Material, &CurMat.Col);
  105.         CurMat.Geom = RwGetMaterialGeometrySampling(Material);
  106.         CurMat.Light = RwGetMaterialLightSampling(Material);
  107.         CurMat.Opacity = RwGetMaterialOpacity(Material);
  108.         CurMat.Tex = RwGetMaterialTexture(Material);
  109.         CurMat.TextureModes = RwGetMaterialTextureModes(Material);
  110.     }
  111.  
  112.     switch (CurMat.Geom)
  113.     {
  114.         case rwPOINTCLOUD:
  115.             Id = MAT_POINTCLOUD;
  116.             break;
  117.         case rwWIREFRAME:
  118.             Id = MAT_WIREFRAME;
  119.             break;
  120.         default:
  121.         case rwSOLID:
  122.             Id = MAT_SOLID;
  123.             break;
  124.     }
  125.     CheckRadioButton(MatHnd, MAT_POINTCLOUD, MAT_SOLID, Id);
  126.  
  127.     switch (CurMat.Light)
  128.     {
  129.         case rwFACET:
  130.             Id = MAT_FLATSHADE;
  131.             break;
  132.         default:
  133.         case rwVERTEX:
  134.             Id = MAT_SMOOTHSHADE;
  135.             break;
  136.     }
  137.     SendMessage(GetDlgItem(MatHnd, MAT_LIT), BM_SETCHECK, (int) (CurMat.TextureModes & rwLIT), 0L);
  138.     CheckRadioButton(MatHnd, MAT_FLATSHADE, MAT_SMOOTHSHADE, Id);
  139.  
  140.     SetScrollBar(MAT_AMBIENTSCROLL, MAT_AMBIENTVALUE, CurMat.Amb);
  141.     SetScrollBar(MAT_DIFFUSESCROLL, MAT_DIFFUSEVALUE, CurMat.Diff);
  142.     SetScrollBar(MAT_SPECUALRSCROLL, MAT_SPECULARVALUE, CurMat.Spec);
  143.     SetScrollBar(MAT_OPACITYSCROLL, MAT_OPACITYVALUE, CurMat.Opacity);
  144.     SetScrollBar(MAT_REDSCROLL, MAT_REDVALUE, CurMat.Col.r);
  145.     SetScrollBar(MAT_GREENSCROLL, MAT_GREENVALUE, CurMat.Col.g);
  146.     SetScrollBar(MAT_BLUESCROLL, MAT_BLUEVALUE, CurMat.Col.b);
  147.  
  148.     RebuildTextureScene();
  149.  
  150.     UpdateClump(MatHnd, FALSE);
  151.     ShowWindow(MatHnd, SW_SHOW);
  152. }
  153.  
  154. HWND FAR PASCAL
  155. MaterialEditor(RwMaterial *UseMaterial, HINSTANCE Instance, HWND hOwner, HWND User, UINT Message)
  156. {
  157.     HMENU hMenu;
  158.  
  159.     Material = UseMaterial;
  160.     CurMat.User = User;
  161.     CurMat.ChangesMessage = Message;
  162.  
  163.     if (MatHnd == NULL)
  164.     {
  165.         MatHnd = CreateDialog(Instance, "DIALOG_1", hOwner, (DLGPROC) MakeProcInstance((FARPROC) PosDlgProc, Instance));
  166.         if (MatHnd == NULL)
  167.         {
  168.             MessageBox(hOwner, "Internal Operating System Error",
  169.              ERROR_DIALOG_TITLE, MB_OK | MB_ICONEXCLAMATION | MB_APPLMODAL);
  170.             return NULL;
  171.         }
  172.         hMenu = GetSystemMenu(MatHnd, FALSE);
  173.         DeleteMenu(hMenu, 4, MF_BYPOSITION);
  174.         DeleteMenu(hMenu, 2, MF_BYPOSITION);
  175.     }
  176.     else
  177.     {
  178.         if (pCamera == NULL)
  179.         {
  180.             /* We should check for error's here */
  181.             CreateMsg(MatHnd);
  182.         }
  183.         SetupControls();
  184.     }
  185.     return (HWND) MatHnd;
  186. }
  187.  
  188. static void
  189. SetScrollBar(int IdScroll, int IdValue, RwReal Value)
  190. {
  191.     char Buf[10];
  192.  
  193.     SetScrollRange(GetDlgItem(MatHnd, IdScroll), SB_CTL, 0, 100, FALSE);
  194.     SetScrollPos(GetDlgItem(MatHnd, IdScroll), SB_CTL, (int) REAL2INT(RMul(RAdd(Value, CREAL(0.001)), CREAL(100.0))), TRUE);
  195.     sprintf(Buf, "%d.%2.2d", REAL2INT(Value), REAL2INT(RMul(Value, CREAL(100.0))) % 100);
  196.     SetWindowText(GetDlgItem(MatHnd, IdValue), Buf);
  197. }
  198.  
  199. LRESULT CALLBACK
  200. PosDlgProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
  201. {
  202.     DRAWITEMSTRUCT far *pDis;
  203.     COLORREF Colour;
  204.     static HBRUSH RedBrush, GreenBrush, BlueBrush;
  205.     HBRUSH Brush;
  206.     HDC hDC;
  207.     PAINTSTRUCT ps;
  208.     HDROP Drop;
  209.     char Path[_MAX_PATH];
  210.     int i;
  211.  
  212.     switch (msg)
  213.     {
  214.         case WM_DROPFILES:
  215.             Drop = (HDROP) wParam;
  216.             for (i = DragQueryFile(Drop, (UINT) - 1, Path, _MAX_PATH) - 1; i >= 0; --i)
  217.             {
  218.                 DragQueryFile(Drop, (UINT) i, Path, _MAX_PATH);
  219.                 RwGetNamedTexture(Path);
  220.                 RebuildTextureScene();
  221.             }
  222.             DragFinish(Drop);
  223.             break;
  224.         case WM_PAINT:
  225.             if (IsIconic(hWnd))
  226.             {
  227.                 hDC = BeginPaint(hWnd, &ps);
  228.                 RwVCMoveCamera(pCamera, CREAL(2.85), CREAL(-2.85), CREAL(-14.0));
  229.                 RwInvalidateCameraViewport(pCamera);
  230.                 RwBeginCameraUpdate(pCamera, (void *)(DWORD)hWnd);
  231.                 RwClearCameraViewport(pCamera);
  232.                 RwRenderScene(pScene);
  233.                 RwEndCameraUpdate(pCamera);
  234.                 RwShowCameraImage(pCamera, (void *)(DWORD)hDC);
  235.                 RwVCMoveCamera(pCamera, CREAL(-2.85), CREAL(2.85), CREAL(14.0));
  236.                 EndPaint(hWnd, &ps);
  237.             }
  238.             break;
  239.         case WM_INITDIALOG:
  240.             MatHnd = hWnd;
  241.             RedBrush = CreateSolidBrush(RGB(255, 0, 0));
  242.             GreenBrush = CreateSolidBrush(RGB(0, 255, 0));
  243.             BlueBrush = CreateSolidBrush(RGB(0, 0, 255));
  244.             DragAcceptFiles(hWnd, TRUE);
  245.  
  246.             if (CreateMsg(hWnd) == -1)
  247.                 return 0;
  248.             SetupControls();
  249.             return MAT_TEXTURESCROLL;
  250.         case WM_ACTIVATE:      /* keep texture list up to date in case app has loaded more */
  251.             if (wParam != WA_INACTIVE)
  252.             {
  253.                 RebuildTextureScene();
  254.                 return 0;
  255.             }
  256.             return 1;
  257.         case WM_DRAWITEM:
  258. #ifdef    __WINDOWS_386__
  259.             pDis = (DRAWITEMSTRUCT FAR *) MK_FP32((void *) lParam);
  260. #else /* __WINDOWS_386__ */
  261.             pDis = (DRAWITEMSTRUCT FAR *) lParam;
  262. #endif /* __WINDOWS_386__ */
  263.             if ((pDis->itemAction == ODA_DRAWENTIRE) && (wParam == MAT_BUTTON))
  264.             {
  265.                 RwForAllPolygonsInClump(pClump, (RwPolygon3dFuncVoid) UpdatePolygon);
  266.                 UpdateTextureBlob();
  267.                 CurMat.Changes = 0;
  268.                 RwInvalidateCameraViewport(pCamera);
  269.                 RwBeginCameraUpdate(pCamera, (void *)(DWORD)hWnd);
  270.                 RwClearCameraViewport(pCamera);
  271.                 RwRenderScene(pScene);
  272.                 RwEndCameraUpdate(pCamera);
  273.                 RwShowCameraImage(pCamera, (void *)(DWORD)pDis->hDC);
  274.  
  275.                 return 1;
  276.             }
  277.             if ((pDis->itemAction == ODA_DRAWENTIRE) && (wParam == MAT_TEXTUREBUTTON))
  278.             {
  279.  
  280.                 RwInvalidateCameraViewport(pComboCam);
  281.                 RwBeginCameraUpdate(pComboCam, (void *)(DWORD)hWnd);
  282.                 RwClearCameraViewport(pComboCam);
  283.                 RwRenderScene(pComboScene);
  284.                 RwEndCameraUpdate(pComboCam);
  285.                 RwShowCameraImage(pComboCam, (void *)(DWORD)pDis->hDC);
  286.                 return 1;
  287.             }
  288.             break;
  289.         case WM_COMMAND:
  290.             DlgCommandMsg(hWnd, wParam, lParam);
  291.             return 0;
  292.         case WM_HSCROLL:
  293.             {
  294.                 short ScrollCode;
  295.                 short Pos;
  296.                 HWND ScrollBar;
  297.  
  298. #ifdef WIN32
  299.                 ScrollCode = (short) LOWORD(wParam);
  300.                 Pos = (short) HIWORD(wParam);
  301.                 ScrollBar = (HWND) lParam;
  302. #else
  303.                 ScrollCode = (short) wParam;
  304.                 Pos = (short) LOWORD(lParam);
  305.                 ScrollBar = (HWND) HIWORD(lParam);
  306. #endif
  307.                 if (GetDlgCtrlID(ScrollBar) != MAT_TEXTURESCROLL)
  308.                     ScrollMsg(hWnd, ScrollCode, Pos, ScrollBar);
  309.                 else
  310.                     ScrollTextures(hWnd, ScrollCode, Pos, ScrollBar);
  311.                 return 0;
  312.             }
  313.         case WM_DESTROY:
  314.             DeleteObject(RedBrush);
  315.             DeleteObject(GreenBrush);
  316.             DeleteObject(BlueBrush);
  317.         case WM_CLOSE:
  318.             if (pCamera != NULL)
  319.             {
  320.                 ShowWindow(MatHnd, SW_HIDE);
  321.                 RwDestroyCamera(pCamera);
  322.                 RwDestroyCamera(pComboCam);
  323.                 pCamera = pComboCam = NULL;
  324.                 RwDestroyScene(pScene);
  325.                 RwDestroyScene(pComboScene);
  326.                 pScene = pComboScene = NULL;
  327.                 pClump = pComboClump = NULL;
  328.                 Current = -1;
  329.                 CurrentTexture = 0;
  330.             }
  331.             SendMessage(CurMat.User, CurMat.ChangesMessage, 0, (LPARAM) NULL);
  332.             break;
  333.  
  334. #ifdef WIN32
  335.         case WM_CTLCOLORSCROLLBAR:
  336.             Brush = NULL;
  337.             switch (GetDlgCtrlID((HWND) lParam))
  338.             {
  339. #else
  340.                 case WM_CTLCOLOR:
  341.             Brush = NULL;
  342.             switch (GetDlgCtrlID(LOWORD(lParam)))
  343.             {
  344. #endif
  345.                 case MAT_REDSCROLL:
  346.                 case MAT_REDVALUE:
  347.                     Colour = RGB(REAL2INT(RMul(CurMat.Col.r, CREAL(255.0))), 0, 0);
  348.                     Brush = RedBrush;
  349.                     break;
  350.                 case MAT_GREENSCROLL:
  351.                 case MAT_GREENVALUE:
  352.                     Colour = RGB(0, REAL2INT(RMul(CurMat.Col.g, CREAL(255.0))), 0);
  353.                     Brush = GreenBrush;
  354.                     break;
  355.                 case MAT_BLUESCROLL:
  356.                 case MAT_BLUEVALUE:
  357.                     Colour = RGB(0, 0, REAL2INT(RMul(CurMat.Col.b, CREAL(255.0))));
  358.                     Brush = BlueBrush;
  359.                     break;
  360.                 case MAT_REDTEXT:
  361.                     Colour = RGB(255, 0, 0);
  362.                     Brush = RedBrush;
  363.                     break;
  364.                 case MAT_GREENTEXT:
  365.                     Colour = RGB(0, 255, 0);
  366.                     Brush = GreenBrush;
  367.                     break;
  368.                 case MAT_BLUETEXT:
  369.                     Colour = RGB(0, 0, 255);
  370.                     Brush = BlueBrush;
  371.                     break;
  372.             }
  373.             if (Brush != NULL)
  374.             {
  375.                 SetBkColor((HDC) wParam, GetSysColor(COLOR_WINDOW));
  376.                 SetTextColor((HDC) wParam, Colour);
  377.                 return Brush;
  378.             }
  379.             break;
  380.  
  381.     }
  382.     return 0;
  383. }
  384.  
  385. void
  386. SetBackClump(RwPolygon3d * Poly)
  387. {
  388.     static RwRGBColor Col;
  389.  
  390.     RwSetPolygonColorStruct(Poly, &Col);
  391.     RwSetPolygonGeometrySampling(Poly, rwSOLID);
  392.     RwSetPolygonLightSampling(Poly, rwFACET);
  393.     RwSetPolygonAmbient(Poly, CREAL(0.1));
  394.     RwSetPolygonDiffuse(Poly, CREAL(0.3));
  395.     RwSetPolygonSpecular(Poly, CREAL(0.6));
  396.     RwSetPolygonOpacity(Poly, CREAL(1.0));
  397.     RwSetPolygonTexture(Poly, NULL);
  398. }
  399.  
  400. static LONG
  401. CreateMsg(HWND hWnd)
  402. {
  403.     HDC hDC;
  404.     DWORD DialogUnits;
  405.  
  406.     DialogUnits = GetDialogBaseUnits();
  407.  
  408.     RwModelBegin();
  409.     RwClumpBegin();
  410.  
  411.     RwTransformBegin();
  412.     RwRotateCTM(CREAL(1.0), CREAL(0.0), CREAL(0.0), CREAL(90.0));
  413.     RwHemisphere(CREAL(0.6), 6);
  414.     RwTransformEnd();
  415.  
  416.     if (RwClumpEnd(&pClump) == NULL)
  417.     {
  418.         MessageBox(hWnd, "Error creating the RenderWare clump",
  419.              ERROR_DIALOG_TITLE, MB_OK | MB_ICONEXCLAMATION | MB_APPLMODAL);
  420.         return -1L;
  421.     }
  422.     RwModelEnd();
  423.     RwSetClumpHints(pClump, 0L);
  424.  
  425.     RwModelBegin();
  426.     RwClumpBegin();
  427.  
  428.     RwTransformBegin();
  429.     RwRotateCTM(CREAL(1.0), CREAL(1.0), CREAL(0.0), CREAL(45.0));
  430.     RwSphere(CREAL(0.3), 0);
  431.     RwTransformEnd();
  432.     if (RwClumpEnd(&pBackClump) == NULL)
  433.     {
  434.         MessageBox(hWnd, "Error creating the RenderWare clump",
  435.              ERROR_DIALOG_TITLE, MB_OK | MB_ICONEXCLAMATION | MB_APPLMODAL);
  436.         return -1L;
  437.     }
  438.     RwModelEnd();
  439.     RwSetClumpHints(pBackClump, rwCONTAINER);
  440.  
  441.     hDC = GetDC(MatHnd);
  442.     pCamera = RwCreateCamera(256, 256, NULL);
  443.     ReleaseDC(MatHnd, hDC);
  444.  
  445.     if (pCamera == NULL)
  446.     {
  447.         if (RwGetError() == E_RW_NOMEM)
  448.         {
  449.             MessageBox(hWnd, "Insufficient memory to create the RenderWare camera",
  450.              ERROR_DIALOG_TITLE, MB_OK | MB_ICONEXCLAMATION | MB_APPLMODAL);
  451.         }
  452.         else
  453.         {
  454.             MessageBox(hWnd, "Error creating the RenderWare camera",
  455.              ERROR_DIALOG_TITLE, MB_OK | MB_ICONEXCLAMATION | MB_APPLMODAL);
  456.         }
  457.         return -1L;
  458.     }
  459.     RwSetCameraViewwindow(pCamera, CREAL(0.2), CREAL(0.2));
  460.     RwSetCameraViewport(pCamera, 0, 0, (90 * LOWORD(DialogUnits)) / 4, (90 * HIWORD(DialogUnits)) / 8);
  461.     RwRevolveCamera(pCamera, CREAL(180.0));
  462.     RwBeginCameraUpdate(pCamera, (void *)(DWORD)hWnd);
  463.     RwSetCameraBackColor(pCamera, CREAL(0.5), CREAL(0.5), CREAL(0.5));
  464.     RwClearCameraViewport(pCamera);
  465.     RwEndCameraUpdate(pCamera);
  466.  
  467.     pScene = RwCreateScene();
  468.     RwSphericalTexturizeClump(pClump);
  469.  
  470.     RwAddLightToScene(pScene, RwCreateLight(rwPOINT, CREAL(-1.0), CREAL(-1.0), CREAL(1.0), CREAL(1.0)));
  471.     RwVCMoveCamera(pCamera, CREAL(0.0), CREAL(0.0), CREAL(-4.0));
  472.     RwAddClumpToScene(pScene, pClump);
  473.  
  474.     RwAddClumpToScene(pScene, pBackClump);
  475.     RwForAllPolygonsInClump(pBackClump, (RwPolygon3dFuncVoid) SetBackClump);
  476.  
  477.     hDC = GetDC(MatHnd);
  478.     pComboCam = RwCreateCamera(max((144 * LOWORD(DialogUnits)) / 4, 256), 256, NULL);
  479.     ReleaseDC(MatHnd, hDC);
  480.  
  481.     if (pComboCam == NULL)
  482.     {
  483.         if (RwGetError() == E_RW_NOMEM)
  484.         {
  485.             MessageBox(hWnd, "Insufficient memory to create the RenderWare camera",
  486.              ERROR_DIALOG_TITLE, MB_OK | MB_ICONEXCLAMATION | MB_APPLMODAL);
  487.         }
  488.         else
  489.         {
  490.             MessageBox(hWnd, "Error creating the RenderWare camera",
  491.              ERROR_DIALOG_TITLE, MB_OK | MB_ICONEXCLAMATION | MB_APPLMODAL);
  492.         }
  493.         return -1L;
  494.     }
  495.  
  496.     RwSetCameraViewport(pComboCam, 0, 0, (144 * LOWORD(DialogUnits)) / 4, (32 * HIWORD(DialogUnits)) / 8);
  497.     RwBeginCameraUpdate(pComboCam, (void *)(DWORD)hWnd);
  498.     RwSetCameraBackColor(pComboCam, CREAL(0.5), CREAL(0.5), CREAL(0.5));
  499.     RwSetCameraViewwindow(pComboCam, CREAL(0.4), RDiv(RDiv(CREAL(32.0), CREAL(72.0)), CREAL(5.0)));
  500.     RwClearCameraViewport(pComboCam);
  501.     RwEndCameraUpdate(pComboCam);
  502.  
  503.     RwVCMoveCamera(pComboCam, CREAL(0.2), CREAL(0.0), CAMERA_BACK);
  504.  
  505.     ShowWindow(MatHnd, SW_SHOW);
  506.  
  507.     return 1;
  508. }
  509.  
  510. static void
  511. DlgCommandMsg(HWND hWnd, WPARAM wParam, LPARAM lParam)
  512. {
  513.     POINT Where;
  514.     RECT Rect;
  515.     RwPickRecord Pick;
  516.  
  517.     if (HIWORD(lParam) == BN_CLICKED)
  518.     {
  519.         if (wParam == MAT_TEXTUREBUTTON)
  520.         {
  521.             GetCursorPos(&Where);
  522.             GetWindowRect(GetDlgItem(hWnd, MAT_TEXTUREBUTTON), &Rect);
  523.             RwPickScene(pComboScene, Where.x - Rect.left, Where.y - Rect.top, pComboCam, &Pick);
  524.             if (Pick.type == rwPICKCLUMP)
  525.             {
  526.                 CurMat.Changes |= MAT_TEXTURE_CHANGED;
  527.                 CurMat.Tex = RwGetPolygonTexture(Pick.object.clump.polygon);
  528.                 UpdateClump(MatHnd, TRUE);
  529.             }
  530.             return;
  531.         }
  532.  
  533.         if (!IsDlgButtonChecked(hWnd, wParam) && (wParam != MAT_LIT))
  534.             return;
  535.         switch (wParam)
  536.         {
  537.             case MAT_POINTCLOUD:
  538.                 CurMat.Geom = rwPOINTCLOUD;
  539.                 CurMat.Changes |= MAT_GEOM_CHANGED;
  540.                 break;
  541.             case MAT_WIREFRAME:
  542.                 CurMat.Geom = rwWIREFRAME;
  543.                 CurMat.Changes |= MAT_GEOM_CHANGED;
  544.                 break;
  545.             case MAT_SOLID:
  546.                 CurMat.Geom = rwSOLID;
  547.                 CurMat.Changes |= MAT_GEOM_CHANGED;
  548.                 break;
  549.             case MAT_LIT:
  550.                 if (SendMessage(GetDlgItem(MatHnd, MAT_LIT), BM_GETCHECK, 0, 0L) != 0)
  551.                     CurMat.TextureModes |= rwLIT;
  552.                 else
  553.                     CurMat.TextureModes &= ~rwLIT;
  554.                 CurMat.Changes |= MAT_TEXMODE_CHANGED;
  555.                 break;
  556.             case MAT_FLATSHADE:
  557.                 CurMat.Light = rwFACET;
  558.                 CurMat.Changes |= MAT_LIGHT_CHANGED;
  559.                 break;
  560.             default:
  561.             case MAT_SMOOTHSHADE:
  562.                 CurMat.Light = rwVERTEX;
  563.                 CurMat.Changes |= MAT_LIGHT_CHANGED;
  564.                 break;
  565.         }
  566.         UpdateClump(hWnd, TRUE);
  567.     }
  568. }
  569.  
  570. static void
  571. ScrollTextures(HWND hDlg, short ScrollCode, short Pos, HWND ScrollBar)
  572. {
  573.     int oldPos, newPos;
  574.     HWND hScroll = GetDlgItem(hDlg, MAT_TEXTURESCROLL);
  575.  
  576.     oldPos = GetScrollPos(hScroll, SB_CTL);
  577.     newPos = oldPos;
  578.  
  579.     switch (ScrollCode)
  580.     {
  581.         case SB_TOP:
  582.             newPos = 0;
  583.             break;
  584.         case SB_BOTTOM:
  585.             newPos = (int) RwGetNumNamedTextures() + 1;
  586.             break;
  587.         case SB_LINEDOWN:
  588.             newPos++;
  589.             break;
  590.         case SB_PAGEDOWN:
  591.             newPos += 4;
  592.             break;
  593.         case SB_LINEUP:
  594.             newPos--;
  595.             break;
  596.         case SB_PAGEUP:
  597.             newPos -= 4;
  598.             break;
  599.         case SB_THUMBPOSITION:
  600.         case SB_THUMBTRACK:
  601.             newPos = Pos;
  602.             break;
  603.         default:
  604.             return;
  605.     }
  606.  
  607.     newPos = max(newPos, 0);
  608.     newPos = min(newPos, (int) RwGetNumNamedTextures() - 3);
  609.  
  610.     if (newPos != oldPos)
  611.     {
  612.         RwVCMoveCamera(pComboCam, -RMul(INT2REAL(oldPos - newPos), SPACING), CREAL(0.0), CREAL(0.0));
  613.         InvalidateRect(GetDlgItem(hDlg, MAT_TEXTUREBUTTON), NULL, FALSE);
  614.         SetScrollPos(hScroll, SB_CTL, newPos, TRUE);
  615.         CurrentTexture = newPos;
  616.     }
  617. }
  618.  
  619. static void
  620. ScrollMsg(HWND hDlg, short ScrollCode, short Pos, HWND ScrollBar)
  621. {
  622.     int oldPos, newPos, Page;
  623.     HWND hScroll, hValue;
  624.     RwReal Value, Factor;
  625.     char sText[80];
  626.     RwReal *Final;
  627.  
  628.     switch (GetDlgCtrlID(ScrollBar))
  629.     {
  630.         case MAT_AMBIENTSCROLL:
  631.             hScroll = GetDlgItem(hDlg, MAT_AMBIENTSCROLL);
  632.             hValue = GetDlgItem(hDlg, MAT_AMBIENTVALUE);
  633.             Factor = CREAL(100);
  634.             Page = 10;
  635.             Final = &CurMat.Amb;
  636.             CurMat.Changes |= MAT_AMBIENT_CHANGED;
  637.             break;
  638.         case MAT_DIFFUSESCROLL:
  639.             hScroll = GetDlgItem(hDlg, MAT_DIFFUSESCROLL);
  640.             hValue = GetDlgItem(hDlg, MAT_DIFFUSEVALUE);
  641.             Factor = CREAL(100);
  642.             Page = 10;
  643.             Final = &CurMat.Diff;
  644.             CurMat.Changes |= MAT_DIFFUSE_CHANGED;
  645.             break;
  646.         case MAT_SPECUALRSCROLL:
  647.             hScroll = GetDlgItem(hDlg, MAT_SPECUALRSCROLL);
  648.             hValue = GetDlgItem(hDlg, MAT_SPECULARVALUE);
  649.             Factor = CREAL(100);
  650.             Page = 10;
  651.             Final = &CurMat.Spec;
  652.             CurMat.Changes |= MAT_SPECULAR_CHANGED;
  653.             break;
  654.         case MAT_OPACITYSCROLL:
  655.             hScroll = GetDlgItem(hDlg, MAT_OPACITYSCROLL);
  656.             hValue = GetDlgItem(hDlg, MAT_OPACITYVALUE);
  657.             Factor = CREAL(100);
  658.             Page = 10;
  659.             Final = &CurMat.Opacity;
  660.             CurMat.Changes |= MAT_OPACITY_CHANGED;
  661.             break;
  662.         case MAT_REDSCROLL:
  663.             hScroll = GetDlgItem(hDlg, MAT_REDSCROLL);
  664.             hValue = GetDlgItem(hDlg, MAT_REDVALUE);
  665.             Factor = CREAL(100);
  666.             Page = 10;
  667.             Final = &CurMat.Col.r;
  668.             CurMat.Changes |= MAT_COLOR_CHANGED;
  669.             break;
  670.         case MAT_GREENSCROLL:
  671.             hScroll = GetDlgItem(hDlg, MAT_GREENSCROLL);
  672.             hValue = GetDlgItem(hDlg, MAT_GREENVALUE);
  673.             Factor = CREAL(100);
  674.             Page = 10;
  675.             Final = &CurMat.Col.g;
  676.             CurMat.Changes |= MAT_COLOR_CHANGED;
  677.             break;
  678.         case MAT_BLUESCROLL:
  679.             hScroll = GetDlgItem(hDlg, MAT_BLUESCROLL);
  680.             hValue = GetDlgItem(hDlg, MAT_BLUEVALUE);
  681.             Factor = CREAL(100);
  682.             Page = 10;
  683.             Final = &CurMat.Col.b;
  684.             CurMat.Changes |= MAT_COLOR_CHANGED;
  685.             break;
  686.         default:
  687.             return;
  688.     }
  689.  
  690.     SetScrollRange(hScroll, SB_CTL, 0, (int) REAL2INT(Factor), FALSE);
  691.     SetScrollPos(hScroll, SB_CTL, (int) REAL2INT(RMul(RAdd(*Final, CREAL(0.001)), Factor)), TRUE);
  692.  
  693.     oldPos = GetScrollPos(hScroll, SB_CTL);
  694.     newPos = oldPos;
  695.  
  696.     switch (ScrollCode)
  697.     {
  698.         case SB_TOP:
  699.             newPos = 0;
  700.             break;
  701.         case SB_BOTTOM:
  702.             newPos = (int) REAL2INT(Factor);
  703.             break;
  704.         case SB_LINEDOWN:
  705.             newPos += 5;
  706.             break;
  707.         case SB_PAGEDOWN:
  708.             newPos += Page;
  709.             break;
  710.         case SB_LINEUP:
  711.             newPos -= 5;
  712.             break;
  713.         case SB_PAGEUP:
  714.             newPos -= Page;
  715.             break;
  716.         case SB_THUMBPOSITION:
  717.         case SB_THUMBTRACK:
  718.             newPos = Pos;
  719.             break;
  720.         default:
  721.             return;
  722.     }
  723.  
  724.     newPos = max(newPos, 0);
  725.     newPos = min(newPos, (int) REAL2INT(Factor));
  726.  
  727.     if (newPos != oldPos)
  728.     {
  729.         Value = RDiv(INT2REAL(newPos), Factor);
  730.         SetScrollPos(hScroll, SB_CTL, newPos, TRUE);
  731.         sprintf(sText, "%d.%2.2d", REAL2INT(Value), REAL2INT(RMul(RSub(Value, INT2REAL(REAL2INT(Value))), CREAL(100))));
  732.         *Final = Value;
  733.         SetWindowText(hValue, sText);
  734.         UpdateClump(hDlg, TRUE);
  735.     }
  736. }
  737.  
  738. static void
  739. UpdatePolygon(RwPolygon3d * Poly)
  740. {
  741.     if (CurMat.Changes & MAT_COLOR_CHANGED)
  742.         RwSetPolygonColorStruct(Poly, &CurMat.Col);
  743.     if (CurMat.Changes & MAT_GEOM_CHANGED)
  744.         RwSetPolygonGeometrySampling(Poly, CurMat.Geom);
  745.     if (CurMat.Changes & MAT_LIGHT_CHANGED)
  746.         RwSetPolygonLightSampling(Poly, CurMat.Light);
  747.     if (CurMat.Changes & MAT_AMBIENT_CHANGED)
  748.         RwSetPolygonAmbient(Poly, CurMat.Amb);
  749.     if (CurMat.Changes & MAT_DIFFUSE_CHANGED)
  750.         RwSetPolygonDiffuse(Poly, CurMat.Diff);
  751.     if (CurMat.Changes & MAT_SPECULAR_CHANGED)
  752.         RwSetPolygonSpecular(Poly, CurMat.Spec);
  753.     if (CurMat.Changes & MAT_OPACITY_CHANGED)
  754.         RwSetPolygonOpacity(Poly, CurMat.Opacity);
  755.     if (CurMat.Changes & MAT_TEXTURE_CHANGED)
  756.         RwSetPolygonTexture(Poly, CurMat.Tex);
  757.     if (CurMat.Changes & MAT_TEXMODE_CHANGED)
  758.         RwSetPolygonTextureModes(Poly, CurMat.TextureModes);
  759. }
  760.  
  761. static void
  762. UpdateClump(HWND hWnd, int Send)
  763. {
  764.  
  765.     InvalidateRect(GetDlgItem(hWnd, MAT_BUTTON), NULL, FALSE);
  766.     if (CurrentTexture == 0)
  767.         InvalidateRect(GetDlgItem(hWnd, MAT_TEXTUREBUTTON), NULL, FALSE);
  768.     if (Send && (CurMat.User != NULL))
  769.     {
  770.         if (Material != NULL)
  771.         {
  772.             RwSetMaterialAmbient(Material, CurMat.Amb);
  773.             RwSetMaterialDiffuse(Material, CurMat.Diff);
  774.             RwSetMaterialSpecular(Material, CurMat.Spec);
  775.             RwSetMaterialColorStruct(Material, &CurMat.Col);
  776.             RwSetMaterialLightSampling(Material, CurMat.Light);
  777.             RwSetMaterialGeometrySampling(Material, CurMat.Geom);
  778.             RwSetMaterialOpacity(Material, CurMat.Opacity);
  779.             RwSetMaterialTexture(Material, CurMat.Tex);
  780.             RwSetMaterialTextureModes(Material, CurMat.TextureModes);
  781.         }
  782.         SendMessage(CurMat.User, CurMat.ChangesMessage, CurMat.Changes, (LPARAM) Material);
  783.     }
  784. }
  785.  
  786. static void
  787. AddToTextureList(RwTexture * pTex, RwRGBColor * Col)
  788. {
  789.     RwClump *pNewClump;
  790.     static RwReal x;
  791.     RwUV uv;
  792.  
  793.     if (Col != NULL)            /* i.e first one */
  794.     {
  795.         x = CREAL(-3.5);
  796.         RwModelBegin();
  797.         RwClumpBegin();
  798.         RwVertexExt(CREAL(-1.0), CREAL(-1.0), CREAL(0.0), NULL, NULL);
  799.         RwVertexExt(CREAL(1.0), CREAL(-1.0), CREAL(0.0), NULL, NULL);
  800.         RwVertexExt(CREAL(1.0), CREAL(1.0), CREAL(0.0), NULL, NULL);
  801.         RwVertexExt(CREAL(-1.0), CREAL(1.0), CREAL(0.0), NULL, NULL);
  802.         RwQuad(1, 2, 3, 4);
  803.  
  804.         RwClumpEnd(&pNewClump);
  805.         pComboClump = pNewClump;
  806.         RwModelEnd();
  807.         RwForAllPolygonsInClumpReal(pNewClump, RwSetPolygonAmbient, CREAL(0.7));
  808.         UpdateTextureBlob();
  809.     }
  810.     else
  811.     {
  812.         RwModelBegin();
  813.         RwClumpBegin();
  814.  
  815.         uv.u = CREAL(0.0);
  816.         uv.v = CREAL(1.0);
  817.         RwVertexExt(CREAL(-1.0), CREAL(-1.0), CREAL(0.0), &uv, NULL);
  818.  
  819.         uv.u = CREAL(1.0);
  820.         uv.v = CREAL(1.0);
  821.         RwVertexExt(CREAL(1.0), CREAL(-1.0), CREAL(0.0), &uv, NULL);
  822.  
  823.         uv.u = CREAL(1.0);
  824.         uv.v = CREAL(0.0);
  825.         RwVertexExt(CREAL(1.0), CREAL(1.0), CREAL(0.0), &uv, NULL);
  826.  
  827.         uv.u = CREAL(0.0);
  828.         uv.v = CREAL(0.0);
  829.         RwVertexExt(CREAL(-1.0), CREAL(1.0), CREAL(0.0), &uv, NULL);
  830.  
  831.         RwQuad(1, 2, 3, 4);
  832.  
  833.         RwClumpEnd(&pNewClump);
  834.         RwModelEnd();
  835.         RwForAllPolygonsInClumpPointer(pNewClump, (RwPolygon3dFuncPointer) RwSetPolygonTexture, pTex);
  836.         RwForAllPolygonsInClumpInt(pNewClump, (RwPolygon3dFuncInt) RwAddTextureModeToPolygon, rwLIT);
  837.         RwForAllPolygonsInClumpReal(pNewClump, (RwPolygon3dFuncReal) RwSetPolygonAmbient, CREAL(0.5));
  838.         RwForAllPolygonsInClumpReal(pNewClump, (RwPolygon3dFuncReal) RwSetPolygonDiffuse, CREAL(0.2));
  839.     }
  840.     RwPushScratchMatrix();
  841.     RwTranslateMatrix(RwScratchMatrix(), x, CREAL(0.0), CREAL(0.0), rwREPLACE);
  842.     RwTransformClump(pNewClump, RwScratchMatrix(), rwPOSTCONCAT);
  843.     RwPopScratchMatrix();
  844.     x = RAdd(SPACING, x);
  845.     RwAddClumpToScene(pComboScene, pNewClump);
  846. }
  847.  
  848. static void
  849. UpdateTextureBlob(void)
  850. {
  851.     RwForAllPolygonsInClumpPointer(pComboClump, (RwPolygon3dFuncPointer) RwSetPolygonColorStruct, &CurMat.Col);
  852. }
  853.  
  854. static void
  855. AddChecksum(RwTexture * pTex)
  856. {
  857.     Checksum += (long) pTex;
  858. }
  859.  
  860. static void
  861. RebuildTextureScene(void)
  862. {
  863.     int NumTex, OldPos;
  864.  
  865.     Checksum = 0;
  866.     RwForAllNamedTextures((RwTextureFuncVoid) AddChecksum);
  867.  
  868.     if ((Checksum != Current) && (pClump != NULL))
  869.     {
  870.         Current = Checksum;
  871.  
  872.         NumTex = (int) RwGetNumNamedTextures();
  873.  
  874.         if (pComboScene != NULL)
  875.             RwDestroyScene(pComboScene);
  876.         pComboScene = RwCreateScene();
  877.         RwAddLightToScene(pComboScene, RwCreateLight(rwPOINT, CREAL(2.0), CREAL(2.0), CREAL(3.0), CREAL(1.0)));
  878.         AddToTextureList(NULL, &CurMat.Col);
  879.         RwForAllNamedTexturesPointer((RwTextureFuncPointer) AddToTextureList, NULL);
  880.  
  881.         if (NumTex >= 4)
  882.         {
  883.             SetScrollRange(GetDlgItem(MatHnd, MAT_TEXTURESCROLL), SB_CTL, 0, NumTex - 3, FALSE);
  884.             EnableWindow(GetDlgItem(MatHnd, MAT_TEXTURESCROLL), TRUE);
  885.         }
  886.         else
  887.         {
  888.             EnableWindow(GetDlgItem(MatHnd, MAT_TEXTURESCROLL), FALSE);
  889.         }
  890.  
  891.         OldPos = CurrentTexture;
  892.         CurrentTexture = min(CurrentTexture, NumTex);
  893.  
  894.         SetScrollPos(GetDlgItem(MatHnd, MAT_TEXTURESCROLL), SB_CTL, CurrentTexture, TRUE);
  895.  
  896.         RwVCMoveCamera(pComboCam, -RMul(INT2REAL(CurrentTexture - OldPos), SPACING), CREAL(0.0), CREAL(0.0));
  897.         InvalidateRect(GetDlgItem(MatHnd, MAT_TEXTUREBUTTON), NULL, FALSE);
  898.     }
  899. }
  900.