DRAWVIEW.C

Go to the documentation of this file.

/* file drawview.c  */

#define MODULE_DRAW 1

#include "animate.h"

static void GetInternalMotion(align *Ap, long frame, double dframe,
                              short *im, double *ima);
static double GetFollowOnOffset(node *Np, long frame, double dframe,
                                point Offset);
static int CheckInterrupt(void);
static void CalculateOffset(node *Np,long frame, double dframe, point dp, double sx,
                            double sy, double sz);
static void CalculateSize(node *Np, long frame, double dframe,
                          double *sx, double *sy, double *sz);
static void DrawLightCone(HDC hdc[], short status, node *Np,
                          short al_type, point Offset, point TrackedOffset,
                          double p, double t, double a,
                          short im, double ima, double cone,
                          double edge);
static void DrawLightExtent(HDC hdc[], short status, node *Np,
                          short al_type, point Offset,
                          double sz);
static void DrawCameraFOV(HDC hdc[],
                          short status, node *Np, short al_type,
                          point Offset, point TrackedOffset,
                          double p, double t, double a,
                          short im, double ima,
                          double sx, double sy, double sz);
static short DrawQuickObject(HDC hdc[], object *Op, point Offset
                   , double p, double t, double a
                   , short im, double ima
                   , double sx, double sy, double sz, short status);
static short DrawNurbsObject(HDC hdc[], object *Op, point Offset
                   , double p, double t, double a
                   , short im, double ima
                   , double sx, double sy, double sz, short status);
static void DrawAxis(HDC hdc[], point v1, short status);
static int OnModelEdge(int npx, int npy,
                       int sh1, int sv1, int sh2, int sv2,
                       point v1, point v2,
                       double *dc);

static int zoom_abort=NO;
static int order_list[3][3]={ {0,1,2},{1,2,0},{2,0,1} };

static int CheckInterrupt(void){
 int i;
 MSG msg;
 if(do_NOT_abort)return 0;
 if(tool_move_flag){
//MessageBeep(MB_OK);
   zoom_abort=1;
 }
 else zoom_abort=0;
 return zoom_abort;
}

void ScalePoint(double scalex, double scaley, double scalez,
                point p, point r){
  r[0] = (long)(scalex*(double)p[0]);
  r[1] = (long)(scaley*(double)p[1]);
  r[2] = (long)(scalez*(double)p[2]);
}

void CopyPoint(point p1, point p2){
 p2[0]=p1[0]; p2[1]=p1[1]; p2[2]=p1[2];
}

void AddPoints(point p1, point p2, point result){
 result[0]=p1[0]+p2[0];
 result[1]=p1[1]+p2[1];
 result[2]=p1[2]+p2[2];
}

void SubPoints(point p1, point p2, point result){
 result[0]=p1[0]-p2[0];
 result[1]=p1[1]-p2[1];
 result[2]=p1[2]-p2[2];
}

short in_stage_triview(point vp){
 if( ((vp[0] > TVpointX) && (vp[0] < TVpointX+TVsizeX))
  && ((vp[1] > TVpointY) && (vp[1] < TVpointY+TVsizeY))
  && ((vp[2] > TVpointZ) && (vp[2] < TVpointZ+TVsizeZ))
   )return 1;
 return 0;
}

static short ep1[12]={0,1,2,3,4,5,6,7,0,1,2,3};
static short ep2[12]={1,2,3,0,5,6,7,4,4,5,6,7};
static point Pointer[6]={{  0,  0,  0}
                        ,{  0, 20,  0}
                        ,{  0, 30,  0}
                        ,{  3, 20,  0}
                        ,{ -3, 20,  0}
                        ,{  0,  0, 10}};
static short pp1[5]={0,2,2,3,0};
static short pp2[5]={1,3,4,4,5};
static point Rectang[4]={{  0,  0,  0}
                        ,{ UNIT*4,  0,  0}
                        ,{ UNIT*4,-UNIT*4,  0}
                        ,{  0,-UNIT*4,  0}};
static short rp1[4]={0,1,2,3};
static short rp2[4]={1,2,3,0};
static point trpoints[13],srpoints[10];

void get_centre_stage(point p, point TVp, point TVclipMin, point TVclipMax){
 node *Np;
 object *Op;
 pathpoint *Pp;
 point  Offset,TrackedOffset;
 short im;
 double phi,theta,alpha,sx,sy,sz,ima;
 long i,xmin,xmax,ymin,ymax,zmin,zmax,d;
 xmin=ymin=zmin=MAXUNIT; xmax=ymax=zmax = -MAXUNIT;
 for(i=0;i<3;i++)TVclipMin[i]=TVclipMax[i]=0;
 if((Np=FirstNp) != NULL)while(Np != NULL){
   if((Op=Np->fobj) != NULL)while(Op != NULL){
     if((CurrentFrame >= Op->firstframe) && (CurrentFrame <= Op->lastframe)){
       GetTransform(0,CurrentFrame,1.0,Np,Op,Offset,TrackedOffset,&phi,&theta,&alpha,
                    &sx,&sy,&sz,&im,&ima);
       if(Op->type == NORMAL || Op->type == ANIMOBJ){
         for(i=0;i<8;i++){
           srpoints[i][0] = (long)((double)Op->outline[i][0])*sx;
           srpoints[i][1] = (long)((double)Op->outline[i][1])*sy;
           srpoints[i][2] = (long)((double)Op->outline[i][2])*sz;
         }
         Transform(8,srpoints,trpoints,Offset,phi,theta,alpha,im,ima);
         for(i=0;i<8;i++){
           if(trpoints[i][0] < xmin)xmin=trpoints[i][0];
           if(trpoints[i][0] > xmax)xmax=trpoints[i][0];
           if(trpoints[i][1] < ymin)ymin=trpoints[i][1];
           if(trpoints[i][1] > ymax)ymax=trpoints[i][1];
           if(trpoints[i][2] < zmin)zmin=trpoints[i][2];
           if(trpoints[i][2] > zmax)zmax=trpoints[i][2];
         }
       }
       else if(Op->type == ROBOT){
         if(Op->nskeleton > 0 && Op->skeleton != NULL){
           double t1[4][4],x,y,z;
           RobotTransform(Offset,phi,theta,alpha,sx,sy,sz,im,ima,t1);
           for(i=0;i<Op->nskeleton;i++){
             m4by1(t1,(double)(Op->skeleton+i)->p[0],
                      (double)(Op->skeleton+i)->p[1],
                      (double)(Op->skeleton+i)->p[2],&x,&y,&z);
             if(x < xmin)xmin=x;
             if(y > xmax)xmax=y;
             if(z < ymin)ymin=z;
             if(x > ymax)ymax=x;
             if(y < zmin)zmin=y;
             if(z > zmax)zmax=z;
           }
         }
       }
       else if(Op->type == PATH){
         Pp=Op->firstpathpoint; while(Pp != NULL){
            CopyPoint(Pp->p,srpoints[0]);
            Transform(1,srpoints,trpoints,Offset,phi,theta,alpha,im,ima);
            if(trpoints[0][0] < xmin)xmin=trpoints[0][0];
            if(trpoints[0][0] > xmax)xmax=trpoints[0][0];
            if(trpoints[0][1] < ymin)ymin=trpoints[0][1];
            if(trpoints[0][1] > ymax)ymax=trpoints[0][1];
            if(trpoints[0][2] < zmin)zmin=trpoints[0][2];
            if(trpoints[0][2] > zmax)zmax=trpoints[0][2];
            Pp=Pp->next;
         }
       }
       else{
         if(Offset[0] < xmin)xmin=Offset[0];
         if(Offset[0] > xmax)xmax=Offset[0];
         if(Offset[1] < ymin)ymin=Offset[1];
         if(Offset[1] > ymax)ymax=Offset[1];
         if(Offset[2] < zmin)zmin=Offset[2];
         if(Offset[2] > zmax)zmax=Offset[2];
       }
     }
     Op=Op->next;
   }
   Np=Np->next;
 }
 p[0]=(xmax+xmin)/2; p[1]=(ymax+ymin)/2; p[2]=(zmax+zmin)/2;
 d=max(labs(xmax-xmin),labs(ymax-ymin)); d=max(d,labs(zmax-zmin));
 TVclipMin[0]=xmin;TVclipMin[1]=ymin;TVclipMin[2]=zmin;
 TVclipMax[0]=xmax;TVclipMax[1]=ymax;TVclipMax[2]=zmax;
 d=max(d,UNIT); d=min(d,MAXUNIT); d = d+d*0.3; d /= 2;
 TVp[0]=p[0]-d; TVp[1]=p[1]-d; TVp[2]=p[2]-d;
}

void Transform(long n ,point Ain[], point Aout[], point Offset,
               double p, double t, double a, short im, double ima){
 long i;
 double tr1[4][4],tr2[4][4],tr3[4][4],trpos[4][4],x,y,z;
 if(im > 0){
   if     (im == 1)rotz(tr1,ima*PIo180);
   else if(im == 2)rotx(tr1,ima*PIo180);
   else if(im == 3)roty(tr1,ima*PIo180);
   roty(tr3,t*PI/180.0);
   m4by4(tr3,tr1,tr2);
 }
 else roty(tr2,t*PIo180);
 rotx(tr3,a*PIo180);
 m4by4(tr3,tr2,tr1);
 rotz(tr2,p*PIo180);
 m4by4(tr2,tr1,trpos);
 for(i=0;i<n;i++){
  m4by1(trpos,(double)Ain[i][0],(double)Ain[i][1],(double)Ain[i][2],&x,&y,&z);
  Aout[i][0]=(long)x;  Aout[i][1]=(long)y;  Aout[i][2]=(long)z;
  AddPoints(Aout[i],Offset,Aout[i]);
 }
}

static void GetInternalMotion(align *Ap, long frame, double dframe,
                              short *im, double *ima){
 double ratio,dp;
 *im = Ap->im;
 if(Ap->firstframe == Ap->lastframe){
   *ima=0.0;
 }
 else{
   ratio=((double)frame+dframe  - (double)Ap->firstframe)
        /(double)(Ap->lastframe+1 - Ap->firstframe);
   dp = 360.0*ratio*Ap->ima ;    /* ima is +1 for anti clock one turn */
   if(dp < -180.0)dp += 360.0;
   if(dp >  180.0)dp -= 360.0;
   *ima = dp;
 }
}

void CalculateDirection(point C, point T, double * phi,
                        double * theta, double * alpha){
 double dx,dy,dz,dxy;
 *phi=0; *theta=0; *alpha=0;
 dx=(double)(T[0]-C[0]);
 dy=(double)(T[1]-C[1]);
 dz=(double)(T[2]-C[2]);
 dxy=sqrt(dx*dx+dy*dy);
 if(dxy < 1.0e-10)return;
 *phi=asin(dy/dxy);
 if(dx < 0.0){*phi = PI - *phi;  if(*phi > PI) *phi = *phi-2*PI;}
 *alpha=asin(dz/sqrt(dx*dx+dy*dy+dz*dz));
 *phi   *= 180.0/PI;
 *phi   -=  90.0;
 *alpha *= 180.0/PI;
 return;
}

static void CalculateOffset(node *Np,long frame, double dframe,
                            point dp, double sx,
                            double sy, double sz){ /* get object offset */
 object *Op;
 double mr;
 dp[0]=dp[1]=dp[2]=0;
 if((Op=Np->fobj) != NULL)while(Op != NULL){
   if((frame >= Op->firstframe) && (frame <= Op->lastframe)){
     if(Op->morph != NO && Op->last != NULL){
       mr=(double)(Op->lastframe - Op->firstframe+1);
       mr=((double)frame + dframe - (double)Op->firstframe)/mr;
       dp[0] = (long)((double)(Op->offset[0] -
              Op->last->offset[0])*mr + Op->last->offset[0])*sx;
       dp[1] = (long)((double)(Op->offset[1] -
              Op->last->offset[1])*mr + Op->last->offset[1])*sy;
       dp[2] = (long)((double)(Op->offset[2] -
              Op->last->offset[2])*mr + Op->last->offset[2])*sz;
     }
     else{
       dp[0] = (long)(Op->offset[0] * sx);
       dp[1] = (long)(Op->offset[1] * sy);
       dp[2] = (long)(Op->offset[2] * sz);
     }
     return;
   }
   Op=Op->next;
 }
}

static void CalculateSize(node *Np, long frame, double dframe,
                          double *sx, double *sy, double *sz){
 size *Xp;
 double lsx,lsy,lsz,nsx,nsy,nsz,ratio;
 double kx[4],ky[4],kz[4];
 if((Xp=Np->fsiz) != NULL)while(Xp != NULL){
  if(frame >= Xp->firstframe && frame <= Xp->lastframe){
    if(Xp->last == NULL){
       *sx=Xp->Sx; *sy=Xp->Sy; *sz=Xp->Sz;
    }
    else{  /* interpolate size by spline tweening */
      ratio=((double)frame+dframe - (double)Xp->firstframe)
           /(double)(Xp->lastframe+1 - Xp->firstframe);
       if(Xp->last->last == NULL ||
        (Xp->last->lastframe - Xp->last->firstframe) == 0){
        lsx = lsy = lsz = 0.0;
      }
      else{
        lsx=Xp->last->Sx - Xp->last->last->Sx;
        lsy=Xp->last->Sy - Xp->last->last->Sy;
        lsz=Xp->last->Sz - Xp->last->last->Sz;
      }
      if(Xp->next == NULL ||
        (Xp->next->lastframe - Xp->next->firstframe) == 0){
        nsx = nsy = nsz = 0.0;
      }
      else{
        nsx=Xp->next->Sx - Xp->Sx;
        nsy=Xp->next->Sy - Xp->Sy;
        nsz=Xp->next->Sz - Xp->Sz;
      }
      SplinesG(kx,Xp->last->Sx,Xp->Sx,lsx,nsx);
      SplinesG(ky,Xp->last->Sy,Xp->Sy,lsy,nsy);
      SplinesG(kz,Xp->last->Sz,Xp->Sz,lsz,nsz);
      *sx = SplinesR(kx,ratio);
      *sy = SplinesR(ky,ratio);
      *sz = SplinesR(kz,ratio);
    }
    break;
  }
  Xp=Xp->next;
 }
}

cameraparam *CalculateCameraProperties(node *Np, long frame, double dframe){
  // These are extracted from the Camera objects Scale object
 size *Xp;
 static cameraparam cc;  // this will retain its value after function returns
 double ratio; 
 if((Xp=Np->fsiz) != NULL)while(Xp != NULL){
  if(frame >= Xp->firstframe && frame <= Xp->lastframe){
    if(Xp->last == NULL){
      return &(Xp->camera_params);
    }
    else{  /* interpolate parameters */
      ratio=((double)frame+dframe - (double)Xp->firstframe)
           /(double)(Xp->lastframe+1 - Xp->firstframe);
      memcpy(&cc,&(Xp->camera_params),sizeof(cameraparam));
      cc.f_number=(Xp->camera_params.f_number - Xp->last->camera_params.f_number)*ratio + Xp->last->camera_params.f_number;
      cc.focal_length=(Xp->camera_params.focal_length - Xp->last->camera_params.focal_length)*ratio + Xp->last->camera_params.focal_length;
      cc.focus_distance=(Xp->camera_params.focus_distance - Xp->last->camera_params.focus_distance)*ratio + Xp->last->camera_params.focus_distance;
      cc.stereo_separation=(Xp->camera_params.stereo_separation - Xp->last->camera_params.stereo_separation)*ratio + Xp->last->camera_params.stereo_separation;
      cc.parallax_distance=(Xp->camera_params.parallax_distance - Xp->last->camera_params.parallax_distance)*ratio + Xp->last->camera_params.parallax_distance;
      //return &(Xp->camera_params);
      return &(cc);
    }
  }
  Xp=Xp->next;
 }
 return NULL;
}



static double GetFollowOnOffset(node *Np, long frame, double dframe,
                                point Offset){
 position *Pp;
 object   *Op;
 node     *Npo,*Npi;
 point p,RelativeOffset;
 long follow_count=0;
 double sx=1.0,sy=1.0,sz=1.0,displacement=0.0,ratio = -1.0,length_on_path;
 Offset[0]=Offset[1]=Offset[2]=0; Npi=Np;
 while(Np != NULL){
   if(follow_count++ > 64){
     SendPrgmQuery(IDQ_SELFFOLLOW1,0);
     SendPrgmQuery(IDQ_SELFFOLLOW2,0);
     Pp=Npi->fpos;
     if(Pp != NULL)while(Pp != NULL){
       Pp->type=TWEEN;
       Pp=Pp->next;
     }
     return 0.0;
   }
   Pp=Np->fpos; Npo=Np; Np=NULL;
   if(Pp != NULL)while(Pp != NULL){
     if((frame >= Pp->firstframe) && (frame <= Pp->lastframe)){
       if(Pp->type == FOLLOWON){
         CalculateSize(Npo,frame,dframe,&sx,&sy,&sz);
         CalculateOffset(Npo,frame,dframe,p,sx,sy,sz);
         displacement += p[1]; /* forwards displacement */
         Np=Pp->onpath;        /* on to next box car */
         break;  /* break out of while Pp */
       }
       else if(Pp->type == FOLLOW && Pp->onpath != NULL &&
               Pp->onpath->type == PATH){
         CalculateSize(Npo,frame,dframe,&sx,&sy,&sz);
         CalculateOffset(Npo,frame,dframe,p,sx,sy,sz);
         displacement += p[1]; /* forwards displacement */
         ratio = -1.0;
         if((Op=GetPathPosition(Pp->onpath,frame,dframe,RelativeOffset,
                                &ratio,&length_on_path)) != NULL){
           length_on_path += displacement;
           if(length_on_path > 0.0){
             if(length_on_path >= Op->pathlength){
               if(Op->pathtype == CLOSED){
                 ratio = (length_on_path-Op->pathlength)/Op->pathlength;
               }
               else ratio = 0.99;
             }
             else ratio = length_on_path/Op->pathlength;
           }
           else if(Op->pathtype == CLOSED){ /* lop < 0 */
             ratio = (Op->pathlength+length_on_path)/Op->pathlength;
           }
           else ratio = 0.0; // possibly not finished
           if(ratio >= 0.0){
             if((Op=GetPathPosition(Pp->onpath,frame,dframe,RelativeOffset,
                                  &ratio,&length_on_path)) != NULL){
               AddPoints(Offset,RelativeOffset,Offset);
               GetOffsetPosition(Pp->onpath,Op,frame,dframe,Offset);
             }
           }
         }
       }
       /* any other type will keep Np = NULL and terminate */
     }
     Pp=Pp->next;
   }
 }
 return ratio;
}

double GetOffsetPosition(node *Np, object *Op,
                         long frame, double dframe,
                         point ObjectOffset){
  position *Pp;
  point dp,RelativeOffset,TrackedOffset,spl,spn,ofs;
  double ratio,kx[4],ky[4],kz[4],rp,ra,rt,rsx,rsy,rsz,rima,
         length_on_path,gs,ge;
  short rim;
  stackdepth++;
  ratio=0.0;
  if(Np == NULL)return(0.0);
  if(stackdepth > 64)longjmp(r_buf,-1);
  if((Pp=Np->fpos) != NULL)while(Pp != NULL){
   if((frame >= Pp->firstframe) && (frame <= Pp->lastframe)){
     if(Pp->type == TWEEN){
       if((Pp->last == NULL)) // || (Pp->firstframe == Pp->lastframe))
         AddPoints(ObjectOffset,Pp->finish,ObjectOffset);
       else{
         ratio=((double)frame+dframe - (double)Pp->firstframe)
              /(double)(Pp->lastframe+1 - Pp->firstframe);
         SubPoints(Pp->finish,Pp->last->finish,dp);
         ScalePoint(ratio,ratio,ratio,dp,dp);
         AddPoints(Pp->last->finish,dp,dp);
         AddPoints(ObjectOffset,dp,ObjectOffset);
       }
     }
     else if(Pp->type == FOLLOW || Pp->type == FOLLOWAT){
       if(Pp->type == FOLLOWAT)CopyPoint(ObjectOffset,ofs);
       if(Pp->onpath->type == PATH){/* if on path get offset rel to path */
         ratio = -1.0;
         if(GetPathPosition(Pp->onpath,frame,dframe,RelativeOffset,&ratio,
                            &length_on_path) != NULL){/* path has been found OK */
           AddPoints(ObjectOffset,RelativeOffset,ObjectOffset);
           GetOffsetPosition(Pp->onpath,Op,frame,dframe,ObjectOffset);
         }
       }
       else ratio=GetOffsetPosition(Pp->onpath,Op,frame,dframe,ObjectOffset);
       if(Pp->type == FOLLOWAT){
         if((Pp->last == NULL)){  // || (Pp->firstframe == Pp->lastframe)){
          if((!Pp->fx))ObjectOffset[0]=ofs[0]+Pp->finish[0];
          if((!Pp->fy))ObjectOffset[1]=ofs[1]+Pp->finish[1];
          if((!Pp->fz))ObjectOffset[2]=ofs[2]+Pp->finish[2];
         }
         else{
           ratio=((double)frame+dframe - (double)Pp->firstframe)
                /(double)(Pp->lastframe+1 - Pp->firstframe);
           SubPoints(Pp->finish,Pp->last->finish,dp);
           ScalePoint(ratio,ratio,ratio,dp,dp);
           AddPoints(Pp->last->finish,dp,dp);
           if(!(Pp->fx))ObjectOffset[0]=ofs[0]+dp[0];
           if(!(Pp->fy))ObjectOffset[1]=ofs[1]+dp[1];
           if(!(Pp->fz))ObjectOffset[2]=ofs[2]+dp[2];
         }
       }
     }
     else if(Pp->type == FOLLOWOFF){
       GetTransform(1,frame,dframe,
                    Pp->onpath,NULL,ObjectOffset,TrackedOffset,
                    &rp,&rt,&ra,&rsx,&rsy,&rsz,&rim,&rima);
       CalculateOffset(Pp->onpath,frame,dframe,trpoints[0],rsx,rsy,rsz);
       Transform(1,trpoints,srpoints,ObjectOffset,rp,rt,ra,rim,rima);
       CopyPoint(srpoints[0],ObjectOffset);
     }
     else if(Pp->type == FOLLOWON){
       ratio=GetFollowOnOffset(Pp->onpath,frame,dframe,ObjectOffset);
     }
     else if(Pp->type == SPLINE){
       if((Pp->last == NULL))// || (Pp->firstframe == Pp->lastframe))
         AddPoints(ObjectOffset,Pp->finish,ObjectOffset);
       else{
         ratio=((double)frame+dframe - (double)Pp->firstframe)
              /(double)(Pp->lastframe+1 - Pp->firstframe);
         if(Pp->last->last != NULL)CopyPoint(Pp->last->last->finish,spl);
         else{
           SubPoints(Pp->finish,Pp->last->finish,dp);
           SubPoints(Pp->last->finish,dp,spl);
         }
         if(Pp->next != NULL)CopyPoint(Pp->next->finish,spn);
         else{
           SubPoints(Pp->finish,Pp->last->finish,dp);
           AddPoints(Pp->finish,dp,spn);
         }
//         SplinesK(kx,spl[0],Pp->last->finish[0],Pp->finish[0],spn[0]);
//         SplinesK(ky,spl[1],Pp->last->finish[1],Pp->finish[1],spn[1]);
//         SplinesK(kz,spl[2],Pp->last->finish[2],Pp->finish[2],spn[2]);
         gs=(double)(Pp->finish[0]-spl[0])*Pp->tension_s;
         ge=(double)(spn[0]-Pp->last->finish[0])*Pp->tension_e;
         SplinesG(kx,Pp->last->finish[0],Pp->finish[0],gs,ge);
         gs=(double)(Pp->finish[1]-spl[1])*Pp->tension_s;
         ge=(double)(spn[1]-Pp->last->finish[1])*Pp->tension_e;
         SplinesG(ky,Pp->last->finish[1],Pp->finish[1],gs,ge);
         gs=(double)(Pp->finish[2]-spl[2])*Pp->tension_s;
         ge=(double)(spn[2]-Pp->last->finish[2])*Pp->tension_e;
         SplinesG(kz,Pp->last->finish[2],Pp->finish[2],gs,ge);
         ObjectOffset[0] += SplinesP(kx,ratio);
         ObjectOffset[1] += SplinesP(ky,ratio);
         ObjectOffset[2] += SplinesP(kz,ratio);
       }
     }
   }
   Pp=Pp->next;
  }
  return ratio;
}

short GetTransform(short stacking, long frame, double dframe,
             node *Np, object *Op,
             point ObjectOffset, point TrackedOffset,
             double *phi, double *theta, double *alpha,
             double *sx,  double *sy,    double *sz,
             short *im, double *ima){
/* the returned values of phi theta and alpha are the rotations for
   the object about the vertical axis the object direction axis
   and the horizontal axis perp. to the direction. To draw the object
   I apply the theta rotation first then the alpha rotation and
   finally the phi rotation.  The offset translation is then applied
   to the object
   Rotation is +ve in the anticlockwise direction.
   THETA is around Y ie. from rear looking forwards
   ALPHA is around X ie. up down
   PHI   is around Z ie. rotation in plane
   returns type of alignment
 */
   point TrackedDummy,TrackedOrigin;
   align *Ap;
   size  *Xp;
   short rim;
   double dp,dpl,dpn,ratio,rsx,rsy,rsz,rima,length_on_path;
   double kx[4],ky[4],kz[4];
   long f,ddt;
   if(Np == NULL)return TWEEN;
   ObjectOffset[0]=0;  ObjectOffset[1]=0;  ObjectOffset[2]=0;
   TrackedOffset[0]=0; TrackedOffset[1]=0; TrackedOffset[2]=0;
   *phi=0; *theta=0; *alpha=0;
   if(Np->type == LIGHT){*sx=15.0; *sy=5.0;}
   else                 {*sx=1.0;  *sy=1.0;}
   *sz=1.0; *im=0; *ima=0.0;
   if(stacking == 0)stackdepth=0;/* set the stack count to the top of stack */
   if(stackdepth > 64)longjmp(r_buf,-1);

   CalculateSize(Np,frame,dframe,sx,sy,sz);

   if((Ap=Np->fali) != NULL){
    while(Ap != NULL){
     if(frame >= Ap->firstframe && frame <= Ap->lastframe){
       GetInternalMotion(Ap,frame,dframe,im,ima);
       if(Ap->type == TRACK ){
         GetOffsetPosition(Ap->topath,Op,frame,dframe,TrackedOffset);
         GetOffsetPosition(Np,Op,frame,dframe,ObjectOffset);
         CalculateDirection(ObjectOffset,TrackedOffset,phi,theta,alpha);
         if((Ap->last == NULL)){// || (Ap->firstframe == Ap->lastframe)){
           *theta = Ap->theta;    /* banking while tracking */
         }
         else{
           ratio=((double)frame+dframe - (double)Ap->firstframe)
                /(double)(Ap->lastframe+1 - Ap->firstframe);
           dp = Ap->theta - Ap->last->theta;
           if(dp < -180.0)dp += 360.0;
           if(dp >  180.0)dp -= 360.0;
           dp *= ratio;
           dp += Ap->last->theta;
           if(dp < -180.0)dp += 360.0;
           if(dp >  180.0)dp -= 360.0;
           *theta = dp;
         }
       }
       else if(Ap->type == COPY){
         stackdepth++;
         GetTransform(1,frame,dframe,
                      Ap->topath,NULL,TrackedOffset,TrackedDummy,/*TO just placer */
                      phi,theta,alpha,&rsx,&rsy,&rsz,&rim,&rima);
         GetOffsetPosition(Np,Op,frame,dframe,ObjectOffset);
       }
       else if(Ap->type == TOPATH){
         ratio=GetOffsetPosition(Np,Op,frame,dframe,ObjectOffset);
         if(Ap->topath->type == PATH && ratio > -1.5){/* offset OK */
           if(GetPathPosition(Ap->topath,frame,dframe,TrackedOrigin,&ratio,
                              &length_on_path) != NULL){ /* some where on path */
             if(ratio < 1.0){ /* not at end of path */
               ratio=min(ratio+0.01,1.0);
               GetPathPosition(Ap->topath,frame,dframe,TrackedOffset,
                               &ratio,&length_on_path);
             }
             else{ /* at end of path interpolate forwards */
               ratio -= 0.1;
               GetPathPosition(Ap->topath,frame,dframe,TrackedOffset,
                               &ratio,&length_on_path);
               SubPoints(TrackedOrigin,TrackedOffset,TrackedOffset);
               AddPoints(TrackedOrigin,TrackedOffset,TrackedOffset);
             }
             CalculateDirection(TrackedOrigin,TrackedOffset,phi,theta,alpha);
           }
           else{*phi=0; *alpha=0; *theta=0;} /* not on a path */
         }
         else{ /* not path to follow */
           *phi=0; *alpha=0; *theta=0;
         }
         if((Ap->last == NULL)){// || (Ap->firstframe == Ap->lastframe)){
           *theta = Ap->theta;    /* banking on path */
         }
         else{
           ratio=((double)frame+dframe - (double)Ap->firstframe)
                /(double)(Ap->lastframe+1 - Ap->firstframe);
           dp = Ap->theta - Ap->last->theta;
           if(dp < -180.0)dp += 360.0;
           if(dp >  180.0)dp -= 360.0;
           dp *= ratio;
           dp += Ap->last->theta;
           if(dp < -180.0)dp += 360.0;
           if(dp >  180.0)dp -= 360.0;
           *theta = dp;
         }
       }
       else if(Ap->type == TWEEN){
         if((Ap->last == NULL)){ // || (Ap->firstframe == Ap->lastframe)){
          *phi=Ap->phi;
          *theta=Ap->theta;
          *alpha=Ap->alpha;
         }
         else{
           ratio=((double)frame+dframe - (double)Ap->firstframe)
                /(double)(Ap->lastframe+1 - Ap->firstframe);
           dp = Ap->phi - Ap->last->phi;
           if(dp < -180.0)dp += 360.0;
           if(dp >  180.0)dp -= 360.0;
           dp *= ratio;
           dp += Ap->last->phi;
           if(dp < -180.0)dp += 360.0;
           if(dp >  180.0)dp -= 360.0;
           *phi = dp;
           dp = Ap->theta - Ap->last->theta;
           if(dp < -180.0)dp += 360.0;
           if(dp >  180.0)dp -= 360.0;
           dp *= ratio;
           dp += Ap->last->theta;
           if(dp < -180.0)dp += 360.0;
           if(dp >  180.0)dp -= 360.0;
           *theta = dp;
           dp = Ap->alpha - Ap->last->alpha;
           if(dp < -180.0)dp += 360.0;
           if(dp >  180.0)dp -= 360.0;
           dp *= ratio;
           dp += Ap->last->alpha;
           if(dp < -180.0)dp += 360.0;
           if(dp >  180.0)dp -= 360.0;
           *alpha = dp;
         }
         GetOffsetPosition(Np,Op,frame,dframe,ObjectOffset);
       }
       else if(Ap->type == SPLINEA){
         if((Ap->last == NULL)){ // || (Ap->firstframe == Ap->lastframe)){
          *phi=Ap->phi;
          *theta=Ap->theta;
          *alpha=Ap->alpha;
         }
         else{
           ratio=((double)frame+dframe - (double)Ap->firstframe)
                /(double)(Ap->lastframe+1 - Ap->firstframe);
           dp = Ap->phi - Ap->last->phi;
           if(dp < -180.0)dp += 360.0;
           if(dp >  180.0)dp -= 360.0;
           if(Ap->last->last == NULL)dpl=0.0;
           else{
             dpl = Ap->last->phi - Ap->last->last->phi;
             if(dpl < -180.0)dpl += 360.0;
             if(dpl >  180.0)dpl -= 360.0;
             ddt = Ap->last->lastframe - Ap->last->firstframe;
             if(ddt == 0)dpl=0.0; /* single frame  zero gradient */
           }
           if(Ap->next == NULL)dpn=0.0;
           else{
             dpn = Ap->next->phi - Ap->phi;
             if(dpn < -180.0)dpn += 360.0;
             if(dpn >  180.0)dpn -= 360.0;
             ddt = Ap->next->lastframe - Ap->next->firstframe;
             if(ddt == 0)dpn=0.0;
           }
           SplinesG(kx,Ap->last->phi,Ap->last->phi+dp,dpl,dpn);
           dp=SplinesR(kx,ratio);
           if(dp < -180.0)dp += 360.0;
           if(dp >  180.0)dp -= 360.0;
           *phi = dp;
           dp = Ap->theta - Ap->last->theta;
           if(dp < -180.0)dp += 360.0;
           if(dp >  180.0)dp -= 360.0;
           if(Ap->last->last == NULL)dpl=0.0;
           else{
             dpl = Ap->last->theta - Ap->last->last->theta;
             if(dpl < -180.0)dpl += 360.0;
             if(dpl >  180.0)dpl -= 360.0;
             ddt = Ap->last->lastframe - Ap->last->firstframe;
             if(ddt == 0)dpl=0.0;
           }
           if(Ap->next == NULL)dpn=0.0;
           else{
             dpn = Ap->next->theta - Ap->theta;
             if(dpn < -180.0)dpn += 360.0;
             if(dpn >  180.0)dpn -= 360.0;
             ddt = Ap->next->lastframe - Ap->next->firstframe;
             if(ddt == 0)dpn=0.0;
           }
           SplinesG(kx,Ap->last->theta,Ap->last->theta+dp,dpl,dpn);
           dp=SplinesR(kx,ratio);
           if(dp < -180.0)dp += 360.0;
           if(dp >  180.0)dp -= 360.0;
           *theta = dp;
           dp = Ap->alpha - Ap->last->alpha;
           if(dp < -180.0)dp += 360.0;
           if(dp >  180.0)dp -= 360.0;
           if(Ap->last->last == NULL)dpl=0.0;
           else{
             dpl = Ap->last->alpha - Ap->last->last->alpha;
             if(dpl < -180.0)dpl += 360.0;
             if(dpl >  180.0)dpl -= 360.0;
             ddt = Ap->last->lastframe - Ap->last->firstframe;
             if(ddt == 0)dpl=0.0;
           }
           if(Ap->next == NULL)dpn=0.0;
           else{
             dpn = Ap->next->alpha - Ap->alpha;
             if(dpn < -180.0)dpn += 360.0;
             if(dpn >  180.0)dpn -= 360.0;
             ddt = Ap->next->lastframe - Ap->next->firstframe;
             if(ddt == 0)dpn=0.0;
           }
           SplinesG(kx,Ap->last->alpha,Ap->last->alpha+dp,dpl,dpn);
           dp=SplinesR(kx,ratio);
           if(dp < -180.0)dp += 360.0;
           if(dp >  180.0)dp -= 360.0;
           *alpha = dp;
         }
         GetOffsetPosition(Np,Op,frame,dframe,ObjectOffset);
       }
       return Ap->type;  /* alignment has been found and calculated */
     }
     Ap=Ap->next;
    }
    GetOffsetPosition(Np,Op,frame,dframe,ObjectOffset); /* no align found */
   }
   else GetOffsetPosition(Np,Op,frame,dframe,ObjectOffset); /* no align   */
   return TWEEN;
}

//
/* draw actors */

void DrawActorCentre(HDC hdc[],point v1, double p, double t, double a,
                     short im, double ima, double scale){
 int sh1,sv1,i;
 int ifd,ild;
 if(View == TRIVIEW){ifd=0;ild=3;}
 else               {ifd=ActiveView; ild=ifd+1;}
 if(in_stage_triview(v1)){
   for(i=ifd;i<ild;i++){
     GetWindowCoords(i,v1[0],v1[1],v1[2],&sh1,&sv1);
     Rectangle(hdc[i],(int)sh1-2,(int)sv1-2,(int)sh1+2,(int)sv1+2);
   }
 }
}

void DrawArrow(HDC hdc[], point Offset, double p, double t, double a,
               short im, double ima, double scale){
 int sh1,sv1,sh2,sv2,i;
 point v1,v2;
 point Lpointer[6];
 short ep;
 double s10;
 int ifd,ild;
 if(View == TRIVIEW){ifd=0;ild=3;}
 else               {ifd=ActiveView; ild=ifd+1;}
 s10=scale/10.0;
 for(i=0;i<6;i++)ScalePoint(s10,s10,s10,Pointer[i],Lpointer[i]);
 Transform(6,Lpointer,trpoints,Offset,p,t,a,im,ima);
 for(ep=0;ep<5;ep++){
   CopyPoint(trpoints[pp1[ep]],v1);
   CopyPoint(trpoints[pp2[ep]],v2);
   if(in_stage_triview(v1) || in_stage_triview(v2)){
     for(i=ifd;i<ild;i++){
       GetWindowCoords(i,v1[0],v1[1],v1[2],&sh1,&sv1);
       GetWindowCoords(i,v2[0],v2[1],v2[2],&sh2,&sv2);
       MoveToEx(hdc[i],sh1,sv1,NULL); LineTo(hdc[i],sh2,sv2);
     }
   }
 }
}

void DrawDirectionLine(HDC hdc[],
               point Offset,
               double p, double t, double a,
               short im, double ima, double scale){
 int sh1,sv1,sh2,sv2,i;
 point v1,v2;
 point Lpointer[2];
 short ep;
 double s10;
 int ifd,ild;
 if(View == TRIVIEW){ifd=0;ild=3;}
 else               {ifd=ActiveView; ild=ifd+1;}
 s10=scale/10.0;
 for(i=0;i<2;i++)ScalePoint(s10,s10,s10,Pointer[i],Lpointer[i]);
 Transform(2,Lpointer,trpoints,Offset,p,t,a,im,ima);
 CopyPoint(trpoints[0],v1);
 CopyPoint(trpoints[1],v2);
 if(in_stage_triview(v1) || in_stage_triview(v2)){
   for(i=ifd;i<ild;i++){
     GetWindowCoords(i,v1[0],v1[1],v1[2],&sh1,&sv1);
     GetWindowCoords(i,v2[0],v2[1],v2[2],&sh2,&sv2);
     MoveToEx(hdc[i],sh1,sv1,NULL); LineTo(hdc[i],sh2,sv2);
   }
 }
}

static short BV_id[3] ={1,2,0};
static short TV_id[3] ={2,1,0};
static short EV_id[6][4]={ 0, 1, 2, 3, 4, 5, 6, 7, 2, 6,10,11,
                           0, 4, 8, 9, 1, 5, 9,10, 3, 7,11, 8};
static short QF1[6]={0,4,3,0,2,0}; /* vertices to calculate normals */
static short QF2[6]={1,7,2,4,1,3};
static short QF3[6]={0,4,3,0,2,3};
static short QF4[6]={3,5,7,1,6,7};

#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]);  \
                        }

static void DrawSolidBox(HDC hdc[]){
 int sh1,sv1,sh2,sv2,i,e,f,visi[12];
 double n[6][3],n1[3],n2[3];
 point v1,v2;
 int ifd,ild;
 if(View == TRIVIEW){ifd=0;ild=3;}
 else               {ifd=ActiveView; ild=ifd+1;}
 for(f=0;f<6;f++){ /* calculate normal vector */
  for(i=0;i<3;i++){
    n1[i]=(double)(trpoints[QF2[f]][i] - trpoints[QF1[f]][i]);
    n2[i]=(double)(trpoints[QF4[f]][i] - trpoints[QF3[f]][i]);
  }
  CROSS(n1,n2,n[f]);
  if(WindowBox_view == 0)n[f][1] = -n[f][1];
 }
 for(i=ifd;i<ild;i++){
   for(e=0;e<12;e++)visi[e]=0;
   for(f=0;f<6;f++)if(n[f][TV_id[i]] > 0.0){ /* face is visible */
     for(e=0;e<4;e++)visi[EV_id[f][e]]=1;
   }
   for(e=0;e<12;e++)if(visi[e]){
     CopyPoint(trpoints[ep1[e]],v1);
     CopyPoint(trpoints[ep2[e]],v2);
     if(in_stage_triview(v1) || in_stage_triview(v2)) {
       GetWindowCoords(i,v1[0],v1[1],v1[2],&sh1,&sv1);
       GetWindowCoords(i,v2[0],v2[1],v2[2],&sh2,&sv2);
       MoveToEx(hdc[i],sh1,sv1,NULL); LineTo(hdc[i],sh2,sv2);
     }
   }
 }
}

static void DrawObject(HDC hdc[], object *Op,
               point Offset, double p,
               double t, double a, short im, double ima,
               double sx, double sy, double sz, short status){
 int sh1,sv1,sh2,sv2,i,ep;
 point  v1,v2;
 double mr;
 int ifd,ild;
 if(View == TRIVIEW){ifd=0;ild=3;}
 else               {ifd=ActiveView; ild=ifd+1;}
// if(status == DESELECTED)
//    DrawActorCentre(hdc,Offset,p,t,a,im,ima,TVsizeX/24);
 if(status == SELECTED)DrawArrow(hdc,Offset,p,t,a,im,ima,TVsizeX/24);
 if(Op->w_frame.p != NULL){
   if(DrawQuickObject(hdc,Op,Offset,p,t,a,im,ima,sx,sy,sz,status) == OK)return;
 }
 // Don't need this since bounding box is OK
 //DrawNurbsObject(hdc,Op,Offset,p,t,a,im,ima,sx,sy,sz,status);
 if(Op->morph != NO && Op->last != NULL){
   mr=(double)(Op->lastframe - Op->firstframe+1);
   mr=(double)(CurrentFrame - Op->firstframe+1)/mr;
   for(i=0;i<8;i++){
     srpoints[i][0] = (long)((double)(Op->outline[i][0] -
         Op->last->outline[i][0])*mr + Op->last->outline[i][0])*sx;
     srpoints[i][1] = (long)((double)(Op->outline[i][1] -
         Op->last->outline[i][1])*mr + Op->last->outline[i][1])*sy;
     srpoints[i][2] = (long)((double)(Op->outline[i][2] -
         Op->last->outline[i][2])*mr + Op->last->outline[i][2])*sz;
   }
 }
 else{
   for(i=0;i<8;i++){
     srpoints[i][0] = (long)((double)Op->outline[i][0])*sx;
     srpoints[i][1] = (long)((double)Op->outline[i][1])*sy;
     srpoints[i][2] = (long)((double)Op->outline[i][2])*sz;
   }
 }
 Transform(8,srpoints,trpoints,Offset,p,t,a,im,ima);

 if(status == SELECTED && tool != NOTOOL && tool != NODETOOL){
   DrawSolidBox(hdc);
   return;
 }

 for(ep=0;ep<12;ep++){
   CopyPoint(trpoints[ep1[ep]],v1);
   CopyPoint(trpoints[ep2[ep]],v2);
   if(in_stage_triview(v1) || in_stage_triview(v2)) {
     for(i=ifd;i<ild;i++){
       GetWindowCoords(i,v1[0],v1[1],v1[2],&sh1,&sv1);
       GetWindowCoords(i,v2[0],v2[1],v2[2],&sh2,&sv2);
       MoveToEx(hdc[i],sh1,sv1,NULL); LineTo(hdc[i],sh2,sv2);
     }
   }
 }
}

static short DrawNurbsObject(HDC hdc[], object *Op, point Offset
                   , double p, double t, double a
                   , short im, double ima
                   , double sx, double sy, double sz, short status){
 vector4 *p1;
 nurbs *n;
 int sh1,sv1,sh2,sv2;
 point  v1,v2,*Vp;
 long ii,jj,i,j,k,id1,id2,NP;
 double mr,w;
 int ifd,ild;
 if(View == TRIVIEW){ifd=0;ild=3;}
 else               {ifd=ActiveView; ild=ifd+1;}
 if(Op->nNurbs == 0 || Op->Nurbs == NULL)return FAIL;
 for(k=0;k<Op->nNurbs;k++){
   n=(Op->Nurbs+k);
   if(n->properties.hidden)continue;
   if((Vp=(point *)X__Malloc((n->numU * n->numV)*sizeof(point))) == NULL)return FAIL;
   if(Op->morph != NO && Op->last != NULL && Op->last->Nurbs != NULL &&
      Op->nNurbs == Op->last->nNurbs){
     mr=(double)(Op->lastframe - Op->firstframe+1);
     mr=(double)(CurrentFrame - Op->firstframe+1)/mr;
     j=0;
     for(ii=0;ii<n->numV;ii++)
     for(jj=0;jj<n->numU;jj++){
       p1 = &(n->points[ii][jj]);
       w=1.0/p1->w;
       Vp[j][0]=(long)((p1->x)*w);
       Vp[j][1]=(long)((p1->y)*w);
       Vp[j][2]=(long)((p1->z)*w);
       Vp[j][0] = Vp[j][0]*sx;
       Vp[j][1] = Vp[j][1]*sy;
       Vp[j][2] = Vp[j][2]*sz;
       p1 = &((Op->last->Nurbs+k)->points[ii][jj]);
       w=1.0/p1->w;
       v1[0]=(long)((p1->x)*w);
       v1[1]=(long)((p1->y)*w);
       v1[2]=(long)((p1->z)*w);
       Vp[j][0] = (long)((double)(Vp[j][0] - v1[0])*mr + v1[0])*sx;
       Vp[j][1] = (long)((double)(Vp[j][1] - v1[1])*mr + v1[1])*sy;
       Vp[j][2] = (long)((double)(Vp[j][2] - v1[2])*mr + v1[2])*sz;
       j++;
     }
   }
   else{
     j=0;
     for(ii=0;ii<n->numV;ii++)
     for(jj=0;jj<n->numU;jj++){
       p1 = &(n->points[ii][jj]);
       w=1.0/p1->w;
       Vp[j][0]=(long)((p1->x)*w);
       Vp[j][1]=(long)((p1->y)*w);
       Vp[j][2]=(long)((p1->z)*w);
       Vp[j][0] = Vp[j][0]*sx;
       Vp[j][1] = Vp[j][1]*sy;
       Vp[j][2] = Vp[j][2]*sz;
       j++;
     }
   }
   Transform((long)(n->numU * n->numV),Vp,Vp,Offset,p,t,a,im,ima);

   for(ii=0;ii<n->numV;ii++)
   for(jj=0;jj<n->numU-1;jj++){
     id1=(ii*(n->numU)+jj);
     id2=(ii*(n->numU)+jj+1);
     CopyPoint(Vp[id1],v1);
     CopyPoint(Vp[id2],v2);
     if(in_stage_triview(v1) || in_stage_triview(v2)){
       for(i=ifd;i<ild;i++){
         GetWindowCoords(i,v1[0],v1[1],v1[2],&sh1,&sv1);
         GetWindowCoords(i,v2[0],v2[1],v2[2],&sh2,&sv2);
         MoveToEx(hdc[i],sh1,sv1,NULL); LineTo(hdc[i],sh2,sv2);
       }
     }
   }
   for(jj=0;jj<n->numU;jj++)
   for(ii=0;ii<n->numV-1;ii++){
     id1=(ii*(n->numU)+jj);
     id2=((ii+1)*(n->numU)+jj);
     CopyPoint(Vp[id1],v1);
     CopyPoint(Vp[id2],v2);
     if(in_stage_triview(v1) || in_stage_triview(v2)){
       for(i=ifd;i<ild;i++){
         GetWindowCoords(i,v1[0],v1[1],v1[2],&sh1,&sv1);
         GetWindowCoords(i,v2[0],v2[1],v2[2],&sh2,&sv2);
         MoveToEx(hdc[i],sh1,sv1,NULL); LineTo(hdc[i],sh2,sv2);
       }
     }
   }
   X__Free(Vp);
 }
 return OK;
}

static void DrawRect(HDC hdc[],point Offset, double p, double t, double a,
              short im, double ima, double scalex, double scaley){
 int sh1,sv1,sh2,sv2,i;
 point v1,v2;
 point Lpointer[4];
 short ep;
 int ifd,ild;
 if(View == TRIVIEW){ifd=0;ild=3;}
 else               {ifd=ActiveView; ild=ifd+1;}
 for(i=0;i<4;i++)ScalePoint(scalex,scaley,1.0,Rectang[i],Lpointer[i]);
 Transform(4,Lpointer,trpoints,Offset,p,t,a,im,ima);
 for(ep=0;ep<4;ep++){
   CopyPoint(trpoints[rp1[ep]],v1);
   CopyPoint(trpoints[rp2[ep]],v2);
   if(in_stage_triview(v1) || in_stage_triview(v2)){
     for(i=ifd;i<ild;i++){
       GetWindowCoords(i,v1[0],v1[1],v1[2],&sh1,&sv1);
       GetWindowCoords(i,v2[0],v2[1],v2[2],&sh2,&sv2);
       MoveToEx(hdc[i],sh1,sv1,NULL); LineTo(hdc[i],sh2,sv2);
     }
   }
 }
}

static void DrawGround(HDC hdc[], point v1
                ,double p, double t, double a, short im
                ,double ima, short status, double scalex, double scaley
                ,double scalez){
 RECT rc;
 int sh1,sv1,i;
 int ifd,ild;
 if(View == TRIVIEW){ifd=0;ild=3;}
 else               {ifd=ActiveView; ild=ifd+1;}
 if(status == DESELECTED)
    DrawActorCentre(hdc,v1,p,t,a,im,ima,TVsizeX/24);
// if     (status == SELECTED)_setcolor(Col_ase);
// else                       _setcolor(Col_ade);
 if(status == SELECTED)
    DrawRect(hdc,v1,p,0.0,0.0,im,ima,scalex,scaley);
 for(i=ifd;i<ild;i++)if(i != TRITOP){
   GetWindowCoords(i,v1[0],v1[1],v1[2],&sh1,&sv1);
   MoveToEx(hdc[i],0,sv1,NULL);
   GetClientRect(ghwnd_triview[i],&rc);
   LineTo(hdc[i],rc.right+1,sv1);
   if(status == SELECTED){
     MoveToEx(hdc[i],sh1,sv1,NULL);
     GetWindowCoords(i,v1[0],v1[1],v1[2]+(long)(UNIT*2*scalez),&sh1,&sv1);
     LineTo(hdc[i],sh1,sv1);
   }
 }
}

static void DrawActorBitmap(HDC hdc[], point v1,
                double p, double t, double a, short im, double ima,
                short status, short what_icon){
 int sh1,sv1,i,c;
 HDC hMemDC;
 HBITMAP hbmOld;
 HBRUSH holdbrush;
 int ifd,ild;
 if(View == TRIVIEW){ifd=0;ild=3;}
 else               {ifd=ActiveView; ild=ifd+1;}
 if(ghCameraBitmap == NULL || ghLightBitmap == NULL)return;
 for(i=ifd;i<ild;i++){
   hMemDC = CreateCompatibleDC(hdc[i]);
   GetWindowCoords(i,v1[0],v1[1],v1[2],&sh1,&sv1);
   if(what_icon == 0){ /* draw Camera icon */
     hbmOld = SelectObject(hMemDC,ghCameraBitmap);  c=32;
   }
   else if(what_icon == 1){ /* Light */
     hbmOld = SelectObject(hMemDC,ghLightBitmap); c=16;
   }
   if(tool != NOTOOL && tool != NODETOOL &&
      tool != PAN && tool != INZOOM && status == SELECTED){
     BitBlt(hdc[i],sh1-c/2,sv1-16,c,16,hMemDC,0,0,SRCINVERT);
   }
   else{
     BitBlt(hdc[i],sh1-c/2,sv1-16,c,16,hMemDC,0,0,0x00220326); /*  DSna */
     if(status == SELECTED)holdbrush=SelectObject(hdc[i],ghSelectedBrush);
     else                  holdbrush=SelectObject(hdc[i],ghDeselectedBrush);
     BitBlt(hdc[i],sh1-c/2,sv1-16,c,16,hMemDC,0,0,0x00ea02e9); /* DPSao */
     SelectObject(hdc[i],holdbrush);
   }
//   SelectObject(hdc[i],holdbrush);
   SelectObject(hMemDC,hbmOld);
   DeleteDC(hMemDC);
 }
}

static void DrawAxis(HDC hdc[], point v1, short status){
 int sh1,sv1,i;
 int ifd,ild;
 if(View == TRIVIEW){ifd=0;ild=3;}
 else               {ifd=ActiveView; ild=ifd+1;}
 for(i=ifd;i<ild;i++){
    GetWindowCoords(i,v1[0],v1[1],v1[2],&sh1,&sv1);
    MoveToEx(hdc[i],sh1-5,sv1,NULL); LineTo(hdc[i],sh1+5,sv1);
    MoveToEx(hdc[i],sh1,sv1+5,NULL); LineTo(hdc[i],sh1,sv1-5);
    MoveToEx(hdc[i],sh1-2,sv1,NULL);
    LineTo(hdc[i],sh1,sv1-2); LineTo(hdc[i],sh1+2,sv1);
    LineTo(hdc[i],sh1,sv1+2); LineTo(hdc[i],sh1-2,sv1);
 }
}

static void DrawFullObject(HDC hdc[], object *Op, point Offset
               , double p, double t, double a, short im, double ima
               , double sx, double sy, double sz, short status){
 int k,n,sh1,sv1,sh2,sv2,morphflag;
 long ep,i,Nv,Nl,Nm,j,id[2],Sz;
 point  v1,v2,*Vp;
 double mr;
 LOGPEN lopn;
 int ifd,ild;
 if(View == TRIVIEW){ifd=0;ild=3; n=3;}
 else               {ifd=ActiveView; ild=ifd+1; n=1;}
 morphflag=0;
 if(status == SELECTED)GetObject(ghSelectedPen,sizeof(LOGPEN),&lopn);
 else                  GetObject(ghDeselectedPen,sizeof(LOGPEN),&lopn);
 if(Op->in_ram)Nv=Op->npoints;
 else          Nv=0;
 if(Op->morph != NO && Op->last != NULL){
   morphflag=1;
   mr=(double)(Op->lastframe - Op->firstframe+1);
   if(Op->lastframe == Nframes)mr += 1.0; /* for loop it end of sequence */
   mr=(double)(CurrentFrame - Op->firstframe+1)/mr;
   Nm=Op->last->npoints;
   if(!Op->last->in_ram || Nm != Nv)morphflag=0;
 }
 DrawNurbsObject(hdc,Op,Offset,p,t,a,im,ima,sx,sy,sz,status);
 Sz=(long)Nv*(long)sizeof(point);
 if(Nv > 0){
  if((Vp=(point *)X__Malloc((long)Nv*sizeof(point))) != NULL){
   for(j=0;j<Nv;j++){
     CopyPoint(Op->points[j],Vp[j]);
     if(morphflag == 1){
       CopyPoint(Op->last->points[j],v1);
       Vp[j][0] -= Op->origin[0];
       Vp[j][1] -= Op->origin[1];
       Vp[j][2] -= Op->origin[2];
       v1[0] -= Op->last->origin[0];
       v1[1] -= Op->last->origin[1];
       v1[2] -= Op->last->origin[2];
       Vp[j][0] = (long)((double)(Vp[j][0] - v1[0])*mr + v1[0])*sx;
       Vp[j][1] = (long)((double)(Vp[j][1] - v1[1])*mr + v1[1])*sy;
       Vp[j][2] = (long)((double)(Vp[j][2] - v1[2])*mr + v1[2])*sz;
     }
     else{
       Vp[j][0] = (Vp[j][0] - Op->origin[0])*sx;
       Vp[j][1] = (Vp[j][1] - Op->origin[1])*sy;
       Vp[j][2] = (Vp[j][2] - Op->origin[2])*sz;
     }
   }
   Transform(Nv,Vp,Vp,Offset,p,t,a,im,ima);
   if(global_quickdraw){
     long qstep,kstep;
     qstep=max(1,Nv/100);
     for(k=0;k<n;k++){
       i=order_list[ActiveView][k];
       for(j=0;j<Nv;j+=qstep)if(in_stage_triview(Vp[j])){
         GetWindowCoords(i,Vp[j][0],Vp[j][1],Vp[j][2],&sh1,&sv1);
         MoveToEx(hdc[i],sh1-1,sv1,NULL); LineTo(hdc[i],sh1+2,sv1);
         MoveToEx(hdc[i],sh1,sv1-1,NULL); LineTo(hdc[i],sh1,sv1+2);
       }
       if(tool_move_flag){
//         InvalidateRect(ghwnd_current,NULL,FALSE);
//         UpdateWindow(ghwnd_current);
//         Sleep(0);
       }
       if(qstep > 1){
         if     (Nv <   100)kstep=1;
         else if(Nv <  1000)kstep=2;
         else if(Nv <  2500)kstep=3;
         else if(Nv <  5000)kstep=4;
         else if(Nv < 10000)kstep=6;
         else               kstep=8;
         for(j=0;j<Nv;j+=kstep){
           if(j%qstep == 0)continue;
           if(in_stage_triview(Vp[j])){
             GetWindowCoords(i,Vp[j][0],Vp[j][1],Vp[j][2],&sh1,&sv1);
             MoveToEx(hdc[i],sh1-1,sv1,NULL); LineTo(hdc[i],sh1+2,sv1);
             MoveToEx(hdc[i],sh1,sv1-1,NULL); LineTo(hdc[i],sh1,sv1+2);
             if(HIWORD(GetQueueStatus(QS_MOUSEMOVE)) == QS_MOUSEMOVE
                &&  CheckInterrupt()){
//               InvalidateRect(ghwnd_current,NULL,FALSE);
//               UpdateWindow(ghwnd_current);
//               Sleep(0);
               goto ABORT;
             }
           }
         }
         if(tool_move_flag){
//           InvalidateRect(ghwnd_current,NULL,FALSE);
//           UpdateWindow(ghwnd_current);
//           Sleep(0);
         }
       }
       if(zoom_abort == 1){
//         InvalidateRect(ghwnd_current,NULL,FALSE);
//         UpdateWindow(ghwnd_current);
//         Sleep(0);
         goto ABORT;
       }
     }
     goto ABORT;
   }
   if(Op->in_ram)Nl=Op->nedges; else Nl=0;
   if(Nl > 0){
     long qstep,kstep;
     if(Preferences.detail_auto){
       if     (Nl <   100)kstep=1;
       else if(Nl <  1000)kstep=2;
       else if(Nl <  2500)kstep=3;
       else if(Nl <  5000)kstep=4;
       else if(Nl < 10000)kstep=6;
       else               kstep=8;
     }
     else{
      kstep=max(1,Preferences.detail_step);
     }
     qstep=0;
     for(ep=0;ep<Nl;ep+=kstep){ /* draw edges */
       id[0]=Op->edges[ep][0];
       id[1]=Op->edges[ep][1];
       CopyPoint(Vp[id[0]],v1);
       CopyPoint(Vp[id[1]],v2);
       if(in_stage_triview(v1) || in_stage_triview(v2)){
//         for(i=ifd;i<ild;i++){
         for(k=0;k<n;k++){
           i=order_list[ActiveView][k];
           GetWindowCoords(i,v1[0],v1[1],v1[2],&sh1,&sv1);
           GetWindowCoords(i,v2[0],v2[1],v2[2],&sh2,&sv2);
           if(abs(sh1-sh2) < 4 && abs(sv1-sv2) < 4){
             MoveToEx(hdc[i],sh1,sv1,NULL); LineTo(hdc[i],sh1+1,sv1);
           }
           else {
             MoveToEx(hdc[i],sh1,sv1,NULL); LineTo(hdc[i],sh2,sv2);
           }
         }
         if(HIWORD(GetQueueStatus(QS_MOUSEMOVE)) == QS_MOUSEMOVE
           &&  CheckInterrupt())goto ABORT;
       }
       if(qstep == 50 && tool_move_flag){
//         InvalidateRect(ghwnd_current,NULL,FALSE);
//         UpdateWindow(ghwnd_current);
//         Sleep(0);
       }
       qstep++;
     }
     if(tool_move_flag){
//       InvalidateRect(ghwnd_current,NULL,FALSE);
//       UpdateWindow(ghwnd_current);
//       Sleep(0);
     }
   }
   ABORT:
   X__Free(Vp);
  }
 }
}

static void DrawCameraFOV(HDC hdc[], short status, node *Np, short al_type,
                          point Offset, point TrackedOffset,
                          double p, double t, double a,
                          short im, double ima,
                          double sx, double sy, double sz){
 HPEN   hOldPen[3];
 COLORREF OldColour[3];
 int    OldMode[3];
 int sh1,sv1,sh2,sv2,i;
 static short ccep1[8]={0,1,2,3,4,4,4,4};
 static short ccep2[8]={1,2,3,0,0,1,2,3};
 point v1,v2;
 point Lcone[4];
 short ep;
 double d,r,asp;
 int ifd,ild;
 if(View == TRIVIEW){ifd=0;ild=3;}
 else               {ifd=ActiveView; ild=ifd+1;}
 if(al_type != TRACK){
   d=(double)(TVsizeX)*0.4;
 }
 else{
   SubPoints(Offset,TrackedOffset,v1);
   d=sqrt((double)v1[0]*(double)v1[0]+
          (double)v1[1]*(double)v1[1]+
          (double)v1[2]*(double)v1[2]);
 }
 r=d*0.42/sx;        /* 0.42 with sx=1 => 50 mm lenz in 3DS setup */
 asp=r*sx/sy*0.75;   /* 0.75 is for 1.333 ratio */
 for(i=0;i<4;i++)Lcone[i][1]=d;
 Lcone[0][0]= (long)r;  Lcone[0][2]= (long)asp;
 Lcone[1][0]=-(long)r;  Lcone[1][2]= (long)asp;
 Lcone[2][0]=-(long)r;  Lcone[2][2]=-(long)asp;
 Lcone[3][0]= (long)r;  Lcone[3][2]=-(long)asp;
 CopyPoint(Offset,trpoints[4]);
 Transform(4,Lcone,trpoints,Offset,p,t,a,im,ima);
 if(tool != NOTOOL && tool != NODETOOL &&
    tool != PAN && tool != INZOOM && Np == SelectedNode){
   for(i=ifd;i<ild;i++){
    OldMode[i]=SetBkMode(hdc[i],TRANSPARENT);
//     OldColour[i]=SetBkColor(hdc[i],RGB(0,0,0));
     hOldPen[i]=SelectObject(hdc[i],ghDotInvertPen);
   }
 }
 else{
   for(i=ifd;i<ild;i++)OldMode[i]=SetBkMode(hdc[i],TRANSPARENT);
   //OldColour[i]=SetBkColor(hdc[i],gScreenColourRef);
   if(status == SELECTED){
     for(i=ifd;i<ild;i++)hOldPen[i]=SelectObject(hdc[i],ghDotSelectedPen);
   }
   else{
     for(i=ifd;i<ild;i++)hOldPen[i]=SelectObject(hdc[i],ghDotDeselectedPen);
   }
 }
 for(ep=0;ep<8;ep++){
  CopyPoint(trpoints[ccep1[ep]],v1);
  CopyPoint(trpoints[ccep2[ep]],v2);
  if(in_stage_triview(v1) || in_stage_triview(v2)){
    for(i=ifd;i<ild;i++){
      GetWindowCoords(i,v1[0],v1[1],v1[2],&sh1,&sv1);
      GetWindowCoords(i,v2[0],v2[1],v2[2],&sh2,&sv2);
      MoveToEx(hdc[i],sh1,sv1,NULL); LineTo(hdc[i],sh2,sv2);
    }
  }
 }
 for(i=ifd;i<ild;i++){
   SelectObject(hdc[i],hOldPen[i]);
   SetBkMode(hdc[i],OldMode[i]);
//   SetBkColor(hdc[i],OldColour[i]);
 }
}

static void DrawLightCone(HDC hdc[], short status, node *Np, short type,
                          point Offset, point TrackedOffset,
                          double p, double t, double a,
                          short im, double ima, double cone, double edge){
 HPEN   hOldPen[3];
 COLORREF OldColour[3];
 int OldMode[3];
 int sh1,sv1,sh2,sv2,i;
 static short lcep1[16]={0,1,2,3,4,5,6,7,8, 9,10,11,12,12,12,12};
 static short lcep2[16]={1,2,3,4,5,6,7,8,9,10,11, 0, 0, 3, 6, 9};
 static double LconeX[12]={ 1.000, 0.866, 0.500, 0.000,-0.500,-0.866,
                           -1.000,-0.866,-0.500, 0.000, 0.500, 0.866};
 static double LconeY[12]={ 0.000, 0.500, 0.866, 1.000, 0.866, 0.500,
                            0.000,-0.500,-0.866,-1.000,-0.866,-0.500};
 point v1,v2;
 point Lcone[12];
 short ep;
 double d,r;
 int ifd,ild;
 if(View == TRIVIEW){ifd=0;ild=3;}
 else               {ifd=ActiveView; ild=ifd+1;}
 if(type != TRACK){
   d=(double)TVsizeX/2;
 }
 else{
   SubPoints(Offset,TrackedOffset,v1);
   d=sqrt((double)v1[0]*(double)v1[0]+
          (double)v1[1]*(double)v1[1]+
          (double)v1[2]*(double)v1[2]);
 }
 r=d*tan(cone/360.0*PI);
 for(i=0;i<12;i++){
  Lcone[i][1]=d;
  Lcone[i][0]=(long)(r*LconeX[i]); Lcone[i][2]=(long)(r*LconeY[i]);
 }
 CopyPoint(Offset,trpoints[12]);
 Transform(12,Lcone,trpoints,Offset,p,t,a,im,ima);
 if(tool != NOTOOL && tool != NODETOOL &&
    tool != PAN && tool != INZOOM && Np == SelectedNode){
   for(i=ifd;i<ild;i++){
//     OldColour[i]=SetBkColor(hdc[i],RGB(0,0,0));
     OldMode[i]=SetBkMode(hdc[i],TRANSPARENT);
     hOldPen[i]=SelectObject(hdc[i],ghDotInvertPen);
   }
 }
 else{
   for(i=ifd;i<ild;i++)OldMode[i]=SetBkMode(hdc[i],TRANSPARENT);
//   OldColour[i]=SetBkColor(hdc[i],gScreenColourRef);
   if(status == SELECTED){
     for(i=ifd;i<ild;i++)hOldPen[i]=SelectObject(hdc[i],ghDotSelectedPen);
   }
   else{
     for(i=ifd;i<ild;i++)hOldPen[i]=SelectObject(hdc[i],ghDotDeselectedPen);
   }
 }
 for(ep=0;ep<16;ep++){
  CopyPoint(trpoints[lcep1[ep]],v1);
  CopyPoint(trpoints[lcep2[ep]],v2);
  if(in_stage_triview(v1) || in_stage_triview(v2)){
    for(i=ifd;i<ild;i++){
      GetWindowCoords(i,v1[0],v1[1],v1[2],&sh1,&sv1);
      GetWindowCoords(i,v2[0],v2[1],v2[2],&sh2,&sv2);
      MoveToEx(hdc[i],sh1,sv1,NULL); LineTo(hdc[i],sh2,sv2);
    }
  }
 }
 for(i=ifd;i<ild;i++){
   SetBkMode(hdc[i],OldMode[i]);
   SelectObject(hdc[i],hOldPen[i]);
//   SetBkColor(hdc[i],OldColour[i]);
 }
}

static void DrawLightExtent(HDC hdc[], short status, node *Np, short type,
                          point vc, double sz){
 HPEN   hOldPen[3];
 COLORREF OldColour[3];
 HBRUSH hOldBrush[3];
 int OldMode[3];
 int sh1,sv1,sh2,sv2,s;
 int i,ifd,ild;
 point vmx,vmn;
 if(View == TRIVIEW){ifd=0;ild=3;}
 else               {ifd=ActiveView; ild=ifd+1;}
 if(tool != NOTOOL && tool != NODETOOL &&
    tool != PAN && tool != INZOOM && Np == SelectedNode){
   for(i=ifd;i<ild;i++){
//     OldColour[i]=SetBkColor(hdc[i],RGB(0,0,0));
     OldMode[i]=SetBkMode(hdc[i],TRANSPARENT);
     hOldPen[i]=SelectObject(hdc[i],ghDotInvertPen);
     hOldBrush[i]=SelectObject(hdc[i],GetStockObject(NULL_BRUSH));
   }
 }
 else{
   for(i=ifd;i<ild;i++){
     OldMode[i]=SetBkMode(hdc[i],TRANSPARENT);
//     OldColour[i]=SetBkColor(hdc[i],gScreenColourRef);
     hOldBrush[i]=SelectObject(hdc[i],GetStockObject(NULL_BRUSH));
   }
   if(status == SELECTED){
     for(i=ifd;i<ild;i++)hOldPen[i]=SelectObject(hdc[i],ghDotSelectedPen);
   }
   else{
     for(i=ifd;i<ild;i++)hOldPen[i]=SelectObject(hdc[i],ghDotDeselectedPen);
   }
 }
 vmn[0]=vc[0]-sz*(double)UNIT;
 vmn[1]=vc[1]-sz*(double)UNIT;
 vmn[2]=vc[2]-sz*(double)UNIT;
 vmx[0]=vc[0]+sz*(double)UNIT;
 vmx[1]=vc[1]+sz*(double)UNIT;
 vmx[2]=vc[2]+sz*(double)UNIT;
 for(i=ifd;i<ild;i++){
   GetWindowCoords(i,vmn[0],vmn[1],vmn[2],&sh1,&sv1);
   GetWindowCoords(i,vmx[0],vmx[1],vmx[2],&sh2,&sv2);
   if(sh1 > sh2){s=sh2; sh2=sh1; sh1=s;}
   if(sv1 > sv2){s=sv2; sv2=sv1; sv1=s;}
   if((sh1 > 0 && sh1 < WindowSizeX[i]) ||
      (sh2 > 0 && sh2 < WindowSizeX[i]) ||
      (sv1 > 0 && sv1 < WindowSizeY[i]) ||
      (sv2 > 0 && sv2 < WindowSizeY[i]))
     Ellipse(hdc[i],sh1,sv1,sh2,sv2);
 }
 for(i=ifd;i<ild;i++){
   SelectObject(hdc[i],hOldPen[i]);
   SelectObject(hdc[i],hOldBrush[i]);
   SetBkMode(hdc[i],OldMode[i]);
//   SetBkColor(hdc[i],OldColour[i]);
 }
}

#define NP Op->w_frame.Np
#define NE Op->w_frame.Ne
static short DrawQuickObject(HDC hdc[], object *Op, point Offset
                   , double p, double t, double a
                   , short im, double ima
                   , double sx, double sy, double sz, short status){
 int sh1,sv1,sh2,sv2;
 point  v1,v2,*Vp;
 long i,j,ep,id1,id2;
 double mr;
 int ifd,ild;
 if(View == TRIVIEW){ifd=0;ild=3;}
 else               {ifd=ActiveView; ild=ifd+1;}
 if(Op->w_frame.p == NULL || Op->w_frame.e == NULL ||
    NP == 0 || NE == 0)return FAIL;
 if((Vp=(point *)X__Malloc((NP)*sizeof(point))) == NULL)return FAIL;
 if(Op->morph != NO && Op->last != NULL && Op->last->w_frame.p != NULL &&
    Op->w_frame.Np == Op->last->w_frame.Np){
   mr=(double)(Op->lastframe - Op->firstframe+1);
   mr=(double)(CurrentFrame - Op->firstframe+1)/mr;
   for(j=0;j<NP;j++){
     CopyPoint(Op->w_frame.p[j],Vp[j]);
     CopyPoint(Op->last->w_frame.p[j],v1);
     Vp[j][0] = (long)((double)(Vp[j][0] - v1[0])*mr + v1[0])*sx;
     Vp[j][1] = (long)((double)(Vp[j][1] - v1[1])*mr + v1[1])*sy;
     Vp[j][2] = (long)((double)(Vp[j][2] - v1[2])*mr + v1[2])*sz;
   }
 }
 else{
  for(j=0;j<NP;j++){
    CopyPoint(Op->w_frame.p[j],Vp[j]);
    Vp[j][0] = Vp[j][0]*sx;
    Vp[j][1] = Vp[j][1]*sy;
    Vp[j][2] = Vp[j][2]*sz;
  }
 }
 Transform((long)(NP),Vp,Vp,Offset,p,t,a,im,ima);
 for(ep=0;ep<NE;ep++){
   id1=Op->w_frame.e[ep][0]; id2=Op->w_frame.e[ep][1];
   CopyPoint(Vp[id1],v1);
   CopyPoint(Vp[id2],v2);
   if(in_stage_triview(v1) || in_stage_triview(v2)){
     for(i=ifd;i<ild;i++){
       GetWindowCoords(i,v1[0],v1[1],v1[2],&sh1,&sv1);
       GetWindowCoords(i,v2[0],v2[1],v2[2],&sh2,&sv2);
       MoveToEx(hdc[i],sh1,sv1,NULL); LineTo(hdc[i],sh2,sv2);
     }
   }
 }
 X__Free(Vp);
 return OK;
}


int CheckBoundingObject(int type, int ifd, int hx, int vy,
               object *Op, point Offset, double p,
               double t, double a, short im, double ima,
               double sx, double sy, double sz, double *dc){
 int sh1,sv1,sh2,sv2,i,j,ep,id1,id2;
 point  v1,v2,*Vp;
 double mr;
 if(type == 1){ /* check full */
   int morphflag;
   long ep,i,Nv,Nl,Nm,j,id[2],Sz;
   morphflag=0;
   if(Op->in_ram)Nv=Op->npoints;
   else          Nv=0;
   if(Op->morph != NO && Op->last != NULL){
     morphflag=1;
     mr=(double)(Op->lastframe - Op->firstframe+1);
     if(Op->lastframe == Nframes)mr += 1.0; /* for loop it end of sequence */
     mr=(double)(CurrentFrame - Op->firstframe+1)/mr;
     Nm=Op->last->npoints;
     if(!Op->last->in_ram || Nm != Nv)morphflag=0;
   }
   Sz=(long)Nv*(long)sizeof(point);
   if(Nv > 0){
     if((Vp=(point *)X__Malloc((long)Nv*sizeof(point))) != NULL){
       for(j=0;j<Nv;j++){
         CopyPoint(Op->points[j],Vp[j]);
         if(morphflag == 1){
           CopyPoint(Op->last->points[j],v1);
           Vp[j][0] -= Op->origin[0];
           Vp[j][1] -= Op->origin[1];
           Vp[j][2] -= Op->origin[2];
           v1[0] -= Op->last->origin[0];
           v1[1] -= Op->last->origin[1];
           v1[2] -= Op->last->origin[2];
           Vp[j][0] = (long)((double)(Vp[j][0] - v1[0])*mr + v1[0])*sx;
           Vp[j][1] = (long)((double)(Vp[j][1] - v1[1])*mr + v1[1])*sy;
           Vp[j][2] = (long)((double)(Vp[j][2] - v1[2])*mr + v1[2])*sz;
         }
         else{
           Vp[j][0] = (Vp[j][0] - Op->origin[0])*sx;
           Vp[j][1] = (Vp[j][1] - Op->origin[1])*sy;
           Vp[j][2] = (Vp[j][2] - Op->origin[2])*sz;
         }
       }
       Transform(Nv,Vp,Vp,Offset,p,t,a,im,ima);
       if(global_quickdraw){
         for(j=0;j<Nv;j++)if(in_stage_triview(Vp[j])){
           GetWindowCoords(ifd,Vp[j][0],Vp[j][1],Vp[j][2],&sh1,&sv1);
           if(CheckClosestObject(ifd,dc,Vp[j],hx,vy,4)){
             X__Free(Vp);
             return 1;
           }
         }
         X__Free(Vp);
         return 0;
       }
       if(Op->in_ram)Nl=Op->nedges; else Nl=0;
       if(Nl > 0) for(ep=0;ep<Nl;ep++){
         id[0]=Op->edges[ep][0];
         id[1]=Op->edges[ep][1];
         CopyPoint(Vp[id[0]],v1);
         CopyPoint(Vp[id[1]],v2);
         if(in_stage_triview(v1) || in_stage_triview(v2)){
           GetWindowCoords(ifd,v1[0],v1[1],v1[2],&sh1,&sv1);
           GetWindowCoords(ifd,v2[0],v2[1],v2[2],&sh2,&sv2);
           if(OnModelEdge(hx,vy,sh1,sv1,sh2,sv2,v1,v2,dc)){
             X__Free(Vp);
             return 1;
           }
         }
       }
       X__Free(Vp);
     }
   }
   return 0;
 }
 if(Op->w_frame.p == NULL || Op->w_frame.e == NULL ||
    NP == 0 || NE == 0)goto BBOX;
 if((Vp=(point *)X__Malloc((NP)*sizeof(point))) == NULL)goto BBOX;
 if(Op->morph != NO && Op->last != NULL && Op->last->w_frame.p != NULL &&
    Op->w_frame.Np == Op->last->w_frame.Np){
   mr=(double)(Op->lastframe - Op->firstframe+1);
   mr=(double)(CurrentFrame - Op->firstframe+1)/mr;
   for(j=0;j<NP;j++){
     CopyPoint(Op->w_frame.p[j],Vp[j]);
     CopyPoint(Op->last->w_frame.p[j],v1);
     Vp[j][0] = (long)((double)(Vp[j][0] - v1[0])*mr + v1[0])*sx;
     Vp[j][1] = (long)((double)(Vp[j][1] - v1[1])*mr + v1[1])*sy;
     Vp[j][2] = (long)((double)(Vp[j][2] - v1[2])*mr + v1[2])*sz;
   }
 }
 else{
  for(j=0;j<NP;j++){
    CopyPoint(Op->w_frame.p[j],Vp[j]);
    Vp[j][0] = Vp[j][0]*sx;
    Vp[j][1] = Vp[j][1]*sy;
    Vp[j][2] = Vp[j][2]*sz;
  }
 }
 Transform((long)(NP),Vp,Vp,Offset,p,t,a,im,ima);
 for(ep=0;ep<NE;ep++){
   id1=Op->w_frame.e[ep][0]; id2=Op->w_frame.e[ep][1];
   CopyPoint(Vp[id1],v1);
   CopyPoint(Vp[id2],v2);
   if(in_stage_triview(v1) || in_stage_triview(v2)){
     GetWindowCoords(ifd,v1[0],v1[1],v1[2],&sh1,&sv1);
     GetWindowCoords(ifd,v2[0],v2[1],v2[2],&sh2,&sv2);
     if(OnModelEdge(hx,vy,sh1,sv1,sh2,sv2,v1,v2,dc)){
       X__Free(Vp);
       return 1;
     }
   }
 }
 X__Free(Vp);
 return 0;
 BBOX:
 if(Op->morph != NO && Op->last != NULL){
   mr=(double)(Op->lastframe - Op->firstframe+1);
   mr=(double)(CurrentFrame - Op->firstframe+1)/mr;
   for(i=0;i<8;i++){
     srpoints[i][0] = (long)((double)(Op->outline[i][0] -
         Op->last->outline[i][0])*mr + Op->last->outline[i][0])*sx;
     srpoints[i][1] = (long)((double)(Op->outline[i][1] -
         Op->last->outline[i][1])*mr + Op->last->outline[i][1])*sy;
     srpoints[i][2] = (long)((double)(Op->outline[i][2] -
         Op->last->outline[i][2])*mr + Op->last->outline[i][2])*sz;
   }
 }
 else{
   for(i=0;i<8;i++){
     srpoints[i][0] = (long)((double)Op->outline[i][0])*sx;
     srpoints[i][1] = (long)((double)Op->outline[i][1])*sy;
     srpoints[i][2] = (long)((double)Op->outline[i][2])*sz;
   }
 }
 Transform(8,srpoints,trpoints,Offset,p,t,a,im,ima);
 for(ep=0;ep<12;ep++){
   CopyPoint(trpoints[ep1[ep]],v1);
   CopyPoint(trpoints[ep2[ep]],v2);
   if(in_stage_triview(v1) || in_stage_triview(v2)) {
     GetWindowCoords(ifd,v1[0],v1[1],v1[2],&sh1,&sv1);
     GetWindowCoords(ifd,v2[0],v2[1],v2[2],&sh2,&sv2);
     if(OnModelEdge(hx,vy,sh1,sv1,sh2,sv2,v1,v2,dc))return 1;
   }
 }
 return 0;
}

static int OnModelEdge(int npx, int npy,
                       int sh1, int sv1, int sh2, int sv2,
                       point vp1, point vp2,
                       double *dc){
 int i,found=0;
 double x,y,z,mu,a,b,c,d;
 a=(double)(sh2-sh1); b=(double)(sv2-sv1);
 if((sh2-sh1) != 0 ||  (sv2-sv1) != 0){
   x=(double)npx; y=(double)npy;
   mu=(a*(x-(double)sh1) + b*(y-(double)sv1))/(a*a+b*b);
   if(mu > 0.0001 && mu < 0.9999){
     x=a*mu+(double)sh1; y=b*mu+(double)sv1;
     sh1=(int)x; sv1=(int)y;
     if(abs(npx-sh1) < 4 && abs(npy-sv1) < 4){/* in 2D range */
       a=(double)(vp2[0]-vp1[0]);
       b=(double)(vp2[1]-vp1[1]);
       c=(double)(vp2[2]-vp1[2]);
       mu=(a*((double)NpointerX-(double)(vp1[0]))
          +b*((double)NpointerY-(double)(vp1[1]))
          +c*((double)NpointerZ-(double)(vp1[2])))/(a*a+b*b+c*c);
       x=a*mu+(double)(vp1[0]);
       y=b*mu+(double)(vp1[1]);
       z=c*mu+(double)(vp1[2]);
       d=(x-(double)NpointerX)*(x-(double)NpointerX)
        +(y-(double)NpointerY)*(y-(double)NpointerY)
        +(z-(double)NpointerZ)*(z-(double)NpointerZ);
       if(d < *dc){/* closest in 3D */
         *dc=d;
         found=1;
       }
     }
   }
 }
 return found;
}

#undef NP
#undef NE

// end of draw actor functions
//

void DrawNode(HDC hDC[], node *Np, short status){
 point  ObjectOffset,TrackedOffset;
 object *Op;
 short im,al_type;
 double phi,theta,alpha,sx,sy,sz,ima;
 if((Op=Np->fobj) != NULL)while(Op != NULL){
  if((CurrentFrame >= Op->firstframe) && (CurrentFrame <= Op->lastframe)){
   al_type=GetTransform(0,CurrentFrame,1.0,Np,Op,ObjectOffset,TrackedOffset,
                &phi,&theta,&alpha,&sx,&sy,&sz,&im,&ima);
   if((Op->type == PATH) && (Op->firstpathpoint != NULL)){
     if(tool == PATHEDITOR && Np == SelectedNode)DrawPath(hDC,
       Op,ObjectOffset,phi,theta,alpha,im,ima,EDITING);
     else                                        DrawPath(hDC,
       Op,ObjectOffset,phi,theta,alpha,im,ima,status);
   }
   else if(Op->type == NORMAL || Op->type == ANIMOBJ){
     if(DrawStatus == 0 || Op->quick_only == 1)
       DrawObject(hDC,Op,ObjectOffset,phi,theta,alpha,
                  im,ima,sx,sy,sz,status);
     else if(DrawStatus == 3 || (DrawStatus == 2 && Np != SelectedNode)
                        || (DrawStatus == 1 && Np == SelectedNode))
       DrawFullObject(hDC,Op,ObjectOffset,phi,theta,alpha,
                      im,ima,sx,sy,sz,status);
     else  DrawObject(hDC,Op,ObjectOffset,phi,theta,alpha,
                      im,ima,sx,sy,sz,status);
   }
   else if(Op->type == PARTICLE)
     DrawObject(hDC,Op,ObjectOffset,phi,theta,alpha,
                im,ima,sx,sy,sz,status);
   else if(Op->type == CAMERA){
     DrawActorBitmap(hDC,ObjectOffset,
                     phi,theta,alpha,0,0.0,status,0);
     if(show_camera_fov)DrawCameraFOV(hDC,status,Np,al_type,
                                      ObjectOffset,TrackedOffset,
                                      phi,theta,alpha,im,ima,sx,sy,sz);
     else DrawArrow(hDC,ObjectOffset,
                    phi,theta,alpha,im,ima,TVsizeX/20);
   }
   else if(Op->type == LIGHT){
     DrawActorBitmap(hDC,ObjectOffset,
                     phi,theta,alpha,im,ima,status,1);
     if(Op->lighttype == SPOTLIGHT){
       if(show_light_cones)DrawLightCone(hDC,status,Np,al_type,
                                         ObjectOffset,TrackedOffset,
                                         phi,theta,alpha,im,ima,sx,sy);
       else DrawArrow(hDC,ObjectOffset,
                      phi,theta,alpha,im,ima,TVsizeX/20);
     }
     if(Op->depth_cue && show_light_cones)
       DrawLightExtent(hDC,status,Np,al_type,ObjectOffset,sz);
   }
   else if(Op->type == GROUND)DrawGround(hDC,
     ObjectOffset,phi,theta,alpha,im,ima,status,sx,sy,sz);
   else if(Op->type == TARGET)DrawAxis(hDC,
     ObjectOffset,status);
   else if(Op->type == ROBOT){
     if(DrawStatus == 3 || (DrawStatus == 2 && Np != SelectedNode)
                        || (DrawStatus == 1 && Np == SelectedNode))
           DrawFullRobot(hDC,
                         Op,ObjectOffset,phi,theta,alpha,
                         im,ima,sx,sy,sz,status);
     else  DrawRobot(    hDC,
                         Op,ObjectOffset,phi,theta,alpha,
                         im,ima,sx,sy,sz,status);
   }
  }
  Op=Op->next;
 }
}

void DrawInvertNode(HDC hDC[], node *Np, short status){
 int i,oldROP[3];
 int ifd,ild;
 if(View == TRIVIEW){ifd=0;ild=3;}
 else               {ifd=ActiveView; ild=ifd+1;}
 if(hDC == NULL){
   HDC hdc[3];
   for(i=ifd;i<ild;i++){
     hdc[i]=GetDC(ghwnd_triview[i]);
//     SelectPalette(hdc[i],ghpaletteScreen,FALSE);
     SelectObject(hdc[i],ghInvertPen);
     RealizePalette (hdc[i]);
     oldROP[i]=SetROP2(hdc[i],R2_XORPEN);
   }
   DrawNode(hdc,Np,(short)abs(status));
   for(i=ifd;i<ild;i++){
     SetROP2(hdc[i],oldROP[i]);
     ReleaseDC(ghwnd_triview[i],hdc[i]);
   }
 }
 else{
   for(i=ifd;i<ild;i++){
     if(hDC[i] == NULL)return;
     oldROP[i]=SetROP2(hDC[i],R2_XORPEN);
   }
   DrawNode(hDC,Np,(short)abs(status));
   for(i=ifd;i<ild;i++){
     SetROP2(hDC[i],oldROP[i]);
     if(status >= 0)InvalidateRect(ghwnd_triview[i],NULL,FALSE);
   }
 }
}

void ReDrawStageDisplay(BOOL draw_selected){
 int i,oldROP[3];
 node     *Np;
 RECT rc;
 HDC hdc;
 int ifd,ild;
 HCURSOR lhcurSave;
 zoom_abort=0;
 if(View == TRIVIEW){ifd=0;ild=3;}
 else               {ifd=ActiveView; ild=ifd+1;}
 for(i=ifd;i<ild;i++){
   if(ghdc_triview_Bitmap[i] == NULL)return;
   if(ghbm_triview[i] == NULL)return;
   GetClientRect(ghwnd_triview[i],&rc);
   PatBlt(ghdc_triview_Bitmap[i],0,0,rc.right,rc.bottom,PATCOPY);
   SelectObject(ghdc_triview_Bitmap[i],ghDeselectedPen);
 }
 if(DrawStatus > 0 && global_quickdraw == 0)lhcurSave=SetCursor(ghcurWait);
 if(/*grid_on &&*/ draw_grid_on)DrawGrid(ghdc_triview_Bitmap);
 if((Np=FirstNp) != NULL)while(Np != NULL){
   if(Np != SelectedNode && Np->type != NORMAL && Np->type != ANIMOBJ){
     DrawNode(ghdc_triview_Bitmap,Np,DESELECTED);
   }
   Np=Np->next;
 }
 if((Np=FirstNp) != NULL)while(Np != NULL){
   if(Np != SelectedNode && (Np->type == NORMAL || Np->type == ANIMOBJ)){
     DrawNode(ghdc_triview_Bitmap,Np,DESELECTED);
   }
   Np=Np->next;
 }
 if(SelectedNode != NULL){
   if(tool != NOTOOL && tool != NODETOOL &&
      tool != PAN && tool != INZOOM){
     for(i=ifd;i<ild;i++){
       SelectObject(ghdc_triview_Bitmap[i],ghInvertPen);
       oldROP[i]=SetROP2(ghdc_triview_Bitmap[i],R2_XORPEN);
     }
   }
   else{
     for(i=ifd;i<ild;i++){
       SelectObject(ghdc_triview_Bitmap[i],ghSelectedPen);
     }
   }
   if(tool == PATHEDITOR)DrawNode(ghdc_triview_Bitmap,SelectedNode,EDITING);
   else if(draw_selected)DrawNode(ghdc_triview_Bitmap,SelectedNode,SELECTED);
   if(tool == TRACKER && subtool == SHIFTER)DrawActorTrack(ghdc_triview_Bitmap,0);
   if(tool == TRACKER && subtool == ANGLER )DrawActorRotations(ghdc_triview_Bitmap,0);
   if(tool != NOTOOL && tool != NODETOOL &&
      tool != PAN && tool != INZOOM)
     for(i=ifd;i<ild;i++)SetROP2(ghdc_triview_Bitmap[i],oldROP[i]);
 }
 for(i=ifd;i<ild;i++)DrawArrowIcons(ghdc_triview_Bitmap[i],i);
 if(DrawStatus > 0 && global_quickdraw == 0)SetCursor(lhcurSave);
 for(i=ifd;i<ild;i++){
   InvalidateRect(ghwnd_triview[i],NULL,FALSE);
   UpdateWindow(ghwnd_triview[i]);
 }
 return;
}

void ReDrawQuickDisplay(BOOL draw_selected){
 /* draw directly onto window surface */
 int i,oldROP[3];
 node     *Np;
 RECT rc;
 HDC hDC[3];
 HBRUSH hOldBrush[3];
 int ifd,ild;
 zoom_abort=0;
 if(View == TRIVIEW){ifd=0;ild=3;}
 else               {ifd=ActiveView; ild=ifd+1;}
 for(i=ifd;i<ild;i++){
   hDC[i]=GetDC(ghwnd_triview[i]);
   if(hDC[i] == NULL)return;
//   SelectPalette(hDC[i],ghpaletteScreen,FALSE);
   hOldBrush[i]=SelectObject(hDC[i],ghbrushWindow);
   RealizePalette(hDC[i]);
   GetClientRect(ghwnd_triview[i],&rc);
   PatBlt(hDC[i],0,0,rc.right,rc.bottom,PATCOPY);
   DrawArrowIcons(hDC[i],i);
   SelectObject(hDC[i],ghDeselectedPen);
 }
 if(draw_grid_on)DrawGrid(hDC);
 if((Np=FirstNp) != NULL)while(Np != NULL){
   if(Np != SelectedNode && Np->type != NORMAL && Np->type != ANIMOBJ){
     DrawNode(hDC,Np,DESELECTED);
   }
   Np=Np->next;
 }
 if(SelectedNode != NULL){
   if(tool != NOTOOL && tool != NODETOOL &&
      tool != PAN && tool != INZOOM){
     for(i=ifd;i<ild;i++){
       SelectObject(hDC[i],ghInvertPen);
       oldROP[i]=SetROP2(hDC[i],R2_XORPEN);
     }
   }
   else{
     for(i=ifd;i<ild;i++){
       SelectObject(hDC[i],ghSelectedPen);
     }
   }
   if(tool == PATHEDITOR)DrawNode(hDC,SelectedNode,EDITING);
   else if(draw_selected)DrawNode(hDC,SelectedNode,SELECTED);
   if(tool == TRACKER && subtool == SHIFTER)DrawActorTrack(hDC,0);
   if(tool == TRACKER && subtool == ANGLER )DrawActorRotations(hDC,0);
   if(tool != NOTOOL && tool != NODETOOL &&
      tool != PAN && tool != INZOOM)
     for(i=ifd;i<ild;i++)SetROP2(hDC[i],oldROP[i]);
 }
 for(i=ifd;i<ild;i++)SelectObject(hDC[i],ghDeselectedPen);
 if((Np=FirstNp) != NULL)while(Np != NULL){
   if(Np != SelectedNode && (Np->type == NORMAL || Np->type == ANIMOBJ)){
     DrawNode(hDC,Np,DESELECTED);
//     if(zoom_abort > 0)goto ABORT;
   }
   Np=Np->next;
 }
 if(SelectedNode != NULL){
   if(tool != NOTOOL && tool != NODETOOL &&
      tool != PAN && tool != INZOOM){
     for(i=ifd;i<ild;i++){
       SelectObject(hDC[i],ghInvertPen);
       oldROP[i]=SetROP2(hDC[i],R2_XORPEN);
     }
   }
   else{
     for(i=ifd;i<ild;i++){
       SelectObject(hDC[i],ghSelectedPen);
     }
   }
   if(tool == PATHEDITOR)DrawNode(hDC,SelectedNode,EDITING);
   else if(draw_selected)DrawNode(hDC,SelectedNode,SELECTED);
   if(tool == TRACKER && subtool == SHIFTER)DrawActorTrack(hDC,0);
   if(tool == TRACKER && subtool == ANGLER )DrawActorRotations(hDC,0);
   if(tool != NOTOOL && tool != NODETOOL &&
      tool != PAN && tool != INZOOM)
     for(i=ifd;i<ild;i++)SetROP2(hDC[i],oldROP[i]);
 }
// ABORT:
 for(i=ifd;i<ild;i++){
   SelectObject(hDC[i],hOldBrush[i]);
   ReleaseDC(ghwnd_triview[i],hDC[i]);
 }
 return;
}