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

/* glow.c  image post-processor                                         */

#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 "glow.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;  /* 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 SetColour(unsigned char *colour, HWND parent){
 CHOOSECOLOR cc;
 static COLORREF CustColours[16]={
   RGB(255,255,255), RGB(239,239,239), RGB(223,223,223), RGB(207,207,207),
   RGB(191,191,191), RGB(175,175,175), RGB(159,159,159), RGB(143,143,143),
   RGB(127,127,127), RGB(111,111,111), RGB( 95, 95, 95), RGB( 79, 79, 79),
   RGB( 63, 63, 63), RGB( 47, 47, 47), RGB( 31, 31, 31), RGB( 15, 15, 15) };
 cc.lStructSize=sizeof(CHOOSECOLOR);
 cc.hwndOwner=parent;
 cc.rgbResult=RGB((BYTE)colour[0],(BYTE)colour[1],(BYTE)colour[2]);
 cc.lpCustColors=(LPDWORD)CustColours;
 cc.Flags= CC_RGBINIT;
 cc.lCustData=(DWORD)0;
 if(ChooseColor(&cc)){
   colour[0]=(unsigned char)GetRValue(cc.rgbResult);
   colour[1]=(unsigned char)GetGValue(cc.rgbResult);
   colour[2]=(unsigned char)GetBValue(cc.rgbResult);
 }
}

static BOOL Aboundary(long i, long j, long X, long Y, fullscreenbuffer *Si){
 fullscreenbuffer *S;
 if(i <= 0 || i >= X-1 || j <= 0 || j >= Y-1)return FALSE;
// S=(Si + j*X + i - 1); if(S->A < 240)return TRUE;
// S=(Si + j*X + i + 1); if(S->A < 240)return TRUE;
// S=(Si + (j-1)*X + i); if(S->A < 240)return TRUE;
// S=(Si + (j+1)*X + i); if(S->A < 240)return TRUE;
 S=(Si + j*X + i - 1); if(S->A < 128)return TRUE;
 S=(Si + j*X + i + 1); if(S->A < 128)return TRUE;
 S=(Si + (j-1)*X + i); if(S->A < 128)return TRUE;
 S=(Si + (j+1)*X + i); if(S->A < 128)return TRUE;
 return FALSE;
}

static void DrawAlphaBoundary(long x, long y, fullscreenbuffer *So,
                         long X, long Y, long radius,
                         fullscreenbuffer *Si,
                         long skip,
                         double I,double R, double G, double B){
 long i,j;
 double d;
 fullscreenbuffer *S;
 for(i=x-radius;i<=x+radius;i+=skip)for(j=y-radius;j<=y+radius;j+=skip){
   if(i < 0 || i >= X || j < 0 || j >= Y)continue;
   S=(Si + j*X + i);
//   if(S->A > 240)continue;
   if(S->A > 127)continue;
   if(radius < 1)d=0.5;
   else{
     d=sqrt((double)(i-x)*(double)(i-x) + (double)(j-y)*(double)(j-y));
     if(d > (double)radius)continue;
     d=1.0 - d/(double)radius;
   }
   d=I*d;
   S=(So + j*X + i);
   S->R = (unsigned char)min(255.0,(double)S->R+R*d);
   S->G = (unsigned char)min(255.0,(double)S->G+G*d);
   S->B = (unsigned char)min(255.0,(double)S->B+B*d);
 }
 return;
}

static BOOL boundary(long i, long j, long X, long Y,
                     fullscreenbuffer *Si, long c1, long c2, long c3){
 fullscreenbuffer *S;
 if(i <= 0 || i >= X-1 || j <= 0 || j >= Y-1)return FALSE;
 S=(Si + j*X + i - 1);
 if(S->R != c1 || S->G != c2 || S->B != c3)return TRUE;
 S=(Si + j*X + i + 1);
 if(S->R != c1 || S->G != c2 || S->B != c3)return TRUE;
 S=(Si + (j-1)*X + i);
 if(S->R != c1 || S->G != c2 || S->B != c3)return TRUE;
 S=(Si + (j+1)*X + i);
 if(S->R != c1 || S->G != c2 || S->B != c3)return TRUE;
 return FALSE;
}

static void DrawInBuffer(long x, long y, fullscreenbuffer *So,
                         long X, long Y, long radius,
                         fullscreenbuffer *Si, BOOL exclude,
                         long c1, long c2, long c3,
                         long skip,
                         double z, float *Zb, double I,
                         double R, double G, double B){
 long i,j;
 double d;
 fullscreenbuffer *S;
 for(i=x-radius;i<=x+radius;i+=skip)for(j=y-radius;j<=y+radius;j+=skip){
   if(i < 0 || i >= X || j < 0 || j >= Y)continue;
   S=(Si + j*X + i);
   if(S->R == c1 && S->G == c2 && S->B == c3){
     if(exclude)continue;
   }
   else if(z > *(Zb + j*X + i))continue;
   if(radius < 1)d=0.5;
   else{
     d=sqrt((double)(i-x)*(double)(i-x) + (double)(j-y)*(double)(j-y));
     if(d > (double)radius)continue;
     d=1.0 - d/(double)radius;
   }
   d=I*d;
   S=(So + j*X + i);
   /* mix to colour */
   S->R = (unsigned char)min(255.0,(double)S->R+R*d);
   S->G = (unsigned char)min(255.0,(double)S->G+G*d);
   S->B = (unsigned char)min(255.0,(double)S->B+B*d);
 }
 return;
}

long _RenderImageProcess(char *PrmList, XIMAGE *lpXimage){
 long i,j;
 char dummy[255];
 double z,scale,I,mr,fade;
 long radius,iradius,hot,c1,c2,c3,Xmax,Ymax,ifade;
 long miradius,mhot,mc1,mc2,mc3,mifade;
 float *Zb;
 fullscreenbuffer *S,*Screen,*So,*Si;
 BOOL  bDraw=TRUE,bMorph=FALSE;
 sscanf(PrmList,"%s %ld %ld %ld %ld %ld %ld %ld",dummy,&version,&c1,&c2,&c3,
        &iradius,&hot,&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,&miradius,&mhot,&mifade);
 }
 if((Zb=lpXimage->Zbuffer) == NULL)return 0;
 Xmax=lpXimage->Xmax; Ymax=lpXimage->Ymax;
 if(bMorph){
  fade=((double)mifade + mr*((double)ifade-(double)mifade))/100.0;
 }
 else fade=(double)ifade/100.0;
 scale=Xmax/320.0*fade;
 Screen=lpXimage->Screen;
 So=(fullscreenbuffer *)X__Malloc(Xmax*Ymax*(long)sizeof(fullscreenbuffer));
 if(So == NULL){
   MessageBox(GetFocus(),"Memory Out",NULL,MB_OK);
   return 0;
 }
 memcpy(So,Screen,sizeof(fullscreenbuffer)*Xmax*Ymax);
 if(hot < 4){
   for(j=0;j<Ymax;j++)for(i=0;i<Xmax;i++){
     S=(Screen + j*Xmax + i);
     z = *(Zb + j*Xmax + i);
     if(z > FARAWAY - 10.0)continue;
     if(S->R != c1 || S->G != c2 || S->B != c3)continue;
     S=(So + j*Xmax + i);
     if(hot == 1){
       S->R = S->G = S->B = 250; // hot
       if(boundary(i,j,Xmax,Ymax,Screen,c1,c2,c3)){
         radius=13.0*scale;
         DrawInBuffer(i,j,So,Xmax,Ymax,radius,Screen,TRUE,c1,c2,c3,
                      1,
                      z,Zb,
                      0.1,
                      255.0,0.0,0.0);
         radius=8.0*scale;
         DrawInBuffer(i,j,So,Xmax,Ymax,radius,Screen,TRUE,c1,c2,c3,
                      1,
                      z,Zb,
                      0.1,
                      0.0,255.0,0.0);
         radius=2.0*scale;
         DrawInBuffer(i,j,So,Xmax,Ymax,radius,Screen,TRUE,c1,c2,c3,
                      1,
                      z,Zb,
                      0.1,
                      255.0,255.0,255.0);
       }
     }
     else if(hot == 2){
       S->R = S->G = 250; S->B= 128; // warm
       if(boundary(i,j,Xmax,Ymax,Screen,c1,c2,c3)){
         radius=13.0*scale;  // 10
         DrawInBuffer(i,j,So,Xmax,Ymax,radius,Screen,FALSE,c1,c2,c3,
                      1,
                      z,Zb,
                      0.1,
                      255.0,0.0,0.0);
         radius=4.0*scale;
         DrawInBuffer(i,j,So,Xmax,Ymax,radius,Screen,FALSE,c1,c2,c3,
                      1,
                      z,Zb,
                      0.1,
                      255.0,255.0,255.0);
       }
     }
     else{
       S->R = S->G = 188; S->B = 240;  // cool
       if(boundary(i,j,Xmax,Ymax,Screen,c1,c2,c3)){
         radius=20.0*scale;
         DrawInBuffer(i,j,So,Xmax,Ymax,radius,Screen,FALSE,c1,c2,c3,
                      1,
                      z,Zb,
                      0.1,
                      48.0,48.0,255.0);
         radius=8.0*scale;
         DrawInBuffer(i,j,So,Xmax,Ymax,radius,Screen,FALSE,c1,c2,c3,
                      1,
                      z,Zb,
                      0.25,
                      90.0,90.0,255.0);
       }
     }
   }
 }
 else{
   if(bMorph){
     I=((double)miradius + mr*((double)iradius-(double)miradius))/100.0;
   }
   else I=(double)iradius/100.0;  // radiate
   for(j=0;j<Ymax;j++)for(i=0;i<Xmax;i++){
     Si=(Screen + j*Xmax + i);
     if(Si->A < 64)continue;
     S=(So + j*Xmax + i);
     if(Aboundary(i,j,Xmax,Ymax,Screen)){
       radius=13.0*scale;  // 10
       DrawAlphaBoundary(i,j,So,Xmax,Ymax,radius,Screen,1,
                    0.1,
                    255.0,0.0,0.0);
       radius=8.0*scale;
       DrawAlphaBoundary(i,j,So,Xmax,Ymax,radius,Screen,1,
                    0.1,
                    255.0,255.0,0.0);
     }
//     if(Si->A >= 64){
     if(Si->A > 128){
       S->R = (unsigned char)min(255.0,(1.0-I)*(double)Si->R+255.0*I);
       S->G = (unsigned char)min(255.0,(1.0-I)*(double)Si->G+220.0*I);
       S->B = (unsigned char)min(255.0,(1.0-I)*(double)Si->B+0.0*I);
     }
   }
 }
 memcpy(Screen,So,sizeof(fullscreenbuffer)*Xmax*Ymax);
 X__Free(So);
 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;
}


BOOL CALLBACK DlgProc(HWND hwnd,UINT msg,WPARAM wparam,LPARAM lparam);

static long   irad=0,hot=1,c1=0,c2=255,c3=0,fade=100;

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[256];
 if(Op != NULL){  /* parameters exist so read them off the list */
   sscanf(Op,"%s %ld %ld %ld %ld %ld %ld %ld",buffer,&version,&c1,&c2,&c3,
          &irad,&hot,&fade);
 }
 if(DialogBox(hDLLinstance,MAKEINTRESOURCE(DLG_GLOW),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",name,version,c1,c2,c3,
         irad,hot,fade);
 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;
}

BOOL CALLBACK DlgProc(HWND hwnd,UINT msg,WPARAM wparam,LPARAM lparam){
 BOOL err;
 char str[32];
 switch( msg ) {
   case WM_INITDIALOG:
     SetDlgItemInt(hwnd,DLG_GLOW_RADIUS,irad,FALSE);
     SetDlgItemInt(hwnd,DLG_GLOW_FADE,fade,FALSE);
     if     (hot == 1)
       SendDlgItemMessage(hwnd,DLG_GLOW_HOT,BM_SETCHECK,TRUE,0);
     if     (hot == 2)
       SendDlgItemMessage(hwnd,DLG_GLOW_WARM,BM_SETCHECK,TRUE,0);
     if     (hot == 3)
       SendDlgItemMessage(hwnd,DLG_GLOW_COOL,BM_SETCHECK,TRUE,0);
     if     (hot == 4)
       SendDlgItemMessage(hwnd,DLG_GLOW_RADIATE,BM_SETCHECK,TRUE,0);
     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_GLOW_COLOUR){
         r=(BYTE)c1; g=(BYTE)c2; b=(BYTE)c3;
         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_GLOW_COLOUR:{
            unsigned char colour[3];
            SetColour(colour,hwnd);
            c1=(long)colour[0]; c2=(long)colour[1]; c3=(long)colour[2];
            InvalidateRect(GetDlgItem(hwnd,DLG_GLOW_COLOUR),NULL,FALSE);
          }
          break;
        case IDCANCEL:
          EndDialog(hwnd,FALSE);
          return(TRUE);
        case IDOK:
          if     (SendDlgItemMessage(hwnd,DLG_GLOW_RADIATE,BM_GETCHECK,0,0))
            hot=4;
          else if(SendDlgItemMessage(hwnd,DLG_GLOW_COOL,BM_GETCHECK,0,0))
            hot=3;
          else if(SendDlgItemMessage(hwnd,DLG_GLOW_WARM,BM_GETCHECK,0,0))
            hot=2;
          else
            hot=1;
          irad=GetDlgItemInt(hwnd,DLG_GLOW_RADIUS,&err,FALSE);
          if(irad < 0)irad=0;
          if(irad > 100)irad=100;
          fade=GetDlgItemInt(hwnd,DLG_GLOW_FADE,&err,FALSE);
          if(irad < 0)irad=0;
          EndDialog(hwnd,TRUE);
          return(TRUE);
        default:
          break;
      }
      break;
    default: break;
 }
 return FALSE;
}