PLUGINS.C

Go to the documentation of this file.

// file PLUGINS.C

// This is the file where the MESH effects POSTPROCESSOR
// and TEXTURE plugins are loaded and called.

#define MODULE_FX

#include "render.h"
#include "..\shaders\shaders.h"
#include "..\gl2.h"

static void ExternalFX(long global, char *);
static short AllocateAnotherShader(void);

#include "..\effects\sfxinfo.h"

static sfxinfo SFXinfo;
static sfxdata SFXdata;
static long FXObj;
static short AllocateAnotherShader(void);

#include "..\common\animate\wspaces.c"

long MotionBlurFrame(long frame, long subframe, long command_id){
  long i,j;
  fullscreenbuffer *f,*b;
  double df1,df,dft[9]={0.9,0.85,0.8,0.75,0.7,0.65,0.6,0.55,0.5};
  if(mblurON < 2)return 0;  /* do it in a DLL */
//  if(mblurON > 10)mblurON=10;
  f=FullScreenBuffer;
  b=MotionBlurBuffer;
  if(mblurON > 10){
    df1=1.0/(double)subframe;
    df=(double)(subframe-1);
    for(i=0;i<ResolutionY;i++){
      for(j=0;j<ResolutionX;j++){
        b->R = (unsigned char)(((double)(f->R)+(double)(b->R)*df)*df1);
        b->G = (unsigned char)(((double)(f->G)+(double)(b->G)*df)*df1);
        b->B = (unsigned char)(((double)(f->B)+(double)(b->B)*df)*df1);
//        f->R = b->R; f->G = b->G; f->B = b->B;
        b++; f++;
      }
    }
    if(command_id == 0){
      memcpy(FullScreenBuffer,MotionBlurBuffer,ResolutionX*ResolutionY*(long)sizeof(fullscreenbuffer));
      memset(MotionBlurBuffer,0,ResolutionX*ResolutionY*(long)sizeof(fullscreenbuffer));
    }
    return 0;
  }
  if(frame == 1)df=1.0;
  else          df=dft[mblurON-2];
  df1=1.0-df;
  for(i=0;i<ResolutionY;i++){
    for(j=0;j<ResolutionX;j++){
      b->R = (unsigned char)((double)(f->R)*df+(double)(b->R)*df1);
      b->G = (unsigned char)((double)(f->G)*df+(double)(b->G)*df1);
      b->B = (unsigned char)((double)(f->B)*df+(double)(b->B)*df1);
      f->R = b->R; f->G = b->G; f->B = b->B;
      b++; f++;
    }
  }
  return 0;
}

void EffectObjectVertices(long global, long O){ // Apply any modifications to the vertex positions due to external motion effects
  double amplitude,wavelength,displacement;
  long i,j,n;
  vertex *v;
  double t,vmax[3],vmin[3];
  if((n=(long)Object[O].effect) < 4)return;
  if(global == 1 && n < 50)return; /* no globals for internal */
  for(i=0;i<3;i++){vmax[i] = (double)(BIGN); vmin[i] = (double)BIGP;}
  t=Object[O].effectratio;
  v=Object[O].Vbase;
  for(i=0;i<Object[O].NoVertices;i++){ /* get object limits */
    for(j=0;j<3;j++){
       if(global == 0)v[i].p[j] -= Object[O].Centre[j]; /* apply offset */
       vmin[j] = min(vmin[j],v[i].p[j]);
       vmax[j] = max(vmax[j],v[i].p[j]);
    }
  }
  FXObj=O;
  SFXinfo.version=1;
  SFXinfo.nvert=Object[O].NoVertices;
  SFXinfo.time=t;
  SFXinfo.ltime=(long)(t*1000);
  SFXinfo.vmin[0]=(long)vmin[0];   SFXinfo.vmax[0]=(long)vmax[0];
  SFXinfo.vmin[1]=(long)vmin[1];   SFXinfo.vmax[1]=(long)vmax[1];
  SFXinfo.vmin[2]=(long)vmin[2];   SFXinfo.vmax[2]=(long)vmax[2];
  SFXinfo.origin[0]=Object[O].Centre[0];
  SFXinfo.origin[1]=Object[O].Centre[1];
  SFXinfo.origin[2]=Object[O].Centre[2];
  SFXinfo.Nfaces=Object[O].NoFaces;
  SFXinfo.Faces=(void *)Object[O].Fbase;
  if(global == 1){ /* origin include in positon matrix already applied */
    memset(&SFXdata,0,sizeof(sfxdata));
    SFXdata.size=sizeof(sfxdata);
    for(i=0;i<3;i++){
      SFXdata.pos[i]=(long)Object[O].Offset[i];
      SFXdata.camera_pos[i]=(long)ViewPoint[i];
    }
    if(R_Nground == 1){
      SFXdata.ground=TRUE;
      for(i=0;i<3;i++)SFXdata.ground_pos[i]=(long)Ground.pin[i];
    }
  }
  ExternalFX(global, Object[O].effect_param_list);
  if(global == 1)return;
  for(i=0;i<Object[O].NoVertices;i++){
    for(j=0;j<3;j++){
      v[i].p[j] += Object[O].Centre[j];  /* undo offset */
    }
  }
}

extern vector Wave_Sources[];

extern char gszHomeDir[];

void init_structures(void);

#include "..\textures\rstruct.h"

X__SHADER EviShader;  
void init_structures(void){
 X__SHADER *lpEVI;
 lpEVI=&EviShader;
 lpEVI->fp_sNoise=Snoise2;
 lpEVI->fp_sTurbulence=STurbulence;
 lpEVI->fp_Cycloidal=Cycloidal;
 lpEVI->fp_vNoise=Dnoise2;
 lpEVI->fp_vTurbulence=DTurbulence;
 lpEVI->fp_normalize=normalize;
 lpEVI->fp_Wave_Sources=Wave_Sources;
 lpEVI->fp_UseSingleShaderProgram=UseSingleShaderProgram;
 lpEVI->fp_LoadAndCompileShader=LoadAndCompileShader;
 lpEVI->fp_UnloadCompiledShader=UnloadCompiledShader;
 lpEVI->fp_SetUniformInteger=SetUniformInteger;
 lpEVI->fp_SetUniformVariable=SetUniformVariable;
 lpEVI->fp_SetUniformVector=SetUniformVector;
 lpEVI->fp_SetUniformVector2=SetUniformVector2;
 lpEVI->fp_SetUniformMatrix3=SetUniformMatrix3;
 lpEVI->fp_SetUniformMatrix4=SetUniformMatrix4;
 lpEVI->fp_SetAttributeInteger=SetAttributeInteger;
 lpEVI->fp_SetAttributeVariable=SetAttributeVariable;
 lpEVI->fp_SetAttributeVector=SetAttributeVector;
 lpEVI->fp_SetAttributeVectorID=SetAttributeVectorID;
 lpEVI->fp_BindAttributeVector=BindAttributeVector;
 lpEVI->fp_GetAttibuteLocation=GetAttibuteLocation;
 lpEVI->version=2;
 return;
}

static void ExternalFX(long global, char *parameters){
 // these old effects are identified by a number  
 static char *FxDLLnameList[]={"wave.dll","modulate.dll","squash.dll","warp.dll","spring.dll","shake.dll"};
 char fname[256],tparam[256];
 HMODULE hLib;
 FARPROC fpFun;
 long l,result=0;
 long (*fpFun1)(char *, sfxinfo *, vertex *);
 long (*fpFun2)(char *, sfxinfo *, sfxdata *, vertex *);
 sscanf(parameters,"%s",tparam);
 // tparam will hold the name of external dll or a number in range 4-9
 // if <  4 then this effect is no-longer supported so silently ignore.
 if(tparam[0] > 48 && tparam[0] < 58){ // this is a numeric ID 
   l=tparam[0] - 48;
   if(l < 4 || l > 9)return; // No effect applied
   l -= 4;
   strcpy(fname,gszHomeDir);  strcat(fname,"effects\\");
   strcat(fname,FxDLLnameList[l]);
   //if(debug != NULL)fprintf(debug,"Using internal effect [%s]\n",fname);
 }
 else {
   RestoreWhiteSpaces(tparam);
   sscanf(tparam,"%[^\0]",fname);
   //if(debug != NULL)fprintf(debug,"Using external effect [%s]\n",fname);
 }
 l=strlen(fname);
 if((hLib=AddLoadedLibrary(fname)) == NULL){ /* try to get 'dll' */
   hLib=AddLoadedLibrary(fname);
 }
 if(hLib == NULL){ /* try the default effect directory */
   char *sfname,tfname[256];
   sfname=short_form(fname);
   strcpy(tfname,gszHomeDir);  strcat(tfname,"effects\\");
   strcat(tfname,sfname);
   hLib=AddLoadedLibrary(tfname);
 }
 if(hLib != NULL){
   if(global == 0){
     if((fpFun=GetProcAddress(hLib,"_RenderExternalEffect")) != NULL){
       fpFun1 = (void *)fpFun;
       result=(*fpFun1)(parameters,&SFXinfo,Object[FXObj].Vbase);
     }
     else MessageBox(GetFocus(),(LPCTSTR)"Function Fail in DLL",NULL,MB_OK);
   }
   else{
     if((fpFun=GetProcAddress(hLib,"_RenderGlobalEffect")) != NULL){
       fpFun2 = (void *)fpFun;
       result=(*fpFun2)(parameters,&SFXinfo,&SFXdata,Object[FXObj].Vbase);
     }
   }
 }
 else MessageBox(GetFocus(),(LPCTSTR) "Load fail on DLL",NULL, MB_OK);
}

short LoadExternalTexture(char *fname, char *parameters){
 HMODULE hLib;
 FARPROC fpFun;
 long result=0;
 long GLshaderID = -1;
 long (*fpFun1)(long, long, char *, X__SHADER *);
 void (*fpFun2)(X__SHADER *);
 long (*fpTexFun1)(long,
                   vector, vector,
                   double,double,double,
                   double,
                   double,double,
                   double *,
                   unsigned char [3],
                   double *, double *);
 long (*fpTexFunGL)();
 fpTexFun1=NULL;
 fpTexFunGL=NULL;
 hLib=AddLoadedLibrary(fname);
 if(hLib == NULL){ /* try the default textures directory */
   char *sfname,tfname[256];
   sfname=short_form(fname);
   strcpy(tfname,gszHomeDir);  strcat(tfname,"textures\\");
   strcat(tfname,sfname);
   hLib=AddLoadedLibrary(tfname);
 }
 if(hLib != NULL){
   if((fpFun=GetProcAddress(hLib,"_ExternalTextureStartup")) != NULL){
     fpFun1 = (void *)fpFun;
     if(bRenderOpenGL)SetUpCorrectContext(TRUE);
     GLshaderID=(*fpFun1)(RenderCurrentFrame,0,parameters,&EviShader);
     if(bRenderOpenGL)SetUpCorrectContext(FALSE);
   }
   if((fpFun=GetProcAddress(hLib,"_ExternalTextureClose"))
     != NULL)fpFun2= (void *)fpFun;
   else      fpFun2=NULL;
   if((fpFun=GetProcAddress(hLib,"_ExternalTextureProcedure")) != NULL){
     fpTexFun1 = (void *)fpFun;
   }
   else{
     MessageBox(GetFocus(),"Failed Texture Function",NULL, MB_OK);
     return FAIL;
   }
   if((fpFun=GetProcAddress(hLib,"_ExternalTextureProcedureGL")) != NULL){ // Get address of OpenGL texture
     fpTexFunGL = (void *)fpFun;
   }
 }
 else {
   MessageBox(GetFocus(),"Failed Texture Load",NULL,MB_OK);
    return FAIL;
 }
 if(AllocateAnotherShader() == FAIL){
   return FAIL;
 }
 strcpy(Shader[Nshader].file,fname);
 strncpy(Shader[Nshader].parameters,parameters,128);
 Shader[Nshader].module     = (void *)hLib;
 Shader[Nshader].function   = (void *)fpTexFun1;
 Shader[Nshader].functionGL = (void *)fpTexFunGL;
 Shader[Nshader].shaderID   = GLshaderID;
 Shader[Nshader].close      = (void *)fpFun2;
 Shader[Nshader].morph      = NULL;  /* to be used later */
 //if(debug != NULL)fprintf(debug,"Loaded shader %ld [%s} with params [%s]\n",Nshader,fname,parameters);
 // if OpenGL renderer call the OpenGL setup function to load shaders etc!
 Nshader++;
 return OK;
}

static short AllocateAnotherShader(void){
 shader *sp;
 if(Shader == NULL)sp=(shader *)X__Malloc(sizeof(shader));
 else              sp=(shader *)X__Realloc(Shader,sizeof(shader)*(Nshader+1));
 if(sp == NULL){
   Render_Message(13,0,NULL);
   return FAIL;
 }
 Shader=sp;
 return OK;
}

void FreeExternalTextures(void){
 HMODULE hLibTex;
 void (*fpFun2)(X__SHADER *);
 long i;
 if(Nshader > 0){
   for(i=0;i<Nshader;i++){
     if(Shader[i].close != NULL){
       EviShader.GLshaderID=Shader[i].shaderID;
       fpFun2 = (void *)Shader[i].close;
       if(bRenderOpenGL)SetUpCorrectContext(TRUE);
       (*fpFun2)(&EviShader);
       if(bRenderOpenGL)SetUpCorrectContext(FALSE);
     }
     hLibTex=(HMODULE)Shader[i].module;
   }
 }
 X__Free(Shader);
 //if(debug != NULL)fprintf(debug,"Shader list freed\n");
 Shader=NULL;
}

BOOL RenderExternalTexture(long tid,     
                        vector p,     
                        vector n,     
                        double alpha, double beta, double gamma, 
                        double bump_scale,  
                        double *ac,   
                        double *transparency,  
                        unsigned char sc[3], 
                        long obj, 
                        face *fp, 
                        double colour[3]){  
 long (*fpTexFun1)(long, // function pointer prototype
                   vector, vector,
                   double,double,double,
                   double,
                   double,double,
                   double *,
                   unsigned char [3],
                   double [3],
                   double *, double *,
                   X__SHADER *);
 long result;
 double reflectivity;
 double unity=1.0;
 vector zerov={0.0,0.0,0.0};
 vector unitvx={1.0,0.0,0.0};
 vector unitvy={0.0,1.0,0.0};
 vector unitvz={0.0,0.0,1.0};
 /*  x and y are same as alpha beta */
 if(tid < 0 || tid >= Nshader)return FALSE;
 fpTexFun1=(void *)(Shader[tid].function);  // assign the function pointer to the correct function for the chosen texture
 EviShader.fp_axis_o=&zerov;
 EviShader.fp_axis_u=&unitvx;
 EviShader.fp_axis_v=&unitvy;
 EviShader.fp_axis_n=&unitvz;
 EviShader.u_length=&unity;
 EviShader.v_length=&unity;
 EviShader.fp_axis_unorm=&unitvx;
 EviShader.fp_axis_vnorm=&unitvy;
 EviShader.fp_FullSat=FALSE;  // use full saturation 
 result=(*fpTexFun1)(   // CALL ExternalTextureProcedure() in plugin
                     1, // always use map coordinates
                     p,
                     n, // surface normal vector (might be modifed in shader if it is a 'bump' shader
                     alpha,beta,gamma, // 3D texture/map coordinates
                     bump_scale,
                     alpha,beta, // 2D map coordinates
                     ac,    // alpha channel
                     sc,      
                     colour,  // Returned - surfcae colour
                     &reflectivity, // retuned but NOT used 
                     transparency,  // returned 
                     &EviShader);  // carry in extra parameters that might be needed by the shader
 return EviShader.fp_FullSat;
}

short MorphExternalTexture(char *name, char *parameters, long obj){
 HMODULE hLibTex;
 FARPROC fpFun;
 long (*fpFun1)(char *, double);
 long n,result;
 if((n=Nshader-1) < 0)return FAIL; /* assumes called IMMEDIATELY after load */
 if((hLibTex=(HMODULE)Shader[n].module) != NULL){
   if((fpFun=GetProcAddress(hLibTex,"_ExternalTextureMorph")) != NULL){
     fpFun1 = (void *)fpFun;
     result=(*fpFun1)(parameters,Object[obj].morphratio);
   }
   else return FAIL;
 }
 else return FAIL;
 return OK;
}


#include "..\common\postprocess\ximage.h"

long ExternalImageProcess(long frame, long HWrender){
 int i,j,k;
 char fname[256],tparam[256];
 long AnimatorIdList[256];
 HMODULE hLib;
 FARPROC fpFun;
 XIMAGE Ximage,*lpXimage;
 long l,result=0;
 long (*fpFun1)(char *, XIMAGE *);
 if(nImageProcesses == 0 || ImageProcesses == NULL)return 0;
 if(FullScreenBuffer == NULL){
   MessageBox(GetFocus(),
              "Image Processing not possible without full screen buffer",
              NULL,MB_OK);
   return FAIL;
 }
 Ximage.version=3;
 Ximage.HWrender=HWrender;
 Ximage.Frame=frame;
 Ximage.Xscale=scalex;
 Ximage.Yscale=scaley;
 if(anti_alias == LOW)   {Ximage.Xscale /= 2;}
 if(anti_alias == MEDIUM){Ximage.Xscale /= 2; Ximage.Yscale /= 2;}
 if(anti_alias == HIGH)  {Ximage.Xscale /= 3; Ximage.Yscale /= 2;}
 if(anti_alias == ULTRA) {Ximage.Xscale /= 3; Ximage.Yscale /= 3;}
 Ximage.Xmax=ResolutionX;
 Ximage.Ymax=ResolutionY;
 Ximage.Screen=FullScreenBuffer;
 Ximage.Blur=MotionBlurBuffer;
 Ximage.ObjectBuffer=ObjectIdBuffer;
 Ximage.Zbuffer=fszBuffer;
 Ximage.Nlights=Nlights;
 Ximage.Lights=Lights;
 Ximage.Ntargets=0;
 Ximage.Targets=NULL;
 Ximage.shadow_buffer_size=shadow_buffer_size;
 for(k=0;k<min(250,ObjectCount);k++)AnimatorIdList[k]=Object[k].AnimatorID;
 Ximage.AnimatorIdList=AnimatorIdList;
 Ximage.ViewPoint = (double *)ViewPoint;
 Ximage.CamPhi=CamPhi;
 Ximage.CamTheta=CamTheta;
 Ximage.CamAlpha=CamAlpha;
 Ximage.CamSx=CamSx;
 Ximage.CamSy=CamSy;
 Ximage.CamSz=CamSz;
 Ximage.CamIma=CamIma;
 Ximage.CamIm=CamIm;
 for(k=0;k<5;k++)Ximage.Pad[k]=0;
 Ximage.fp_Terminate=R_terminator;
 Ximage.fp_Yield=RenderYield;
 Ximage.fp_sNoise=Snoise2;
 Ximage.fp_sTurbulence=STurbulence;
 Ximage.fp_Cycloidal=Cycloidal;
 Ximage.fp_vNoise=Dnoise2;
 Ximage.fp_vTurbulence=DTurbulence;
 Ximage.fp_normalize=normalize;
 lpXimage=&Ximage;
 for(k=0;k<nImageProcesses;k++){
   lpXimage->Morph=ImageProcesses[k].imo;
   lpXimage->MorphRatio=ImageProcesses[k].fmr;
   lpXimage->first_frame=ImageProcesses[k].first_frame;
   lpXimage->this_frame=ImageProcesses[k].this_frame;
   lpXimage->last_frame=ImageProcesses[k].last_frame;
   lpXimage->aParameters=ImageProcesses[k].parameters;
   lpXimage->mParameters=ImageProcesses[k].mparameters;
   sscanf(ImageProcesses[k].parameters,"%s",tparam);
   RestoreWhiteSpaces(tparam);
   sscanf(tparam,"%[^\0]",fname);
   Render_Message(98,0,fname);
//MessageBox(NULL,fname,"Original Name",MB_OK);
   hLib=AddLoadedLibrary(fname);
   lpXimage->ModuleName=fname;
   if(hLib == NULL){ /* try the default ximage directory */
     char *sfname,tfname[256];
     sfname=short_form(fname);
     strcpy(tfname,gszHomeDir);  strcat(tfname,"postprocess\\");
     strcat(tfname,sfname);
//MessageBox(NULL,fname,"Relpacement name",MB_OK);
     hLib=AddLoadedLibrary(tfname);
     lpXimage->ModuleName=tfname;
   }
   if(hLib != NULL){
     if((fpFun=GetProcAddress(hLib,"_RenderImageProcess")) != NULL){
       for(i=0;i<4;i++)for(j=0;j<4;j++)Ximage.ViewTransform[i][j]=ViewTransform[i][j];
       fpFun1 = (void *)fpFun;
       result=(*fpFun1)(ImageProcesses[k].parameters,lpXimage);
     }
     else MessageBox(GetFocus(),
        (LPCTSTR) "Failed Function", NULL, MB_OK | MB_SYSTEMMODAL );
     //FreeLibrary(hLib);
   }
   else MessageBox(GetFocus(),(LPCTSTR) "Failed Load", NULL, MB_OK | MB_SYSTEMMODAL );
   if(!result)return FAIL;
 }
 return 0;
}