ATM2.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 ATM2.C  build Characters */

#define SELECTED   1
#define DESELECTED 0

static long VP,VF;

static void GetATMholdPoint(long *x, long *y, long cx, long cy, short pt);
static void process_type1_routine(character_program Cp);
static long CurveUpto(long vp, point *p, double d, long n);

static void DeselectVertexSet(long vs, long vf){
 vertex *Vs;
 while(vs < vf){
   Vs=(MainVp+vs);
   if(Vs->status == SELECTED){
      Vs->status = DESELECTED; NvertSelect--; NvertDeselect++;
   }
   vs++;
 }
}

static void SelectVertexSet(long vs, long vf){
 vertex *Vs;
 while(vs < vf){
   Vs=(MainVp+vs);
   if(Vs->status == DESELECTED){
      Vs->status = SELECTED; NvertSelect++; NvertDeselect--;
   }
   vs++;
 }
}

static void MakeNewPSletter(HWND hwnd){
 long i,j,char_id,Depth,Opx,Opy,Opz;
 int ifail,capped=0;
 long Vstart,Vstop,BackStart,BackStop,fBevelStart,fBevelStop,Vfirst;
 long ep,Estart=-1;
 long fp,LastFace;
 skel *sp;
 Vfirst=Nvert;
 char_id=0;
 Opx=NpointerX; Opy=NpointerY; Opz=NpointerZ;
 DeselectVertexSet(0,Nvert);
 while ((j=(long)lpAtm->ATM_Letters[char_id++]) > 0){
   n_Subroutines = 0; C_Subs=NULL; Cprogram.n=0; Cprogram.p=NULL;
   if((type1_stack=(int *)X__Malloc(512*sizeof(int))) == NULL){
     MessageBox(hwnd,"Out of memory","ATM",MB_OK);
     return;
   }
   if((ifail=decode_build_type1((int)j,lpAtm->last_ATM_font)) != OK){
     if(ifail == FAIL){
       MessageBox(hwnd,"Font corrupt","ATM",MB_OK);
     }
     else if(ifail == MEMFAIL){
       MessageBox(hwnd,"Out of memory","ATM",MB_OK);
     }
     goto FREEALL;
   }
   SP=0; XX=NpointerY; YY=NpointerZ;
   Cwidthx=0; Cwidthy=0; Vstart=Nvert; Estart=Nedge; VF=VP= -1;
   process_type1_routine(Cprogram);
   if(lpAtm->ATM_chara_width > 0){
     Depth=MaxScale*(double)lpAtm->ATM_chara_width/100.0*Scale;
   }
   else Depth=0;
   if(j == 32){
     UpdateVertexHeap(Nvert+2);
     CreateVertex();
     (MainVp+Nvert-1)->xyz[0]=NpointerX-Depth/2;
     (MainVp+Nvert-1)->xyz[1]=NpointerY;
     (MainVp+Nvert-1)->xyz[2]=NpointerZ;
     CreateVertex();
     (MainVp+Nvert-1)->xyz[0]=NpointerX-Depth/2;
     (MainVp+Nvert-1)->xyz[1]=NpointerY+Cwidthx*lpAtm->FORB;
     (MainVp+Nvert-1)->xyz[2]=NpointerZ+Cwidthy;
     UpdateEdgeHeap(Nedge+1);
     CreateEdge(Nvert-1,Nvert-2);
   }
   NpointerY += Cwidthx*lpAtm->FORB; NpointerZ += Cwidthy;
   FREEALL:
   X__Free(type1_stack);
   if(Cprogram.p != NULL)X__Free(Cprogram.p);
   if(C_Subs != NULL && n_Subroutines > 0){
     for(i=0;i<n_Subroutines;i++){
       if(C_Subs[i].p != NULL)X__Free(C_Subs[i].p);
     }
     X__Free(C_Subs);
   }
   C_Subs=NULL; Cprogram.p=NULL;
   Vstop=Nvert; VP=Vstart; while(VP < Nvert){
     (MainVp+VP)->xyz[1] += rand()%4-2;  /* NB this helps fools the filling */
                                /* which can fail on some cases    */
     VP++;
   }
   if(Vstop == Vstart)ifail=FAIL;
   if(ifail == FAIL)break;
   CreateSkeleton(FirstSp);  sp=MainSp;
   if(j == 32){
     strcpy(MainSp->name,"Space");
   }
   else{
     if(j > 64 && j < 91)sprintf(MainSp->name,"%c%ld-C",j,char_id);
     else                sprintf(MainSp->name,"%c%ld",j,char_id);
   }
   MainSp->xyz[0]=NpointerX-Depth/2;
   GetATMholdPoint(&MainSp->xyz[1],&MainSp->xyz[2],Cwidthx,Cwidthy,0);
//   ZeroSkeletonBoundingBox(MainSp);
   CreateSkeleton(MainSp);
   strcpy(MainSp->name,"F.Pt.");
   MainSp->xyz[0]=NpointerX-Depth/2;
   GetATMholdPoint(&MainSp->xyz[1],&MainSp->xyz[2],Cwidthx,Cwidthy,1);
//   ZeroSkeletonBoundingBox(MainSp);
   DeselectVertexSet(Vstart,Vstop);
   Estart=Nedge;
   LastFace=Nface;
   if(j == 32)goto SPACEBREAK;
   if(lpAtm->ATM_cap && !lpAtm->ATM_bevel_front && !lpAtm->ATM_bevel_back){
     capped=1;
     SelectVertexSet(Vstart,Vstop);
     LastFace=Nface;
     if(AutoFacetCurveWithHoles(0,0,1,0.0,0.0) == FAIL)break;
     DeselectVertexSet(Vstart,Vstop);
     fp=LastFace; while(fp < Nface){
       for(i=0;i<3;i++)(MainFp+fp)->color[i]=lpAtm->ATM_face_colour[i];
       fp++;
     }
     LastFace=Nface;
   }
   if(lpAtm->ATM_chara_width > 0){
     SelectVertexSet(Vstart,Vstop);
     BackStart=Nvert; LastFace=Nface;
     if(!CreateAttachedCopy(1))break; /* copy failed */
     BackStop=Nvert;
     DeselectVertexSet(BackStart,BackStop);
     VP=BackStart; while(VP < BackStop){
       (MainVp+VP)->xyz[0] -= Depth;
       VP++;
     }
     fp=LastFace; while(fp < Nface){
       for(i=0;i<3;i++)(MainFp+fp)->color[i]=lpAtm->ATM_side_colour[i];
//       (MainFp+fp)->attrib |= 0x80;
       fp++;
     }
     LastFace=Nface;
   }
   else{BackStart=Vstart; BackStop=Vstop;}
   if((lpAtm->FORB > 0 && lpAtm->ATM_bevel_front) ||
      (lpAtm->FORB < 0 && lpAtm->ATM_bevel_back)){
     SelectVertexSet(Vstart,Vstop);
     fBevelStart=Nvert; LastFace=Nface;
     if(AutoFacetCurveWithHoles(3,0,1,(double)lpAtm->ATM_bevel_angle,
       (double)lpAtm->ATM_bevel_width/2000.0*MaxScale*Scale) == FAIL)break;
     fBevelStop=Nvert;
     fp=LastFace; while(fp < Nface){
       for(i=0;i<3;i++)(MainFp+fp)->color[i]=lpAtm->ATM_beve_colour[i];
//       (MainFp+fp)->attrib |= 0x80;
       fp++;
     }
     LastFace=Nface;
     if(lpAtm->ATM_cap){
       if(AutoFacetCurveWithHoles(0,0,1,0.0,0.0) == FAIL)break;
       fp=LastFace; while(fp < Nface){
         for(i=0;i<3;i++)(MainFp+fp)->color[i]=lpAtm->ATM_face_colour[i];
         fp++;
       }
       LastFace=Nface;
     }
     DeselectVertexSet(fBevelStart,fBevelStop);
   }
   else if(lpAtm->ATM_cap && !capped){
     SelectVertexSet(Vstart,Vstop);
     LastFace=Nface;
     if(AutoFacetCurveWithHoles(0,0,1,0.0,0.0) == FAIL)break;
     DeselectVertexSet(Vstart,Vstop);
     fp=LastFace; while(fp < Nface){
       for(i=0;i<3;i++)(MainFp+fp)->color[i]=lpAtm->ATM_face_colour[i];
       fp++;
     }
     LastFace=Nface;
   }
   if((lpAtm->FORB > 0 && lpAtm->ATM_bevel_back) ||
      (lpAtm->FORB < 0 && lpAtm->ATM_bevel_front)){
     SelectVertexSet(BackStart,BackStop);
     fBevelStart=Nvert; LastFace=Nface;
     if(AutoFacetCurveWithHoles(3,0,1,(double)(lpAtm->ATM_bevel_angle * -1),
       (double)lpAtm->ATM_bevel_width/2000.0*MaxScale*Scale) == FAIL)break;
     fBevelStop=Nvert;
     fp=LastFace; while(fp < Nface){
       for(i=0;i<3;i++)(MainFp+fp)->color[i]=lpAtm->ATM_beve_colour[i];
//       (MainFp+fp)->attrib |= 0x80;
       fp++;
     }
     LastFace=Nface;
     if(lpAtm->ATM_cap){
       if(AutoFacetCurveWithHoles(0,0,1,0.0,0.0) == FAIL)break;
       fp=LastFace; while(fp < Nface){
         for(i=0;i<3;i++)(MainFp+fp)->color[i]=lpAtm->ATM_face_colour[i];
         fp++;
       }
       LastFace=Nface;
     }
     DeselectVertexSet(fBevelStart,fBevelStop);
   }
   else if(lpAtm->ATM_cap && !capped){
     SelectVertexSet(BackStart,BackStop);
     LastFace=Nface;
     if(AutoFacetCurveWithHoles(0,0,1,0.0,0.0) == FAIL)break;
     DeselectVertexSet(BackStart,BackStop);
     fp=LastFace; while(fp < Nface){
       for(i=0;i<3;i++)(MainFp+fp)->color[i]=lpAtm->ATM_face_colour[i];
       fp++;
     }
     LastFace=Nface;
   }
   SPACEBREAK:
   VP=Vstart; while(VP < Nvert){
     (MainVp+VP)->sp=sp;
     VP++;
   }
   DrawModel();
 }
 SelectVertexSet(Vfirst,Nvert);
 NpointerX=Opx; NpointerY=Opy; NpointerZ=Opz;
//DrawModel();
 return;
}

static void GetATMholdPoint(long *x, long *y, long cx, long cy, short pt){
  long x0,y0;
  double offx[]={0.0,0.5,1.0,  0.5,  0.0  ,0.5,  1.0};
  double offy[]={0.0,0.0,0.0,300.0,600.0,600.0,600.0};
  x0=NpointerY-cx*lpAtm->FORB;
  y0=NpointerZ-cy;
  if(pt == 0){
   *x=x0+(long)(offx[lpAtm->ATM_offset]*(double)cx)*lpAtm->FORB;
   *y=y0+(long)(offy[lpAtm->ATM_offset]*Scale);
  }
  else{ /* follow point */
   *x=x0+(long)((offx[lpAtm->ATM_offset]+1.0)*(double)cx)*lpAtm->FORB;
   *y=y0+(long)(offy[lpAtm->ATM_offset]*Scale+(double)cy);
  }
}


static void process_type1_routine(character_program Cp){
  int i,com,sid,last_line=0;
  long u,v,w,x,y,z;
  for(i=0;i<Cp.n;i++){
    com=(int)Cp.p[i].i;
    if(Cp.p[i].com == 0)type1_stack[SP++] = com;
    else{
      switch(com){
        case 1:  /* hstem */          SP=0; break;     /* ignored */
        case 3:  /* vstem */          SP=0; break;     /* ignored */
        case 4:  /* vmoveto */
          x = 0; y = (long)type1_stack[SP-1];
          goto MOVEJUMP;
        case 5:  /* rlineto */
          x = (long)type1_stack[SP-2];
          y = (long)type1_stack[SP-1];
          LINEJUMP:
          last_line=1;
          if(VP < 0){
            UpdateVertexHeap(Nvert+1);
            CreateVertex();
            (MainVp+Nvert-1)->xyz[1]=XX;
            (MainVp+Nvert-1)->xyz[2]=YY;
            (MainVp+Nvert-1)->xyz[0]=NpointerX;
            VP=VF=Nvert-1;
          }
          UpdateVertexHeap(Nvert+1);
          CreateVertex(); /* add midpoint vertex to prevent 3 sided holes! */
          UpdateEdgeHeap(Nedge+1);
          CreateEdge(VP,Nvert-1);
          (MainVp+Nvert-1)->xyz[1]=XX+x*Scale/2*lpAtm->FORB;
          (MainVp+Nvert-1)->xyz[2]=YY+y*Scale/2;
          (MainVp+Nvert-1)->xyz[0]=NpointerX;
          VP=Nvert-1;
          XX += x*Scale*lpAtm->FORB;  YY += y*Scale;
          if(VF >= 0 && (MainVp+VF)->xyz[1] == XX
                     && (MainVp+VF)->xyz[2] == YY){
            UpdateEdgeHeap(Nedge+1);
            CreateEdge(VP,VF);
            VP=VF;
          }
          else{
            UpdateVertexHeap(Nvert+1);
            CreateVertex(); /* vertex at end of straight edge segment */
            UpdateEdgeHeap(Nedge+1);
            CreateEdge(VP,Nvert-1);
            (MainVp+Nvert-1)->xyz[1]=XX;
            (MainVp+Nvert-1)->xyz[2]=YY;
            (MainVp+Nvert-1)->xyz[0]=NpointerX;
            VP=Nvert-1;
          }
          SP=0; break;
        case 6:  /* hlineto */
          y = 0; x = (long)type1_stack[SP-1];
          goto LINEJUMP;
        case 7:  /* vlineto */
          x = 0; y = (long)type1_stack[SP-1];
          goto LINEJUMP;
        case 8:  /* rrcurveto */
          u = (long)type1_stack[SP-6];
          v = (long)type1_stack[SP-5];
          w = (long)type1_stack[SP-4];
          x = (long)type1_stack[SP-3];
          y = (long)type1_stack[SP-2];
          z = (long)type1_stack[SP-1];
          CURVEJUMP:
          last_line=0;
          if(VP < 0){
            UpdateVertexHeap(Nvert+1);
            CreateVertex();
            (MainVp+Nvert-1)->xyz[1]=XX;
            (MainVp+Nvert-1)->xyz[2]=YY;
            (MainVp+Nvert-1)->xyz[0]=NpointerX;
            VP=VF=Nvert-1;
          }
          PP[0][0]=XX; PP[0][1]=YY; PP[0][2]=0;
          XX += u*Scale*lpAtm->FORB; YY += v*Scale;
          PP[1][0]=XX; PP[1][1]=YY; PP[1][2]=0;
          XX += w*Scale*lpAtm->FORB; YY += x*Scale;
          PP[2][0]=XX; PP[2][1]=YY; PP[2][2]=0;
          XX += y*Scale*lpAtm->FORB; YY += z*Scale;
          PP[3][0]=XX; PP[3][1]=YY; PP[3][2]=0;
          VP=CurveUpto(VP,PP,MaxScale*Scale,Nmax);
          SP=0; break;
        case 9:  /* closepath */
          if(VF == VP){ /* path already closed */
            VF=VP=-1;
            break;
          }
          if(VF >= 0 && VP >= 0){
            if(last_line){/* if last segment was a line add a mid point */
              UpdateVertexHeap(Nvert+1);
              CreateVertex();
              (MainVp+Nvert-1)->xyz[1]=((MainVp+VP)->xyz[1]+(MainVp+VF)->xyz[1])/2;
              (MainVp+Nvert-1)->xyz[2]=((MainVp+VP)->xyz[2]+(MainVp+VF)->xyz[2])/2;
              (MainVp+Nvert-1)->xyz[0]=NpointerX;
              UpdateEdgeHeap(Nedge+1);
              CreateEdge(VP,Nvert-1);
              VP=Nvert-1;
            }
            UpdateEdgeHeap(Nedge+1);
            CreateEdge(VP,VF);
          }
          VF=VP= -1;
          SP=0; break;
        case 10: /* callsubr */
          /* if other subs return -1 then sub is invalid and not called */
          sid=type1_stack[SP-1];
          SP=0;
          if(sid >= 0 && sid < n_Subroutines)
             process_type1_routine(C_Subs[sid]);
          break;
        case 11: /* return */
          SP=0; return;
        case 13: /* hsbw */
          XX = NpointerY+(long)type1_stack[SP-2]*Scale*lpAtm->FORB;
          Cwidthx=(long)type1_stack[SP-1]*Scale;
          SP=0; break;
        case 14: /* endchar */
          SP=0; break;  /* this should be the last command anyway */
        case 21: /* rmoveto */
          x = (long)type1_stack[SP-2];
          y = (long)type1_stack[SP-1];
          MOVEJUMP:
          last_line=0;
          XX += x*Scale*lpAtm->FORB; YY += y*Scale;
          SP=0; break;
        case 22: /* hmoveto */
          y = 0; x = (long)type1_stack[SP-1];
          goto MOVEJUMP;
        case 30: /* vhcurveto */
          u = 0;
          v = (long)type1_stack[SP-4];
          w = (long)type1_stack[SP-3];
          x = (long)type1_stack[SP-2];
          y = (long)type1_stack[SP-1];
          z = 0;
          goto CURVEJUMP;
        case 31: /* hvcurveto */
          u = (long)type1_stack[SP-4];
          v = 0;
          w = (long)type1_stack[SP-3];
          x = (long)type1_stack[SP-2];
          y = 0;
          z = (long)type1_stack[SP-1];
          goto CURVEJUMP;
        case 12:
          i++; com=Cp.p[i].i; /* assume that it is a command */
          switch (com) {
            case 0:  /* dotsection */   SP=0; break;
            case 1:  /* vstem3 */       SP=0; break;
            case 2:  /* hstem3 */       SP=0; break;
            case 6:  /* seac */
              SP=0; break;      /* not implemented */
            case 7:  /* sbw */
              XX = NpointerX+(long)type1_stack[SP-4]*Scale*lpAtm->FORB;
              YY = NpointerY+(long)type1_stack[SP-3]*Scale;
              Cwidthx=(long)type1_stack[SP-2]*Scale;
              Cwidthy=(long)type1_stack[SP-1]*Scale;
              SP=0; break;
            case 12: /* div */
              x = (long)type1_stack[SP-2];
              y = (long)type1_stack[SP-1];
              SP -= 1;
              type1_stack[SP-1] = (int)((double)x/(double)y);
              break;
            case 16: /* callothersubr */
              SP=0; break;  /* ignore other sub calls for 3D work; */
            case 17: /* pop  is only used for other subs which we ignore  */
              type1_stack[SP++] = -1; /* push a dummy variable onto stack */
              break;
            case 33: /* setcurrentpoint */
              SP=0; break; /* ignore this it is used with Other subs      */
            default:  SP=0; break;
          }
          break;
        default: SP=0; break;
      }
    }
  }
}

static long CurveUpto(long vp, point *p, double d, long n){
 long i,j,N;
 double l=0,mu;
 point po;
 for(i=0;i<3;i++)for(j=0;j<2;j++){
   l += ((double)(p[i+1][j] - p[i][j]))*(double)((p[i+1][j] - p[i][j]));
 }
 N=(long)((sqrt(l)/d)*(double)n);
 N=max(N,4);
 UpdateVertexHeap(Nvert+N+1);
 UpdateEdgeHeap(Nedge+N+1);
 for(i=1;i<=N;i++){
   mu=(double)i/(double)N;
   Casteljau2(po,p,0,3,mu);
   if(i == N && VF >= 0 && po[0] == (MainVp+VF)->xyz[1]
                        && po[1] == (MainVp+VF)->xyz[2]){
     ; /* do nothing clospath will fill it */
   }
   else{ /* last vertex not coincident with start of path */
     CreateVertex();
     CreateEdge(vp,Nvert-1);
     vp=Nvert-1;
     (MainVp+Nvert-1)->xyz[1]=po[0];
     (MainVp+Nvert-1)->xyz[2]=po[1];
     (MainVp+Nvert-1)->xyz[0]=NpointerX;
   }
 }
 UpdateVertexHeap(Nvert);
 UpdateEdgeHeap(Nedge);
 return Nvert-1;
}