v_dots.c

Go to the documentation of this file.

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

/* V_DOTS.C   External texture that creates 3 dimensional dots */

#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

#ifndef PI
#define PI 3.1415926
#endif

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

static HINSTANCE hDLLinstance=NULL; /* use to pick up resources from DLL   */

/**************  definitions needed ********************************/
/* Very important to make sure that float is used for real variables       */
/* NOTE!!!!!! The modeler uses DOUBLES as they are supposed to be used     */
/*            when setting up the parametes it is VITAL that this is       */
/*            taken into account !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!      */

#include "..\animate\memory.h" /* for memory definition */
#include "..\animate\memdef.h" /* local names           */
#include "defines.h"    /* define names for callback functions          */
#include "rstruct.h"    /* define struct with callback functions etc.   */
#include "v_dots.h"     /* shader specific header file                  */

/************************** DLL entry point ********************************/

#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:
//MessageBox(NULL,"Attaching","Debug",MB_OK);
#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
//MessageBox(NULL,"Detaching","Debug",MB_OK);
      break;
  }
  return (int)TRUE;
}

#if __SC__
#pragma startaddress(DllMain)
#endif

/*******************************************************************\
|                Code that define the textures                       |
\*******************************************************************/

#define VECCOPY(a,b)    { b[0] = a[0]; b[1] = a[1]; b[2] = a[2]; }

/* set default values for any parameters in case list is lost */

static double ground_range=0.4,
              dots_xscale=1.0,dots_yscale=1.0,dots_zscale=1.0;
static long tr_type;

long _ExternalTextureStartup(
  long frame,  /* identify the frame in the animation                     */
  long nframes,/* number of frames in the animation                       */
  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 { /* use parameters as required */
   parameter_list++; /* skip over the idetifying # symbol and read any
                        parameters that may be required for this shader
                     */
   sscanf(parameter_list,"%f %f %f %f %ld",&ground_range,&dots_xscale,
          &dots_yscale,&dots_zscale,&tr_type);
 }
return LoadAndCompileShader("v_dots");
}

long _ExternalTextureMorph(char *parameter_list, double mr){
/*  mr is 0.0 -> 1.0 morph ratio - if object is being morphed           */
/*  this function is called to allow internal parameters to be adjusted */
/*  so that they may change over the duration of the morph              */
 double ground_range1;
 parameter_list++; /* skip over the idetifying # symbol and read any
                      parameters that may be required for this shader
                   */
 sscanf(parameter_list,"%f",&ground_range1);
 ground_range = ground_range1+(ground_range - ground_range1)*mr;
 return 1;
}

#define DLTA 0.05

long _ExternalTextureProcedure(
  long coord_type, /* 0 if alpha/beta/gamma must be used 1 if map-coords available */
  vector p,    /* point in World co-ordinates of the suface point to be mapped */
  vector n,    /* normal to surface at point to be mapped                  */
  double alpha,/* co-ordinates relative to the texture axes  0.0 -> 1.0 is */
  double beta, /* inside the parallipiped formed from the texture axes     */
  double gamma,
  double bump, /* parameter relative to height set for bumps               */
  double map_x,/* surface mapping co-ordinates over the face to which the  */
  double map_y,/* texture is to be applied                                 */
  double *alpha_channel, /* pointer to texture alpha channel        */
  unsigned char sc[3], /* original texture/secondary colour as set by user */
  double colour[3],    /* return the RGB value in floating point  0-255    */
                       /* On calling, the colour contains the colour that  */
                       /* has been calculated by any previous shader or    */
                       /* the original color                               */
  double *reflectivity, /* not used at present  */
  double *transparency, /* not used at present  */
  X__SHADER *lpEVI     /* pointer to structure */
){
 double r;
 alpha /= dots_xscale;
 beta  /= dots_yscale;
 gamma /= dots_zscale;
 alpha=(alpha-floor(alpha))-0.5;
 beta=(beta-floor(beta))-0.5;
 gamma=(gamma-floor(gamma))-0.5;
 if((r=sqrt(beta*beta+alpha*alpha+gamma*gamma)) < ground_range){ // dot
   VECCOPY((double)sc,colour)
   if     (tr_type == 1)*transparency=1.0;
   else if(tr_type == 2)*transparency=0.0;
 }
 else if(r < ground_range+DLTA){
   r= (r-ground_range)/DLTA;
   colour[0] = colour[0]*r + (double)sc[0]*(1.0-r);
   colour[1] = colour[1]*r + (double)sc[1]*(1.0-r);
   colour[2] = colour[2]*r + (double)sc[2]*(1.0-r);
   if     (tr_type == 1)*transparency=r;
   else if(tr_type == 2)*transparency=(1.0-r);
 }
 else{ /* background */
   if     (tr_type == 1)*transparency=0.0;
   else if(tr_type == 2)*transparency=1.0;
 }
 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.
 SetUniformVector(tGLshaderID,"MaterialC",(GLfloat)ac[0]/255.0,(GLfloat)ac[1]/255.0,(GLfloat)ac[2]/255.0);
 SetUniformVector(tGLshaderID,"ScalingV",1.0/dots_xscale,1.0/dots_zscale,1.0/dots_yscale);
 SetUniformInteger(tGLshaderID,"Ttype",tr_type);
 SetUniformVariable(tGLshaderID,"GroundRange",ground_range);
 // 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;
}

/************************** Local Utility Functions ***********************/

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

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

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

/* Set defaults for the parameter variables, declare them as static so that
   they are available to the dialog function. They are here only for the
   function that edits the parameter list and must not be used in the
   code that is called from the renderer to execute the shader             */

/************ Functions called by the modeler to set up shader *************/

#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[128],*Op1;
 if(Op != NULL){  /* parameters exist so read them off the list */
   Op1=Op;
   Op1++; /* skip over the idetifying # symbol and read any
             parameters that may be required for this shader
           */
   sscanf(Op1,"%f %f %f %f %ld",&ground_range,&dots_xscale,&dots_yscale,
          &dots_zscale,&tr_type);
 }
 if(DialogBox(hDLLinstance,MAKEINTRESOURCE(DLG_DOTS),hWnd,
              (DLGPROC)DotsDlgProc) == FALSE)return Op;
 if(Op != NULL)CALL_FREE(Op);  /* free the old string */
 sprintf(szbuf,"%c %.2f %.2f %.2f %.2f %ld",'#',ground_range,dots_xscale,
         dots_yscale,dots_zscale,tr_type);
 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 DotsDlgProc(HWND hwnd,UINT msg,WPARAM wparam,LPARAM lparam){
 char str[16];
 switch( msg ) {
   case WM_INITDIALOG:
     sprintf(str,"%.2f",ground_range);
     SendDlgItemMessage(hwnd,DLG_DOTS_RADIUS,WM_SETTEXT,0,(LPARAM)str);
     SendDlgItemMessage(hwnd,DLG_DOTS_RADIUS,EM_LIMITTEXT,(WPARAM)12,0);
     sprintf(str,"%.2f",dots_xscale);
     SendDlgItemMessage(hwnd,DLG_DOTS_XSCALE,WM_SETTEXT,0,(LPARAM)str);
     SendDlgItemMessage(hwnd,DLG_DOTS_XSCALE,EM_LIMITTEXT,(WPARAM)12,0);
     sprintf(str,"%.2f",dots_yscale);
     SendDlgItemMessage(hwnd,DLG_DOTS_YSCALE,WM_SETTEXT,0,(LPARAM)str);
     SendDlgItemMessage(hwnd,DLG_DOTS_YSCALE,EM_LIMITTEXT,(WPARAM)12,0);
     sprintf(str,"%.2f",dots_zscale);
     SendDlgItemMessage(hwnd,DLG_DOTS_ZSCALE,WM_SETTEXT,0,(LPARAM)str);
     SendDlgItemMessage(hwnd,DLG_DOTS_ZSCALE,EM_LIMITTEXT,(WPARAM)12,0);
     if     (tr_type == 0)
        SendDlgItemMessage(hwnd,DLG_DOTS_TRANSALL,BM_SETCHECK,TRUE,0);
     else if(tr_type == 1)
        SendDlgItemMessage(hwnd,DLG_DOTS_TRANSB,BM_SETCHECK,TRUE,0);
     else if(tr_type == 2)
        SendDlgItemMessage(hwnd,DLG_DOTS_TRANSM,BM_SETCHECK,TRUE,0);
     CentreDialogOnScreen(hwnd);
     return TRUE;
   case WM_COMMAND:
     switch(LOWORD(wparam)){
        case IDCANCEL:
        case DLG_DOTS_CANCEL:
          EndDialog(hwnd,FALSE);
          return(TRUE);
        case IDOK:
        case DLG_DOTS_OK:
          if(GetDlgItemText(hwnd,DLG_DOTS_RADIUS,str,10) == 0)
             EndDialog(hwnd,FALSE);
          if((ground_range=atof(str)) == 0)EndDialog(hwnd,FALSE);
          if(GetDlgItemText(hwnd,DLG_DOTS_XSCALE,str,10) == 0)
             EndDialog(hwnd,FALSE);
          if((dots_xscale=atof(str)) == 0)EndDialog(hwnd,FALSE);
          if(GetDlgItemText(hwnd,DLG_DOTS_YSCALE,str,10) == 0)
             EndDialog(hwnd,FALSE);
          if((dots_yscale=atof(str)) == 0)EndDialog(hwnd,FALSE);
          if(GetDlgItemText(hwnd,DLG_DOTS_ZSCALE,str,10) == 0)
             EndDialog(hwnd,FALSE);
          if((dots_zscale=atof(str)) == 0)EndDialog(hwnd,FALSE);
          if     (SendDlgItemMessage(hwnd,DLG_DOTS_TRANSALL,BM_GETCHECK,0,0))
            tr_type=0;
          if     (SendDlgItemMessage(hwnd,DLG_DOTS_TRANSB,BM_GETCHECK,0,0))
            tr_type=1;
          if     (SendDlgItemMessage(hwnd,DLG_DOTS_TRANSM,BM_GETCHECK,0,0))
            tr_type=2;
          EndDialog(hwnd,TRUE);
          return(TRUE);
        default:
          break;
      }
      break;
    default: break;
 }
 return FALSE;
}