MATERIAL.C

Go to the documentation of this file.

/* --
OpenFX - Modelling, Animation and Rendering Package
-- */

/* file MATERIAL.C */

// Handle surface attributes shaders and materials

#define MODULE_MATERIAL 1

#include "design.h"
#include "faceattr.h"

static int GetFaceAttribs(FACEATTRIBS *fa, int defaults);
static void UpdateAttribsDialog(HWND, int, FACEATTRIBS *, FACEATTRIBS *);
static void PutFaceAttribute(int what, FACEATTRIBS *f);
static BOOL CALLBACK SetExternalShaderDlgProc(HWND hdlg,UINT msg,
                                    WPARAM wparam,LPARAM lparam);
static void UpdateShaderLoadDialog(int id,HWND hdlg);
static void UpdateShaderSetDialog(int sa, int id, HWND hdlg);
static void LoadExternalShader(int id, HWND hdlg);
static int  EditExternalShader(int id, HWND hdlg);
static void DropExternalShader(int id, HWND hdlg);
static void DrawShaderPreview(HDC hdc,RECT rc);
static BOOL CALLBACK MaterialDlgProc(HWND hdlg,UINT msg,
                                    WPARAM wparam,LPARAM lparam);


static FACEATTRIBS FaceAttribs,DefAttribs;
static int nf;
static int LastUsedMatID=0;
static int IdentifiedShaderPoint=-1;


static void UpdateGLview(void){
 if(ghwndOpenGLview != NULL)PostMessage(ghwndOpenGLview,(WM_USER+2),0,0);
}

static int GetFaceAttribs(FACEATTRIBS *fa, int defaults){
 unsigned char lfc[3],lsc[3];
 int ff,lma,lsm,lbr,lgl,ltr,lrf,lsh,lsa,lbu,lba,lbt,lbs,lbc,lpa,lgt,lst;
 int ma;
 face *fp;
 vertex *V0,*V1,*V2;
 int i,j,nff=0;
 fa->flag_fc = 1;
 fa->flag_sm = 1;                    /* SMOOTHING    */
 fa->flag_sa = 1;                    /* material ID  */
 fa->flag_bu = 1;                    /* map ID       */
 fa->flag_ba = 1;                    /* map active   */
 fa->flag_ma = 1;                    // face mapping coords
 for(i=0;i<3;i++){
   fa->fc[i]=LastColour[i];
 }
 fa->sm=  DefaultSmoothing;
 fa->sh=  0;   /* No Material applied  */
 fa->sa=  0;   /* material ID  */
 fa->bu=  0;   /* map ID       */
 fa->ba=  0;   /* map active   */
 fa->ma=  0;   // mapping coords 
 if(defaults)return 0;
 ff=1;   // first found
 if((fp=MainFp) != NULL)for(j=0;j<Nface;j++){
   V0=(MainVp+fp->V[0]); V1=(MainVp+fp->V[1]); V2=(MainVp+fp->V[2]);
   if(V0->status == SELECTED &&
      V1->status == SELECTED &&
      V2->status == SELECTED){
     nff++; /* make sure that at least one face is selected */
     if(fp->bSmooth)fa->sm=1; else fa->sm=0; /* smoothing on  */
     if(fp->gp)ma=1; else ma=0;    // face has mapping
     if(fp->gp)fa->ma=1;
     if(fp->imagemap < 0)fa->ba=0; else fa->ba=1;
     fa->bu=fp->imagemap;
     if(fp->material >= 0)fa->sh=1;  // some material on at least one face
     fa->sa=fp->material;
     fa->fc[0]=fp->color[0];
     fa->fc[1]=fp->color[1];
     fa->fc[2]=fp->color[2];
     if(ff){
       for(i=0;i<3;i++){lfc[i]=fa->fc[i];}
       lsm=fa->sm; lma=fa->ma;  // smoothing and mapping coords
       lsh=fa->sh; lsa=fa->sa;
       lbu=fa->bu; lba=fa->ba;
       ff=0;
     }
     else{
       for(i=0;i<3;i++){
         if(lfc[i] != fa->fc[i])fa->flag_fc = -1;
       }
       if(lsm != fa->sm)fa->flag_sm = -1;  // some faces smoothed - some not
       if(lma != ma)fa->flag_ma = -1;  // some faces mapped some not !
       if(lsa != fa->sa)fa->flag_sa = -1;
       if(lbu != fa->bu)fa->flag_bu = -1;
       if(lba != fa->ba)fa->flag_ba = -1;
     }
   }
   fp++;
 }
 return nff;
}

static void PutFaceAttribute(int what, FACEATTRIBS *f){
/* what   0 = face colour
          1 = shader colour
          2 = gloss
          3 = trans
          4 = reflectance
          5 = smoothing
          6 = brilliance switch
          7 = shader ID
          8 = dump map
          9 = shader axis
         10 = set brush ID;
         11 = set tiled
         12 = set shaded
         13 = set clear
         14 = set parameter
         15 = set glass type
         16 = remove mapping coords
         17 = apply mapping coords.
*/
 face *fp;
 vertex *vp,*V0,*V1,*V2;
 int i,j;
 EDIT_ACTION=YES;
 if(what < 17 && (fp=MainFp) != NULL)for(i=0;i<Nface;i++){
   V0=(MainVp+fp->V[0]); V1=(MainVp+fp->V[1]); V2=(MainVp+fp->V[2]);
   if(  (V0->status == SELECTED)
     && (V1->status == SELECTED)
     && (V2->status == SELECTED)){
     if(what == 0){
       VECCOPY(f->fc,fp->color)
     }
     else if(what == 5){ /* smoothing */
       if(f->sm == 1)fp->bSmooth=TRUE; /* Set Smoothing bit #7            */
       else          fp->bSmooth=FALSE; /* Clear Smoothing bit in faces #7 */
     }
     else if(what == 8){ /* dump map - clear bit 6 */
       fp->imagemap = -1;
     }
     else if(what == 9){ /* set material    (could be -1) */
       fp->material  = (short)f->sa;
     }
     else if(what == 10){ /* set map */
       fp->imagemap    = (short)f->bu;
     }
     else if(what == 16){ /* drop mapping coords */
       fp->gp=FALSE; for(j=0;j<3;j++){fp->x[j]=0.0; fp->y[j]=0.0;}
     }
   }
   fp++;
 }
 PutNurbsAttribute(what,f);
 if(what == 16){ // need to drop vertex coords too.
   if(Nvert > 0)for(i=0,vp=MainVp;i<Nvert;i++,vp++)if(vp->status == SELECTED){
     vp->gp=0; vp->x=vp->y=0.0;
   }
 }
 if(what == 17){ // Assign Mapping Coordinates to selected
   long id,mapt,type = -1;
   if(nImaps == 1)id=0;
   else id=RequestMapID(ghwnd_main,"Choose Map",0);
   if(id >= 0 && id < nImaps){
     mapt=iMap[id].Map;
     if     (mapt == PLANE)type=0;
     else if(mapt == CYLINDER)type=1;         
     else if(mapt == PLANE_MOZIAC)type=0;
     else if(mapt == CYLINDER_MOZIAC)type=1;
     else if(mapt == MAP_SPHERICAL)type=2;
     // don't re-assign fixed mapping
     if(type >= 0){
       MapVerticesByImageMap(id,type); 
       MapFacesByImageMap(id,type,FALSE);
     }
     else MessageBox(NULL,"Fixed mapping not reassigned",NULL,MB_OK);
   }
 }
}

static void UpdateMapAttribsSection(HWND hdlg, int nff,
                                FACEATTRIBS *fa, FACEATTRIBS *da){
 int active;
 char *map_type_list[]={"Still","Animate"};
 char *map_attr_list[]={"Plane","Cylinder","Moziac-P","Moziac-C","Fixed To","Spherical"};
 char str[64];

 if(nff != 0 && fa->ma)active=SW_SHOW; else active=SW_HIDE; // some mapping coords exists
 ShowWindow(GetDlgItem(hdlg,DLG_ATTRIBS_WARN_FMAP),active);
 if(nff != 0 && fa->flag_ma < 0)active=SW_SHOW; else active=SW_HIDE; // some mappcoords exist and some dont
 ShowWindow(GetDlgItem(hdlg,DLG_ATTRIBS_WARN_FMAP1),active);
 if(nff == 0){
   EnableWindow(GetDlgItem(hdlg,DLG_ATTRIBS_FMAP_ON),FALSE);
   EnableWindow(GetDlgItem(hdlg,DLG_ATTRIBS_FMAP_OFF),FALSE);
 }
 else if(nImaps == 0){
  if(fa->ma)EnableWindow(GetDlgItem(hdlg,DLG_ATTRIBS_FMAP_OFF),TRUE);
  else      EnableWindow(GetDlgItem(hdlg,DLG_ATTRIBS_FMAP_OFF),FALSE);
  EnableWindow(GetDlgItem(hdlg,DLG_ATTRIBS_FMAP_ON),FALSE);
 }
 else {
  if(fa->ma)EnableWindow(GetDlgItem(hdlg,DLG_ATTRIBS_FMAP_OFF),TRUE);
  else      EnableWindow(GetDlgItem(hdlg,DLG_ATTRIBS_FMAP_OFF),FALSE);
  EnableWindow(GetDlgItem(hdlg,DLG_ATTRIBS_FMAP_ON),TRUE);
 }
 if(nff == 0){
   EnableWindow(GetDlgItem(hdlg,DLG_ATTRIBS_MAP_SET),FALSE);
   EnableWindow(GetDlgItem(hdlg,DLG_ATTRIBS_MAP_DROP),FALSE);
   EnableWindow(GetDlgItem(hdlg,DLG_ATTRIBS_MAP_MOVE),FALSE);
   EnableWindow(GetDlgItem(hdlg,DLG_ATTRIBS_MAP_EDIT),FALSE);
   EnableWindow(GetDlgItem(hdlg,DLG_ATTRIBS_MAP_DELETE),FALSE);
   SetDlgItemText(hdlg,DLG_ATTRIBS_MAP_NAME,(LPCTSTR)"<No faces>");
   SetDlgItemText(hdlg,DLG_ATTRIBS_MAP_TYPE,(LPCTSTR)"  ");
   return;
 }
 EnableWindow(GetDlgItem(hdlg,DLG_ATTRIBS_MAP_SET),TRUE);
 if(fa->flag_ba < 0 || fa->ba == 0 || fa->flag_bu < 0 || nImaps == 0)active=FALSE;
 else                                                                active=TRUE;
 if(fa->flag_ba < 0){ /* brush activity is not consistant */
   SetDlgItemText(hdlg,DLG_ATTRIBS_MAP_NAME,(LPCTSTR)"<Some faces have map>");
   SetDlgItemText(hdlg,DLG_ATTRIBS_MAP_TYPE,(LPCTSTR)"  ");
   EnableWindow(GetDlgItem(hdlg,DLG_ATTRIBS_MAP_DROP),TRUE);
   EnableWindow(GetDlgItem(hdlg,DLG_ATTRIBS_MAP_MOVE),FALSE);
   EnableWindow(GetDlgItem(hdlg,DLG_ATTRIBS_MAP_EDIT),FALSE);
   EnableWindow(GetDlgItem(hdlg,DLG_ATTRIBS_MAP_DELETE),FALSE);
 }
 else{
   if(fa->ba == 0 || nImaps == 0){
     SetDlgItemText(hdlg,DLG_ATTRIBS_MAP_NAME,(LPCTSTR)"<No map>");
     SetDlgItemText(hdlg,DLG_ATTRIBS_MAP_TYPE,(LPCTSTR)"  ");
     EnableWindow(GetDlgItem(hdlg,DLG_ATTRIBS_MAP_DROP),FALSE);
     EnableWindow(GetDlgItem(hdlg,DLG_ATTRIBS_MAP_MOVE),FALSE);
     EnableWindow(GetDlgItem(hdlg,DLG_ATTRIBS_MAP_EDIT),FALSE);
     EnableWindow(GetDlgItem(hdlg,DLG_ATTRIBS_MAP_DELETE),FALSE);
   }
   else if(fa->flag_bu < 0){
     SetDlgItemText(hdlg,DLG_ATTRIBS_MAP_NAME,(LPCTSTR)"<Not all same map>");
     SetDlgItemText(hdlg,DLG_ATTRIBS_MAP_TYPE,(LPCTSTR)"  ");
     EnableWindow(GetDlgItem(hdlg,DLG_ATTRIBS_MAP_DROP),TRUE);
     EnableWindow(GetDlgItem(hdlg,DLG_ATTRIBS_MAP_MOVE),FALSE);
     EnableWindow(GetDlgItem(hdlg,DLG_ATTRIBS_MAP_EDIT),FALSE);
     EnableWindow(GetDlgItem(hdlg,DLG_ATTRIBS_MAP_DELETE),FALSE);
   }
   else{
     SetDlgItemText(hdlg,DLG_ATTRIBS_MAP_NAME,(LPCTSTR)iMap[fa->bu].N);
     sprintf(str,"%s and %s",map_type_list[min((int)iMap[fa->bu].Type,1)],
                                  map_attr_list[(int)(iMap[fa->bu].Map)] );
     SetDlgItemText(hdlg,DLG_ATTRIBS_MAP_TYPE,(LPCTSTR)str);
     EnableWindow(GetDlgItem(hdlg,DLG_ATTRIBS_MAP_DROP),TRUE);
     EnableWindow(GetDlgItem(hdlg,DLG_ATTRIBS_MAP_MOVE),TRUE);
     EnableWindow(GetDlgItem(hdlg,DLG_ATTRIBS_MAP_EDIT),TRUE);
     EnableWindow(GetDlgItem(hdlg,DLG_ATTRIBS_MAP_DELETE),TRUE);
   }
 }
}

static void UpdateShaderAttribsSection(HWND hdlg, int nff,
                                FACEATTRIBS *fa, FACEATTRIBS *da){
 BOOL active;
 if(nff != 0 && (fa->flag_sa < 0))active=SW_SHOW; else active=SW_HIDE;
 ShowWindow(GetDlgItem(hdlg,DLG_ATTRIBS_WARN_MATL),active);
 if(nff == 0){
   EnableWindow(GetDlgItem(hdlg,DLG_ATTRIBS_MATL_SET),FALSE);
   EnableWindow(GetDlgItem(hdlg,DLG_ATTRIBS_MATL_DROP),FALSE);
   EnableWindow(GetDlgItem(hdlg,DLG_ATTRIBS_SHA_XMOVE),FALSE);
   EnableWindow(GetDlgItem(hdlg,DLG_ATTRIBS_MATL_EDIT),FALSE);
   SetDlgItemText(hdlg,DLG_ATTRIBS_MATL_NAME,(LPCTSTR)"<No faces>");
 }
 else{
   if(fa->sh == 0){
     EnableWindow(GetDlgItem(hdlg,DLG_ATTRIBS_MATL_SET),TRUE);
     EnableWindow(GetDlgItem(hdlg,DLG_ATTRIBS_MATL_DROP),FALSE);
     EnableWindow(GetDlgItem(hdlg,DLG_ATTRIBS_SHA_XMOVE),FALSE);
     EnableWindow(GetDlgItem(hdlg,DLG_ATTRIBS_MATL_EDIT),FALSE);
     SetDlgItemText(hdlg,DLG_ATTRIBS_MATL_NAME,(LPCTSTR)"<No Materials Applied>");
   }
   else{
     if(fa->flag_sa < 0){
       EnableWindow(GetDlgItem(hdlg,DLG_ATTRIBS_MATL_SET),TRUE);
       EnableWindow(GetDlgItem(hdlg,DLG_ATTRIBS_MATL_DROP),TRUE);
       EnableWindow(GetDlgItem(hdlg,DLG_ATTRIBS_SHA_XMOVE),FALSE);
       EnableWindow(GetDlgItem(hdlg,DLG_ATTRIBS_MATL_EDIT),FALSE);
       SetDlgItemText(hdlg,DLG_ATTRIBS_MATL_NAME,(LPCTSTR)"<Not same>");
     }
     else{
       EnableWindow(GetDlgItem(hdlg,DLG_ATTRIBS_MATL_SET),TRUE);
       EnableWindow(GetDlgItem(hdlg,DLG_ATTRIBS_MATL_DROP),TRUE);
       EnableWindow(GetDlgItem(hdlg,DLG_ATTRIBS_SHA_XMOVE),TRUE);
       EnableWindow(GetDlgItem(hdlg,DLG_ATTRIBS_MATL_EDIT),TRUE);
       SetDlgItemText(hdlg,DLG_ATTRIBS_MATL_NAME,(LPCTSTR)iMat[fa->sa].name);
     }
   }
 }
}

static void UpdateSmoothAttribsSection(HWND hdlg, int nff,
                                FACEATTRIBS *fa, FACEATTRIBS *da){
 BOOL active;
 if(nff != 0 && fa->flag_sm < 0)active=SW_SHOW; else active=SW_HIDE;
 ShowWindow(GetDlgItem(hdlg,DLG_ATTRIBS_WARN_SMOOTH),active);
 if(nff == 0){
   EnableWindow(GetDlgItem(hdlg,DLG_ATTRIBS_SMOOTH_ON),FALSE);
   SendDlgItemMessage(hdlg,DLG_ATTRIBS_SMOOTH_ON, BM_SETCHECK,BST_INDETERMINATE,0);
 }
 else {
   EnableWindow(GetDlgItem(hdlg,DLG_ATTRIBS_SMOOTH_ON),TRUE);
   if( fa->flag_sm < 0){
     SendDlgItemMessage(hdlg,DLG_ATTRIBS_SMOOTH_ON, BM_SETCHECK,BST_INDETERMINATE,0);
   }
   else{
     SendDlgItemMessage(hdlg,DLG_ATTRIBS_SMOOTH_ON, BM_SETCHECK,fa->sm,0);
   }
 }
}

static void UpdateColourAttribsSection(HWND hdlg, int nff,
                                FACEATTRIBS *fa, FACEATTRIBS *da){
 int active;
 if(nff != 0 && fa->flag_fc < 0)active=SW_SHOW; else active=SW_HIDE;
 ShowWindow(GetDlgItem(hdlg,DLG_ATTRIBS_WARN_FC),active);
 if(nff != 0)active=TRUE; else active=FALSE;
 EnableWindow(GetDlgItem(hdlg,DLG_ATTRIBS_FC_EDIT),active);
 if(nff != 0){
   VECCOPY(FaceAttribs.fc,DefAttribs.fc)
   VECCOPY(DefAttribs.fc,LastColour)
 }
 InvalidateRect(GetDlgItem(hdlg,DLG_ATTRIBS_FC_EDIT),NULL,FALSE);

 if(nff != 0 && (fa->sh == 1))active=SW_SHOW; else active=SW_HIDE;
 ShowWindow(GetDlgItem(hdlg,DLG_ATTRIBS_WARN_MESSAGE),active);
 ShowWindow(GetDlgItem(hdlg,DLG_ATTRIBS_WARN_TRIANGL),active);

}


static void UpdateTitleDialog(HWND hdlg,int nff){
 char str[128];
 char ltext[256];
 LoadString(ghinst_main,IDX_MISC_SETATTRIBS,ltext,256);
 sprintf(str,ltext,nff);
 SendMessage(hdlg,WM_SETTEXT,0,(LPARAM)str);
}

static void UpdateAttribsDialog(HWND hdlg, int nff,
                                FACEATTRIBS *fa, FACEATTRIBS *da){
 UpdateTitleDialog(hdlg,nff);
 UpdateColourAttribsSection(hdlg,nff,fa,da);
 UpdateSmoothAttribsSection(hdlg,nff,fa,da);
 UpdateShaderAttribsSection(hdlg,nff,fa,da);
 UpdateMapAttribsSection(hdlg,nff,fa,da);
}


static BOOL APIENTRY PropColourDlgProc(HWND hDlg,UINT msg,
                                    WPARAM wParam, LPARAM lParam){
 HWND hctl;
 int i,iMin,iMax;
 LPDRAWITEMSTRUCT lpdis;
 FACEATTRIBS *fa,*da;
 fa=&FaceAttribs; da=&DefAttribs;
 switch(msg){
   case WM_PAINT:
     PaintDialogBackground(hDlg,ghinst_main);
     break;
   case WM_INITDIALOG:
//     image_edit_flag= -1;                     //  Put these lines in which
//     nf=GetFaceAttribs(da,1);                 //  ever is the default dialog tab
//     nf=GetFaceAttribs(fa,0);                 //  
//     UpdateTitleDialog(GetParent(hDlg),nf);   //
     UpdateColourAttribsSection(hDlg,nf,fa,da);
     UpdateSmoothAttribsSection(hDlg,nf,fa,da);
     return TRUE;
   case WM_DRAWITEM:{
       HBRUSH   hbr,hbrold;
       BYTE r,g,b;
       lpdis=(LPDRAWITEMSTRUCT)lParam;
       if(lpdis->CtlID == DLG_ATTRIBS_FC_EDIT){
         r=da->fc[0]; g=da->fc[1]; b=da->fc[2];
         if(lpdis->itemState & ODS_DISABLED){
           r=128; g=128; b=128;
         }
         if(lpdis->itemState & ODS_SELECTED)
           InvertRect(lpdis->hDC,&(lpdis->rcItem));
         else{
           if(lpdis->itemState & ODS_DISABLED)
                hbr=CreateHatchBrush(HS_DIAGCROSS,RGB(128,128,128));
           else hbr=CreateSolidBrush(RGB(r,g,b));
           hbrold=SelectObject(lpdis->hDC,hbr);
           Rectangle(lpdis->hDC,lpdis->rcItem.left,lpdis->rcItem.top,
                         lpdis->rcItem.right,lpdis->rcItem.bottom);
           SelectObject(lpdis->hDC,hbrold);
           DeleteObject(hbr);
         }
       }
     }
     return TRUE;
   case WM_HSCROLL:
     break;
   case WM_COMMAND:
     switch(LOWORD(wParam)){
       case DLG_ATTRIBS_UPDATE:
         nf=GetFaceAttribs(fa,0);
         UpdateTitleDialog(GetParent(hDlg),nf);
         UpdateColourAttribsSection(hDlg,nf,fa,da);
         UpdateSmoothAttribsSection(hDlg,nf,fa,da);
         break;
       case DLG_ATTRIBS_FC_EDIT:
         if(SetSfxColour(da->fc,IDX_MISC_FACE_COLOUR,hDlg)){
           VECCOPY(da->fc,fa->fc) fa->flag_fc=1;
           VECCOPY(da->fc,LastColour)
           UpdateColourAttribsSection(hDlg,nf,fa,da);
           PutFaceAttribute(0,fa);
           UpdateGLview();
         }
         InvalidateRect(GetDlgItem(hDlg,DLG_ATTRIBS_FC_EDIT),NULL,FALSE);

         break;
       case DLG_ATTRIBS_SMOOTH_ON:
         i=SendDlgItemMessage(hDlg,DLG_ATTRIBS_SMOOTH_ON,BM_GETCHECK,0,0);
         if(i == BST_CHECKED)fa->sm=da->sm=0;
         else                fa->sm=da->sm=1;
         fa->flag_sm=1;
         UpdateSmoothAttribsSection(hDlg,nf,fa,da);
         PutFaceAttribute(5,fa);
         UpdateGLview();
         break;
       default:
         break;
     }
   default:   break;
 }
 return FALSE;
}

static BOOL APIENTRY PropTextureDlgProc(HWND hDlg,UINT msg, // NOT USED 
                                       WPARAM wParam, LPARAM lParam){
 HWND hctl;
 int i,iMin,iMax;
 FACEATTRIBS *fa,*da;
 fa=&FaceAttribs; da=&DefAttribs;
 switch(msg){
   case WM_PAINT:
     PaintDialogBackground(hDlg,ghinst_main);
     break;
   case WM_INITDIALOG:
     return TRUE;
     break;
   case WM_COMMAND:
     switch(LOWORD(wParam)){
       case DLG_ATTRIBS_UPDATE:
         nf=GetFaceAttribs(fa,0);
         UpdateTitleDialog(GetParent(hDlg),nf);
         break;
       default:
         break;
     }
   default:   break;
 }
 return FALSE;
}

static BOOL APIENTRY PropShaderDlgProc(HWND hDlg,UINT msg,
                                       WPARAM wParam, LPARAM lParam){
 HWND hctl;
 int i,iMin,iMax;
 LPDRAWITEMSTRUCT lpdis;
 FACEATTRIBS *fa,*da;
 fa=&FaceAttribs; da=&DefAttribs;
 switch(msg){
   case WM_PAINT:
     PaintDialogBackground(hDlg,ghinst_main);
     break;
   case WM_INITDIALOG:
     image_edit_flag= -1;                     //  Put these lines in which
     nf=GetFaceAttribs(da,1);                 //  ever is the default dialog tab
     nf=GetFaceAttribs(fa,0);                 //  
     UpdateTitleDialog(GetParent(hDlg),nf);   //
     UpdateShaderAttribsSection(hDlg,nf,fa,da);
     return TRUE;
     break;
   case WM_COMMAND:
     switch(LOWORD(wParam)){
       case DLG_ATTRIBS_UPDATE:
         nf=GetFaceAttribs(fa,0);
         UpdateTitleDialog(GetParent(hDlg),nf);
         UpdateShaderAttribsSection(hDlg,nf,fa,da);
         break;
       case DLG_ATTRIBS_MATL_DROP:
         fa->flag_sa=1; fa->sa = -1;
         fa->sh=0;
         PutFaceAttribute(9,fa);
         UpdateShaderAttribsSection(hDlg,nf,fa,da);
         UpdateGLview();
         break;
       case DLG_ATTRIBS_MATL_SET:
         if(nMats <= 0){
           CreateMaterial(TRUE);
           if(nMats <= 0){
             SendPrgmQuery(IDQ_NOSHADERAXES,0);
             break;
           }
           fa->flag_sa=1; fa->sa=0; fa->sh=1;
           PutFaceAttribute(9,fa);
           UpdateShaderAttribsSection(hDlg,nf,fa,da);
           UpdateGLview();
           break;
         }
         else {
           int sa;
           if((sa=RequestMaterialID(hDlg,"Choose Material to Use")) >= 0){
             fa->flag_sa=1; fa->sa=sa; fa->sh=1;
             PutFaceAttribute(9,fa);
             UpdateShaderAttribsSection(hDlg,nf,fa,da);
             UpdateGLview();
           }
         }
         break;
       case DLG_ATTRIBS_MATL_EDIT:
         if(fa->flag_sa > 0 && fa->sa >= 0 && fa->sh == 1){
           image_edit_flag=1;   // so we return to editing faces attributes
           axis_move_flag=fa->sa;
           DestroyWindow(ghwndDlgAttribs);
           ghwndDlgAttribs=NULL;
           if(sktool == YES)DisengageSkeletonTool();
           PostMessage(ghwnd_main,WM_COMMAND,IDM_MATERIAL_EDIT,0);
         }
         break; 
       case DLG_ATTRIBS_SHA_XMOVE:
         if(fa->sa >= 0){
           if(tool != NOTOOL)DisengageDesignerTool();
           if(sktool == YES)DisengageSkeletonTool();
           PositionMaterialOnOff(1,fa->sa);
         }
         break;
      default:
        break;
     }
   default:   break;
 }
 return FALSE;
}

static BOOL APIENTRY PropMappingDlgProc(HWND hDlg,UINT msg,
                                       WPARAM wParam, LPARAM lParam){
 FACEATTRIBS *fa,*da;
 fa=&FaceAttribs; da=&DefAttribs;
 switch(msg){
   case WM_PAINT:
     PaintDialogBackground(hDlg,ghinst_main);
     break;
   case WM_INITDIALOG:
     UpdateMapAttribsSection(hDlg,nf,fa,da);
     return TRUE;
     break;
   case WM_COMMAND:
     switch(LOWORD(wParam)){
       case DLG_ATTRIBS_UPDATE:
         nf=GetFaceAttribs(fa,0);
         UpdateTitleDialog(GetParent(hDlg),nf);
         UpdateMapAttribsSection(hDlg,nf,fa,da);
         break;
       case DLG_ATTRIBS_MAP_SET:{
         int id;
           if((id=RequestMapID(hDlg,"Choose map",1)) < 0)break;
           if(id == nImaps){
             if(CreateImageMap() == FAIL){
               SendPrgmQuery(IDQ_NOMOREMAPS,0);
               break;
             }
           }
           fa->flag_ba=1; fa->ba=1;  /* brush    */
           fa->flag_bu=1; fa->bu=id; /* brush ID */
           PutFaceAttribute(10,fa);
           UpdateMapAttribsSection(hDlg,nf,fa,da);
           UpdateGLview();
         }
         break;
       case DLG_ATTRIBS_MAP_DROP:
         fa->flag_ba=1; fa->ba=0;
         fa->flag_bu=1; fa->bu &=0xe0;
         PutFaceAttribute(8,fa);
         UpdateMapAttribsSection(hDlg,nf,fa,da);
         UpdateGLview();
         break;
       case DLG_ATTRIBS_FMAP_ON:
         fa->ma=1; 
         fa->flag_ma=1;
         PutFaceAttribute(17,fa);
         UpdateMapAttribsSection(hDlg,nf,fa,da);
         UpdateGLview();
         break;
       case DLG_ATTRIBS_FMAP_OFF:
         fa->ma=0; 
         fa->flag_ma=1;
         PutFaceAttribute(16,fa);
         UpdateMapAttribsSection(hDlg,nf,fa,da);
         UpdateGLview();
         break;
       case DLG_ATTRIBS_MAP_MOVE:
         if(tool != NOTOOL)DisengageDesignerTool();
         if(sktool == YES)DisengageSkeletonTool();
         PositionBrushOnOff(1,fa->bu);
         break;
       case DLG_ATTRIBS_MAP_EDIT:
         image_edit_flag=1;    // so that we return to editing the face attributes
         axis_move_flag=fa->bu;
         DestroyWindow(ghwndDlgAttribs);
         ghwndDlgAttribs=NULL;
         if(sktool == YES)DisengageSkeletonTool();
         PostMessage(ghwnd_main,WM_COMMAND,IDM_ATTRIBUTES_MAP,0);
         break;
       case DLG_ATTRIBS_MAP_DELETE:   /* not used yet */
         break;
       default:
         break;
     }
   default:   break;
 }
 return FALSE;
}

#define D_BORDER 4
#define N_PAGES  3


typedef struct tag_dlghdr1 {
  HWND hwndDlg[N_PAGES];
  RECT rcTab;
} DLGHDR1;

static DLGHDR1 DlgHdrAttribs,*lpDlgHdrAttribs;
static HWND    hwndTabAttribs;

BOOL CALLBACK AttribsDlgProc(HWND hdlg,UINT msg,
                             WPARAM wparam,LPARAM lparam){
 static BOOL bRollUp=FALSE;
 static RECT RollUpRect;
 static int xpos= -1,ypos= -1;
 int i;
 RECT rc,rd;
 char str[32];
 switch( msg ){
//   case WM_PAINT: // Include this if the tabbed page bacground is to be textured
//     PaintDialogBackground(hdlg,ghinst_main);
//     break;
   case WM_INITDIALOG:{
       TC_ITEM tie;
       int h;
       DWORD dwDlgBase=GetDialogBaseUnits();
       if(xpos == -1 && ypos == -1)CentreDialogOnScreen(hdlg);
       else SetWindowPos(hdlg,HWND_TOP,xpos,ypos,0,0,SWP_NOSIZE);
       lpDlgHdrAttribs=&DlgHdrAttribs;
       GetWindowRect(hdlg,&rc);
       GetWindowRect(GetDlgItem(hdlg,DLG_ATTRIBS_PREVIEW),&rd);
       h=rd.top-rc.top-GetSystemMetrics(SM_CYCAPTION);
       GetClientRect(hdlg,&rc);
       hwndTabAttribs=CreateWindow(WC_TABCONTROL," ",
                            WS_CHILD | WS_VISIBLE | WS_CLIPSIBLINGS,
                            (D_BORDER*LOWORD(dwDlgBase))/4,
                            (D_BORDER*HIWORD(dwDlgBase))/8,
                            rc.right-(2*D_BORDER*LOWORD(dwDlgBase))/4,
                            h-(2*D_BORDER*HIWORD(dwDlgBase))/8,
                            hdlg,NULL,ghinst_main,NULL);
       {char text_string[255];
         LoadString(ghinst_main,IDX_MISC_LANGUAGE,
                    text_string,sizeof(text_string));
         if(strcmp(text_string,"ENGLISH") == 0)
           SendMessage(hwndTabAttribs,WM_SETFONT, /* for text in tab */
                  (WPARAM)GetStockObject(ANSI_VAR_FONT),0);
       }
       memset(&tie,0,sizeof(TC_ITEM));
       tie.mask = TCIF_TEXT | TCIF_IMAGE;
       tie.iImage = -1;
       tie.pszText=str;
//       LoadString(ghinst_main,IDX_MISC_ATT_SETTINGS,str,32);
//       TabCtrl_InsertItem(hwndTabAttribs,3,&tie);
       LoadString(ghinst_main,IDX_MISC_ATT_SHADER,str,32);
       TabCtrl_InsertItem(hwndTabAttribs,0,&tie);
       LoadString(ghinst_main,IDX_MISC_ATT_MAPS,str,32);
       TabCtrl_InsertItem(hwndTabAttribs,1,&tie);
       LoadString(ghinst_main,IDX_MISC_ATT_COLOUR,str,32);
       TabCtrl_InsertItem(hwndTabAttribs,2,&tie);
       SetRectEmpty(&rc);
       TabCtrl_AdjustRect(hwndTabAttribs,FALSE,&rc);
       rc.left += (D_BORDER*LOWORD(dwDlgBase))/4;
       rc.top += (D_BORDER*HIWORD(dwDlgBase))/8;
       CopyRect(&(lpDlgHdrAttribs->rcTab),&rc);
       for(i=0;i<N_PAGES;i++)lpDlgHdrAttribs->hwndDlg[i]=NULL;
       lpDlgHdrAttribs->hwndDlg[0]=CreateDialog(ghinst_main,
                                   "ATTRIBSPAGE3",
                                   hdlg,(DLGPROC)PropShaderDlgProc);
//       lpDlgHdrAttribs->hwndDlg[0]=CreateDialog(ghinst_main,
//                                   "ATTRIBSPAGE1",
//                                   hdlg,(DLGPROC)PropColourDlgProc);
       SetWindowPos(lpDlgHdrAttribs->hwndDlg[0],NULL,
                    lpDlgHdrAttribs->rcTab.left,
                    lpDlgHdrAttribs->rcTab.top,0,0,
                    SWP_NOSIZE | SWP_NOZORDER);
       ShowWindow(lpDlgHdrAttribs->hwndDlg[0],SW_SHOW);
     }
     return TRUE;
   case WM_NOTIFY:
     if( ((LPNMHDR)lparam)->code == TCN_SELCHANGING){
       int id=TabCtrl_GetCurSel(hwndTabAttribs);
     }
     if( ((LPNMHDR)lparam)->code == TCN_SELCHANGE){
       int id=TabCtrl_GetCurSel(hwndTabAttribs);
       for(i=0;i<N_PAGES;i++){
         if(lpDlgHdrAttribs->hwndDlg[i] != NULL){
           DestroyWindow(lpDlgHdrAttribs->hwndDlg[i]);
           lpDlgHdrAttribs->hwndDlg[i]=NULL;
         }
       }
       if(id == 2)lpDlgHdrAttribs->hwndDlg[2]=CreateDialog(ghinst_main,
                                   "ATTRIBSPAGE1",
                                   hdlg,(DLGPROC)PropColourDlgProc);
//       if(id == 3)lpDlgHdrAttribs->hwndDlg[3]=CreateDialog(ghinst_main,
//                                   "ATTRIBSPAGE2",
//                                   hdlg,(DLGPROC)PropTextureDlgProc);
       if(id == 0)lpDlgHdrAttribs->hwndDlg[0]=CreateDialog(ghinst_main,
                                   "ATTRIBSPAGE3",
                                   hdlg,(DLGPROC)PropShaderDlgProc);
       if(id == 1)lpDlgHdrAttribs->hwndDlg[1]=CreateDialog(ghinst_main,
                                   "ATTRIBSPAGE4",
                                   hdlg,(DLGPROC)PropMappingDlgProc);
       if(lpDlgHdrAttribs->hwndDlg[id] != NULL){
         SetWindowPos(lpDlgHdrAttribs->hwndDlg[id],NULL,
                      lpDlgHdrAttribs->rcTab.left,
                      lpDlgHdrAttribs->rcTab.top,0,0,
                      SWP_NOSIZE | SWP_NOZORDER);
         ShowWindow(lpDlgHdrAttribs->hwndDlg[id],SW_SHOW);
       }
     }
     break;
   case WM_SYSCOMMAND:
     switch(LOWORD(wparam & 0xfff0)){
       default:
         break;
       case SC_MINIMIZE:
         if(bRollUp){
           SetWindowPos(hdlg,NULL,0,0,RollUpRect.right-RollUpRect.left,
                                      RollUpRect.bottom-RollUpRect.top,
                                      SWP_NOMOVE | SWP_NOZORDER);
         }
         else{
           GetWindowRect(hdlg,&RollUpRect);
           SetWindowPos(hdlg,NULL,0,0,RollUpRect.right-RollUpRect.left,
                                      GetSystemMetrics(SM_CYCAPTION)+
                                      2*GetSystemMetrics(SM_CYFIXEDFRAME),
                                      SWP_NOMOVE | SWP_NOZORDER);
         }
         bRollUp ^= 1;
         return TRUE;
         break;
       case SC_RESTORE:
         return TRUE;
         break;
       case SC_CLOSE:
         PostMessage(ghwnd_main,WM_COMMAND,IDM_ATTRIBUTES_FACE,0);
         break;
     }
     break;
   case WM_COMMAND:
     switch( LOWORD(wparam) ){
       case DLG_ATTRIBS_UPDATE:
         for(i=0;i<N_PAGES;i++){
           if(lpDlgHdrAttribs->hwndDlg[i] != NULL)
             PostMessage(lpDlgHdrAttribs->hwndDlg[i],
             WM_COMMAND,DLG_ATTRIBS_UPDATE,0);
         }
         break;
       case DLG_ATTRIBS_PREVIEW:
         PostMessage(ghwnd_main,WM_COMMAND,IDM_VIEW_RENDERINWINDOW,0);
         break;
       case DLG_ATTRIBS_CLOSE:
       case IDOK:
       case IDCANCEL:
         PostMessage(ghwnd_main,WM_COMMAND,IDM_ATTRIBUTES_FACE,0);
         break;
       default:
         break;
     }
     break;
   case WM_NCHITTEST:
     if(current_message >= 0){
       current_message = -1;
       SendPrgmMessage(IDS_ZERO,1);
     }
     break;
   case WM_DESTROY:
     for(i=0;i<N_PAGES;i++){
       if(lpDlgHdrAttribs->hwndDlg[i] != NULL)
         DestroyWindow(lpDlgHdrAttribs->hwndDlg[i]);
       lpDlgHdrAttribs->hwndDlg[i]=NULL;
     }
     GetWindowRect(hdlg,&rc);
     bRollUp=FALSE;
     xpos=rc.left; ypos=rc.top;
     break;
   default: break;
 }
 return( FALSE );
}



BOOL IsAttribDlgMessage(HWND hWnd, LPMSG lpMsg){
 int i;
 DLGHDR1 *lpDlgHdr;
 lpDlgHdr=&DlgHdrAttribs;
 for(i=0;i<N_PAGES;i++){
   if(lpDlgHdr->hwndDlg[i] != NULL){
     if(IsDialogMessage(lpDlgHdr->hwndDlg[i],lpMsg))return TRUE;
   }
 }
 return IsDialogMessage(hWnd,lpMsg);
}



BOOL CALLBACK DefaultAttribsDlgProc(HWND hdlg,UINT msg,
                             WPARAM wparam,LPARAM lparam){
 HWND hctl;
 BOOL err;
 int i,iMin,iMax;
 LPDRAWITEMSTRUCT lpdis;
 static FACEATTRIBS DefAttribs;
 static int nf;
 FACEATTRIBS *da;
 char str[32];
 da=&DefAttribs;
 switch( msg ) {
   case WM_PAINT:
     PaintDialogBackground(hdlg,ghinst_main);
     break;
   case WM_INITDIALOG:
     GetFaceAttribs(da,1);
     for(i=0;i<3;i++){
       da->fc[i]=FaceColour[i];
     }
     SendDlgItemMessage(hdlg,DLG_DEFAULT_SMOOTH_OFF,BM_SETCHECK,da->sm^1,0);
     SendDlgItemMessage(hdlg,DLG_DEFAULT_SMOOTH_ON, BM_SETCHECK,da->sm,  0);
     CentreDialogOnScreen(hdlg);
     return (TRUE);
   case WM_DRAWITEM:{
       HBRUSH   hbr,hbrold;
       BYTE r,g,b;
       lpdis=(LPDRAWITEMSTRUCT)lparam;
       if(lpdis->CtlID == DLG_DEFAULT_FC_EDIT ||
          lpdis->CtlID == DLG_DEFAULT_SC_EDIT){
         if(lpdis->CtlID == DLG_DEFAULT_FC_EDIT){
           r=da->fc[0]; g=da->fc[1]; b=da->fc[2];
         }
         if(lpdis->itemState & ODS_SELECTED)
           InvertRect(lpdis->hDC,&(lpdis->rcItem));
         else{
           hbr=CreateSolidBrush(RGB(r,g,b));
           hbrold=SelectObject(lpdis->hDC,hbr);
           Rectangle(lpdis->hDC,lpdis->rcItem.left,lpdis->rcItem.top,
                         lpdis->rcItem.right,lpdis->rcItem.bottom);
           SelectObject(lpdis->hDC,hbrold);
           DeleteObject(hbr);
         }
       }
     }
     return TRUE;
   case WM_HSCROLL:
     break;
   case WM_COMMAND:
      switch(LOWORD(wparam)){
        case DLG_DEFAULT_FC_EDIT:
          SetSfxColour(da->fc,IDX_MISC_FACE_COLOUR,hdlg);
          InvalidateRect(GetDlgItem(hdlg,DLG_DEFAULT_FC_EDIT),NULL,FALSE);
          break;
        case DLG_DEFAULT_SMOOTH_OFF:
          da->sm=0;
          break;
        case DLG_DEFAULT_SMOOTH_ON:
          da->sm=1;
          break;
        case IDCANCEL:
        case DLG_DEFAULT_CANCEL:
          EndDialog(hdlg,FAIL);
          return(TRUE);
        case IDOK:
        case DLG_DEFAULT_OK:
          for(i=0;i<3;i++){
            FaceColour[i]=da->fc[i];
          }
          DefaultSmoothing=da->sm;
          EndDialog(hdlg,OK);
          return(TRUE);
        default:
          break;
      }
      break;
    default: break;
 }
 return(FALSE);
}


static int EditExternalMaterial(HWND hdlg, int mapid, int id){
 HMODULE hLib;
 FARPROC fpFun;
 X__MEMORY_MANAGER *Evs;
 char *(*fpFun1)(char *, HWND, X__MEMORY_MANAGER *);
 Evs=&EviMemoryManager;
 EDIT_ACTION=YES;
 if(iMat[mapid].Shader[id].in_use ==  0)return FAIL;
 if(iMat[mapid].Shader[id].xname == NULL)return FAIL;
 hLib=LoadLibrary(iMat[mapid].Shader[id].xname);
 if(hLib == NULL){ /* try the default directory */
   char *sfname,tfname[256];
   sfname=short_form(iMat[mapid].Shader[id].xname);
   strcpy(tfname,gszHomeDir);  strcat(tfname,"textures\\");
   strcat(tfname,sfname);
   hLib=LoadLibrary(tfname);
 }
 if(hLib != NULL){
   if((fpFun=GetProcAddress(hLib,"_SetExternalParameters")) != NULL){
     fpFun1 = (void *)fpFun;
     if(iMat[mapid].Shader[id].parameters != NULL)iMat[mapid].Shader[id].parameters[0]='#';
     iMat[mapid].Shader[id].parameters=(*fpFun1)(iMat[mapid].Shader[id].parameters,hdlg,Evs);
   }
   else SendPrgmQuery(IDQ_FAILEDFUNCTION,3);
   FreeLibrary(hLib);
 }
 else SendPrgmQuery(IDQ_FAILEDLIBRARY,3);
 if(iMat[mapid].Shader[id].parameters == NULL)return FAIL;
 return OK;
}


static void DropExternalMaterial(HWND hdlg, int mapid, int id){
 EDIT_ACTION=YES;
 iMat[mapid].Shader[id].in_use=0;
 if(iMat[mapid].Shader[id].parameters != NULL)X__Free(iMat[mapid].Shader[id].parameters);
 if(iMat[mapid].Shader[id].xname != NULL)X__Free(iMat[mapid].Shader[id].xname);
 iMat[mapid].Shader[id].parameters=NULL;
 iMat[mapid].Shader[id].xname=NULL;
 return;
}

static void LoadExternalMaterial(HWND hdlg, int mapid, int id ){
 long l;
 unsigned char *np;
 l=strlen(gszDLLfile);
 strcpy((gszDLLfile+l-3),"sfx");
 if(SelectSfxFileName(0,gszDLLfile,gszDLLdir,IDX_MISC_LOADXSHADER,
   "(*.TFX)|*.tfx|",hdlg) == TRUE){
   l=strlen(gszDLLfile);
   strcpy((gszDLLfile+l-3),"dll");
   if(iMat[mapid].Shader[id].xname != NULL)X__Free(iMat[mapid].Shader[id].xname);
   iMat[mapid].Shader[id].xname=NULL;

   if((np=(unsigned char *)X__Malloc(strlen(gszDLLfile)+2)) == NULL)return;
   iMat[mapid].Shader[id].xname=np;
   strcpy(iMat[mapid].Shader[id].xname,gszDLLfile);

   iMat[mapid].Shader[id].in_use=1;
   if(iMat[mapid].Shader[id].parameters != NULL)X__Free(iMat[mapid].Shader[id].parameters);
   iMat[mapid].Shader[id].parameters=NULL;
   if(EditExternalMaterial(hdlg,mapid,id) == FAIL ||
      iMat[mapid].Shader[id].parameters == NULL  || 
      iMat[mapid].Shader[id].xname == NULL)DropExternalMaterial(hdlg,mapid,id);
 }
 return;
}

int CreateMaterial(BOOL ask){ 
 long i,j;
 char tempstr[32];
 if((i=nMats) >= NMATERIALMAX)return FAIL;
 sprintf(tempstr,"Material%ld",i);
 if(ask)if(RequestCharString(30,tempstr,"New Material Name",ghwnd_main) == 0)return FAIL;
 if(strlen(tempstr) > 0){
   iMat[i].version=1;
   strcpy(iMat[i].name,tempstr);
   for(j=0;j<3;j++){
    iMat[i].mcolour1[j]=128; iMat[i].mcolour2[j]=64;
    iMat[i].acolour[j]=64;   iMat[i].scolour[j]=255; // ambient and spec colours
    iMat[i].xcolour[j]=0;  // renamed as appropriate for other uses
    iMat[i].ycolour[j]=0;   
    iMat[i].zcolour[j]=0; 
   }
   iMat[i].bClear=iMat[i].bGlassEdge=FALSE;
   iMat[i].bShiny=iMat[i].bSmooth=TRUE;
   iMat[i].bUseSurfaceMapping=FALSE;
   iMat[i].gloss=128;
   iMat[i].refractive_index=1000;  // this is  1 (which is assumed to just be onesided class)
   iMat[i].refl=0;
   iMat[i].transp=0;
   iMat[i].bInternalShader=TRUE;
   iMat[i].internalShaderID=0;
   iMat[i].ax.P[0]=0;          iMat[i].ax.P[1]=0;         iMat[i].ax.P[2]=TVpointZ;
   iMat[i].ax.X[0]=TVsizeX/2;  iMat[i].ax.X[1]=0;         iMat[i].ax.X[2]=TVpointZ;
   iMat[i].ax.Y[0]=0;          iMat[i].ax.Y[1]=TVsizeZ/2; iMat[i].ax.Y[2]=TVpointZ;
   for(j=0;j<4;j++){
     iMat[i].Shader[j].bActive=FALSE;
     iMat[i].Shader[j].version=1;
     iMat[i].Shader[j].in_use=0;
     iMat[i].Shader[j].mixx=0;
     iMat[i].Shader[j].parameters=NULL;
     iMat[i].Shader[j].xname=NULL;
   } 
   for(j=0;j<16;j++) iMat[i].params[j]=0;
   for(j=0;j<16;j++) iMat[i].mmw[j]=(double)0.0;
   iMat[i].mmw[0]=(double)1.0;   // Emission
   iMat[i].mmw[1]=(double)0.0;   // Reflection
   iMat[i].mmw[2]=(double)0.0;   // transmission
   iMat[i].mmw[3]=(double)1.0;   // Refractive Index
   iMat[i].mmw[4]=(double)300.0; // Temerature
   iMat[i].mmw[5]=(double)0.0;   // Model (0/1/2)
   iMat[i].mmw[6]=(double)0.75;  // thickness (mm)
   iMat[i].mmw[7]=(double)0.5;   // Refr  Im
   // 8 is polarisation
   iMat[i].mmw[9]=(double)0.0001;   // APL
   iMat[i].mmw[10]=(double)0.015;   // BPL
   iMat[i].mmw[11]=(double)2.0;     // GPL
   iMat[i].mmw[12]=(double)0.0001;  // APD
   iMat[i].mmw[13]=(double)0.015;   // BPD
   iMat[i].mmw[14]=(double)2.0;     // GPD
   strcpy(iMat[i].mmw_brdf,"<none>");
   nMats++;
 }
 return OK;
}

void DeleteMaterial(int idd){
  int bid,id,i,j,k;
  face *f;
  if(nMats == 0){
    SendPrgmQuery(IDQ_NOSHADERAXES,0);
    return;
  }
  if(idd < 0){
    id=RequestMaterialID(ghwnd_main,"Choose Material to Delete");
    if(id < 0)return;  // cancel pressed
  }
  else id=idd;
  EDIT_ACTION=YES;
  if((f=MainFp) != NULL && Nface > 0)for(k=0;k<Nface;k++){ /* drop shader */
    if((bid = (int)f->material) == id){
      f->material = -1;            /* goto default plain material  */
    }
    else if(bid > id){      /* slide all the axes down one */
      bid--;
      f->material=bid;
    }
    f++;
  }
  for(k=0;k<4;k++){
    if(iMat[id].Shader[k].in_use && iMat[id].Shader[k].parameters != NULL)X__Free(iMat[id].Shader[k].parameters);
    if(iMat[id].Shader[k].in_use && iMat[id].Shader[k].xname != NULL)X__Free(iMat[id].Shader[k].xname);
  }
  if(id < nMats-1)for(i=id;i<nMats-1;i++){
    memcpy(&iMat[i],&iMat[i+1],sizeof(SURFACEMATERIAL));
  }
  nMats--;
  return;
}

void PurgeUnusedMaterials(void){
 int i,k,id;
 BOOL found;
 face *f;
 if(nMats == 0){
   SendPrgmQuery(IDQ_NOSHADERAXES,0);
   return;
 }
 LOOP:
 for(i=0;i<nMats;i++){
   found=FALSE;
   if((f=MainFp) != NULL && Nface > 0)for(k=0;k<Nface;k++){ /* drop shader */
     if((id=(unsigned char)f->material) == i)found=TRUE;
     if(id >= nMats) f->material = -1; // bad axis - reset to none axis
     f++;
   }
   if(!found){
     DeleteMaterial(i);
     goto LOOP;  // go back and repeat until all materials have been done
   }
 }
 return;
}

void PurgeDuplicateMaterials(long startat){
 long i,j,k;
 face *f;
 startagain:
 if(nMats < 2)return;
 if(startat >= nMats)return;
 for(i=0;i<startat;i++){
  for(j=startat;j<nMats;j++){
    if(stricmp(iMat[i].name,iMat[j].name) == 0){
      if((f=MainFp) != NULL && Nface > 0){for(k=0;k<Nface;k++,f++){if((f->material) == j)f->material=i;}}
      DeleteMaterial(j);
      goto startagain;
    }
  }
 }
 return;
}

void  CopyMaterial(int fromID, int toID){  
 int k;
 long ln;
 char name[32];
 for(k=0;k<4;k++){
   if(iMat[toID].Shader[k].in_use && iMat[toID].Shader[k].parameters != NULL)X__Free(iMat[toID].Shader[k].parameters);
   if(iMat[toID].Shader[k].in_use && iMat[toID].Shader[k].xname != NULL)X__Free(iMat[toID].Shader[k].xname);
 }
 memcpy(name,iMat[toID].name,32);
 memcpy(&iMat[toID],&iMat[fromID],sizeof(SURFACEMATERIAL));
 memcpy(iMat[toID].name,name,32);
 for(k=0;k<4;k++){
   iMat[toID].Shader[k].in_use=0; iMat[toID].Shader[k].xname=NULL; iMat[toID].Shader[k].parameters=NULL; 
   if(iMat[fromID].Shader[k].in_use){
     if(iMat[fromID].Shader[k].xname != NULL){
       ln=strlen(iMat[fromID].Shader[k].xname);  
       if((iMat[toID].Shader[k].xname=(char *)X__Malloc(ln+1)) != NULL){
         memcpy(iMat[toID].Shader[k].xname,iMat[fromID].Shader[k].xname,ln+1);
         if(iMat[fromID].Shader[k].parameters != NULL){
           ln=strlen(iMat[fromID].Shader[k].parameters);  
           if((iMat[toID].Shader[k].parameters=(char *)X__Malloc(ln+1)) != NULL){
             memcpy(iMat[toID].Shader[k].parameters,iMat[fromID].Shader[k].parameters,ln+1);
             iMat[toID].Shader[k].in_use=1;
           }
           else{
             X__Free(iMat[toID].Shader[k].xname); iMat[toID].Shader[k].xname=NULL;
           }
         }  
       }
       else iMat[k].Shader[toID].in_use=0;
     }
   }
 }
}

void DrawShaderInOne(HDC hDC,int view,int j){
 HPEN holdPen;
 HBRUSH holdBrush;
 int  oldROP;
 int i,k;
 int sho,svo,shx,svx,shy,svy;
 long x,y,z;
 if(j < 0 || j >= nMats)return; 
 holdPen=SelectObject(hDC,ghInvertPen);
 holdBrush=SelectObject(hDC,GetStockObject(HOLLOW_BRUSH));
 oldROP=SetROP2(hDC,R2_XORPEN);
 SelectPalette(hDC,ghpaletteScreen,FALSE);
 RealizePalette(hDC);
 GetWindowCoords(view,iMat[j].ax.P[0],iMat[j].ax.P[1],iMat[j].ax.P[2],&sho,&svo);
 GetWindowCoords(view,iMat[j].ax.X[0],iMat[j].ax.X[1],iMat[j].ax.X[2],&shx,&svx);
 GetWindowCoords(view,iMat[j].ax.Y[0],iMat[j].ax.Y[1],iMat[j].ax.Y[2],&shy,&svy);
 Rectangle(hDC,sho-5,svo-5,sho+5,svo+5);
 Rectangle(hDC,shx-2,svx-2,shx+2,svx+2);
 MoveToEx(hDC,shy-6,svy-3,NULL); LineTo(hDC,shy+5,svy-3);
 MoveToEx(hDC,shy+6,svy-3,NULL); LineTo(hDC,shy,svy+5);
 MoveToEx(hDC,shy-1,svy+4,NULL); LineTo(hDC,shy-6,svy-2);
 MoveToEx(hDC,shx,svx,NULL);  LineTo(hDC,sho,svo); LineTo(hDC,shy,svy);
 SelectObject(hDC,holdPen);
 SelectObject(hDC,holdBrush);
 SetROP2(hDC,oldROP);
 return;
}


int RequestMaterialID(HWND parent,char *message){
 int N,i,id;
 char **ItemList;
 N=nMats;
 if((ItemList = (char **)X__Malloc(N*sizeof(char *))) == NULL){
   SendPrgmQuery(IDQ_NOMEM2,0);
   return -1;
 }
 for(i=0;i<N;i++)ItemList[i] = iMat[i].name;
 id=SelectScrolledItemList(N,ItemList,message,parent);
 X__Free(ItemList);
 return id;
}

void EditMaterial(int id){
 int id1;
 if(id < 0){
  if(nMats == 0){ // create a new material;
    id1=0;
    CreateMaterial(TRUE);
    if(nMats == 0)return;
  }
  else{
    if(LastUsedMatID < 0){
      if(nMats == 1)id1=0;
      else id1=RequestMaterialID(ghwnd_main,"Choose Material");
    }
    id1=LastUsedMatID;
    if(id1 < 0)return;
    if(id1 >= nMats)id1=0; // In case one has been deleted.
  }
  id=id1;
 }
 if(nMats == 0)return; // MOVE later
 if(id >= nMats)return;
 EnableToolPannels(SELECT_PANNEL|COMMAND_PANNEL|TOOL_PANNEL|
                   ACTION_PANNEL|COORD_PANNEL|LOCK_PANNEL,FALSE);
 ActivateAllMenus(ghwnd_main,MF_GRAYED);
 id1=(int)DialogBoxParam(ghinst_main,MAKEINTRESOURCE(DLG_MATS),ghwnd_main,
            (DLGPROC)MaterialDlgProc,(LPARAM)id);
 ActivateAllMenus(ghwnd_main,MF_ENABLED);
 EnableToolPannels(SELECT_PANNEL|COMMAND_PANNEL|TOOL_PANNEL|
                   ACTION_PANNEL|COORD_PANNEL|LOCK_PANNEL,TRUE);
 if(id1 >= 0){
   axis_move_flag=id1;
   PositionMaterialOnOff(1,id1);
 }
 else if(image_edit_flag == 1) /* go back to the faces dialog */
   PostMessage(ghwnd_main,WM_COMMAND,IDM_ATTRIBUTES_FACE,0);
}

static int Nplist=5;
static char *plist[]={"None","Horizontal","Vertical","Circular+","Circular-"};

static UpdateMaterialDialogMMW(HWND hdlg, int matid){
 char str[32];
 int type;
 sprintf(str,"%.3lf",(float)iMat[matid].mmw[0]);  // EMISSION 
 SendDlgItemMessage(hdlg,DLG_MMW_EMISSION,WM_SETTEXT,0,(LPARAM)str);
 sprintf(str,"%.3lf",(float)iMat[matid].mmw[1]);  //reflection
 SendDlgItemMessage(hdlg,DLG_MMW_REFLECTION,WM_SETTEXT,0,(LPARAM)str);
 sprintf(str,"%.3lf",(float)iMat[matid].mmw[2]);  // transmission
 SendDlgItemMessage(hdlg,DLG_MMW_TRANSIMSSION,WM_SETTEXT,0,(LPARAM)str);
 sprintf(str,"%.3lf",(float)iMat[matid].mmw[3]); // Refractive Index (real)
 SendDlgItemMessage(hdlg,DLG_MMW_RI_RL,WM_SETTEXT,0,(LPARAM)str);
 sprintf(str,"%.3lf",(float)iMat[matid].mmw[4]); // Temperature
 SendDlgItemMessage(hdlg,DLG_MMW_TEMPERATURE,WM_SETTEXT,0,(LPARAM)str);
 type=(int)iMat[matid].mmw[5];
 if(type == 0)SendDlgItemMessage(hdlg,DLG_MMW_MODEL0,BM_SETCHECK,1,0); // Spec
 else         SendDlgItemMessage(hdlg,DLG_MMW_MODEL0,BM_SETCHECK,0,0); 
 if(type == 1)SendDlgItemMessage(hdlg,DLG_MMW_MODEL1,BM_SETCHECK,1,0); // ABg
 else         SendDlgItemMessage(hdlg,DLG_MMW_MODEL1,BM_SETCHECK,0,0); 
 if(type == 2)SendDlgItemMessage(hdlg,DLG_MMW_MODEL2,BM_SETCHECK,1,0); // lookup
 else         SendDlgItemMessage(hdlg,DLG_MMW_MODEL2,BM_SETCHECK,0,0); 
 sprintf(str,"%.3lf",(float)iMat[matid].mmw[6]); // Thickness (mm)
 SendDlgItemMessage(hdlg,DLG_MMW_THICKNESS,WM_SETTEXT,0,(LPARAM)str);
 sprintf(str,"%.3lf",(float)iMat[matid].mmw[7]); // Refractive Index Imag
 SendDlgItemMessage(hdlg,DLG_MMW_RI_IM,WM_SETTEXT,0,(LPARAM)str);
 {
   int i;
   HWND hctl;
   hctl=GetDlgItem(hdlg,DLG_MMW_POLARISATION);
   SendMessage(hctl,CB_RESETCONTENT,0,0);
   for(i=0;i<Nplist;i++)SendMessage(hctl,CB_ADDSTRING,0,(LPARAM)plist[i]);
   SendMessage(hctl,CB_SELECTSTRING,0,(LPARAM)plist[(int)(iMat[matid].mmw[8])]);
 } 
 sprintf(str,"%.5lf",(float)iMat[matid].mmw[9]); // APL 
 SendDlgItemMessage(hdlg,DLG_MMW_BRDF_APL,WM_SETTEXT,0,(LPARAM)str);
 sprintf(str,"%.5lf",(float)iMat[matid].mmw[10]); // BPL 
 SendDlgItemMessage(hdlg,DLG_MMW_BRDF_BPL,WM_SETTEXT,0,(LPARAM)str);
 sprintf(str,"%.2lf",(float)iMat[matid].mmw[11]); // GPL 
 SendDlgItemMessage(hdlg,DLG_MMW_BRDF_GPL,WM_SETTEXT,0,(LPARAM)str);
 sprintf(str,"%.5lf",(float)iMat[matid].mmw[12]); // APD 
 SendDlgItemMessage(hdlg,DLG_MMW_BRDF_APD,WM_SETTEXT,0,(LPARAM)str);
 sprintf(str,"%.5lf",(float)iMat[matid].mmw[13]); // BPD 
 SendDlgItemMessage(hdlg,DLG_MMW_BRDF_BPD,WM_SETTEXT,0,(LPARAM)str);
 sprintf(str,"%.2lf",(float)iMat[matid].mmw[14]); // GPD 
 SendDlgItemMessage(hdlg,DLG_MMW_BRDF_GPD,WM_SETTEXT,0,(LPARAM)str);
 if(type == 2){
   SendDlgItemMessage(hdlg,DLG_MMW_BRDF,WM_SETTEXT,0,(LPARAM)iMat[matid].mmw_brdf);
 }
 else {
   SendDlgItemMessage(hdlg,DLG_MMW_BRDF,WM_SETTEXT,0,(LPARAM)"  ");
 }
}

static void ReadDialogMMWvalues(HWND hdlg, int matid){
 char str[32];
 int i;
 // Non MMW specific
 if(GetDlgItemText(hdlg,DLG_MATS_REFINDEX,str,12) != 0)iMat[matid].refractive_index=(long)(atof(str)*1000.0);
 //
 if(GetDlgItemText(hdlg,DLG_MMW_EMISSION,str,12) != 0)iMat[matid].mmw[0]=atof(str);
 if(GetDlgItemText(hdlg,DLG_MMW_REFLECTION,str,12) != 0)iMat[matid].mmw[1]=atof(str);
 if(GetDlgItemText(hdlg,DLG_MMW_TRANSIMSSION,str,12) != 0)iMat[matid].mmw[2]=atof(str);
 if(GetDlgItemText(hdlg,DLG_MMW_RI_RL,str,12) != 0)iMat[matid].mmw[3]=atof(str); // Ref index
 if(GetDlgItemText(hdlg,DLG_MMW_TEMPERATURE,str,12) != 0)iMat[matid].mmw[4]=atof(str);  //Temperature
 if(GetDlgItemText(hdlg,DLG_MMW_THICKNESS,str,12) != 0)iMat[matid].mmw[6]=atof(str);  //Thickness (mm)
 if(GetDlgItemText(hdlg,DLG_MMW_RI_IM,str,12) != 0)iMat[matid].mmw[7]=atof(str); // Ref index (Imag)
 // RI tick and BRDF name set by buttons - no need to update
 // get the polarisation 
 SendDlgItemMessage(hdlg,DLG_MMW_POLARISATION,WM_GETTEXT,(WPARAM)31,(LPARAM)str);
 for(i=0;i<Nplist;i++){ 
   if(strcmp(str,plist[i]) == 0){
     iMat[matid].mmw[8]=(double)i;
     break;
   }
 }
 if(GetDlgItemText(hdlg,DLG_MMW_BRDF_APL,str,12) != 0)iMat[matid].mmw[9]=atof(str);
 if(GetDlgItemText(hdlg,DLG_MMW_BRDF_BPL,str,12) != 0)iMat[matid].mmw[10]=atof(str);
 if(GetDlgItemText(hdlg,DLG_MMW_BRDF_GPL,str,12) != 0)iMat[matid].mmw[11]=atof(str);
 if(GetDlgItemText(hdlg,DLG_MMW_BRDF_APD,str,12) != 0)iMat[matid].mmw[12]=atof(str);
 if(GetDlgItemText(hdlg,DLG_MMW_BRDF_BPD,str,12) != 0)iMat[matid].mmw[13]=atof(str);
 if(GetDlgItemText(hdlg,DLG_MMW_BRDF_GPD,str,12) != 0)iMat[matid].mmw[14]=atof(str);
}

static UpdateMaterialDialog(HWND hdlg,int matid){
 char str[32];
 SendDlgItemMessage(hdlg,DLG_ATTRIBS_TRN_SCROLL,TBM_SETPOS,TRUE,(LPARAM)iMat[matid].transp);
 sprintf(str,"%.1lf",(float)iMat[matid].transp/255.0);
 SendDlgItemMessage(hdlg,DLG_ATTRIBS_TRN_EDIT,WM_SETTEXT,0,(LPARAM)str);
 SendDlgItemMessage(hdlg,DLG_ATTRIBS_GLS_SCROLL,TBM_SETPOS,TRUE,(LPARAM)iMat[matid].gloss);
 sprintf(str,"%.1lf",(float)iMat[matid].gloss/255.0);
 SendDlgItemMessage(hdlg,DLG_ATTRIBS_GLS_EDIT,WM_SETTEXT,0,(LPARAM)str);
 SendDlgItemMessage(hdlg,DLG_ATTRIBS_REF_SCROLL,TBM_SETPOS,TRUE,(LPARAM)iMat[matid].refl);
 sprintf(str,"%.1lf",(float)iMat[matid].refl/255.0);
 SendDlgItemMessage(hdlg,DLG_ATTRIBS_REF_EDIT,WM_SETTEXT,0,(LPARAM)str);
 SendDlgItemMessage(hdlg,DLG_ATTRIBS_PRM_SCROLL,TBM_SETPOS,TRUE,(LPARAM)iMat[matid].params[0]);
 sprintf(str,"%.1lf",(float)iMat[matid].params[0]/255.0);
 SendDlgItemMessage(hdlg,DLG_ATTRIBS_PRM_EDIT,WM_SETTEXT,0,(LPARAM)str);
 SendDlgItemMessage(hdlg,DLG_MATS_LIST,CB_SELECTSTRING,0,
                           (LPARAM)iMat[matid].name);
 EnableWindow(GetDlgItem(hdlg,DLG_ATTRIBS_GLS_ON),TRUE);
 EnableWindow(GetDlgItem(hdlg,DLG_ATTRIBS_SMOOTH_ON),TRUE);
 EnableWindow(GetDlgItem(hdlg,DLG_ATTRIBS_TRN_TYPE1),TRUE);
 SendDlgItemMessage(hdlg,DLG_ATTRIBS_GLS_ON, BM_SETCHECK,iMat[matid].bShiny,0);
 SendDlgItemMessage(hdlg,DLG_ATTRIBS_TRN_TYPE1, BM_SETCHECK,iMat[matid].bGlassEdge,0);
 SendDlgItemMessage(hdlg,DLG_ATTRIBS_SMOOTH_ON, BM_SETCHECK,iMat[matid].bSmooth,0);
 SendDlgItemMessage(hdlg,DLG_MATS_MAPCOORDS, BM_SETCHECK,iMat[matid].bUseSurfaceMapping,0);
 
 SendDlgItemMessage(hdlg,DLG_ATTRIBS_SHA_INT, BM_SETCHECK,iMat[matid].bInternalShader,0);
 SendDlgItemMessage(hdlg,DLG_ATTRIBS_SHA_EXT, BM_SETCHECK,!iMat[matid].bInternalShader,0);
 SetDlgItemText(hdlg,DLG_ATTRIBS_SHA_NAME,AlTextList[iMat[matid].internalShaderID]);
 SendDlgItemMessage(hdlg,DLG_SHADERSET_ON1, BM_SETCHECK,iMat[matid].Shader[0].bActive,0);
 SendDlgItemMessage(hdlg,DLG_SHADERSET_ON2, BM_SETCHECK,iMat[matid].Shader[1].bActive,0);
 SendDlgItemMessage(hdlg,DLG_SHADERSET_ON3, BM_SETCHECK,iMat[matid].Shader[2].bActive,0);
 SendDlgItemMessage(hdlg,DLG_SHADERSET_ON4, BM_SETCHECK,iMat[matid].Shader[3].bActive,0);
 if(iMat[matid].Shader[0].in_use == 1 && iMat[matid].Shader[0].xname != NULL)
   SetDlgItemText(hdlg,DLG_SHADERSET_NAME1 ,(LPCTSTR)FileInPath(iMat[matid].Shader[0].xname));
 else 
   SetDlgItemText(hdlg,DLG_SHADERSET_NAME1 ," ");
 if(iMat[matid].Shader[1].in_use == 1 && iMat[matid].Shader[1].xname != NULL)
   SetDlgItemText(hdlg,DLG_SHADERSET_NAME2 ,(LPCTSTR)FileInPath(iMat[matid].Shader[1].xname));
 else 
   SetDlgItemText(hdlg,DLG_SHADERSET_NAME2 ," ");
 if(iMat[matid].Shader[2].in_use == 1 && iMat[matid].Shader[2].xname != NULL)
   SetDlgItemText(hdlg,DLG_SHADERSET_NAME3 ,(LPCTSTR)FileInPath(iMat[matid].Shader[2].xname));
  else 
   SetDlgItemText(hdlg,DLG_SHADERSET_NAME3 ," ");
if(iMat[matid].Shader[3].in_use == 1 && iMat[matid].Shader[3].xname != NULL)
   SetDlgItemText(hdlg,DLG_SHADERSET_NAME4 ,(LPCTSTR)FileInPath(iMat[matid].Shader[3].xname));
 else 
   SetDlgItemText(hdlg,DLG_SHADERSET_NAME4 ," ");
 InvalidateRect(GetDlgItem(hdlg,DLG_ATTRIBS_FC_EDIT),NULL,FALSE);
 InvalidateRect(GetDlgItem(hdlg,DLG_ATTRIBS_SC_EDIT),NULL,FALSE);
 sprintf(str,"%.2lf",((float)iMat[matid].refractive_index)/1000.0);
 SendDlgItemMessage(hdlg,DLG_MATS_REFINDEX,WM_SETTEXT,0,(LPARAM)str);
 UpdateMaterialDialogMMW(hdlg,matid);
}

static BOOL CALLBACK MaterialDlgProc(HWND hdlg,UINT msg,
                                    WPARAM wparam,LPARAM lparam){
 static int MatID,sv;
 HWND hctl;
 BOOL err;
 int i,iMin,iMax;
 unsigned char fcc[3];
 LPDRAWITEMSTRUCT lpdis;
 switch( msg ) {
   case WM_PAINT:
     PaintDialogBackground(hdlg,ghinst_main);
     break;
   case WM_INITDIALOG:
     EDIT_ACTION=YES;
     EnableWindow(ghwnd_main,TRUE);
     MatID=(int)lparam;
     SendDlgItemMessage(hdlg,DLG_MAPS_LIST,CB_LIMITTEXT,30,0);
     for(i=0;i<nMats;i++){
       SendDlgItemMessage(hdlg,DLG_MATS_LIST,CB_ADDSTRING,0,
                               (LPARAM)iMat[i].name);
     }
     //
     SendDlgItemMessage(hdlg,DLG_ATTRIBS_GLS_SCROLL,TBM_SETRANGE,
                                (WPARAM)TRUE,(LPARAM)MAKELONG(0,255));
     SendDlgItemMessage(hdlg,DLG_ATTRIBS_GLS_SCROLL,TBM_SETLINESIZE,0,1);
     SendDlgItemMessage(hdlg,DLG_ATTRIBS_GLS_SCROLL,TBM_SETPAGESIZE,0,5);
     SendDlgItemMessage(hdlg,DLG_ATTRIBS_GLS_SCROLL,TBM_SETTICFREQ,16,(LPARAM)0);
     //
     SendDlgItemMessage(hdlg,DLG_ATTRIBS_TRN_SCROLL,TBM_SETRANGE,
                                (WPARAM)TRUE,(LPARAM)MAKELONG(0,255));
     SendDlgItemMessage(hdlg,DLG_ATTRIBS_TRN_SCROLL,TBM_SETLINESIZE,0,1);
     SendDlgItemMessage(hdlg,DLG_ATTRIBS_TRN_SCROLL,TBM_SETPAGESIZE,0,5);
     SendDlgItemMessage(hdlg,DLG_ATTRIBS_TRN_SCROLL,TBM_SETTICFREQ,16,(LPARAM)0);
     //
     SendDlgItemMessage(hdlg,DLG_ATTRIBS_REF_SCROLL,TBM_SETRANGE,
                                (WPARAM)TRUE,(LPARAM)MAKELONG(0,255));
     SendDlgItemMessage(hdlg,DLG_ATTRIBS_REF_SCROLL,TBM_SETLINESIZE,0,1);
     SendDlgItemMessage(hdlg,DLG_ATTRIBS_REF_SCROLL,TBM_SETPAGESIZE,0,5);
     SendDlgItemMessage(hdlg,DLG_ATTRIBS_REF_SCROLL,TBM_SETTICFREQ,16,(LPARAM)0);
     //
     SendDlgItemMessage(hdlg,DLG_ATTRIBS_PRM_SCROLL,TBM_SETRANGE,
                                (WPARAM)TRUE,(LPARAM)MAKELONG(0,255));
     SendDlgItemMessage(hdlg,DLG_ATTRIBS_PRM_SCROLL,TBM_SETLINESIZE,0,1);
     SendDlgItemMessage(hdlg,DLG_ATTRIBS_PRM_SCROLL,TBM_SETPAGESIZE,0,5);
     SendDlgItemMessage(hdlg,DLG_ATTRIBS_PRM_SCROLL,TBM_SETTICFREQ,16,(LPARAM)0);
     //
     CentreDialogOnScreen(hdlg);
     UpdateMaterialDialog(hdlg,MatID);
     return (TRUE);
   case WM_DESTROY:
     break;
   case WM_DRAWITEM:{
       HBRUSH   hbr,hbrold;
       BYTE r,g,b;
       lpdis=(LPDRAWITEMSTRUCT)lparam;
       if(lpdis->CtlID == DLG_ATTRIBS_FC_EDIT){
         r=iMat[MatID].mcolour1[0];
         g=iMat[MatID].mcolour1[1];
         b=iMat[MatID].mcolour1[2];
         if(lpdis->itemState & ODS_DISABLED){
           r=128; g=128; b=128;
         }
         if(lpdis->itemState & ODS_SELECTED)
           InvertRect(lpdis->hDC,&(lpdis->rcItem));
         else{
           if(lpdis->itemState & ODS_DISABLED)
                hbr=CreateHatchBrush(HS_DIAGCROSS,RGB(128,128,128));
           else hbr=CreateSolidBrush(RGB(r,g,b));
           hbrold=SelectObject(lpdis->hDC,hbr);
           Rectangle(lpdis->hDC,lpdis->rcItem.left,lpdis->rcItem.top,
                         lpdis->rcItem.right,lpdis->rcItem.bottom);
           SelectObject(lpdis->hDC,hbrold);
           DeleteObject(hbr);
         }
       }
       else if(lpdis->CtlID == DLG_ATTRIBS_SC_EDIT){
         r=iMat[MatID].mcolour2[0];
         g=iMat[MatID].mcolour2[1];
         b=iMat[MatID].mcolour2[2];
         if(lpdis->itemState & ODS_DISABLED){
           r=128; g=128; b=128;
         }
         if(lpdis->itemState & ODS_SELECTED)
           InvertRect(lpdis->hDC,&(lpdis->rcItem));
         else{
           if(lpdis->itemState & ODS_DISABLED)
                hbr=CreateHatchBrush(HS_DIAGCROSS,RGB(128,128,128));
           else hbr=CreateSolidBrush(RGB(r,g,b));
           hbrold=SelectObject(lpdis->hDC,hbr);
           Rectangle(lpdis->hDC,lpdis->rcItem.left,lpdis->rcItem.top,
                         lpdis->rcItem.right,lpdis->rcItem.bottom);
           SelectObject(lpdis->hDC,hbrold);
           DeleteObject(hbr);
         }
       }
     }
     return TRUE;
   case WM_HSCROLL:
     i=0;
     if((HWND)lparam == (hctl=GetDlgItem(hdlg,DLG_ATTRIBS_PRM_SCROLL)))i=1;
     if((HWND)lparam == (hctl=GetDlgItem(hdlg,DLG_ATTRIBS_REF_SCROLL)))i=2;
     if((HWND)lparam == (hctl=GetDlgItem(hdlg,DLG_ATTRIBS_TRN_SCROLL)))i=3;
     if((HWND)lparam == (hctl=GetDlgItem(hdlg,DLG_ATTRIBS_GLS_SCROLL)))i=4;
     if(i > 0){
       iMin=SendMessage(hctl,TBM_GETRANGEMIN,0,0);
       iMax=SendMessage(hctl,TBM_GETRANGEMAX,0,0);
       switch (LOWORD(wparam)) {
         case TB_PAGEDOWN:
         case TB_LINEDOWN: 
           if(i == 1)sv=iMat[MatID].params[0]=min(iMax,iMat[MatID].params[0]+16);
           if(i == 2)sv=iMat[MatID].refl=min(iMax,iMat[MatID].refl+16);
           if(i == 3)sv=iMat[MatID].transp=min(iMax,iMat[MatID].transp+16);
           if(i == 4)sv=iMat[MatID].gloss=min(iMax,iMat[MatID].gloss+16);
           UpdateMaterialDialog(hdlg,MatID);
           break;
         case TB_PAGEUP:
         case TB_LINEUP:
           if(i == 1)sv=iMat[MatID].params[0]=max(iMin,iMat[MatID].params[0]-16);
           if(i == 2)sv=iMat[MatID].refl=max(iMin,iMat[MatID].refl-16);
           if(i == 3)sv=iMat[MatID].transp=max(iMin,iMat[MatID].transp-16);
           if(i == 4)sv=iMat[MatID].gloss=max(iMin,iMat[MatID].gloss-16);
           UpdateMaterialDialog(hdlg,MatID);
           break;
         case TB_THUMBTRACK:
         case TB_THUMBPOSITION:
           sv=HIWORD(wparam);  
           if(i == 1)iMat[MatID].params[0]=sv;
           if(i == 2)sv=iMat[MatID].refl=sv;
           if(i == 3)sv=iMat[MatID].transp=sv;
           if(i == 4)sv=iMat[MatID].gloss=sv;
           UpdateMaterialDialog(hdlg,MatID);
           break;
         case TB_ENDTRACK:
           if(i == 1)iMat[MatID].params[0]=sv;
           if(i == 1)iMat[MatID].params[0]=sv;
           if(i == 2)sv=iMat[MatID].refl=sv;
           if(i == 3)sv=iMat[MatID].transp=sv;
           if(i == 4)sv=iMat[MatID].gloss=sv;
           UpdateMaterialDialog(hdlg,MatID);
           UpdateGLview();
           break;
         default: break;
       }
     }
     break;
   case WM_COMMAND:
     switch(HIWORD(wparam)){
       case CBN_EDITCHANGE:
         SendDlgItemMessage(hdlg,DLG_MATS_LIST,WM_GETTEXT,(WPARAM)30,
                            (LPARAM)iMat[MatID].name);
         if(strlen(iMat[MatID].name) == 0)strcpy(iMat[MatID].name,"$");
         SendDlgItemMessage(hdlg,DLG_MATS_LIST,CB_DELETESTRING,
                                (WPARAM)MatID,0);
         SendDlgItemMessage(hdlg,DLG_MATS_LIST,CB_INSERTSTRING,
                                (WPARAM)MatID,(LPARAM)iMat[MatID].name);
         break;
       case CBN_SELENDOK:
         if(LOWORD(wparam) == DLG_MATS_LIST){
           i=(int)SendDlgItemMessage(hdlg,DLG_MATS_LIST,CB_GETCURSEL,0,0);
           if(i != CB_ERR){
             ReadDialogMMWvalues(hdlg,MatID);   // update the structure with the user's settings
             MatID=(long)i;
             LastUsedMatID=MatID; // save global
             UpdateMaterialDialog(hdlg,MatID);
           }
         }
         break;
       default:
         break;
     }
     switch(LOWORD(wparam)){
       case DLG_MMW_MODEL0:
         i=SendDlgItemMessage(hdlg,DLG_MMW_MODEL0,BM_GETCHECK,0,0);
         if(i == BST_CHECKED)iMat[MatID].mmw[5]=0.0;
         UpdateMaterialDialog(hdlg,MatID);
         break;
       case DLG_MMW_MODEL1:
         i=SendDlgItemMessage(hdlg,DLG_MMW_MODEL1,BM_GETCHECK,0,0);
         if(i == BST_CHECKED)iMat[MatID].mmw[5]=1.0;
         UpdateMaterialDialog(hdlg,MatID);
         break;
       case DLG_MMW_MODEL2:
         i=SendDlgItemMessage(hdlg,DLG_MMW_MODEL2,BM_GETCHECK,0,0);
         if(i == BST_CHECKED)iMat[MatID].mmw[5]=2.0;
         UpdateMaterialDialog(hdlg,MatID);
         break;
       case DLG_MATS_BRDF_FILE:
         if(SelectSfxFileName(1,gszBRDfile,gszBRDdir,IDX_MISC_USEBRDF,
                           "(*.BRDF)|*.brdf|",hdlg) == TRUE){
           AppendFileExtension(gszBRDfile,".brdf");
           strcpy(iMat[MatID].mmw_brdf,gszBRDfile);  
           UpdateMaterialDialog(hdlg,MatID);
         }
         break;
       case DLG_ATTRIBS_FC_EDIT:
         VECCOPY(iMat[MatID].mcolour1,fcc)
         if(SetSfxColour(fcc,IDX_MISC_FACE_COLOUR,hdlg)){
           VECCOPY(fcc,iMat[MatID].mcolour1)
           VECCOPY(fcc,LastColour)
           UpdateGLview();
           InvalidateRect(GetDlgItem(hdlg,DLG_ATTRIBS_FC_EDIT),NULL,FALSE);
         }
         break;
       case DLG_ATTRIBS_SC_EDIT:
         VECCOPY(iMat[MatID].mcolour2,fcc)
         if(SetSfxColour(fcc,IDX_MISC_FACE_COLOUR,hdlg)){
           VECCOPY(fcc,iMat[MatID].mcolour2)
           VECCOPY(fcc,LastColour)
           UpdateGLview();
           InvalidateRect(GetDlgItem(hdlg,DLG_ATTRIBS_SC_EDIT),NULL,FALSE);
         }
         break;
       case DLG_MATS_MAPCOORDS:
         i=SendDlgItemMessage(hdlg,DLG_MATS_MAPCOORDS,BM_GETCHECK,0,0);
         if(i == BST_CHECKED)iMat[MatID].bUseSurfaceMapping=TRUE;
         else                iMat[MatID].bUseSurfaceMapping=FALSE;
         UpdateMaterialDialog(hdlg,MatID);
         break;
       case DLG_ATTRIBS_SMOOTH_ON:
         i=SendDlgItemMessage(hdlg,DLG_ATTRIBS_SMOOTH_ON,BM_GETCHECK,0,0);
         if(i == BST_CHECKED)iMat[MatID].bSmooth=TRUE;
         else                iMat[MatID].bSmooth=FALSE;
         UpdateMaterialDialog(hdlg,MatID);
         UpdateGLview();
         break;
       case DLG_ATTRIBS_GLS_ON:
         i=SendDlgItemMessage(hdlg,DLG_ATTRIBS_GLS_ON,BM_GETCHECK,0,0);
         if(i == BST_CHECKED)iMat[MatID].bShiny=TRUE;
         else                iMat[MatID].bShiny=FALSE;
         UpdateMaterialDialog(hdlg,MatID);
         UpdateGLview();
         break;
       case DLG_ATTRIBS_TRN_TYPE1:
         i=SendDlgItemMessage(hdlg,DLG_ATTRIBS_TRN_TYPE1,BM_GETCHECK,0,0);
         if(i == BST_CHECKED)iMat[MatID].bGlassEdge=TRUE;
         else                iMat[MatID].bGlassEdge=FALSE;
         UpdateMaterialDialog(hdlg,MatID);
         break;
       case DLG_ATTRIBS_SHA_SET:
         if((i=SelectScrolledItemList(NoAlTexts,AlTextList,
                 "Texture",hdlg)) >= 0){
           iMat[MatID].internalShaderID=i; 
         }
         UpdateMaterialDialog(hdlg,MatID);
         UpdateGLview(); 
         break;
       case DLG_ATTRIBS_SHA_INT:
         iMat[MatID].bInternalShader=TRUE; 
         UpdateMaterialDialog(hdlg,MatID);
         UpdateGLview();
         break;
       case DLG_ATTRIBS_SHA_EXT:
         iMat[MatID].bInternalShader=FALSE; 
         UpdateMaterialDialog(hdlg,MatID);
         UpdateGLview();
         break;

       case DLG_SHADERSET_ON1:
         iMat[MatID].Shader[0].bActive ^= 1;
         UpdateMaterialDialog(hdlg,MatID);
         break;
       case DLG_SHADERSET_ON2:
         iMat[MatID].Shader[1].bActive ^= 1;
         UpdateMaterialDialog(hdlg,MatID);
         break;
       case DLG_SHADERSET_ON3:
         iMat[MatID].Shader[2].bActive ^= 1;
         UpdateMaterialDialog(hdlg,MatID);
         break;
       case DLG_SHADERSET_ON4:
         iMat[MatID].Shader[3].bActive ^= 1;
         UpdateMaterialDialog(hdlg,MatID);
         break;
       case DLG_SHADERSET_LOAD1:
         LoadExternalMaterial(hdlg,MatID,0);
         UpdateMaterialDialog(hdlg,MatID);
         break;
       case DLG_SHADERLOAD_DROP1:
         DropExternalMaterial(hdlg,MatID,0);
         UpdateMaterialDialog(hdlg,MatID);
         break;
       case DLG_SHADERSET_EDIT1:
         EditExternalMaterial(hdlg,MatID,0);
         UpdateMaterialDialog(hdlg,MatID);
         break;
       case DLG_SHADERSET_LOAD2:
         LoadExternalMaterial(hdlg,MatID,1);
         UpdateMaterialDialog(hdlg,MatID);
         break;
       case DLG_SHADERLOAD_DROP2:
         DropExternalMaterial(hdlg,MatID,1);
         UpdateMaterialDialog(hdlg,MatID);
         break;
       case DLG_SHADERSET_EDIT2:
         EditExternalMaterial(hdlg,MatID,1);
         UpdateMaterialDialog(hdlg,MatID);
         break;
       case DLG_SHADERSET_LOAD3:
         LoadExternalMaterial(hdlg,MatID,2);
         UpdateMaterialDialog(hdlg,MatID);
         break;
       case DLG_SHADERLOAD_DROP3:
         DropExternalMaterial(hdlg,MatID,2);
         UpdateMaterialDialog(hdlg,MatID);
         break;
       case DLG_SHADERSET_EDIT3:
         EditExternalMaterial(hdlg,MatID,2);
         UpdateMaterialDialog(hdlg,MatID);
         break;
       case DLG_SHADERSET_LOAD4:
         LoadExternalMaterial(hdlg,MatID,3);
         UpdateMaterialDialog(hdlg,MatID);
         break;
       case DLG_SHADERLOAD_DROP4:
         DropExternalMaterial(hdlg,MatID,3);
         UpdateMaterialDialog(hdlg,MatID);
         break;
       case DLG_SHADERSET_EDIT4:
         EditExternalMaterial(hdlg,MatID,3);
         UpdateMaterialDialog(hdlg,MatID);
         break;
       case DLG_MATS_MOVE:
         // if openGL then update the OpenGL maps
         if(ghwndOpenGLview != NULL)PostMessage(ghwndOpenGLview,(WM_USER+4),0,0);
         EndDialog(hdlg,MatID);
         return(TRUE);
       case DLG_MATS_NEW:
         ReadDialogMMWvalues(hdlg,MatID);   // update the structure with the user's settings
         CreateMaterial(TRUE);
         MatID=nMats-1;
         LastUsedMatID=MatID; // save global
         SendDlgItemMessage(hdlg,DLG_MATS_LIST,CB_ADDSTRING,0,
                               (LPARAM)iMat[MatID].name);
         UpdateMaterialDialog(hdlg,MatID);
         break;
       case DLG_MATS_DELETE:
         SendDlgItemMessage(hdlg,DLG_MATS_LIST,CB_DELETESTRING,
                                (WPARAM)MatID,0);
         DeleteMaterial(MatID);
         // if openGL then update the OpenGL maps
         if(ghwndOpenGLview != NULL)PostMessage(ghwndOpenGLview,
                                                (WM_USER+4),0,0);
         if(nMats == 0){
           EndDialog(hdlg,-1);
           return(TRUE);
         }
         if(MatID >= nMats)MatID=nMats-1;
         LastUsedMatID=MatID; // save global
         UpdateMaterialDialog(hdlg,MatID);
         break;
       case DLG_MATS_COPY: 
         i=RequestMaterialID(hdlg,"Copy From ?");
         if(i >= 0 && i < nMats && i != MatID){
           CopyMaterial(i,MatID);  
           UpdateMaterialDialog(hdlg,MatID);
         } 
         break;
       case DLG_MATS_PREVIEW:
         SendMessage(ghwnd_main,WM_COMMAND,(WPARAM)IDM_VIEW_RENDERINWINDOW,0);
         break;
       case IDCANCEL:
       case DLG_MATS_DONE:
         // if openGL then update the OpenGL maps
         ReadDialogMMWvalues(hdlg,MatID);   // update the structure with the user's settings
         if(ghwndOpenGLview != NULL)PostMessage(ghwndOpenGLview,
                                                (WM_USER+4),0,0);
         EndDialog(hdlg,-1);
         return(TRUE);
       default:
         break;
     }
     break;
   default: break;
 }
 return(FALSE);
}

void PositionMaterialOnOff(int OnOff,int id){
 int i;
 static int LastShaderUsed = -1;
 if(!OnOff){ // i.e. ON/OFF = 0 
   EnableToolPannels(COMMAND_PANNEL|SELECT_PANNEL|TOOL_PANNEL|ACTION_PANNEL,TRUE);
   ActivateAllMenus(ghwnd_main,MF_ENABLED);
   EnableMenuItem(GetMenu(ghwnd_main),IDM_STOP,MF_GRAYED);
   DrawMenuBar(ghwnd_main);
   lock_visible=NO;
   if(ghwndLock)ShowWindow(ghwndLock,SW_HIDE);
   controls_visible=YES;
   DrawShader(SelectedShader);
   SelectedShader = -1;
   if(IsWindow(ghwndDlgAttribs))ShowWindow(ghwndDlgAttribs,SW_SHOW);
   if(axis_move_flag >= 0){
     PostMessage(ghwnd_main,WM_COMMAND,IDM_MATERIAL_EDIT,0);
   }
   return;
 }
 if(SelectedShader >= 0)return;
 if(id < 0){
   if(nMats == 0){
     MessageBox(NULL,"NEED MATERIAL",NULL,MB_OK);// need to create material
     return;
   }
   else if((id=RequestMaterialID(ghwnd_main,"Choose Material")) < 0)return;
 }
 EDIT_ACTION=YES;
 SelectedShader = id;
 LastShaderUsed=SelectedShader;
 EnableToolPannels(COMMAND_PANNEL|SELECT_PANNEL|TOOL_PANNEL|ACTION_PANNEL,FALSE);
 ActivateAllMenus(ghwnd_main,MF_GRAYED);
 EnableMenuItem(GetMenu(ghwnd_main),IDM_STOP,MF_ENABLED);
 DrawMenuBar(ghwnd_main);
 controls_visible=NO;
 lock_visible=YES;
 if(ghwndLock)ShowWindow(ghwndLock,SW_SHOW);
 if(IsWindow(ghwndDlgAttribs))ShowWindow(ghwndDlgAttribs,SW_HIDE);
 DrawShader(SelectedShader);
 return;
}

void GrabMaterialAxisPoint(int x,int y){
 int id,x0,y0,x1,y1,x2,y2;
 double d,dmin;
 if(SelectedShader < 0)return;
 GetWindowCoords(ActiveView,iMat[SelectedShader].ax.P[0],
           iMat[SelectedShader].ax.P[1],iMat[SelectedShader].ax.P[2],&x0,&y0);
 GetWindowCoords(ActiveView,iMat[SelectedShader].ax.X[0],
           iMat[SelectedShader].ax.X[1],iMat[SelectedShader].ax.X[2],&x1,&y1);
 GetWindowCoords(ActiveView,iMat[SelectedShader].ax.Y[0],
           iMat[SelectedShader].ax.Y[1],iMat[SelectedShader].ax.Y[2],&x2,&y2);
 id = -1; dmin=(double)TVsizeX*(double)TVsizeY*2.0;
 if(abs(x-x0) < 4 && abs(y-y0) < 4){
   d=DIS2(iMat[SelectedShader].ax.P); if(d < dmin){id = 0; dmin=d;}
 }
 if(abs(x-x1) < 4 && abs(y-y1) < 4){
   d=DIS2(iMat[SelectedShader].ax.X); if(d < dmin){id = 1; dmin=d;}
 }
 if(abs(x-x2) < 4 && abs(y-y2) < 4){
   d=DIS2(iMat[SelectedShader].ax.Y); if(d < dmin){id = 2; dmin=d;}
 }
 if(id >= 0){
   IdentifiedShaderPoint=id;
 }
}

void UnGrabMaterialAxisPoint(void){
  if(ghwndOpenGLview != NULL)PostMessage(ghwndOpenGLview,(WM_USER+4),0,0); 
  IdentifiedShaderPoint=-1;
}

void PullShaderPoint(int x,int y){
 int p,sb,ix,iy,iz;
 long x1,y1,z1,dx,dy,dz;
 if((p=IdentifiedShaderPoint) >= 0){
   sb=SelectedShader;
   DrawShader(sb);
   GetWorldCoords(ActiveView,&x1,&y1,&z1,x,y);
   ix=iy=iz=1;
   if     (ActiveView == TRITOP  )iz=0;
   else if(ActiveView == TRIFRONT)iy=0;
   else if(ActiveView == TRIRIGHT)ix=0;
   if(p == 0){
     dx=iMat[sb].ax.X[0]-iMat[sb].ax.P[0];
     dy=iMat[sb].ax.X[1]-iMat[sb].ax.P[1];
     dz=iMat[sb].ax.X[2]-iMat[sb].ax.P[2];
     if(ix)iMat[sb].ax.X[0]=x1+dx;
     if(iy)iMat[sb].ax.X[1]=y1+dy;
     if(iz)iMat[sb].ax.X[2]=z1+dz;
     dx=iMat[sb].ax.Y[0]-iMat[sb].ax.P[0];
     dy=iMat[sb].ax.Y[1]-iMat[sb].ax.P[1];
     dz=iMat[sb].ax.Y[2]-iMat[sb].ax.P[2];
     if(ix){iMat[sb].ax.Y[0]=x1+dx; iMat[sb].ax.P[0]=x1;}
     if(iy){iMat[sb].ax.Y[1]=y1+dy; iMat[sb].ax.P[1]=y1;}
     if(iz){iMat[sb].ax.Y[2]=z1+dz; iMat[sb].ax.P[2]=z1;}
   }
   else if(p == 1){
     if(ix)iMat[sb].ax.X[0]=x1;
     if(iy)iMat[sb].ax.X[1]=y1;
     if(iz)iMat[sb].ax.X[2]=z1;
   }
   else if(p == 2){
     if(ix)iMat[sb].ax.Y[0]=x1;
     if(iy)iMat[sb].ax.Y[1]=y1;
     if(iz)iMat[sb].ax.Y[2]=z1;
   }
   DrawShader(SelectedShader);
 }
}

void ExportMaterialsToFile(HWND parent){ //RSFx
 int i;
 FILE *fp;
 if(SelectSfxFileName(1,gszMTLfile,gszMTLdir,IDX_MISC_USEMATERIAL,
                        "(*.MTL)|*.mtl|",parent) == TRUE){
   AppendFileExtension(gszMTLfile,".mtl");
   if(nMats > 0 && (fp=fopen(gszMTLfile,"wb")) != NULL){
     fwrite(&nMats,sizeof(int),1,fp);
     for(i=0;i<nMats;i++){
       fwrite(&(iMat[i].name),sizeof(char),32,fp);
       fwrite(&(iMat[i]),sizeof(SURFACEMATERIAL),1,fp);
     }
     fclose(fp);
   }
 } 
}
 
void ImportMaterialsFromFile(HWND parent){
 int i,j,nlMats,c=0;
 SURFACEMATERIAL lMat;
 char name[32],txt[128];
 FILE *fp;
 if(nMats < 1)return;
 if(SelectSfxFileName(0,gszMTLfile,gszMTLdir,IDX_MISC_USEMATERIAL,
                        "(*.MTL)|*.mtl|",parent) == TRUE){
   AppendFileExtension(gszMTLfile,".mtl");
   if(nMats > 0 && (fp=fopen(gszMTLfile,"rb")) != NULL){
     fread(&nlMats,sizeof(int),1,fp);     
     if(nlMats > 0)for(i=0;i<nlMats;i++){
       fread(&name,sizeof(char),32,fp);
       fread(&lMat,sizeof(SURFACEMATERIAL),1,fp);
       // now see if this material is in use and replace
       for(j=0;j<nMats;j++){
         if(strncmp(name,iMat[j].name,32) == 0){ // this material has been found
           memcpy(&(iMat[j]),&lMat,sizeof(SURFACEMATERIAL));
           c++;
         }
       }
     }
     fclose(fp);
   }
 }
 sprintf(txt,"%d Materials Replaced",c); MessageBox(parent,txt,"OpenFx",MB_OK); 
}