FILTER.C

Go to the documentation of this file.

/* --
OpenFX version 2.0 - Modelling, Animation and Rendering Package
Copyright (C) 2000 - 2007 OpenFX Development Team
-- */

/* 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 <stdlib.h>
#include <stdio.h>
#include <float.h>
#include <math.h>
#include <windows.h>

#include <gl/gl.h>
#include <gl/glu.h>

// Need these when using OpenGL extensions
#include <fcntl.h>
#define __gl2_main_
#include "..\gl2.h"
#define PADDR(functype,funcname) (funcname = (functype) wglGetProcAddress( #funcname ))

#include "struct.h"           /* general structures    */
#include "..\common\postprocess\ximage.h"
#include "local.h"

#include "filter.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"

#include "paint.c"

/************************** 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;
 double rs,gs,bs;
 char dummy[255];
 fullscreenbuffer *S;
 /* read the parameters from the parameter list */
 sscanf(PrmList,"%s %f %f %f",dummy,&rs,&gs,&bs);
 /* 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 pixles in row j   */
   /* scale the R,G,B values for pixel i,j */
   S->R = min(255,(unsigned char)((double)S->R * rs));
   S->G = min(255,(unsigned char)((double)S->G * gs));
   S->B = min(255,(unsigned char)((double)S->B * bs));
   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){
 GLfloat rs,gs,bs;
 char dummy[255];
 gl2Initialize(); // needed for some functions 
 sscanf(PrmList,"%s %f %f %f",dummy,&rs,&gs,&bs);
 //glEnable(GL_CONVOLUTION_2D);
 //glDisable(GL_CONVOLUTION_2D);
 glMatrixMode(GL_PROJECTION);
 glLoadIdentity();
 glOrtho(0.0,1.0,0.0,1.0,-1.0,1.0);
 glMatrixMode( GL_MODELVIEW );
 glLoadIdentity();
 glViewport( 0, 0, lpXimage->Xmax,lpXimage->Ymax);
 glEnable(GL_BLEND);
 glDisable(GL_DEPTH_TEST);
 glDepthMask(GL_FALSE);
 glBlendColor(rs,gs,bs,1.0);
 // glBlendColor(1.0,0.0,0.0,1.0); // for a red filter
 glBlendFunc(GL_ONE_MINUS_CONSTANT_COLOR,GL_CONSTANT_COLOR);
 glColor4f(0.0,0.0,0.0,1.0);
 glBegin(GL_QUADS);
 glVertex3f(0.0,0.0,-1.0); 
 glVertex3f(1.0,0.0,-1.0); 
 glVertex3f(1.0,1.0,-1.0);
 glVertex3f(0.0,1.0,-1.0);
 glEnd();
 glEnable(GL_DEPTH_TEST);
 glDepthMask(GL_TRUE);
 glDisable(GL_BLEND);
 return 1;
}

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


/* local variable for communication between dialog box and Setup function */
double red_scale=1.0,green_scale=1.0,blue_scale=1.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 %f %f %f",buffer,&red_scale,&green_scale,&blue_scale);
 }
 /*   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 %f %f %f",name,red_scale,green_scale,blue_scale);
 /* 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];
 switch( msg ) {
   case WM_INITDIALOG:
     /* prime dialog box controls          */
     sprintf(str,"%.2f",red_scale);
     SetDlgItemText(hwnd,DLG_FILTER_RED,str);
     sprintf(str,"%.2f",green_scale);
     SetDlgItemText(hwnd,DLG_FILTER_GREEN,str);
     sprintf(str,"%.2f",blue_scale);
     SetDlgItemText(hwnd,DLG_FILTER_BLUE,str);
     CentreDialogOnScreen(hwnd);
     return TRUE;
   case WM_PAINT:
     PaintBackground(hwnd);
     break;
   case WM_COMMAND:
     switch(LOWORD(wparam)){
        case IDCANCEL:    /* user clicked cancel                            */
          EndDialog(hwnd,FALSE);
          return(TRUE);
        case IDOK:        /* OK so get numbers from the Dailog Box controls */
          if(GetDlgItemText(hwnd,DLG_FILTER_RED,str,12) != 0)
            sscanf(str,"%f",&red_scale);
          if(GetDlgItemText(hwnd,DLG_FILTER_GREEN,str,12) != 0)
            sscanf(str,"%f",&green_scale);
          if(GetDlgItemText(hwnd,DLG_FILTER_BLUE,str,12) != 0)
            sscanf(str,"%f",&blue_scale);
          EndDialog(hwnd,TRUE);
          return(TRUE);
        default:
          break;
      }
      break;
    default: break;
 }
 return FALSE;
}