STARS.C

Go to the documentation of this file.

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

/* STARS.C  example image post-processing module                        */
/*                                                                      */
/*  This post processing example give users the opportunity to set an   */
/*  animation agains a background of a starfield, the stars can be      */
/*  as simple as a regular grid to a astronomically accurate cluster.   */
/*  The example illustrates drawing pixels in the screenbuffer and      */
/*  using the TransformIntoView function to bring the star location     */
/*  given in World Coordinates to the screen.  It also shows how the    */
/*  "ruler" varible is used to switch from User to World co-ords.       */
/*                                                                      */

#include <stdlib.h>
#include <stdio.h>
#include <float.h>
#include <math.h>
#include <windows.h>
#include <gl\gl.h>
#include <gl\glu.h>

#include "struct.h"           /* general structures    */
#include "..\common\postprocess\ximage.h"
#include "local.h"

#include "stars.h"    /* dialog box id's    */

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

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

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

#include "utils.h"
#include "paint.c"

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

#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

/*******************************************************************\
|                Code that executes the process                     |
\*******************************************************************/

void DrawInBuffer(BOOL black,
                  fullscreenbuffer *Screen, int Xmax, int Ymax,
                  int x, int y, unsigned char v ){
 int r,g,b;
 fullscreenbuffer *S;
 if(x < 0 || y < 0 || x >= Xmax || y >= Ymax)return;
 S=(Screen+y*Xmax+x);
 if(black &&(S->R > 1 || S->G > 1 || S->B > 1))return;
 r=(int)S->R+(int)v;
 g=(int)S->G+(int)v;
 b=(int)S->B+(int)v;
 S->R=(r>255) ? 255:r;
 S->G=(g>255) ? 255:g;
 S->B=(b>255) ? 255:b;
}

#define frac(z) fmod(z,1.0)

void DrawAApixel(BOOL black,
                 double x, double y, double w, double h,int brite,
                 fullscreenbuffer *S, int X, int Y){
  int xa,xb,ya,yb,i,j;
  double x2,y2,lfrac,rfrac,tfrac,bfrac,xfrac,yfrac;
  x2 = x + w;
  y2 = y + w;
  xa = (int)x;
  xb = (int)x2;
  ya = (int)y;
  yb = (int)y2;
  lfrac = 1.0-frac(x);
  rfrac = frac(x2);
  tfrac = 1.0-frac(y);
  bfrac = frac(y2);
  if (xa==xb) {
    xfrac = lfrac+rfrac-1.0;
    if (ya==yb) {
      DrawInBuffer(black,S,X,Y,xa,ya,xfrac*(tfrac+bfrac-1.0)*brite);
    }
    else {
      DrawInBuffer(black,S,X,Y,xa,ya,xfrac*tfrac*brite);
      for (j=ya+1; j<yb; j++) DrawInBuffer(black,S,X,Y,xa,j,xfrac*brite);
      DrawInBuffer(black,S,X,Y,xa,yb,xfrac*bfrac*brite);
    }
  }
  else {
    if (ya==yb) {
      yfrac = tfrac+bfrac-1.0;
      DrawInBuffer(black,S,X,Y,xa,ya,yfrac*lfrac*brite);
      for (i=xa+1; i<xb; i++) DrawInBuffer(black,S,X,Y,i,ya,yfrac*brite);
      DrawInBuffer(black,S,X,Y,xb,ya,yfrac*rfrac*brite);
    }
    else {
      DrawInBuffer(black,S,X,Y,xa,ya,tfrac*lfrac*brite);
      for (i=xa+1; i<xb; i++) DrawInBuffer(black,S,X,Y,i,ya,tfrac*brite);
      DrawInBuffer(black,S,X,Y,xb,ya,tfrac*rfrac*brite);
      for (j=ya+1; j<yb; j++) {
        DrawInBuffer(black,S,X,Y,xa,j,lfrac*brite);
        for (i=xa+1; i<xb; i++)DrawInBuffer(black,S,X,Y,i,j,brite);
        DrawInBuffer(black,S,X,Y,xb,j,rfrac*brite);
      }
      DrawInBuffer(black,S,X,Y,xa,yb,bfrac*lfrac*brite);
      for (i=xa+1; i<xb; i++) DrawInBuffer(black,S,X,Y,i,yb,bfrac*brite);
      DrawInBuffer(black,S,X,Y,xb,yb,bfrac*rfrac*brite);
    }
  }
}

static void DrawPointInBuffer(BOOL black, long x, long y,
                              fullscreenbuffer *Screen,
                              long X, long Y){
 /* draw a white star at screen co-ordinate (x,y)                  */
 fullscreenbuffer *S;
 S=(Screen + y*X + x);
 /* if not black don't draw, this is like 'blue screen' and should */
 /* simulate drawing in background only (well quite near!)         */
 if(black && (S->R > 1 || S->G > 1 || S->B > 1))return;
 S->R = (unsigned char)255.0;
 S->G = (unsigned char)255.0;
 S->B = (unsigned char)255.0;
 return;
}

long RegularGridOfStars(char *PrmList, XIMAGE *lpXimage){
 /* lights have been transformed to Renderer frame of reference  */
 /* Z is UP, Y is forward (in front of observer, X to the RIGHT  */
 /* the camera is located at 0,0,0. All real numbers are floats  */
 /* xx and yy are screen co-ords of light (0,0) is at top left   */
 /* With a big grid the camera can be made to appear to move     */
 /* inside the star field.                                       */
 long i,j,k,ispacing,nside,ifade,mi,mispacing,mnside,mifade;
 char dummy[255];
 double x,y,z,xp,yp,zp;
 double xx,yy,fade,mr;      /* screen coordinates of point to be plotted  */
 float *Zb;
 BOOL bMorph=FALSE;
 sscanf(PrmList,"%s %ld %ld %ld %s %ld %ld",
        dummy,&i,&nside,&ispacing,dummy,&version,&ifade);
 if(lpXimage->Morph && lpXimage->mParameters != NULL){
   bMorph=TRUE; mr=lpXimage->MorphRatio;
   sscanf(lpXimage->mParameters,"%s %ld %ld %ld %s %ld %ld",
        dummy,&mi,&mnside,&mispacing,dummy,&version,&mifade);
 }
 if(bMorph){
   fade=((double)mifade + mr*((double)ifade-(double)mifade))/100.0;
 }
 else fade=1.0;
 /* calculate regular 3D grid of stars spaced "ispacing" apart,   */
 /* ispacing is a World (long int) co-ordinate                    */
 Zb=lpXimage->Zbuffer;
 for(i=0;i<nside;i++){
   xp=(double)((i-nside/2)*ispacing);
 for(j=0;j<nside;j++){
   yp=(double)((j-nside/2)*ispacing);
 for(k=0;k<nside;k++){
   zp=(double)((k-nside/2)*ispacing);
   TransformIntoView(lpXimage->ViewTransform,xp,yp,zp,&x,&y,&z);
   if(y >= 1.000){  /* all points in front of viewer */
     xx=(double)lpXimage->Xmax/2.0 + (lpXimage->Xscale*x/y);
     yy=(double)lpXimage->Ymax/2.0 - (lpXimage->Yscale*z/y);
     if((long)xx >= 0 && (long)xx < lpXimage->Xmax &&
        (long)yy >= 0 && (long)yy < lpXimage->Ymax){
       /* this point is visible on screen */
       if(Zb != NULL){
        if(*(Zb + ((long)yy * lpXimage->Xmax) + (long)xx) > FARAWAY-10.0)
          DrawAApixel(FALSE,(long)xx,(long)yy,1.5,1.5,
                        (long)(255.0*fade),lpXimage->Screen,
                        lpXimage->Xmax,lpXimage->Ymax);
       }
       else DrawAApixel(TRUE,(long)xx,(long)yy,1.5,1.5,
                        (long)(255.0*fade),lpXimage->Screen,
                        lpXimage->Xmax,lpXimage->Ymax);
     }
   }
 }
 }
 }
 return 1;
}

/* A utility function that helps determine the name of the Star data file. */
/* The Star data filename is derived from the name and the directory where */
/* the STAR.DLL image processor is located                                 */

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

PSTR FileInPath(PSTR pstrPath){
 PSTR pstr;
 pstr = pstrPath + strlen(pstrPath);
 while (pstr > pstrPath) {
     pstr = (AnsiPrev(pstrPath, pstr));
     if (*pstr == '\\' || *pstr == ':' || *pstr == '/') {
         pstr = (AnsiNext(pstr));
         break;
     }
 }
 return pstr;
}

typedef struct{     /* star data base */
  long x,y,z;
} Star;

long _RenderImageProcess(char *PrmList, XIMAGE *lpXimage){
 int ix,nStars;
 Star *stardata=NULL;
 FILE *ifp=NULL;
 long i,j,k,ispacing,nside,ifade,mi,mj,mk,mifade;
 char xname[255],dummy[255],starname[16];
 double x,y,z,xp,yp,zp,mr;
 double xx,yy,fade;      /* screen coordinates of point to be plotted  */
 float *Zb;
 BOOL bMorph=FALSE;
 sscanf(PrmList,"%s %ld",dummy,&i);
 if(i == 0){ /* use a regular grid of stars */
   RegularGridOfStars(PrmList,lpXimage);
   return 1;
 }
 /* use the data from the database          */
 sscanf(PrmList,"%s %ld %ld %ld %s %ld %ld",
        xname,&i,&j,&k,starname,&version,&ifade);
 if(lpXimage->Morph && lpXimage->mParameters != NULL){
   bMorph=TRUE; mr=lpXimage->MorphRatio;
   sscanf(lpXimage->mParameters,"%s %ld %ld %ld %s %ld %ld",
        dummy,&mi,&mj,&mk,dummy,&version,&mifade);
 }
 if(bMorph){
   fade=((double)mifade + mr*((double)ifade-(double)mifade))/100.0;
 }
 else fade=1.0;
 /* get the name of the data file based on the processing module filename */
 /* this assumes that the data file is in the Ximage directory            */
 RestoreWhiteSpaces(xname);
 *FileInPath(xname) = '\0';
 strcat(xname,starname);
 if((ifp=fopen(xname,"rb"))== NULL){
   /* Try to base file on module base */
   strcpy(xname,lpXimage->ModuleName);
   *FileInPath(xname) = '\0';
   strcat(xname,starname);
   if((ifp=fopen(xname,"rb"))== NULL){
     MessageBeep(MB_OK);
     return 0;
   }
 }
 /* read the number of stars */
 if(fread(&nStars,sizeof(int),1,ifp)!=1)goto CLOSEDOWN;
 if(nStars < 1)goto CLOSEDOWN;
 if((stardata=X__Malloc(nStars*sizeof(Star)))==NULL){
   MessageBeep(MB_OK);
   goto CLOSEDOWN;
 }
 /* Read the star data, the data is recorded in long ints that are    */
 /* sufficiently large so that they are apparently over the horizon!  */
 if(fread(stardata,sizeof(Star),nStars,ifp)!=nStars){
   MessageBeep(MB_OK);
   goto CLOSEDOWN;
 }
 fclose(ifp); ifp=NULL;
 Zb=lpXimage->Zbuffer;
 for(i=0;i<nStars;i++){
   xp=(double)stardata[i].x;
   yp=(double)stardata[i].y;
   zp=(double)stardata[i].z;
   TransformIntoView(lpXimage->ViewTransform,xp,yp,zp,&x,&y,&z);
   if(y >= 1.000){  /* all points in front of viewer */
     xx=(double)lpXimage->Xmax/2.0 + (lpXimage->Xscale*x/y);
     yy=(double)lpXimage->Ymax/2.0 - (lpXimage->Yscale*z/y);
     if((long)xx >= 0 && (long)xx < lpXimage->Xmax &&
        (long)yy >= 0 && (long)yy < lpXimage->Ymax){
       /* this point is visible on screen */
     if(Zb != NULL){
        if(*(Zb + ((long)yy * lpXimage->Xmax) + (long)xx) > FARAWAY-10.0)
          DrawAApixel(FALSE,(long)xx,(long)yy,1.5,1.5,
                        (long)(255.0*fade),lpXimage->Screen,
                        lpXimage->Xmax,lpXimage->Ymax);
       }
         else DrawAApixel(TRUE,(long)xx,(long)yy,1.5,1.5,
                        (long)(255.0*fade),lpXimage->Screen,
                        lpXimage->Xmax,lpXimage->Ymax);
     }
   }
 }
 CLOSEDOWN:
 if(stardata != NULL)X__Free(stardata);
 if(ifp != NULL)fclose(ifp);
 return 1;
}

/*************** Function that renders anyof the OpenGL Functionality ************/

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


/******** Functions used to set process parameters ***********/

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

/* static variables that give defaults                                   */
static double spacing=1.0;          /*              in user co-ordinates */
static long startype=0,nside=10,ifade=100;
static char starfile[16]="STARS.DAT";

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 */
                                    ){
 /* output name and buffer should be as long as necessary to hold full string */
 char buffer[256];
 int ispacing;
 if(Op != NULL){  /* parameters exist so read them off the list             */
   sscanf(Op,"%s %ld %ld %ld %s %ld %ld",buffer,&startype,&nside,&ispacing,
          starfile,&version,&ifade);
   /* transform from World co-ordinates stored in parameter list to User    */
   /* coords for Dialog box edit control. The variable "ruler" is the ratio */
   /* between the integer co-ordinates used internally and the dimensions   */
   /* set by the user in the animator's Co-ord dialog box.                  */
   spacing=(double)ispacing/(double)ruler;
 }
 /*   Do the user interface as required to set up the effect, may use a     */
 /*   dialog box etc. Return old string if effect is cancelled (no change)  */
 if(DialogBox(hDLLinstance,MAKEINTRESOURCE(DLG_STARS),hWnd,
              (DLGPROC)DlgProc) == FALSE)return Op;
 /* Free space occupied by old parameter string */
 if(Op != NULL)CALL_FREE(Op);  /* free the old string */
 /* print the parameters into the buffer */
 ispacing=(long)(spacing*(double)ruler);
 sprintf(buffer,"%s %ld %ld %ld %s %ld %ld",name,startype,nside,ispacing,
         starfile,version,ifade);
 /* Prepare the output buffer to take copy of parameter list */
 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;
 }
 /* Copy the parameter string to the output buffer */
 strcpy(Op,buffer);
 return Op;
}

BOOL CALLBACK DlgProc(HWND hwnd,UINT msg,WPARAM wparam,LPARAM lparam){
 char temp[16];
 BOOL err;
 switch( msg ) {
   case WM_INITDIALOG:
     if(startype == 0)
       SendDlgItemMessage(hwnd,DLG_STARS_REGULAR,BM_SETCHECK,TRUE,0);
     else
       SendDlgItemMessage(hwnd,DLG_STARS_FILE,BM_SETCHECK,TRUE,0);
     SetDlgItemText(hwnd,DLG_STARS_NAME,starfile);
     SetDlgItemInt(hwnd,DLG_STARS_NSIDE,nside,FALSE);
     SetDlgItemInt(hwnd,DLG_STARS_BRIGHTNESS,ifade,FALSE);
     sprintf(temp,"%.2f",spacing);
     SetDlgItemText(hwnd,DLG_STARS_SPACING,temp);
     CentreDialogOnScreen(hwnd);
     return TRUE;
   case WM_PAINT:
     PaintBackground(hwnd);
     break;
   case WM_COMMAND:
     switch(LOWORD(wparam)){
        case IDCANCEL:
          EndDialog(hwnd,FALSE);
          return(TRUE);
        case IDOK:
          if(SendDlgItemMessage(hwnd,DLG_STARS_FILE,BM_GETCHECK,0,0))
               startype=1;
          else startype=0;
          if(GetDlgItemText(hwnd,DLG_STARS_NAME,starfile,12) == 0)
            strcpy(starfile,"EARTH.STB");
          if(GetDlgItemText(hwnd,DLG_STARS_SPACING,temp,12) == 0)
            spacing=1.0;
          else spacing=atof(temp);
          nside=GetDlgItemInt(hwnd,DLG_STARS_NSIDE,&err,FALSE);
          if(nside < 2)nside=2;
          ifade=GetDlgItemInt(hwnd,DLG_STARS_BRIGHTNESS,&err,FALSE);
          EndDialog(hwnd,TRUE);
          return(TRUE);
        default:
          break;
      }
      break;
    default: break;
 }
 return FALSE;
}