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

/* STARS.C  example image post-processing external DLL for            */

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

#include "stars.h"

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

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

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

#include "utils.h"

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

int APIENTRY LibMain(HANDLE hDLL, DWORD dwReason, LPVOID lpReserved){
  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(LibMain)
#endif

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

static void DrawPointInBuffer(long x, long y,
                              fullscreenbuffer *Screen,
                              long X, long 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(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;
}

void DrawInBuffer(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(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(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(S,X,Y,xa,ya,xfrac*(tfrac+bfrac-1.0)*brite);
    }
    else {
      DrawInBuffer(S,X,Y,xa,ya,xfrac*tfrac*brite);
      for (j=ya+1; j<yb; j++) DrawInBuffer(S,X,Y,xa,j,xfrac*brite);
      DrawInBuffer(S,X,Y,xa,yb,xfrac*bfrac*brite);
    }
  }
  else {
    if (ya==yb) {
      yfrac = tfrac+bfrac-1.0;
      DrawInBuffer(S,X,Y,xa,ya,yfrac*lfrac*brite);
      for (i=xa+1; i<xb; i++) DrawInBuffer(S,X,Y,i,ya,yfrac*brite);
      DrawInBuffer(S,X,Y,xb,ya,yfrac*rfrac*brite);
    }
    else {
      DrawInBuffer(S,X,Y,xa,ya,tfrac*lfrac*brite);
      for (i=xa+1; i<xb; i++) DrawInBuffer(S,X,Y,i,ya,tfrac*brite);
      DrawInBuffer(S,X,Y,xb,ya,tfrac*rfrac*brite);
      for (j=ya+1; j<yb; j++) {
        DrawInBuffer(S,X,Y,xa,j,lfrac*brite);
        for (i=xa+1; i<xb; i++)DrawInBuffer(S,X,Y,i,j,brite);
        DrawInBuffer(S,X,Y,xb,j,rfrac*brite);
      }
      DrawInBuffer(S,X,Y,xa,yb,bfrac*lfrac*brite);
      for (i=xa+1; i<xb; i++) DrawInBuffer(S,X,Y,i,yb,bfrac*brite);
      DrawInBuffer(S,X,Y,xb,yb,bfrac*rfrac*brite);
    }
  }
}

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  */
 long i,j,k,ispacing,nside;
 char dummy[255];
 double x,y,z,xp,yp,zp;
 double xx,yy;      /* screen coordinates of point to be plotted  */
 sscanf(PrmList,"%s %ld %ld %ld",dummy,&i,&nside,&ispacing);
 for(i=0;i<nside;i++){
   xp=(i-nside/2)*ispacing;
 for(j=0;j<nside;j++){
   yp=(j-nside/2)*ispacing;
 for(k=0;k<nside;k++){
   zp=(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 */
//       DrawPointInBuffer((long)xx,(long)yy,lpXimage->Screen,
//                        lpXimage->Xmax,lpXimage->Ymax);
       DrawAApixel(xx,yy,1.5,1.5,255,lpXimage->Screen,
                        lpXimage->Xmax,lpXimage->Ymax);
     }
   }
 }
 }
 }
 return 1;
}

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{
 float x,y,z,fmag;
 unsigned char mag;
} Star;

long CALLBACK RenderImageProcess(char *PrmList, XIMAGE *lpXimage){
 BOOL logarithmic=FALSE;
 int ix,starcount,mag,bright,dim;
 float factor2;
 Star *stardata=NULL;
 FILE *istream=NULL;
 long i,j,k,ispacing,nside;
 char dummy[255],starname[16];
 double x,y,z,xp,yp,zp;
 double xx,yy;      /* screen coordinates of point to be plotted  */
 sscanf(PrmList,"%s %ld",dummy,&i);
 if(i == 0){
   RegularGridOfStars(PrmList,lpXimage);
   return 1;
 }
 sscanf(PrmList,"%s %ld %ld %ld %s",dummy,&i,&j,&k,starname);
 *FileInPath(dummy) = '\0';
 strcat(dummy,starname);
 if((istream=fopen(dummy,"rb"))== NULL){
   MessageBeep(MB_OK);
   return 0;
 }
 if(fread(&starcount,sizeof(int),1,istream)!=1)goto CLOSEDOWN;
 if(starcount < 1)goto CLOSEDOWN;
 if((stardata=X__Malloc(starcount*sizeof(Star)))==NULL){
   MessageBeep(MB_OK);
   goto CLOSEDOWN;
 }
 if(fread(stardata,sizeof(Star),starcount,istream)!=starcount){
   MessageBeep(MB_OK);
   goto CLOSEDOWN;
 }
 fclose(istream); istream=NULL;
 bright=255; dim=128;
 factor2=((float)bright-(float)dim)/10.0;
 for(ix=0; ix<starcount; ++ix){
   mag=stardata[ix].fmag;
   if(logarithmic)stardata[ix].mag=(int)(pow(10.0-mag,2.407));
   else           stardata[ix].mag=(int)((10.0-mag)*factor2)+dim;
 }
 for(i=0;i<starcount;i++){
   xp=stardata[i].x*65536.0;
   yp=stardata[i].y*65536.0;
   zp=stardata[i].z*65536.0;
   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 */
       DrawAApixel(xx,yy,1.5,1.5,stardata[i].mag,lpXimage->Screen,
                        lpXimage->Xmax,lpXimage->Ymax);
     }
   }
 }
 CLOSEDOWN:
 if(stardata != NULL)X__Free(stardata);
 if(istream != NULL)fclose(istream);
 return 1;
}

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


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

/* static variables     */
static double spacing=1.0;
static long startype=0,nside=10;
static char starfile[16]="EARTH.STB";

/* Function called      */
char *CALLBACK 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",buffer,&startype,&nside,&ispacing,starfile);
   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",name,startype,nside,ispacing,starfile);
 /* 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);
     sprintf(temp,"%.2f",spacing);
     SetDlgItemText(hwnd,DLG_STARS_SPACING,temp);
     CentreDialogOnScreen(hwnd);
     return TRUE;
   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;
          EndDialog(hwnd,TRUE);
          return(TRUE);
        default:
          break;
      }
      break;
    default: break;
 }
 return FALSE;
}