NURBS2.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  NURBS2.C  included in NURBS.C

#include "hidden.h"

static long hGranularityU=15,hGranularityV=15;

void HiddenGetNurbsNumbers(long *NoVertices, long *NoFaces){
 nurbs *n;
 long Vc=0,Fc=0;
 if(Nnurbs == 0 || MainNp == NULL)return;
 n=MainNp; while(n != NULL){
   if(!n->properties.hidden){//n->selected){
     Vc += (hGranularityU+1)*(hGranularityV+1);
     Fc += (hGranularityU*hGranularityV*2);
   }
   n=n->last;
 }
 *NoVertices += Vc;
 *NoFaces += Fc;
 return;
}

void HiddenAddNurbsVertices(long *Vcount, void *Vbase, double scale,
                            double trr[4][4],
                            long XMAX, long YMAX,
                            long Xcentre, long Ycentre){
 rvertex *v;
 nurbs *n;
 register long i,j,id;
 NurbsSurfSample **pts;
 double x,y,z;
 v=(rvertex *)Vbase;
 if(Nnurbs == 0 || MainNp == NULL)return;
 n=MainNp; while(n != NULL){
   if(!n->properties.hidden){//n->selected){
     if((pts=CreateSurfaceNet(n,hGranularityU,hGranularityV)) == NULL)return;
     for(i = 0; i <= hGranularityV; i++)
     for(j = 0; j <= hGranularityU; j++){
        x=pts[i][j].point[0];
        y=pts[i][j].point[1];
        z=pts[i][j].point[2];
        m4by1(trr,x,y,z,&x,&y,&z);
        id = *Vcount;
        v[id].p[0]=x;
        v[id].p[1]=y;
        v[id].p[2]=z;
        if(y >= 0.0){
          v[id].x=Xcentre+scale*x;
          v[id].y=Ycentre-scale*z;
        }
        else {v[id].x = 0; v[id].y= 0;}
        (*Vcount)++;
     }
     X__Free(pts[0]);
     X__Free(pts);
   }
   n=n->last;
 }
 return;
}

void HiddenAddNurbsFaces(long *nF, void *Fb, long Vf){
 rface *Fbase;
 nurbs *n;
 register long i,j;
 long x,y,z;
 Fbase=(rface *)Fb;
 if(Nnurbs == 0 || MainNp == NULL)return;
 n=MainNp; while(n != NULL){
   if(!n->properties.hidden){//n->selected){
     for(i = 0; i < hGranularityV; i++)
     for(j = 0; j < hGranularityU; j++){
       Fbase[*nF].V[0]=Vf+i*(hGranularityU+1)+j;
       Fbase[*nF].V[1]=Vf+(i+1)*(hGranularityU+1)+j;
       Fbase[*nF].V[2]=Vf+(i+1)*(hGranularityU+1)+j+1;
       (*nF)++;
       Fbase[*nF].V[0]=Vf+i*(hGranularityU+1)+j;
       Fbase[*nF].V[1]=Vf+(i+1)*(hGranularityU+1)+j+1;
       Fbase[*nF].V[2]=Vf+i*(hGranularityU+1)+j+1;
       (*nF)++;
     }
     Vf += (hGranularityU+1)*(hGranularityV+1);
   }
   n=n->last;
 }
 return;
}

typedef struct tagNURBSEDGELIST {
 long e[3];
} NURBSEDGELIST;

typedef struct tagVERTEXEDGELIST {
 long ne;
 long *e;
} VERTEXEDGELIST;

static BOOL InNurbsVertexList(long, VERTEXEDGELIST *);

static long NurbsFirstVertex=0,NurbsFirstEdge=0,NurbsFirstFace=0,
            NurbsEdgeListCount=0;
static NURBSEDGELIST *NurbsEdgeList=NULL;

static void EmitTriangles(nurbs *n){
/*
 * Turn a sufficiently flat surface into triangles.
 */
 vector vecnn,vec0n;        /* Diagonal vectors */
 double len2nn,len20n;      /* Diagonal lengths squared */
 double u0,un,v0,vn;        /* Texture coords; */
 long i,Fv,Fe;
 vertex *Vp;
 /*
  * Measure the distance along the two diagonals to decide the best
  * way to cut the rectangle into triangles.
  */
 VECSUB(n->c00.point,n->cnn.point,vecnn)
 VECSUB(n->c0n.point,n->cn0.point,vec0n)
 len2nn=(vecnn[0]*vecnn[0]+vecnn[1]*vecnn[1]+vecnn[2]*vecnn[2]);
 len20n=(vec0n[0]*vec0n[0]+vec0n[1]*vec0n[1]+vec0n[2]*vec0n[2]);
 if(max(len2nn,len20n) < EPSILON)return;
 /*
  * Assign the texture coordinates
  */
 u0 = n->kvU[n->orderU-1L];
 un = n->kvU[n->numU];
 v0 = n->kvV[n->orderV-1L];
 vn = n->kvV[n->numV];
 n->c00.u = u0; n->c00.v = v0;
 n->c0n.u = un; n->c0n.v = v0;
 n->cn0.u = u0; n->cn0.v = vn;
 n->cnn.u = un; n->cnn.v = vn;
 /*
  * If any normals are sick, fix them now.
  */
 if((n->c00.normLen == 0.0) ||
    (n->cnn.normLen == 0.0) ||
    (n->cn0.normLen == 0.0)){
   FixNormals(&(n->c00),&(n->cnn),&(n->cn0));
 }
 if(n->c0n.normLen == 0.0){
   FixNormals(&(n->c00),&(n->c0n),&(n->cnn));
 }
 if(NurbsEdgeList == NULL)
   NurbsEdgeList=(NURBSEDGELIST *)X__Malloc(2*sizeof(NURBSEDGELIST));
 else
   NurbsEdgeList=(NURBSEDGELIST *)X__Realloc(NurbsEdgeList,
                 (NurbsEdgeListCount+2)*sizeof(NURBSEDGELIST));
 if(NurbsEdgeList == NULL)return;
 if(UpdateVertexHeap(Nvert+4)){
   if(UpdateEdgeHeap(Nedge+5)){
     if(UpdateFaceHeap(Nface+2)){
       Fv=Nvert;
       Fe=Nedge;
       for(i=0;i<4;i++)CreateVertex();
       Vp=(MainVp+Fv);
       Vp->xyz[0]=(long)n->c00.point[0];
       Vp->xyz[1]=(long)n->c00.point[1];
       Vp->xyz[2]=(long)n->c00.point[2];
       Vp->gp=1; 
       Vp->x=n->c00.u; Vp->y=n->c00.v;
       Vp=(MainVp+Fv+1);
       Vp->xyz[0]=(long)n->cn0.point[0];
       Vp->xyz[1]=(long)n->cn0.point[1];
       Vp->xyz[2]=(long)n->cn0.point[2];
       Vp->gp=1;
       Vp->x=n->cn0.u; Vp->y=n->cn0.v;
       Vp=(MainVp+Fv+2);
       Vp->xyz[0]=(long)n->cnn.point[0];
       Vp->xyz[1]=(long)n->cnn.point[1];
       Vp->xyz[2]=(long)n->cnn.point[2];
       Vp->gp=1;
       Vp->x=n->cnn.u; Vp->y=n->cnn.v;
       Vp=(MainVp+Fv+3);
       Vp->xyz[0]=(long)n->c0n.point[0];
       Vp->xyz[1]=(long)n->c0n.point[1];
       Vp->xyz[2]=(long)n->c0n.point[2];
       Vp->gp=1;
       Vp->x=n->c0n.u; Vp->y=n->c0n.v;
       CreateEdge(Fv+0,Fv+1);
       CreateEdge(Fv+1,Fv+2);
       CreateEdge(Fv+2,Fv+3);
       CreateEdge(Fv+3,Fv+0);
       if(len2nn < len20n){
         CreateEdge(Fv+0,Fv+2);
         CreateFace(Fv+0,Fv+2,Fv+1);
         CreateFace(Fv+0,Fv+3,Fv+2);
         NurbsEdgeList[NurbsEdgeListCount].e[0]=Fe+1;
         NurbsEdgeList[NurbsEdgeListCount].e[1]=Fe+0;
         NurbsEdgeList[NurbsEdgeListCount].e[2]=Fe+4;
         NurbsEdgeListCount++;
         NurbsEdgeList[NurbsEdgeListCount].e[0]=Fe+2;
         NurbsEdgeList[NurbsEdgeListCount].e[1]=Fe+4;
         NurbsEdgeList[NurbsEdgeListCount].e[2]=Fe+3;
         NurbsEdgeListCount++;
       }
       else{
         CreateEdge(Fv+3,Fv+1);
         CreateFace(Fv+0,Fv+3,Fv+1);
         CreateFace(Fv+3,Fv+2,Fv+1);
         NurbsEdgeList[NurbsEdgeListCount].e[0]=Fe+4;
         NurbsEdgeList[NurbsEdgeListCount].e[1]=Fe+0;
         NurbsEdgeList[NurbsEdgeListCount].e[2]=Fe+3;
         NurbsEdgeListCount++;
         NurbsEdgeList[NurbsEdgeListCount].e[0]=Fe+1;
         NurbsEdgeList[NurbsEdgeListCount].e[1]=Fe+4;
         NurbsEdgeList[NurbsEdgeListCount].e[2]=Fe+2;
         NurbsEdgeListCount++;
       }
     }
   }
 }
 return;
}

static BOOL SameVertexLocation(vertex *vp, vertex *vpp){
 long tolerance=MINUNIT/32;
 if(labs(vp->xyz[0] - vpp->xyz[0]) < tolerance &&
    labs(vp->xyz[1] - vpp->xyz[1]) < tolerance &&
    labs(vp->xyz[2] - vpp->xyz[2]) < tolerance)return TRUE;
 return FALSE;
}

static void NurbsEliminateDuplicateVertices(void){
 BOOL removed=FALSE;
 vertex *vp,*vpp,*vo;
 edge   *ep;
 face   *fp;
 long i,j,k,NewC;
 for(vp=(MainVp+NurbsFirstVertex),i=NurbsFirstVertex;i<Nvert;i++,vp++)vp->id = -1;
 for(i=NurbsFirstVertex;i<Nvert-1;i++){
   vp=(MainVp+i);
   if(vp->id < 0){
     for(j=i+1;j<Nvert;j++){
       vpp=(MainVp+j);
       if(vpp->id < 0 && SameVertexLocation(vp,vpp))vpp->id=i;
     }
   }
 }
 for(ep=(MainEp+NurbsFirstEdge),i=NurbsFirstEdge;i<Nedge;i++,ep++){
   if((j=(MainVp+ep->V[0])->id) >= 0)ep->V[0]=j;
   if((j=(MainVp+ep->V[1])->id) >= 0)ep->V[1]=j;
 }
 for(fp=(MainFp+NurbsFirstFace),i=NurbsFirstFace;i<Nface;i++,fp++){
   if((j=(MainVp+fp->V[0])->id) >= 0)fp->V[0]=j;
   if((j=(MainVp+fp->V[1])->id) >= 0)fp->V[1]=j;
   if((j=(MainVp+fp->V[2])->id) >= 0)fp->V[2]=j;
 }
 for(vp=(MainVp+NurbsFirstVertex),i=NurbsFirstVertex;i<Nvert;i++,vp++){
   if(vp->id >= 0){
     vp->status=INEDITOR;
     removed=TRUE;
     NvertSelect--;
   }
   vp->id = 0;
 }
 NewC=Nvert;
 vp=(MainVp+NurbsFirstVertex);
 for(i=NurbsFirstVertex,k=NurbsFirstVertex;i<Nvert;i++){
   if(vp->status == INEDITOR){
     if(i < Nvert-1){
       vo=(MainVp+NewC-1);
       CopyMemory(vp,vo,sizeof(vertex));
       vo->id=k;
     }
     NewC--;
   }
   else {
     vp++; k++;
   }
 }
 if(NewC < Nvert){
   Nvert=NewC;
   for(i=NurbsFirstFace,fp=(MainFp+NurbsFirstFace);i<Nface;i++,fp++){
     if(fp->V[0] >= Nvert)fp->V[0]=(MainVp+fp->V[0])->id;
     if(fp->V[1] >= Nvert)fp->V[1]=(MainVp+fp->V[1])->id;
     if(fp->V[2] >= Nvert)fp->V[2]=(MainVp+fp->V[2])->id;
   }
   for(i=NurbsFirstEdge,ep=(MainEp+NurbsFirstEdge);i<Nedge;i++,ep++){
     if(ep->V[0] >= Nvert)ep->V[0]=(MainVp+ep->V[0])->id;
     if(ep->V[1] >= Nvert)ep->V[1]=(MainVp+ep->V[1])->id;
   }
   UpdateVertexHeap(Nvert);
 }
 else if(removed)MessageBox(NULL,"Warning 1",NULL,MB_OK);
 return;
}

static BOOL VertexOnEdge(vertex *vp, edge *ep){
 double tolerance=(double)MINUNIT/32.0;
 double l,l01,d;
 vector pi,p01;
 VECSUB((double)vp->xyz,(double)(MainVp+ep->V[0])->xyz,pi)
 VECSUB((double)(MainVp+ep->V[1])->xyz,(double)(MainVp+ep->V[0])->xyz,p01)
 l01=sqrt(p01[0]*p01[0]+p01[1]*p01[1]+p01[2]*p01[2]);
 if(fabs(l01) < 0.01)return FALSE;
 p01[0] /= l01; p01[1] /= l01; p01[2] /= l01;
 l=DOT(pi,p01);
 if(l < 0.0 || l > l01)return FALSE;
 d=sqrt((pi[0]-l*p01[0])*(pi[0]-l*p01[0])+
        (pi[1]-l*p01[1])*(pi[1]-l*p01[1])+
        (pi[2]-l*p01[2])*(pi[2]-l*p01[2]));
 if(d < tolerance)return TRUE;
 return FALSE;
}

static void NurbsInsertDividingEdges(void){
 vertex *vp;
 face *fp;
 long i,j,k,movedV,movedE;
 edge *e0,*e1,*e2;
 LOOP:
 for(i=NurbsFirstFace,fp=(MainFp+NurbsFirstFace),k=0;i<Nface;i++,fp++,k++){
   e0=(MainEp+NurbsEdgeList[k].e[0]);
   e1=(MainEp+NurbsEdgeList[k].e[1]);
   e2=(MainEp+NurbsEdgeList[k].e[2]);
   for(vp=(MainVp+NurbsFirstVertex),j=NurbsFirstVertex;j<Nvert;j++,vp++){
     if(j != fp->V[0] && j != fp->V[1] && j != fp->V[2]){
       if(VertexOnEdge(vp,e0)){
         movedV=fp->V[2];
         fp->V[2]=j;
         e0->V[0]=fp->V[1];
         e0->V[1]=j;
         if(!UpdateEdgeHeap(Nedge+2))return;
         CreateEdge(fp->V[0],j);
         movedE=NurbsEdgeList[k].e[1];
         NurbsEdgeList[k].e[1]=(Nedge-1);
         CreateEdge(j,movedV);
         if(!UpdateFaceHeap(Nface+1))return;
         CreateFace(fp->V[0],j,movedV);
         CopyFaceProp(fp,(MainFp+Nface-1));
         NurbsEdgeList=(NURBSEDGELIST *)X__Realloc(NurbsEdgeList,
           (NurbsEdgeListCount+1)*sizeof(NURBSEDGELIST));
         if(NurbsEdgeList == NULL)return;
         NurbsEdgeList[NurbsEdgeListCount].e[0]=Nedge-1;
         NurbsEdgeList[NurbsEdgeListCount].e[1]=movedE;
         NurbsEdgeList[NurbsEdgeListCount].e[2]=Nedge-2;
         NurbsEdgeListCount++;
         goto LOOP;
       }
       if(VertexOnEdge(vp,e1)){
         movedV=fp->V[0];
         fp->V[0]=j;
         e1->V[0]=fp->V[2];
         e1->V[1]=j;
         if(!UpdateEdgeHeap(Nedge+2))return;
         CreateEdge(fp->V[1],j);
         movedE=NurbsEdgeList[k].e[2];
         NurbsEdgeList[k].e[2]=(Nedge-1);
         CreateEdge(j,movedV);
         if(!UpdateFaceHeap(Nface+1))return;
         CreateFace(fp->V[1],j,movedV);
         CopyFaceProp(fp,(MainFp+Nface-1));
         NurbsEdgeList=(NURBSEDGELIST *)X__Realloc(NurbsEdgeList,
           (NurbsEdgeListCount+1)*sizeof(NURBSEDGELIST));
         if(NurbsEdgeList == NULL)return;
         NurbsEdgeList[NurbsEdgeListCount].e[0]=Nedge-1;
         NurbsEdgeList[NurbsEdgeListCount].e[1]=movedE;
         NurbsEdgeList[NurbsEdgeListCount].e[2]=Nedge-2;
         NurbsEdgeListCount++;
         goto LOOP;
       }
       if(VertexOnEdge(vp,e2)){
         movedV=fp->V[1];
         fp->V[1]=j;
         e2->V[0]=fp->V[0];
         e2->V[1]=j;
         if(!UpdateEdgeHeap(Nedge+2))return;
         CreateEdge(fp->V[2],j);
         movedE=NurbsEdgeList[k].e[0];
         NurbsEdgeList[k].e[0]=(Nedge-1);
         CreateEdge(j,movedV);
         if(!UpdateFaceHeap(Nface+1))return;
         CreateFace(fp->V[2],j,movedV);
         CopyFaceProp(fp,(MainFp+Nface-1));
         NurbsEdgeList=(NURBSEDGELIST *)X__Realloc(NurbsEdgeList,
           (NurbsEdgeListCount+1)*sizeof(NURBSEDGELIST));
         if(NurbsEdgeList == NULL)return;
         NurbsEdgeList[NurbsEdgeListCount].e[0]=Nedge-1;
         NurbsEdgeList[NurbsEdgeListCount].e[1]=movedE;
         NurbsEdgeList[NurbsEdgeListCount].e[2]=Nedge-2;
         NurbsEdgeListCount++;
         goto LOOP;
       }
     }
   }
 }
 return;
}

static BOOL InNurbsVertexList(long v, VERTEXEDGELIST *vl){
 long i;
 for(i=0;i<vl->ne;i++){
   if(vl->e[i] == v)return TRUE;
 }
 return FALSE;
}

static void NurbsEliminateDuplicateEdges(void){
 VERTEXEDGELIST *VertexEdgeList=NULL;
 long i,v0,v1,ne,NewC;
 edge *ep;
 if((VertexEdgeList=(VERTEXEDGELIST *)X__Malloc(sizeof(VERTEXEDGELIST)*
   (Nvert-NurbsFirstVertex))) == NULL)return;
 for(i=0;i<Nvert-NurbsFirstVertex;i++){
  VertexEdgeList[i].ne=0;
  VertexEdgeList[i].e=NULL;
 }
 for(i=NurbsFirstEdge;i<Nedge;i++){
   v0=((MainEp+i)->V[0])-NurbsFirstVertex;
   v1=((MainEp+i)->V[1])-NurbsFirstVertex;
   if(v0 < 0 || v1 < 0)MessageBox(NULL,"BAD vertices",NULL,MB_OK);
   if(VertexEdgeList[v0].e != NULL && VertexEdgeList[v0].ne > 0){
     if(InNurbsVertexList(v1,&VertexEdgeList[v0])){ // duplicate mark for delete
       (MainEp+i)->V[0] = -1;
       (MainEp+i)->V[1] = -1;
     }
     else{ // add to list
       ne=VertexEdgeList[v0].ne;
       if((VertexEdgeList[v0].e=(long *)X__Realloc(VertexEdgeList[v0].e,
                                        sizeof(long)*(ne+1))) != NULL){
         VertexEdgeList[v0].e[ne]=v1;
         VertexEdgeList[v0].ne=ne+1;
       }
     }
   }
   else{ // start new list
     if((VertexEdgeList[v0].e=(long *)X__Malloc(sizeof(long))) != NULL){
       VertexEdgeList[v0].e[0]=v1;
       VertexEdgeList[v0].ne=1;
     }
   }
   if(VertexEdgeList[v1].e != NULL && VertexEdgeList[v1].ne > 0){
     if(InNurbsVertexList(v0,&VertexEdgeList[v1])){ // duplicate mark for delete
       (MainEp+i)->V[0] = -1;
       (MainEp+i)->V[1] = -1;
     }
     else{ // add to list
       ne=VertexEdgeList[v1].ne;
       if((VertexEdgeList[v1].e=(long *)X__Realloc(VertexEdgeList[v1].e,
                                        sizeof(long)*(ne+1))) != NULL){
         VertexEdgeList[v1].e[ne]=v0;
         VertexEdgeList[v1].ne=ne+1;
       }
     }
   }
   else{ // start new list
     if((VertexEdgeList[v1].e=(long *)X__Malloc(sizeof(long))) != NULL){
       VertexEdgeList[v1].e[0]=v0;
       VertexEdgeList[v1].ne=1;
     }
   }
 }
 NewC=Nedge; // eliminate duplicate edges
 for(ep=(MainEp+NurbsFirstEdge),i=NurbsFirstEdge;i<Nedge;i++){
   if(ep->V[0] < 0 || ep->V[1] < 0){
     if(i < Nedge-1)CopyMemory(ep,(MainEp+NewC-1),sizeof(edge));
     NewC--;
   }
   else ep++;
 }
 if(NewC != Nedge){
   Nedge=NewC;
   UpdateEdgeHeap(Nedge);
 }
 for(ep=MainEp,i=0;i<Nedge;i++,ep++){
   if(ep->V[0] < 0 || ep->V[1] < 0)MessageBox(NULL,"BAD Edges",NULL,MB_OK);
 }
 for(i=0;i<Nvert-NurbsFirstVertex;i++){
   if(VertexEdgeList[i].e != NULL)X__Free(VertexEdgeList[i].e);
 }
 X__Free(VertexEdgeList);
 return;
}

void MeshNurbsSurface(void){
 HCURSOR hCursorSave;
 long i=500;
 nurbs *n;
 if(Nnurbs == 0 || MainNp == NULL)return;
 if((i=RequestNumEntry((short)i,1,10000,"Tesselate","Resolution")) < 0)return;
 hCursorSave=SetCursor(ghcurWait);
 SubdivTolerance=((double)MINUNIT)*(double)(i)/1000.0;
 n=MainNp; while(n != NULL){
   if(n->selected && !n->properties.hidden){
     NurbsFirstVertex=Nvert;
     NurbsFirstEdge=Nedge;
     NurbsFirstFace=Nface;
     NurbsEdgeListCount=0;
     NurbsEdgeList=NULL;
     EmitSubdivision(n);
     NurbsEliminateDuplicateVertices();
     NurbsInsertDividingEdges();
     NurbsEliminateDuplicateEdges();
     if(NurbsEdgeList != NULL)X__Free(NurbsEdgeList);
   }
   n=n->last;
 }
 SetCursor(hCursorSave);
 DrawModel();
 return;
}

#include "faceattr.h"

void PutNurbsAttribute(int what, void *ff){
 /* The IDs are the same as for the face attributes */
 nurbs *np;
 NurbsProperties *fp;
 FACEATTRIBS *f;
 f=(FACEATTRIBS *)ff;
 if(Nnurbs == 0 || MainNp == NULL)return;
 np=MainNp; while(np != NULL){
   if(np->selected){
     fp = &(np->properties);
     if(what == 0){
       VECCOPY(f->fc,fp->colour)
     }
     else if(what == 5){ /* smoothing */
       if(f->sm == 1)fp->smoothing=1;
       else          fp->smoothing=0;
     }
     else if(what == 7){ /* set shader value */
       fp->shader = (long)f->sh;
     }
     else if(what == 8){ /* dump map - clear bit 6 */
       fp->map = -1;
     }
     else if(what == 9){ /* set shader axis ID */
       fp->axis  = (long)f->sa;
     }
     else if(what == 10){ /* set map */
       fp->map    = (long)f->bu;
     }
   }
   np=np->last;
 }
 return;
}

void WriteNurbs(FILE *fo){
 long i,j;
 nurbs *n,*first;
//{ char ttt[256];
//sprintf(ttt,"size of prop %ld  vec4=%ld vec=%ld BOOL=%ld uc=%ld",
//sizeof(NurbsProperties),
//sizeof(vector4),sizeof(vector),
//sizeof(BOOL),sizeof(unsigned char));
//MessageBox(NULL,ttt,"Write",MB_OK);
//}
 if(Nnurbs == 0 || MainNp == NULL)return;
 n=MainNp; while(n != NULL){
   first=n;
   n=n->last;
 }
 n=first;
 fwrite(&Nnurbs,sizeof(long),1,fo);
 while(n != NULL){
   fwrite(&(n->properties),sizeof(NurbsProperties),1,fo);
   fwrite(&(n->numU),sizeof(long),1,fo);
   fwrite(&(n->numV),sizeof(long),1,fo);
   fwrite(&(n->orderU),sizeof(long),1,fo);
   fwrite(&(n->orderV),sizeof(long),1,fo);
   for(i=0;i<n->numU + n->orderU; i++)fwrite(&(n->kvU[i]),sizeof(double),1,fo);
   for(i=0;i<n->numV + n->orderV; i++)fwrite(&(n->kvV[i]),sizeof(double),1,fo);
   for(i=0;i<n->numV; i++)
   for(j=0;j<n->numU; j++){
     fwrite(&(n->points[i][j]),sizeof(vector4),1,fo);
   }
   n=n->next;
 }
 return;
}

void ReadNurbs(long clen, short relation, HANDLE fq){
 DWORD dwRead;
 nurbs *n;
 long i,j,k,N;
 ReadFile(fq,&N,sizeof(long),&dwRead,NULL);
 for(k=0;k<N;k++){
   CreateNurbs();
   n=MainNp;
   if(n != NULL){
     ReadFile(fq,&(n->properties),sizeof(NurbsProperties),&dwRead,NULL);
     ReadFile(fq,&(n->numU),sizeof(long),&dwRead,NULL);
     ReadFile(fq,&(n->numV),sizeof(long),&dwRead,NULL);
     ReadFile(fq,&(n->orderU),sizeof(long),&dwRead,NULL);
     ReadFile(fq,&(n->orderV),sizeof(long),&dwRead,NULL);
     AllocNurbs(n,NULL,NULL);
     for(i=0;i<n->numU + n->orderU; i++)
       ReadFile(fq,&(n->kvU[i]),sizeof(double),&dwRead,NULL);
     for(i=0;i<n->numV + n->orderV; i++)
       ReadFile(fq,&(n->kvV[i]),sizeof(double),&dwRead,NULL);
     for(i=0;i<n->numV; i++)
     for(j=0;j<n->numU; j++){
       ReadFile(fq,&(n->points[i][j]),sizeof(vector4),&dwRead,NULL);
     }
   }
 }
 return;
}