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

#include <stdlib.h>
#include <stdio.h>
#include <float.h>
#include <math.h>
#include <windows.h>
#include <commctrl.h>
#include "struct.h"           /* general structures    */
#include "..\common\postprocess\ximage.h"
#include "local.h"

#include "stereo2.h"

static long version=0;

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

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

#include "utils.h"

unsigned char *LoadMAP(char *name, int *x, int *y);

#if __WATCOMC__
int APIENTRY LibMain(HANDLE hDLL, DWORD dwReason, LPVOID lpReserved){
#elif __BC__
BOOL WINAPI DllEntryPoint(HANDLE hDLL, DWORD dwReason, LPVOID lpReserved){
#else
BOOL WINAPI DllMain(HANDLE hDLL, DWORD dwReason, LPVOID lpReserved){
#endif
  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 INVERT(a)       { a[0] = -a[0]; a[1] = -a[1]; a[2] = -a[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 VECSUM(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 TOL 0.1

double hitpoint(vector n, vector x, vector y, vector pb, vector pf,
                double * a, double * b){
vector v1,p;
double mu,det,ve1,ve2,ve3,vp1,vp2,vp3,p1,p2,p3;
VECSUB(pb,pf,v1)
mu=DOT(n,v1);
VECSCALE(mu,n,v1)
VECSUM(pf,v1,p)
ve1=x[0]; ve2=x[1]; ve3=x[2];
vp1=y[0]; vp2=y[1]; vp3=y[2];
p1=p[0]-pb[0];
p2=p[1]-pb[1];
p3=p[2]-pb[2];
det=ve1*vp2-vp1*ve2 ;
if(det > TOL || det < -TOL)  /* e-10 appears not to work */
  {  *a=( vp2*p1-vp1*p2)/det;
     *b=(-ve2*p1+ve1*p2)/det;
     goto HIT;
  }
det=ve1*vp3-vp1*ve3 ;
if(det > TOL || det < -TOL)
  {  *a=( vp3*p1-vp1*p3)/det;
     *b=(-ve3*p1+ve1*p3)/det;
     goto HIT;
  }
det=ve2*vp3-vp2*ve3 ;
if(det > TOL || det < -TOL)
  {  *a=( vp3*p2-vp2*p3)/det;
     *b=(-ve3*p2+ve2*p3)/det;
     goto HIT;
  }
*a = *b = 0.0;
HIT:
return mu;
}

long MapFrom(vector p,
             vector Mp, vector Mdx, vector Mdy, vector Mn,
             fullscreenbuffer *S,
             long Xmax, long Ymax,
             double *red,double *green,double *blue){
 long  ialpha,ibeta,i,j,k,kl,kr,kt,kb,pixel;
 double alpha,beta,a,b,cc0,cc1,cc2,cl0,cl1,cl2,
           cr0,cr1,cr2,ct0,ct1,ct2,cb0,cb1,cb2;
 unsigned char *pP,*pR,*pG,*pB;
 j=Xmax;
 hitpoint(Mn,Mdx,Mdy,Mp,p,&alpha,&beta);
 if(alpha < -0.01 || alpha > 1.01)return -1;
 if(beta  < -0.02 || beta  > 1.02)return -1;
 alpha=Xmax*alpha;
 beta =Ymax*beta;
 ialpha = (long)alpha; alpha -= (double)ialpha;
 ibeta  = (long)beta;  beta  -= (double)ibeta;
 if(ialpha < 0 || ialpha >= Xmax)return 0;
 if(ibeta  < 0 || ibeta  >= Ymax)return 0;
 k =ibeta*j+ialpha;
 if(ialpha <   1)kl=k; else kl=k-1;
 if(ialpha > j-2)kr=k; else kr=k+1;
 if(ibeta  <   1)kb=k; else kb=k-j;
 if(ibeta  > Ymax-2)kt=k; else kt=k+j;
 cc0 = (double)S[k].R;  cc1 = (double)S[k].G;  cc2 = (double)S[k].B;
 cl0 = (double)S[kl].R; cl1 = (double)S[kl].G; cl2 = (double)S[kl].B;
 cr0 = (double)S[kr].R; cr1 = (double)S[kr].G; cr2 = (double)S[kr].B;
 ct0 = (double)S[kt].R; ct1 = (double)S[kt].G; ct2 = (double)S[kt].B;
 cb0 = (double)S[kb].R; cb1 = (double)S[kb].G; cb2 = (double)S[kb].B;
 if(alpha > 0.5){
   alpha = alpha-0.5;
   if(beta > 0.5){
     beta = beta-0.5;
     *red   = (cr0-cc0)*alpha+(ct0-cc0)*beta+cc0;
     *green = (cr1-cc1)*alpha+(ct1-cc1)*beta+cc1;
     *blue  = (cr2-cc2)*alpha+(ct2-cc2)*beta+cc2;
   }
   else{
     beta = 0.5-beta;
     *red   = (cr0-cc0)*alpha+(cb0-cc0)*beta+cc0;
     *green = (cr1-cc1)*alpha+(cb1-cc1)*beta+cc1;
     *blue  = (cr2-cc2)*alpha+(cb2-cc2)*beta+cc2;
   }
 }
 else{
   alpha = 0.5-alpha;
   if(beta > 0.5){
     beta = beta-0.5;
     *red   = (cl0-cc0)*alpha+(ct0-cc0)*beta+cc0;
     *green = (cl1-cc1)*alpha+(ct1-cc1)*beta+cc1;
     *blue  = (cl2-cc2)*alpha+(ct2-cc2)*beta+cc2;
   }
   else{
     beta = 0.5-beta;
     *red   = (cl0-cc0)*alpha+(cb0-cc0)*beta+cc0;
     *green = (cl1-cc1)*alpha+(cb1-cc1)*beta+cc1;
     *blue  = (cl2-cc2)*alpha+(cb2-cc2)*beta+cc2;
   }
 }
 return 1;
}

fullscreenbuffer *ScaleImageMap(unsigned char *ImagePixels, int x, int y,
                             long X, long Y){
 vector p,Mn={0.0,0.0,1.0},Mx,My,Mp;
 double r,g,b;
 fullscreenbuffer *S,*s,*T,*t;
 unsigned char *px;
 long i,j;
 if((T=(fullscreenbuffer *)X__Malloc(x*y*sizeof(fullscreenbuffer))) == NULL){
   MessageBeep(MB_OK);
   return NULL;
 }
 px=ImagePixels; t=T;
 for(j=0;j<y;j++)for(i=0;i<x;i++){
   t->R = *px++;
   t->G = *px++;
   t->B = *px++;
   t++;
 }
 if((S=(fullscreenbuffer *)X__Malloc(X*Y*sizeof(fullscreenbuffer))) == NULL){
   MessageBeep(MB_OK);
   X__Free(T);
   return NULL;
 }
 memset(S,0,X*Y*sizeof(fullscreenbuffer));
 Mp[0]=Mp[1]=Mp[2]=Mx[2]=My[2]=p[2]=0.0;
 Mx[1]=0.0; My[0]=0.0;
 Mx[0]=(double)X;
 My[1]=(double)Y;
 s=S;
 for(i=0;i<Y;i++)for(j=0;j<X;j++){
   p[0]=(double)j;
   p[1]=(double)i;
   if(MapFrom(p,Mp,Mx,My,Mn,T,x,y,&r,&g,&b) > 0){
     s->R=(unsigned char)r;
     s->G=(unsigned char)g;
     s->B=(unsigned char)b;
   }
   s++;
 }
 X__Free(T);
 return S;
}

static void GetAnimFileName(char *fsurf, char *tempstr, long frame,
                       long firstframe, long lastframe, long framestep){
 long thisframe;
 char *cp1,*cp2;
 cp1=strchr(fsurf,'0');
 cp2=strchr(fsurf,'.');
 if(cp1 == NULL || cp2 == NULL){
   sprintf(tempstr,"dummy.evi");
 }
 else{
   int ln;
   char *cp,extn[16],fmat[16];
   strcpy(extn,cp2);
   ln=0; cp=cp1; while(cp != cp2){ln++; cp++; if(ln > 8)break;}
   *cp1='\0';
   framestep=min(1,framestep);
   thisframe=firstframe-1+frame/framestep;
   while(thisframe > lastframe)thisframe -= lastframe;
   sprintf(fmat,"%%s%%0%ldld%%s",ln);
   sprintf(tempstr,fmat,fsurf,thisframe,extn);
 }
 strcpy(fsurf,tempstr);
}


long _RenderImageProcess(char *PrmList, XIMAGE *lpXimage){
 double mr;
 int i,j;
 char name_path[256],imagefile[256],conback[255];
 long version,type,hold,nx,ny,cR,cG,cB,back,lframe,Xmax,Ymax;
 fullscreenbuffer *BackBuffer=NULL,*Front;
 
 sscanf(PrmList,"%s %ld %ld %ld %ld %ld %ld %ld %ld %ld %ld %s",name_path,
        &version,&type,&hold,
        &nx,&ny,&cR,&cG,&cB,&back,&lframe,imagefile);
 //MessageBox(NULL,PrmList,"Debug",MB_OK);
 back=2;
 sprintf(conback,"%ld",back);
 //MessageBox(NULL,conback,"Debug",MB_OK);
 if(back > 0){
   unsigned char *ImagePixels;
   int ImageXsize,ImageYsize;
   if(back == 2)GetAnimFileName(imagefile,name_path,
                     lpXimage->this_frame - lpXimage->first_frame + 1,
                     1,lframe,1);
   //MessageBox(NULL,imagefile,"Imagefile",MB_OK);
   if((ImagePixels=LoadMAP(imagefile,&ImageXsize,&ImageYsize)) != NULL){
     BackBuffer=ScaleImageMap(ImagePixels,ImageXsize,ImageYsize,lpXimage->Xmax,lpXimage->Ymax);
     X__Free(ImagePixels);
   }
 }
 else{
         MessageBox(NULL,"Bad Pointer",NULL,MB_OK);
         return 1;
 }
 Front=lpXimage->Screen;
 for(i=0;i<lpXimage->Ymax;i++)
 for(j=0;j<lpXimage->Xmax;j++){
   Front->R = Front->R + BackBuffer->R;
   Front->G = 0;
   Front->B = Front->B + BackBuffer->B;
   Front++;
   BackBuffer++;
 }
 return 1;
}

/*************** Function that renders any of the OpenGL Functionality ************/

long _RenderGLexternal(char *PrmList, XIMAGE *lpXimage){
MessageBox(NULL,"OpenGL function called","OK",MB_OK);
 return 1;
}
/**********************************************************************************/

BOOL CALLBACK DlgProc(HWND hwnd,UINT msg,WPARAM wparam,LPARAM lparam);

static long colour[3]={255,255,255};
static long type=0,hold=0,back=0,lframe=9999,nx=10,ny=10;
static char iname[256];
static X__MEMORY_MANAGER *lpLocalEVI;

char * _SetExternalParameters(
  char *Op,                 /* string for the parameters                  */
  HWND hWnd,                /* parent window                              */
  long ruler,               /* ruler scale value to facilitate scaling    */
  char *name,               /* name of DLL file with the effect           */
  X__MEMORY_MANAGER *lpEVI /* pointer to structure with memory functions */
                                    ){
 char buffer[1024];
 long id1,id2;   /* integer scaled radius value */
 strcpy(iname,"-none-");
 if(Op != NULL){  /* parameters exist so read them off the list */
   sscanf(Op,"%s %ld %ld %ld %ld %ld %ld %ld %ld %ld %ld %s",buffer,&version,
          &type,&hold,&nx,&ny,&colour[0],&colour[1],&colour[2],
          &back,&lframe,iname);
 }
 lpLocalEVI=lpEVI;
 if(DialogBox(hDLLinstance,MAKEINTRESOURCE(DLG_SUPER),hWnd,
              (DLGPROC)DlgProc) == FALSE)return Op;
 if(Op != NULL)CALL_FREE(Op);  /* free the old string */
 sprintf(buffer,"%s %ld %ld %ld %ld %ld %ld %ld %ld %ld %ld %s",
           name,version,type,hold,
           nx,ny,colour[0],colour[1],colour[2],back,lframe,iname);
 if((Op=(char *)CALL_MALLOC(strlen(buffer)+1)) == NULL){
  MessageBox (GetFocus(),"External effect: Out of memory","Error",
                MB_OK|MB_TASKMODAL|MB_ICONSTOP);
   return NULL;
 }
 strcpy(Op,buffer);
 return Op;
}


BOOL CALLBACK DlgProc(HWND hwnd,UINT msg,WPARAM wparam,LPARAM lparam){
 BOOL err;
 int i;
 char lname[255],text[512],str[255],filmname[255],*c;
 switch( msg ) {
   case WM_INITDIALOG:
     CentreDialogOnScreen(hwnd);
         GetModuleFileName(hDLLinstance,filmname,255);
         if((c=strrchr(filmname,'.')) != NULL){
           strcpy(c,".avi");
           Animate_Open(GetDlgItem(hwnd,IDC_ANIMATE1),filmname);
           Animate_Play(GetDlgItem(hwnd,IDC_ANIMATE1),0,-1,-1);
         }
         //MessageBox(NULL,iname,"Iname",MB_OK);
     SetDlgItemText(hwnd,DLG_VIDEO_IMAGENAME,iname);
         return TRUE;
   case WM_COMMAND:
     switch(LOWORD(wparam)){
        case DLG_VIDEO_SETIMAGENAME:{
            strcpy(lname,iname);
            if(XimageFileName(lpLocalEVI->lpAni,lname,"render",
                              "Choose First/Only Image File",
                              "Targa TGAs|*.tga|",
                              hwnd)){

              SetDlgItemText(hwnd,DLG_VIDEO_IMAGENAME,lname);
              strcpy(iname,lname);
            }
          }
          break;
        case IDCANCEL:
          EndDialog(hwnd,FALSE);
          return(TRUE);
        case IDOK:
          EndDialog(hwnd,TRUE);
          return(TRUE);
        default:
          break;
      }
      break;
    default: break;
 }
 return FALSE;
}


int colourmap_size,x_size,y_size,gif_iLace;
//unsigned  char p_red[256],p_green[256],p_blue[256],*decoderline;

static int rowcount;
static unsigned char *pixels = NULL;

static void tga_display_line(unsigned char *prgb,
                             long wide, long line,
                             long upsidedown, long hi){
 register long l,x,k;
 if(!upsidedown)l = 3L*(long)(line)*(long)(x_size);
 else           l = 3L*(long)(hi - 1 - line)*(long)(x_size);
 memcpy(pixels + l, prgb, (int)(wide*3));
}

static short R_getvariword(long n, FILE *f, long *vw){
 long c;
 if((c=(long)getc(f)) == EOF)return 0;
 *vw = c;          if(n == 1)return 1;
 if((c=(long)getc(f)) == EOF)return 0;
 *vw |= (c << 8);  if(n == 2)return 1;
 if((c=(long)getc(f)) == EOF)return 0;
 *vw |= (c << 16); if(n == 3)return 1;
 if((c=(long)getc(f)) == EOF)return 0;
 *vw |= (c << 24);
 return 1;
}

static short read_tga_image(char *filename, short info_only){
 char c0,c1,c2;
 long i,j,k,l,m,n,cmo,cml,xor,yor,wi,hi,iok=0,idsize,cm_type,vw,
      image_type,cmes,pixel_size,image_descriptor,n_attr,upsidedown,b_size,
      s1,s2,s,pat,wi3;
 FILE *t24;
 unsigned char *prgb;
 prgb=NULL;
 if((t24=fopen(filename,"rb")) != NULL){
   if(! R_getvariword(1,t24,&idsize))goto CLOSEOUT;
   if(! R_getvariword(1,t24,&cm_type))goto CLOSEOUT; /* 0 for non mapped */
   if(! R_getvariword(1,t24,&image_type))goto CLOSEOUT; /* image type */
   if(image_type != 2 && image_type != 10)goto CLOSEOUT;
   if(! R_getvariword(2,t24,&cmo))goto CLOSEOUT;  /* color map 5 bytes */
   if(! R_getvariword(2,t24,&cml))goto CLOSEOUT;
   if(! R_getvariword(1,t24,&cmes))goto CLOSEOUT;
   if(! R_getvariword(2,t24,&xor))goto CLOSEOUT;  /* Image spec 10 bytes */
   if(! R_getvariword(2,t24,&yor))goto CLOSEOUT;
   if(! R_getvariword(2,t24,&wi))goto CLOSEOUT;
   if(! R_getvariword(2,t24,&hi))goto CLOSEOUT;
   if(! R_getvariword(1,t24,&pixel_size))goto CLOSEOUT;
   if(! R_getvariword(1,t24,&image_descriptor))goto CLOSEOUT;
   if(idsize > 0)for(i=0;i<idsize;i++)if(getc(t24) == EOF)goto CLOSEOUT;
   if(cm_type == 1 && cml > 0){
     for(i=cmo;i<cml;i++)if(! R_getvariword(cmes/8,t24,&j))goto CLOSEOUT;
   }
   n_attr = image_descriptor & 0xf;
   upsidedown = (image_descriptor & 0x20) > 0 ? 0 : 1 ;
   if(info_only){
     x_size=(int)wi;
     y_size=(int)hi;
     fclose(t24);
     return 1;
   }
   if((prgb=(unsigned char *)X__Malloc((size_t)wi*3)) == NULL)goto CLOSEOUT;
   if((image_descriptor & 0xc0) > 0)goto CLOSEOUT; /* interlaced */
   b_size=i=wi*hi;
   if     (pixel_size == 16){n=2;s1=5;s2=10;s=3;pat=0x1f;}
   else if(pixel_size == 24){n=3;s1=8;s2=16;s=0;pat=0xff;}
   else                     {n=4;s1=8;s2=16;s=0;pat=0xff;}
   wi3=wi*3;
   if(image_type == 2){ /* uncompressed */
     m=0; k=0; for(i=0;i<hi;i++)for(j=0;j<wi;j++){
       if(! R_getvariword(n,t24,&vw))goto CLOSEOUT;
       prgb[m+2] = (char)( vw        & pat) << s;
       prgb[m+1] = (char)((vw >> s1) & pat) << s;
       prgb[m  ] = (char)((vw >> s2) & pat) << s;
       k++; m+=3;
       if(m == wi3){
         tga_display_line(prgb,wi,i,upsidedown,hi); m=0;
       }
     }
   }
   else{  /* compressed */
     m=0; l=0; k=0; while(k < b_size){
       i=getc(t24); if(feof(t24))goto CLOSEOUT;
        if(i < 128){
         for(j=0;j<i+1;j++){
           if(! R_getvariword(n,t24,&vw))goto CLOSEOUT;
           prgb[m+2] = (char)( vw        & pat) << s;
           prgb[m+1] = (char)((vw >> s1) & pat) << s;
           prgb[m  ] = (char)((vw >> s2) & pat) << s;
           k++; m+=3;
           if(m == wi3){
             tga_display_line(prgb,wi,l,upsidedown,hi); m=0; l++;
           }
         }
       }
       else{
         if(! R_getvariword(n,t24,&vw))goto CLOSEOUT;
         c0 = (char)( vw        & pat) << s;
         c1 = (char)((vw >> s1) & pat) << s;
         c2 = (char)((vw >> s2) & pat) << s;
         i -= 128;
         for(j=0;j<i+1;j++){
           prgb[m+2] = c0;
           prgb[m+1] = c1;
           prgb[m  ] = c2;
           k++;  m+=3;
           if(m == wi3){
             tga_display_line(prgb,wi,l,upsidedown,hi); m=0; l++;
           }
         }
       }
     }
   }
   iok=1;
   CLOSEOUT:
   fclose(t24);
   if(prgb != NULL)X__Free((char *)prgb);
 }
 return (short)iok;
}

static unsigned char *LoadTGA(char *TGAfile, int *xx, int *yy){
 long imagesize;
 char consize[255];
 rowcount=0;
 //MessageBox(NULL,TGAfile,"Reading TGA",MB_OK);
 if(read_tga_image(TGAfile,1) < 0)return 0;
 imagesize=x_size*y_size*3;
 //sprintf(consize,"%ld",imagesize);
 //MessageBox(NULL,consize,"Imagesize",MB_OK);
 if((pixels=(unsigned char*)X__Malloc(imagesize)) == NULL)return NULL;
 if(read_tga_image(TGAfile,0) < 0){
   X__Free(pixels);
   return NULL;
 }
 *xx=x_size; *yy=y_size;
 return pixels;
}

unsigned char *LoadMAP(char *CurrentFile, int *xx, int *yy){
 int ff;
 if(strstr(CurrentFile,".TGA") || strstr(CurrentFile,".tga"))
   return LoadTGA(CurrentFile,xx,yy);
 return NULL;
}