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

/* Droplets  Image post-processor using Z buffer                            */

#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 "droplets.h"

static long version=0;

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

//#include "..\animate\wspaces.c"

unsigned char *LoadMAP(char *name, int *x, int *y);

#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

static void DrawRingInBuffer(fullscreenbuffer *Screen, long X, long Y,
                             long x, long y, long radius){
 long i,j;
 double d,dc;
 long oradius,iradius;
 double minV=0.0,maxV=1.0;
 fullscreenbuffer *S;
 oradius=radius;
 iradius=oradius-20;
 dc=0.5*(double)(iradius+oradius);
 for(i=x-oradius;i<=x+oradius;i++)for(j=y-oradius;j<=y+oradius;j++){
   if(i < 0 || i >= X || j < 0 || j >= Y)continue;
   S=(Screen + j*X + i);
   d=sqrt((double)(i-x)*(double)(i-x) + (double)(j-y)*(double)(j-y));
   if(d >= (double)iradius && d <= (double)oradius){
     if(d > dc){
       d=maxV-(maxV-minV)*(d-dc)/((double)oradius-dc);
     }
     else{
       d=minV+(maxV-minV)*(d-(double)iradius)/(dc-(double)iradius);
     }
     S->R = (unsigned char)min(255.0,(double)S->R+d*255);
     S->G = (unsigned char)min(255.0,(double)S->G+d*255);
     S->B = (unsigned char)min(255.0,(double)S->B+d*255);
   }
 }
 return;
}

static void DrawRingsInBuffer(fullscreenbuffer *B, long X, long Y){
 DrawRingInBuffer(B,X,Y,X/2,Y/2,X/4);
 DrawRingInBuffer(B,X,Y,X/4,Y/3,X/6);
 DrawRingInBuffer(B,X,Y,3*X/4,2*Y/3,X/6);
 return;
}

long _RenderImageProcess(char *PrmList, XIMAGE *lpXimage){
 double mr;
 char name_path[256],imagefile[256];
 fullscreenbuffer *Screen,*BackBuffer;
 BOOL bMorph=FALSE;
 long cR,cG,cB,mcR,mcG,mcB,dummy,type,hold,back,lframe,nx,ny,Xmax,Ymax,frame;
 sscanf(PrmList,"%s %ld %ld %ld %ld %ld %ld %ld %ld %ld %ld %s",name_path,
        &version,&type,&hold,
        &nx,&ny,&cR,&cG,&cB,&back,&lframe,imagefile);
 if(lpXimage->Morph && lpXimage->mParameters != NULL){
   bMorph=TRUE; mr=lpXimage->MorphRatio;
   sscanf(lpXimage->mParameters,
          "%s %ld %ld %ld %ld %ld %ld %ld %ld",
          name_path,&version,&dummy,&dummy,&dummy,&dummy,&dummy,
          &mcR,&mcG,&mcB);
 }
 if(!bMorph){
   mr=(double)(lpXimage->last_frame - lpXimage->first_frame);
   if(mr < 1.0)mr=0.0; //return 1;
   else mr=(double)(lpXimage->this_frame - lpXimage->first_frame)/mr;
 }
 frame=lpXimage->this_frame - lpXimage->first_frame + 1;
 if     (hold == 1)mr=(1.0-mr);
 else if(hold == 2)mr=1.0;
 else if(hold == 3)mr=0.0;
 BackBuffer=NULL;
 Xmax=lpXimage->Xmax; Ymax=lpXimage->Ymax;
 Screen=lpXimage->Screen;
 if((BackBuffer=(fullscreenbuffer *)X__Malloc(Xmax*Ymax*
   sizeof(fullscreenbuffer))) == NULL)return 0;
 memset(BackBuffer,0,Xmax*Ymax*sizeof(fullscreenbuffer));
 if(BackBuffer != NULL){
   long i,j;
   fullscreenbuffer *S,*B;
   double shade,background,NdotL,spec;
   double a,spower,
          azimuth=0.7777,
          elevation=0.7777,
          Nx,Ny,Nz,Lx,Ly,Lz,Nz2,NzLz,Vx=0.0,Vy=0.0,Vz=255.9,VzNz,len;
   spower=(double)10;
   B=BackBuffer;
   azimuth = (double)ny*3.1415926/180.0;
   Lx=cos(azimuth)*cos(elevation)*255.9;
   Ly=sin(azimuth)*cos(elevation)*255.9;
   Lz=sin(elevation)*255.9;
   Vx += Lx; Vy += Ly; Vz += Lz;
   NdotL=1.0/sqrt(Vx*Vx+Vy*Vy+Vz*Vz);
   Vx *= NdotL; Vy *= NdotL; Vz *= NdotL;
   for(i=1;i<Ymax-1;i++)for(j=1;j<Xmax-1;j++){
     a=((double)(B->R)+(double)(B->G)+(double)(B->B))/3.0;
     B->R=(unsigned char)a;
     B->G=(unsigned char)a;
     B->B=(unsigned char)a;
     B++;
   }
   B=BackBuffer;
   DrawRingsInBuffer(B,Xmax,Ymax);
   for(i=1;i<Ymax-1;i++){
     for(j=1;j<Xmax-1;j++){
       a=(double)(B+(i-1)*Xmax+(j-1))->R+
         (double)(B+(i-1)*Xmax+(j  ))->R+
         (double)(B+(i-1)*Xmax+(j+1))->R+
         (double)(B+(i  )*Xmax+(j-1))->R+
         (double)(B+(i  )*Xmax+(j  ))->R+
         (double)(B+(i  )*Xmax+(j+1))->R+
         (double)(B+(i+1)*Xmax+(j-1))->R+
         (double)(B+(i+1)*Xmax+(j  ))->R+
         (double)(B+(i+1)*Xmax+(j+1))->R;
       (B+i*Xmax+j)->R=(unsigned char)(a/9.0);
       a=(double)(B+(i-1)*Xmax+(j-1))->G+
         (double)(B+(i-1)*Xmax+(j  ))->G+
         (double)(B+(i-1)*Xmax+(j+1))->G+
         (double)(B+(i  )*Xmax+(j-1))->G+
         (double)(B+(i  )*Xmax+(j  ))->G+
         (double)(B+(i  )*Xmax+(j+1))->G+
         (double)(B+(i+1)*Xmax+(j-1))->G+
         (double)(B+(i+1)*Xmax+(j  ))->G+
         (double)(B+(i+1)*Xmax+(j+1))->G;
       (B+i*Xmax+j)->G=(unsigned char)(a/9.0);
       a=(double)(B+(i-1)*Xmax+(j-1))->B+
         (double)(B+(i-1)*Xmax+(j  ))->B+
         (double)(B+(i-1)*Xmax+(j+1))->B+
         (double)(B+(i  )*Xmax+(j-1))->B+
         (double)(B+(i  )*Xmax+(j  ))->B+
         (double)(B+(i  )*Xmax+(j+1))->B+
         (double)(B+(i+1)*Xmax+(j-1))->B+
         (double)(B+(i+1)*Xmax+(j  ))->B+
         (double)(B+(i+1)*Xmax+(j+1))->B;
       (B+i*Xmax+j)->B=(unsigned char)(a/9.0);
     }
   }
   B=BackBuffer;
   nx = max(1,nx);
   Nz=(6.0*255.0)/((double)nx/10.0);
   Nz2=Nz*Nz;
   NzLz=Nz*Lz;
   VzNz=Vz*Nz;
   background=Lz/255.0;
   for(i=0;i<Ymax;i++){
     for(j=0;j<Xmax;j++){
       S=(Screen+i*Xmax+j);
       spec=0.0;
       if(i > 0 && i < Ymax-1 && j > 0 && j < Xmax-1){
         Ny= -(double)(B+(i-1)*Xmax+(j-1))->R
             -(double)(B+(i-1)*Xmax+(j  ))->R
             -(double)(B+(i-1)*Xmax+(j+1))->R+
              (double)(B+(i+1)*Xmax+(j-1))->R+
              (double)(B+(i+1)*Xmax+(j  ))->R+
              (double)(B+(i+1)*Xmax+(j+1))->R;

         Nx= -(double)(B+(i-1)*Xmax+(j-1))->R
             -(double)(B+(i  )*Xmax+(j-1))->R
             -(double)(B+(i+1)*Xmax+(j-1))->R+
              (double)(B+(i-1)*Xmax+(j+1))->R+
              (double)(B+(i  )*Xmax+(j+1))->R+
              (double)(B+(i+1)*Xmax+(j+1))->R;

         if(fabs(Nx) < 1.0 && fabs(Ny) < 1.0){
           shade=background;
         }
         else if((NdotL=Nx*Lx+Ny*Ly+NzLz) < 0.0){
           shade=0;
         }
         else{
           len=1.0/sqrt(Nx*Nx+Ny*Ny+Nz2);
           shade=NdotL*len/255.0;
           NdotL=(Vx*Nx+Vy*Ny+VzNz)*len;
           if(NdotL > 0)spec=pow((2*NdotL*NdotL-1.0),spower);
         }
       }
       else shade=background;
       S->R = (unsigned char)(min(255,(double)S->R*shade+spec*255.0));
       S->G = (unsigned char)(min(255,(double)S->G*shade+spec*255.0));
       S->B = (unsigned char)(min(255,(double)S->B*shade+spec*255.0));
     }
   }
 }
 if(BackBuffer != NULL)X__Free(BackBuffer);
 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);

// ny is angle
// nx is % of slope  100 is highest 0 is lowest


static long colour[3]={255,255,255};
static long type=0,hold=0,back=0,lframe=9999,nx=50,ny=45;
static char iname[256];
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 */
                                    ){
 char buffer[1024];
 long id1,id2;   /* integer scaled radius value */
 strcpy(iname," ");
 if(Op != NULL){  /* parameters exist so read them off the list */
   sscanf(Op,"%s %ld %ld %ld %ld %ld %ld %ld %ld %ld %ld %s",buffer,&version,
          &type,&hold,&nx,&ny,&colour[0],&colour[1],&colour[2],
          &back,&lframe,iname);
 }
 lpLocalEVI=lpEVI;
 if(DialogBox(hDLLinstance,MAKEINTRESOURCE(DLG_VIDEO),hWnd,
              (DLGPROC)DlgProc) == FALSE)return Op;
 if(Op != NULL)CALL_FREE(Op);  /* free the old string */
 sprintf(buffer,"%s %ld %ld %ld %ld %ld %ld %ld %ld %ld %ld %s",
           name,version,type,hold,
           nx,ny,colour[0],colour[1],colour[2],back,lframe,iname);
 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;
}


BOOL CALLBACK DlgProc(HWND hwnd,UINT msg,WPARAM wparam,LPARAM lparam){
 BOOL err;
 int i;
 char lname[256],text[512];
 switch( msg ) {
   case WM_INITDIALOG:
     if     (hold == 0)
       SendDlgItemMessage(hwnd,DLG_VIDEO_FADE_IN,BM_SETCHECK,TRUE,0);
     else if(hold == 1)
       SendDlgItemMessage(hwnd,DLG_VIDEO_FADE_OUT,BM_SETCHECK,TRUE,0);
     else if(hold == 2)
       SendDlgItemMessage(hwnd,DLG_VIDEO_HOLD_IN,BM_SETCHECK,TRUE,0);
     else if(hold == 3)
       SendDlgItemMessage(hwnd,DLG_VIDEO_HOLD_OUT,BM_SETCHECK,TRUE,0);
     SetDlgItemInt(hwnd,DLG_VIDEO_NX,nx,TRUE);
     SetDlgItemInt(hwnd,DLG_VIDEO_NY,ny,TRUE);
     CentreDialogOnScreen(hwnd);
   case WM_PAINT:
     PaintBackground(hwnd);
     break;
     return TRUE;
   case WM_COMMAND:
     switch(LOWORD(wparam)){
        case IDCANCEL:
          EndDialog(hwnd,FALSE);
          return(TRUE);
        case IDOK:
          nx=GetDlgItemInt(hwnd,DLG_VIDEO_NX,&err,FALSE);
          ny=GetDlgItemInt(hwnd,DLG_VIDEO_NY,&err,FALSE);
          if(SendDlgItemMessage(hwnd,DLG_VIDEO_FADE_IN,BM_GETCHECK,0,0))
            hold=0;
          if(SendDlgItemMessage(hwnd,DLG_VIDEO_FADE_OUT,BM_GETCHECK,0,0))
            hold=1;
          if(SendDlgItemMessage(hwnd,DLG_VIDEO_HOLD_IN,BM_GETCHECK,0,0))
            hold=2;
          if(SendDlgItemMessage(hwnd,DLG_VIDEO_HOLD_OUT,BM_GETCHECK,0,0))
            hold=3;
          EndDialog(hwnd,TRUE);
          return(TRUE);
        default:
          break;
      }
      break;
    default: break;
 }
 return FALSE;
}