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

#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
#include <string.h>
#include <math.h>

#define double float

#if __ZTC__
#include "\x-32vm\include\x32.h"
#ifndef max
#define max(a,b)  ( ((a) > (b)) ? (a) : (b) )
#endif
#endif

#if __WATCOMC__
#include "\x-32vm\include\x32.h"
#endif

typedef struct {
 long pos[3];
} vertex;

typedef struct {
 long nvert;
 long ltime;
 long vmin[3];
 long vmax[3];
 long origin[3];
 double time;
} sfxinfo;

char     *PrmList=NULL;
vertex   *Vlist=NULL;
sfxinfo  *SFXinfo=NULL,SFX;

char WriteFXfile(char *fname);
void ExecuteEffect(void);
char ReadFXfile(char *fname);
void SetUpEffect(void);

int main(int argc, char *argv[]){
 if(argc < 2){
   printf("Envisage 3D procedural animation program.\n");
   exit(-1);
 }
 if(strcmp(argv[1],"$$") == 0){
   unsigned long i;
//printf("Ram based\n");
//printf("%s %s %s\n",argv[2],argv[3],argv[4]);
   i=atol(argv[2]);
   SFXinfo=(sfxinfo *)((unsigned int)_x32_zero_base_ptr +
                    ((i & 0xFFFF0000) >> 12) + (i & 0xFFFF));
   i=atol(argv[3]);
   PrmList=(char *)((unsigned int)_x32_zero_base_ptr +
                    ((i & 0xFFFF0000) >> 12) + (i & 0xFFFF));
   i=atol(argv[4]);
   Vlist=(vertex *)((unsigned int)_x32_zero_base_ptr +
                    ((i & 0xFFFF0000) >> 12) + (i & 0xFFFF));
//printf("Vertices %ld ltime %ld  time %f\n",SFXinfo->nvert,SFXinfo->ltime,
//        SFXinfo->time);
//printf("Max and min %ld %ld   %ld %ld   %ld %ld\n",
//SFXinfo->vmax[0],SFXinfo->vmin[0],
//SFXinfo->vmax[1],SFXinfo->vmin[1],
//SFXinfo->vmax[2],SFXinfo->vmin[2]);
//if(PrmList != NULL)printf("[%s]\n",PrmList);
//getch();
   ExecuteEffect();
 }
 else{
   if(ReadFXfile(argv[1]) != 0) exit(-1);
   ExecuteEffect();
   if(WriteFXfile(argv[1]) != 0) exit(-1);
 }
 exit(0);
}

/* FNAME is the name of the temporary file that the EVI render module
   produces. The path for this file is passed to your program as its first
   argument.
   This function returns 0 if the temporary file was successfully opened,
   and all its data read in. Error return values are listed below :

                 -1 : Could not open file.
                 -2 : Out of memory.
                 -3 : Error in vertex (VERT) chunk (file corrupted ?).

*/
char ReadFXfile(char *fname){
 FILE *fp;
 long size, lp,nv,tl;
 short i, j;
 char buffer[16], c;
 for(i=0; i<16; ++i)buffer[i]=0;
 fp=fopen(fname,"rb");
 if(fp == NULL) return(-1);
 while(1){
  if(fread(buffer,sizeof(char),4,fp) != 4) break;  /* Read chunk title */
  if(fread(&size,sizeof(long),1,fp) != 1) break;   /* Read chunk length */
  if(strcmp(buffer,"INFO") == 0){             /* Read INFO chunk */
   fread(&SFX.nvert,sizeof(long),1,fp);
   fread(&SFX.ltime,sizeof(long),1,fp);
   fread(&SFX.vmin,sizeof(long),3,fp);
   fread(&SFX.vmax,sizeof(long),3,fp);
   fread(&SFX.origin,sizeof(long),3,fp);
   SFX.time=(double)SFX.ltime/1000.0;
   SFXinfo = &SFX;
  }
  else if(strcmp(buffer,"PRMS") == 0){        /* Read Parameter PRMS chunk */
   PrmList = (char *)malloc((size+1L)*(long)sizeof(char));
   if(PrmList == NULL){
    fclose(fp); return(-2);
   }
   fread(PrmList,sizeof(char),size,fp);
  }
  else if(strcmp(buffer,"VERT") == 0){          /* Read vertex VERT chunk */
   nv = SFXinfo->nvert;
   Vlist = (vertex *)malloc((nv+1L) * (long)sizeof(vertex));
   if(Vlist == NULL){
    fclose(fp); return(-2);
   }
   for(lp=0L; lp < nv; lp++) for(j=0; j < 3; j++){
    if(fread(&tl,sizeof(long),1,fp) != 1){ fclose(fp); return(-3); }
    Vlist[lp].pos[j] = tl;
   }
  }
  else {                        /* Chunk not recognized - so it is skipped */
   for(lp=0L; lp < size; ++lp) fread(&c,1,1,fp);
  }
 }
 fclose(fp);
 return 0;
}

/* FNAME is the temporary file that the EVI render module produces.
   The path for this file is passed to your program as its first
   argument.
   VERTICES is a pointer to the start of the vertex array to be written out.
   Give NULL as a value for this parameter if you do not wish to write out
   vertices.
   This function returns 0 if the temporary file was successfully opened,
   and all the data written out. Error return values are listed below :

                 -1 : Could not open file.
                 -2 : Could not write vertices (disk full ?).
                 NOTE: -2 is a fatal error and you should abandon your
                 special effect and return control to the renderer. Since
                 not all of the vertex positions can be written, none are
                 written and the temporary comunications file is
                 automatically deleted.

*/
char WriteFXfile(char *fname){
 FILE *fo;
 long size, lp,tl;
 short j;
 fo=fopen(fname,"wb");
 if(fo == NULL) return(-1);
 fprintf(fo,"VERT");
 size=(long)SFXinfo->nvert * (long)sizeof(long) * (long)3;
 fwrite(&size,sizeof(long),1,fo);
 for(lp=0L; lp < SFXinfo->nvert; lp++){
  for(j=0; j < 3; j++){
   tl=Vlist[lp].pos[j];
   if(fwrite(&tl,sizeof(long),1,fo) != 1){
    fclose(fo); remove(fname); return(-2);
   }
  }
 }
 fclose(fo);
 return 0;
}
/*******************************************************************\
|                Code that define the effects                       |
\*******************************************************************/

void ExecuteEffect(void){
 double amplitude,wavelength,displacement,distance;
 long i;
 double PRMfreq, PRMwavelength;
 char axis, *cp;
 wavelength=max((double)(SFXinfo->vmax[1]-SFXinfo->vmin[1]),1.0) / 12.0;
 amplitude=wavelength/24;
 for(i=0L; i < SFXinfo->nvert; i++){
  distance=sqrt((double)Vlist[i].pos[0]*(double)Vlist[i].pos[0] +
                (double)Vlist[i].pos[1]*(double)Vlist[i].pos[1]);
  displacement=amplitude*cos(PI*2*(SFXinfo->time-distance/wavelength));
  Vlist[i].pos[2] += (long)displacement;
 }
}