twist.c

Go to the documentation of this file.

/* --
OpenFX version 2.0 - Modelling, Animation and Rendering Package
Copyright (C) 2000 - 2007 OpenFX Development Team
-- */

/* TWIST.C external animation effect  (Windows NT version)                 */
/*                                                                         */
/* This effect twists the model about an axis in either the up/down  left/ */
/* right or up/down directions. The angle of the twist is specifed by the  */
/* user. The twist at the most negative co-ordinate of the model in the    */
/* axis direction is zero and reaches its maximum at the most positive     */
/* co-ordinate of the axis direction. The twist is zero at the first frame */
/* of the channel(time-line) and maximum in the last. Using a +ve twist    */
/* for one channel eg. frames 1-10 and a -ve  twist for a subsequent       */
/* channel eg. frames 11-20 will give the impression of the model twisting */
/* round and back.                                                         */
/*                                                                         */

#include <math.h>
#include <windows.h>
#include <commctrl.h>

#include "twist.h"

#if __ZTC__ || __SC__
#ifndef max
#define max(a,b)  ( ((a) > (b)) ? (a) : (b) )
#endif
#endif

#ifndef PI
#define PI 3.1415926
#endif

#if __X__MIPS__
BOOL WINAPI _CRT_INIT(HINSTANCE ,DWORD , LPVOID );
#endif

static HINSTANCE hDLLinstance=NULL; /* use to pick up resources from DLL   */


/**************  Structures that may be addressed externally ********/

#include "pstruct.h"

/************************** Local Utility Functions ***********************/

#include "paint.c"

#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:
#if __X__MIPS__
      if(!_CRT_INIT(hDLL,dwReason,lpReserved))return(int)FALSE;
#endif
      hDLLinstance = hDLL;  /* handle to DLL file */
      break;
    case DLL_PROCESS_DETACH:
#if __X__MIPS__
      if(!_CRT_INIT(hDLL,dwReason,lpReserved))return(int)FALSE;
#endif
      break;
  }
return (int)TRUE;
}

#if __SC__
#pragma startaddress(LibMain)
#endif

/*******************************************************************\
|                Code that define the effects                       |
\*******************************************************************/


long _RenderGlobalEffect
(char *PrmList, sfxinfo *SFXinfo, sfxdata *SFXdata, vertex *Vlist){
 return 1;
}

void _PreviewGlobalEffect
(char *PrmList, sfxinfo *SFXinfo, sfxdata *SFXdata, Svertex *Vlist){
 return;
}

long _RenderExternalEffect(char *PrmList, sfxinfo *SFXinfo,
                                 vertex *Vlist){
 double h,d,t,x,y;
 long i;
 int val;
 double PRMangle=60, angle, ang;
 char buffer[128];
 int PRMaxis, axis, paxis, paxis2, type;
 sscanf(PrmList,"%s %d %d %d",buffer,&PRMaxis,&type,&val);
 PRMangle=(double)val;  /* extract the maximum twist angle       */
 t=SFXinfo->time;       /* extract the percentage of the effect  */
 if     (PRMaxis == 3) axis=1;    /* F / B */
 else if(PRMaxis == 1) axis=2;    /* U / D */
 else if(PRMaxis == 2) axis=0;    /* L / R */
 if     (axis == 0){ paxis = 1; paxis2 = 2; }
 else if(axis == 2){ paxis = 1; paxis2 = 0; }
 else if(axis == 1){ paxis = 0; paxis2 = 2; }
 /* The axis of twist is known paxis and paxis2 are the axes perpendicular */
 /* to the axis about which the twist is occuring                          */
 if(type == 2) t = 1.00 - t;    /* Is it Un-Twist, Untwist starts with max */
                                /* twist at first frame of channed         */
 t = -1.00 * (t*t) + 2.00 * t;  /* Non-linear twist, apparent acceleration */
 angle=(PRMangle * PI/180) * t; /* maximum angle of twist at this frame    */
 for(i=0L; i < SFXinfo->nvert; i++){ /* for all vertices in model          */
  /* For each vertex get its distance from the minimum co-ordinate of the  */
  /* twist axis. Scale twist angle so that it is zero at the base.         */
  h=(double)(Vlist[i].p[axis] - SFXinfo->vmin[axis]) /
    (double)(SFXinfo->vmax[axis] - SFXinfo->vmin[axis]);
  ang=angle * h;
  /* Apply the twist to the co-ord axes perpendicular to twist axis        */
  x=Vlist[i].p[paxis]; y=Vlist[i].p[paxis2];
  Vlist[i].p[paxis]=(double)x*(double)cos(ang)-(double)y*(double)sin(ang);
  Vlist[i].p[paxis2]=(double)y*(double)cos(ang)+(double)x*(double)sin(ang);
 }
 return 1;
}

/********* Functions used to preview external effect                    ****/
/********* Return immediatly if no preview possible else do best approx ****/
/********* Note different data structures from Renderers requirement    ****/

void _PreviewExternalEffect(char *PrmList, sfxinfo *SFXinfo,
                                    Svertex *Vlist){
 /* For this effect the preview is a duplicate copy  of the effect itself. */
 /* The only difference is in the addressing of the Vertices.              */
 double h,d,t,x,y;
 long i;
 int val;
 double PRMangle=60, angle, ang;
 char buffer[128];
 int PRMaxis, axis, paxis, paxis2, type;
 sscanf(PrmList,"%s %d %d %d",buffer,&PRMaxis,&type,&val);
 PRMangle=(double)val;
 t=SFXinfo->time;
 if(PRMaxis == 3) axis=1;         /* F / B */
 else if(PRMaxis == 1) axis=2;    /* U / D */
 else if(PRMaxis == 2) axis=0;    /* L / R */
 if(axis == 0){      paxis = 1; paxis2 = 2; }
 else if(axis == 2){ paxis = 1; paxis2 = 0; }
 else if(axis == 1){ paxis = 0; paxis2 = 2; }
 if(type == 2) t = 1.00 - t;
 t = -1.00 * (t*t) + 2.00 * t;
 angle=(PRMangle * PI/180) * t;
 for(i=0L; i < SFXinfo->nvert; i++){
  h=(double)(Vlist[i][axis] - SFXinfo->vmin[axis]) /
    (double)(SFXinfo->vmax[axis] - SFXinfo->vmin[axis]);
  ang=angle * h;
  x=Vlist[i][paxis]; y=Vlist[i][paxis2];
  Vlist[i][paxis]=(double)x*(double)cos(ang)-(double)y*(double)sin(ang);
  Vlist[i][paxis2]=(double)y*(double)cos(ang)+(double)x*(double)sin(ang);
 }
 return;
}

/*************** Functions used to set up effect ***************/

/* Dialog box callback  */
BOOL CALLBACK TwistDlgProc(HWND hwnd,UINT msg,WPARAM wparam,LPARAM lparam);


/* Set defaults for the parameter variables, declare them as static so that
   they are available to the dialog function. They are here only for the
   function that edits the parameter list and must not be used in the
   code that is called from the renderer to execute the effect            */

static long type=1,PRMaxis=1,PRMangle=60;


/************ Functions called by the animator to set up effect *************/

char * _SetExternalParameters(
  char *Op,                 /* string for the parameters                  */
  HWND hWnd,                /* parent window                              */
  long ruler,               /* ruler scale value to facilitate scaling    */
  char *name,               /* name of DLL file with the effect           */
  X__MEMORY_MANAGER *lpEVI /* pointer to structure with memory functions */
                                    ){
/* output name and buffer should be as long as necessary to hold full string */
 char buffer[128];
 if(Op != NULL){  /* parameters exist so read them off the list */
   sscanf(Op,"%s %ld %ld %ld",buffer,&PRMaxis,&type,&PRMangle);
 }
/*   Do the user interface as required to set up the effect, may use a     */
/*   dialog box etc. Return old string if effect is cancelled (no change)  */

 if(DialogBox(hDLLinstance,MAKEINTRESOURCE(DLG_TWIST),hWnd,
              (DLGPROC)TwistDlgProc) == FALSE)return Op;

/* Free space occupied by old parameter string */
   if(Op != NULL)CALL_FREE(Op);  /* free the old string */
/* print the parameters into the buffer */
 sprintf(buffer,"%s %ld %ld %ld",name,PRMaxis,type,PRMangle);
/* Prepare the output buffer to take copy of parameter list */
 if((Op=(char *)CALL_MALLOC(strlen(buffer)+1)) == NULL){
  MessageBox (GetFocus(),"External effect: Out of memory","Error",
                MB_OK|MB_TASKMODAL|MB_ICONSTOP);
   return NULL;
 }
 /* Copy the parameter string to the output buffer */
 strcpy(Op,buffer);
//MessageBox(NULL,Op,"Output",MB_OK);
 return Op;
}

BOOL CALLBACK TwistDlgProc(HWND hwnd,UINT msg,WPARAM wparam,LPARAM lparam){
 int n,err,axisID[3]={DLG_TWIST_UD,DLG_TWIST_LR,DLG_TWIST_FB};
 char str[16];
 switch( msg ) {
   case WM_INITDIALOG:
     if(type == 2)SendDlgItemMessage(hwnd,DLG_TWIST_UNTWIST,BM_SETCHECK,1,0);
     else         SendDlgItemMessage(hwnd,DLG_TWIST_TWIST,BM_SETCHECK,1,0);
     SendDlgItemMessage(hwnd,axisID[PRMaxis-1],BM_SETCHECK,1,0);
     SetDlgItemInt(hwnd,DLG_TWIST_ANGLE,PRMangle,TRUE);
     LoadAnimatedClip(hwnd);
     CentreDialogOnScreen(hwnd);
     return TRUE;
   case WM_PAINT:
     PaintBackground(hwnd);
     break;
   case WM_SYSCOMMAND:
     switch(LOWORD(wparam & 0xfff0)){
       case SC_CLOSE:
         EndDialog(hwnd,FALSE);
         return(TRUE);
       default:
         break;
     }
     break;
   case WM_COMMAND:
     switch(LOWORD(wparam)){
        case DLG_TWIST_TWIST:           type=1;          break;
        case DLG_TWIST_UNTWIST:         type=2;          break;
        case DLG_TWIST_UD:              PRMaxis=1;       break;
        case DLG_TWIST_LR:              PRMaxis=2;       break;
        case DLG_TWIST_FB:              PRMaxis=3;       break;
        case DLG_TWIST_CANCEL:
          EndDialog(hwnd,FALSE);
          return(TRUE);
        case DLG_TWIST_OK:
          n=(int)GetDlgItemInt(hwnd,DLG_TWIST_ANGLE,&err,TRUE);
          if(!err){
            MessageBox (GetFocus(),"External effect: Error in angle setting",
               "Error",MB_OK|MB_TASKMODAL|MB_ICONSTOP);
            break;
          }
          else PRMangle=n;
          EndDialog(hwnd,TRUE);
          return(TRUE);
        default:
          break;
      }
      break;
    default: break;
 }
 return FALSE;
}