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

/* trails.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 "trails.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;

#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;
      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 i,j;
 char dummy[255];
 double z,scale,I,mr,fade;
 long number,type,c1,c2,c3,Xmax,Ymax,ifade;
 long mnumber,mtype,mc1,mc2,mc3,mifade;
 float *Zb;
 fullscreenbuffer *S,*Screen,*Blur,*B;
 BOOL  bDraw=TRUE,bMorph=FALSE;
#include "pro_key.c"
 sscanf(PrmList,"%s %ld %ld %ld %ld %ld %ld %ld",dummy,&version,&c1,&c2,&c3,
        &number,&type,&ifade);
 if(lpXimage->Morph && lpXimage->mParameters != NULL){
   bMorph=TRUE; mr=lpXimage->MorphRatio;
   sscanf(lpXimage->mParameters,"%s %ld %ld %ld %ld %ld %ld %ld",dummy,
          &version,&mc1,&mc2,&mc3,&mnumber,&mtype,&mifade);
 }
 //silently ignore the that that the blur is not turned on
 if((Blur=lpXimage->Blur) == NULL)return 1;
 if((Zb=lpXimage->Zbuffer) == NULL)return 0;
 if((Screen=lpXimage->Screen) == NULL)return 0;
 Xmax=lpXimage->Xmax;
 Ymax=lpXimage->Ymax;
 S=Screen; B=Blur;
 if(type == 2){
   for(j=0;j<Ymax;j++)for(i=0;i<Xmax;i++){
     if(S->A < 64 && B->A > 0){
       S->R=B->R;
       S->G=B->G;
       S->B=B->B;
       S->A=B->A;
     }
     if(S->A >= 64){
       B->A=(unsigned char)number;
       B->R=S->R;
       B->G=S->G;
       B->B=S->B;
     }
     else if(B->A > 0)B->A -= 1;
     S++;
     B++;
   }
 }
 else{
   for(j=0;j<Ymax;j++)for(i=0;i<Xmax;i++){
     if(S->A < 64 && B->A > 64){
       S->R=B->R;
       S->G=B->G;
       S->B=B->B;
       S->A=B->A;
     }
     if(S->A >= 64){
       B->A=S->A;
       B->R=S->R;
       B->G=S->G;
       B->B=S->B;
     }
     S++;
     B++;
   }
 }
 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 long   number=10,type=1,c1=0,c2=255,c3=0,fade=100;

char * _SetExternalParameters(
  char *Op,
  HWND hWnd,
  long ruler,
  char *name,
  X__MEMORY_MANAGER *lpEVI
                                    ){
 char buffer[256];
 if(Op != NULL){
   sscanf(Op,"%s %ld %ld %ld %ld %ld %ld %ld",buffer,&version,&c1,&c2,&c3,
          &number,&type,&fade);
 }
 if(DialogBox(hDLLinstance,MAKEINTRESOURCE(DLG_TRAILS),hWnd,
              (DLGPROC)DlgProc) == FALSE)return Op;
 if(Op != NULL)CALL_FREE(Op);
 sprintf(buffer,"%s %ld %ld %ld %ld %ld %ld %ld",name,version,c1,c2,c3,
         number,type,fade);
 if((Op=(char *)CALL_MALLOC(strlen(buffer)+1)) == NULL){
  MessageBox (GetFocus(),"Out of memory",NULL,
                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);
 }
}

BOOL CALLBACK DlgProc(HWND hwnd,UINT msg,WPARAM wparam,LPARAM lparam){
 BOOL err;
 char str[32];
 switch( msg ) {
   case WM_INITDIALOG:
     SetDlgItemInt(hwnd,DLG_TRAILS_NUMBER,number,FALSE);
     if     (type == 1)
       SendDlgItemMessage(hwnd,DLG_TRAILS_ALL,BM_SETCHECK,TRUE,0);
     if     (type == 2)
       SendDlgItemMessage(hwnd,DLG_TRAILS_SET,BM_SETCHECK,TRUE,0);
     LoadAnimatedClip(hwnd);
     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(SendDlgItemMessage(hwnd,DLG_TRAILS_SET,BM_GETCHECK,0,0))
            type=2;
          else
            type=1;
          number=GetDlgItemInt(hwnd,DLG_TRAILS_NUMBER,&err,FALSE);
          if(number < 0)number=0;
          EndDialog(hwnd,TRUE);
          return(TRUE);
        default:
          break;
      }
      break;
    default: break;
 }
 return FALSE;
}