NURBS0.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 NURBS0.C */

void IncludeNurbsBoundary(short *flag,
                          long *xmin, long *xmax,
                          long *ymin, long *ymax,
                          long *zmin, long *zmax){
 nurbs *np;
 long i,j,x,y,z;
 double w;
 vector4 *p1;
 if(Nnurbs == 0 || MainNp == NULL)return;
 *flag = 1;
 np=MainNp; while(np != NULL){
   for(i=0;i<np->numV;i++)
   for(j=0;j<np->numU;j++){
     p1 = &(np->points[i][j]);
     w=1.0/p1->w;
     x=(long)((p1->x)*w);
     y=(long)((p1->y)*w);
     z=(long)((p1->z)*w);
     if(x < *xmin)*xmin=x; if(y < *ymin)*ymin=y; if(z < *zmin)*zmin=z;
     if(x > *xmax)*xmax=x; if(y > *ymax)*ymax=y; if(z > *zmax)*zmax=z;
   }
   np=np->last;
 }
 return;
}

static void DrawNurbsEdge(HDC hdc, int view,
                          NurbsSurfSample *p1, NurbsSurfSample *p2){
 int sh1,sv1,sh2,sv2;
 vertex v,*vp;
 vp = &v;
 vp->status=SELECTED;
 vp->xyz[0]=(long)(p1->point[0]);
 vp->xyz[1]=(long)(p1->point[1]);
 vp->xyz[2]=(long)(p1->point[2]);
 if(intriview(vp)){
   GetWindowCoords(view,vp->xyz[0],vp->xyz[1],vp->xyz[2],&sh1,&sv1);
   vp->xyz[0]=(long)(p2->point[0]);
   vp->xyz[1]=(long)(p2->point[1]);
   vp->xyz[2]=(long)(p2->point[2]);
   if(intriview(vp)){
     GetWindowCoords(view,vp->xyz[0],vp->xyz[1],vp->xyz[2],&sh2,&sv2);
     MoveToEx(hdc,sh1,sv1,NULL); LineTo(hdc,sh2,sv2);
   }
 }
 return;
}

static BOOL DrawNurbsOutline(HDC hdc, int view, nurbs *n, BOOL abort){
 BOOL bAbort=FALSE;
 register long i,j;
 NurbsSurfSample **pts;
 long GranularityU,GranularityV;
 GranularityU=n->properties.GranularityMax;
 GranularityV=n->properties.GranularityMin;
 if((pts=CreateSurfaceNet(n,GranularityU,GranularityV)) == NULL)return FALSE;
 for(i = 0; i < GranularityV+1; i++)
 for(j = 0; j < GranularityU; j++){
   DrawNurbsEdge(hdc,view,&pts[i][j],&pts[i][j+1]);
   if(abort && HIWORD(GetQueueStatus(QS_MOUSEMOVE)) == QS_MOUSEMOVE){
     bAbort=TRUE;
     goto ABORT1;
   }
 }
 ABORT1:
 X__Free(pts[0]);
 X__Free(pts);
 if(bAbort)return TRUE;
 GranularityU=n->properties.GranularityMin;
 GranularityV=n->properties.GranularityMax;
 if((pts=CreateSurfaceNet(n,GranularityU,GranularityV)) == NULL)return FALSE;
 for(j = 0; j < GranularityU+1; j++)
 for(i = 0; i < GranularityV; i++){
   DrawNurbsEdge(hdc,view,&pts[i][j],&pts[i+1][j]);
   if(abort && HIWORD(GetQueueStatus(QS_MOUSEMOVE)) == QS_MOUSEMOVE){
     bAbort=TRUE;
     goto ABORT2;
   }
 }
 ABORT2:
 X__Free(pts[0]);
 X__Free(pts);
 if(bAbort)return TRUE;
 return FALSE;
}

static void DrawNurbsControlPoints(nurbs *np, HDC hdc, int view, BOOL status){
 HPEN hOldPen;
 int hOldMode;
 int sh1,sv1;
 double w;
 vertex v,*vp;
 long i,j,x,y,z;
 vector4 *p1;
 vp=&v;
 vp->status=SELECTED;
 hOldMode=SetBkMode(hdc,TRANSPARENT);
 if(status)hOldPen=SelectObject(hdc,ghDotSelectedPen);
 for(i=0;i<np->numV;i++)
 for(j=0;j<np->numU-1;j++){
   p1 = &(np->points[i][j]);
   w=1.0/p1->w;
   v.xyz[0]=(long)((p1->x)*w);
   v.xyz[1]=(long)((p1->y)*w);
   v.xyz[2]=(long)((p1->z)*w);
   if(intriview(vp)){
     GetWindowCoords(view,vp->xyz[0],vp->xyz[1],vp->xyz[2],&sh1,&sv1);
     MoveToEx(hdc,sh1,sv1,NULL);
     p1 = &(np->points[i][j+1]);
     w=1.0/p1->w;
     v.xyz[0]=(long)((p1->x)*w);
     v.xyz[1]=(long)((p1->y)*w);
     v.xyz[2]=(long)((p1->z)*w);
     GetWindowCoords(view,vp->xyz[0],vp->xyz[1],vp->xyz[2],&sh1,&sv1);
     LineTo(hdc,sh1,sv1);
   }
 }
 for(j=0;j<np->numU;j++)
 for(i=0;i<np->numV-1;i++){
   p1 = &(np->points[i][j]);
   w=1.0/p1->w;
   v.xyz[0]=(long)((p1->x)*w);
   v.xyz[1]=(long)((p1->y)*w);
   v.xyz[2]=(long)((p1->z)*w);
   if(intriview(vp)){
     GetWindowCoords(view,vp->xyz[0],vp->xyz[1],vp->xyz[2],&sh1,&sv1);
     MoveToEx(hdc,sh1,sv1,NULL);
     p1 = &(np->points[i+1][j]);
     w=1.0/p1->w;
     v.xyz[0]=(long)((p1->x)*w);
     v.xyz[1]=(long)((p1->y)*w);
     v.xyz[2]=(long)((p1->z)*w);
     GetWindowCoords(view,vp->xyz[0],vp->xyz[1],vp->xyz[2],&sh1,&sv1);
     LineTo(hdc,sh1,sv1);
   }
 }
 if(status)SelectObject(hdc,ghEdgePen);
 SetBkMode(hdc,hOldMode);

 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;
     v.xyz[0]=(long)((p1->x)*w);
     v.xyz[1]=(long)((p1->y)*w);
     v.xyz[2]=(long)((p1->z)*w);
     if(intriview(vp)){
       GetWindowCoords(view,vp->xyz[0],vp->xyz[1],vp->xyz[2],&sh1,&sv1);
       Rectangle(hdc,sh1-1,sv1-1,sh1+2,sv1+2);
     }
   }
 }
 if(status)SelectObject(hdc,ghSelectedPen);
 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;
     v.xyz[0]=(long)((p1->x)*w);
     v.xyz[1]=(long)((p1->y)*w);
     v.xyz[2]=(long)((p1->z)*w);
     if(intriview(vp)){
       GetWindowCoords(view,vp->xyz[0],vp->xyz[1],vp->xyz[2],&sh1,&sv1);
       if(status && p1->selected)hOldPen=SelectObject(hdc,ghSelectedPen);
       Rectangle(hdc,sh1-1,sv1-1,sh1+2,sv1+2);
       if(status && p1->selected)SelectObject(hdc,hOldPen);
     }
   }
 }
 if(status)SelectObject(hdc,hOldPen);
 return;
}

void DrawAllNurbsInOne(HDC hdc, int view, BOOL abort){
 BOOL bAbort=FALSE;
 HPEN hOldPen;
 nurbs *np;
 if(Nnurbs == 0 || MainNp == NULL)return;
 np=MainNp; while(np != NULL){
   if(!np->selected && !np->properties.hidden){
     bAbort=DrawNurbsOutline(hdc,view,np,abort);
     if(bAbort)goto ABORT;
   }
   np=np->last;
 }
 np=MainNp; while(np != NULL){
   if(np->selected && !np->properties.hidden){
     hOldPen=SelectObject(hdc,ghSelectedPen);
     bAbort=DrawNurbsOutline(hdc,view,np,abort);
     SelectObject(hdc,hOldPen);
     if(bAbort)goto ABORT;
     DrawNurbsControlPoints(np,hdc,view,TRUE);
   }
   np=np->last;
 }
 ABORT:
 return;
}

static void DrawInvertNurbsInOne(nurbs *np, int view, BOOL update){
 HDC hdc;
 HPEN hOldPen;
 DWORD oldROP2;
 if(np->properties.hidden)return;
 if((hdc=ghdc_triview_Bitmap[view]) == NULL)return;
 hOldPen=SelectObject(hdc,ghInvertPen);
 oldROP2=SetROP2(hdc,R2_XORPEN);
 DrawNurbsControlPoints(np,hdc,view,FALSE);
 DrawNurbsOutline(hdc,view,np,FALSE);
 SelectObject(hdc,hOldPen);
 SetROP2(hdc,oldROP2);
 if(update){
   InvalidateRect(ghwnd_triview[view],NULL,FALSE);
   UpdateWindow(ghwnd_triview[view]);
 }
 return;
}

void DrawNurbsWireFrame(HDC hdc, int skelview,
                        double scale, double trr[4][4],
                        short (*in_modeller_view1)(vertex *, vertex *),
                        short (*in_modeller_view2)(vertex *, vertex *),
                        BOOL abort){
 BOOL bAbort=FALSE;
 double x1,y1,z1,x2,y2,z2;
 int ix1,ix2,iy1,iy2,flag,
     pwinl,pwinr,pwint,pwinb,pwincx,pwincy;
 short (*in_modeller_view)(vertex *vp1, vertex *vp2);
 RECT rc;
 int sh1,sv1;
 nurbs *n;
 long i,j;
 vertex V1,V2,*v1,*v2;
 if(Nnurbs == 0 || MainNp == NULL)return;
 if(!draw_joins)in_modeller_view = in_modeller_view2; /* scroll lock   */
 else           in_modeller_view = in_modeller_view1; /* test function */
 GetClientRect(ghwnd_view,&rc);
 pwinl=pwint=0; pwinr=rc.right; pwinb=rc.bottom;
 pwincx=rc.right/2; pwincy=rc.bottom/2;
 v1 = &V1; v2 = &V2;
 v1->status=SELECTED;
 v2->status=SELECTED;
 n=MainNp; while(n != NULL){
   if(!n->properties.hidden){
     NurbsSurfSample **pts;
     long GranularityU,GranularityV;
     GranularityU=n->properties.GranularityMax;
     GranularityV=n->properties.GranularityMin;
     if((pts=CreateSurfaceNet(n,GranularityU,GranularityV)) == NULL)return;
     for(i = 0; i < GranularityV+1; i++)
     for(j = 0; j < GranularityU; j++){
       v1->xyz[0]=(long)(pts[i][j].point[0]);
       v1->xyz[1]=(long)(pts[i][j].point[1]);
       v1->xyz[2]=(long)(pts[i][j].point[2]);
       v2->xyz[0]=(long)(pts[i][j+1].point[0]);
       v2->xyz[1]=(long)(pts[i][j+1].point[1]);
       v2->xyz[2]=(long)(pts[i][j+1].point[2]);
       if(in_modeller_view(v1,v2)){
         flag=0;
         m4by1(trr,(double)v1->xyz[0],(double)v1->xyz[1],(double)v1->xyz[2]
                  ,&x1,&y1,&z1);
         m4by1(trr,(double)v2->xyz[0],(double)v2->xyz[1],(double)v2->xyz[2]
                  ,&x2,&y2,&z2);
         if(y1 >= 0.0){
           ix1=(int)(pwincx+scale*x1);
           iy1=(int)(pwincy-scale*z1);
         }
         else  flag=1;
         if(y2 >= 0.0){
           ix2=(int)(pwincx+scale*x2);
           iy2=(int)(pwincy-scale*z2);
         }
         else flag=1;
         if(flag == 0){// && (!Preferences.quick_trick || abs(ix1-ix2) > 2 || abs(iy1-iy2) > 2) ){
           MoveToEx(hdc,ix1,iy1,NULL);
           LineTo(hdc,ix2,iy2);
         }
       }
       if(abort && HIWORD(GetQueueStatus(QS_MOUSEMOVE)) == QS_MOUSEMOVE){
         bAbort=TRUE;
         goto ABORT1;
       }
     }
     ABORT1:
     X__Free(pts[0]);
     X__Free(pts);
     if(bAbort)return;
     GranularityU=n->properties.GranularityMin;
     GranularityV=n->properties.GranularityMax;
     if((pts=CreateSurfaceNet(n,GranularityU,GranularityV)) == NULL)return;
     for(j = 0; j < GranularityU+1; j++)
     for(i = 0; i < GranularityV; i++){
       v1->xyz[0]=(long)(pts[i][j].point[0]);
       v1->xyz[1]=(long)(pts[i][j].point[1]);
       v1->xyz[2]=(long)(pts[i][j].point[2]);
       v2->xyz[0]=(long)(pts[i+1][j].point[0]);
       v2->xyz[1]=(long)(pts[i+1][j].point[1]);
       v2->xyz[2]=(long)(pts[i+1][j].point[2]);
       if(in_modeller_view(v1,v2)){
         flag=0;
         m4by1(trr,(double)v1->xyz[0],(double)v1->xyz[1],(double)v1->xyz[2]
                  ,&x1,&y1,&z1);
         m4by1(trr,(double)v2->xyz[0],(double)v2->xyz[1],(double)v2->xyz[2]
                  ,&x2,&y2,&z2);
         if(y1 >= 0.0){
           ix1=(int)(pwincx+scale*x1);
           iy1=(int)(pwincy-scale*z1);
         }
         else  flag=1;
         if(y2 >= 0.0){
           ix2=(int)(pwincx+scale*x2);
           iy2=(int)(pwincy-scale*z2);
         }
         else flag=1;
         if(flag == 0){// && (!Preferences.quick_trick || abs(ix1-ix2) > 2 || abs(iy1-iy2) > 2) ){
           MoveToEx(hdc,ix1,iy1,NULL);
           LineTo(hdc,ix2,iy2);
         }
       }
       if(abort && HIWORD(GetQueueStatus(QS_MOUSEMOVE)) == QS_MOUSEMOVE){
         bAbort=TRUE;
         goto ABORT2;
       }
     }
     ABORT2:
     X__Free(pts[0]);
     X__Free(pts);
     if(bAbort)return;
   }
   n=n->last;
 }
 return;
}

static BOOL CALLBACK TriangulateNurbsDlgProc(HWND hwnd, UINT msg,
                                    WPARAM wparam, LPARAM lparam){
 struct GRAN {int u,v;} *gran;
 BOOL err;
 int i;
 switch( msg ) {
   case WM_PAINT:
     PaintDialogBackground(hwnd,ghinst_main);
     break;
   case WM_INITDIALOG:{
       gran=(struct GRAN *)lparam;
       SetDlgItemInt(hwnd,DLG_MESHNURBS_U,gran->u,FALSE);
       SendDlgItemMessage(hwnd,DLG_MESHNURBS_U,EM_LIMITTEXT,(WPARAM)6,0);
       SendDlgItemMessage(hwnd,DLG_MESHNURBS_U_S,SPNM_SETRANGE,0,
                          MAKELPARAM(3,100));
       SendDlgItemMessage(hwnd,DLG_MESHNURBS_U_S,SPNM_SETCRNTVALUE,
                          (WPARAM)gran->u,0);
       SendDlgItemMessage(hwnd,DLG_MESHNURBS_U_S,SPNM_SETEDITCTRL,0,
                          (LPARAM)GetDlgItem(hwnd,DLG_MESHNURBS_U));
       SetDlgItemInt(hwnd,DLG_MESHNURBS_V,gran->v,FALSE);
       SendDlgItemMessage(hwnd,DLG_MESHNURBS_V,EM_LIMITTEXT,(WPARAM)6,0);
       SendDlgItemMessage(hwnd,DLG_MESHNURBS_V_S,SPNM_SETRANGE,0,
                          MAKELPARAM(3,100));
       SendDlgItemMessage(hwnd,DLG_MESHNURBS_V_S,SPNM_SETCRNTVALUE,
                          (WPARAM)gran->v,0);
       SendDlgItemMessage(hwnd,DLG_MESHNURBS_V_S,SPNM_SETEDITCTRL,0,
                          (LPARAM)GetDlgItem(hwnd,DLG_MESHNURBS_V));
       SetWindowLong(hwnd,GWL_USERDATA,lparam);
       CentreDialogOnCursor(hwnd);
     }
     return (TRUE);
   case WM_COMMAND:
      switch(LOWORD(wparam)){
        case IDCANCEL:
          EndDialog(hwnd,FALSE);
          return(TRUE);
        case IDOK:
          gran=(struct GRAN *)GetWindowLong(hwnd,GWL_USERDATA);
          gran->u=GetDlgItemInt(hwnd,DLG_MESHNURBS_U,&err,FALSE);
          if(!err)EndDialog(hwnd,FALSE);
          gran->v=GetDlgItemInt(hwnd,DLG_MESHNURBS_V,&err,FALSE);
          EndDialog(hwnd,TRUE);
          return(TRUE);
        default:
          break;
      }
      break;
    default: break;
 }
 return(FALSE);
}

void TriangulateNurbsSurface(void){
 struct GRAN {int u,v;} gran;
 nurbs *n;
 register long i,j;
 NurbsSurfSample **pts;
 long GranularityU,GranularityV;
 long x,y,z,Vf;
 vertex *Vp;
 if(Nnurbs == 0 || MainNp == NULL)return;
 GranularityU=20;
 GranularityV=20;
 gran.u=GranularityU;
 gran.v=GranularityV;
 if(!DialogBoxParam(ghinst_main,MAKEINTRESOURCE(DLG_MESHNURBS),ghwnd_main,
                     (DLGPROC)TriangulateNurbsDlgProc,(LPARAM)(&gran)))return;
 GranularityU=gran.u;
 GranularityV=gran.v;
 n=MainNp; while(n != NULL){
   if(n->selected && !n->properties.hidden){
     if((pts=CreateSurfaceNet(n,GranularityU,GranularityV)) == NULL)return;
     Vf=Nvert;
     if(UpdateVertexHeap(Nvert+(GranularityU+1)*(GranularityV+1))){
       for(i = 0; i <= GranularityV; i++)
       for(j = 0; j <= GranularityU; j++){
          CreateVertex();
          Vp=(MainVp+Nvert-1);
          Vp->xyz[0]=(long)pts[i][j].point[0];
          Vp->xyz[1]=(long)pts[i][j].point[1];
          Vp->xyz[2]=(long)pts[i][j].point[2];
          Vp->gp=1; 
          Vp->x=pts[i][j].u;
          Vp->y=pts[i][j].v;
       }
       if(UpdateEdgeHeap(Nedge+(GranularityU)*(GranularityV+1) // U edges
                              +(GranularityV)*(GranularityU+1) // V edges
                              +(GranularityU)*(GranularityV))){// Cross edges
         if(UpdateFaceHeap(Nface+(GranularityU*GranularityV*2))){
           for(i = 0; i < GranularityV; i++)
           for(j = 0; j < GranularityU; j++){
             CreateEdge(Vf+i*(GranularityU+1)+j,Vf+i*(GranularityU+1)+j+1);
             CreateEdge(Vf+i*(GranularityU+1)+j,Vf+(i+1)*(GranularityU+1)+j);
             CreateEdge(Vf+i*(GranularityU+1)+j,Vf+(i+1)*(GranularityU+1)+j+1);
             CreateFace(Vf+i*(GranularityU+1)+j,
                        Vf+(i+1)*(GranularityU+1)+j,
                        Vf+(i+1)*(GranularityU+1)+j+1);
             VECCOPY(n->properties.colour,(MainFp+Nface-1)->color)
             (MainFp+Nface-1)->bSmooth=TRUE; // smoothing
             CreateFace(Vf+i*(GranularityU+1)+j,
                        Vf+(i+1)*(GranularityU+1)+j+1,
                        Vf+i*(GranularityU+1)+j+1);
             VECCOPY(n->properties.colour,(MainFp+Nface-1)->color)
             (MainFp+Nface-1)->bSmooth=TRUE; // smoothing
           }
           j=GranularityU;
           for(i = 0; i < GranularityV; i++){ // Last row in V
             CreateEdge(Vf+i*(GranularityU+1)+j,Vf+(i+1)*(GranularityU+1)+j);
           }
           for(j = 0; j < GranularityU; j++){ // Last row in U
             CreateEdge(Vf+(GranularityU+1)*GranularityV+j,
                        Vf+(GranularityU+1)*GranularityV+j+1);
           }
         }
       }
     }
     X__Free(pts[0]);
     X__Free(pts);
   }
   n=n->last;
 }
 DrawModel();
 return;
}

void EraseAllNurbs(void){
 nurbs *temps;
 while(MainNp != NULL){
  temps=MainNp->last;
  ReleaseNurbs(MainNp);
  X__Free(MainNp);
  MainNp=temps;
 }
 Nnurbs=0;
}

void EraseNurbs(nurbs *sp){
 ReleaseNurbs(sp);
 if(sp == MainNp){
   MainNp=sp->last;
   if(MainNp != NULL)MainNp->next=NULL;
   X__Free(sp);
   sp=MainNp;
 }
 else{
   (sp->next)->last=sp->last;
   if(sp->last != NULL)(sp->last)->next=sp->next;
   X__Free(sp);
 }
 Nnurbs--;
 return;
}

void CreateNurbs(void){
 nurbs *temp;
 int i,j;
 if((temp=(nurbs *)X__Malloc(sizeof(nurbs))) == NULL)longjmp(j_buf,0);
 memset(temp,0,sizeof(nurbs));
 if(MainNp != NULL)MainNp->next=temp;
 temp->last=MainNp;
 MainNp=temp;
 Nnurbs++;
 temp->sp=NULL;
 temp->numU=0;
 temp->numV=0;
 temp->orderU=0;
 temp->orderV=0;
 temp->selected=FALSE;
 temp->kvU=NULL;
 temp->kvV=NULL;
 temp->points=NULL;
 sprintf(temp->properties.name,"Patch %ld",Nnurbs-1);
 temp->properties.GranularityMax=30;
 temp->properties.GranularityMin=4;
 temp->properties.colour[0]=255;
 temp->properties.colour[1]=255;
 temp->properties.colour[2]=255;
 temp->properties.hidden=0;
}

void ClearNurbsSkeleton(skel *sp){
 nurbs *np;
 if(Nnurbs == 0 || MainNp == NULL)return;
 np=MainNp; while(np != NULL){
   if(np->sp == sp)np->sp=NULL;
   np=np->last;
 }
 return;
}

BOOL DeleteSelectedNurbsSurfaces(void){
 BOOL bUpdate=FALSE;
 nurbs *np,*nptemp;
 if(Nnurbs == 0 || MainNp == NULL)return bUpdate;
 np=MainNp; while(np != NULL){
   if(np->selected){
     nptemp=np->last;
     bUpdate=TRUE;
     EraseNurbs(np);
     np=nptemp;
   }
   else np=np->last;
 }
 return bUpdate;
}

void ReleaseNurbs(nurbs *n){
 long i;
 if(n->kvU != NULL)X__Free(n->kvU);
 n->kvU = NULL;
 if(n->kvV != NULL)X__Free(n->kvV);
 n->kvV = NULL;
 if(n->points == NULL)return;
 for(i=0;i < n->numV;i++)X__Free(n->points[i]);
 X__Free(n->points);
 n->points=NULL;
 return;
}

BOOL AllocNurbs(nurbs *n, double *ukv, double *vkv){
 long i;
 if(ukv == NULL){
 if((n->kvU = (double *)X__Malloc((n->numU + n->orderU) * sizeof(double)))
   == NULL)return FALSE;
 }
 else n->kvU = ukv;
 if(vkv == NULL){
 if((n->kvV = (double *)X__Malloc((n->numV + n->orderV) * sizeof(double)))
   == NULL)return FALSE;
 }
 else n->kvV = vkv;
 if((n->points = (vector4 **)X__Malloc((long)n->numV
       * (long)sizeof(vector4 *))) == NULL)return FALSE;
 for (i = 0; i < n->numV; i++){
   if((n->points[i] = (vector4 *)X__Malloc((long)n->numU
       * (long)sizeof(vector4))) == NULL)return FALSE;
 }
 return TRUE;
}

BOOL CloneNurbs(nurbs *src, nurbs *dst){
 long i, j;
 double *srcp, *dstp;
 nurbs *last,*next;
 last = dst->last;
 next = dst->next;
 *dst = *src;        /* Copy fields that don't change */
 dst->last=last;
 dst->next=next;
 // memcpy(dst,src,sizeof(nurbs));
 dst->kvU = NULL;
 dst->kvV = NULL;    /* So they get allocated */
 dst->points = NULL;
 if(AllocNurbs(dst,NULL,NULL) == FALSE)return FALSE;
 /* Copy kv's */
 srcp = src->kvU;
 dstp = dst->kvU;
 for(i = 0; i < src->numU + src->orderU; i++)*dstp++ = *srcp++;
 srcp = src->kvV;
 dstp = dst->kvV;
 for(i = 0; i < src->numV + src->orderV; i++)*dstp++ = *srcp++;
 /* Copy control points */
 for(i = 0; i < src->numV; i++)
 for(j = 0; j < src->numU; j++){
   dst->points[i][j] = src->points[i][j];
 }
//{char str[256];
//sprintf(str,"Dest U %ld V %ld  Orders %ld %ld",dst->numU,dst->numV,
//dst->orderU,dst->orderV);
//MessageBox(NULL,str,"Copy Allocated",MB_OK);
//}
 return TRUE;
}

static NurbsSurfSample **CreateSurfaceNet(nurbs *n,
                                          long GranularityU,
                                          long GranularityV){
 register long i,j;
 register double u,v;
 NurbsSurfSample **pts;
 if((pts=(NurbsSurfSample**)X__Malloc((GranularityV+1L)*sizeof(NurbsSurfSample*)))
   == NULL)return NULL;
 if((pts[0]=(NurbsSurfSample*)X__Malloc((GranularityV+1L)*(GranularityU+1L)
        * sizeof(NurbsSurfSample))) == NULL)return NULL;
 for(i = 1; i <= GranularityV; i++)
   pts[i] = &(pts[0][(GranularityU+1L) * i]);
 for (i = 0; i <= GranularityV; i++){
   v = ((double) i / (double) GranularityV)
     * (n->kvV[n->numV] - n->kvV[n->orderV-1])
     + n->kvV[n->orderV-1];
   for (j = 0; j <= GranularityU; j++){
     u = ((double) j / (double) GranularityU)
       * (n->kvU[n->numU] - n->kvU[n->orderU-1])
       + n->kvU[n->orderU-1];
     CalcPoint(u,v,n,pts[i][j].point,NULL,NULL);
     pts[i][j].u = u;
     pts[i][j].v = v;
   }
 }
 return pts;
}