explode.c

Go to the documentation of this file.

/* --
OpenFX version 2.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.
-- */

/* EXPLODE.C */

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

#include "explode.h"

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

#ifndef PI
#define PI   3.1415926
#endif
#define PI2  PI/2

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

#define DIST2(a,b)      (                                           \
                         (a[0]-(double)b[0]) * (a[0]-(double)b[0])  \
                        +(a[1]-(double)b[1]) * (a[1]-(double)b[1])  \
                        +(a[2]-(double)b[2]) * (a[2]-(double)b[2])  \
                        )

int version=1;

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

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

#include "pstruct.h"

static void scal(double t[4][4], double sx, double sy, double sz){
 long i,j;
 for(i=0;i<4;i++) for(j=0;j<4;j++) t[i][j]=0.0;
 t[0][0]=sx; t[1][1]=sy; t[2][2]=sz; t[3][3]=1;
 return;
}

static void rotz(double tr[4][4], double ang){
 short i,j;
 for(i=0;i<4;i++)
 for(j=0;j<4;j++)
 {
  tr[i][j]=0.0;
  if(i == j)tr[i][j]=1.0;
 }
  tr[0][0]= cos(ang);
  tr[0][1]=-sin(ang);
  tr[1][0]= sin(ang);
  tr[1][1]= cos(ang);
  return;
}

static void roty(double tr[4][4], double ang){
 short i,j;
 for(i=0;i<4;i++)
 for(j=0;j<4;j++)
 {
  tr[i][j]=0.0;
  if(i == j)tr[i][j]=1.0;
 }
  tr[0][0]= cos(ang);
  tr[0][2]=-sin(ang);
  tr[2][0]= sin(ang);
  tr[2][2]= cos(ang);
  return;
}

static void rotx(double tr[4][4], double ang){
 long i,j;
 for(i=0;i<4;i++)
 for(j=0;j<4;j++)
 {
  tr[i][j]=0.0;
  if(i == j)tr[i][j]=1.0;
 }
  tr[1][1]= cos(ang);
  tr[1][2]=-sin(ang);
  tr[2][1]= sin(ang);
  tr[2][2]= cos(ang);
  return;
}

static void tram(double t[4][4], double dx, double dy, double dz){
 short i,j;
 for(i=0;i<4;i++)
 for(j=0;j<4;j++)
 {
  t[i][j]=0.0;
  if(i == j)t[i][j]=1.0;
 }
 t[0][3]=dx;
 t[1][3]=dy;
 t[2][3]=dz;
 t[3][3]=1;
 return;
}

static void m4by4(double t1[4][4], double t2[4][4], double tr[4][4]){
 short n=4,i,j,k;
 for(i=0;i<4;i++)
 for(j=0;j<4;j++)
 {
  tr[i][j]=0.0;
  for(k=0;k<4;k++)tr[i][j]=tr[i][j]+t1[i][k]*t2[k][j];
 }
 return;
}

static void m4by1(double t4[4][4], vector v, vector vv){
 vv[0]=t4[0][0]*v[0]+t4[0][1]*v[1]+t4[0][2]*v[2]+t4[0][3];
 vv[1]=t4[1][0]*v[0]+t4[1][1]*v[1]+t4[1][2]*v[2]+t4[1][3];
 vv[2]=t4[2][0]*v[0]+t4[2][1]*v[1]+t4[2][2]*v[2]+t4[2][3];
 return;
}

static void c4to4(double tin[4][4], double tout[4][4]){
 short i,j;
 for(i=0;i<4;i++)
 for(j=0;j<4;j++)
 tout[i][j]=tin[i][j];
}

static void null_transform(double t[4][4]){
 short i,j;
 for(i=0;i<4;i++)
 for(j=0;j<4;j++)
 if(i == j)t[i][j]=1.0;
 else      t[i][j]=0.0;
}

static void rotate_round_vector(double angle, vector v, double t[4][4]){
  double dx,dy,dz,phi,theta,dxy;
  double t1[4][4],t2[4][4],t3[4][4];
  angle *= PI/180.0;
  dx=v[0]; dy=v[1]; dz=v[2];
  dxy=dx*dx+dy*dy;
  if(dxy < 0.00001){ /* vertical so just rotate about z  and return */
    if(dz > 0.0)rotz(t, angle);
    else        rotz(t,-angle);
    return;
  }
  dxy=sqrt(dxy);
  if     (dx == 0.0 && dy > 0.0)phi =  PI2;
  else if(dx == 0.0 && dy < 0.0)phi = -PI2;
  else phi = atan2(dy,dx);
  theta = atan2(dz,dxy);
  rotz(t3, -phi);
  roty(t2, -theta);
  m4by4(t2,t3,t1);
  rotx(t2, angle);
  m4by4(t2,t1,t3);
  roty(t2,theta);
  m4by4(t2,t3,t1);
  rotz(t2,phi);
  m4by4(t2,t1,t);
}

static BOOL normalise(vector v){
  double n,nn;
  n= (double)((v[0]*v[0]) + (v[1]*v[1]) + (v[2]*v[2]));
  if(n < 1.e-10)return FALSE;
  nn=sqrt(n);
  n = 1.0 / nn;
  VECSCALE(n,v,v)
  return TRUE;
}

#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

static double GetT(double shock, double t, vector dv,
                   double dmin, double dmax){
 double d;
 d=sqrt(dv[0]*dv[0]+dv[1]*dv[1]+dv[2]*dv[2]);
 d=(d-dmin)*dmax;
 if(t < d)return 0.0;
 return t=t-d;
}


static void GetSpin(int type, vector p, vector d, double t, double spin[4][4]){
 static vector up={0.0,0.0,1.0};
 vector a;
 double angle;
 if(type == 0)VECCOPY(up,a)
 else{
   CROSS(d,up,a)
   if(!normalise(a))VECCOPY(up,a)  /* a is axis of rotation */
 }
 angle = t*360.0;
 rotate_round_vector(angle,a,spin);
 return;
}

static void SpinIntoPosition(vector pp, vector dd, vector dp, double flr,
                             double spin[4][4], long type){
 vector dpp;
 m4by1(spin,dp,dpp);
 VECSUM(pp,dpp,dp)
 if(type == 2)dp[2]=max(dp[2],flr);
 return;
}

static void GetVandA(double df, double dex, long type,
                     double *V, double *A){
 if(type == 0){  // assumes velocity falls to zero at end
   *V = 2.0*dex;
   *A = 0.0;
 }
 else{
   *A = sqrt(2.0*dex) + sqrt(2.0*(dex+df));
   *A = (*A) * (*A);
   *V = sqrt(2.0*(*A)*dex);
 }
 return;
}

static void GetPosition(vector p, vector d, vector po,
                        double df, double dex, double t,
                        double V, double A, double floor,
                        vector pp, vector dd, long type){
 // p is face centroid
 // d is out direction normalised
 // pp is new face centroid position
 // dd is new direction  not used
 // po is original position
 // t is interpolation time
 // df is distance
 // V is initial velocity
 // A is acceleration due to gravity
 if(type == 0){
   VECCOPY(d,dd)
   VECSCALE(V*t*(1.0-0.5*t),d,pp)
   VECSUM(p,pp,pp)
 }
 else{
   double ca,sa,r,ti,c;
   vector dxy;
   dxy[0]=d[0]; dxy[1]=d[1]; dxy[2]=0.0;
   normalise(dxy); ca=DOT(d,dxy);
   sa=sqrt(1.0 - ca*ca); if(p[2] < po[2])sa = -sa;
   c=(V*V*sa*sa - 2.0*A*(floor-p[2]));
   if(c >= 0){// if before first bounce fall through
     if(c > 0)c=sqrt(c);
     ti = (V*sa + c)/A;
     if(t > ti){ // subsequent bounces
       double vx,vy,dt;
       vector pnew;
       r = V*ca*ti;
       pnew[0]=p[0]+r*dxy[0];
       pnew[1]=p[1]+r*dxy[1];
       pnew[2]=p[2]+V*sa*ti-0.5*A*ti*ti;
       vx=V*ca; vy=A*ti-V*sa;
       V=sqrt(vx*vx+vy*vy);
       ca=vx/V; sa=vy/V; V *= 0.5; // attenuation
       t=t-ti;
       dt=2.0*V*sa/A;
       if(ti+dt > 1.0){
         VECCOPY(pnew,pp);
         pp[2]=max(pp[2],floor); // comment out this line - flat finish
         return;
       }
       if(t > dt)t=dt;
       r = V*ca*t;
       pp[0]=pnew[0]+r*dxy[0];
       pp[1]=pnew[1]+r*dxy[1];
       pp[2]=pnew[2]+V*sa*t-0.5*A*t*t;
       pp[2]=max(pp[2],floor); // comment out this line for totally flat finish
       return;
     }
   }
   r = V*ca*t;
   pp[0]=p[0]+r*dxy[0];
   pp[1]=p[1]+r*dxy[1];
   pp[2]=p[2]+V*sa*t-0.5*A*t*t;
   pp[2]=max(pp[2],floor); // comment out this line for totally flat finish
 }
 return;
}

static void MoveIntoPosition(vector pp, vector dd, vector dp, double flr,
                             long type){
 VECSUM(pp,dp,dp)
 if(type == 2)dp[2]=max(dp[2],flr);
 return;
}

long _RenderGlobalEffect
(char *PrmList, sfxinfo *SFXinfo, sfxdata *SFXdata, vertex *Vlist){
 long Nv;
 char buffer[128];
 long i,type,x,y,z,idf,idex,icentre,ifix,itumble,ishock,tumbletype;
 double t,tt,df,dex,V,A,spin[4][4],floor,zmax,dmin,dmax,di,shock;
 vector p,pp,po,d,dd,d0,d1,d2;
#include "pro_key.c"
 sscanf(PrmList,"%s %ld %ld %ld %ld %ld %ld %ld %ld %ld %ld %ld %ld",
  buffer,&version,&type,&x,&y,&z,&idf,&idex,&icentre,&ifix,&itumble,
  &ishock,&tumbletype);
 shock=(double)ishock/100.0;
 if(icentre == 1){ // centre on given point
   po[0]=(double)x; po[1]=(double)y; po[2]=(double)z;
 }
 else VECCOPY((double)SFXdata->pos,po)
 df=(double)idf; dex=(double)idex;
 if(type == 2){ // fall to ground
  if(SFXdata->ground)df=po[2]-(double)SFXdata->ground_pos[2];
 }
 floor=po[2]-df-10.0;  // just above the floor
 Nv=SFXinfo->nvert;
 if(ifix == 1)t=1.0;             // go straight to end
 else t=(double)SFXinfo->time;   // is on a 0-1 scale
 if((Nv/3)*3 != Nv)return 1;     // must be multiple of 3 after split
 if(type > 0 || ishock > 0){
   dmax = zmax = -1.e20; dmin = 1.e30;
   for(i=0;i<Nv;i++){
     di=DIST2(po,Vlist[i].p); if(di > dmax)dmax=di; if(di < dmin)dmin=di;
     if((double)Vlist[i].p[2] > zmax)zmax=(double)Vlist[i].p[2];
   }
   if(dmax-dmin < 100.0)ishock=0;   // no difference
   else {
     dmin=sqrt(dmin); dmax=shock/(sqrt(dmax)-dmin);
   }
   if(type > 0)df += (zmax - po[2]);
 }
 GetVandA(df,dex,type,&V,&A);
 for(i=0;i<Nv;i+=3){        // for each face
   VECSUM((double)Vlist[i].p,(double)Vlist[i+1].p,p)
   VECSUM((double)Vlist[i+2].p,p,p)
   VECSCALE(0.333,p,p)
   VECSUB((double)Vlist[i  ].p,p,d0)
   VECSUB((double)Vlist[i+1].p,p,d1)
   VECSUB((double)Vlist[i+2].p,p,d2)
   VECSUB(p,po,d)                               // -> from centre of exp
   if(ishock > 0)tt=GetT(shock,t,d,dmin,dmax);
   else          tt=t;
   if(!normalise(d))MessageBeep(MB_OK);
   GetPosition(p,d,po,df,dex,tt,V,A,floor,pp,dd,type);
   if(itumble == 0){
     MoveIntoPosition(pp,dd,d0,floor,type);  // d0 will be new vertex posn
     MoveIntoPosition(pp,dd,d1,floor,type);
     MoveIntoPosition(pp,dd,d2,floor,type);
   }
   else{
     GetSpin(tumbletype,p,d,tt,spin);
     SpinIntoPosition(pp,dd,d0,floor,spin,type);  // d0 will be new vertex posn
     SpinIntoPosition(pp,dd,d1,floor,spin,type);
     SpinIntoPosition(pp,dd,d2,floor,spin,type);
   }
   VECCOPY((long)d0,Vlist[i].p)
   VECCOPY((long)d1,Vlist[i+1].p)
   VECCOPY((long)d2,Vlist[i+2].p)
 }
 return 1;
}

void _PreviewGlobalEffect
(char *PrmList, sfxinfo *SFXinfo, sfxdata *SFXdata, Svertex *Vlist){
 long Nv;
 char buffer[128];
 long i,type,x,y,z,idf,idex,icentre,ifix,itumble,ishock,tumbletype;
 double t,tt,df,dex,V,A,spin[4][4],floor,zmax,shock,dmin,dmax,di;
 vector p,pp,po,d,dd,d0,d1,d2;
#include "pro_key1.c"
 sscanf(PrmList,"%s %ld %ld %ld %ld %ld %ld %ld %ld %ld %ld %ld %ld",
  buffer,&version,&type,&x,&y,&z,&idf,&idex,&icentre,&ifix,&itumble,
  &ishock,&tumbletype);
 shock=(double)ishock/100.0;
 if(icentre == 1){ // centre on given point
   po[0]=(double)x; po[1]=(double)y; po[2]=(double)z;
 }
 else VECCOPY((double)SFXdata->pos,po)
 df=(double)idf; dex=(double)idex;
 if(type == 2){ // fall to ground
  if(SFXdata->ground)df=po[2]-(double)SFXdata->ground_pos[2];
 }
 floor=po[2]-df-10.0;  // just above the floor
 Nv=SFXinfo->nvert;
 if(ifix == 1)t=1.0;             // go straight to end
 else t=(double)SFXinfo->time;   // is on a 0-1 scale
 if((Nv/3)*3 != Nv)return;       // must be multiple of 3 after split
 if(type > 0 || ishock > 0){
   dmax = zmax = -1.e20; dmin = 1.e30;
   for(i=0;i<Nv;i++){
     if(ishock > 0){
       di=DIST2(po,Vlist[i]); if(di > dmax)dmax=di; if(di < dmin)dmin=di;
     }
     if((double)Vlist[i][2] > zmax)zmax=(double)Vlist[i][2];
   }
   if(dmax-dmin < 100.0)ishock=0;   // no difference
   else {
     dmin=sqrt(dmin); dmax=shock/(sqrt(dmax)-dmin);
   }
   if(type > 0)df += (zmax - po[2]);
 }
 GetVandA(df,dex,type,&V,&A);
 for(i=0;i<Nv;i+=3){        // for each face
   VECSUM((double)Vlist[i],(double)Vlist[i+1],p)
   VECSUM((double)Vlist[i+2],p,p)
   VECSCALE(0.333,p,p)
   VECSUB((double)Vlist[i  ],p,d0)
   VECSUB((double)Vlist[i+1],p,d1)
   VECSUB((double)Vlist[i+2],p,d2)
   VECSUB(p,po,d)                               // -> from centre of exp
   if(ishock > 0)tt=GetT(shock,t,d,dmin,dmax);
   else          tt=t;
   if(!normalise(d))MessageBeep(MB_OK);
   GetPosition(p,d,po,df,dex,tt,V,A,floor,pp,dd,type);
   if(itumble == 0){
     MoveIntoPosition(pp,dd,d0,floor,type);  // d0 will be new vertex posn
     MoveIntoPosition(pp,dd,d1,floor,type);
     MoveIntoPosition(pp,dd,d2,floor,type);
   }
   else{
     GetSpin(tumbletype,p,d,tt,spin);
     SpinIntoPosition(pp,dd,d0,floor,spin,type);  // d0 will be new vertex posn
     SpinIntoPosition(pp,dd,d1,floor,spin,type);
     SpinIntoPosition(pp,dd,d2,floor,spin,type);
   }
   VECCOPY((long)d0,Vlist[i])
   VECCOPY((long)d1,Vlist[i+1])
   VECCOPY((long)d2,Vlist[i+2])
 }
 return;
}

long _RenderExternalEffect(char *PrmList, sfxinfo *SFXinfo,
                                 vertex *Vlist){
#if 0
 long i;   // testing face accesibility
 face *f;
 char buffer[128];
#include "pro_key.c"
 sscanf(PrmList,"%s %d",buffer,&version);
 if(SFXinfo->Nfaces > 0 && SFXinfo->Faces != NULL){
   f=(face *)SFXinfo->Faces;
   for(i=0;i<SFXinfo->Nfaces;i++){
     f->color[0]=255; f->color[1] = f->color[2] = 0;
     f++;
   }
 }
#endif
 return 1;
}

void _PreviewExternalEffect(char *PrmList, sfxinfo *SFXinfo,
                                    Svertex *Vlist){
 return;
}

static long ix,iy,iz,type=0,idf,idex,icentre=0,ifix=0,itumble=0,
            shock=0,tumbletype=0;
double df=1.0,dex=1.0,x=0.0,y=0.0,z=0.0;

BOOL CALLBACK EffectDlgProc(HWND hwnd,UINT msg,WPARAM wparam,LPARAM lparam);

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 */
                                    ){
 char buffer[128];
 if(Op != NULL){  /* parameters exist so read them off the list */
   sscanf(Op,"%s %ld %ld %ld %ld %ld %ld %ld %ld %ld %ld %ld %ld",buffer,&version,
          &type,&ix,&iy,&iz,&idf,&idex,&icentre,&ifix,&itumble,&shock,
          &tumbletype);
   df=(double)idf/(double)ruler;
   dex=(double)idex/(double)ruler;
   x=(double)ix/(double)ruler;
   y=(double)iy/(double)ruler;
   z=(double)iz/(double)ruler;
 }
 if(DialogBox(hDLLinstance,MAKEINTRESOURCE(DLG_EXPLODE),hWnd,
              (DLGPROC)EffectDlgProc) == FALSE)return Op;
 if(Op != NULL)CALL_FREE(Op);  /* free the old string */
 idf=df*(double)ruler;
 idex=dex*(double)ruler;
 ix=x*(double)ruler;
 iy=y*(double)ruler;
 iz=z*(double)ruler;
 sprintf(buffer,"%s %ld %ld %ld %ld %ld %ld %ld %ld %ld %ld %ld %ld",
         name,version,type,ix,iy,iz,idf,idex,icentre,ifix,itumble,
         shock,tumbletype);
 if((Op=(char *)CALL_MALLOC(strlen(buffer)+1)) == NULL){
  MessageBox (GetFocus(),"External effect: Out of memory",NULL,
                MB_OK|MB_TASKMODAL|MB_ICONSTOP);
   return NULL;
 }
 strcpy(Op,buffer);
 return Op;
}

BOOL CALLBACK EffectDlgProc(HWND hwnd,UINT msg,WPARAM wparam,LPARAM lparam){
 BOOL err;
 char str[16];
 switch( msg ) {
   case WM_INITDIALOG:
     if(type == 0)
       SendDlgItemMessage(hwnd,DLG_EXPLODE_TYPE0,BM_SETCHECK,TRUE,0);
     if(type == 1)
       SendDlgItemMessage(hwnd,DLG_EXPLODE_TYPE1,BM_SETCHECK,TRUE,0);
     if(type == 2)
       SendDlgItemMessage(hwnd,DLG_EXPLODE_TYPE2,BM_SETCHECK,TRUE,0);
     if(icentre == 0)
       SendDlgItemMessage(hwnd,DLG_EXPLODE_CENTRE,BM_SETCHECK,TRUE,0);
     if(icentre == 1)
       SendDlgItemMessage(hwnd,DLG_EXPLODE_POINT,BM_SETCHECK,TRUE,0);
     if(itumble == 1)
       SendDlgItemMessage(hwnd,DLG_EXPLODE_TUMBLE,BM_SETCHECK,TRUE,0);
     if(tumbletype == 0)
       SendDlgItemMessage(hwnd,DLG_EXPLODE_TTYPE0,BM_SETCHECK,TRUE,0);
     if(tumbletype == 1)
       SendDlgItemMessage(hwnd,DLG_EXPLODE_TTYPE1,BM_SETCHECK,TRUE,0);
     if(ifix == 1)
       SendDlgItemMessage(hwnd,DLG_EXPLODE_FIX,BM_SETCHECK,TRUE,0);
     sprintf(str,"%.2f",x);
     SetDlgItemText(hwnd,DLG_EXPLODE_X,str);
     sprintf(str,"%.2f",y);
     SetDlgItemText(hwnd,DLG_EXPLODE_Y,str);
     sprintf(str,"%.2f",z);
     SetDlgItemText(hwnd,DLG_EXPLODE_Z,str);
     sprintf(str,"%.2f",df);
     SetDlgItemText(hwnd,DLG_EXPLODE_FALLD,str);
     sprintf(str,"%.2f",dex);
     SetDlgItemText(hwnd,DLG_EXPLODE_DEX,str);
     SetDlgItemInt(hwnd,DLG_EXPLODE_SHOCK,shock,FALSE);
     LoadAnimatedClip(hwnd);
     CentreDialogOnScreen(hwnd);
     return TRUE;
   case WM_PAINT:
     PaintBackground(hwnd);
     break;
   case WM_COMMAND:
     switch(LOWORD(wparam)){
        case IDCANCEL:
          EndDialog(hwnd,FALSE);
          return(TRUE);
        case IDOK:
          if(SendDlgItemMessage(hwnd,DLG_EXPLODE_TYPE2,BM_GETCHECK,0,0))
            type=2;
          else if(SendDlgItemMessage(hwnd,DLG_EXPLODE_TYPE1,BM_GETCHECK,0,0))
            type=1;
          else
            type=0;
          if(SendDlgItemMessage(hwnd,DLG_EXPLODE_POINT,BM_GETCHECK,0,0))
            icentre=1;
          else
            icentre=0;
          if(SendDlgItemMessage(hwnd,DLG_EXPLODE_TUMBLE,BM_GETCHECK,0,0))
            itumble=1;
          else
            itumble=0;
          if(SendDlgItemMessage(hwnd,DLG_EXPLODE_TTYPE1,BM_GETCHECK,0,0))
               tumbletype=1;
          else tumbletype=0;
          if(SendDlgItemMessage(hwnd,DLG_EXPLODE_FIX,BM_GETCHECK,0,0))
            ifix=1;
          else
            ifix=0;
          if(GetDlgItemText(hwnd,DLG_EXPLODE_X,str,12) != 0)
            x=atof(str);
          if(GetDlgItemText(hwnd,DLG_EXPLODE_Y,str,12) != 0)
            y=atof(str);
          if(GetDlgItemText(hwnd,DLG_EXPLODE_Z,str,12) != 0)
            z=atof(str);
          if(GetDlgItemText(hwnd,DLG_EXPLODE_FALLD,str,12) != 0)
            df=atof(str);
          if(GetDlgItemText(hwnd,DLG_EXPLODE_DEX,str,12) != 0)
            dex=atof(str);
          shock=GetDlgItemInt(hwnd,DLG_EXPLODE_SHOCK,&err,FALSE);
          EndDialog(hwnd,TRUE);
          return(TRUE);
        default:
          break;
      }
      break;
    default: break;
 }
 return FALSE;
}