NURBS.C

Go to the documentation of this file.

/* file NURBS.C  - for use in the renderer */

#define MODULE_NURBS

#include "render.h"

#define MAXORDER 20

static double SubdivTolerance=(double)1024;

static void EmitTriangles(nurbs *);
static BOOL NurbsSameVertexLocation(vertex *, vertex *);
static void NurbsEliminateDuplicateVertices(void);

static 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;
}

void FreeNurbs(long n, nurbs *Np){
 long i;
 if(n == 0 || Np == NULL)return;
 for(i=0;i<n;i++){
   ReleaseNurbs((Np+i));
 }
 X__Free(Np);
 return;
}

#include "..\common\design\nurbs1.c"

static object *ObjectPointer=NULL;
static nurbs  *thisNurbs;
static long   NurbsFirstVertex,NurbsFirstFace,NonNurbsVertices;

static void EmitTriangles(nurbs *n){
 BOOL    no_vertices;
 vertex  *Vbase=NULL;
 face    *Fbase=NULL;
 long Nv,Nt,Nf;
 vector vecnn,vec0n;
 double len2nn,len20n;
 double u0,un,v0,vn;
 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;
 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((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));
 }

 Nv=ObjectPointer->NoVertices;
 if(ObjectPointer->Vbase == NULL){
   Vbase=(vertex *)X__Malloc(4*sizeof(vertex));
 }
 else{
   Vbase=(vertex *)X__Realloc(ObjectPointer->Vbase,(Nv+4)*sizeof(vertex));
 }
 if(Vbase != NULL){
   ObjectPointer->NoVertices=Nv+4;
   ObjectPointer->Vbase=Vbase;
 }
 else return;
 if(NonNurbsVertices == 0 || ObjectPointer->Vbase != NULL){
   (Vbase+Nv  )->u=n->c00.u; (Vbase+Nv  )->v=n->c00.v;
   (Vbase+Nv+1)->u=n->cn0.u; (Vbase+Nv+1)->v=n->cn0.v;
   (Vbase+Nv+2)->u=n->cnn.u; (Vbase+Nv+2)->v=n->cnn.v;
   (Vbase+Nv+3)->u=n->c0n.u; (Vbase+Nv+3)->v=n->c0n.v;
 }
 VECCOPY(n->c00.point,(Vbase+Nv  )->p)
 VECCOPY(n->cn0.point,(Vbase+Nv+1)->p)
 VECCOPY(n->cnn.point,(Vbase+Nv+2)->p)
 VECCOPY(n->c0n.point,(Vbase+Nv+3)->p)
 Nf=ObjectPointer->NoFaces;
 if(ObjectPointer->Fbase == NULL){
   Fbase=(face  *)X__Malloc(2*sizeof(face ));
 }
 else{
   Fbase=(face  *)X__Realloc(ObjectPointer->Fbase,(Nf+2)*sizeof(face ));
 }
 if(Fbase != NULL){
   ObjectPointer->NoFaces=Nf+2;
   ObjectPointer->Fbase=Fbase;
 }
 else return;
 memset((Fbase+Nf  ),0,sizeof(face));
 memset((Fbase+Nf+1),0,sizeof(face));
 if(len2nn < len20n){
   (Fbase+Nf)->V[0]=Nv;
   (Fbase+Nf)->V[1]=Nv+2;
   (Fbase+Nf)->V[2]=Nv+1;
   (Fbase+Nf+1)->V[0]=Nv;
   (Fbase+Nf+1)->V[1]=Nv+3;
   (Fbase+Nf+1)->V[2]=Nv+2;
 }
 else{
   (Fbase+Nf)->V[0]=Nv;
   (Fbase+Nf)->V[1]=Nv+3;
   (Fbase+Nf)->V[2]=Nv+1;
   (Fbase+Nf+1)->V[0]=Nv+3;
   (Fbase+Nf+1)->V[1]=Nv+2;
   (Fbase+Nf+1)->V[2]=Nv+1;
 }
 VECCOPY(thisNurbs->properties.colour,(Fbase+Nf  )->color)
 VECCOPY(thisNurbs->properties.colour,(Fbase+Nf+1)->color)
 (Fbase+Nf  )->bSmooth=TRUE;  // smooth
 (Fbase+Nf+1)->bSmooth=TRUE;  // smooth
 return;
}

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

static void NurbsEliminateDuplicateVertices(void){
 BOOL removed=FALSE;
 vertex *vp,*vpp,*vo,*MainVp;
 face   *fp,*MainFp;
 long i,j,k,NewC,Nvert,Nface;
 Nvert=ObjectPointer->NoVertices;
 Nface=ObjectPointer->NoFaces;
 MainVp=ObjectPointer->Vbase;
 MainFp=ObjectPointer->Fbase;
 for(vp=(MainVp+NurbsFirstVertex),i=NurbsFirstVertex;i<Nvert;i++,vp++){
   vp->x = -1.0;
 }
 for(i=NurbsFirstVertex;i<Nvert-1;i++){
   vp=(MainVp+i);
   if(vp->x < 0.0){
     for(j=i+1;j<Nvert;j++){
       vpp=(MainVp+j);
       if(vpp->x < 0.0 && NurbsSameVertexLocation(vp,vpp))vpp->x=(double)i;
     }
   }
 }
 for(fp=(MainFp+NurbsFirstFace),i=NurbsFirstFace;i<Nface;i++,fp++){
   if((j=(long)(MainVp+fp->V[0])->x) >= 0)fp->V[0]=j;
   if((j=(long)(MainVp+fp->V[1])->x) >= 0)fp->V[1]=j;
   if((j=(long)(MainVp+fp->V[2])->x) >= 0)fp->V[2]=j;
 }
 for(vp=(MainVp+NurbsFirstVertex),i=NurbsFirstVertex;i<Nvert;i++,vp++){
   if(vp->x >= 0.0){
     vp->y = 1.0;
     removed=TRUE;
   }
   else vp->y = 0.0;
   vp->x = 0.0;
 }
 NewC=Nvert;
 vp=(MainVp+NurbsFirstVertex);
 for(i=NurbsFirstVertex,k=NurbsFirstVertex;i<Nvert;i++){
   if(vp->y > 0.0){
     if(i < Nvert-1){
       vo=(MainVp+NewC-1);
       CopyMemory(vp,vo,sizeof(vertex));
       vo->x=(double)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]=(UNSIGNED)(MainVp+fp->V[0])->x;
     if(fp->V[1] >= Nvert)fp->V[1]=(UNSIGNED)(MainVp+fp->V[1])->x;
     if(fp->V[2] >= Nvert)fp->V[2]=(UNSIGNED)(MainVp+fp->V[2])->x;
   }
   MainVp=(vertex *)X__Realloc(ObjectPointer->Vbase,(Nvert)*sizeof(vertex));
   if(MainVp != NULL){
     ObjectPointer->NoVertices=Nvert;
     ObjectPointer->Vbase=MainVp;
   }
 }
 else if(removed)MessageBox(NULL,"Warning 1",NULL,MB_OK);
 for(vp=(MainVp+NurbsFirstVertex),i=NurbsFirstVertex;i<Nvert;i++,vp++){
   vp->x = vp->y = 0.0;
 }
 return;
}

BOOL MeshNurbsSurfaces(long oid){
 nurbs *Np;
 long   i,n;
 ObjectPointer=(Object+oid);
 NonNurbsVertices=ObjectPointer->NoVertices;
 Np=ObjectPointer->Nbase;
 n=ObjectPointer->NoNurbs;
 if(n == 0 || Np == NULL)return FALSE;
 for(i=0;i<n;i++){
   thisNurbs=(Np+i);
   if(thisNurbs->properties.hidden == 0){
     NurbsFirstVertex=ObjectPointer->NoVertices;
     NurbsFirstFace=ObjectPointer->NoFaces;
     EmitSubdivision(thisNurbs);
     NurbsEliminateDuplicateVertices();
   }
 }
 return TRUE;
}