template.c

Go to the documentation of this file.

/* --
OpenFX version 1.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.
-- */

/* TEMPLATE.C     External shader template                                */
/*                                                                        */
/*  It should be possible to quickly build an external shader DLL for     */
/*  using this template file. Watcom C++32 is the recommended             */
/*  compiler. Check the example shader codes to see how some simple       */
/*  shaders are implemented.                                              */
/*                                                                        */

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

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

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

#ifndef PI
#define PI 3.1415926
#endif

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

/*********************** definitions needed ********************************/

#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 "template.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:
#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

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

long _ExternalTextureStartup(
  long frame,  /* identify the frame in the animation                     */
  long nframes,/* number of frames in the animation                       */
  char *parameter_list){
 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
                     */
 /* extract the shader parameters from the parameter string  */
 /* sscanf(parameter_list,"....",&....);  */
 }
 return 1;
}

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

 /* extract the shader parameters from the parameter string  */
 /* sscanf(parameter_list,"....",&....);  */

 /* morph to the original parametes with a statement of the form        */
 /* original_value = morph_value+(original_value - morph_value)*mr;     */

 return 1;
}

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 */
){

 /* Execute here the code that creates the shader */

 return 1;
}

void _ExternalTextureClose(void){
/* This function is called when the frame has been rendered and the texture
   DLL is being detached. Use it for freeing any memory allocated during
   startup
*/
}

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

/* Dialog box callback  */

BOOL CALLBACK DlgProc(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 *************/

char * _SetExternalParameters(
  char *Op,                 /* string for the parameters                  */
  HWND hWnd,                /* parent window                              */
  X__MEMORY_MANAGER *lpEVI /* pointer to structure with memory functions */
                             ){
/* output name and buffer should be as long as necessary to hold full string */
 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
           */
 /* extract the shader parameters from the parameter string  */
 /* sscanf(Op1,"....",&....);  */
 }
/*   Do the user interface as required to set up the effect, may use a  */
/*   dialog box etc. Return old string if effect is cancelled           */
 if(DialogBox(hDLLinstance,MAKEINTRESOURCE(DLG_TEMPLATE),hWnd,
              (DLGPROC)DlgProc) == FALSE)return Op;
 if(Op != NULL)CALL_FREE(Op);  /* free the old string */
/* print the parameters into the buffer       */
/* sprintf(szbuf,"# ....", .......);          */

 sprintf(szbif,"#"); /* just in case this template is compiled ! */

/* Prepare the output buffer to take copy of parameter list */
 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;
 }
 /* Copy the parameter string to the output buffer */
 strcpy(Op,szbuf);
 return Op;
}

BOOL CALLBACK DlgProc(HWND hwnd,UINT msg,WPARAM wparam,LPARAM lparam){
 char str[16];
 switch( msg ) {
   case WM_INITDIALOG:
     return TRUE;
   case WM_COMMAND:
     switch(LOWORD(wparam)){

        case IDCANCEL:
          EndDialog(hwnd,FALSE);
          return(TRUE);

        case IDOK:

          /* acquire the parameter values from Edit controls etc. */

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