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

// lens1.c   - included in lens.c

static void  BlurBuffer(fullscreenbuffer *s, long Xmax, long Ymax){
  long i,j;
  double sum;
  for(i=0;i<Ymax-1;i++)for(j=0;j<Xmax-1;j++){
    sum  = (double)((s+i*Xmax+j)->R);
    sum += (double)((s+i*Xmax+j+1)->R);
    sum += (double)((s+(i+1)*Xmax+j)->R);
    sum += (double)((s+(i+1)*Xmax+j+1)->R);
    (s+i*Xmax+j)->R = (unsigned char)(sum*0.25);
    sum  = (double)((s+i*Xmax+j)->G);
    sum += (double)((s+i*Xmax+j+1)->G);
    sum += (double)((s+(i+1)*Xmax+j)->G);
    sum += (double)((s+(i+1)*Xmax+j+1)->G);
    (s+i*Xmax+j)->G = (unsigned char)(sum*0.25);
    sum  = (double)((s+i*Xmax+j)->B);
    sum += (double)((s+i*Xmax+j+1)->B);
    sum += (double)((s+(i+1)*Xmax+j)->B);
    sum += (double)((s+(i+1)*Xmax+j+1)->B);
    (s+i*Xmax+j)->B = (unsigned char)(sum*0.25);
  }
  return;
}

static void MixBuffer(fullscreenbuffer *s, fullscreenbuffer *t,
                      long Xmax, long Ymax){
 int r,g,b;
 long i,j;
 for(i=0;i<Ymax-1;i++)for(j=0;j<Xmax-1;j++){
   r=(int)t->R+(int)s->R;
   g=(int)t->G+(int)s->G;
   b=(int)t->B+(int)s->B;
   t->R=(r>255) ? 255:r;
   t->G=(g>255) ? 255:g;
   t->B=(b>255) ? 255:b;
   s++; t++;
 }
 return;
}

double DistFromHidingObject(int x, int y, double d,
                            double *Zb,
                            int border, int X, int Y){
 long i,j;
 double e,*Z,dmin,dr;
 dmin=(double)(X*10);
 for(i=x-border;i<=x+border;i++)for(j=y-border;j<=y+border;j++){
   if(i < 0 || i >= X || j < 0 || j >= Y)continue;
   e = *(Zb + (j * X) + i);
   if(e < d){
     dr=sqrt((double)(i-x)*(double)(i-x) + (double)(j-y)*(double)(j-y));
     if(dr < dmin)dmin=dr;
   }
 }
 return dmin;
}

double DistFromVisibleObject(int x, int y, double d,
                            double *Zb,
                            int border, int X, int Y){
 long i,j;
 double e,*Z,dmin,dr;
 dmin=(double)(X*10);
 for(i=x-border;i<=x+border;i++)for(j=y-border;j<=y+border;j++){
   if(i < 0 || i >= X || j < 0 || j >= Y)continue;
   e = *(Zb + (j * X) + i);
   if(e > d){
     dr=sqrt((double)(i-x)*(double)(i-x) + (double)(j-y)*(double)(j-y));
     if(dr < dmin)dmin=dr;
   }
 }
 return dmin;
}

double Grad(double x, double y1, double y2, int x1, int x2){
 double g;
 if(x <= x1)return y1;
 if(x >= x2)return y2;
 g=(y2-y1)/(double)(x2-x1);
 return y1+g*(x-(double)x1);
}

void DrawInBuffer(fullscreenbuffer *Screen, int Xmax, int Ymax,
                  int x, int y, unsigned char v,
                  double rr, double gg, double bb){
 int r,g,b;
 fullscreenbuffer *S;
 if(x < 0 || y < 0 || x >= Xmax || y >= Ymax)return;
 S=(Screen+y*Xmax+x);
 r=(int)S->R+(int)((double)v*rr);
 g=(int)S->G+(int)((double)v*gg);
 b=(int)S->B+(int)((double)v*bb);
 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, double C,
                 fullscreenbuffer *S, int X, int Y,
                 double r, double g, double b){
  int xa,xb,ya,yb,i,j,brite;
  double x2,y2,lfrac,rfrac,tfrac,bfrac,xfrac,yfrac;
  brite=(int)C;
  if(x < 0 || y < 0)return;
  x -= w*0.5; y -= h*0.5;
  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,r,g,b);
    }
    else {
      DrawInBuffer(S,X,Y,xa,ya,xfrac*tfrac*brite,r,g,b);
      for (j=ya+1; j<yb; j++) DrawInBuffer(S,X,Y,xa,j,xfrac*brite,r,g,b);
      DrawInBuffer(S,X,Y,xa,yb,xfrac*bfrac*brite,r,g,b);
    }
  }
  else {
    if (ya==yb) {
      yfrac = tfrac+bfrac-1.0;
      DrawInBuffer(S,X,Y,xa,ya,yfrac*lfrac*brite,r,g,b);
      for (i=xa+1; i<xb; i++) DrawInBuffer(S,X,Y,i,ya,yfrac*brite,r,g,b);
      DrawInBuffer(S,X,Y,xb,ya,yfrac*rfrac*brite,r,g,b);
    }
    else {
      DrawInBuffer(S,X,Y,xa,ya,tfrac*lfrac*brite,r,g,b);
      for (i=xa+1; i<xb; i++) DrawInBuffer(S,X,Y,i,ya,tfrac*brite,r,g,b);
      DrawInBuffer(S,X,Y,xb,ya,tfrac*rfrac*brite,r,g,b);
      for (j=ya+1; j<yb; j++) {
        DrawInBuffer(S,X,Y,xa,j,lfrac*brite,r,g,b);
        for (i=xa+1; i<xb; i++)DrawInBuffer(S,X,Y,i,j,brite,r,g,b);
        DrawInBuffer(S,X,Y,xb,j,rfrac*brite,r,g,b);
      }
      DrawInBuffer(S,X,Y,xa,yb,bfrac*lfrac*brite,r,g,b);
      for (i=xa+1; i<xb; i++) DrawInBuffer(S,X,Y,i,yb,bfrac*brite,r,g,b);
      DrawInBuffer(S,X,Y,xb,yb,bfrac*rfrac*brite,r,g,b);
    }
  }
}

#define DIST(i,j)  sqrt((double)i * (double)i + (double)j * (double)j)

static double GetW(double l, double dx, double dy,
                   double Wmin, double Wmax, double iScale,
                   BOOL linear){
 double d,f;
 d=DIST(dx,dy);
 f=d/l;
 if(linear){
   if(f < 0.5)return (Wmin+2.0*f*(Wmax-Wmin))*(double)iScale;
   return (Wmin+(Wmax-Wmin)*2.0*(1.0-f))*(double)iScale;
 }
 else{
   double y,dx,dw;
   dw=(Wmax-Wmin);
   if(f < 0.5)f=1.0-f;
   f = 2.0*(f-0.5);
   y=Wmax-dw*f*f*f;
   return y*(double)iScale;
 }
 return 0.0;
}

static double GetC(double l, double dx, double dy,
                   double Wmin, double Wmax, double iScale,
                   BOOL linear){
 double d,f;
 d=DIST(dx,dy);
 f=d/l;
 if(f < 0.5)return Wmax; //(Wmin+2.0*f*(Wmax-Wmin))*(double)iScale;
 return (Wmin+(Wmax-Wmin)*2.0*(1.0-f));
}

static void DrawFlareInBuffer(long x, long y, long idx, long idy,
                              fullscreenbuffer *Screen,
                              long X, long Y, double iScale,
                              double Cin,
                              double Wmin, double Wmax,
                              double z, float *Zb,
                              BOOL bDraw, BOOL linear){
 long i,j;
 double grad,error,W,l,C;
 if(iScale <1.1)Cin *= 2; Cin=min(255,Cin); C=Cin;
 if(idx == 0 && idy == 0)return;
 l=DIST(idx,idy);
 if(abs(idx) >= abs(idy)){
   grad=(double)idy/(double)idx; j=y;
   if(idy >= 0)error = -0.5; else error = 0.5;
   if(idx >= 0){
     for(i=x;i<x+idx;i++){
       error += grad;
       if(idy >= 0){
         if(error > 0.0){j++; error -= 1.0;}
       }
       else{
         if(error < 0.0){j--; error += 1.0;}
       }
       W=GetW(l,(double)(i-x),(double)(j-y),Wmin,Wmax,iScale,linear);
       if(!linear)C=GetC(l,(double)(i-x),(double)(j-y),Cin*0.25,Cin,1.0,TRUE);
       DrawAApixel((double)i,(double)j,W,W,C,Screen,X,Y,1,1,1);
     }
   }
   else{
     for(i=x;i>x+idx;i--){
       error -= grad;
       if(idy >= 0){
         if(error > 0.0){j++; error -= 1.0;}
       }
       else{
         if(error < 0.0){j--; error += 1.0;}
       }
       W=GetW(l,(double)(i-x),(double)(j-y),Wmin,Wmax,iScale,linear);
       if(!linear)C=GetC(l,(double)(i-x),(double)(j-y),Cin*0.25,Cin,1.0,TRUE);
       DrawAApixel((double)i,(double)j,W,W,C,Screen,X,Y,1,1,1);
     }
   }
 }
 else{
   grad=(double)idx/(double)idy; j=x;
   if(idx >= 0)error = -0.5; else error = 0.5;
   if(idy >= 0){
     for(i=y;i<y+idy;i++){
       error += grad;
       if(idx >= 0){
         if(error > 0.0){j++; error -= 1.0;}
       }
       else{
         if(error < 0.0){j--; error += 1.0;}
       }
       W=GetW(l,(double)(j-x),(double)(i-y),Wmin,Wmax,iScale,linear);
       if(!linear)C=GetC(l,(double)(j-x),(double)(i-y),Cin*0.25,Cin,1.0,TRUE);
       DrawAApixel((double)j,(double)i,W,W,C,Screen,X,Y,1,1,1);
     }
   }
   else{
     for(i=y;i>y+idy;i--){
       error -= grad;
       if(idx >= 0){
         if(error > 0.0){j++; error -= 1.0;}
       }
       else{
         if(error < 0.0){j--; error += 1.0;}
       }
       W=GetW(l,(double)(j-x),(double)(i-y),Wmin,Wmax,iScale,linear);
       if(!linear)C=GetC(l,(double)(j-x),(double)(i-y),Cin*0.25,Cin,1.0,TRUE);
       DrawAApixel((double)j,(double)i,W,W,C,Screen,X,Y,1,1,1);
     }
   }
 }
 return;
}

static double GetWL(double l, double dx, double dy,
                   double Wmin, double Wmax,
                   BOOL linear){
 double d,f;
 d=DIST(dx,dy);
 f=d/l;
 return (Wmax-(Wmax-Wmin)*f);
}


static void DrawFadedFlareInBuffer(long x, long y, long idx, long idy,
                              fullscreenbuffer *Screen,
                              long X, long Y,
                              double Cin,
                              double r, double g, double b,
                              double Wmin, double Wmax,
                              double z, float *Zb,
                              BOOL bDraw, BOOL linear){
 long i,j;
 double grad,error,W,l,C;
 C=Cin;
 l=DIST(idx,idy);
 if(abs(idx) >= abs(idy)){
   grad=(double)idy/(double)idx; j=y;
   if(idy >= 0)error = -0.5; else error = 0.5;
   if(idx >= 0){
     for(i=x;i<x+idx;i++){
       error += grad;
       if(idy >= 0){
         if(error > 0.0){j++; error -= 1.0;}
       }
       else{
         if(error < 0.0){j--; error += 1.0;}
       }
       W=GetWL(l,(double)(i-x),(double)(j-y),Wmin,Wmax,linear);
       DrawAApixel((double)i,(double)j,W,W,C,Screen,X,Y,r,g,b);
     }
   }
   else{
     for(i=x;i>x+idx;i--){
       error -= grad;
       if(idy >= 0){
         if(error > 0.0){j++; error -= 1.0;}
       }
       else{
         if(error < 0.0){j--; error += 1.0;}
       }
       W=GetWL(l,(double)(i-x),(double)(j-y),Wmin,Wmax,linear);
       DrawAApixel((double)i,(double)j,W,W,C,Screen,X,Y,r,g,b);
     }
   }
 }
 else{
   grad=(double)idx/(double)idy; j=x;
   if(idx >= 0)error = -0.5; else error = 0.5;
   if(idy >= 0){
     for(i=y;i<y+idy;i++){
       error += grad;
       if(idx >= 0){
         if(error > 0.0){j++; error -= 1.0;}
       }
       else{
         if(error < 0.0){j--; error += 1.0;}
       }
       W=GetWL(l,(double)(j-x),(double)(i-y),Wmin,Wmax,linear);
       DrawAApixel((double)j,(double)i,W,W,C,Screen,X,Y,r,g,b);
     }
   }
   else{
     for(i=y;i>y+idy;i--){
       error -= grad;
       if(idx >= 0){
         if(error > 0.0){j++; error -= 1.0;}
       }
       else{
         if(error < 0.0){j--; error += 1.0;}
       }
       W=GetWL(l,(double)(j-x),(double)(i-y),Wmin,Wmax,linear);
       DrawAApixel((double)j,(double)i,W,W,C,Screen,X,Y,r,g,b);
     }
   }
 }
 return;
}

static void DrawHaloInBuffer(long x, long y,
                             fullscreenbuffer *Screen,
                             long X, long Y, long radius,
                             double z, float *Zb,
                             BOOL bDraw,
                             double maxV,
                             double R, double G, double B){
 /* mix in a white halo at the screen buffer location of the light source */
 long i,j;
 double d;
 fullscreenbuffer *S;
 for(i=x-radius;i<=x+radius;i++)for(j=y-radius;j<=y+radius;j++){
   if(i < 0 || i >= X || j < 0 || j >= Y)continue;
   S=(Screen + j*X + i);
   d=sqrt((double)(i-x)*(double)(i-x) + (double)(j-y)*(double)(j-y));
   if(d < radius*0.25)d=maxV;
   else d=maxV*1.3333*((double)radius-d)/(double)radius;
   d=max(0.0,d);
   if(bDraw || Zb == NULL || z < *(Zb + j*X + i)){
     S->R = (unsigned char)min(255.0,(double)S->R+d*R);
     S->G = (unsigned char)min(255.0,(double)S->G+d*G);
     S->B = (unsigned char)min(255.0,(double)S->B+d*B);
   }
 }
 return;
}

static void DrawDiskInBuffer(long x, long y,
                             fullscreenbuffer *Screen,
                             long X, long Y, long radius,
                             double z, float *Zb,
                             BOOL bDraw,
                             double minV, double maxV,
                             double R, double G, double B){
 long i,j;
 double d;
 fullscreenbuffer *S;
 for(i=x-radius;i<=x+radius;i++)for(j=y-radius;j<=y+radius;j++){
   if(i < 0 || i >= X || j < 0 || j >= Y)continue;
   S=(Screen + j*X + i);
   d=sqrt((double)(i-x)*(double)(i-x) + (double)(j-y)*(double)(j-y));
   if(d < (double)radius){
     d=minV+(maxV-minV)*((double)radius-d)/(double)radius;
       S->R = (unsigned char)min(255.0,(double)S->R+d*R);
     S->G = (unsigned char)min(255.0,(double)S->G+d*G);
     S->B = (unsigned char)min(255.0,(double)S->B+d*B);
   }
 }
 return;
}

static void DrawDiskWithFade(long x, long y,
                             fullscreenbuffer *Screen,
                             long X, long Y,
                             long radius, long dradius,
                             double z, float *Zb,
                             BOOL bDraw,
                             double minV, double maxV,
                             double R, double G, double B){
 long i,j;
 double d,dr;
 fullscreenbuffer *S;
 for(i=x-dradius;i<=x+dradius;i++)for(j=y-dradius;j<=y+dradius;j++){
   if(i < 0 || i >= X || j < 0 || j >= Y)continue;
   if(bDraw || Zb == NULL || z < *(Zb + j*X + i)){
     S=(Screen + j*X + i);
     d=sqrt((double)(i-x)*(double)(i-x) + (double)(j-y)*(double)(j-y));
     if(d < (double)radius){
       d=minV+(maxV-minV)*((double)radius-d)/(double)radius;
       S->R = (unsigned char)min(255.0,(double)S->R+d*R);
       S->G = (unsigned char)min(255.0,(double)S->G+d*G);
       S->B = (unsigned char)min(255.0,(double)S->B+d*B);
     }
     else if(d < (double)dradius){
       d -= (double)radius; dr = (double)(dradius-radius);
       d=minV*(dr-d)/dr;
       S->R = (unsigned char)min(255.0,(double)S->R+d*R);
       S->G = (unsigned char)min(255.0,(double)S->G+d*G);
       S->B = (unsigned char)min(255.0,(double)S->B+d*B);
     }
   }
 }
 return;
}

static void DrawCircleInBuffer(long x, long y,
                             fullscreenbuffer *Screen,
                             long X, long Y,
                             long iradius, long oradius,
                             double minV, double maxV,
                             double R, double G, double B){
 long i,j;
 double d,dc;
 fullscreenbuffer *S;
 dc=0.5*(double)(iradius+oradius);
 for(i=x-oradius;i<=x+oradius;i++)for(j=y-oradius;j<=y+oradius;j++){
   if(i < 0 || i >= X || j < 0 || j >= Y)continue;
   S=(Screen + j*X + i);
   d=sqrt((double)(i-x)*(double)(i-x) + (double)(j-y)*(double)(j-y));
   if(d >= (double)iradius && d <= (double)oradius){
     if(d > dc){
       d=maxV-(maxV-minV)*(d-dc)/((double)oradius-dc);
     }
     else{
       d=minV+(maxV-minV)*(d-(double)iradius)/(dc-(double)iradius);
     }
     S->R = (unsigned char)min(255.0,(double)S->R+d*R);
     S->G = (unsigned char)min(255.0,(double)S->G+d*G);
     S->B = (unsigned char)min(255.0,(double)S->B+d*B);
   }
 }
 return;
}

long _RenderImageProcess(char *PrmList, XIMAGE *lpXimage){
 int i,j,Nl,li,n=45;
 char dummy[255];
 double x,y,z,radius,angle,atnd,atnc,atnr,atn,atnV=1.0;
 long v,model,type,flicker,hide,sx,sy,ipx,ipy,ipz,id;
 long xx,yy,Xmax,Ymax,Xc,Yc,oborder=2,border=5,dborder=8;
 long xBlue,yBlue,xBrown,yBrown,xGreen,yGreen,xT,yT;
 double bscale,rscale,iScale,ascale,lscale,dlscale,d2r,lc,dx,dy;
 double cr=1.0,cg=1.0,cb=1.0;
 float *Zb;
 BOOL  bDraw=TRUE;
#include "pro_key.c"
//debug=fopen("d:debug.evi","w");
//MessageBox(NULL,PrmList,NULL,MB_OK);
 sscanf(PrmList,"%s %ld %ld %ld %ld %ld %ld %ld %ld %ld %ld %f %f %ld %lf",
        dummy,&type,&flicker,&hide,&sx,&sy,&ipx,&ipy,&ipz,&model,&v,
        &bscale,&rscale,&id,&angle);
 if(type == 1 && (lpXimage->Nlights == 0 || lpXimage->Lights == NULL))return 1;
 if(lpXimage->Morph){
   double mr=lpXimage->MorphRatio;
   long q_v,q_model,q_type,q_flicker,q_hide,q_sx,q_sy,q_ipx,q_ipy,q_ipz,q_id;
   double q_bscale,q_rscale;
   sscanf(lpXimage->mParameters,
        "%s %ld %ld %ld %ld %ld %ld %ld %ld %ld %ld %f %f %ld",
        dummy,&q_type,&q_flicker,&q_hide,&q_sx,&q_sy,&q_ipx,&q_ipy,&q_ipz,
        &q_model,&q_v,
        &q_bscale,&q_rscale,&q_id);
   bscale=q_bscale+mr*(bscale-q_bscale);
   rscale=q_rscale+mr*(rscale-q_rscale);
 }
 Xmax=lpXimage->Xmax;  Ymax=lpXimage->Ymax;
 Xc=Xmax/2; Yc=Ymax/2;
 iScale=rscale*(double)Xmax/320;
 atnV *= bscale;
 ascale=5.0/32767.0;
 lscale=80.0*(double)iScale;
 dlscale=80.0/32767.0*(double)iScale;
 d2r=3.1415626/180.0;
 border  *= iScale;
 oborder *= iScale;
 dborder *= iScale;
 Zb=lpXimage->Zbuffer;
 if(flicker)srand(lpXimage->Frame);
 else       srand(1);
 if(type == 1 || type == 4 || type == 5)Nl=lpXimage->Nlights;
 else Nl=1;
 for(li=0;li<Nl;li++){
   if(type == 4 && lpXimage->Lights[li].type != DUMMYL)continue;
   if(type == 5 && lpXimage->Lights[li].AnimatorID != id)continue;
   if(type == 1 || type == 4 || type == 5){
     x=lpXimage->Lights[li].p[0];
     y=lpXimage->Lights[li].p[1];
     z=lpXimage->Lights[li].p[2];
     cr=(double)(lpXimage->Lights[li].color[0])/255.0;
     cg=(double)(lpXimage->Lights[li].color[1])/255.0;
     cb=(double)(lpXimage->Lights[li].color[2])/255.0;
   }
   else if(type == 2){
     TransformIntoView(lpXimage->ViewTransform,
                       (double)ipx,(double)ipy,(double)ipz,
                       &x,&y,&z);
   }
   else if(type == 3){
     hide=0; y=1.1;
   }
   if(y >= 1.000){
     if(type == 3){
       xx=sx; yy=sy;
     }
     else{
       xx=Xc + (long)(lpXimage->Xscale*x/y);
       yy=Yc - (long)(lpXimage->Yscale*z/y);
     }
     if(xx >= -border && xx < Xmax+border &&
        yy >= -border && yy < Ymax+border){
       dx=(double)(xx-Xc);  dy=(double)(yy-Yc);
       lc=DIST(dx,dy);  dx /= lc; dy /= lc;
       atnc=atnV; atn=atnV;
       if(xx < border && yy < border){
         if(xx < yy){
           atn  = Grad((double)xx,0.0,atnV,0,border);
           atnc = Grad((double)xx,0.0,atnV,-border,border);
         }
         else{
           atn  = Grad((double)yy,0.0,atnV,0,border);
           atnc = Grad((double)yy,0.0,atnV,-border,border);
         }
       }
       else if(xx > Xmax-border && yy > Ymax-border){
         if(xx-Xmax > yy-Ymax){
           atn  = Grad((double)xx,atnV,0.0,Xmax-border,Xmax);
           atnc = Grad((double)xx,atnV,0.0,Xmax-border,Xmax+border);
         }
         else{
           atn  = Grad((double)yy,atnV,0.0,Ymax-border,Ymax);
           atnc = Grad((double)yy,atnV,0.0,Ymax-border,Ymax+border);
         }
       }
       else if(xx < border && yy > Ymax-border){
         if(border-xx > yy-(Ymax-border)){
           atn  = Grad((double)xx,0.0,atnV,0,border);
           atnc = Grad((double)xx,0.0,atnV,-border,border);
         }
         else{
           atn  = Grad((double)yy,atnV,0.0,Ymax-border,Ymax);
           atnc = Grad((double)yy,atnV,0.0,Ymax-border,Ymax+border);
         }
       }
       else if(xx > Xmax-border && yy < border){
         if(border-yy > xx-(Xmax-border)){
           atn  = Grad((double)yy,0.0,atnV,0,border);
           atnc = Grad((double)yy,0.0,atnV,-border,border);
         }
         else{
           atn  = Grad((double)xx,atnV,0.0,Xmax-border,Xmax);
           atnc = Grad((double)xx,atnV,0.0,Xmax-border,Xmax+border);
         }
       }
       else if(xx < border){
         atn  = Grad((double)xx,0.0,atnV,0,border);
         atnc = Grad((double)xx,0.0,atnV,-border,border);
       }
       else if(yy < border){
         atn  = Grad((double)yy,0.0,atnV,0,border);
         atnc = Grad((double)yy,0.0,atnV,-border,border);
       }
       else if(xx > Xmax-border){
         atn  = Grad((double)xx,atnV,0.0,Xmax-border,Xmax);
         atnc = Grad((double)xx,atnV,0.0,Xmax-border,Xmax+border);
       }
       else if(yy > Ymax-border){
         atn  = Grad((double)yy,atnV,0.0,Ymax-border,Ymax);
         atnc = Grad((double)yy,atnV,0.0,Ymax-border,Ymax+border);
       }
       atnd=atnV; atnr=1.0;
       if(hide && Zb != NULL && xx >= 0 && yy >= 0 && xx < Xmax && yy < Ymax){
         double dd;
         if(y < *(Zb + (yy * Xmax) + xx)){  // visible
           dd=DistFromHidingObject(xx,yy,y,Zb,border,Xmax,Ymax);
           if(dd < border){
             atn  = Grad(dd,atnV*0.2,atnV,0,border);
             atnc = Grad(dd,atnV*0.5,atnV,0,border);
           }
         }
         if(y > *(Zb + (yy * Xmax) + xx)){  // hidden
           dd=DistFromVisibleObject(xx,yy,y,Zb,dborder,Xmax,Ymax);
           if(dd < oborder){
             atn  = Grad(dd,atnV*0.2,0.0,0,oborder);
             atnc = Grad(dd,atnV*0.5,0.0,0,oborder);
           }
           else if(dd < dborder){
             atn=0.0; atnc=0.0;
             atnr = Grad(dd,1.0,0.0,0,dborder);
           }
           else continue;
         }
       }
       if(model < 3){  /* draw inter-lens reflections */
       DrawDiskInBuffer(Xc+(long)(1.8*lc*dx),Yc+(long)(1.8*lc*dy), // big brown
                        lpXimage->Screen,Xmax,Ymax,
                        (long)(120*iScale),
                        y,Zb,bDraw,20.0*atn,30.0*atn,
                        1.0,0.1,0.05);
       DrawCircleInBuffer(Xc+(long)(1.3*lc*dx),Yc+(long)(1.3*lc*dy),
                        lpXimage->Screen,Xmax,Ymax,            // yellow disk
                        (long)(10*iScale),(long)(13*iScale),
                        0.0*atn,30.0*atn,
                        1.0,1.0,0.2);
       DrawDiskInBuffer(Xc+(long)(1.3*lc*dx),Yc+(long)(1.3*lc*dy),
                        lpXimage->Screen,Xmax,Ymax,            // centre of yellow disk
                        (long)(15*iScale),
                        y,Zb,bDraw,
                        10.0*atn,20.0*atn,
                        1.0,1.0,0.2);

       xBlue=Xc+(long)(0.5*lc*dx); yBlue=Yc+(long)(0.5*lc*dy);
       DrawDiskWithFade(xBlue,yBlue, // blue overlapping
                        lpXimage->Screen,Xmax,Ymax,
                        (long)(20*iScale),(long)(25*iScale),
                        y,Zb,bDraw,
                        40.0*atn,60.0*atn,
                        0.0,0.0,1.0);
       DrawDiskWithFade(xBlue+(long)(8*iScale*dx),yBlue+(long)(8*iScale*dy),
                        lpXimage->Screen,Xmax,Ymax,
                        (long)(6*iScale),(long)(8*iScale),
                        y,Zb,bDraw,
                        40.0*atn,44.0*atn,
                        0.0,0.0,1.0);
       DrawDiskWithFade(xBlue-(long)(6*iScale*dx),yBlue-(long)(6*iScale*dy),
                        lpXimage->Screen,Xmax,Ymax,
                        (long)(9*iScale),(long)(11*iScale),
                        y,Zb,bDraw,
                        40.0*atn,44.0*atn,
                        0.0,0.0,1.0);

       xBrown=Xc-(long)(0.5*lc*dx); yBrown=Yc-(long)(0.5*lc*dy);
       DrawDiskWithFade(xBrown,yBrown, // brown overlapping
                        lpXimage->Screen,Xmax,Ymax,
                        (long)(18*iScale),(long)(21*iScale),
                        y,Zb,bDraw,
                        40.0*atn,44.0*atn,
                        1.0,0.1,0.2);
       DrawDiskWithFade(xBrown-(long)(8*iScale*dx),yBrown-(long)(8*iScale*dy),
                        lpXimage->Screen,Xmax,Ymax,
                        (long)(5*iScale),(long)(7*iScale),
                        y,Zb,bDraw,
                        40.0*atn,44.0*atn,
                        1.0,0.1,0.2);
       DrawDiskWithFade(xBrown+(long)(6*iScale*dx),yBrown+(long)(6*iScale*dy),
                        lpXimage->Screen,Xmax,Ymax,
                        (long)(10*iScale),(long)(12*iScale),
                        y,Zb,bDraw,40.0*atn,44.0*atn,
                        1.0,0.1,0.2);

       xBrown=Xc+(long)(0.35*lc*dx); yBrown=Yc+(long)(0.35*lc*dy);
       DrawDiskInBuffer(xBrown,yBrown, // single brown
                        lpXimage->Screen,Xmax,Ymax,
                        (long)(5*iScale),
                        y,Zb,bDraw,
                        40.0*atn,44.0*atn,
                        1.0,0.1,0.2);

       xT=Xc-(long)(0.8*lc*dx); yT=Yc-(long)(0.8*lc*dy);
       DrawHaloInBuffer(xT,yT,lpXimage->Screen,Xmax,Ymax,
                        (long)(10*iScale),
                        y,Zb,bDraw,
                        160.0*atn,
                        0.2,0.2,1.0);  // blue halo
       DrawHaloInBuffer(xT-(long)(2*iScale*dx),yT-(long)(2*iScale*dy),
                        lpXimage->Screen, // white bit
                        Xmax,Ymax,
                        (long)(2*iScale),
                        y,Zb,bDraw,
                        64.0*atn,
                        1.0,1.0,1.0);
       DrawDiskWithFade(xT+(long)(8*iScale*dx),yT+(long)(8*iScale*dy),
                        lpXimage->Screen,Xmax,Ymax,
                        (long)(11*iScale),(long)(13*iScale), // green bit
                        y,Zb,bDraw,
                        40.0*atn,44.0*atn,
                        0.5,0.8,0.2);

       xGreen=Xc-(long)(0.8*lc*dx); yGreen=Yc-(long)(0.8*lc*dy);
       DrawDiskInBuffer(xGreen,yGreen, // green disk
                        lpXimage->Screen,Xmax,Ymax,
                        (long)(30*iScale),
                        y,Zb,bDraw,
                        20.0*atn,44.0*atn,
                        0.4,0.5,0.2);
       DrawCircleInBuffer(xGreen,yGreen,
                        lpXimage->Screen,Xmax,Ymax,    // green outline
                        (long)(28*iScale),(long)(30*iScale),
                        0.0*atn,30.0*atn,
                        1.0,1.0,0.2);

       xT=Xc-(long)(1.2*lc*dx); yT=Yc-(long)(1.2*lc*dy); // opposite rainbow
       DrawCircleInBuffer(xT,yT,
                        lpXimage->Screen,Xmax,Ymax,
                        (long)(60*iScale),(long)(62*iScale),
                        10.0*atn,30.0*atn,
                        1.0,0.2,0.2);
       DrawCircleInBuffer(xT,yT,
                        lpXimage->Screen,Xmax,Ymax,
                        (long)(58*iScale),(long)(61*iScale),
                        30.0*atn,30.0*atn,
                        0.2,1.0,0.2);
       DrawCircleInBuffer(xT,yT,
                        lpXimage->Screen,Xmax,Ymax,
                        (long)(56*iScale),(long)(59*iScale),
                        10.0*atn,30.0*atn,
                        0.2,0.2,1.0);

       DrawAApixel(Xmax/2,Ymax/2,1.0*iScale,1.0*iScale,   // bright screen centre
                   255.0*atn,
                   lpXimage->Screen,Xmax,Ymax,
                   1,1,1);
       xT=Xc-(long)(0.35*lc*dx); yT=Yc-(long)(0.35*lc*dy);
       DrawHaloInBuffer(xT,yT,lpXimage->Screen,           // bright offcentre
                        Xmax,Ymax,
                        (long)(3*iScale),
                        y,Zb,bDraw,
                        255.0*atn,
                        0.8,0.8,1.0);
       } /* end inter-lens reflections */
       if(model == 1){
         DrawHaloInBuffer(xx,yy,lpXimage->Screen,Xmax,Ymax, // light halo
                          (long)(3*iScale),
                          y,Zb,bDraw,
                          255.0*atnc,
                          1.0,1.0,1.0);
         DrawHaloInBuffer(xx,yy,lpXimage->Screen,Xmax,Ymax, // light halo red disk
                          (long)(20*iScale),
                          y,Zb,bDraw,
                          80.0*atn,
                          1.0,0.5,0.2);
         DrawCircleInBuffer(xx,yy,
                          lpXimage->Screen,Xmax,Ymax,       // light halo outer ring
                          (long)(20*iScale),(long)(23*iScale),
                          50.0*atn,80.0*atn,
                          1.0,0.5,0.0);
         for(j=0;j<n;j++){  /* outlying spines */
           double a,l;
           long   idx,idy;
           a=360.0/(double)n*(double)j+ascale*(double)rand();
           a *= d2r;
           l=lscale+dlscale*(double)rand();
           l *= atn;
           idx=(long)(l*cos(a)); idy=(long)(l*sin(a));
           DrawFlareInBuffer(xx,yy,idx,idy,lpXimage->Screen,Xmax,Ymax,
                             iScale/rscale, /* don't scale size */
                             20.0*atn, // brightness 0-255
                             0.2,0.8,  // min width max width
                             y,Zb,bDraw,TRUE);
         }
         for(i=0;i<3;i++)for(j=0;j<n;j++){ /* centre spines */
           double a,l,C;
           long   idx,idy;
           a=360.0/(double)n*(double)j+ascale*(double)rand();
           a *= d2r;
           l=lscale+dlscale*(double)rand();
           if     (i == 0){l /= 5; l *= atnc; C=32.0*atn;}
           else if(i == 1){l /= 10; C=64.0*atn;}
           else if(i == 2){l /= 20; C=128.0*atnc;}
           idx=(long)(l*cos(a)); idy=(long)(l*sin(a));
           DrawFlareInBuffer(xx,yy,idx,idy,lpXimage->Screen,Xmax,Ymax,
                             iScale,
                             C,
                             0.2,0.8,
                             y,Zb,bDraw,TRUE);
         }
       }
       else if(model == 2 || model == 3){ /* model2/3 */
         DrawHaloInBuffer(xx,yy,lpXimage->Screen,Xmax,Ymax, // light halo
                          (long)(20*iScale),
                          y,Zb,bDraw,
                          255.0*atnc,
                          1.0,1.0,1.0);
         DrawHaloInBuffer(xx,yy,lpXimage->Screen,Xmax,Ymax, // light halo red disk
                          (long)(30*iScale),
                          y,Zb,bDraw,
                          80.0*atnc,
                          1.0,0.5,0.2);
         DrawCircleInBuffer(xx,yy,
                          lpXimage->Screen,Xmax,Ymax,       // light halo outer ring
                          (long)(150*iScale),(long)(160*iScale),
                          50.0*atn,80.0*atn,
                          1.0,0.5,0.0);
         if(model == 2)DrawDiskWithFade(xx,yy,
                         lpXimage->Screen,Xmax,Ymax,        // big obscured disk
                          (long)(27*iScale)*atnr,
                          (long)(40*iScale)*atnr,
                          y,Zb,(BOOL)(!hide),
                          100.0*atnd,100.0*atnd,
                          1.0,1.0,1.0);
         if(model == 2)for(j=0;j<10;j++){  /* spines */
           double a,l,ddx,ddy;
           long   xs,ys,idx,idy;
           a= -90.0 + 360.0/(double)10*(double)j;
           a *= d2r;
           l=lscale*1.5;
           l *= atn/bscale;  /* don't scale for brightness */
           ddx=l*cos(a); ddy=l*sin(a);
           idx=(long)ddx; idy=(long)ddy;
           xs=xx+(long)(ddx*0.09); ys=yy+(long)(ddy*0.09);
           DrawFlareInBuffer(xs,ys,idx,idy,lpXimage->Screen,Xmax,Ymax,
                             iScale/rscale, /* don't scale size */
                             40.0*atnc/bscale, // brightness 0-255
                             0.0,1.4*atnc/bscale,  // min width max width
                             y,Zb,bDraw,FALSE);
           DrawFlareInBuffer(xs,ys,idx,idy,lpXimage->Screen,Xmax,Ymax,
                             iScale/rscale, /* don't scale size */
                             20.0*atnc/bscale, // brightness 0-255
                             0.0,2.8*atnc/bscale,  // min width max width
                             y,Zb,bDraw,FALSE);
           xs=xx+(long)(ddx*0.2); ys=yy+(long)(ddy*0.2);
           DrawFlareInBuffer(xs,ys,idx,idy,lpXimage->Screen,Xmax,Ymax,
                             iScale/rscale, /* don't scale size */
                             10.0*atnc/bscale, // brightness 0-255
                             0.0,4.5*atnc/bscale,  // min width max width
                             y,Zb,bDraw,FALSE);
         }
       }
       else { /* model=4 */
         fullscreenbuffer *Screen;
         if((Screen=(fullscreenbuffer *)X__Malloc(Xmax*Ymax*
             (long)sizeof(fullscreenbuffer))) != NULL){
           memset(Screen,0,Xmax*Ymax*sizeof(fullscreenbuffer));
           for(j=0;j<8;j++){  /* outer */
             double a,l;
             long   idx,idy;
             a=360.0/(double)8*(double)j+22.5;
             a *= d2r;
             l=lscale;
             l *= atn;
             idx=(long)(l*cos(a)); idy=(long)(l*sin(a));
             DrawFadedFlareInBuffer(xx,yy,idx,idy,
                             Screen,
                             Xmax,Ymax,
                             8.0*atn, // brightness 0-255
                             cr,cg,cb, // colour
                             4.0*iScale/2,4.5*iScale/2,  // min width max width
                             y,Zb,
                             bDraw,TRUE);
             DrawFadedFlareInBuffer(xx,yy,idx,idy,
                             Screen,
                             Xmax,Ymax,
                             16.0*atn, // brightness 0-255
                             cr,cg,cb, // colour
                             1.0*iScale/2,3.0*iScale/2,  // min width max width
                             y,Zb,
                             bDraw,TRUE);
             DrawFadedFlareInBuffer(xx,yy,idx,idy,
                             Screen,
                             Xmax,Ymax,
                             80.0*atn, // brightness 0-255
                             1.0,1.0,1.0, // colour
                             0.0,2.0*iScale/2,  // min width max width
                             y,Zb,
                             bDraw,TRUE);
             idx /= 2; idy /=2;
             DrawFadedFlareInBuffer(xx,yy,idx,idy,
                             Screen,
                             Xmax,Ymax,
                             16.0*atn, // brightness 0-255
                             cr,cg,cb, // colour
                             0.0,2.0*iScale/2,  // min width max width
                             y,Zb,
                             bDraw,TRUE);
           }
           for(j=0;j<8;j++){  /* inner */
             double a,l;
             long   idx,idy;
             a=360.0/(double)8*(double)j;
             a *= d2r;
             l=lscale/2;
             l *= atn;
             idx=(long)(l*cos(a)); idy=(long)(l*sin(a));
             DrawFadedFlareInBuffer(xx,yy,idx,idy,
                             Screen,
                             Xmax,Ymax,
                             64.0*atn, // brightness 0-255
                             cr,cg,cb, // colour
                             0.8*iScale/2,1.5*iScale/2,  // min width max width
                             y,Zb,bDraw,TRUE);
           }
           n=36;
           for(j=0;j<n;j++){  /* jitter */
             double a,l;
             long   idx,idy;
             a=360.0/(double)n*(double)j+ascale*(double)rand();
             a *= d2r;
             l=(lscale+dlscale*(double)rand())/30;
             l *= atn;
             idx=(long)(l*cos(a)); idy=(long)(l*sin(a));
             DrawFadedFlareInBuffer(xx,yy,idx,idy,
                             Screen,
                             Xmax,Ymax,
                             255.0*atn, // brightness 0-255
                             1.0,1.0,1.0, // colour
                             0.8*iScale/2,1.2*iScale/2,  // min width max width
                             y,Zb,bDraw,TRUE);
           }
           DrawDiskWithFade(xx,yy,Screen,Xmax,Ymax, // light halo
                          (long)(5*iScale), (long)(20*iScale),
                          y,Zb,bDraw,
                          128.0*atnc/bscale,255.0*atnc/bscale,
                          cr,cg,cb);
           if(Xmax > 320)BlurBuffer(Screen,Xmax,Ymax);
           MixBuffer(Screen,lpXimage->Screen,Xmax,Ymax);
           X__Free(Screen);
         }
       }
     }
   }
 }
//fclose(debug);
 return 1;
}