PYRO.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.
-- */

#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 "pyro.h"
#include "resource.h"

#ifndef PI
#define PI  3.1415926535
#endif

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

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

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

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

void FillColourRect(HWND hwnd, DWORD colour);

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

#if __SC__
#pragma startaddress(DllMain)
#endif

/* Colour references for the custom colours in the full colour dialog*/
COLORREF acrCustClr[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)};

X__MEMORY_MANAGER  *lpLocalEVI;

/*******************************************************************\
|                Code that executes the process                     |
\*******************************************************************/

long _RenderImageProcess(char *PrmList, XIMAGE *lpXimage){

 long i, j,seed, ruler, t_of_explode;
 double Xuser, Yuser, Zuser, Xview, Yview, Zview, xx, yy, Xpos, Ypos, Zpos, velocity, dist;
 double time, theta, phi, Xexp, Yexp, Zexp, expvel, expmax;
 long launchframe, spark, no_sparks;
 int redval, greenval, blueval, factor, trails;
 double Xstart, Ystart, Zstart, ground;
 long id1, id2, type;
 DWORD colour;
 BOOL source, target;
 light *lightptr;
 int lightcount;
 char dummy[255];
 char test[255];
 fullscreenbuffer *S;
 float *Z;
 /* read the parameters from the parameter list */
 sscanf(PrmList,"%s %d %d %f %d %X %f %f %f %f %f %f %f %d %d %d %d %d %d",dummy, &seed, &launchframe, &expmax,
            &no_sparks, &colour, &Xstart, &Ystart, &Zstart, &Xexp, &Yexp, &Zexp, 
            &ground, &id1, &id2, &source, &target, &type, &ruler);
  /* set local pointer to start of screen buffer */
 S=lpXimage->Screen;
 Z=lpXimage->Zbuffer;
 lightptr=lpXimage->Lights;
 srand(seed);
 redval=GetRValue(colour);
 greenval=GetGValue(colour);
 blueval=GetBValue(colour);

 /* Is source selected rather than defined? if so find 3-D position */
 if(source==FALSE){
  for(lightcount=0;lightcount<lpXimage->Nlights;lightcount++){
     if(lightptr->AnimatorID==id1){
       Xstart=(lightptr->pin[0])/(double)ruler;
       Ystart=(lightptr->pin[1])/(double)ruler;
       Zstart=(lightptr->pin[2])/(double)ruler;
     }
     lightptr++;
  }
 }

 
 /* Is target selected rather than defined? if so find 3-D position */
 if(target==FALSE){
   for(lightcount=0;lightcount<lpXimage->Nlights;lightcount++){
     if(lightptr->AnimatorID==id2){
       Xexp=(lightptr->pin[0])/(double)ruler;
       Yexp=(lightptr->pin[1])/(double)ruler;
       Zexp=(lightptr->pin[2])/(double)ruler;
     }
     lightptr++;
   }
 }

 velocity=(10.0*(sqrt((Zexp-Zstart)/5.0)));
 time=(((double)(lpXimage->this_frame))-((double)(launchframe)))/4.0;
 t_of_explode=((long)((velocity/10.0)*(4.0))+(double)(launchframe));


 /*code that describes the flight path of the rocket (not used for the fountain type)*/

 if(type!=1)
 if (lpXimage->this_frame>=launchframe && lpXimage->this_frame<=t_of_explode){
  /*find co-ordinates of projectile at any time*/
  Xuser=Xstart+(time*((Xexp-Xstart)/((double)(t_of_explode-launchframe)/4.0)));
  Yuser=Ystart+(time*((Yexp-Ystart)/((double)(t_of_explode-launchframe)/4.0)));
  Zuser=Zstart+(((velocity)*(time))-((5.0)*(time)*(time)));
  /*scale co-ordinates to tranformable co-ordinates*/
   Xpos=Xuser*(double)ruler;
  Ypos=Yuser*(double)ruler;
  Zpos=Zuser*(double)ruler;

  TransformIntoView(lpXimage->ViewTransform,Xpos,Ypos,Zpos,&Xview,&Yview,&Zview);
  
  /*Draw in buffer the position of the rocket*/
  if (Yview>=1.000){      /*all points in front of viewer */
  /*scale to appear in buffer (image size is Xmax by Ymax)*/
    xx=(double)lpXimage->Xmax/2.0 + (lpXimage->Xscale*Xview/Yview);
    yy=(double)lpXimage->Ymax/2.0 - (lpXimage->Yscale*Zview/Yview);

    if ((long)xx>=0 && (long)xx<lpXimage->Xmax && (long)yy>=0 && (long)yy<lpXimage->Ymax){
      i=(long)xx;
      j=(long)yy;
      /*check the Z-buffer to see if anything is in the way*/
      if((float)Yview<*(Z+(j*(lpXimage->Xmax))+i)){
        (S+(j*(lpXimage->Xmax))+i)->R=255;
        (S+(j*(lpXimage->Xmax))+i)->G=255;
        (S+(j*(lpXimage->Xmax))+i)->B=255;
        *(Z+(j*(lpXimage->Xmax))+i)=Yview;  /*update the Z-buffer with the new depth value*/
      }
    }
  }
 }

 /*code that executes the explosion*/

 if(lpXimage->this_frame>t_of_explode || (type==1 && lpXimage->this_frame>launchframe)){

   if(type==1){
     time=(((double)(lpXimage->this_frame))-((double)(launchframe)))/4.0;
   }else{
     time=(((double)(lpXimage->this_frame))-((double)(t_of_explode)))/4.0;
   }
   
   for(spark=0;spark<no_sparks;spark++){
    /*choose random angles to describe the initial direction of each spark*/
    if(type!=1){
      theta=(((double)(rand())*(2.0*PI))/(double)(RAND_MAX+1));
      phi=(((double)(rand())*(2.0*PI))/(double)(RAND_MAX+1));
      expvel=(10.0*(sqrt(expmax/5.0))) ;
    }else{
      theta=(((double)(rand())*(2.0*PI))/(double)(RAND_MAX+1));
      phi=(((double)(rand())*(PI/18.0))/(double)(RAND_MAX+1))+(PI/2.0);
      expvel=(20.0*(sqrt(expmax/5.0))) ;
    }
    /*for each spark and its trails find its current position*/
    for(trails=0;trails<10;trails++){

      if(type!=1){

        Xuser=Xexp+((expvel)*(cos(phi))*(cos(theta))*(time+((double)(trails)/30.0)));
        Yuser=Yexp+((expvel)*(cos(phi))*(sin(theta))*(time+((double)(trails)/30.0)));
        Zuser=Zexp+(((expvel)*(sin(phi))*(time+((double)(trails)/30.0)))-
              ((1.8)*(time+((double)(trails)/30.0))*(time+((double)(trails)/30.0))));
      }else{
        Xuser=Xstart+((expvel)*(cos(phi))*(cos(theta))*(time+((double)(trails)/30.0))-50);
        Yuser=Ystart+((expvel)*(cos(phi))*(sin(theta))*(time+((double)(trails)/30.0))-50);
        Zuser=Zstart+(((expvel)*(sin(phi))*(time+((double)(trails)/30.0)))-
              ((2.5)*(time+((double)(trails)/30.0))*(time+((double)(trails)/30.0))));
      }

      if (Zuser<ground){      /*ground detection*/
        Zuser=ground;
      }
      /*scaling*/
      Xpos=Xuser*(double)ruler;  
      Ypos=Yuser*(double)ruler;
      Zpos=Zuser*(double)ruler;

      TransformIntoView(lpXimage->ViewTransform,Xpos,Ypos,Zpos,&Xview,&Yview,&Zview);

      /*draw in buffer the sparks and trails and twinkles if the user has specified it*/
      if (Yview>=1.000){    /*all points in front of viewer */
      /*scale to appear in buffer (image size is Xmax by Ymax)*/

        xx=(double)lpXimage->Xmax/2.0 + (lpXimage->Xscale*Xview/Yview);
        yy=(double)lpXimage->Ymax/2.0 - (lpXimage->Yscale*Zview/Yview);

        if ((long)xx>=0 && (long)xx<lpXimage->Xmax && (long)yy>=0 && (long)yy<lpXimage->Ymax-1){
          i=(long)xx;
          j=(long)yy;
          factor=((20*rand())/RAND_MAX+1)+15;
          /*check the Z-buffer to see if anything is in the way*/
          if((float)Yview<*(Z+(j*(lpXimage->Xmax))+i)){    
            if(trails==9 && type!=1){
              (S+(j*(lpXimage->Xmax))+i)->R=max((S+(j*(lpXimage->Xmax))+i)->R,255-(factor*time));
              (S+(j*(lpXimage->Xmax))+i)->G=max((S+(j*(lpXimage->Xmax))+i)->G,255-(factor*time));
              (S+(j*(lpXimage->Xmax))+i)->B=max((S+(j*(lpXimage->Xmax))+i)->B,255-(factor*time));
              *(Z+(j*(lpXimage->Xmax))+i)=Yview;  /*update the Z-buffer with the new depth value*/
              if(lpXimage->this_frame%8==0 || (lpXimage->this_frame-1)%8==0 || (lpXimage->this_frame-2)%8==0 || (lpXimage->this_frame-3)%8==0){
                if(type==2 && i>=0 && i<lpXimage->Xmax && j+1>=0 && j+1<=lpXimage->Ymax-1){
                  (S+((j+1)*(lpXimage->Xmax))+i)->R=max((S+(j*(lpXimage->Xmax))+i)->R,255-(factor*time));
                  (S+((j+1)*(lpXimage->Xmax))+i)->G=max((S+(j*(lpXimage->Xmax))+i)->G,255-(factor*time));
                  (S+((j+1)*(lpXimage->Xmax))+i)->B=max((S+(j*(lpXimage->Xmax))+i)->B,255-(factor*time));
                  *(Z+((j+1)*(lpXimage->Xmax))+i)=Yview;  /*update the Z-buffer with the new depth value*/
                }
                if(type==2 && i>=0 && i<lpXimage->Xmax && j-1>=0 && j-1<=lpXimage->Ymax-1){
                  (S+((j-1)*(lpXimage->Xmax))+i)->R=max((S+(j*(lpXimage->Xmax))+i)->R,255-(factor*time));
                  (S+((j-1)*(lpXimage->Xmax))+i)->G=max((S+(j*(lpXimage->Xmax))+i)->G,255-(factor*time));
                  (S+((j-1)*(lpXimage->Xmax))+i)->B=max((S+(j*(lpXimage->Xmax))+i)->B,255-(factor*time));
                  *(Z+((j-1)*(lpXimage->Xmax))+i)=Yview;  /*update the Z-buffer with the new depth value*/
                }
                if(type==2 && i+1>=0 && i+1<lpXimage->Xmax && j>=0 && j<=lpXimage->Ymax-1){
                  (S+(j*(lpXimage->Xmax))+i+1)->R=max((S+(j*(lpXimage->Xmax))+i)->R,255-(factor*time));
                  (S+(j*(lpXimage->Xmax))+i+1)->G=max((S+(j*(lpXimage->Xmax))+i)->G,255-(factor*time));
                  (S+(j*(lpXimage->Xmax))+i+1)->B=max((S+(j*(lpXimage->Xmax))+i)->B,255-(factor*time));
                  *(Z+(j*(lpXimage->Xmax))+i+1)=Yview;  /*update the Z-buffer with the new depth value*/
                }
                if(type==2 && i-1>=0 && i-1<lpXimage->Xmax && j>=0 && j<=lpXimage->Ymax-1){
                  (S+(j*(lpXimage->Xmax))+i-1)->R=max((S+(j*(lpXimage->Xmax))+i)->R,255-(factor*time));
                  (S+(j*(lpXimage->Xmax))+i-1)->G=max((S+(j*(lpXimage->Xmax))+i)->G,255-(factor*time));
                  (S+(j*(lpXimage->Xmax))+i-1)->B=max((S+(j*(lpXimage->Xmax))+i)->B,255-(factor*time));
                  *(Z+(j*(lpXimage->Xmax))+i-1)=Yview;  /*update the Z-buffer with the new depth value*/
                }
              }
            }else{
              (S+(j*(lpXimage->Xmax))+i)->R=max((S+(j*(lpXimage->Xmax))+i)->R,redval-(factor*time));
              (S+(j*(lpXimage->Xmax))+i)->G=max((S+(j*(lpXimage->Xmax))+i)->G,greenval-(factor*time));
              (S+(j*(lpXimage->Xmax))+i)->B=max((S+(j*(lpXimage->Xmax))+i)->B,blueval-(factor*time));
              *(Z+(j*(lpXimage->Xmax))+i)=Yview;  /*update the Z-buffer with the new depth value*/
            }
          }
        }
      }
    }
  }   
 }


 /*code that produces the initial flash of the firework*/

 if(lpXimage->this_frame>t_of_explode+1 && lpXimage->this_frame<t_of_explode+6){
   for(j=0;j<lpXimage->Ymax-1;j++)  /* do rows in screen buffer */
   for(i=0;i<lpXimage->Xmax;i++){  /* do all pixles in row j   */
   /* add a little white for pixel i,j to give the illusion of a flash*/
    S->R = min(255,(unsigned char)((double)S->R + (5.0/time)));
    S->G = min(255,(unsigned char)((double)S->G + (5.0/time)));
    S->B = min(255,(unsigned char)((double)S->B + (5.0/time)));
    S++;             /* point to next pixels in screen buffer */
   }
 }
 return 1;          /* all done OK                           */
}

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

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


/*************** Functions used for set up  ***************/


/* local variable for communication between dialog box and Setup function */
long seed=5643;
long launchframe=1;
long sparks=100;
double expmax=5.0;
DWORD colour=0x000000FF;
BOOL source=TRUE;
BOOL target=TRUE;
double Xstart=0.0;
double Ystart=0.0;
double Zstart=0.0;
double Xexp=0.0;
double Yexp=0.0;
double Zexp=200.0;
double ground=0.0;
long id1=0;
long id2=0;
long type=0;


/* Dialog box callback prototype */
BOOL CALLBACK DlgProc(HWND hwnd,UINT msg,WPARAM wparam,LPARAM lparam);
BOOL CALLBACK DlgHelp(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 */
                                    ){
 /* output buffer should be as long as necessary to hold full string        */
 char buffer[256];

 lpLocalEVI=lpEVI;
 
 if(Op != NULL){  /* parameters exist so read them off the list */
   sscanf(Op,"%s %d %d %f %d %X %f %f %f %f %f %f %f %d %d %d %d %d",buffer, &seed, &launchframe, &expmax,
              &sparks, &colour, &Xstart, &Ystart, &Zstart, &Xexp, &Yexp, &Zexp,
              &ground, &id1, &id2, &source, &target, &type);
 }
  
 /*   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_PYRO),hWnd,
              (DLGPROC)DlgProc) == 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 %d %d %f %d %X %f %f %f %f %f %f %f %d %d %d %d %d %d",name, seed, launchframe, expmax,
              sparks, colour, Xstart, Ystart, Zstart, Xexp, Yexp, Zexp, ground,
              id1, id2, source, target, type, ruler);
 /* 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);
 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);
 }
}

BOOL CALLBACK DlgProc(HWND hwnd,UINT msg,WPARAM wparam,LPARAM lparam){
 CHOOSECOLOR cs;
 PAINTSTRUCT ps;
 char str[32];
 char test[32];
 switch( msg ) {
   case WM_INITDIALOG:
     /* prime dialog box controls     */
     if(source==TRUE){
    SendDlgItemMessage(hwnd,DLG_RADFIXED,BM_SETCHECK,1,0);
   }else{
    SendDlgItemMessage(hwnd,DLG_RADNAMED,BM_SETCHECK,1,0);
   }
   if(target==TRUE){
    SendDlgItemMessage(hwnd,DLG_TARFIXED,BM_SETCHECK,1,0);
   }else{
      SendDlgItemMessage(hwnd,DLG_TARNAMED,BM_SETCHECK,1,0);
   }
   switch(type){
    case 0:
      SendDlgItemMessage(hwnd,DLG_NORMAL,BM_SETCHECK,1,0);
      break;
    case 1:
      SendDlgItemMessage(hwnd,DLG_FOUNTAIN,BM_SETCHECK,1,0);
      break;
    case 2:
      SendDlgItemMessage(hwnd,DLG_TWINKLE,BM_SETCHECK,1,0);
      break;
    default:
      break;
   }
   if(id1>=1)SendDlgItemMessage(hwnd,IDC_SNAME,WM_SETTEXT,0,
              (LPARAM)GetActorsName(lpLocalEVI->lpAni,id1));
   if(id2>=1)SendDlgItemMessage(hwnd,IDC_TNAME,WM_SETTEXT,0,
              (LPARAM)GetActorsName(lpLocalEVI->lpAni,id2));
  
   sprintf(str,"%d",seed);
     SetDlgItemText(hwnd,DLG_SEED,str);
   sprintf(str,"%d",launchframe);
     SetDlgItemText(hwnd,DLG_FRAME,str);
   sprintf(str,"%.3f",expmax);
   SetDlgItemText(hwnd,DLG_RADIUS,str);
   sprintf(str,"%d",sparks);
   SetDlgItemText(hwnd,DLG_SPARK,str);
   sprintf(str,"%.3f",Xstart);
   SetDlgItemText(hwnd,DLG_XSTART,str);
   sprintf(str,"%.3f",Ystart);
   SetDlgItemText(hwnd,DLG_YSTART,str);
   sprintf(str,"%.3f",Zstart);
   SetDlgItemText(hwnd,DLG_ZSTART,str);
   sprintf(str,"%.3f",Xexp);
   SetDlgItemText(hwnd,DLG_XEXP,str);
   sprintf(str,"%.3f",Yexp);
   SetDlgItemText(hwnd,DLG_YEXP,str);
   sprintf(str,"%.3f",Zexp);
   SetDlgItemText(hwnd,DLG_ZEXP,str);
   sprintf(str,"%.3f",ground);
   SetDlgItemText(hwnd,DLG_GROUND,str);
     LoadAnimatedClip(hwnd);
   CentreDialogOnScreen(hwnd);
     return TRUE;
   case WM_PAINT:
     PaintBackground(hwnd);
     break;
     return TRUE;
   case WM_COMMAND:
     switch(LOWORD(wparam)){
        case IDCANCEL:    /* user clicked cancel                            */
          EndDialog(hwnd,FALSE);
          return(TRUE);
    case DLG_COLOUR:
      cs.lStructSize=sizeof(CHOOSECOLOR);
      cs.hwndOwner=hwnd;
      cs.lpCustColors =(LPDWORD) acrCustClr;
      cs.Flags=CC_FULLOPEN;
      ChooseColor(&cs);
      colour=cs.rgbResult;
      FillColourRect(hwnd,colour);
      return (TRUE);
    case DLG_RADFIXED:
      source=TRUE;
      return (TRUE);
    case DLG_RADNAMED:
      source=FALSE;
      return (TRUE);
    case DLG_TARFIXED:
      target=TRUE;
      return (TRUE);
    case DLG_TARNAMED:
      target=FALSE;
      return (TRUE);
    case DLG_NORMAL:
      type=0;
      return (TRUE);
    case DLG_FOUNTAIN:
      type=1;
      return (TRUE);
    case DLG_TWINKLE:
      type=2;
      return (TRUE);
    case DLG_CHOOSELAUNCH:
      id1=GetActorsID(lpLocalEVI->lpAni,hwnd);
      if (id1>=0)SendDlgItemMessage(hwnd,IDC_SNAME,WM_SETTEXT,0,
              (LPARAM)GetActorsName(lpLocalEVI->lpAni,id1));
      return (TRUE);
    case DLG_CHOOSEEXP:
      id2=GetActorsID(lpLocalEVI->lpAni,hwnd);
      if (id2>=0)SendDlgItemMessage(hwnd,IDC_TNAME,WM_SETTEXT,0,
              (LPARAM)GetActorsName(lpLocalEVI->lpAni,id2));
      return (TRUE);
    case DLG_HELP:
      if(DialogBox(hDLLinstance,MAKEINTRESOURCE(IDD_HELP),hwnd,
              (DLGPROC)DlgHelp)!=1)return(FALSE);
      return (TRUE);
    case IDOK:        /* OK so get numbers from the Dailog Box controls */
         if(GetDlgItemText(hwnd,DLG_SEED,str,12) != 0)
            sscanf(str,"%d",&seed);
      if(GetDlgItemText(hwnd,DLG_FRAME,str,12) != 0)
            sscanf(str,"%d",&launchframe);
      if(GetDlgItemText(hwnd,DLG_RADIUS,str,12) != 0)
            sscanf(str,"%f",&expmax);
      if(GetDlgItemText(hwnd,DLG_SPARK,str,12) != 0)
            sscanf(str,"%d",&sparks);
      if(GetDlgItemText(hwnd,DLG_XSTART,str,12) !=0)
        sscanf(str,"%f",&Xstart);
      if(GetDlgItemText(hwnd,DLG_YSTART,str,12) !=0)
        sscanf(str,"%f",&Ystart);
      if(GetDlgItemText(hwnd,DLG_ZSTART,str,12) !=0)
        sscanf(str,"%f",&Zstart);
      if(GetDlgItemText(hwnd,DLG_XEXP,str,12) !=0)
        sscanf(str,"%f",&Xexp);
      if(GetDlgItemText(hwnd,DLG_YEXP,str,12) !=0)
        sscanf(str,"%f",&Yexp);
      if(GetDlgItemText(hwnd,DLG_ZEXP,str,12) !=0)
        sscanf(str,"%f",&Zexp);
      if(GetDlgItemText(hwnd,DLG_GROUND,str,12) != 0)
            sscanf(str,"%f",&ground);
      if (Zstart>Zexp && source==TRUE && target==TRUE){
        MessageBox(NULL,"Explosion height must be greater than source height.",NULL,MB_OK);
          return(TRUE);

      }else{
        EndDialog(hwnd,TRUE);
      }
        default:
          break;
      }
      break;
    default: break;
 }
 return FALSE;
}

void FillColourRect(HWND hwnd, DWORD colour){
  HDC hdc;
  HBRUSH hBrush,hBrushOld;
  RECT rect;
  POINT point1, point2;

  GetWindowRect(GetDlgItem(hwnd,DLG_COLOUR),&rect);
  point1.x=rect.left;
  point1.y=rect.top;
  point2.x=rect.right;
  point2.y=rect.bottom;
  ScreenToClient(hwnd,&point1);
  ScreenToClient(hwnd,&point2);
  rect.left=point1.x+1;
  rect.top=point1.y+1;
  rect.right=point2.x-1;
  rect.bottom=point2.y-1;

  hdc=GetDC(hwnd);
  hBrush=CreateSolidBrush(colour);
  hBrushOld=SelectObject(hdc,hBrush);
  FillRect(hdc,&rect,hBrush);
  SelectObject(hdc,hBrushOld);
  DeleteObject(hBrush);
  ReleaseDC(hwnd,hdc);
}


BOOL CALLBACK DlgHelp(HWND hwnd,UINT msg,WPARAM wparam,LPARAM lparam){
  switch( msg ) {
    case WM_INITDIALOG:
      CentreDialogOnScreen(hwnd);
      return TRUE;
    case WM_COMMAND:
      switch(LOWORD(wparam)){
        case IDCANCEL:    /* user clicked cancel                            */
        EndDialog(hwnd,FALSE);
        return(TRUE);
    case IDOK:        
            EndDialog(hwnd,TRUE);
        return (TRUE);
       default:
        break;
      }
      break;
    default: break;
 }
 return FALSE;
}