NURBSDLG.C

Go to the documentation of this file.

/* --
OpenFX version 1.0 - Modelling, Animation and Rendering Package
Copyright (C) 2000 OpenFX Development Team

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

You may contact the OpenFX development team via elecronic mail
at core@openfx.org, or visit our website at http://openfx.org for
further information and support details.
-- */


/* File NURBSDLG.C   included in NURBS.C */

static BOOL CALLBACK AddNurbsDlgProc(HWND hwnd, UINT msg,
                                    WPARAM wparam, LPARAM lparam){
 long orderU=4,orderV=4,numU=4,numV=4;
 BOOL err;
 int i;
 nurbs *np;
 switch( msg ) {
   case WM_PAINT:
     PaintDialogBackground(hwnd,ghinst_main);
     break;
   case WM_INITDIALOG:{
       np=(nurbs *)lparam;
       SendDlgItemMessage(hwnd,DLG_ADDNURBS_NAME,WM_SETTEXT,0,
                          (LPARAM)np->properties.name);
       SetDlgItemInt(hwnd,DLG_ADDNURBS_ORDERU,orderU,FALSE);
       SendDlgItemMessage(hwnd,DLG_ADDNURBS_ORDERU,EM_LIMITTEXT,(WPARAM)6,0);
       SendDlgItemMessage(hwnd,DLG_ADDNURBS_ORDERU_S,SPNM_SETRANGE,0,
                          MAKELPARAM(3,100));
       SendDlgItemMessage(hwnd,DLG_ADDNURBS_ORDERU_S,SPNM_SETCRNTVALUE,
                          (WPARAM)orderU,0);
       SendDlgItemMessage(hwnd,DLG_ADDNURBS_ORDERU_S,SPNM_SETEDITCTRL,0,
                          (LPARAM)GetDlgItem(hwnd,DLG_ADDNURBS_ORDERU));
       SetDlgItemInt(hwnd,DLG_ADDNURBS_ORDERV,orderV,FALSE);
       SendDlgItemMessage(hwnd,DLG_ADDNURBS_ORDERV,EM_LIMITTEXT,(WPARAM)6,0);
       SendDlgItemMessage(hwnd,DLG_ADDNURBS_ORDERV_S,SPNM_SETRANGE,0,
                          MAKELPARAM(3,100));
       SendDlgItemMessage(hwnd,DLG_ADDNURBS_ORDERV_S,SPNM_SETCRNTVALUE,
                          (WPARAM)orderV,0);
       SendDlgItemMessage(hwnd,DLG_ADDNURBS_ORDERV_S,SPNM_SETEDITCTRL,0,
                          (LPARAM)GetDlgItem(hwnd,DLG_ADDNURBS_ORDERV));
       SetDlgItemInt(hwnd,DLG_ADDNURBS_NUMU,numU,FALSE);
       SendDlgItemMessage(hwnd,DLG_ADDNURBS_NUMU,EM_LIMITTEXT,(WPARAM)6,0);
       SendDlgItemMessage(hwnd,DLG_ADDNURBS_NUMU_S,SPNM_SETRANGE,0,
                          MAKELPARAM(3,100));
       SendDlgItemMessage(hwnd,DLG_ADDNURBS_NUMU_S,SPNM_SETCRNTVALUE,
                          (WPARAM)numU,0);
       SendDlgItemMessage(hwnd,DLG_ADDNURBS_NUMU_S,SPNM_SETEDITCTRL,0,
                          (LPARAM)GetDlgItem(hwnd,DLG_ADDNURBS_NUMU));
       SetDlgItemInt(hwnd,DLG_ADDNURBS_NUMV,numV,FALSE);
       SendDlgItemMessage(hwnd,DLG_ADDNURBS_NUMV,EM_LIMITTEXT,(WPARAM)6,0);
       SendDlgItemMessage(hwnd,DLG_ADDNURBS_NUMV_S,SPNM_SETRANGE,0,
                          MAKELPARAM(3,100));
       SendDlgItemMessage(hwnd,DLG_ADDNURBS_NUMV_S,SPNM_SETCRNTVALUE,
                          (WPARAM)numV,0);
       SendDlgItemMessage(hwnd,DLG_ADDNURBS_NUMV_S,SPNM_SETEDITCTRL,0,
                          (LPARAM)GetDlgItem(hwnd,DLG_ADDNURBS_NUMV));
       SetWindowLong(hwnd,GWL_USERDATA,lparam);
       CentreDialogOnCursor(hwnd);
     }
     return (TRUE);
   case WM_DRAWITEM:{
       LPDRAWITEMSTRUCT lpdis;
       HBRUSH   hbr,hbrold;
       BYTE r,g,b;
       lpdis=(LPDRAWITEMSTRUCT)lparam;
       if(lpdis->CtlID == DLG_ADDNURBS_COLOUR){
         np=(nurbs *)GetWindowLong(hwnd,GWL_USERDATA);
         r=np->properties.colour[0];
         g=np->properties.colour[1];
         b=np->properties.colour[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_COMMAND:
      switch(LOWORD(wparam)){
        case DLG_ADDNURBS_COLOUR:
          np=(nurbs *)GetWindowLong(hwnd,GWL_USERDATA);
          SetSfxColour(np->properties.colour,IDX_MISC_CHOOSE_COLOUR,hwnd);
          InvalidateRect(GetDlgItem(hwnd,DLG_ADDNURBS_COLOUR),NULL,FALSE);
          break;
        case IDCANCEL:
          EndDialog(hwnd,FALSE);
          return(TRUE);
        case IDOK:
          np=(nurbs *)GetWindowLong(hwnd,GWL_USERDATA);
          orderU=GetDlgItemInt(hwnd,DLG_ADDNURBS_ORDERU,&err,FALSE);
          if(!err)EndDialog(hwnd,FALSE);
          orderV=GetDlgItemInt(hwnd,DLG_ADDNURBS_ORDERV,&err,FALSE);
          if(!err)EndDialog(hwnd,FALSE);
          numU=GetDlgItemInt(hwnd,DLG_ADDNURBS_NUMU,&err,FALSE);
          if(!err)EndDialog(hwnd,FALSE);
          numV=GetDlgItemInt(hwnd,DLG_ADDNURBS_NUMV,&err,FALSE);
          if(!err)EndDialog(hwnd,FALSE);
          if(GetDlgItemText(hwnd,DLG_ADDNURBS_NAME,
             np->properties.name,31) == 0)EndDialog(hwnd,FALSE);
          orderU=max(orderU,3);
          orderV=max(orderV,3);
          numU=max(numU,orderU);
          numV=max(numV,orderV);
          {
            BOOL bI;
            long i,j,k,knot,multiplicity;
            double weight=1.0,width=10.0,length=10.0;
            np->numU = numU;
            np->numV = numV;
            np->orderU = orderU;
            np->orderV = orderV;
            AllocNurbs(np,NULL,NULL);
            for(i = 0; i < numV; i++){
              for(j = 0; j < numU; j++){
                np->points[i][j].x = NpointerX + ((double)j/(double)(numU-1)
                                   * (double)MINUNIT)
                                   * width * weight;
                np->points[i][j].y = NpointerY + ((double)i/(double)(numV-1)
                                   * (double)MINUNIT)
                                   * length * weight;
                np->points[i][j].z = (NpointerZ)*weight;
                np->points[i][j].w = weight;
                np->points[i][j].selected = FALSE;
              }
            }
            multiplicity=1;
//            multiplicity=orderU-1;
            for(knot = 1, k = 0,i = 0; i < (numU+orderU); i++){
              if(i < orderU){
                np->kvU[i]=0.0;
                bI=FALSE;
              }
              else if(i < numU){
                np->kvU[i] = (double)knot;
                if((++k) == multiplicity){
                  k=0;
                  knot++;
                  bI=FALSE;
                }
                else bI=TRUE;
              }
              else {
                np->kvU[i] = (bI ? (double)(knot+1) : (double)knot);
              }
            }
            multiplicity=1;
//            multiplicity=orderV-1;
            for(knot = 1, k = 0,i = 0; i < (numV+orderV); i++){
              if(i < orderV){
                np->kvV[i]=0.0;
                bI=FALSE;
              }
              else if(i < numV){
                np->kvV[i] = (double)knot;
                if((++k) == multiplicity){
                  k=0;
                  knot++;
                  bI=FALSE;
                }
                else bI=TRUE;
              }
              else {
                np->kvV[i] = (bI ? (double)(knot+1) : (double)knot);
              }
            }
#if 0
            for(i = 0; i < (numU+orderU); i++){
              if(i < orderU){
                np->kvU[i]=0.0;
              }
              else if(i < numU){
                np->kvU[i] = (double)(i-orderU+1);
              }
              else {
                np->kvU[i] = (double)(numU-orderU+1);
              }
            }
            for(i = 0; i < (numV+orderV); i++){
              if(i < orderV){
                 np->kvV[i]=0.0;
              }
              else if(i < numV){
                np->kvV[i] = (double)(i-orderV+1);
              }
              else {
                np->kvV[i] = (double)(numV-orderV+1);
              }
            }
#endif
          }
          EndDialog(hwnd,TRUE);
          return(TRUE);
        default:
          break;
      }
      break;
    default: break;
 }
 return(FALSE);
}

static BOOL CALLBACK NurbsWeightsDlgProc(HWND hwnd, UINT msg,
                                         WPARAM wparam, LPARAM lparam){
 char str[32];
 double wt;
 BOOL err;
 switch( msg ) {
   case WM_PAINT:
     PaintDialogBackground(hwnd,ghinst_main);
     break;
   case WM_INITDIALOG:{
      SendDlgItemMessage(hwnd,DLG_NURBSWEIGHTS_VALUE,WM_SETTEXT,0,
                        (LPARAM)"1.0");
       CentreDialogOnCursor(hwnd);
     }
     return TRUE;
   case WM_COMMAND:
      switch(LOWORD(wparam)){
        case DLG_ADDNURBS_COLOUR:
        case IDCANCEL:
          EndDialog(hwnd,TRUE);
        case IDOK:
          if(GetDlgItemText(hwnd,DLG_NURBSWEIGHTS_VALUE,
             str,31) != 0){
          wt=atof(str);
          if(wt > 0.0){
            nurbs *np;
            long i,j;
            double xp,yp,zp,w;
            vector4 *p1;
            np=MainNp; while(np != NULL){
              if(np->selected){
                EDIT_ACTION=YES;
                for(i=0;i<np->numV;i++)
                for(j=0;j<np->numU;j++){
                  p1 = &(np->points[i][j]);
                  if(p1->selected){
                  w=1.0/p1->w;
                    xp=((p1->x)*w);
                    yp=((p1->y)*w);
                    zp=((p1->z)*w);
                    w=wt;
                    p1->w=w;
                    p1->x = xp*w;
                    p1->y = yp*w;
                    p1->z = zp*w;
                  }
                }
              }
              np=np->last;
            }
            DrawModel();
          }
        }
        break;
      }
      break;
    default: break;
 }
 return(FALSE);
}

static BOOL CALLBACK NurbsSplitDlgProc(HWND hwnd, UINT msg,
                                       WPARAM wparam, LPARAM lparam){
#define DIVX(rpt,pt ) \
    { (pt[0]) = (rpt)->x / (rpt)->w; \
      (pt[1]) = (rpt)->y / (rpt)->w; \
      (pt[2]) = (rpt)->z / (rpt)->w; }
 char str[32];
 BOOL err;
 switch( msg ) {
   case WM_PAINT:
     PaintDialogBackground(hwnd,ghinst_main);
     break;
   case WM_INITDIALOG:{
       SendDlgItemMessage(hwnd,DLG_NURBSSPLIT_U,BM_SETCHECK,1,0);
       CentreDialogOnCursor(hwnd);
     }
     return TRUE;
   case WM_COMMAND:
      switch(LOWORD(wparam)){
        case IDCANCEL:
          EndDialog(hwnd,FALSE);
          break;
        case IDOK:{
          long i,j;
          BOOL dirflag;
          nurbs *np,*next,*kid0,*kid1,*k0n,*k0l,*k1n,*k1l;
          if(SendDlgItemMessage(hwnd,DLG_NURBSSPLIT_U,BM_GETCHECK,0,0))
               dirflag=TRUE;
          else dirflag=FALSE;
          np=MainNp; while(np != NULL){
            next=np->last;
            if(np->selected){
              np->flatV = FALSE;
              np->flatU = FALSE;
              np->strU0 = FALSE;
              np->strUn = FALSE;
              np->strV0 = FALSE;
              np->strVn = FALSE;
              DIVX(&(np->points[0L][0L]),                  np->c00.point);
              DIVX(&(np->points[0L][np->numU-1L]),         np->c0n.point);
              DIVX(&(np->points[np->numV-1L][0L]),         np->cn0.point);
              DIVX(&(np->points[np->numV-1L][np->numU-1L]),np->cnn.point);
              GetNormal(np, 0L, 0L );
              GetNormal(np, 0L, (np->numU)-1);
              GetNormal(np, (np->numV)-1, 0L );
              GetNormal(np, (np->numV)-1, (np->numU)-1 );
              CreateNurbs(); kid0=MainNp;
              CreateNurbs(); kid1=MainNp;
              k0n=kid0->next; k0l=kid0->last;
              k1n=kid1->next; k1l=kid1->last;
              SplitSurface(np,kid0,kid1,dirflag);
              kid0->next=k0n; kid0->last=k0l;
              kid1->next=k1n; kid1->last=k1l;
              kid0->selected=FALSE;
              kid1->selected=FALSE;
              for(i=0;i<kid0->numV;i++)
              for(j=0;j<kid0->numU;j++)kid0->points[i][j].selected=FALSE;
              for(i=0;i<kid1->numV;i++)
              for(j=0;j<kid1->numU;j++)kid1->points[i][j].selected=FALSE;
              EraseNurbs(np);
            }
            np=next;
          }
          EndDialog(hwnd,TRUE);
        }
        break;
      }
      break;
    default: break;
 }
 return(FALSE);
#undef DIVX
}

static long SplitKVat(double * srckv,
                      double ** destkv,
                      double kv,       // new knot value
                      long n, long k){ // n = numU/V  k = orderU/V
 double minK,maxK;
 long i,sp,extra=1;
 minK=srckv[0];
 maxK=srckv[n+k-1];
 kv=minK+kv*(maxK-minK);
 for(i=0;i<n+k;i++){
   if(srckv[i] <= kv)sp=i;
   if(srckv[i] == kv)extra=0;  // don't add control points if knot exists
 }
 if((*destkv = (double *)X__Malloc((long)(sizeof(double)
               * (n+k+extra)))) == NULL)return 0;
 for(i=0;i<=sp;i++)(*destkv)[i]=srckv[i];
 if(extra == 1)(*destkv)[sp+1]=kv;
 for(i=sp+1;i<n+k;i++)(*destkv)[i+extra]=srckv[i];
 return extra;
}

static BOOL CALLBACK NurbsIknotDlgProc(HWND hwnd, UINT msg,
                                       WPARAM wparam, LPARAM lparam){
 BOOL err;
 char str[32];
 double kv=0.5;
 switch( msg ) {
   case WM_PAINT:
     PaintDialogBackground(hwnd,ghinst_main);
     break;
   case WM_INITDIALOG:{
       SendDlgItemMessage(hwnd,DLG_NURBSIKNOT_U,BM_SETCHECK,1,0);
       SendDlgItemMessage(hwnd,DLG_NURBSIKNOT_CORNER,BM_SETCHECK,0,0);
       sprintf(str,"%lf",kv);
       SendDlgItemMessage(hwnd,DLG_NURBSIKNOT_VALUE,WM_SETTEXT,0,(LPARAM)str);
       CentreDialogOnCursor(hwnd);
     }
     return TRUE;
   case WM_COMMAND:
      switch(LOWORD(wparam)){
        case IDCANCEL:
          EndDialog(hwnd,FALSE);
          break;
        case IDOK:{
          BOOL dirflag,corner;
          nurbs *np,*next,*n,*p;
          double *newkv;
          long i,j,splitPt,e;
          if(SendDlgItemMessage(hwnd,DLG_NURBSIKNOT_U,BM_GETCHECK,0,0))
               dirflag=TRUE;
          else dirflag=FALSE;
          if(SendDlgItemMessage(hwnd,DLG_NURBSIKNOT_CORNER,BM_GETCHECK,0,0))
               corner=TRUE;
          else corner=FALSE;
          if(GetDlgItemText(hwnd,DLG_NURBSIKNOT_VALUE,str,31) != 0){
            kv=atof(str); kv=max(0.0,kv); kv=min(1.0,kv);
          }
          np=MainNp; while(np != NULL){
            next=np->last;
            if(np->selected){
              CreateNurbs(); n=MainNp->next; p=MainNp->last;
              *MainNp = *np; MainNp->next=n; MainNp->last=p;
              if(dirflag){
                MainNp->numU = np->numU + (e = (corner ?
                  SplitKV(np->kvU,&newkv,&splitPt,(np->numU)-1,np->orderU) :
                  SplitKVat(np->kvU,&newkv,kv,np->numU,np->orderU)));
                AllocNurbs(MainNp,newkv,NULL);
                for(i=0L;i<MainNp->numV+MainNp->orderV;i++)
                  MainNp->kvV[i] = np->kvV[i];
              }
              else{
                MainNp->numV = np->numV + (e = (corner ?
                  SplitKV(np->kvV,&newkv,&splitPt,(np->numV)-1,np->orderV) :
                  SplitKVat(np->kvV,&newkv,kv,np->numV,np->orderV)));
                AllocNurbs(MainNp,NULL,newkv);
                for(i=0L;i<MainNp->numU+MainNp->orderU;i++)
                  MainNp->kvU[i] = np->kvU[i];
              }
              if(e == 0){
                MessageBox(hwnd,"Knot already exists",NULL,MB_OK);
              }
              RefineSurface(np,MainNp,dirflag);
              for(i=0;i<MainNp->numV;i++)
              for(j=0;j<MainNp->numU;j++)MainNp->points[i][j].selected=FALSE;
              EraseNurbs(np);
            }
            np=next;
          }
          EndDialog(hwnd,TRUE);
        }
        break;
      }
      break;
    default: break;
 }
 return(FALSE);
}