NURBS.C

Go to the documentation of this file.

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


/* File NURBS.C the nurbs objects */

#define MODULE_NURBS 1

#include "design.h"
#include "..\animate\spin_dll.h"

#define MAXORDER 20

/* Size of facets produced in adaptive subdivision */
//static double SubdivTolerance=(double)MINUNIT/10;
static double SubdivTolerance=(double)MINUNIT/2;

static long FindBreakPoint( double, double *, long, long);
static void BasisDerivatives( double, long, double *, long, double *);
static void BasisFunctions( double, long, double *, long, double *);
static void CalcPoint(double, double, nurbs *, vector, vector, vector);
static NurbsSurfSample **CreateSurfaceNet(nurbs *, long, long);
static BOOL DrawNurbsOutline(HDC, int, nurbs *, BOOL);
static void DrawNurbsEdge(HDC, int, NurbsSurfSample *, NurbsSurfSample *);
static void DrawNurbsControlPoints(nurbs *, HDC, int, BOOL);
static void DrawInvertNurbsInOne(nurbs *, int, BOOL);
static void RotateNurbsPoint(double, double, long, long, double *,
                             double *, double, double);
static void NurbsTorus(nurbs *, double, double);
static void NurbsBezier(nurbs *, double, double);
static void NurbsTeapot(void);
static BOOL CalcAlpha(double *, double *, long, long, long, double ***);
static void RefineSurface(nurbs *, nurbs *, BOOL);
static long SplitKV(double *, double **, long *, long, long);
static void ProjectToLine(vector, vector, vector);
static void FixNormals(NurbsSurfSample *, NurbsSurfSample *, NurbsSurfSample *);
static void AdjustNormal(NurbsSurfSample *);
static void GetNormal(nurbs *, long, long);
static void MakeNewCorners(nurbs *, nurbs *, nurbs *, BOOL);
static void SplitSurface(nurbs *, nurbs *, nurbs *, BOOL);
static BOOL IsCurveStraight(nurbs *, double, long, BOOL);
static BOOL TestFlat(nurbs *, double);
static void EmitTriangles(nurbs *);
static void DoSubdivision(nurbs *, double, BOOL, long);
static void NurbsEliminateDuplicateVertices(void);
static void NurbsInsertDividingEdges(void);
static void NurbsEliminateDuplicateEdges(void);
static void EmitSubdivision(nurbs *);
static BOOL CheckHitNurbsOutline(int, int, int, NurbsSurfSample *, NurbsSurfSample *);
static BOOL CheckNurbsIn(int, int,
                         long, long, long, long, int, int, double, HRGN,
                         NurbsSurfSample *,NurbsSurfSample *);
static BOOL SameVertexLocation(vertex *, vertex *);
static BOOL VertexOnEdge(vertex *, edge *);

#include "nurbsdlg.c"

void MakeNewNurbsSurface(int type){
 if(type == 0){ // basic type
   CreateNurbs();
   if(!DialogBoxParam(ghinst_main,MAKEINTRESOURCE(DLG_ADDNURBS),ghwnd_main,
                     (DLGPROC)AddNurbsDlgProc,(LPARAM)MainNp)){
     EraseNurbs(MainNp);
   }
 }
 else if(type == 1){
   CreateNurbs();
   sprintf(MainNp->properties.name,"Bezier_%ld",Nnurbs);
   NurbsBezier(MainNp,10.0,10.0);
 }
 else if(type == 2){
   CreateNurbs();
   sprintf(MainNp->properties.name,"Torus_%ld",Nnurbs);
   NurbsTorus(MainNp,5.0,1.0);
 }
 else if(type == 3){
   NurbsTeapot();
 }
 EDIT_ACTION=YES;
 DrawModel();
 return;
}

void EditSelectedNurbsSurface(void){
 if(Nnurbs == 0 || MainNp == NULL)return;
 if(DialogBox(ghinst_main,MAKEINTRESOURCE(DLG_NURBSIKNOT),ghwnd_main,
                     (DLGPROC)NurbsIknotDlgProc)){
   EDIT_ACTION=YES;
   DrawModel();
 }
 return;
}

void SetSelectedNurbsWeights(void){
 if(Nnurbs == 0 || MainNp == NULL)return;
 DialogBox(ghinst_main,MAKEINTRESOURCE(DLG_NURBSWEIGHTS),ghwnd_main,
                     (DLGPROC)NurbsWeightsDlgProc);
 return;
}

static void NurbsTorus(nurbs *torus, double majorRadius, double minorRadius){
 /* These define the shape of a unit torus centered about the origin. */
 double xvalues[] = { 0.0, -1.0, -1.0, -1.0, 0.0, 1.0, 1.0, 1.0, 0.0 };
 double yvalues[] = { 1.0, 1.0, 0.0, -1.0, -1.0, -1.0, 0.0, 1.0, 1.0 };
 double zvalues[] = { 0.0, 1.0, 1.0, 1.0, 0.0, -1.0, -1.0, -1.0, 0.0 };
 double offsets[] = { -1.0, -1.0, 0.0, 1.0, 1.0, 1.0, 0.0, -1.0, -1.0 };
 /* Piecewise Bezier knot vector for a quadratic curve with four segments */
 long knots[] = { 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 4 };
// long knots[] = { 0, 0, 0, 1, 2, 3, 4, 5, 6, 7, 7, 7 }; // odd
 long i,j;
 double r2over2 = sqrt( 2.0 ) / 2.0;
 double weight;
 /* Set up the dimension and orders of the surface */
 torus->numU = 9;       /* A circle is formed from nine points */
 torus->numV = 9;
 torus->orderU = 3;       /* Quadratic in both directions */
 torus->orderV = 3;
 /* After the dimension and orders are set, AllocNurbs creates the dynamic
  * storage for the control points and the knot vectors */
 AllocNurbs(torus,NULL,NULL);
 for(i = 0; i < 9; i++){
   for(j = 0; j < 9; j++){
     weight = ((j & 1) ? r2over2 : 1.0) * ((i & 1) ? r2over2 : 1.0);
     /* Notice how the weights are pre-multiplied with the x, y and z values */
     torus->points[i][j].x = (NpointerX + xvalues[j] * (double)MINUNIT
                * (majorRadius + offsets[i] * minorRadius)) * weight;
     torus->points[i][j].y = (NpointerY + yvalues[j] * (double)MINUNIT
                * (majorRadius + offsets[i] * minorRadius)) * weight;
     torus->points[i][j].z = (NpointerZ + zvalues[i] * (double)MINUNIT
                * (minorRadius)) * weight;
     torus->points[i][j].w = weight;
     torus->points[i][j].selected = FALSE;
   }
 }
 /* The knot vectors define piecewise Bezier segments (the same in both U and V). */
 for (i = 0; i < torus->numU + torus->orderU; i++){
   torus->kvU[i] = torus->kvV[i] = (double) knots[i];
 }
 return;
}

static void NurbsBezier(nurbs *torus, double width, double length){
 /* These define the shape of a flat Bezier patch. */
 double xvalues[] = { 0.0, 0.33333, 0.66666, 1.0};
 double yvalues[] = { 0.0, 0.33333, 0.66666, 1.0};
 double zvalues[] = { 0.0, 0.0,     0.0,     0.0};
 long knots[] = { 0, 0, 0, 0, 1, 1, 1, 1};
 long i,j;
 double weight=1.0;
 /* Set up the dimension and orders of the surface */
 torus->numU = 4;
 torus->numV = 4;
 torus->orderU = 4;    /* cubic in both directions */
 torus->orderV = 4;
 AllocNurbs(torus,NULL,NULL);
 for(i = 0; i < 4; i++){
   for(j = 0; j < 4; j++){
     /* Notice how the weights are pre-multiplied with the x, y and z values */
     torus->points[i][j].x = NpointerX + (xvalues[j] * (double)MINUNIT)
                * width * weight;
     torus->points[i][j].y = NpointerY + (yvalues[i] * (double)MINUNIT)
                * length * weight;
     torus->points[i][j].z = (NpointerZ)*weight;
     torus->points[i][j].w = weight;
     torus->points[i][j].selected = FALSE;
   }
 }
 /* The knot vectors define piecewise Bezier segments (the same in both U and V). */
 for (i = 0; i < torus->numU + torus->orderU; i++){
   torus->kvU[i] = torus->kvV[i] = (double) knots[i];
 }
 return;
}

static BOOL CheckHitNurbsOutline(int view, int x, int y,
                                 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);
     if(labs(sh1-x) < 6 && labs(sv1-y) < 6)return TRUE;
     if(labs(sh2-x) < 6 && labs(sv2-y) < 6)return TRUE;
   }
 }
 return FALSE;
}


void SelectAllNurbs(BOOL state){
 nurbs *n;
 if(Nnurbs == 0 || MainNp == NULL)return;
 n=MainNp; while(n != NULL){
   n->selected=state;
   n=n->last;
 }
 DrawModel();
}

void SwapNurbsSelection(void){
 nurbs *n;
 if(Nnurbs == 0 || MainNp == NULL)return;
 n=MainNp; while(n != NULL){
   n->selected ^= 1;
   n=n->last;
 }
 DrawModel();
}

BOOL SelectNurbsPatch(int view, int x, int y){
 BOOL bHit;
 register long i,j;
 NurbsSurfSample **pts;
 long GranularityU,GranularityV;
 nurbs *n;
 if(Nnurbs == 0 || MainNp == NULL)return FALSE;
 bHit=FALSE;
 n=MainNp; while(n != NULL){
   if(!n->properties.hidden){
     GranularityU=n->properties.GranularityMax;
     GranularityV=n->properties.GranularityMin;
     if((pts=CreateSurfaceNet(n,GranularityU,GranularityV)) == NULL)return FALSE;
     for(i = 0; i < GranularityV; i++)
     for(j = 0; j < GranularityU; j++){
       if(bHit=CheckHitNurbsOutline(view,x,y,&pts[i][j],&pts[i][j+1]))goto XXIT1;
     }
     XXIT1:

     X__Free(pts[0]);
     X__Free(pts);
     if(!bHit){
       GranularityU=n->properties.GranularityMin;
       GranularityV=n->properties.GranularityMax;
       if((pts=CreateSurfaceNet(n,GranularityU,GranularityV)) == NULL)return FALSE;
       for(j = 0; j < GranularityU; j++)
       for(i = 0; i < GranularityV; i++){
         if(bHit=CheckHitNurbsOutline(view,x,y,&pts[i][j],&pts[i+1][j]))goto XXIT2;
       }
       XXIT2:
       X__Free(pts[0]);
       X__Free(pts);
     }
     if(bHit){
       n->selected ^= 1;
       if(!(n->selected)){
         for(i=0;i<n->numV;i++)
         for(j=0;j<n->numU;j++)(n->points[i][j]).selected=FALSE;
       }
       if(!(GetAsyncKeyState(VK_SHIFT) & 0x8000)){
         nurbs *np;
         np=MainNp; while(np != NULL){
           if(np != n){
             np->selected=FALSE;
           }
           np=np->last;
         }
       }
       DrawModel();
       return TRUE;
     }
   }
   n=n->last;
 }
 return FALSE;
}

vector4 *LastSelectedControlPoint=NULL;

BOOL SelectNurbsControlPoint(int view, int x, int y){
 nurbs *np;
 int sh1,sv1;
 double w,d,dmin;
 vertex v,*vp;
 long i,j;
 vector4 *p1,*ps;
 LastSelectedControlPoint=NULL;
 if(Nnurbs == 0 || MainNp == NULL)return FALSE;
 dmin=(double)TVsizeY*(double)TVsizeY*(double)TVsizeZ;
 ps=NULL;
 vp=&v;
 vp->status=SELECTED;
 np=MainNp; while(np != NULL){
   if(np->selected){
     for(i=0;i<np->numV;i++)
     for(j=0;j<np->numU;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);
         if(labs(sh1-x) < 4 && labs(sv1-y) < 4){
           d=(double)(vp->xyz[0]-NpointerX)*(double)(vp->xyz[0]-NpointerX)
            +(double)(vp->xyz[1]-NpointerY)*(double)(vp->xyz[1]-NpointerY)
            +(double)(vp->xyz[2]-NpointerZ)*(double)(vp->xyz[2]-NpointerZ);
            if(d < dmin){
              dmin=d;
              ps=p1;
            }
         }
       }
     }
   }
   np=np->last;
 }
 if(ps != NULL){
   if(ps->selected)LastSelectedControlPoint=ps;
   ps->selected = TRUE;
   return TRUE;
 }
 return FALSE;
}

static BOOL CheckNurbsIn(int view, int type,
                         long xl, long xr, long yt, long yb,
                         int cx, int cy, double radius1,
                         HRGN hrgn,
                         NurbsSurfSample *p1,
                         NurbsSurfSample *p2){
 int sh1,sv1,sh2,sv2;
 double radius2;
 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);
     if(type == 0){
       if(sh1 > xl && sh1 < xr && sv1 > yt && sv1 < yb &&
          sh2 > xl && sh2 < xr && sv2 > yt && sv2 < yb)return TRUE;
     }
     else if(type == 1){
       radius2 = (sqrt((double)(sh1-cx)*(double)(sh1-cx)
                      +(double)(sv1-cy)*(double)(sv1-cy)));
       if(radius2 < radius1){
         radius2 = (sqrt((double)(sh2-cx)*(double)(sh2-cx)
                        +(double)(sv2-cy)*(double)(sv2-cy)));
         if(radius2 < radius1)return TRUE;
       }
     }
     else if(type == 2){
       if(PtInRegion(hrgn,sh1,sv1) && PtInRegion(hrgn,sh2,sv2))return TRUE;
     }
   }
 }
 return FALSE;
}

void SelectNurbsInRectangle(int Tool, BOOL bFlagNodeTool,
                            long xl, long xr, long yt, long yb){
 long i,j;
 nurbs *np;
 int sx,sy;
 double w;
 vertex v,*vp;
 vector4 *p1;
 if(Nnurbs == 0 || MainNp == NULL)return;
 vp=&v;
 vp->status=SELECTED;
 if(bFlagNodeTool){
   np=MainNp; while(np != NULL){
     if(np->selected){
       for(i=0;i<np->numV;i++)
       for(j=0;j<np->numU;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(ActiveView,vp->xyz[0],vp->xyz[1],vp->xyz[2],
                           &sx,&sy);
           if((sx > xl) && (sx < xr) && (sy > yt) && (sy < yb)){
             if(Tool == SELECTOR)p1->selected=TRUE;
             else                p1->selected=FALSE;
           }
         }
       }
     }
     np=np->last;
   }
 }
 else{
   long bHit;
   NurbsSurfSample **pts;
   long GranularityU,GranularityV;
   np=MainNp; while(np != NULL){
     bHit=0;
     GranularityU=np->properties.GranularityMax;
     GranularityV=np->properties.GranularityMin;
     if((pts=CreateSurfaceNet(np,GranularityU,GranularityV)) == NULL)return;
     for(i = 0; i < GranularityV; i++)
     for(j = 0; j < GranularityU; j++){
       if(CheckNurbsIn(ActiveView,0,
                       xl,xr,yt,yb,
                       0,0,0.0,
                       (HRGN)NULL,
                       &pts[i][j],&pts[i][j+1])){
         if(bHit == 0)bHit=1;
       }
       else bHit = -1;
     }
     X__Free(pts[0]);
     X__Free(pts);
     GranularityU=np->properties.GranularityMin;
     GranularityV=np->properties.GranularityMax;
     if((pts=CreateSurfaceNet(np,GranularityU,GranularityV)) == NULL)return;
     for(j = 0; j < GranularityU; j++)
     for(i = 0; i < GranularityV; i++){
       if(CheckNurbsIn(ActiveView,0,
                       xl,xr,yt,yb,
                       0,0,0.0,
                       (HRGN)NULL,
                       &pts[i][j],&pts[i+1][j])){

         if(bHit == 0)bHit=1;
       }
       else bHit = -1;
     }
     X__Free(pts[0]);
     X__Free(pts);
     if(bHit == 1){
       if(Tool == SELECTOR)np->selected=TRUE;
       else                np->selected=FALSE;
     }
     np=np->last;
   }
 }
 return;
}

void SelectNurbsInCircle(int Tool, BOOL bFlagNodeTool,
                         int cx, int cy, double radius1){
 long i,j;
 nurbs *np;
 int sx,sy;
 double w,radius2;
 vertex v,*vp;
 vector4 *p1;
 if(Nnurbs == 0 || MainNp == NULL)return;
 vp=&v;
 vp->status=SELECTED;
 if(bFlagNodeTool){
   np=MainNp; while(np != NULL){
     if(np->selected){
       for(i=0;i<np->numV;i++)
       for(j=0;j<np->numU;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(ActiveView,vp->xyz[0],vp->xyz[1],vp->xyz[2],
                           &sx,&sy);
           radius2 = (sqrt((double)(sx-cx)*(double)(sx-cx)
                          +(double)(sy-cy)*(double)(sy-cy)));
           if(radius2 < radius1){
             if(Tool == SELECTOR)p1->selected=TRUE;
             else                p1->selected=FALSE;
           }
         }
       }
     }
     np=np->last;
   }
 }
 else{
   long bHit;
   NurbsSurfSample **pts;
   long GranularityU,GranularityV;
   np=MainNp; while(np != NULL){
     bHit=0;
     GranularityU=np->properties.GranularityMax;
     GranularityV=np->properties.GranularityMin;
     if((pts=CreateSurfaceNet(np,GranularityU,GranularityV)) == NULL)return;
     for(i = 0; i < GranularityV; i++)
     for(j = 0; j < GranularityU; j++){
       if(CheckNurbsIn(ActiveView,1,
                       0,0,0,0,
                       cx,cy,radius1,
                       (HRGN)NULL,
                       &pts[i][j],&pts[i][j+1])){
         if(bHit == 0)bHit=1;
       }
       else bHit = -1;
     }
     X__Free(pts[0]);
     X__Free(pts);
     GranularityU=np->properties.GranularityMin;
     GranularityV=np->properties.GranularityMax;
     if((pts=CreateSurfaceNet(np,GranularityU,GranularityV)) == NULL)return;
     for(j = 0; j < GranularityU; j++)
     for(i = 0; i < GranularityV; i++){
       if(CheckNurbsIn(ActiveView,1,
                       0,0,0,0,
                       cx,cy,radius1,
                       (HRGN)NULL,
                       &pts[i][j],&pts[i+1][j])){

         if(bHit == 0)bHit=1;
       }
       else bHit = -1;
     }
     X__Free(pts[0]);
     X__Free(pts);
     if(bHit == 1){
       if(Tool == SELECTOR)np->selected=TRUE;
       else                np->selected=FALSE;
     }
     np=np->last;
   }
 }
 return;
}

void SelectNurbsInLasso(int Tool, BOOL bFlagNodeTool, HRGN hrgn){
 long i,j;
 nurbs *np;
 int sx,sy;
 double w;
 vertex v,*vp;
 vector4 *p1;
 if(Nnurbs == 0 || MainNp == NULL)return;
 vp=&v;
 vp->status=SELECTED;
 if(bFlagNodeTool){
   np=MainNp; while(np != NULL){
     if(np->selected){
       for(i=0;i<np->numV;i++)
       for(j=0;j<np->numU;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(ActiveView,vp->xyz[0],vp->xyz[1],vp->xyz[2],
                           &sx,&sy);
           if(PtInRegion(hrgn,sx,sy)){
             if(Tool == SELECTOR)p1->selected=TRUE;
             else                p1->selected=FALSE;
           }
         }
       }
     }
     np=np->last;
   }
 }
 else{
   long bHit;
   NurbsSurfSample **pts;
   long GranularityU,GranularityV;
   np=MainNp; while(np != NULL){
     bHit=0;
     GranularityU=np->properties.GranularityMax;
     GranularityV=np->properties.GranularityMin;
     if((pts=CreateSurfaceNet(np,GranularityU,GranularityV)) == NULL)return;
     for(i = 0; i < GranularityV; i++)
     for(j = 0; j < GranularityU; j++){
       if(CheckNurbsIn(ActiveView,2,
                       0,0,0,0,
                       0,0,0.0,
                       hrgn,
                       &pts[i][j],&pts[i][j+1])){
         if(bHit == 0)bHit=1;
       }
       else bHit = -1;
     }
     X__Free(pts[0]);
     X__Free(pts);
     GranularityU=np->properties.GranularityMin;
     GranularityV=np->properties.GranularityMax;
     if((pts=CreateSurfaceNet(np,GranularityU,GranularityV)) == NULL)return;
     for(j = 0; j < GranularityU; j++)
     for(i = 0; i < GranularityV; i++){
       if(CheckNurbsIn(ActiveView,2,
                       0,0,0,0,
                       0,0,0.0,
                       hrgn,
                       &pts[i][j],&pts[i+1][j])){

         if(bHit == 0)bHit=1;
       }
       else bHit = -1;
     }
     X__Free(pts[0]);
     X__Free(pts);
     if(bHit == 1){
       if(Tool == SELECTOR)np->selected=TRUE;
       else                np->selected=FALSE;
     }
     np=np->last;
   }
 }
 return;
}

void HideNurbs(BOOL hide){
 nurbs *np;
 if(Nnurbs == 0 || MainNp == NULL)return;
 np=MainNp; while(np != NULL){
   if(hide){
     if(np->selected){
       np->properties.hidden=1;
       np->selected=FALSE;
     }
   }
   else{
     np->properties.hidden=0;
   }
   np=np->last;
 }
 DrawModel();
 return;
}

void MoveNurbsControlPoint(int view, int x, int y, int UpOrDown){
 static long last_x,last_y,last_z;
 nurbs *np;
 double w,xp,yp,zp;
 long i,j;
 vector4 *p1;
 long dx,dy,dz;
 if(Nnurbs == 0 || MainNp == NULL)return;
 if(UpOrDown > 0){ // Down
   np=MainNp; while(np != NULL){
     if(np->selected)DrawInvertNurbsInOne(np,view,TRUE);
     np=np->last;
   }
 }
 else if(UpOrDown == 0){ // Move
   dx=NpointerX-last_x;
   dy=NpointerY-last_y;
   dz=NpointerZ-last_z;
   np=MainNp; while(np != NULL){
     if(np->selected){
       DrawInvertNurbsInOne(np,view,FALSE);
       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);
           xp += (double)dx;
           yp += (double)dy;
           zp += (double)dz;
           w=p1->w;
           p1->x = xp*w;
           p1->y = yp*w;
           p1->z = zp*w;
         }
       }
       DrawInvertNurbsInOne(np,view,TRUE);
     }
     np=np->last;
   }
   LastSelectedControlPoint=NULL;
 }
 else if(UpOrDown < 0){ // Up
   if(!(GetAsyncKeyState(VK_CONTROL) & 0x8000)){
     np=MainNp; while(np != NULL){
       if(np->selected){
         for(i=0;i<np->numV;i++)
         for(j=0;j<np->numU;j++){
           p1 = &(np->points[i][j]);
           if(p1->selected){
             p1->selected=FALSE;
           }
         }
       }
       np=np->last;
     }
   }
   else if(LastSelectedControlPoint != NULL){
     LastSelectedControlPoint->selected=FALSE;
   }
 }
 last_x=NpointerX; last_y=NpointerY; last_z=NpointerZ;
}

void MoveNurbsSurface(int view, int x, int y, int UpOrDown){
 static long last_x,last_y,last_z;
 nurbs *np;
 double w,xp,yp,zp;
 long i,j;
 vector4 *p1;
 long dx,dy,dz;
 if(Nnurbs == 0 || MainNp == NULL)return;
 if(UpOrDown > 0){ // Down
   np=MainNp; while(np != NULL){
     if(np->selected)DrawInvertNurbsInOne(np,view,TRUE);
     np=np->last;
   }
 }
 else if(UpOrDown == 0){ // Move
   dx=NpointerX-last_x;
   dy=NpointerY-last_y;
   dz=NpointerZ-last_z;
   np=MainNp; while(np != NULL){
     if(np->selected){
       DrawInvertNurbsInOne(np,view,FALSE);
       for(i=0;i<np->numV;i++)
       for(j=0;j<np->numU;j++){
         p1 = &(np->points[i][j]);
         w=1.0/p1->w;
         xp=((p1->x)*w);
         yp=((p1->y)*w);
         zp=((p1->z)*w);
         xp += (double)dx;
         yp += (double)dy;
         zp += (double)dz;
         w=p1->w;
         p1->x = xp*w;
         p1->y = yp*w;
         p1->z = zp*w;
       }
       DrawInvertNurbsInOne(np,view,TRUE);
     }
     np=np->last;
   }
 }
 else if(UpOrDown < 0){ // Up
 }
 last_x=NpointerX; last_y=NpointerY; last_z=NpointerZ;
 return;
}

void XpandNurbsSurface(int view, int UpOrDown, double sx, double sy, double sz){
 static long last_x,last_y,last_z;
 nurbs *np;
 double w,xp,yp,zp;
 long i,j;
 vector4 *p1;
 if(Nnurbs == 0 || MainNp == NULL)return;
 if(UpOrDown != 0){ // Down or Up
   np=MainNp; while(np != NULL){
     if(np->selected)DrawInvertNurbsInOne(np,view,TRUE);
     np=np->last;
   }
   last_x=NpointerX; last_y=NpointerY; last_z=NpointerZ;
 }
 else if(UpOrDown == 0){ // Move
   np=MainNp; while(np != NULL){
     if(np->selected){
       DrawInvertNurbsInOne(np,view,FALSE);
       for(i=0;i<np->numV;i++)
       for(j=0;j<np->numU;j++){
         p1 = &(np->points[i][j]);
         w=1.0/p1->w;
         xp=((p1->x)*w);
         yp=((p1->y)*w);
         zp=((p1->z)*w);
         xp = (xp-(double)last_x)*sx+(double)last_x;
         yp = (yp-(double)last_y)*sy+(double)last_y;
         zp = (zp-(double)last_z)*sz+(double)last_z;
         w=p1->w;
         p1->x = xp*w;
         p1->y = yp*w;
         p1->z = zp*w;
       }
       DrawInvertNurbsInOne(np,view,TRUE);
     }
     np=np->last;
   }
 }
 return;
}

static void RotateNurbsPoint(double x, double y, long X, long Y,
                             double *tx, double *ty,
                             double ctheta, double stheta){
 double dx,dy;
 dx=(x-(double)X);
 dy=(y-(double)Y);
 *tx = (double)X+(ctheta*dx-stheta*dy);
 *ty = (double)Y+(stheta*dx+ctheta*dy);
}

void RotateNurbsSurface(int view, int UpOrDown, double RotatorTheta){
 static long GrabonX,GrabonY,GrabonZ;
 static long lastRotator;
 nurbs *np;
 double xp,yp,x,y,z;
 double w,ctheta,stheta,beta;
 long i,j;
 vector4 *p1;
 if(Nnurbs == 0 || MainNp == NULL)return;
 if(UpOrDown != 0){ // Down or Up
   np=MainNp; while(np != NULL){
     if(np->selected)DrawInvertNurbsInOne(np,view,TRUE);
     np=np->last;
   }
   GrabonX=NpointerX; GrabonY=NpointerY; GrabonZ=NpointerZ;
   lastRotator=0.0;
 }
 else if(UpOrDown == 0){ // Move
//   beta=RotatorTheta-lastRotator;
   beta=RotatorTheta;
   lastRotator=RotatorTheta;
   ctheta=cos(beta); stheta=sin(beta);
   np=MainNp; while(np != NULL){
     if(np->selected){
       DrawInvertNurbsInOne(np,view,FALSE);
       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=((p1->x)*w);
         y=((p1->y)*w);
         z=((p1->z)*w);
         if(view == TRITOP){
           RotateNurbsPoint(x,y,GrabonX,GrabonY,&xp,&yp,ctheta,stheta);
           x=xp; y=yp;
         }
         else if(view == TRIFRONT){
           RotateNurbsPoint(x,z,GrabonX,GrabonZ,&xp,&yp,ctheta,stheta);
           x=xp; z=yp;
         }
         else if(view == TRIRIGHT){
           RotateNurbsPoint(y,z,GrabonY,GrabonZ,&xp,&yp,ctheta,stheta);
           y=xp; z=yp;
         }
         w=p1->w;
         p1->x = x*w;
         p1->y = y*w;
         p1->z = z*w;
       }
       DrawInvertNurbsInOne(np,view,TRUE);
     }
     np=np->last;
   }
 }
 return;
}

void RotateNurbsAction(int axis, double theta){
 nurbs *np;
 double x,y,z;
 double w,ctheta,stheta,beta;
 long i,j;
 vector4 *p1;
 if(Nnurbs == 0 || MainNp == NULL)return;
 ctheta=cos(theta); stheta=sin(theta);
 np=MainNp; while(np != NULL){
   if(np->selected){
     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=((p1->x)*w);
       y=((p1->y)*w);
       z=((p1->z)*w);
       if(axis == 0){
         RotateNurbsPoint(x,y,NpointerX,NpointerY,&x,&y,ctheta,stheta);
       }
       else if(axis == 1){
         RotateNurbsPoint(x,z,NpointerX,NpointerZ,&x,&z,ctheta,stheta);
       }
       else if(axis == 2){
         RotateNurbsPoint(y,z,NpointerY,NpointerZ,&y,&z,ctheta,stheta);
       }
       w=p1->w;
       p1->x = x*w;
       p1->y = y*w;
       p1->z = z*w;
     }
   }
   np=np->last;
 }
 return;
}

void ExpandNurbsAction(long cx, long cy, long cz,
                       double sx, double sy, double sz){
 nurbs *np;
 double w,xp,yp,zp;
 long i,j;
 vector4 *p1;
 if(Nnurbs == 0 || MainNp == NULL)return;
 np=MainNp; while(np != NULL){
   if(np->selected){
     for(i=0;i<np->numV;i++)
     for(j=0;j<np->numU;j++){
       p1 = &(np->points[i][j]);
       w=1.0/p1->w;
       xp=((p1->x)*w);
       yp=((p1->y)*w);
       zp=((p1->z)*w);
       xp = (xp-(double)cx)*sx+(double)cx;
       yp = (yp-(double)cy)*sy+(double)cy;
       zp = (zp-(double)cz)*sz+(double)cz;
       w=p1->w;
       p1->x = xp*w;
       p1->y = yp*w;
       p1->z = zp*w;
     }
   }
   np=np->last;
 }
 return;
}

void DuplicateSelectedNurbs(void){
 nurbs *np;
 if(Nnurbs == 0 || MainNp == NULL)return;
 np=MainNp; while(np != NULL){
   if(np->selected){
     EDIT_ACTION=YES;
     CreateNurbs();
     CloneNurbs(np,MainNp);
     MainNp->selected=FALSE;
   }
   np=np->last;
 }
 return;
}

void SplitNurbs(void){
 if(Nnurbs == 0 || MainNp == NULL)return;
 if(DialogBox(ghinst_main,MAKEINTRESOURCE(DLG_NURBSSPLIT),ghwnd_main,
                     (DLGPROC)NurbsSplitDlgProc)){
   EDIT_ACTION=YES;
   DrawModel();
 }
 return;
}

#include "nurbs0.c"
#include "nurbs1.c"
#include "nurbs2.c"
#include "teapot.c"