FIREBALL.C

Go to the documentation of this file.

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

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

You may contact the OpenFX development team via elecronic mail
at core@openfx.org, or visit our website at http://openfx.org for
further information and support details.
-- */

/* fireball.c  image post-processor                                     */
/*                                                                      */

#include <stdlib.h>
#include <stdio.h>
#include <float.h>
#include <math.h>
#include <windows.h>
#include <commctrl.h>
#include "struct.h"           /* general structures    */
#include "..\common\postprocess\ximage.h"
#include "local.h"
#include "defines.h"

#include "fireball.h"

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

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

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

#include "utils.h"
#include "paint.c"

/************************** DLL entry point ********************************/

#if __WATCOMC__
int APIENTRY LibMain(HANDLE hDLL, DWORD dwReason, LPVOID lpReserved){
#elif __BC__
BOOL WINAPI DllEntryPoint(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(DllMain)
#endif

#define RS              (1.0/(double)RAND_MAX)
#define CF(c)           ((double)(c)/(double)(255))
#define FC(c)           ((unsigned char)(c*255.0))
#define VECCOPY(a,b)    { b[0] = a[0]; b[1] = a[1]; b[2] = a[2]; }
#define INVERT(a)       { a[0] = -a[0]; a[1] = -a[1]; a[2] = -a[2]; }
#define VECSUB(a,b,c)   { c[0]=a[0]-b[0]; c[1]=a[1]-b[1]; c[2]=a[2]-b[2];}
#define VECSUM(a,b,c)   { c[0]=a[0]+b[0]; c[1]=a[1]+b[1]; c[2]=a[2]+b[2];}
#define VECSCALE(a,b,c) { c[0]=(a)*b[0]; c[1]=(a)*b[1]; c[2]=(a)*b[2];}
#define DOT(a,b)        ( (a[0]*b[0]) + (a[1]*b[1]) + (a[2]*b[2]) )
#define CROSS(v1,v2,r)  { \
                          r[0] = (v1[1]*v2[2]) - (v2[1]*v1[2]);  \
                          r[1] = (v1[2]*v2[0]) - (v1[0]*v2[2]);  \
                          r[2] = (v1[0]*v2[1]) - (v2[0]*v1[1]);  \
                        }
#define ONE_256 3.90625e-3

static long GetSphereIntersection(vector d, vector P,
                                double radius,
                                double *dn, double *df){
 double ddotr,pdotr,a,a2,b,c,b4,mu1,mu2,lambda1,lambda2;
 vector A,B,tv;
 a=1.0;
 b=-2*(DOT(d,P));
 c=DOT(P,P)-radius*radius;
 b4=b*b-4.0*a*c;
 if(b4 < 0.0)return 0;
 else if(b4 < 1.e-10){
   *dn = *df = -b/(2*a);
 }
 else{
   b4=sqrt(b4);
   a2=0.5/a;
   mu1=(-b+b4)*a2;
   mu2=(-b-b4)*a2;
   if(mu1 < 0.0){
     *dn=0.0; *df=mu2;
   }
   else if(mu2 < 0){
     *dn=0.0; *df=mu1;
   }
   else{
     if(mu1 < mu2){*dn=mu1; *df=mu2;}
     else         {*dn=mu2; *df=mu1;}
   }
 }
 return 2;
}

static double NoiseScale=12000.0;
static vector color1={CF(252),CF(202),CF(  0)};
static vector color2={CF(225),CF( 30),CF( 30)};
static vector color3={0.1,0.1,0.1};
static BOOL flametype=FALSE;  // tendrils ?
static double linear_falloff;
static double stretch=1.0f;
static double regularity=0.2f;  // 0.0 - 1.0
static double levels=3.0f;
static double density=15.0f;
static double phase=0.0f;
static double drift=0.0f;
static BOOL explode=TRUE;
static BOOL smoke=TRUE;
static double fury=1.0f;
static double rfact;
static double m_ratio=1.0;

static void SetExplodeParameters(void){
 int i;
 density /= 50.0f;
 if(stretch !=0.0f) stretch = 1.0f/stretch;

 phase=m_ratio*300.0;

 if(explode && (phase < 0.0f || phase > 300.0f)) {  // Outside of explosion.
    rfact   = 0.0f;
    density = 0.0f;
 }
 else if(explode){ // In explosion
   rfact = (float)sqrt(phase/100.0f);
   if(phase > 100.0f) {
     float u = 1.0f - (phase-100.0f)/200.0f;
     density *= (u*u * (3.0f - 2.0f*u));
   }
   if(smoke){
     if(phase > 200.0f){ // Solid smoke
        VECCOPY(color3,color1)
        VECCOPY(color3,color2)
     }
     else if( phase > 100.0f){ // Interpolate to smoke color
       float u = (phase-100.0f)/100.0f;
       u = (u*u * (3.0f - 2.0f*u));
       for(i=0;i<3;i++){
         color1[i] += color3[i]*u - color1[i]*u;
         color2[i] += color3[i]*u - color2[i]*u;
       }
     }
   }
   // Convert phase to a reasonable value and
   // add in fury factor
   phase = (double)(sqrt(phase/75.0f))/2.0f * 5.0f * fury;
 }
 else{ // Not doing an explosion
   rfact = 1.0f;
   phase = phase/300.0f * 5.0f;
 }

 rfact *= (1.0+1.6*(1.0 - regularity));
}

double NoiseFunc(vector p, double phase, double levels, int invert,
                 XIMAGE *lpXimage){
  double nn;
  double sum = 0.0f;
  double l,f = 1.0f;
  for(l = levels; l>=1.0f; l-=1.0f) {
    nNoise(p[0]*f/NoiseScale+phase,
           p[1]*f/NoiseScale+phase,
           p[2]*f/NoiseScale+phase,
           &nn);
    nn = (nn-0.5)*0.3;
    sum += fabs(nn)/f;            //(double)fabs(noise4(p*f,phase))/f;
    f *= 2.0f;
  }
  if(l > 0.0f){
    nNoise(p[0]*f/NoiseScale+phase,
           p[1]*f/NoiseScale+phase,
           p[2]*f/NoiseScale+phase,
           &nn);
    nn = (nn-0.5)*0.3;
    sum += l*fabs(nn)/f;          //l*(double)fabs(noise4(p*f,phase))/f;
  }
  if(sum > 1.0)sum=1.0;
  if(invert){
    sum = 0.5f-sum;
    return sum>0.0f?sum:0.0f;
  }
  return sum;
}

static void TraceSphericalVolume(long Nsamples, vector dLook, vector pLight,
                                 double dns, double z, double dfs,
                                 double max_attn, vector colour,
                                 light *Lp, XIMAGE *lpXimage){
 vector c={0.0,0.0,0.0};
 double u,n,opac,o=0.0;
 long i;
 double ds;
 vector p,dp,dd;
 ds=(dfs-dns);
 if(z < dfs){
   max_attn = max_attn*(z-dns)/ds;
   dfs=min(z,dfs);
   ds=(dfs-dns);
 }
 ds=ds/(double)Nsamples;
 VECSCALE(dns,dLook,p)
 VECSCALE(ds,dLook,dd);
 for(i=0;i<Nsamples;i++){
//   VECSCALE(ds*(double)rand()*RS,dLook,dp) VECSUM(dp,p,dp)
   VECCOPY(p,dp)
   u=sqrt((dp[0]-pLight[0])*(dp[0]-pLight[0])+
          (dp[1]-pLight[1])*(dp[1]-pLight[1])+
          (dp[2]-pLight[2])*(dp[2]-pLight[2]));
   u *= linear_falloff/rfact;
   n=NoiseFunc(dp,phase,levels,flametype,lpXimage);
   if(u > regularity){
     n -= u-regularity;
     if(n < 0.0f)n=0.0f;
   }
   opac = (1.0f-u)*n*ds*density/200;
   c[0] += (color1[0]*n + (1.0f-n)*color2[0])*opac;
   c[1] += (color1[1]*n + (1.0f-n)*color2[1])*opac;
   c[2] += (color1[2]*n + (1.0f-n)*color2[2])*opac;
   o += opac;
   VECSUM(p,dd,p)
 }
 o = 1.0f - exp(-o);
 for(i=0;i<3;i++){
   c[i] = 1.0f - exp(-c[i]);
   colour[i] += c[i]-(colour[i]*o);
 }
 return;
}


long _RenderImageProcess(char *PrmList, XIMAGE *lpXimage){
 int i,j,k;
 char dummy[255];
 double tan_theta1,tan_theta2,cos_theta2;
 double Sx,Sy,dn,df,dns,dfs,dmin,dmax,l,mu,lambda;
 double noise_scale,radius_multiplier;
 long Xmax,Ymax,flames,type,id,nc,Nsamples,expl,smok;
 light *Lp;
 BOOL bOriginInCone,bIlluminated;
 vector d,dl,colour,phat;
 double tan_theta_sq;
 float *Zb;
 double z;
 fullscreenbuffer *S,*s;
 if(lpXimage->Nlights == 0 || lpXimage->Lights == NULL)return 1;
 sscanf(PrmList,"%s %ld %f %ld %ld %ld %ld %ld %ld %f %f %f %f"
                " %f %f %f %f %f %f %f %f %f",
        dummy,&version,
        &noise_scale,&flames,&type,&id,&Nsamples,&expl,&smok,
        &stretch,&regularity,&radius_multiplier,&density,
        &color1[0],&color1[1],&color1[2],
        &color2[0],&color2[1],&color2[2],
        &color3[0],&color3[1],&color3[2]);
 if(lpXimage->Morph && lpXimage->mParameters != NULL){
   m_ratio=lpXimage->MorphRatio;
 }
 else{
   m_ratio=(double)(lpXimage->last_frame - lpXimage->first_frame);
   if(m_ratio < 1.0)m_ratio=0.4;
   else m_ratio=(double)(lpXimage->this_frame - lpXimage->first_frame)/m_ratio;
 }
 if(expl == 0)explode=FALSE; else explode=TRUE;
 if(flames == 1)flametype=TRUE; else flametype=FALSE;
 NoiseScale *= noise_scale;
 SetExplodeParameters();
 Zb=lpXimage->Zbuffer;
 S=lpXimage->Screen;
 Xmax=lpXimage->Xmax;
 Ymax=lpXimage->Ymax;
 Sx=lpXimage->Xscale;
 Sy=lpXimage->Yscale;
 for(k=0;k<lpXimage->Nlights;k++){
   Lp=(lpXimage->Lights+k);
   if(type == 2 && Lp->type != DUMMYL)continue;
   if(type == 3 && Lp->AnimatorID != id)continue;
   if(Lp->type != SPOTLIGHT){ // non spots can only do if falloff
     if(Lp->dc){              // light fall off
       linear_falloff=Lp->dc_l/radius_multiplier;
       for(j=0;j<Ymax;j++){
         lpXimage->fp_Yield();
         if((lpXimage->fp_Terminate()) < 0)goto XXIT;
         for(i=0;i<Xmax;i++){
           d[2] = -((double)j + 0.5 - (double)Ymax/2.0)/Sy;
           d[2] *= stretch;
           d[0] =  ((double)i + 0.5 - (double)Xmax/2.0)/Sx;
           d[1] =  1.0;
           normalize(d);
           nc=GetSphereIntersection(d,Lp->p,rfact/linear_falloff,&dns,&dfs);
           if(nc > 1){  // inside sphere as well
             z = (double)(*(Zb + (j*Xmax)+i))/d[1];
             if(dns < z){
               s = (S+(j*Xmax)+i);
               colour[0]=ONE_256*(double)s->R;
               colour[1]=ONE_256*(double)s->G;
               colour[2]=ONE_256*(double)s->B;
               TraceSphericalVolume(Nsamples,d,Lp->p,dns,z,dfs,1.0,colour,Lp,lpXimage);
               s->R=(unsigned char)min(255L,(long)(256.0*colour[0]));
               s->G=(unsigned char)min(255L,(long)(256.0*colour[1]));
               s->B=(unsigned char)min(255L,(long)(256.0*colour[2]));
             }
           }
         }
       }
     }
   }
 }
 XXIT:
 return 1;
}

/*************** Function that renders any of the OpenGL Functionality ************/

long _RenderGLexternal(char *PrmList, XIMAGE *lpXimage){
MessageBox(NULL,"OpenGL function called","OK",MB_OK);
 return 1;
}

/*************** +++++++++++++++++++++++++++++++++++++++++++++++++++++ ************/

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

static double nvar=1.0;
static double radm=1.0;
static long   samples=16,flames=0,type=1,id = -1,expl=1,smok=1;
static vector c1={CF(252),CF(202),CF(  0)};
static vector c2={CF(225),CF( 30),CF( 30)};
static vector c3={0.1,0.1,0.1};
static double stre=1.0f;
static double regu=0.2f;  // 0.0 - 1.0
static double dens=15.0f;

static X__MEMORY_MANAGER *lpLocalEVI;

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[256];
 if(Op != NULL){  /* parameters exist so read them off the list */
   sscanf(Op,"%s %ld %f %ld %ld %ld %ld %ld %ld %f %f %f %f"
             " %f %f %f %f %f %f %f %f %f",
          buffer,&version,
          &nvar,&flames,&type,&id,&samples,&expl,&smok,
          &stre,&regu,&radm,&dens,
          &c1[0],&c1[1],&c1[2],
          &c2[0],&c2[1],&c2[2],
          &c3[0],&c3[1],&c3[2]);
 }
 lpLocalEVI=lpEVI;
 if(DialogBox(hDLLinstance,MAKEINTRESOURCE(DLG_FIREBALL),hWnd,
              (DLGPROC)DlgProc) == FALSE)return Op;
 if(Op != NULL)CALL_FREE(Op);  /* free the old string */
 sprintf(buffer,"%s %ld %f %ld %ld %ld %ld %ld %ld %f %f %f %f"
         " %f %f %f %f %f %f %f %f %f",name,version,
         nvar,flames,type,id,samples,expl,smok,
         stre,regu,radm,dens,
         c1[0],c1[1],c1[2],
         c2[0],c2[1],c2[2],
         c3[0],c3[1],c3[2]);
 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;
 }
 strcpy(Op,buffer);
 return Op;
}

static void LoadAnimatedClip(HWND hDlg){
 char *c,modname[256];
 GetModuleFileName(hDLLinstance,modname,255);
 if((c=strrchr(modname,'.')) != NULL){
   strcpy(c,".avi");
   Animate_Open(GetDlgItem(hDlg,DLG_IMAGE),modname);
   Animate_Play(GetDlgItem(hDlg,DLG_IMAGE),0, -1, -1);
 }
}

static void SetColour(unsigned char *colour, HWND parent){
 CHOOSECOLOR cc;
 static COLORREF CustColours[16]={
   RGB(255,255,255), RGB(239,239,239), RGB(223,223,223), RGB(207,207,207),
   RGB(191,191,191), RGB(175,175,175), RGB(159,159,159), RGB(143,143,143),
   RGB(127,127,127), RGB(111,111,111), RGB( 95, 95, 95), RGB( 79, 79, 79),
   RGB( 63, 63, 63), RGB( 47, 47, 47), RGB( 31, 31, 31), RGB( 15, 15, 15) };
 cc.lStructSize=sizeof(CHOOSECOLOR);
 cc.hwndOwner=parent;
 cc.rgbResult=RGB((BYTE)colour[0],(BYTE)colour[1],(BYTE)colour[2]);
 cc.lpCustColors=(LPDWORD)CustColours;
 cc.Flags= CC_RGBINIT;
 cc.lCustData=(DWORD)0;
 if(ChooseColor(&cc)){
   colour[0]=(unsigned char)GetRValue(cc.rgbResult);
   colour[1]=(unsigned char)GetGValue(cc.rgbResult);
   colour[2]=(unsigned char)GetBValue(cc.rgbResult);
 }
}

BOOL CALLBACK DlgProc(HWND hwnd,UINT msg,WPARAM wparam,LPARAM lparam){
 char str[32];
 switch( msg ) {
   case WM_INITDIALOG:
     sprintf(str,"%.3f",nvar);
     SetDlgItemText(hwnd,DLG_FIREBALL_NOISESCALE,str);  // Noise Variability
     sprintf(str,"%.3f",stre);
     SetDlgItemText(hwnd,DLG_FIREBALL_STRETCH,str);
     sprintf(str,"%.3f",regu);
     SetDlgItemText(hwnd,DLG_FIREBALL_REGULARITY,str);
     sprintf(str,"%.3f",radm);
     SetDlgItemText(hwnd,DLG_FIREBALL_RADIUSMULTIPLIER,str);
     sprintf(str,"%.3f",dens);
     SetDlgItemText(hwnd,DLG_FIREBALL_DENSITY,str);
     sprintf(str,"%ld",samples);
     SetDlgItemText(hwnd,DLG_FIREBALL_SAMPLES,str);
     if(flames == 1)SendDlgItemMessage(hwnd,DLG_FIREBALL_FLAMES,BM_SETCHECK,TRUE,0);
     if(expl   == 1)SendDlgItemMessage(hwnd,DLG_FIREBALL_EXPLODE,BM_SETCHECK,TRUE,0);
     if(type == 1)SendDlgItemMessage(hwnd,DLG_FIREBALL_TYPE1,BM_SETCHECK,TRUE,0);
     if(type == 2)SendDlgItemMessage(hwnd,DLG_FIREBALL_TYPE2,BM_SETCHECK,TRUE,0);
     if(type == 3)SendDlgItemMessage(hwnd,DLG_FIREBALL_TYPE3,BM_SETCHECK,TRUE,0);
     if(id >= 0)SendDlgItemMessage(hwnd,DLG_FIREBALL_NAME,WM_SETTEXT,
                0,(LPARAM)GetActorsName(lpLocalEVI->lpAni,id));
     LoadAnimatedClip(hwnd);
     CentreDialogOnScreen(hwnd);
     return TRUE;
   case WM_PAINT:
     PaintBackground(hwnd);
     break;
   case WM_DRAWITEM:{
       LPDRAWITEMSTRUCT lpdis;
       HBRUSH   hbr,hbrold;
       BYTE r,g,b;
       lpdis=(LPDRAWITEMSTRUCT)lparam;
       if(lpdis->CtlID == DLG_FIREBALL_COLOUR1 ||
          lpdis->CtlID == DLG_FIREBALL_COLOUR2 ||
          lpdis->CtlID == DLG_FIREBALL_COLOUR3){
         if(lpdis->CtlID == DLG_FIREBALL_COLOUR1){
           r=FC(c1[0]); g=FC(c1[1]); b=FC(c1[2]);
         }
         else if(lpdis->CtlID == DLG_FIREBALL_COLOUR2){
           r=FC(c2[0]); g=FC(c2[1]); b=FC(c2[2]);
         }
         else if(lpdis->CtlID == DLG_FIREBALL_COLOUR3){
           r=FC(c3[0]); g=FC(c3[1]); b=FC(c3[2]);
         }
         if(lpdis->itemState & ODS_SELECTED)
            InvertRect(lpdis->hDC,&(lpdis->rcItem));
         else{
           hbr=CreateSolidBrush(RGB(r,g,b));
           hbrold=SelectObject(lpdis->hDC,hbr);
           Rectangle(lpdis->hDC,lpdis->rcItem.left,lpdis->rcItem.top,
                         lpdis->rcItem.right,lpdis->rcItem.bottom);
           SelectObject(lpdis->hDC,hbrold);
           DeleteObject(hbr);
         }
       }
     }
     break;
   case WM_COMMAND:
     switch(LOWORD(wparam)){
        case DLG_FIREBALL_COLOUR1:{
            unsigned char colour[3];
            colour[0]=FC(c1[0]);
            colour[1]=FC(c1[1]);
            colour[2]=FC(c1[2]);
            SetColour(colour,hwnd);
            c1[0]=CF(colour[0]); c1[1]=CF(colour[1]); c1[2]=CF(colour[2]);
            InvalidateRect(GetDlgItem(hwnd,DLG_FIREBALL_COLOUR1),NULL,FALSE);
          }
          break;
        case DLG_FIREBALL_COLOUR2:{
            unsigned char colour[3];
            colour[0]=FC(c2[0]);
            colour[1]=FC(c2[1]);
            colour[2]=FC(c2[2]);
            SetColour(colour,hwnd);
            c2[0]=CF(colour[0]); c2[1]=CF(colour[1]); c2[2]=CF(colour[2]);
            InvalidateRect(GetDlgItem(hwnd,DLG_FIREBALL_COLOUR2),NULL,FALSE);
          }
          break;
        case DLG_FIREBALL_COLOUR3:{
            unsigned char colour[3];
            colour[0]=FC(c3[0]);
            colour[1]=FC(c3[1]);
            colour[2]=FC(c3[2]);
            SetColour(colour,hwnd);
            c3[0]=CF(colour[0]); c3[1]=CF(colour[1]); c3[2]=CF(colour[2]);
            InvalidateRect(GetDlgItem(hwnd,DLG_FIREBALL_COLOUR3),NULL,FALSE);
          }
          break;
        case DLG_FIREBALL_SETID:
          id=GetActorsID(lpLocalEVI->lpAni,hwnd);
          if(id >= 0)SendDlgItemMessage(hwnd,DLG_FIREBALL_NAME,WM_SETTEXT,
                     0,(LPARAM)GetActorsName(lpLocalEVI->lpAni,id));
          break;
        case IDCANCEL:
          EndDialog(hwnd,FALSE);
          return(TRUE);
        case IDOK:
          if(GetDlgItemText(hwnd,DLG_FIREBALL_NOISESCALE,str,12) != 0)
            sscanf(str,"%f",&nvar);
          if(GetDlgItemText(hwnd,DLG_FIREBALL_STRETCH,str,12) != 0)
            sscanf(str,"%f",&stre);
          if(GetDlgItemText(hwnd,DLG_FIREBALL_REGULARITY,str,12) != 0)
            sscanf(str,"%f",&regu);
          if(GetDlgItemText(hwnd,DLG_FIREBALL_RADIUSMULTIPLIER,str,12) != 0)
            sscanf(str,"%f",&radm);
          if(GetDlgItemText(hwnd,DLG_FIREBALL_DENSITY,str,12) != 0)
            sscanf(str,"%f",&dens);
          if(GetDlgItemText(hwnd,DLG_FIREBALL_SAMPLES,str,12) != 0)
            sscanf(str,"%ld",&samples);
          if(SendDlgItemMessage(hwnd,DLG_FIREBALL_FLAMES,BM_GETCHECK,0,0))
               flames=1;
          else flames=0;
          if(SendDlgItemMessage(hwnd,DLG_FIREBALL_EXPLODE,BM_GETCHECK,0,0))
               expl=1;
          else expl=0;
          if(SendDlgItemMessage(hwnd,DLG_FIREBALL_TYPE1,BM_GETCHECK,0,0))type=1;
          if(SendDlgItemMessage(hwnd,DLG_FIREBALL_TYPE2,BM_GETCHECK,0,0))type=2;
          if(SendDlgItemMessage(hwnd,DLG_FIREBALL_TYPE3,BM_GETCHECK,0,0))type=3;
          EndDialog(hwnd,TRUE);
          return(TRUE);
        default:
          break;
      }
      break;
    default: break;
 }
 return FALSE;
}


#if 0
old function
double NoiseFunc(vector p, double phase, double levels, int invert,
                 XIMAGE *lpXimage){
  double nn;
  double sum = 0.0f;
  double l,f = 1.0f;
  //return 0.5;
  //sTurbulence(p[0]*f/NoiseScale,p[1]*f/NoiseScale,p[2]*f/NoiseScale,&nn);
  //return nn;
  for(l = levels; l>=1.0f; l-=1.0f) {
    nNoise(p[0]*f/NoiseScale,p[1]*f/NoiseScale,p[2]*f/NoiseScale,&nn);
//    nNoise((p[0]*f/NoiseScale),
//           (p[1]*f/NoiseScale),
//           (p[2]*f/NoiseScale+phase),&nn);
    nn = (nn-0.5)*0.3;
    sum += fabs(nn)/f;            //(double)fabs(noise4(p*f,phase))/f;
    f *= 2.0f;
  }
  if(l > 0.0f){
    nNoise(p[0]*f/NoiseScale,p[1]*f/NoiseScale,p[2]*f/NoiseScale,&nn);
//    nNoise((p[0]*f/NoiseScale),
//           (p[1]*f/NoiseScale),
//           (p[2]*f/NoiseScale+phase),&nn);
    nn = (nn-0.5)*0.3;
    sum += l*fabs(nn)/f;          //l*(double)fabs(noise4(p*f,phase))/f;
  }
  //sum /= 3.333;
  if(sum > 1.0)sum=1.0;
  if(invert){
    sum = 0.5f-sum;
    return sum>0.0f?sum:0.0f;
  }
  return sum;
}
#endif