HALO.C

Go to the documentation of this file.

/* --
OpenFX version 2.0 - Modelling, Animation and Rendering Package
Copyright (C) 2000 -  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.
-- */

/* halo.c  image post-processor                                         */
/*                                                                      */
/* This post-processor gives users the ability to add halos round light */
/* sources. Normally lights are invisible in an animation but this      */
/* process adds a halo round light sources, the size of halo is set by  */
/* the user, because the size of the halo is constant it will appear    */
/* to get smaller as a light moves away from the camera. Many more      */
/* parameters could be added to this example, colour, transparency      */
/* falloff, etc. If used with a Z buffer the light could pass behind    */
/* other objects in the scene. Note that the position of lights has     */
/* been transformed to camera co-ordinates before the image processor   */
/* is loaded so there is no need to call TransformIntoView before       */
/* using the components of the vector P. This examples is intended to   */
/* show how access and use information in the light data structure.     */
/*                                                                      */

#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 "halo.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;

/************************** 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
      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 DrawInBuffer(long x, long y, fullscreenbuffer *Screen,
                         long X, long Y, long radius,
                         double r, double g, double b,
                         double z, float *Zb,
                         BOOL bDraw, long hide){
 /* mix in a white halo at the screen buffer location of the light source */
 long i,j;
 double d;
 fullscreenbuffer *S;
 /* bounding rectangle */
 for(i=x-radius;i<=x+radius;i++)for(j=y-radius;j<=y+radius;j++){
   if(i < 0 || i >= X || j < 0 || j >= Y)continue;
   S=(Screen + j*X + i);
   if(radius < 1)d=1.0;
   else{
     d=sqrt((double)(i-x)*(double)(i-x) + (double)(j-y)*(double)(j-y));
     d=255.0*((double)radius-d)/(double)radius;
     d=max(0.0,d);
   }
   /* mix to white */
   if(!hide || bDraw || z < *(Zb + j*X + i)){
     S->R = (unsigned char)min(255.0,(double)S->R+d*r);
     S->G = (unsigned char)min(255.0,(double)S->G+d*g);
     S->B = (unsigned char)min(255.0,(double)S->B+d*b);
   }
 }
 return;
}

long _RenderImageProcess(char *PrmList, XIMAGE *lpXimage){
 /* lights have been transformed to Renderer frame of reference */
 /* Z is UP, Y is forward (in front of observer, X to the RIGHT */
 /* the camera is located at 0,0,0. All real numbers are floats */
 /* xx and yy are screen co-ords of light (0,0) is at top left  */
 int i,j;
 char dummy[255];
 double x,y,z,mr,r,g,b;
 long xx,yy,radius,iradius,hide,miradius,type,id;
 float *Zb;
 BOOL  bDraw;
 if(lpXimage->Nlights == 0 || lpXimage->Lights == NULL)return 1;
 sscanf(PrmList,"%s %ld %ld %ld %ld %ld",dummy,&version,
        &iradius,&hide,&type,&id);
 if(lpXimage->Morph && lpXimage->mParameters != NULL){
   mr=lpXimage->MorphRatio;
   sscanf(lpXimage->mParameters,"%s %ld %ld",dummy,&version,&miradius);
   iradius=(long)((double)miradius + mr*((double)iradius-(double)miradius));
 }
 Zb=lpXimage->Zbuffer;
 for(i=0;i<lpXimage->Nlights;i++){
   if(type == 2 && lpXimage->Lights[i].type != DUMMYL)continue;
   if(type == 3 && lpXimage->Lights[i].AnimatorID != id)continue;
   x=lpXimage->Lights[i].p[0];
   y=lpXimage->Lights[i].p[1];
   z=lpXimage->Lights[i].p[2];
   if(y >= 1.000){                     /* all points in front of viewer */
     xx=lpXimage->Xmax/2 +
       (long)(lpXimage->Xscale*x/y);
     yy=lpXimage->Ymax/2 -
       (long)(lpXimage->Yscale*z/y);
     if(xx >= 0 && xx < lpXimage->Xmax &&
        yy >= 0 && yy < lpXimage->Ymax){
       /* this light is visible on screen                 */
       /* perspective transformation of light halo radius */
       if(Zb != NULL){      /* zbuffer       */
         if(y < *(Zb + (yy * lpXimage->Xmax) + xx))bDraw=TRUE;
         else bDraw=FALSE;  /* light obscured */
       }
       else bDraw=TRUE;
       radius = (long)(lpXimage->Xscale*(double)iradius/y);
       r=(double)(lpXimage->Lights[i].color[0])/255.0;
       g=(double)(lpXimage->Lights[i].color[1])/255.0;
       b=(double)(lpXimage->Lights[i].color[2])/255.0;
       DrawInBuffer(xx,yy,lpXimage->Screen,
                    lpXimage->Xmax,lpXimage->Ymax,radius,
                    r,g,b,
                    y,Zb,bDraw,hide);
     }
   }
 }
 return 1;
}

/*************** Function that renders anyof the OpenGL Functionality ************/

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


/*************** Functions used to set up      ***************/


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

static double rad=1.0;
static long   hide=1,type=1,id = -1;
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 */
                                    ){
 /* output name and buffer should be as long as necessary to hold full string */
 char buffer[256];
 long irad;       /* integer scaled radius value                */
 if(Op != NULL){  /* parameters exist so read them off the list */
   sscanf(Op,"%s %ld %ld %ld %ld %ld",buffer,&version,&irad,&hide,&type,&id);
   /* transform from World units to User units                  */
   rad=(double)irad/(double)ruler;
 }
 /*   Do the user interface as required to set up the effect, may use a */
 /*   dialog box etc. Return old string if cancelled (no change)        */
 lpLocalEVI=lpEVI;
 if(DialogBox(hDLLinstance,MAKEINTRESOURCE(DLG_HALO),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             */
 /* transform from User units to World units         */
 irad=(long)(rad*(double)ruler);
 sprintf(buffer,"%s %ld %ld %ld %ld %ld",name,version,irad,hide,type,id);
 /* 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){
 /* a radius value of 1.0 will give a halo of radius 1.0  unit     */
 /* for whatever co-ordinate system is in use for this animation   */
 /* the size relative to the actors can be determined by using the */
 /* co-ord dialog to check on the size of the actors               */
 char str[32];
 switch( msg ) {
   case WM_INITDIALOG:
     sprintf(str,"%.3f",rad);
     SetDlgItemText(hwnd,DLG_HALO_RADIUS,str);
     if(hide == 1)SendDlgItemMessage(hwnd,DLG_HALO_HIDE,BM_SETCHECK,TRUE,0);
     if(type == 1)SendDlgItemMessage(hwnd,DLG_HALO_TYPE1,BM_SETCHECK,TRUE,0);
     if(type == 2)SendDlgItemMessage(hwnd,DLG_HALO_TYPE2,BM_SETCHECK,TRUE,0);
     if(type == 3)SendDlgItemMessage(hwnd,DLG_HALO_TYPE3,BM_SETCHECK,TRUE,0);
     if(id >= 0)SendDlgItemMessage(hwnd,DLG_HALO_NAME,WM_SETTEXT,
                0,(LPARAM)GetActorsName(lpLocalEVI->lpAni,id));
     CentreDialogOnScreen(hwnd);
     return TRUE;
   case WM_PAINT:
     PaintBackground(hwnd);
     break;
   case WM_COMMAND:
     switch(LOWORD(wparam)){
        case DLG_HALO_SETID:
          id=GetActorsID(lpLocalEVI->lpAni,hwnd);
          if(id >= 0)SendDlgItemMessage(hwnd,DLG_HALO_NAME,WM_SETTEXT,
                     0,(LPARAM)GetActorsName(lpLocalEVI->lpAni,id));
          break;
        case IDCANCEL:
          EndDialog(hwnd,FALSE);
          return(TRUE);
        case IDOK:
          if(GetDlgItemText(hwnd,DLG_HALO_RADIUS,str,12) != 0)
            sscanf(str,"%f",&rad);
          if(SendDlgItemMessage(hwnd,DLG_HALO_HIDE,BM_GETCHECK,0,0))
               hide=1;
          else hide=0;
          if(SendDlgItemMessage(hwnd,DLG_HALO_TYPE1,BM_GETCHECK,0,0))type=1;
          if(SendDlgItemMessage(hwnd,DLG_HALO_TYPE2,BM_GETCHECK,0,0))type=2;
          if(SendDlgItemMessage(hwnd,DLG_HALO_TYPE3,BM_GETCHECK,0,0))type=3;
          EndDialog(hwnd,TRUE);
          return(TRUE);
        default:
          break;
      }
      break;
    default: break;
 }
 return FALSE;
}