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

/* FILTER.C  image post-processing external DLL                         */
/*                                                                      */
/* This image processor gives the user the opportunity to alter the     */
/* colour balance in an image once it has been rendered. The proportion */
/* of red, green and blue in each pixel is adjusted by multiplying      */
/* the R,G,B values held in the ScreenBuffer after they have been       */
/* calculated but before they are written to disk or built into an      */
/* animation.                                                           */
/*                                                                      */
/* This example servers to illustrate the design of the Dialog Box      */
/* called by the Animator to set up the process and how pixels in the   */
/* screen buffer are addressed and modified.                            */
/*                                                                      */

#include "resource.h"
#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 <commctrl.h>
#include "stereo1.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"

/************************** 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
//MessageBox(NULL,"Attaching",NULL,MB_OK);
      hDLLinstance = hDLL;  /* handle to DLL file */
      break;
    case DLL_PROCESS_DETACH:
#if __X__MIPS__
      if(!_CRT_INIT(hDLL,dwReason,lpReserved))return(int)FALSE;
#endif
//MessageBox(NULL,"Detaching",NULL,MB_OK);
      break;
  }
return (int)TRUE;
}

#if __SC__
#pragma startaddress(DllMain)
#endif

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

long _RenderImageProcess(char *PrmList, XIMAGE *lpXimage){
 int i,j;
 BOOL LR,RL;
 char dummy[255];
 fullscreenbuffer *S;
 /* read the parameters from the parameter list */
 sscanf(PrmList,"%s %d %d",dummy,&LR,&RL);
 
 //MessageBox(NULL,PrmList,"Debug",MB_OK);
 /* set local pointer to start of screen buffer */
 S=lpXimage->Screen;
 for(j=0;j<lpXimage->Ymax;j++)   /* do rows in screen buffer */
 for(i=0;i<lpXimage->Xmax;i++){  /* do all pixies in row j   */
   /* scale the R,G,B values for pixel i,j */
   S->R = min(255,(unsigned char)((double)S->R * LR));
   S->G = min(255,(unsigned char)((double)S->G * 0));
   S->B = min(255,(unsigned char)((double)S->B * RL));
   S++;             /* point to next pixels in screen buffer */
 }
 return 1;          /* all done OK                           */
}

/*************** Function that renders any of the OpenGL Functionality ************/

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


/*************** Functions used for set up  ***************/


/* local variable for communication between dialog box and Setup function */
BOOL LorR=1,RorL=0;

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

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 buffer should be as long as necessary to hold full string        */
 char buffer[256];
 if(Op != NULL){  /* parameters exist so read them off the list */
   sscanf(Op,"%s %d %d",buffer,&LorR,&RorL);
 }
 /*   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_FILTER),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 */
 sprintf(buffer,"%s %d %d",name,LorR,RorL);
 /* 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){
 int str[32];
 char filmname[255],*c;
 switch( msg ) {
   case WM_INITDIALOG:
     /* prime dialog box controls          */
     GetModuleFileName(hDLLinstance,filmname,255);
         if((c=strrchr(filmname,'.')) != NULL){
           strcpy(c,".avi");
           Animate_Open(GetDlgItem(hwnd,IDR_ANIMATION1),filmname);
           Animate_Play(GetDlgItem(hwnd,IDR_ANIMATION1),0,-1,-1);
         }
           if(LorR == 1)
                 SendDlgItemMessage(hwnd,IDC_RADIO_LEFT,BM_SETCHECK,1,0);
           else{
                 SendDlgItemMessage(hwnd,IDC_RADIO_RIGHT,BM_SETCHECK,1,0);
           }
     CentreDialogOnScreen(hwnd);
     return TRUE;
   case WM_COMMAND:
     switch(LOWORD(wparam)){
            case IDC_RADIO_LEFT:
          MessageBox(NULL,"Activate Left Camera","Don't Forget!",MB_OK);
                  return(TRUE);
                case IDC_RADIO_RIGHT:
          MessageBox(NULL,"Activate Right Camera","Don't Forget!",MB_OK);
                  return(TRUE);
            case IDCANCEL:    /* user clicked cancel                            */
          EndDialog(hwnd,FALSE);
          return(TRUE);
        case IDOK:        /* OK so get numbers from the Dailog Box controls */
                  if (SendDlgItemMessage(hwnd,IDC_RADIO_LEFT,BM_GETCHECK,0,0) == 1)
                    LorR=1,RorL=0;
                  else {
                        LorR=0,RorL=1;
          }
                        EndDialog(hwnd,TRUE);
          return(TRUE);
                
        default:
          break;
      }
      break;
    default: break;
 }
 return FALSE;
}