hcpbumps.c

Go to the documentation of this file.

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

// HCPbumps

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

#if __SC__
#pragma startaddress(DllMain)
#endif

#define VECCOPY(a,b)    { b[0] = a[0]; b[1] = a[1]; b[2] = a[2]; }
#define VECSUM(a,b,c)   { c[0]=a[0]+b[0]; c[1]=a[1]+b[1]; c[2]=a[2]+b[2];}
#define VECSUB(a,b,c)   { c[0]=a[0]-b[0]; c[1]=a[1]-b[1]; c[2]=a[2]-b[2];}
#define VECSCALE(a,b,c) { c[0]=(a)*b[0]; c[1]=(a)*b[1]; c[2]=(a)*b[2];}
#define DOT(a,b)        ( (a[0]*b[0]) + (a[1]*b[1]) + (a[2]*b[2]) )
#define CROSS(v1,v2,r)  { \
                          r[0] = (v1[1]*v2[2]) - (v2[1]*v1[2]);  \
                          r[1] = (v1[2]*v2[0]) - (v1[0]*v2[2]);  \
                          r[2] = (v1[0]*v2[1]) - (v2[0]*v1[1]);  \
                        }

#define IMOD(z,a) ((z) - ((z)/(a))*(a))

#define PATTERN(x,y,z)   ( ((z)+16384L)*64536L +  \
                           ((y)+16384L)*32768L +  \
                           ((x)+16384L))
#define FLOOR(x) ((x) >= 0.0 ? floor(x) : (0.0 - floor(0.0 - (x)) - 1.0))
#define FMOD(x,a) ((x) >= 0.0 ? fmod(x,a) :(a - fmod(-(x),a)))
#define ROOT32 0.866025403
#define ROOT3   1.73205080

static void mix(double *r, double *g, double *b, double mx,
                double r1, double g1, double b1,
                double r2, double g2, double b2){
 *r = mx*r1 + (1.0-mx)*r2;
 *g = mx*g1 + (1.0-mx)*g2;
 *b = mx*b1 + (1.0-mx)*b2;
}

double sigmoid(double t, double tmin, double tmax){
 t=3.1415926*(2.0*(t-tmin)/(tmax-tmin));
 return 0.5*(1.0-cos(t));
}

static double size=0.25,depth=1.0;
static double c1[3]={255.0,0.0,0.0};
static double c2[3]={255.0,255.0,0.0};
static double c3[3]={0.0,0.0,255.0};
static double x=1.0,y=1.0,z=1.0;
static long  type=0,colourflag=0,bumps=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 %f   %f %f %f  %ld %ld %ld",
         &x,&y,&z,&size,&depth,
         &c1[0],&c1[1],&c1[2],
         &c2[0],&c2[1],&c2[2],
         &c3[0],&c3[1],&c3[2],
         &type,&colourflag,&bumps);
 }
 return LoadAndCompileShader("hcpbumps");
}

#if 0
long CALLBACK ExternalTextureMorph(
#else
long _ExternalTextureMorph(
#endif
 char *parameter_list, double mr){
 int i;
 double size_m,depth_m;
 double c1_m[3],c2_m[3],c3_m[3];
 double x_m,y_m,z_m;
 parameter_list++;
 sscanf(parameter_list,"%f %f %f  %f %f  %f %f %f  %f %f %f   %f %f %f",
        &x_m,&y_m,&z_m,&size_m,&depth_m,
        &c1_m[0],&c1_m[1],&c1_m[2],
        &c2_m[0],&c2_m[1],&c2_m[2],
        &c3_m[0],&c3_m[1],&c3_m[2]);
 for(i=0;i<3;i++)c1[i]=c1_m[i]+(c1[i]-c1_m[i])*mr;
 for(i=0;i<3;i++)c2[i]=c2_m[i]+(c2[i]-c2_m[i])*mr;
 for(i=0;i<3;i++)c3[i]=c3_m[i]+(c3[i]-c3_m[i])*mr;
 size=size_m+(size-size_m)*mr;
 depth=depth_m+(depth-depth_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
){
 static
#if 0
 vector pp[22]={{0.25,0.0,      0.0},                     //0
                {0.75,0.0,      0.0},
                {0.0, ROOT32/2, 0.0},
                {0.5, ROOT32/2, 0.0},
                {1.0, ROOT32/2, 0.0},
                {0.25,ROOT32,   0.0},
                {0.75,ROOT32,   0.0},
                {0.0, 1.0/2.0/ROOT3-ROOT32/2,ROOT32/2.0},  //7
                {0.5, 1.0/2.0/ROOT3-ROOT32/2,ROOT32/2.0},
                {1.0, 1.0/2.0/ROOT3-ROOT32/2,ROOT32/2.0},
                {0.25,1.0/2.0/ROOT3,         ROOT32/2.0},
                {0.75,1.0/2.0/ROOT3,         ROOT32/2.0},
                {0.0, 1.0/2.0/ROOT3+ROOT32/2,ROOT32/2.0}, //12
                {0.5, 1.0/2.0/ROOT3+ROOT32/2,ROOT32/2.0},
                {1.0, 1.0/2.0/ROOT3+ROOT32/2,ROOT32/2.0},
                {0.25,0.0,      ROOT32},
                {0.75,0.0,      ROOT32},
                {0.0, ROOT32/2, ROOT32},
                {0.5, ROOT32/2, ROOT32},
                {1.0, ROOT32/2, ROOT32},
                {0.25,ROOT32,   ROOT32},
                {0.75,ROOT32,   ROOT32}};                 //21
#endif
 vector pp[35]={{0.25,0.0,      0.0},                     //0
                {0.75,0.0,      0.0},
                {0.0, ROOT32/2, 0.0},
                {0.5, ROOT32/2, 0.0},
                {1.0, ROOT32/2, 0.0},
                {0.25,ROOT32,   0.0},
                {0.75,ROOT32,   0.0},

                {-0.25,0.0,     0.0},
                { 1.25,0.0,     0.0},
                {-0.25,ROOT32,  0.0},
                { 1.25,ROOT32,  0.0},
                {-0.25,0.0,    ROOT32},
                { 1.25,0.0,    ROOT32},
                {-0.25,ROOT32, ROOT32},
                { 1.25,ROOT32, ROOT32},
                {-0.25,1.0/2.0/ROOT3,ROOT32/2.0},
                { 1.75,1.0/2.0/ROOT3,ROOT32/2.0},
                {0.0,1.0/2.0/ROOT3+ROOT32,ROOT32/2.0},
                {0.5,1.0/2.0/ROOT3+ROOT32,ROOT32/2.0},
                {1.0,1.0/2.0/ROOT3+ROOT32,ROOT32/2.0},

                {0.0, 1.0/2.0/ROOT3-ROOT32/2,ROOT32/2.0},
                {0.5, 1.0/2.0/ROOT3-ROOT32/2,ROOT32/2.0},
                {1.0, 1.0/2.0/ROOT3-ROOT32/2,ROOT32/2.0},
                {0.25,1.0/2.0/ROOT3,         ROOT32/2.0},
                {0.75,1.0/2.0/ROOT3,         ROOT32/2.0},
                {0.0, 1.0/2.0/ROOT3+ROOT32/2,ROOT32/2.0},
                {0.5, 1.0/2.0/ROOT3+ROOT32/2,ROOT32/2.0},
                {1.0, 1.0/2.0/ROOT3+ROOT32/2,ROOT32/2.0},
                {0.25,0.0,      ROOT32},
                {0.75,0.0,      ROOT32},
                {0.0, ROOT32/2, ROOT32},
                {0.5, ROOT32/2, ROOT32},
                {1.0, ROOT32/2, ROOT32},
                {0.25,ROOT32,   ROOT32},
                {0.75,ROOT32,   ROOT32}};
 vector dn,vt;
 double dx,dy,dz,zb,ccc;
 long i;
 double a,cc,xx,yy,zz,r,g,b;
 vector u,v;
 cc=size;
 xx=alpha / x;
 yy=beta  / y;
 zz=gamma / z;
 yy /= ROOT32;
 xx=FMOD(xx,1.0);
 yy=FMOD(yy,ROOT32);
 zz /= ROOT32;
 zz=FMOD(zz,ROOT32);
 zb=0.0;
 r=colour[0];
 g=colour[1];
 b=colour[2];
 VECCOPY(n,dn)
 for(i=0;i<35;i++){
   dx=(xx-pp[i][0]);
   dy=(yy-pp[i][1]);
   dz=(zz-pp[i][2]);
   if(fabs(dx) > cc)continue;
   if(fabs(dy) > cc)continue;
   if(fabs(dz) > cc)continue;
   if((a=sqrt(dx*dx+dy*dy+dz*dz)) < cc){
     if((cc-a) > zb){
       zb=(cc-a);
       if(colourflag){
         r=c1[0];
         g=c1[1];
         b=c1[2];
       }
       v[0]=dx; v[1]=dy; v[2]=dz;
       VECCOPY(dn,n)
       normalize(v);  // direction of bend relative to the texture axes
       VECSCALE(v[0],tAxis_unorm,vt)
       VECSUM(v[1]*tAxis_vnorm,vt,vt)
       VECSUM(-v[2]*tAxis_n,vt,vt)
       normalize(vt);  
       VECCOPY( vt,v) // direction of bend NOW relative to the global coords (i.e. same as "n")
       ccc=fabs(DOT(v,n));
       CROSS(v,n,u)
       CROSS(n,u,v)
       normalize(v);  // direction of bend - at right angles to the surface normal
       if(type == 0){
         a=1.9*a*sqrt(1.0-ccc*ccc);
       }
       else if(type == 1){
         a=0.5;
       }
       else{
         if(a < 0.5)a=1.0-sigmoid(a,0.0,0.5);
         else a=1.0;
       }
       a *= depth;
       if(bumps)VECSCALE( a,v,v)
       else     VECSCALE(-a,v,v)
       VECSCALE((1.0-a),n,n)
       VECSUM(v,n,n)
       normalize(n);
     }
     break;
   }
 }
 colour[0]  = r;
 colour[1]  = g;
 colour[2]  = b;
 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
){
 // Set any shader specific uniform variables here.
// 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);
 if(colourflag)SetUniformInteger(tGLshaderID,"ColourType",1);
 else          SetUniformInteger(tGLshaderID,"ColourType",0);
 if(bumps)SetUniformInteger(tGLshaderID,"Dimples",0);
 else     SetUniformInteger(tGLshaderID,"Dimples",1);
 SetUniformInteger(tGLshaderID,"ShaderID",type);
 SetUniformVector(tGLshaderID,"ScalingV",1.0/x,1.0/z,1.0/y);
 SetUniformVariable(tGLshaderID,"BumpDepth",depth);
 SetUniformVariable(tGLshaderID,"BumpSize",size);
 // 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;
}

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_FULLOPEN | CC_RGBINIT | CC_ENABLEHOOK;
 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  %f %f %f   %f %f %f  %ld %ld %ld",
         &x,&y,&z,&size,&depth,
         &c1[0],&c1[1],&c1[2],
         &c2[0],&c2[1],&c2[2],
         &c3[0],&c3[1],&c3[2],
         &type,&colourflag,&bumps);
 }
 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 "
                 "%.2f %.2f %.2f "
                 "%.2f %.2f %.2f %ld %ld %ld",
         x,y,z,size,depth,
         c1[0],c1[1],c1[2],
         c2[0],c2[1],c2[2],
         c3[0],c3[1],c3[2],
         type,colourflag,bumps);
 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",size);
     SendDlgItemMessage(hwnd,DLG_SIZE,WM_SETTEXT,0,(LPARAM)str);
     SendDlgItemMessage(hwnd,DLG_SIZE,EM_LIMITTEXT,(WPARAM)12,0);
     sprintf(str,"%.2f",depth);
     SendDlgItemMessage(hwnd,DLG_DEPTH,WM_SETTEXT,0,(LPARAM)str);
     SendDlgItemMessage(hwnd,DLG_DEPTH,EM_LIMITTEXT,(WPARAM)12,0);
     if(colourflag)
       SendDlgItemMessage(hwnd,DLG_COLOURFLAG,BM_SETCHECK,TRUE,0);
     if(type == 0)
       SendDlgItemMessage(hwnd,DLG_TYPE1,BM_SETCHECK,TRUE,0);
     else if(type == 1)
       SendDlgItemMessage(hwnd,DLG_TYPE2,BM_SETCHECK,TRUE,0);
     else if(type == 2)
       SendDlgItemMessage(hwnd,DLG_TYPE3,BM_SETCHECK,TRUE,0);
     if(bumps == 1)
       SendDlgItemMessage(hwnd,DLG_BUMP,BM_SETCHECK,TRUE,0);
     else
       SendDlgItemMessage(hwnd,DLG_DIMPLE,BM_SETCHECK,TRUE,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_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_SIZE,str,10) == 0)
             EndDialog(hwnd,FALSE);
          if((size=atof(str)) == 0)EndDialog(hwnd,FALSE);
          if(GetDlgItemText(hwnd,DLG_DEPTH,str,10) == 0)
             EndDialog(hwnd,FALSE);
          if((depth=atof(str)) == 0)EndDialog(hwnd,FALSE);
          if(SendDlgItemMessage(hwnd,DLG_COLOURFLAG,BM_GETCHECK,0,0))
            colourflag=1; else colourflag=0;
          if(SendDlgItemMessage(hwnd,DLG_TYPE1,BM_GETCHECK,0,0))type=0;
          else if(SendDlgItemMessage(hwnd,DLG_TYPE2,BM_GETCHECK,0,0))type=1;
          else if(SendDlgItemMessage(hwnd,DLG_TYPE3,BM_GETCHECK,0,0))type=2;
          if(SendDlgItemMessage(hwnd,DLG_BUMP,BM_GETCHECK,0,0))bumps=1;
          else bumps=0;
          EndDialog(hwnd,TRUE);
          return(TRUE);
        default:
          break;
      }
      break;
    default: break;
 }
 return FALSE;
}