caustic.c

Go to the documentation of this file.

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

//    CAUSTIC.C

#include <stdlib.h>
#include <stdio.h>
#include <math.h>
#include <float.h>
#include <windows.h>
#include <gl/gl.h>

// to use texture unit 5 include this code
#include <fcntl.h>  
#define __gl2_main_
#include "..\gl2.h"
#define PADDR(functype,funcname) (funcname = (functype) wglGetProcAddress( #funcname ))
GLuint g_texture = 0;
//

#if __ZTC__ || __SC__
#ifndef max
#define max(a,b)  ( ((a) > (b)) ? (a) : (b) )
#endif
#endif

#if __WATCOMC__
#define PI 3.1415926
#endif

#if __X__MIPS__
BOOL WINAPI _CRT_INIT(HINSTANCE ,DWORD , LPVOID );
#endif

static HINSTANCE hDLLinstance=NULL;

#include "..\animate\memory.h" /* for memory definition */
#include "..\animate\memdef.h" /* local names           */
#include "defines.h"
#include "rstruct.h"
#include "caustic.h"

double triangle(double value){
  register double offset;
  if (value >= 0.0) offset = value - floor(value);
  else offset = value - (-1.0 - floor(fabs(value)));
  if (offset >= 0.5) return (2.0 * (1.0 - offset));
  else return (2.0 * offset);
}

#if __WATCOMC__
int APIENTRY LibMain(HANDLE hDLL, DWORD dwReason, LPVOID lpReserved){
#else
BOOL WINAPI DllMain(HANDLE hDLL, DWORD dwReason, LPVOID lpReserved){
#endif
  HANDLE ghMod;
  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 double sharpness=0.0,coverage=0.8;
static double c1[3]={255.0,255.0,255.0};
static double x=1.0,y=1.0,z=1.0;


#if 0
long CALLBACK ExternalTextureStartup(
#else
long _ExternalTextureStartup(
#endif
  long frame,long nframes,char *parameter_list, X__SHADER *lpEVI){
 long result;
 if(parameter_list[0] != '#'){
   MessageBox ( GetFocus(),
                (LPCTSTR) "External texture: Startup",
                (LPCTSTR) "Parameter list missing",
                MB_OK | MB_SYSTEMMODAL );
 }
 else {
  parameter_list++;
  sscanf(parameter_list,"%f %f %f  %f %f  %f %f %f",
         &x,&y,&z,&coverage,&sharpness,
         &c1[0],&c1[1],&c1[2]);
 }
 result=LoadAndCompileShader("caustic");
 //
 g_texture=0;
 if(result != -1){  // OpenGL renderer make the texture (units 5 - 7 are available
   unsigned char texdata[4][3]={{255,255,255},{255,0,0},{0,255,0},{255,255,0}};
   //   gl2Initialize(); // needed for some functions 
   PADDR(PFNGLACTIVETEXTUREPROC, glActiveTexture); 
   if(glActiveTexture == NULL)MessageBox(NULL,"NULL function",NULL,MB_OK);
   //else MessageBox(NULL,"Texture assigned","OK",MB_OK);
   glGenTextures( 1, &g_texture );
   glActiveTexture(GL_TEXTURE5); 
   glBindTexture(GL_TEXTURE_2D,g_texture);
   glTexImage2D(GL_TEXTURE_2D, 0, 3, 
                4,1, // width & height
                0, GL_RGB, GL_UNSIGNED_BYTE,
                &texdata[0][0]);
//   glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
//   glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
   glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
   glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
   glBindTexture(GL_TEXTURE_2D,0);
 }
 //
 return result;
}

#if 0
long CALLBACK ExternalTextureMorph(
#else
long _ExternalTextureMorph(
#endif
 char *parameter_list, double mr){
 int i;
 double coverage_m,sharpness_m;
 double c1_m[3];
 double x_m,y_m,z_m;
 parameter_list++;
 sscanf(parameter_list,"%f %f %f  %f %f  %f %f %f",
        &x_m,&y_m,&z_m,&coverage_m,&sharpness_m,
        &c1_m[0],&c1_m[1],&c1_m[2]);
 for(i=0;i<3;i++)c1[i]=c1_m[i]+(c1[i]-c1_m[i])*mr;
 coverage=coverage_m+(coverage-coverage_m)*mr;
 sharpness=sharpness_m+(sharpness-sharpness_m)*mr;
 x=x_m+(x-x_m)*mr;
 y=y_m+(y-y_m)*mr;
 z=z_m+(z-z_m)*mr;
 return 1;
}

#if 0
long CALLBACK ExternalTextureProcedure(
#else
long _ExternalTextureProcedure(
#endif
  long coord_type,  vector p, vector n,
  double alpha, double beta, double gamma,
  double bump,  double map_x,  double map_y,
  double *alpha_channel, unsigned char sc[3], double colour[3],
  double *reflectivity, double *transparency,
  X__SHADER *lpEVI
){
 double xx,yy,zz,noiseH;
 xx=alpha / x;
 yy=beta  / y;
 zz=gamma / z;
 nNoise(xx*5.0, yy*5.0, zz*5.0, &noiseH);
 noiseH = triangle(noiseH);
 noiseH = (0.3+0.9*noiseH);
 if(noiseH > coverage){
   noiseH=(noiseH-coverage)/(1.2-coverage);
   noiseH=noiseH*(1.0+1.0*sharpness);
   noiseH=min(noiseH,1.0);
   if(noiseH < 0.98){
     if(noiseH < 0.5)*transparency=1.0;
     else *transparency=1.0-(noiseH-0.5)*2.084;
   }
   else *transparency=0.0;
   colour[0]=(unsigned char)
    (noiseH*(double)c1[0]+(1.0-noiseH)*(double)colour[0]);
   colour[1]=(unsigned char)
    (noiseH*(double)c1[1]+(1.0-noiseH)*(double)colour[1]);
   colour[2]=(unsigned char)
    (noiseH*(double)c1[2]+(1.0-noiseH)*(double)colour[2]);
 }
 return 1;
}

void _ExternalTextureClose(X__SHADER *lpEVI){
 if(g_texture > 0){
   glDeleteTextures( 1, &g_texture );
   g_texture=0;
   //MessageBox(NULL,"Texture deleted","OK",MB_OK);
 }
 UnloadCompiledShader(tGLshaderID);
}

long _ExternalTextureProcedureGL(
  double bump_scale,
  unsigned char sc[3],
  unsigned char ac[3],
  X__SHADER *lpEVI
){
 // Set any shader specific uniform variables here.
 SetUniformVector(tGLshaderID,"MaterialC",(GLfloat)ac[0]/255.0,(GLfloat)ac[1]/255.0,(GLfloat)ac[2]/255.0);
 SetUniformVector(tGLshaderID,"C1",(GLfloat)c1[0]/255.0,(GLfloat)c1[1]/255.0,(GLfloat)c1[2]/255.0);
 SetUniformVariable(tGLshaderID,"Coverage",coverage);
 SetUniformVariable(tGLshaderID,"Sharpness",sharpness);
 SetUniformVector(tGLshaderID,"ScalingV",1.0/x,1.0/z,1.0/y);
 if(g_texture > 0){
   glActiveTexture(GL_TEXTURE5);
   glBindTexture(GL_TEXTURE_2D,g_texture);
   SetUniformInteger(tGLshaderID,"ShaderTexture",5);
 } 
 DrawShadedPolygons(tmatpass,tpass,tprogID,tattrloc,tNface,tMainFp,tNvert,tMainVp);
 if(g_texture > 0){
   glBindTexture(GL_TEXTURE_2D,g_texture);
 } 
 return 1;
}

void CentreDialogOnScreen(HWND hwnd){
 RECT rcDlg;
 long Xres,Yres;
 Yres=GetSystemMetrics(SM_CYSCREEN);
 Xres=GetSystemMetrics(SM_CXSCREEN);
 GetWindowRect(hwnd,&rcDlg);
 OffsetRect(&rcDlg,-rcDlg.left,-rcDlg.top);
 OffsetRect(&rcDlg,(Xres-rcDlg.right)/2,(Yres-rcDlg.bottom)/2);
 SetWindowPos(hwnd,HWND_TOP,rcDlg.left,rcDlg.top,0,0,SWP_NOSIZE);
 return;
}

static void SetColour(double *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]=(double)GetRValue(cc.rgbResult);
   colour[1]=(double)GetGValue(cc.rgbResult);
   colour[2]=(double)GetBValue(cc.rgbResult);
 }
}

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

#if 0
char * CALLBACK SetExternalParameters(
#else
char * _SetExternalParameters(
#endif
  char *Op,                 /* string for the parameters                  */
  HWND hWnd,                /* parent window                              */
  X__MEMORY_MANAGER *lpEVI /* pointer to structure with memory functions */
                             ){
 char szbuf[255],*Op1;
 if(Op != NULL){  /* parameters exist so read them off the list */
   Op1=Op;
   Op1++;
   sscanf(Op1,"%f %f %f  %f %f  %f %f %f",
         &x,&y,&z,&coverage,&sharpness,
         &c1[0],&c1[1],&c1[2]);
 }
 if(DialogBox(hDLLinstance,MAKEINTRESOURCE(DLG),hWnd,
              (DLGPROC)DlgProc) == FALSE)return Op;
 if(Op != NULL)CALL_FREE(Op);  /* free the old string */
 sprintf(szbuf,"# %.2f %.2f %.2f  %.3f %.2f "
                 "%.2f %.2f %.2f ",
         x,y,z,coverage,sharpness,
         c1[0],c1[1],c1[2]);
 if((Op=(char *)CALL_MALLOC(strlen(szbuf)+1)) == NULL){
  MessageBox (GetFocus(),"External shader: Out of memory","Error",
                MB_OK|MB_TASKMODAL|MB_ICONSTOP);
   return NULL;
 }
 strcpy(Op,szbuf);
 return Op;
}

BOOL CALLBACK DlgProc(HWND hwnd,UINT msg,WPARAM wparam,LPARAM lparam){
 char str[16];
 switch( msg ) {
   case WM_INITDIALOG:
     sprintf(str,"%.2f",x);
     SendDlgItemMessage(hwnd,DLG_XSCALE,WM_SETTEXT,0,(LPARAM)str);
     SendDlgItemMessage(hwnd,DLG_XSCALE,EM_LIMITTEXT,(WPARAM)12,0);
     sprintf(str,"%.2f",y);
     SendDlgItemMessage(hwnd,DLG_YSCALE,WM_SETTEXT,0,(LPARAM)str);
     SendDlgItemMessage(hwnd,DLG_YSCALE,EM_LIMITTEXT,(WPARAM)12,0);
     sprintf(str,"%.2f",z);
     SendDlgItemMessage(hwnd,DLG_ZSCALE,WM_SETTEXT,0,(LPARAM)str);
     SendDlgItemMessage(hwnd,DLG_ZSCALE,EM_LIMITTEXT,(WPARAM)12,0);
     sprintf(str,"%.2f",coverage);
     SendDlgItemMessage(hwnd,DLG_COVERAGE,WM_SETTEXT,0,(LPARAM)str);
     SendDlgItemMessage(hwnd,DLG_COVERAGE,EM_LIMITTEXT,(WPARAM)12,0);
     sprintf(str,"%.2f",sharpness);
     SendDlgItemMessage(hwnd,DLG_SHARPNESS,WM_SETTEXT,0,(LPARAM)str);
     SendDlgItemMessage(hwnd,DLG_SHARPNESS,EM_LIMITTEXT,(WPARAM)12,0);
     CentreDialogOnScreen(hwnd);
     return TRUE;
   case WM_DRAWITEM:{
       LPDRAWITEMSTRUCT lpdis;
       HBRUSH   hbr,hbrold;
       BYTE r,g,b;
       lpdis=(LPDRAWITEMSTRUCT)lparam;
       if(lpdis->CtlID == DLG_COLOUR1){
         if(lpdis->CtlID == DLG_COLOUR1){
           r=(BYTE)c1[0]; g=(BYTE)c1[1]; b=(BYTE)c1[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_COLOUR1:
          SetColour(c1,hwnd);
          InvalidateRect(GetDlgItem(hwnd,DLG_COLOUR1),NULL,FALSE);
          break;
        case IDCANCEL:
          EndDialog(hwnd,FALSE);
          return(TRUE);
        case IDOK:
          if(GetDlgItemText(hwnd,DLG_COVERAGE,str,10) == 0)
             EndDialog(hwnd,FALSE);
          if((coverage=atof(str)) == 0)EndDialog(hwnd,FALSE);
          if(GetDlgItemText(hwnd,DLG_SHARPNESS,str,10) == 0)
             EndDialog(hwnd,FALSE);
          if((sharpness=atof(str)) == 0)EndDialog(hwnd,FALSE);
          if(GetDlgItemText(hwnd,DLG_XSCALE,str,10) == 0)
             EndDialog(hwnd,FALSE);
          if((x=atof(str)) == 0)EndDialog(hwnd,FALSE);
          if(GetDlgItemText(hwnd,DLG_YSCALE,str,10) == 0)
             EndDialog(hwnd,FALSE);
          if((y=atof(str)) == 0)EndDialog(hwnd,FALSE);
          if(GetDlgItemText(hwnd,DLG_ZSCALE,str,10) == 0)
             EndDialog(hwnd,FALSE);
          if((z=atof(str)) == 0)EndDialog(hwnd,FALSE);
          EndDialog(hwnd,TRUE);
          return(TRUE);
        default:
          break;
      }
      break;
    default: break;
 }
 return FALSE;
}