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

/* IMAGE  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 "image.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"

#include "video1.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 CycleBrightness(double mr, fullscreenbuffer *S, long Xmax, long Ymax,
                   long R, long G, long B, fullscreenbuffer *Bb){
 long i,j;
 double mono;
 for(i=0;i<Ymax;i++)for(j=0;j<Xmax;j++){
   mono=((double)(S->R) + (double)(S->G) + (double)(S->B))*0.33333;
   mono -= 256.0*mr;
   if(mono < 0.0)mono += 256;
   S->R = (unsigned char)mono;
   S->G = (unsigned char)mono;
   S->B = (unsigned char)mono;
   S++;
 }
}


static void CycleColours(double mr, fullscreenbuffer *S, long Xmax, long Ymax,
                   long R, long G, long B, fullscreenbuffer *Bb){
 long i,j;
 double r,g,b;
 for(i=0;i<Ymax;i++)for(j=0;j<Xmax;j++){
   r=(double)(S->R);
   g=(double)(S->G);
   b=(double)(S->B);
   r -= 256.0*mr; if(r < 0.0)r += 256;
   g -= 256.0*mr; if(g < 0.0)g += 256;
   b -= 256.0*mr; if(b < 0.0)b += 256;
   S->R = (unsigned char)r;
   S->G = (unsigned char)g;
   S->B = (unsigned char)b;
   S++;
 }
}

static void OscillateBrightness(double mr, fullscreenbuffer *S, long Xmax, long Ymax,
                   long R, long G, long B, fullscreenbuffer *Bb){
 long i,j;
 double mono,phase;
 for(i=0;i<Ymax;i++)for(j=0;j<Xmax;j++){
   phase=((double)(S->R) + (double)(S->G) + (double)(S->B))*0.33333/256.0; // [0 , 1]
   mono = sin(2*3.1415926*(mr+phase));    // [-1 , 1]
   mono = min(255.0,(1.0+mono)*128.0);
   S->R = (unsigned char)mono;
   S->G = (unsigned char)mono;
   S->B = (unsigned char)mono;
   S++;
 }
}

static void OscillateColours(double mr, fullscreenbuffer *S, long Xmax, long Ymax,
                   long R, long G, long B, fullscreenbuffer *Bb){
 long i,j;
 double r,g,b,phaser,phaseg,phaseb;
 for(i=0;i<Ymax;i++)for(j=0;j<Xmax;j++){
   phaser=((double)(S->R))/256.0;
   phaseg=((double)(S->G))/256.0;
   phaseb=((double)(S->B))/256.0;
   r = sin(2*3.1415926*(mr+phaser));    // [-1 , 1]
   r = min(255.0,(1.0+r)*128.0);
   g = sin(2*3.1415926*(mr+phaseg));    // [-1 , 1]
   g = min(255.0,(1.0+g)*128.0);
   b = sin(2*3.1415926*(mr+phaseb));    // [-1 , 1]
   b = min(255.0,(1.0+b)*128.0);
   S->R = (unsigned char)r;
   S->G = (unsigned char)g;
   S->B = (unsigned char)b;
   S++;
 }
}

static void TintImage(double mr, fullscreenbuffer *S, long Xmax, long Ymax,
                   long R, long G, long B, fullscreenbuffer *Bb){
 long i,j;
 double r,g,b;
 for(i=0;i<Ymax;i++)for(j=0;j<Xmax;j++){
   r=(double)(S->R) * (1.0-(1.0-((double)R)/255.0)*mr);
   g=(double)(S->G) * (1.0-(1.0-((double)G)/255.0)*mr);
   b=(double)(S->B) * (1.0-(1.0-((double)B)/255.0)*mr);
   S->R = (unsigned char)r;
   S->G = (unsigned char)g;
   S->B = (unsigned char)b;
   S++;
 }
}



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;
#include "pro_key.c"
 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)return 1;
   mr=(double)(lpXimage->this_frame - lpXimage->first_frame)/mr;
 }
 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;
#if 0
 if(back > 0 && type != 1 && type != 2 && type != 3 && type != 8 &&
    type != 9 && type != 11 && type != 12 && type != 13){
   unsigned char *ImagePixels;
   int ImageXsize,ImageYsize;
   if(back == 2)GetAnimFileName(imagefile,name_path,
                     lpXimage->this_frame - lpXimage->first_frame + 1,
                     1,lframe,1);
   RestoreWhiteSpaces(imagefile);
   if((ImagePixels=LoadMAP(imagefile,&ImageXsize,&ImageYsize)) != NULL){
     BackBuffer=ScaleImageMap(ImagePixels,ImageXsize,ImageYsize,Xmax,Ymax);
     X__Free(ImagePixels);
   }
 }
#endif
 Screen=lpXimage->Screen;
 if(type ==  0)CycleBrightness(mr,Screen,Xmax,Ymax,cR,cG,cB,BackBuffer);
 if(type ==  1)OscillateBrightness(mr,Screen,Xmax,Ymax,cR,cG,cB,BackBuffer);
 if(type ==  2)CycleColours(mr,Screen,Xmax,Ymax,cR,cG,cB,BackBuffer);
 if(type ==  3)OscillateColours(mr,Screen,Xmax,Ymax,cR,cG,cB,BackBuffer);
 if(type ==  4)TintImage(mr,Screen,Xmax,Ymax,cR,cG,cB,BackBuffer);
 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);

static long colour[3]={255,255,255};
static long type=0,hold=0,back=0,lframe=9999,nx=10,ny=10;
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;
}

#define NVIDEO 5

static void LoadAnimatedClip(HWND hDlg,long id){
 char *c,str[32],modname[256];
 GetModuleFileName(hDLLinstance,modname,255);
 if((c=strrchr(modname,'.')) != NULL){
   sprintf(str,"%ld",id+1);
   strcpy(c,str);
   strcat(modname,".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;
 int i;
 char lname[256],text[512];
 static long type_list[NVIDEO]={
   DLG_VIDEO_1,
   DLG_VIDEO_2,
   DLG_VIDEO_3,
   DLG_VIDEO_4,
   DLG_VIDEO_5
 };
 static long text_list[NVIDEO]={
   IDX_VIDEO_1,
   IDX_VIDEO_2,
   IDX_VIDEO_3,
   IDX_VIDEO_4,
   IDX_VIDEO_5
 };
 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);
     for(i=0;i<NVIDEO;i++){
       LoadString(hDLLinstance,type_list[i],lname,256);
       SendDlgItemMessage(hwnd,DLG_VIDEO_LIST,LB_ADDSTRING,0,
                   (LPARAM)(LPCTSTR)lname);
     }
     SendDlgItemMessage(hwnd,DLG_VIDEO_LIST,LB_SETCURSEL,(WPARAM)type,0);
     if     (back == 0)
       SendDlgItemMessage(hwnd,DLG_VIDEO_PLAIN,BM_SETCHECK,TRUE,0);
     if     (back == 1)
       SendDlgItemMessage(hwnd,DLG_VIDEO_IMAGE,BM_SETCHECK,TRUE,0);
     if     (back == 2)
       SendDlgItemMessage(hwnd,DLG_VIDEO_ANIIMAGE,BM_SETCHECK,TRUE,0);
     strcpy(lname,iname);
     RestoreWhiteSpaces(lname);
     SetDlgItemText(hwnd,DLG_VIDEO_IMAGENAME,lname);
     SetDlgItemInt(hwnd,DLG_VIDEO_NX,nx,TRUE);
     SetDlgItemInt(hwnd,DLG_VIDEO_NY,ny,TRUE);
     SetDlgItemInt(hwnd,DLG_VIDEO_LASTFRAME,lframe,TRUE);
     LoadAnimatedClip(hwnd,type);
     LoadString(hDLLinstance,text_list[type],text,256);
     SendDlgItemMessage(hwnd,DLG_VIDEO_HELP,WM_SETTEXT,0,(LPARAM)text);
     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_VIDEO_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_VIDEO_LIST:
          switch(HIWORD(wparam)){
            case LBN_SELCHANGE:{
               HWND hctl;
               hctl=GetDlgItem(hwnd,DLG_VIDEO_LIST);
               i=SendMessage(hctl,LB_GETCURSEL,0,0);
               LoadAnimatedClip(hwnd,i);
               LoadString(hDLLinstance,text_list[i],text,256);
               SendDlgItemMessage(hwnd,DLG_VIDEO_HELP,WM_SETTEXT,0,(LPARAM)text);
            }
            break;
            default: break;
          }
          break;
        case DLG_VIDEO_SETIMAGENAME:{
            strcpy(lname,iname);
            RestoreWhiteSpaces(lname);
            if(XimageFileName(lpLocalEVI->lpAni,lname,"gif",
                              "Choose First/Only Image File",
                              "All file formats|*.gif;*.tga|"
                              "Compuserve GIFs|*.gif|"
                              "Targa TGAs|*.tga|",
                              hwnd)){

              SetDlgItemText(hwnd,DLG_VIDEO_IMAGENAME,lname);
              HideWhiteSpaces(lname);
              strcpy(iname,lname);
            }
          }
          break;
        case DLG_VIDEO_COLOUR:
          SetColour(colour,hwnd);
          InvalidateRect(GetDlgItem(hwnd,DLG_VIDEO_COLOUR),NULL,FALSE);
          break;
        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);
          lframe=GetDlgItemInt(hwnd,DLG_VIDEO_LASTFRAME,&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;
          if(SendDlgItemMessage(hwnd,DLG_VIDEO_ANIIMAGE,BM_GETCHECK,0,0))
            back=2;
          if(SendDlgItemMessage(hwnd,DLG_VIDEO_IMAGE,BM_GETCHECK,0,0))
            back=1;
          if(SendDlgItemMessage(hwnd,DLG_VIDEO_PLAIN,BM_GETCHECK,0,0))
            back=0;
          type=SendDlgItemMessage(hwnd,DLG_VIDEO_LIST,LB_GETCURSEL,0,0);
//          for(i=0;i<NVIDEO;i++)
//            if(SendDlgItemMessage(hwnd,type_list[i],BM_GETCHECK,0,0))type=i;
          EndDialog(hwnd,TRUE);
          return(TRUE);
        default:
          break;
      }
      break;
    default: break;
 }
 return FALSE;
}

#include "video2.c"