SUBDCURV.CPP

Go to the documentation of this file.

/* --
OpenFX version 2.0 - Modelling, Animation and Rendering Package
Copyright (C) 2000 - 2007 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.
-- */

/* SUBDCURV.CPP  */

#include <stdlib.h>
#include <stdio.h>
#include <math.h>
#include <windows.h>

#ifdef __cplusplus
extern "C" {
#endif

#include "struct.h"
#include "dstruct.h"

#ifdef __cplusplus
}
#endif

#include "subdcurv.h"

#define DESELECTED 0
#define SELECTED   1
#define HIDDEN     2
#define INEDITOR   3
#define FAIL      -1
#define OK         1

static HWND      hParent;
static HINSTANCE hThisInstance;

#if __WATCOMC__
int APIENTRY LibMain(HANDLE hDLL, DWORD dwReason, LPVOID lpReserved){
#else
BOOL WINAPI DllMain(HANDLE hDLL, DWORD dwReason, LPVOID lpReserved){
#endif
  switch (dwReason) {
    case DLL_PROCESS_ATTACH: {
      hThisInstance=(HINSTANCE)hDLL;
      if(hDLL == NULL)MessageBox ( GetFocus()," NULL instance",NULL, MB_OK);
      break;
    }
    case DLL_PROCESS_DETACH:
      break;
  }
  return TRUE;
}

#if __SC__
#pragma startaddress(DllMain)
#endif

static int Subdivide(long, long);
static void SmoothOutCurve(long, long *, BOOL);

extern "C" BOOL _Xmodeler
 (HWND parent_window,HWND info_window,X__STRUCTURE *lpevi){
 lpEVI=lpevi;
 hParent=parent_window;
// if(MessageBox(hParent,"Subdivide selected faces ?","Subdivide",MB_OKCANCEL)
//               == IDCANCEL)return FALSE;
// else
 {
   HCURSOR hSave;
   if(NvertSelect == 0 || NvertSelect > 32000)return FALSE;
   hSave=SetCursor(LoadCursor(NULL,IDC_WAIT));
   Subdivide(0,0);
   SetCursor(hSave);
 }
 return TRUE;
}

#define VECCOPY(a,b)    { b[0] = a[0]; b[1] = a[1]; b[2] = a[2]; }
#define VECSUB(a,b,c)   { c[0]=a[0]-b[0]; c[1]=a[1]-b[1]; c[2]=a[2]-b[2];}
#define VECSUM(a,b,c)   { c[0]=a[0]+b[0]; c[1]=a[1]+b[1]; c[2]=a[2]+b[2];}
#define VECSCALE(a,b,c) { c[0]=(a)*b[0]; c[1]=(a)*b[1]; c[2]=(a)*b[2];}
#define DOT(a,b)        ( (a[0]*b[0]) + (a[1]*b[1]) + (a[2]*b[2]) )
#define CROSS(v1,v2,r)  { \
                          r[0] = (v1[1]*v2[2]) - (v2[1]*v1[2]);  \
                          r[1] = (v1[2]*v2[0]) - (v1[0]*v2[2]);  \
                          r[2] = (v1[0]*v2[1]) - (v2[0]*v1[1]);  \
                         }

typedef struct tagVERTEXVERTEX{
 long vl,vr;
} VERTEXVERTEX;

typedef struct tagFACEEXTRA{
 long extra,xxtra;
} FACEEXTRA;

#include "splines.c"

BOOL intriview(vertex *vp){
 if(vp->status == HIDDEN)return FALSE;
 if( ((vp->xyz[0] > TVpointX) && (vp->xyz[0] < TVpointX+TVsizeX))
  && ((vp->xyz[1] > TVpointY) && (vp->xyz[1] < TVpointY+TVsizeY))
  && ((vp->xyz[2] > TVpointZ) && (vp->xyz[2] < TVpointZ+TVsizeZ))
   )return TRUE;
 return FALSE;
}

BOOL IdentifyCurve(long *Np, long **Va, BOOL *loop){
 vertex *Vp;
 long vp,vf,*va;
 double d,dmin,drange;
 long Npath;
 *Va=NULL;
 *Np=0;
 if(NvertSelect < 1)return FALSE;
 if(NvertSelect > 1000)return FALSE;
 dmin=(double)TVsizeX*(double)TVsizeX;
 drange=dmin/1024;
 vp=0; vf= -1;
 while(vp < Nvert){
   Vp=(MainVp+vp);
   if(Vp->status == SELECTED && intriview(Vp)){
     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 && d < drange){
       dmin=d;
       vf=vp;
     }
   }
   Vp->id=0; /* use this bit for found flag */
   vp++;
 }
 if(vf < 0)return FALSE;
 if((va=(long *)X__Malloc(NvertSelect*sizeof(long))) == NULL){
   return FALSE;
 }
 *Va=va;
 Npath=0; va[0]=vf; (MainVp+va[0])->id=1;
 vp=0; while(vp < Nvert){
   Vp=(MainVp+vp);
   if(Vp->status == SELECTED && Vp->id == 0 && Connected(va[Npath],vp)){
     Npath++;
     va[Npath]=vp;
     Vp->id=1;
     vp=0;
   }
   else vp++;
 }
 if(Connected(va[Npath],va[0]))*loop = TRUE;
 else                          *loop = FALSE;
 if(*loop){
   if((va=(long *)X__Realloc(va,(Npath+2)*sizeof(long))) == NULL){
     return FALSE;
   }
   *Va=va;
   Npath++;
   va[Npath]=va[0];
 }
 Npath++;
 if(Npath < 4)return FALSE;
 *Np=Npath;
 return TRUE;
}

static int Subdivide(long down_to_f, long down_to_e){
 face *fp;
 edge *ep;
 vertex *vp,*V0,*V1,*V2;
 long i,j,vl,vr,id,nf=0,ne=0,n,Nedge1,Nface1,Nv1;
 long Npath=0,*Vpath=NULL;
 VERTEXVERTEX *vlist=NULL;
 FACEEXTRA    *MainLp=NULL,*lp;
 HCURSOR hSave;
 BOOL loop;
 // identity the curve
 if(!IdentifyCurve(&Npath,&Vpath,&loop)){
   if(Vpath != NULL)X__Free(Vpath);
   return FAIL;
 }
 for(i=0;i<Npath;i++)(MainVp+Vpath[i])->status=INEDITOR;
 X__Free(Vpath);
 // unidentity any selected vertices NOT on curve
 for(i=0;i<Nvert;i++){
   if(     (MainVp+i)->status == SELECTED)(MainVp+i)->status=INEDITOR;
   else if((MainVp+i)->status == INEDITOR)(MainVp+i)->status=SELECTED;
 }
 /* get upper bound for number of faces selected */
 if(down_to_f < Nface){
   if((MainLp=(FACEEXTRA *)X__Malloc(Nface*sizeof(FACEEXTRA))) == NULL){
     return FAIL;
   }
   fp=(MainFp+down_to_f); lp=(MainLp+down_to_f); nf=0;
   for(i=down_to_f;i<Nface;i++){
     lp->extra = -1;
     lp->xxtra = -1;
     V0=(MainVp+fp->V[0]); V1=(MainVp+fp->V[1]); V2=(MainVp+fp->V[2]);
     if((V0->status == SELECTED && V1->status == SELECTED) ||
        (V1->status == SELECTED && V2->status == SELECTED) ||
        (V2->status == SELECTED && V0->status == SELECTED)){
       nf++;
     }
     fp++; lp++;
   }
 }
 for(ep=(MainEp+down_to_e),ne=0,i=down_to_e;i<Nedge;i++){
   if((MainVp+ep->V[0])->status == SELECTED &&
      (MainVp+ep->V[1])->status == SELECTED)ne++; // number of edges to be divided
   ep++;
 }
 if(ne == 0){
   if(MainLp != NULL)X__Free(MainLp);
   return FAIL;
 }
 /* extend the Vertices Edges and Faces arrays to their upper bounds */
 if((vlist=(VERTEXVERTEX *)X__Malloc(ne*sizeof(VERTEXVERTEX))) == NULL){
   if(MainLp != NULL)X__Free(MainLp);
   return FAIL;
 }
 if(!UpdateVertexHeap(Nvert+ne))goto EP1;
 if(!UpdateEdgeHeap(Nedge+ne+nf*3))goto EP1;
 if(!UpdateFaceHeap(Nface+nf*3))goto EP1;
 Nface1=Nface; Nedge1=Nedge;
 ep=(MainEp+down_to_e); n=0;
 for(i=down_to_e;i<Nedge1;i++){
   vl=ep->V[0]; V0=(MainVp+vl); vr=ep->V[1]; V1=(MainVp+vr);
   if(V0->status == SELECTED && V1->status == SELECTED){
     CreateVertex(); Nv1=Nvert-1;
     vlist[n].vl=vl; vlist[n].vr=vr; (MainVp+Nv1)->id=n; n++;
     (MainVp+Nv1)->xyz[0]=(V0->xyz[0] + V1->xyz[0])/2;
     (MainVp+Nv1)->xyz[1]=(V0->xyz[1] + V1->xyz[1])/2;
     (MainVp+Nv1)->xyz[2]=(V0->xyz[2] + V1->xyz[2])/2;
     CreateEdge(Nv1,ep->V[1]);
     ep->V[1]=Nv1;
     if(down_to_f < Nface1){
       fp=(MainFp+down_to_f); lp=(MainLp+down_to_f);
       for(j=down_to_f;j<Nface1;j++){
        id=0;
        if     ((fp->V[0] == vl && fp->V[1] == vr) ||
                (fp->V[0] == vr && fp->V[1] == vl) )id=1;
        else if((fp->V[1] == vl && fp->V[2] == vr) ||
                (fp->V[1] == vr && fp->V[2] == vl) )id=2;
        else if((fp->V[2] == vl && fp->V[0] == vr) ||
                (fp->V[2] == vr && fp->V[0] == vl) )id=3;
        if(id != 0){
          if(lp->extra < 0)lp->extra=Nv1;
          else{
            if(lp->xxtra < 0)lp->xxtra=Nv1;
            else{
               CreateEdge(Nv1,lp->extra);
               CreateEdge(Nv1,lp->xxtra);
               CreateEdge(lp->extra,lp->xxtra);
               if     (id == 1){
                 if(IsFOSame(fp->V[0],fp->V[1],fp->V[2],
                             fp->V[2],lp->xxtra,lp->extra))
                   CreateFace(fp->V[2],lp->xxtra,lp->extra);
                 else
                   CreateFace(fp->V[2],lp->extra,lp->xxtra);
                 CopyFaceProp(fp,(MainFp+Nface-1));
                 if(vlist[(MainVp+lp->extra)->id].vl == fp->V[0] ||
                    vlist[(MainVp+lp->extra)->id].vr == fp->V[0]){
                   if(IsFOSame(fp->V[0],fp->V[1],fp->V[2],
                               fp->V[0],Nv1,lp->extra))
                     CreateFace(fp->V[0],Nv1,lp->extra);
                   else
                     CreateFace(fp->V[0],lp->extra,Nv1);
                   CopyFaceProp(fp,(MainFp+Nface-1));
                   if(IsFOSame(fp->V[0],fp->V[1],fp->V[2],
                               fp->V[1],Nv1,lp->xxtra))
                     CreateFace(fp->V[1],Nv1,lp->xxtra);
                   else
                     CreateFace(fp->V[1],lp->xxtra,Nv1);
                   CopyFaceProp(fp,(MainFp+Nface-1));
                 }
                 else{
                   if(IsFOSame(fp->V[0],fp->V[1],fp->V[2],
                               fp->V[1],Nv1,lp->extra))
                     CreateFace(fp->V[1],Nv1,lp->extra);
                   else
                     CreateFace(fp->V[1],lp->extra,Nv1);
                   CopyFaceProp(fp,(MainFp+Nface-1));
                   if(IsFOSame(fp->V[0],fp->V[1],fp->V[2],
                               fp->V[0],Nv1,lp->xxtra))
                     CreateFace(fp->V[0],Nv1,lp->xxtra);
                   else
                     CreateFace(fp->V[0],lp->xxtra,Nv1);
                   CopyFaceProp(fp,(MainFp+Nface-1));
                 }
               }
               else if(id == 2){
                 if(IsFOSame(fp->V[0],fp->V[1],fp->V[2],
                             fp->V[0],lp->xxtra,lp->extra))
                   CreateFace(fp->V[0],lp->xxtra,lp->extra);
                 else
                   CreateFace(fp->V[0],lp->extra,lp->xxtra);
                 CopyFaceProp(fp,(MainFp+Nface-1));
                 if(vlist[(MainVp+lp->extra)->id].vl == fp->V[1] ||
                    vlist[(MainVp+lp->extra)->id].vr == fp->V[1]){
                   if(IsFOSame(fp->V[0],fp->V[1],fp->V[2],
                               fp->V[1],Nv1,lp->extra))
                     CreateFace(fp->V[1],Nv1,lp->extra);
                   else
                     CreateFace(fp->V[1],lp->extra,Nv1);
                   CopyFaceProp(fp,(MainFp+Nface-1));
                   if(IsFOSame(fp->V[0],fp->V[1],fp->V[2],
                               fp->V[2],Nv1,lp->xxtra))
                     CreateFace(fp->V[2],Nv1,lp->xxtra);
                   else
                     CreateFace(fp->V[2],lp->xxtra,Nv1);
                   CopyFaceProp(fp,(MainFp+Nface-1));
                 }
                 else{
                   if(IsFOSame(fp->V[0],fp->V[1],fp->V[2],
                               fp->V[2],Nv1,lp->extra))
                     CreateFace(fp->V[2],Nv1,lp->extra);
                   else
                     CreateFace(fp->V[2],lp->extra,Nv1);
                   CopyFaceProp(fp,(MainFp+Nface-1));
                   if(IsFOSame(fp->V[0],fp->V[1],fp->V[2],
                               fp->V[1],Nv1,lp->xxtra))
                     CreateFace(fp->V[1],Nv1,lp->xxtra);
                   else
                     CreateFace(fp->V[1],lp->xxtra,Nv1);
                   CopyFaceProp(fp,(MainFp+Nface-1));
                 }
               }
               else if(id == 3){
                 if(IsFOSame(fp->V[0],fp->V[1],fp->V[2],
                             fp->V[1],lp->xxtra,lp->extra))
                   CreateFace(fp->V[1],lp->xxtra,lp->extra);
                 else
                   CreateFace(fp->V[1],lp->extra,lp->xxtra);
                 CopyFaceProp(fp,(MainFp+Nface-1));
                 if(vlist[(MainVp+lp->extra)->id].vl == fp->V[2] ||
                    vlist[(MainVp+lp->extra)->id].vr == fp->V[2]){
                   if(IsFOSame(fp->V[0],fp->V[1],fp->V[2],
                               fp->V[2],Nv1,lp->extra))
                     CreateFace(fp->V[2],Nv1,lp->extra);
                   else
                     CreateFace(fp->V[2],lp->extra,Nv1);
                   CopyFaceProp(fp,(MainFp+Nface-1));
                   if(IsFOSame(fp->V[0],fp->V[1],fp->V[2],
                               fp->V[0],Nv1,lp->xxtra))
                     CreateFace(fp->V[0],Nv1,lp->xxtra);
                   else
                     CreateFace(fp->V[0],lp->xxtra,Nv1);
                   CopyFaceProp(fp,(MainFp+Nface-1));
                 }
                 else{
                   if(IsFOSame(fp->V[0],fp->V[1],fp->V[2],
                               fp->V[0],Nv1,lp->extra))
                     CreateFace(fp->V[0],Nv1,lp->extra);
                   else
                    CreateFace(fp->V[0],lp->extra,Nv1);
                   CopyFaceProp(fp,(MainFp+Nface-1));
                   if(IsFOSame(fp->V[0],fp->V[1],fp->V[2],
                               fp->V[2],Nv1,lp->xxtra))
                     CreateFace(fp->V[2],Nv1,lp->xxtra);
                   else
                     CreateFace(fp->V[2],lp->xxtra,Nv1);
                   CopyFaceProp(fp,(MainFp+Nface-1));
                 }
               }
               if(IsFOSame(fp->V[0],fp->V[1],fp->V[2],
                          lp->xxtra,lp->extra,Nv1)){
                 fp->V[0]=lp->xxtra;
                 fp->V[1]=lp->extra;
                 fp->V[2]=Nv1;
               }
               else{
                 fp->V[0]=lp->xxtra;
                 fp->V[1]=Nv1;
                 fp->V[2]=lp->extra;
               }
               lp->extra = -1;
               lp->xxtra = -1;
            }
          }
        }
        fp++; lp++;
       }
     }
   }
   ep++;
 }
 if(down_to_f < Nface1){
   fp=(MainFp+down_to_f); lp=(MainLp+down_to_f);
   for(i=down_to_f;i<Nface1;i++){
     V0=(MainVp+fp->V[0]);
     V1=(MainVp+fp->V[1]);
     V2=(MainVp+fp->V[2]);
     if(lp->extra >= 0){
       if(V0->status == DESELECTED){
         if( IsFOSame(fp->V[0],fp->V[1],fp->V[2],
                      fp->V[0],lp->extra,fp->V[2]))
           CreateFace(fp->V[0],lp->extra,fp->V[2]);
         else
           CreateFace(fp->V[0],fp->V[2],lp->extra);
         CopyFaceProp(fp,(MainFp+Nface-1));
         CreateEdge(fp->V[0],lp->extra);
         fp->V[2] = lp->extra;
       }
       else if(V1->status == DESELECTED){
         if( IsFOSame(fp->V[0],fp->V[1],fp->V[2],
                      fp->V[1],lp->extra,fp->V[0]))
           CreateFace(fp->V[1],lp->extra,fp->V[0]);
         else
           CreateFace(fp->V[1],fp->V[0],lp->extra);
         CopyFaceProp(fp,(MainFp+Nface-1));
         CreateEdge(fp->V[1],lp->extra);
         fp->V[0] = lp->extra;
       }
       else if(V2->status == DESELECTED){
         if( IsFOSame(fp->V[0],fp->V[1],fp->V[2],
                      fp->V[2],lp->extra,fp->V[1]))
           CreateFace(fp->V[2],lp->extra,fp->V[1]);
         else
           CreateFace(fp->V[2],fp->V[1],lp->extra);
         CopyFaceProp(fp,(MainFp+Nface-1));
         CreateEdge(fp->V[2],lp->extra);
         fp->V[1] = lp->extra;
       }
     }
     fp++; lp++;
   }
 }
 X__Free(vlist);
 if(MainLp != NULL)X__Free(MainLp);
 // get the new curve included subdivied vertices
 if(!IdentifyCurve(&Npath,&Vpath,&loop)){
   if(Vpath != NULL)X__Free(Vpath);
   return FAIL;
 }
 // relabel any INEDITOR vertex
 for(i=0;i<Nvert;i++){
   if((MainVp+i)->status == INEDITOR)(MainVp+i)->status=SELECTED;
 }
 // smooth out the divided curve
 SmoothOutCurve(Npath,Vpath,loop);
 X__Free(Vpath);
 return OK;
 EP1:
 if(MainLp != NULL)X__Free(MainLp);
 X__Free(vlist);
 return FAIL;
}

static void SmoothOutCurve(long Npath, long *Vpath, BOOL loop){
 long c,i,j,l,n;
 double vl,v1,v2,vn,k[4];
//{char str[256]; sprintf(str,"Npath %ld Selected %ld",Npath,NvertSelect);
// if(loop)MessageBox(NULL,str,"LOOP",MB_OK);
// else MessageBox(NULL,str,"NO LOOP",MB_OK);
//}
 for(i=0;i<Npath-2;i+=2){
   for(c=0;c<3;c++){
     j=i+2;
     v1=(double)(MainVp+Vpath[i])->xyz[c];
     v2=(double)(MainVp+Vpath[j])->xyz[c];
     if(i == 0){
       if(loop)vl=(double)(MainVp+Vpath[Npath-3])->xyz[c];
       else    vl=(double)(2*((MainVp+Vpath[i])->xyz[c]) -
                              (MainVp+Vpath[j])->xyz[c]);
       vn=(double)(MainVp+Vpath[j+2])->xyz[c];
     }
     else if(i == Npath-3){
       vl=(double)(MainVp+Vpath[i-2])->xyz[c];
       if(loop)vn=(double)(MainVp+Vpath[2])->xyz[c];
       else    vn=(double)(2*((MainVp+Vpath[j])->xyz[c]) -
                              (MainVp+Vpath[i])->xyz[c]);
     }
     else{
       vl=(double)(MainVp+Vpath[i-2])->xyz[c];
       vn=(double)(MainVp+Vpath[j+2])->xyz[c];
     }
     SplinesK(k,vl,v1,v2,vn);
     (MainVp+Vpath[i+1])->xyz[c] = (long)SplinesR(k,0.5);
   }
 }
 return;
}