ATMOS.C

Go to the documentation of this file.

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

/* atmos.c  image post-processor                                        */
/*                                                                      */

#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 "defines.h"

#include "atmos.h"

#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

#define RS              (1.0/(double)RAND_MAX)
#define CF(c)           ((double)(c)/(double)(255))
#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 ONE_256 3.90625e-3

static vector fog_colour={0.5,0.2,1.0};
static double over_shadow=0.0,over_density=0.0,max_attn1=0.96;

static void m4by1(double t4[4][4], double x, double y, double z,
                  double *xx, double *yy, double *zz){
   *xx=t4[0][0]*x+t4[0][1]*y+t4[0][2]*z+t4[0][3];
   *yy=t4[1][0]*x+t4[1][1]*y+t4[1][2]*z+t4[1][3];
   *zz=t4[2][0]*x+t4[2][1]*y+t4[2][2]*z+t4[2][3];
 return;
}

static double GetClosestPoint(vector d, vector P, vector r,
                              double *mu, double *lambda){
  vector a,x;
  double ddotr,pdotd,pdotr;
  ddotr=DOT(d,r);
  if(fabs(ddotr) < 1.0e-10){
    *mu = *lambda = 0.0; return 0.0;   // colinear;
  }
  pdotd=DOT(P,d);
  pdotr=DOT(P,r);
  *mu = (pdotd - pdotr*ddotr)/(1.0 - ddotr*ddotr);
  *lambda = *mu*ddotr-pdotr;
  VECSCALE(*mu,d,a)
  VECSUM(P,*lambda*r,x)
  VECSUB(a,x,a)
  return sqrt(a[0]*a[0]+a[1]*a[1]+a[2]*a[2]);
}

static long GetSphereIntersection(vector d, vector P,
                                double radius,
                                double *dn, double *df){
 double ddotr,pdotr,a,a2,b,c,b4,mu1,mu2,lambda1,lambda2;
 vector A,B,tv;
 a=1.0;
 b=-2*(DOT(d,P));
 c=DOT(P,P)-radius*radius;
 b4=b*b-4.0*a*c;
 if(b4 < 0.0)return 0;
 else if(b4 < 1.e-10){
   *dn = *df = -b/(2*a);
 }
 else{
   b4=sqrt(b4);
   a2=0.5/a;
   mu1=(-b+b4)*a2;
   mu2=(-b-b4)*a2;
   if(mu1 < 0.0){
     *dn=0.0; *df=mu2;
   }
   else if(mu2 < 0){
     *dn=0.0; *df=mu1;
   }
   else{
     if(mu1 < mu2){*dn=mu1; *df=mu2;}
     else         {*dn=mu2; *df=mu1;}
   }
 }
 return 2;
}

static long GetConeIntersection(vector d,            // direction of ray
                                vector P, vector r,  // light pos + direction
                                double tt2,
                                BOOL bOriginInCone,  // double cone
                                BOOL bIlluminated,   // origin in ill. half
                                double *dn, double *df){
 double ddotr,pdotr,a,a2,b,c,b4,mu1,mu2,lambda1,lambda2;
 vector A,B,tv;
 ddotr=DOT(d,r);
 VECSCALE(-ddotr,r,tv)
 VECSUM(d,tv,A)
 pdotr=DOT(P,r);
 VECSCALE(pdotr,r,tv)
 VECSUB(tv,P,B)
 a=DOT(A,A)-ddotr*ddotr*tt2;
 b=2*(DOT(A,B)+ddotr*pdotr*tt2);
 c=DOT(B,B)-pdotr*pdotr*tt2;
 b4=b*b-4.0*a*c;
 if(b4 < 0.0)return 0;     // no intersection of ray with cone
 else if(b4 < 1.e-10){     // one intersection
   *dn = -b/(2*a);
   lambda1=(*dn)*ddotr-pdotr;
   if(lambda1 < 0.0)return 0;
   *df = FARAWAY;
MessageBeep(MB_OK);
   return 0; // 2
 }
 else{
   b4=sqrt(b4);
   a2=0.5/a;
   mu1=(-b+b4)*a2;
   mu2=(-b-b4)*a2;
   lambda1=mu1*ddotr-pdotr;
   lambda2=mu2*ddotr-pdotr;
   if(!bOriginInCone){ // ray originates outside cone
     if(lambda1 < 0.0 && lambda2 < 0.0)return 0;
     else if(lambda1 < 0.0){
       if(mu2 < 0)return 0;
       *dn=mu2; *df=FARAWAY;
     }
     else if(lambda2 < 0.0){
       if(mu1 < 0)return 0;
       *dn=mu1; *df=FARAWAY;
     }
     else{
       if(mu1 < 0.0 || mu2 < 0.0)return 0;
       if(mu1 < mu2){*dn=mu1; *df=mu2;}
       else         {*dn=mu2; *df=mu1;}
     }
   }
   else{  // ray originates inside cone
     if(lambda1 < 0.0 && lambda2 < 0.0)return 0;  // no inter with illuminate half
     else if(lambda1 < 0.0){  // dark half
       if(bIlluminated){
         *dn=1.0;
         *df=mu2;
       }
       else{
         if(mu2 < 0)*dn=1.0;    // light behind
         else       *dn=mu2;
        *df=FARAWAY;
       }
     }
     else if(lambda2 < 0.0){  // dark half
       if(bIlluminated){
         *dn=1.0;
         *df=mu1;
       }
       else{
         if(mu1 < 0)*dn=1.0;
         else       *dn=mu1;
         *df=FARAWAY;
       }
     }
     else{
       if(mu1 < mu2){
         if(mu1 < 0.0)*dn=1.0;
         else         *dn=mu1;
         *df=mu2;
       }
       else{
         if(mu2 < 0.0)*dn=1.0;
         else         *dn=mu2;
         *df=mu1;
       }
     }
   }
 }
 return 2;
}

static double m_ratio=1.0;

static void TraceSphericalVolume(long Nsamples, vector d, vector pLight,
                                 double dns, double z, double dfs,
                                 double attn, vector colour,
                                 light *Lp, XIMAGE *lpXimage){
 double f;
 f = attn*(dfs-dns)/(2.0/Lp->dc_l);
 colour[0] = colour[0]*(1.0-f) + fog_colour[0]*f;
 colour[1] = colour[1]*(1.0-f) + fog_colour[1]*f;
 colour[2] = colour[2]*(1.0-f) + fog_colour[2]*f;
 return;
}

static void SimpleTrace(long type, double l, double lambda,
                        double dmin, double z, double dmax,
                        double tan_theta1, double tan_theta2,
                        double attn, vector colour,
                        light *Lp, XIMAGE *lpXimage){
 double tan_theta,f,noise,dattn;
 double noise1,noise2;
 if(lambda < 1.0e-10)return;
 tan_theta=l/lambda;
 if(z < dmax){
   attn = attn*(z-dmin)/(dmax-dmin);
 }
 noise1=Lp->pin[0]+Lp->pin[1]+Lp->pin[2];
 noise1 *= 0.33/12000.0;
 noise2=Lp->dPhi+Lp->dTheta+Lp->dAlpha;
 noise2 *= 0.33;
 if(type < 3){
   if(type == 0){
     noise=tan_theta*90.0; dattn=0.1;  // streaks
   }
   else if(type == 1){
     noise=l; dattn=0.3;               // particulate
   }
   else if(type == 2){
     noise = lambda/500.0;  dattn=0.1; // bands
   }
   nNoise(noise,noise1,noise2,&noise);
   attn += dattn*(noise-0.5);
   if(tan_theta <= tan_theta2){
     f=1.0 - (tan_theta/tan_theta2)*(tan_theta/tan_theta2);
     f=max(0.0,attn)*f;
   }
   else f=0.0;
 }
 else{
   attn=0.5; dattn=0.3;                // cloudy
   nNoise(l/12000.0,lambda/12000.0,0.0,&noise);
   attn += dattn*(noise-0.5);
   if(tan_theta <= tan_theta1)f=attn;
   else if(tan_theta <= tan_theta2){
     f=(1.0-(tan_theta-tan_theta1)/(tan_theta2-tan_theta1));
     f=attn*f;
   }
   else f=0.0;
 }
 colour[0] = colour[0]*(1.0-f) + fog_colour[0]*f;
 colour[1] = colour[1]*(1.0-f) + fog_colour[1]*f;
 colour[2] = colour[2]*(1.0-f) + fog_colour[2]*f;
 return;
// if(tan_theta <= tan_theta1)f=attn;
// else if(tan_theta <= tan_theta2){
//   f=(1.0-(tan_theta-tan_theta1)/(tan_theta2-tan_theta1));
//   f=attn*f;
// }
}

static double PointInShadow(vector p, light *Lp, long SBS, XIMAGE *lpXimage){
  //  double shadow_density = -0.2;
  double shadow_density = -over_shadow;
  double intensity=1.0;
  double x,y,z,zz,dx,dy,ddx,ddy;
  long i,j;
  m4by1(Lp->shadow_transform,p[0],p[1],p[2],&x,&y,&z);
  if(y > 0.0){  /* point in front of light */
    ddx=Lp->scale*x/y;
    ddy=Lp->scale*z/y;
    dx=((double)SBS/2.0 + ddx);
    dy=((double)SBS/2.0 - ddy);
    //i=(long)dx; j=(long)dy;
    for(i=(long)dx-2;i<=(long)dx+1;i++)
    for(j=(long)dy-1;j<=(long)dy+2;j++)
    if(i >= 0 && i < SBS && j >= 0 && j < SBS){
      zz = *(Lp->atmospheric_shadow_buffer+j*SBS+i);
      if(y > zz)return shadow_density;
    }
    { double noise,noise1,noise2,r;
      r=2.0*sqrt(ddx*ddx+ddy*ddy)/(double)SBS;
      noise=10.0*r;
      noise1=Lp->pin[0]+Lp->pin[1]+Lp->pin[2];
      noise1 *= 0.33/12000.0;
      noise2=Lp->dPhi+Lp->dTheta+Lp->dAlpha;
      noise2 *= 0.33;
      nNoise(noise,noise1,noise2,&noise);
      intensity = 0.8+0.4*(noise-0.5);
    }
  }
  return intensity;
}

static void TracePixel(long Nsamples, long x, long y,
                       double dmin, double z, double dmax,
                       vector d, vector colour,
                       light *Lp, XIMAGE *lpXimage){
 double max_attn=max_attn1;
 long i;
 double ds,f,attn,attn1,alpha,cc,falloff;
 vector p,dp,dd,dl;
 ds=(dmax-dmin);
 if(z < dmax){
   max_attn = max_attn*(z-dmin)/ds;
   dmax=min(z,dmax);
   ds=(dmax-dmin);
 }
 ds=ds/(double)Nsamples;
 VECSCALE(dmin,d,p)
 VECSCALE(ds,d,dd);
 for(i=0,attn=0.0;i<Nsamples;i++){
   VECSCALE(ds*(double)rand()*RS,d,dp) VECSUM(dp,p,dp)
   attn1=PointInShadow(dp,Lp,lpXimage->shadow_buffer_size,lpXimage);
   //   if(attn1 > 0){f=0.8; goto TSST;}
   //   attn1=PointInShadow(p,Lp,lpXimage->shadow_buffer_size,lpXimage);
   //   if(PointInShadow(p,Lp,lpXimage->shadow_buffer_size,lpXimage) < 1.0)return;
   if(attn1 > 0.0){
     VECSUB(Lp->p,p,dl)
     normalize(dl);
     alpha=(fabs(DOT(Lp->d,dl)));
     if(alpha < Lp->dot2)falloff=0.0;
     else if(alpha < Lp->dot1)
       falloff=(alpha-Lp->dot2)*Lp->falloff;
     else falloff=1.0;
     attn1 *= falloff;
   }
   attn += attn1;
   VECSUM(p,dd,p)
 }
 attn=max(attn,0.0);
 f=max_attn*attn/(double)Nsamples;
 //f=min(1.0,f*4);
 f=min(1.0,f*over_density);
 //TSST:
 colour[0] = colour[0]*(1.0-f) + fog_colour[0]*f;
 colour[1] = colour[1]*(1.0-f) + fog_colour[1]*f;
 colour[2] = colour[2]*(1.0-f) + fog_colour[2]*f;
 return;
}

long _RenderImageProcess(char *PrmList, XIMAGE *lpXimage){
 int i,j,k;
 unsigned char cR,cG,cB;
 int icR,icG,icB;
 long fast,fast_type;
 char dummy[255];
 double tan_theta1,tan_theta2,cos_theta2;
 double Sx,Sy,dn,df,dns,dfs,dmin,dmax,l,mu,lambda;
 long Xmax,Ymax,type,id,nc,Nsamples=16;
 light *Lp;
 BOOL bOriginInCone,bIlluminated;
 vector d,dl,colour,phat;
 double tan_theta_sq;
 float *Zb;
 double z;
 fullscreenbuffer *S,*s;
 if(lpXimage->Nlights == 0 || lpXimage->Lights == NULL)return 1;
 sscanf(PrmList,"%s %ld %ld %ld %ld %ld %ld %d %d %d %f %f %f",
        dummy,
        &version,&type,&id,
        &Nsamples,&fast,&fast_type,
        &icR,&icG,&icB,
        &over_shadow,&over_density,&max_attn1);
 cR = (unsigned char)icR; 
 cG = (unsigned char)icG; 
 cB = (unsigned char)icB; 
 fog_colour[0]=CF(cR);
 fog_colour[1]=CF(cG);
 fog_colour[2]=CF(cB);
 over_density += 1;
 over_density=min(over_density,5.0);
 over_shadow=max(over_shadow,0.0);
 over_shadow=min(over_shadow,1.0);
 if(lpXimage->Morph && lpXimage->mParameters != NULL){
   m_ratio=lpXimage->MorphRatio;
   //sscanf(lpXimage->mParameters,"%s %ld",dummy,&version);
 }
 else{
   m_ratio=(double)(lpXimage->last_frame - lpXimage->first_frame);
   if(m_ratio < 1.0)m_ratio=1.0;
   else m_ratio=(double)(lpXimage->this_frame - lpXimage->first_frame)/m_ratio;
 }
 Zb=lpXimage->Zbuffer;
 S=lpXimage->Screen;
 Xmax=lpXimage->Xmax;
 Ymax=lpXimage->Ymax;
 Sx=lpXimage->Xscale;
 Sy=lpXimage->Yscale;
 for(k=0;k<lpXimage->Nlights;k++){
   Lp=(lpXimage->Lights+k);
   if(type == 2 && Lp->type != DUMMYL)continue;
   if(type == 3 && Lp->AnimatorID != id)continue;
   //SetShadowBuffer(325000.0,Lp,lpXimage);
   //SetShadowBuffer(200.0,Lp,lpXimage);
   if(Lp->type != SPOTLIGHT){ // non spots can only do if falloff
     if(Lp->dc){              // light fall off
       for(j=0;j<Ymax;j++){
         lpXimage->fp_Yield();
         if((lpXimage->fp_Terminate()) < 0)goto XXIT;
         for(i=0;i<Xmax;i++){
           d[2] = -((double)j + 0.5 - (double)Ymax/2.0)/Sy;
           d[0] =  ((double)i + 0.5 - (double)Xmax/2.0)/Sx;
           d[1] =  1.0;
           normalize(d);
           nc=GetSphereIntersection(d,Lp->p,1.0/Lp->dc_l,&dns,&dfs);
           if(nc > 1){  // inside sphere as well
             z = (double)(*(Zb + (j*Xmax)+i))/d[1];
             if(dns < z){
               s = (S+(j*Xmax)+i);
               colour[0]=ONE_256*(double)s->R;
               colour[1]=ONE_256*(double)s->G;
               colour[2]=ONE_256*(double)s->B;
               TraceSphericalVolume(Nsamples,d,Lp->p,dns,z,dfs,1.0,colour,Lp,lpXimage);
               s->R=(unsigned char)min(255L,(long)(256.0*colour[0]));
               s->G=(unsigned char)min(255L,(long)(256.0*colour[1]));
               s->B=(unsigned char)min(255L,(long)(256.0*colour[2]));
             }
           }
         }
       }
     }
   }
   else{  // spotlights only
     tan_theta1=tan(Lp->cone1-2.0*PI/180.0);
     tan_theta2=tan(Lp->cone2);
     cos_theta2=cos(Lp->cone2);
     tan_theta_sq=tan_theta2*tan_theta2;
     VECSCALE(-1.0,Lp->d,dl) // to point in direction of shine!
     VECCOPY(Lp->p,phat)
     normalize(phat);
     z=DOT(dl,phat);
     if(z > 0)bIlluminated=FALSE;
     else     bIlluminated=TRUE;
     if(fabs(z) > cos_theta2)bOriginInCone=TRUE;
     else                    bOriginInCone=FALSE;
     for(j=0;j<Ymax;j++){
       lpXimage->fp_Yield();
       if((lpXimage->fp_Terminate()) < 0)goto XXIT;
       for(i=0;i<Xmax;i++){
         d[2] = -((double)j + 0.5 - (double)Ymax/2.0)/Sy;
         d[0] =  ((double)i + 0.5 - (double)Xmax/2.0)/Sx;
         d[1] =  1.0;
         normalize(d);
         dmin=FARAWAY; dmax=0.0;
         nc=GetConeIntersection(d,Lp->p,dl,
                                tan_theta_sq,bOriginInCone,bIlluminated,
                                &dn,&df);
         if(nc > 0){
           if(dn < dmin)dmin=dn;
           if(df > dmax)dmax=df;
           if(dmax > FARAWAY-100.0)dmax=1.0e9;
           // since Z buffer is DEPTH not distance the "z" value must
           // be adjusted from depth to distance
           z = (double)(*(Zb + (j*Xmax)+i))/d[1];
           if(dmin < z){  // some light visible
             s = (S+(j*Xmax)+i);
             colour[0]=ONE_256*(double)s->R;
             colour[1]=ONE_256*(double)s->G;
             colour[2]=ONE_256*(double)s->B;
             if(fast == 1){  // aprox or full integration
               l=GetClosestPoint(d,Lp->p,dl,&mu,&lambda);
               SimpleTrace(fast_type,l,lambda,dmin,z,dmax,
                           tan_theta1,tan_theta2,
                           min(max_attn1,0.4),colour,Lp,lpXimage);  // max_attn1 0.4
             }
             else TracePixel(Nsamples,i,j,dmin,z,dmax,d,colour,Lp,lpXimage);
             s->R=(unsigned char)min(255L,(long)(256.0*colour[0]));
             s->G=(unsigned char)min(255L,(long)(256.0*colour[1]));
             s->B=(unsigned char)min(255L,(long)(256.0*colour[2]));
           }
         }
       }
     }
   }
 }
 XXIT:
 return 1;
}

long _RenderGLexternal(char *PrmList, XIMAGE *lpXimage){
 return 1;
}

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


static long type=1,id = -1,samp=16,fast=0,fast_type=0;
static unsigned char cR=255,cG=255,cB=255;
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 */
                                    ){
 /* output name and buffer should be as long as necessary to hold full string */
 char buffer[256];
 int icR,icG,icB;
 if(Op != NULL){  /* parameters exist so read them off the list */
   sscanf(Op,"%s %ld %ld %ld %ld %ld %ld %d %d %d %f %f %f",
          buffer,&version,&type,&id,
          &samp,&fast,&fast_type,&icR,&icG,&icB,
          &over_shadow,&over_density,&max_attn1);
   cR = (unsigned char)icR; 
   cG = (unsigned char)icG; 
   cB = (unsigned char)icB; 
 }
 lpLocalEVI=lpEVI;
 if(DialogBox(hDLLinstance,MAKEINTRESOURCE(DLG_ATMOS),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 %f %f %f",
         name,version,type,id,
         samp,fast,fast_type,cR,cG,cB,
         over_shadow,over_density,max_attn1);
 if((Op=(char *)CALL_MALLOC(strlen(buffer)+1)) == NULL){
   return NULL;
 }
 strcpy(Op,buffer);
 return Op;
}

static void SetColour(unsigned char *colour, HWND parent){
 CHOOSECOLOR cc;
 static COLORREF CustColours[16]={
   RGB(255,255,255), RGB(239,239,239), RGB(223,223,223), RGB(207,207,207),
   RGB(191,191,191), RGB(175,175,175), RGB(159,159,159), RGB(143,143,143),
   RGB(127,127,127), RGB(111,111,111), RGB( 95, 95, 95), RGB( 79, 79, 79),
   RGB( 63, 63, 63), RGB( 47, 47, 47), RGB( 31, 31, 31), RGB( 15, 15, 15) };
 cc.lStructSize=sizeof(CHOOSECOLOR);
 cc.hwndOwner=parent;
 cc.rgbResult=RGB((BYTE)colour[0],(BYTE)colour[1],(BYTE)colour[2]);
 cc.lpCustColors=(LPDWORD)CustColours;
 cc.Flags= CC_RGBINIT;
 cc.lCustData=(DWORD)0;
 if(ChooseColor(&cc)){
   colour[0]=(unsigned char)GetRValue(cc.rgbResult);
   colour[1]=(unsigned char)GetGValue(cc.rgbResult);
   colour[2]=(unsigned char)GetBValue(cc.rgbResult);
 }
}

static void LoadAnimatedClip(HWND hDlg){
 char *c,modname[256];
 GetModuleFileName(hDLLinstance,modname,255);
 if((c=strrchr(modname,'.')) != NULL){
   strcpy(c,".avi");
   Animate_Open(GetDlgItem(hDlg,DLG_IMAGE),modname);
   Animate_Play(GetDlgItem(hDlg,DLG_IMAGE),0, -1, -1);
 }
}

BOOL CALLBACK DlgProc(HWND hwnd,UINT msg,WPARAM wparam,LPARAM lparam){
 char str[32];
 switch( msg ) {
   case WM_INITDIALOG:
     sprintf(str,"%.3f",over_shadow);
     SetDlgItemText(hwnd,DLG_ATMOS_OVERSHADOW,str);
     sprintf(str,"%.3f",over_density);
     SetDlgItemText(hwnd,DLG_ATMOS_OVERDENSITY,str);
     sprintf(str,"%.3f",max_attn1);
     SetDlgItemText(hwnd,DLG_ATMOS_MAXATTN,str);
     sprintf(str,"%ld",samp);
     SetDlgItemText(hwnd,DLG_ATMOS_SAMPLES,str);

     if(fast == 1)SendDlgItemMessage(hwnd,DLG_ATMOS_FAST,BM_SETCHECK,TRUE,0);
     if(fast_type == 0)SendDlgItemMessage(hwnd,DLG_ATMOS_FAST1,BM_SETCHECK,TRUE,0);
     if(fast_type == 1)SendDlgItemMessage(hwnd,DLG_ATMOS_FAST2,BM_SETCHECK,TRUE,0);
     if(fast_type == 2)SendDlgItemMessage(hwnd,DLG_ATMOS_FAST3,BM_SETCHECK,TRUE,0);
     if(fast_type == 3)SendDlgItemMessage(hwnd,DLG_ATMOS_FAST4,BM_SETCHECK,TRUE,0);

     if(type == 1)SendDlgItemMessage(hwnd,DLG_ATMOS_TYPE1,BM_SETCHECK,TRUE,0);
     if(type == 2)SendDlgItemMessage(hwnd,DLG_ATMOS_TYPE2,BM_SETCHECK,TRUE,0);
     if(type == 3)SendDlgItemMessage(hwnd,DLG_ATMOS_TYPE3,BM_SETCHECK,TRUE,0);
     if(id >= 0)SendDlgItemMessage(hwnd,DLG_ATMOS_NAME,WM_SETTEXT,
                0,(LPARAM)GetActorsName(lpLocalEVI->lpAni,id));

 //    LoadAnimatedClip(hwnd);
     CentreDialogOnScreen(hwnd);
     return TRUE;
   case WM_PAINT:
     PaintBackground(hwnd);
     break;
   case WM_DRAWITEM:{
       LPDRAWITEMSTRUCT lpdis;
       HBRUSH   hbr,hbrold;
       BYTE r,g,b;
       lpdis=(LPDRAWITEMSTRUCT)lparam;
       if(lpdis->CtlID == DLG_ATMOS_COLOUR){
         r=cR; g=cG; b=cB;
         if(lpdis->itemState & ODS_SELECTED)
            InvertRect(lpdis->hDC,&(lpdis->rcItem));
         else{
           hbr=CreateSolidBrush(RGB(r,g,b));
           hbrold=SelectObject(lpdis->hDC,hbr);
           Rectangle(lpdis->hDC,lpdis->rcItem.left,lpdis->rcItem.top,
                         lpdis->rcItem.right,lpdis->rcItem.bottom);
           SelectObject(lpdis->hDC,hbrold);
           DeleteObject(hbr);
         }
       }
     }
     break;
   case WM_COMMAND:
     switch(LOWORD(wparam)){
        case DLG_ATMOS_COLOUR:{
            unsigned char colour[3];
            colour[0]=cR; colour[1]=cG; colour[2]=cB;
            SetColour(colour,hwnd);
            cR=colour[0]; cG=colour[1]; cB=colour[2];
            InvalidateRect(GetDlgItem(hwnd,DLG_ATMOS_COLOUR),NULL,FALSE);
          }
          break;
        case DLG_ATMOS_SETID:
          id=GetActorsID(lpLocalEVI->lpAni,hwnd);
          if(id >= 0)SendDlgItemMessage(hwnd,DLG_ATMOS_NAME,WM_SETTEXT,
                     0,(LPARAM)GetActorsName(lpLocalEVI->lpAni,id));
          break;
        case IDCANCEL:
          EndDialog(hwnd,FALSE);
          return(TRUE);
        case IDOK:
          if(GetDlgItemText(hwnd,DLG_ATMOS_OVERSHADOW,str,12) != 0)
            sscanf(str,"%f",&over_shadow);
          if(GetDlgItemText(hwnd,DLG_ATMOS_OVERDENSITY,str,12) != 0)
            sscanf(str,"%f",&over_density);
          if(GetDlgItemText(hwnd,DLG_ATMOS_MAXATTN,str,12) != 0)
            sscanf(str,"%f",&max_attn1);
          if(GetDlgItemText(hwnd,DLG_ATMOS_SAMPLES,str,12) != 0)
            sscanf(str,"%ld",&samp);

          if(SendDlgItemMessage(hwnd,DLG_ATMOS_FAST,BM_GETCHECK,0,0))fast=1;
          else                                                       fast=0;
          if(SendDlgItemMessage(hwnd,DLG_ATMOS_FAST1,BM_GETCHECK,0,0))fast_type=0;
          if(SendDlgItemMessage(hwnd,DLG_ATMOS_FAST2,BM_GETCHECK,0,0))fast_type=1;
          if(SendDlgItemMessage(hwnd,DLG_ATMOS_FAST3,BM_GETCHECK,0,0))fast_type=2;
          if(SendDlgItemMessage(hwnd,DLG_ATMOS_FAST4,BM_GETCHECK,0,0))fast_type=3;

          if(SendDlgItemMessage(hwnd,DLG_ATMOS_TYPE1,BM_GETCHECK,0,0))type=1;
          if(SendDlgItemMessage(hwnd,DLG_ATMOS_TYPE2,BM_GETCHECK,0,0))type=2;
          if(SendDlgItemMessage(hwnd,DLG_ATMOS_TYPE3,BM_GETCHECK,0,0))type=3;
          EndDialog(hwnd,TRUE);
          return(TRUE);
        default:
          break;
      }
      break;
    default: break;
 }
 return FALSE;
}

//static void TracePixel0(long Nsamples, long x, long y,
//                       double dmin, double z, double dmax,
//                       vector d, vector colour,
//                       light *Lp, XIMAGE *lpXimage){
// colour[0] += 0.25;
// colour[1] += 0.25;
// colour[2] += 0.25;
// return;
//}

//static BOOL RenderShadow(long Nsamples, long x, long y,
//                       double dmin, double z, double dmax,
//                       vector d, vector colour,
//                       light *Lp, XIMAGE *lpXimage){
// double zz;
// long SBS;
// SBS=lpXimage->shadow_buffer_size;
// if(x >= 0 && x < SBS && y >= 0 && y < SBS){
//   zz = *(Lp->atmospheric_shadow_buffer+y*SBS+x);
//   if(zz < FARAWAY-100.0){colour[0]=colour[1]=colour[2]=1.0;}
//   else                  {colour[0]=colour[1]=colour[2]=0.0;}
//   return TRUE;
// }
// return FALSE;
//}

//void SetShadowBuffer(double v, light *Lp, XIMAGE *lpXimage){
// double zz;
// long i,j,SBS,nd,dd,x0,y0;
// SBS=lpXimage->shadow_buffer_size;
// for(i=0;i<SBS;i++)for(j=0;j<SBS;j++){
//#if 1
//  *(Lp->atmospheric_shadow_buffer+i*SBS+j) = FARAWAY;  // for trellis
//#elif 0
//   if(i > SBS/4 && i < (SBS*3)/4 && j > SBS/4 && j < (SBS*3)/4){
//     *(Lp->atmospheric_shadow_buffer+i*SBS+j) = v;
//   }
//   else *(Lp->atmospheric_shadow_buffer+i*SBS+j) = FARAWAY;
//#else
//   if(*(Lp->atmospheric_shadow_buffer+i*SBS+j) < v)
//        *(Lp->atmospheric_shadow_buffer+i*SBS+j) = v;
//   else *(Lp->atmospheric_shadow_buffer+i*SBS+j) = FARAWAY;
//#endif
// }
//#if 1
// dd=4;             // trellis
// nd=SBS/(4*dd);
// y0=nd;
// for(i=0;i<dd;i++){
//   x0=nd;
//   for(j=0;j<dd;j++){
//     long ii,jj;
//     for(ii=y0;ii<y0+2*nd;ii++)for(jj=x0;jj<x0+2*nd;jj++){
//         *(Lp->atmospheric_shadow_buffer+ii*SBS+jj) = v;
//     }
//     x0 += 4*nd;
//   }
//   y0 += 4*nd;
// }
//#endif
// return;
//}

//         s = (S+(j*Xmax)+i);
//         if(RenderShadow(16,i,j,dmin,z,dmax,d,colour,Lp,lpXimage)){
//           s->R=(unsigned char)min(255L,(long)(256.0*colour[0]));
//           s->G=(unsigned char)min(255L,(long)(256.0*colour[1]));
//           s->B=(unsigned char)min(255L,(long)(256.0*colour[2]));
//         }