FOG.C

Go to the documentation of this file.

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

/* FOG.C  Image post-processor using Z buffer                            */
/*                                                                       */
/* Postprocessor showing the use of the Z buffer, user must have turned  */
/* this on. If it is NOT available the Zbuffer pointer in the XIMAGE     */
/* structure will be NULL. The user can set two distances between which  */
/* the FOG wil go from zero attenuation to a preset value. A Haze option */
/* automatically attenuates from full visibility at the camera to x% at  */
/* farthest value in Z buffer. Z buffer distances are float values of    */
/* World co-ordinates.                                                   */
/*                                                                       */

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

#include "fog.h"

#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"

/* utility function to set colour value */
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);
 }
}

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

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


long _RenderImageProcess(char *PrmList, XIMAGE *lpXimage){
 /* Z is UP, Y is forward (in front of observer, X to the RIGHT    */
 /* the camera is located at 0,0,0. All real numbers are floats    */
 /* xx and yy are screen co-ords of light (0,0) is at top left     */
 /* Zbuffer values are distances from Camera (at 0,0,0) to surface */
 /* visible in pixel. Z buffer addressing is similar to Screen     */
 /* buffer addressing.                                             */
 int i,j,ftype,id1,id2,idensity,cR,cG,cB;
 int mftype,midensity,mid1,mid2,mcR,mcG,mcB;
 double d1,d2,d12,density,density1,f,f1,zmax,zmin;
 double mr;
 char name_path[255];
 fullscreenbuffer *S;
 float *Z;
 BOOL bMorph;
 if((Z=lpXimage->Zbuffer) == NULL){
   MessageBox(GetFocus(),"Z buffer must be available for this effect",
              NULL,MB_OK);
   return 0;
 }
 sscanf(PrmList,"%s %d %d %d %d %d %d %d",name_path,&ftype,&idensity,
        &id1,&id2,&cR,&cG,&cB);
 if(lpXimage->Morph && lpXimage->mParameters != NULL){
   bMorph=TRUE; mr=lpXimage->MorphRatio;
   sscanf(lpXimage->mParameters,"%s %d %d %d %d %d %d %d",
          name_path,&mftype,&midensity,&mid1,&mid2,&mcR,&mcG,&mcB);
   id1=(long)((double)mid1 + mr*((double)id1-(double)mid1));
   id2=(long)((double)mid2 + mr*((double)id2-(double)mid2));
   idensity=(long)((double)midensity + mr*((double)idensity-(double)midensity));
   cR=(long)((double)mcR + mr*((double)cR-(double)mcR));
   cG=(long)((double)mcG + mr*((double)cG-(double)mcG));
   cB=(long)((double)mcB + mr*((double)cB-(double)mcB));
 }
 density=(double)idensity/100.0;
 density1=(1.0 - density);
 d1=(double)id1;
 d2=(double)id2;
 S=lpXimage->Screen;
 if(ftype == 0){ /* autoscaled haze    */
   zmin=FARAWAY; /* defined in utils.h */
   zmax=0.0;
   for(i=0;i<lpXimage->Ymax;i++){
     for(j=0;j<lpXimage->Xmax;j++){
       if(*Z < zmin)zmin = *Z;
       if(*Z > zmax && *Z < FARAWAY)zmax=*Z;
       Z++;
     }
   }
   Z=lpXimage->Zbuffer;  /* re-vector Z to start of buffer  */
   d1=zmin; d2=zmax;     /* set depth for this mist/haze    */
 }
 d12=density/(d2-d1);
//{char ttt[256]; sprintf(ttt,"Image size %ld by %ld d1=%lf d2=%lf",lpXimage->Xmax,lpXimage->Ymax,d1,d2);
//MessageBox(NULL,ttt,NULL,MB_OK);}
 for(i=0;i<lpXimage->Ymax;i++){
   for(j=0;j<lpXimage->Xmax;j++){
     if( *Z > d2){ /* total whiteout */
       S->R = (unsigned char)min(255.0,density*(double)cR+
                                      density1*(double)S->R);
       S->G = (unsigned char)min(255.0,density*(double)cG+
                                      density1*(double)S->G);
       S->B = (unsigned char)min(255.0,density*(double)cB+
                                      density1*(double)S->B);
     }
     else if( *Z > d1){ /* in the mist */
       f=(*Z - d1)*d12; f1=(1.0-f);
       S->R = (unsigned char)min(255.0,f*(double)cR+f1*(double)S->R);
       S->G = (unsigned char)min(255.0,f*(double)cG+f1*(double)S->G);
       S->B = (unsigned char)min(255.0,f*(double)cB+f1*(double)S->B);
     }
     S++; Z++;
   }
 }
 return 1;
}

/*************** Function that renders anyof the OpenGL Functionality ************/

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

/*************** Functions used to setup      ***************/


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

static double   d1=2.0,d2=10.0;
static int      ftype=0,density=80;
static unsigned char colour[3]={255,255,255};

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];
 long id1,id2;   /* integer scaled radius value */
 if(Op != NULL){  /* parameters exist so read them off the list */
   sscanf(Op,"%s %ld %ld %ld %ld %d %d %d",buffer,&ftype,&density,&id1,&id2,
          &colour[0],&colour[1],&colour[2]);
   d1=(double)id1/(double)ruler;
   d2=(double)id2/(double)ruler;
 }
 /*   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_FOG),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 */
 id1=(long)(d1*(double)ruler);
 id2=(long)(d2*(double)ruler);
 sprintf(buffer,"%s %ld %ld %ld %ld %d %d %d",name,ftype,density,id1,id2,
           colour[0],colour[1],colour[2]);
 /* 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;
}

BOOL CALLBACK DlgProc(HWND hwnd,UINT msg,WPARAM wparam,LPARAM lparam){
 /* a radius value of 1.0 will give a halo of radius 1.0  unit     */
 /* for whatever co-ordinate system is in use for this animation   */
 /* the size relative to the actors can be determined by using the */
 /* co-ord dialog to check on the size of the actors               */
 char str[32];
 switch( msg ) {
   case WM_INITDIALOG:
     if(ftype == 0)
       SendDlgItemMessage(hwnd,DLG_FOG_HAZE,BM_SETCHECK,TRUE,0);
     else
       SendDlgItemMessage(hwnd,DLG_FOG_FOG,BM_SETCHECK,TRUE,0);
     SetDlgItemInt(hwnd,DLG_FOG_DENSITY,(100-density),FALSE);
     sprintf(str,"%.2f",d1);
     SetDlgItemText(hwnd,DLG_FOG_D1,str);
     sprintf(str,"%.2f",d2);
     SetDlgItemText(hwnd,DLG_FOG_D2,str);
     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_FOG_COLOUR){
         r=(BYTE)colour[0]; g=(BYTE)colour[1]; b=(BYTE)colour[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_FOG_COLOUR:
          SetColour(colour,hwnd);
          InvalidateRect(GetDlgItem(hwnd,DLG_FOG_COLOUR),NULL,FALSE);
          break;
        case IDCANCEL:
          EndDialog(hwnd,FALSE);
          return(TRUE);
        case IDOK:
          if(SendDlgItemMessage(hwnd,DLG_FOG_FOG,BM_GETCHECK,0,0))
               ftype=1;
          else ftype=0;
          if(GetDlgItemText(hwnd,DLG_FOG_D1,str,12) != 0)d1=atof(str);
          if(GetDlgItemText(hwnd,DLG_FOG_D2,str,12) != 0)d2=atof(str);
          if(GetDlgItemText(hwnd,DLG_FOG_DENSITY,str,12) != 0)
            density=100-atoi(str);
          EndDialog(hwnd,TRUE);
          return(TRUE);
        default:
          break;
      }
      break;
    default: break;
 }
 return FALSE;
}