fplasma.c

Go to the documentation of this file.

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

// fplasma.c

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

#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 "fplasma.h"

#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;
}

static double red_freq=5.0,green_freq=6.0,   blue_freq=7.0;
static double red_phas=0.0,green_phas=0.333333333,blue_phas=0.66666666;
static double x=1.0,y=1.0,z=1.0;
static double brite=255.0;

#if 0
long CALLBACK ExternalTextureStartup(
#else
long _ExternalTextureStartup(
#endif
  long frame,long nframes,char *parameter_list, X__SHADER *lpEVI){
 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 %f %f",
         &x,&y,&z,&brite,
         &red_freq,&green_freq,&blue_freq,
         &red_phas,&green_phas,&blue_phas);
 }
 return LoadAndCompileShader("fplasma");
}

#if 0
long CALLBACK ExternalTextureMorph(
#else
long _ExternalTextureMorph(
#endif
 char *parameter_list, double mr){
 double red_freq_m,green_freq_m,blue_freq_m;
 double red_phas_m,green_phas_m,blue_phas_m;
 double x_m,y_m,z_m;
 double brite_m;
 parameter_list++;
 sscanf(parameter_list,"%f %f %f  %f  %f %f %f  %f %f %f",
        &x_m,&y_m,&z_m,&brite_m,
        &red_freq_m,&green_freq_m,&blue_freq_m,
        &red_phas_m,&green_phas_m,&blue_phas_m);
 x=x_m+(x-x_m)*mr;
 y=y_m+(y-y_m)*mr;
 z=z_m+(z-z_m)*mr;
 brite=brite_m+(brite-brite_m)*mr;
 red_freq=red_freq_m+(red_freq-red_freq_m)*mr;
 green_freq=green_freq_m+(green_freq-green_freq_m)*mr;
 blue_freq=blue_freq_m+(blue_freq-blue_freq_m)*mr;
 red_phas=red_phas_m+(red_phas-red_phas_m)*mr;
 green_phas=green_phas_m+(green_phas-green_phas_m)*mr;
 blue_phas=blue_phas_m+(blue_phas-blue_phas_m)*mr;
 return 1;
}

double costab(double value){
  if (value < 0.0)return 0.0;
  return 0.5*(1.0+cos((value-floor(value))*3.141592657*2));
}


#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
){
 vector v;
 double xx,yy,zz,noiseH,r,g,b,noiseHH;
 xx=alpha / x;
 yy=beta  / y;
 zz=gamma / z;
 vNoise(v,
 ((double)((int)(xx*4)))/4.0,
 ((double)((int)(yy*4)))/4.0,
 ((double)((int)(zz*4)))/4.0);
 xx += v[0]; yy += v[1]; zz += v[2];
 nNoise(xx, yy, zz, &noiseH);
 nNoise(xx*0.5, yy*0.5, zz*0.5,&noiseHH);
 noiseH += noiseHH;
 nNoise(xx*0.25, yy*0.25, zz*0.25, &noiseHH);
 noiseH += noiseHH;
 r = costab(noiseH*red_freq+red_phas);             // * freq  + phase
 g = costab(noiseH*green_freq+green_phas);
 b = costab(noiseH*blue_freq+blue_phas);
 colour[0]  = r * brite;
 colour[1]  = g * brite;
 colour[2]  = b * brite;
 return 1;
}

void _ExternalTextureClose(X__SHADER *lpEVI){
 UnloadCompiledShader(tGLshaderID);
}

long _ExternalTextureProcedureGL(
  double bump_scale,
  unsigned char sc[3],
  unsigned char ac[3],
  X__SHADER *lpEVI
){
 SetUniformVector(tGLshaderID,"MaterialC",(GLfloat)ac[0]/255.0,(GLfloat)ac[1]/255.0,(GLfloat)ac[2]/255.0);
 // Callback to Render the Polygons - this allows for multiple passes - through same shaders
 // possibly with different parameters - including vertex offset - blending depth enabling 
 // to allow for multipass textures e.g. hair and fur (shell model) it's arguments must not be altered!!!
 DrawShadedPolygons(tmatpass,tpass,tprogID,tattrloc,tNface,tMainFp,tNvert,tMainVp);
 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;
}

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 %f %f",
         &x,&y,&z,&brite,
         &red_freq,&green_freq,&blue_freq,
         &red_phas,&green_phas,&blue_phas);
 }
 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  %.2f  %.2f %.2f %.2f  %.6f %.6f %.6f ",
         x,y,z,brite,
         red_freq,green_freq,blue_freq,
         red_phas,green_phas,blue_phas);
 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];
 double scale=120.0*3.0;
 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",brite);
     SendDlgItemMessage(hwnd,DLG_BRITE,WM_SETTEXT,0,(LPARAM)str);
     sprintf(str,"%.1f",red_freq);
     SendDlgItemMessage(hwnd,DLG_RED_FREQ,WM_SETTEXT,0,(LPARAM)str);
     sprintf(str,"%.1f",green_freq);
     SendDlgItemMessage(hwnd,DLG_GREEN_FREQ,WM_SETTEXT,0,(LPARAM)str);
     sprintf(str,"%.1f",blue_freq);
     SendDlgItemMessage(hwnd,DLG_BLUE_FREQ,WM_SETTEXT,0,(LPARAM)str);
     sprintf(str,"%.1f",red_phas*scale);
     SendDlgItemMessage(hwnd,DLG_RED_PHAS,WM_SETTEXT,0,(LPARAM)str);
     sprintf(str,"%.1f",green_phas*scale);
     SendDlgItemMessage(hwnd,DLG_GREEN_PHAS,WM_SETTEXT,0,(LPARAM)str);
     sprintf(str,"%.1f",blue_phas*scale);
     SendDlgItemMessage(hwnd,DLG_BLUE_PHAS,WM_SETTEXT,0,(LPARAM)str);
     CentreDialogOnScreen(hwnd);
     return TRUE;
   case WM_COMMAND:
     switch(LOWORD(wparam)){
        case IDCANCEL:
          EndDialog(hwnd,FALSE);
          return(TRUE);
        case IDOK:
          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);
          if(GetDlgItemText(hwnd,DLG_BRITE,str,10) == 0)
             EndDialog(hwnd,FALSE);
          if((brite=atof(str)) == 0)EndDialog(hwnd,FALSE);
          if(GetDlgItemText(hwnd,DLG_RED_FREQ,str,10) == 0)
             EndDialog(hwnd,FALSE);
          if((red_freq=atof(str)) == 0)EndDialog(hwnd,FALSE);
          if(GetDlgItemText(hwnd,DLG_GREEN_FREQ,str,10) == 0)
             EndDialog(hwnd,FALSE);
          if((green_freq=atof(str)) == 0)EndDialog(hwnd,FALSE);
          if(GetDlgItemText(hwnd,DLG_BLUE_FREQ,str,10) == 0)
             EndDialog(hwnd,FALSE);
          if((blue_freq=atof(str)) == 0)EndDialog(hwnd,FALSE);

         if(GetDlgItemText(hwnd,DLG_RED_PHAS,str,10) == 0)
             EndDialog(hwnd,FALSE);
          red_phas=atof(str)/scale;
          if(GetDlgItemText(hwnd,DLG_GREEN_PHAS,str,10) == 0)
             EndDialog(hwnd,FALSE);
          green_phas=atof(str)/scale;
          if(GetDlgItemText(hwnd,DLG_BLUE_PHAS,str,10) == 0)
             EndDialog(hwnd,FALSE);
          blue_phas=atof(str)/scale;

          EndDialog(hwnd,TRUE);
          return(TRUE);
        default:
          break;
      }
      break;
    default: break;
 }
 return FALSE;
}