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

/* DOF.C  Image post-processor using Z buffer                            */
/*                                                                       */

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

#include "dof.h"

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

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

#include "utils.h"

#include "paint.c"

#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

long _RenderImageProcess(char *PrmList, XIMAGE *lpXimage){
 long v,i,j,k,l,ai,aj,n,atype,back,nmax,n2,Xres,Yres,id1;
 long matype,mback,mid1,mnmax;
 double d1,d2,ar,ag,ab,an,z,mr;
 char name_path[255];
 fullscreenbuffer *S,*So,*Si;
 float *Z;
#include "pro_key.c"
 if((Z=lpXimage->Zbuffer) == NULL){
   MessageBox(GetFocus(),"Z buffer must be available for this effect",
              NULL,MB_OK);
   return 0;
 }
 Xres=lpXimage->Xmax; Yres=lpXimage->Ymax;
 So=(fullscreenbuffer *)X__Malloc(Xres*Yres*(long)sizeof(fullscreenbuffer));
 if(So == NULL){
   MessageBox(GetFocus(),"Memory Out",NULL,MB_OK);
   return 0;
 }
 memcpy(So,lpXimage->Screen,sizeof(fullscreenbuffer)*Xres*Yres);
 sscanf(PrmList,"%s %ld %ld %ld %ld %ld",name_path,&nmax,&atype,&back,&id1,&v);
 if(lpXimage->Morph && lpXimage->mParameters != NULL){
   mr=lpXimage->MorphRatio;
   sscanf(lpXimage->mParameters,"%s %ld %ld %ld %ld %ld",
          name_path,&mnmax,&matype,&mback,&mid1,&v);
   id1=(long)((double)mid1 + mr*((double)id1-(double)mid1));
   nmax=(long)((double)mnmax + mr*((double)nmax-(double)mnmax));
 }
 d1=(double)id1;
 nmax=nmax*(Xres/320);
//sprintf(name_path,"nmax=%ld acc=%ld back=%ld",nmax,atype,back);
//MessageBox(NULL,name_path,"Debug",MB_OK);
 for(i=0;i<Yres;i++){
   for(j=0;j<Xres;j++){
     Z=(lpXimage->Zbuffer+(Xres*i)+j);
     if(!back && *Z > FARAWAY-10.0)continue;
     z=min(1.0,fabs(1.0-d1/(*Z)));
     n=1+(int)((double)nmax*z);
     n2=n/2;
     ar=ag=ab=an=0.0;
     for(k=0;k<n;k+=atype)for(l=0;l<n;l+=atype){
       ai=k-n2; aj=l-n2;
       if((i+ai) >= 0 && (j+aj) >= 0 &&
          (j+aj) < Xres && (i+ai) < Yres){
         Si=(lpXimage->Screen+(Xres*(i+ai))+(j+aj));
         ar+=(double)Si->R;
         ag+=(double)Si->G;
         ab+=(double)Si->B;
         an += 1.0;
       }
     }

     if(an > 0.0){
       S=(So+(Xres*i)+j);
       S->R = (unsigned char)(min(255.0,ar/an));
       S->G = (unsigned char)(min(255.0,ag/an));
       S->B = (unsigned char)(min(255.0,ab/an));
     }
   }
 }
 memcpy(lpXimage->Screen,So,sizeof(fullscreenbuffer)*Xres*Yres);
 X__Free(So);
 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;
}

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

static double   d1=2.0;
static int      version=1,samples=7,atype=1,back=1;

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 %ld",buffer,&samples,&atype,&back,&id1,&version);
   d1=(double)id1/(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_DOF),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);
 sprintf(buffer,"%s %ld %ld %ld %ld %ld",name,samples,atype,back,id1,version);
 /* 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){
 char str[32];
 BOOL err;
 switch( msg ) {
   case WM_INITDIALOG:
     sprintf(str,"%.2f",d1);
     SetDlgItemText(hwnd,DLG_DOF_D1,str);
     SetDlgItemInt(hwnd,DLG_DOF_SAMPLES,samples,FALSE);
     if(back == 1)SendDlgItemMessage(hwnd,DLG_DOF_BACK,BM_SETCHECK,TRUE,0);
     if     (atype == 1)
       SendDlgItemMessage(hwnd,DLG_DOF_ACC1,BM_SETCHECK,TRUE,0);
     else if(atype == 2)
       SendDlgItemMessage(hwnd,DLG_DOF_ACC2,BM_SETCHECK,TRUE,0);
     else
       SendDlgItemMessage(hwnd,DLG_DOF_ACC3,BM_SETCHECK,TRUE,0);
     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(GetDlgItemText(hwnd,DLG_DOF_D1,str,12) != 0)d1=atof(str);
          samples=GetDlgItemInt(hwnd,DLG_DOF_SAMPLES,&err,FALSE);
          if(samples < 0)samples=1;
          if(SendDlgItemMessage(hwnd,DLG_DOF_BACK,BM_GETCHECK,0,0))
               back=1;
          else back=0;
          if   (SendDlgItemMessage(hwnd,DLG_DOF_ACC3,BM_GETCHECK,0,0))
               atype=3;
          else if(SendDlgItemMessage(hwnd,DLG_DOF_ACC2,BM_GETCHECK,0,0))
               atype=2;
          else atype=1;
          EndDialog(hwnd,TRUE);
          return(TRUE);
        default:
          break;
      }
      break;
    default: break;
 }
 return FALSE;
}