RENDER.C

Go to the documentation of this file.

// File render.c

#define MODULE_RENDER

#include "render.h"

extern HWND hWndOpenGL;
extern short mirror_ground;
extern init_structures(void);
extern HINSTANCE hThisInstance;
extern void SetLightShadow(long i);
extern void Free_Mirror_On_Ground(void);
extern void Free_Lights_Shadows(void);
extern void Mirror_In_Ground(void);

static int TransformSceneForRendering(long *, long, long);
static short TransformObjectIntoPosition(long O);
static void CalculateFaceNormals(vertex *v, face *f, long O);
static int PsameSide(vector pt, vector p, vector n);
static CalculateObjectScreenCoordinates(long O);

BOOL bKeepObjectsInRAM=TRUE;  
FILE *CF=NULL;
long renderer_NT_abort_flag=0;
short End_of_animation;

static char ambient_flag=0,outputfile[256];

char *short_form(char *filename){ 
 char *sps,*spc;
 sps=spc=filename;
 while((spc=strchr(spc,'\\')) != NULL){spc++; sps=spc;}
 return sps;
}

short R_terminator(void){    
 char c;
 if(renderer_NT_abort_flag && ConfirmNTabort())return FAIL;
 renderer_NT_abort_flag=0;
 return NO;
}

int render(int argc, char **argv){
 char  scriptfile[512];
 char  outputroot[512];
 char  c,temp_str[256],format[128],temp_message[128];
 long  i,j,frame,subframe,command_id,firstframe,lastframe,
       failure=NO,x_xmax,y_ymax,nAnimStart,version,
       ApplyPPtoGL=NO;
 short flash_count,truevision=0,targa_compress=1;
 fullscreenbuffer *stereo_buffer=NULL;
 long StereoPosition;
 BOOL StereoFrame;
 //
 X_message=X__local_print;
 WindowedRenderInfo("Scene:");
 renderer_silent=0;/* if printing output, vector printf() function */
 firstframe=1; lastframe=65536;
 anti_alias=NONE; anti_alias_edges=NO;
 remove_hidden_faces=NO;
 instant_callback=NO; shadow_buffer_size=300;
 //FAST=NO; 
 OUTPUT_FILE_TYPE=B24_FILE; XMAX=320; YMAX=200;
 ColourResolution=BITS8; End_of_animation=0; colour0_flag=0;
 FullScreenBuffer=NULL; fszBuffer=NULL;
 objectIDbufferON=YES; ObjectIdBuffer=NULL;
 alfachannelON=NO; alfagroundON=NO;
 StereoRenderingON=NO;
 ntsc_colours=NO; full_mirror=FALSE;
 MotionBlurBuffer=NULL; mblurON=0; jpeg_quality=75;
 trace_shadows=NO; trace_reflections=NO; trace_refractions=NO;
 trace_partition=1; trace_depth=8;
 trace_face_count_target=25; trace_voxel_min_size=4;
 ClipXmin=ClipYmin=ClipZmin=0;       //BIGN;  // For scripts without scene bounds defined in scripts
 ClipXmax=ClipYmax=ClipZmax=UNIT*20; //BIGP;  // some apprximations for the Designer renderer
 tzeros=4;
 if(argc < 3){
  Render_Message(40,0,NULL);
  goto EXITPOINT;
 }
 else if(argc > 3){
   i=3;
   while(i < argc){
     if(strcmp(argv[i],"-an2" ) == 0){  // animation - high colour def
       ColourResolution=BITS24; OUTPUT_FILE_TYPE=AVI_FILE;
     }
     else if(strcmp(argv[i],"-t24") == 0){
       ColourResolution=BITS24; OUTPUT_FILE_TYPE=TIF_FILE;
     }
     else if(strcmp(argv[i],"-b24") == 0){
       ColourResolution=BITS24; OUTPUT_FILE_TYPE=B24_FILE;
     }
     else if(strcmp(argv[i],"-p24") == 0){
       ColourResolution=BITS24; OUTPUT_FILE_TYPE=PNG_FILE;
     }
     else if(strcmp(argv[i],"-j24") == 0){
       ColourResolution=BITS24; OUTPUT_FILE_TYPE=J24_FILE;
       i++; jpeg_quality = atol(argv[i]);
     }
     else if(strcmp(argv[i],"-cbk") == 0){
       instant_callback=YES;  // show image while rendering 
     }
     else if(strcmp(argv[i],"-h"   ) == 0){ApplyPPtoGL=YES;}
     else if(strcmp(argv[i],"-x"   ) == 0){i++; XMAX=atoi(argv[i]); }
     else if(strcmp(argv[i],"-y"   ) == 0){i++; YMAX=atoi(argv[i]); }
     //else if(strcmp(argv[i],"-f"   ) == 0)FAST=YES;
     else if(strcmp(argv[i],"-ff"  ) == 0){i++; firstframe=atoi(argv[i]); }
     else if(strcmp(argv[i],"-lf"  ) == 0){i++; lastframe=atoi(argv[i]);  }
     else if(strcmp(argv[i],"-ae"  ) == 0)anti_alias_edges=YES;
     else if(strcmp(argv[i],"-a"   ) == 0)anti_alias=LOW;
     else if(strcmp(argv[i],"-aa"  ) == 0)anti_alias=MEDIUM;
     else if(strcmp(argv[i],"-aaa" ) == 0)anti_alias=HIGH;
     else if(strcmp(argv[i],"-aaaa") == 0)anti_alias=ULTRA;
     else if(strcmp(argv[i],"-sto" ) == 0)StereoRenderingON=YES;
     else if(strcmp(argv[i],"-z"   ) == 0){;} // No dithering 
     else if(strcmp(argv[i],"-zz"  ) == 0){ // NO dithering 
       i++;
     }
     else if(strcmp(argv[i],"-w"   ) == 0){ // not used now
       i++;
     }
     else if(strcmp(argv[i],"-ac"  ) == 0){ // not used now (but alpha is used in PNG files!)
       alfachannelON=YES;
     }
     else if(strcmp(argv[i],"-acg" ) == 0){ // not used now
       alfagroundON=YES;
     }
     //else if(strcmp(argv[i],"-zb"  ) == 0){;} // always ON
     else if(strcmp(argv[i],"-al"  ) == 0){
       i++; ambient_light= ((double)atof(argv[i]))/100.0; /* % light */
       ambient_flag=1; /* override script ambients */
     }
     else if(strcmp(argv[i],"-sd"  ) == 0){
       i++; shadow_density = 1.0-((double)atof(argv[i])/100.0); /* %age */
       glass_shadow_density = 1.0-0.5*((double)atof(argv[i])/100.0);
     }
     else if(strcmp(argv[i],"-sc"  ) == 0){
       i++; smoothing_angle = cos((double)atof(argv[i])*PI/180.0); /* cos angle */
     }
     else if(strcmp(argv[i],"-c0"  ) == 0){ // not used now
       i++;             /* colour zero option */
       if     (strcmp(argv[i],"b") == 0){
//         colour0_flag=1; colour0_red=0; colour0_green=0; colour0_blue=0;
       }
       else if(strcmp(argv[i],"w") == 0){
//         colour0_flag=2; colour0_red=255; colour0_green=255; colour0_blue=255;
       }
       else  colour0_flag=0;
     }
     else if(strcmp(argv[i],"-sb"  ) == 0){
       i++; shadow_buffer_size=atoi(argv[i]);
       if(shadow_buffer_size < 0)shadow_buffer_size=0;
       if(shadow_buffer_size > 1024)shadow_buffer_size=1024;
     }
     else if(strcmp(argv[i],"-tz"  ) == 0){
       i++; tzeros = atol(argv[i]); /* trailing zeros */
     }
#if TRACER
     else if(strcmp(argv[i],"-trs"  ) == 0)trace_shadows=YES;
     else if(strcmp(argv[i],"-trr"  ) == 0)trace_reflections=YES;
     else if(strcmp(argv[i],"-trg"  ) == 0)trace_refractions=YES;
     else if(strcmp(argv[i],"-to"   ) == 0)trace_partition=0;
     else if(strcmp(argv[i],"-tod"  ) == 0){
       i++; trace_depth = atol(argv[i]); /* depth of tree */
     }
     else if(strcmp(argv[i],"-tot"  ) == 0){
       i++; trace_face_count_target = atol(argv[i]); /* face in voxel */
     }
     else if(strcmp(argv[i],"-tos"  ) == 0){
       i++; trace_voxel_min_size = atol(argv[i]); /* sizeo of voxel */
     }
#endif
     else if(strcmp(argv[i],"-q"   ) == 0){  /* quiet operation */
       OUTPUT_FILE_TYPE=NUL_FILE;
       renderer_silent=1;
     }
     else if(strcmp(argv[i],"-prv" ) == 0){
       // NOT in this renderer - ignore
     }
     else if(strcmp(argv[i],"-ntsc") == 0){
       ntsc_colours=YES;
     }
     else if(strcmp(argv[i],"-blr") == 0){
       i++; mblurON = (int)atoi(argv[i]);
     }
     else if(strcmp(argv[i],"-fm") == 0){
       full_mirror=TRUE;
     }
     else if(strcmp(argv[i],"-ob") == 0){;} // always ON
     i++;
   }
 }
 ResolutionX=XMAX; ResolutionY=YMAX;
 aaXstep=1; aaYstep=1;
 // IF we are tracing GLASS then there is no need to use the Scanline GLASS layers.
 // The function pointers are directed appropriately
 if(trace_refractions)UpdateScanBuffers=UpdateNoGlassScanBuffers;
 else                 UpdateScanBuffers=UpdateGlassScanBuffers;
 if(anti_alias_edges)full_mirror=FALSE;
 if(anti_alias == LOW)   {XMAX *= 2; aaXstep=2; aaYstep=1;}
 if(anti_alias == MEDIUM){XMAX *= 2; YMAX *= 2; aaXstep=2; aaYstep=2;}
 if(anti_alias == HIGH)  {XMAX *= 3; YMAX *= 2; aaXstep=3; aaYstep=2;}
 if(anti_alias == ULTRA) {XMAX *= 3; YMAX *= 3; aaXstep=3; aaYstep=3;}
 frame=0;
 command_id=0;
 if(firstframe < 1)firstframe=1;
 if(firstframe > lastframe)firstframe=lastframe;
 flash_count=0; wave_phase=0.0;
 if(InitialiseNoise() == FAIL){
   Render_Message(13,0,NULL); goto EXITPOINT;
 }
 init_spec();        // Initialise the specularity look-up table.
 init_structures();  // Initialise the structures that will be used to pass Renderer data to the plug-ins
 setup_render_discarded_list();
 if(AllocateRamBuffers() == FAIL){ // Allocate the main memory buffers
   Render_Message(13,0,NULL); goto EXITPOINT;
 }
 for (i=0;i<nCOLOUR;i++)colorstats0[i] = 0; colorstats0[0]=65536*1024L;
 for(i=0;i<XMAX;i++)DummyShadow[i]=0;
 sprintf(scriptfile,"%s.scr",argv[1]);
 // NOW READY TO RENDER AN ANIMATION FROM A SCRIPT FILE READ WRITTEN BY ANIMATOR
 if((CF=fopen((char *)scriptfile,"r")) == NULL){
   Render_Message(41,1,NULL);
   goto EXITPOINT;
 }
 fscanf(CF,"%s",temp_str);
 if(temp_str[2] == '2')version=2; else version=1;
 if(temp_str[0] == 'R'){ /* get the number of frames in the script */
   fscanf(CF,"%s",temp_str);
   nScriptframes=atoi(temp_str);
   fscanf(CF,"%s",temp_str);
   nAnimStart=atoi(temp_str)-1;
 }
 else{
   fscanf(CF,"%s",temp_str);
   nScriptframes=9999;
   nAnimStart=0;
 }
 if(version > 1){// Read the scene bounds to use for clipping planes
   fscanf(CF,"%ld %ld",&ClipXmin,&ClipXmax);
   fscanf(CF,"%ld %ld",&ClipYmin,&ClipYmax);
   fscanf(CF,"%ld %ld",&ClipZmin,&ClipZmax);
 }
 ObjectCount=0; Object=NULL; 
 Nshader=0; Shader=NULL;
 StereoFrame=TRUE;  // this is rendering the left frame
 NEXTFRAME:
 if(StereoRenderingON){
   // When doing stereo we need to render the frame twice 
   // do this by re-rendering the frame from the left and right position
   // re-rendering is done by re-reading the script file and adjusting the viewpoint.
   if(StereoFrame)StereoPosition=ftell(CF); 
   else fseek(CF,StereoPosition,0);
 }
 frame++;
 subframe=0;   // Sub frames are used when rendering motion blur
 NEXTSUBFRAME:
 subframe++;
 if(frame < firstframe){ // Skip frames if not starting from the first 
   char c,tt[256];
   int ic=0;
   LOOP:
   ic=0;
   LOOP2:
   if((c=getc(CF)) == EOF)goto EXITPOINT; 
   if(c != '\n'){
     tt[ic++]=c;
     goto LOOP2;
   }
   tt[ic]=0;
  if(tt[0] != 'f')goto LOOP;
   wave_phase += 0.1;          /* move onto next wave phase */
   if(wave_phase > 1.99999)wave_phase = 0.0;
   goto NEXTFRAME;
 }
 if(!renderer_silent)UpdateNTFrame(frame,command_id);
 if(frame > lastframe){ End_of_animation=1; goto EXITPOINT;}
 sprintf(temp_message,"%ld",frame);
 Render_Message(42,0,temp_message);
 RenderCurrentFrame=frame;
 R_Nground=0; 
 if(!bKeepObjectsInRAM){
   ObjectCount=0; Object=NULL; Nshader=0; Shader=NULL;
 }
 FirstObject=ObjectCount; 
 Nlights=0; Lights=NULL; nImageProcesses=0; ImageProcesses=NULL;
 Nparticles=0; ParticleS=NULL;
 VGA_screen=NULL; Nsky=0;
 // This is the main animation frame rendering start /////////////
 if((command_id=GetCommand(firstframe,frame,nAnimStart,argv[2])) < 0)goto EXITPOINT;
 //if(debug != NULL){
 // fprintf(debug,"Frame %ld with %ld Objects in Scene\n",frame,ObjectCount);
 // if(ObjectCount > 0)for(i=0;i<ObjectCount;i++)
 //  fprintf(debug,"O %ld in use=%ld\n",i,Object[i].in_use);
 //}
 Render_Message(44,0,NULL);
 Xcentre=(XMAX+XMIN)/2;
 Ycentre=(YMAX+YMIN)/2;
 SetPerspectiveView((int)StereoFrame); /* build view transformation TRR */
 if(TransformSceneForRendering(&failure,frame,firstframe) == FAIL)goto FREEPOINT;
 // Now render the scene using either the GPU or Software
 if(bRenderOpenGL){ // GPU
   RenderGL(frame,(ApplyPPtoGL == YES ? FALSE : TRUE)); // don't PostPprocess(PP) if using SW PP
   InvalidateRect(hWndOpenGL,NULL,FALSE);
   if(R_terminator() == FAIL)failure=FAIL;
   if(FullScreenBuffer != NULL)CopyGLtoFSB();
   if(fszBuffer != NULL)CopyGLtoZbuffer(); // Only if enabled 
   if(ApplyPPtoGL == YES && failure != FAIL)ExternalImageProcess(frame,1);
 }
 else{ // Software Renderer
   if(RenderHide() == FAIL)failure=FAIL;
   if(failure != FAIL && Nparticles > 0 && ParticleS != NULL && 
      FullScreenBuffer != NULL && fszBuffer != NULL)RenderParticles();
   if(failure != FAIL && nImageProcesses > 0)
     failure=ExternalImageProcess(frame,0);
   if(failure != FAIL && FullScreenBuffer != NULL && MotionBlurBuffer != NULL)
     failure=MotionBlurFrame(frame,subframe,command_id);
 }
 if(failure != FAIL && instant_callback == YES && FullScreenBuffer != NULL)
   AddToRenderImagePreview(0,
                           ResolutionX,ResolutionY,
                           FullScreenBuffer,NULL,NULL,NULL);
 /* if integrating for Motion blur or field rendering don't write yet   */
 if(command_id == 1)goto FREEPOINT;
 /* if output file type is 24 bit or 16 bit TARGA then do it now         */
 /* else if full screen buffer and 8 bit create the compressed truncated */
 /* temporary file. If full screen buffer buffer not used, this will     */
 /* already have been done (outputfile is temporary arrary)              */
 strcpy(outputroot,argv[2]);
 if(StereoRenderingON){
   if(StereoFrame && FullScreenBuffer != NULL){ // left frame 
     if((stereo_buffer=(fullscreenbuffer *)X__Malloc(ResolutionX*ResolutionY*2*(long)sizeof(fullscreenbuffer))) != NULL){
       memcpy(stereo_buffer,FullScreenBuffer,sizeof(fullscreenbuffer)*ResolutionX*ResolutionY);
     }
   }
   else if(stereo_buffer != NULL){ // right frame
     memcpy((stereo_buffer+ResolutionX*ResolutionY),FullScreenBuffer,sizeof(fullscreenbuffer)*ResolutionX*ResolutionY);
     if(OUTPUT_FILE_TYPE == AVI_FILE && failure != FAIL){
       failure=ScreenTo32bitFile(frame,outputfile,outputroot,stereo_buffer); 
     } 
     else {
       OneExternalFrame(frame,(char *)stereo_buffer,outputroot,JPS_FILE,jpeg_quality); 
     }
     free(stereo_buffer); stereo_buffer=NULL;
   }
   StereoFrame ^= 1;
 }
 else if(OUTPUT_FILE_TYPE == TIF_FILE && failure != FAIL)
   OneExternalFrame(frame,NULL,outputroot,TIF_FILE,100);
 else if(OUTPUT_FILE_TYPE == B24_FILE && failure != FAIL)
   OneExternalFrame(frame,NULL,outputroot,B24_FILE,100);
 else if(OUTPUT_FILE_TYPE == J24_FILE && failure != FAIL)
   OneExternalFrame(frame,NULL,outputroot,J24_FILE,jpeg_quality);
 else if(OUTPUT_FILE_TYPE == PNG_FILE && failure != FAIL)
   OneExternalFrame(frame,NULL,outputroot,PNG_FILE,100);
 else if(OUTPUT_FILE_TYPE == AVI_FILE && failure != FAIL && FullScreenBuffer != NULL)
   failure=ScreenTo32bitFile(frame,outputfile,outputroot,NULL);
 FREEPOINT:
 Free_Mirror_On_Ground();
 Free_Lights_Shadows();
 FreeFrameObjects();
 if(!bKeepObjectsInRAM)FreeAllObjects();
 if(Lights != NULL){X__Free(Lights); Lights = NULL;}
 if(ParticleS != NULL){
   for(i=0;i<Nparticles;i++){
     if((ParticleS+i)->particles != NULL)X__Free((ParticleS+i)->particles);
   }
   X__Free(ParticleS); ParticleS = NULL; Nparticles=0;
 }
 if(nImageProcesses > 0 && ImageProcesses != NULL){
   for(i=0;i<nImageProcesses;i++){
     if(ImageProcesses[i].parameters != NULL)
       X__Free(ImageProcesses[i].parameters);
     if(ImageProcesses[i].mparameters != NULL)
       X__Free(ImageProcesses[i].mparameters);
   }
   X__Free(ImageProcesses);
   ImageProcesses=NULL;
   nImageProcesses=0;
 }
 if(VGA_screen != NULL){
   X__Free(VGA_screen);
   VGA_screen=NULL;
 }
#ifdef TRACER
 if(trace_reflections || trace_refractions || trace_shadows)freeBST();
#endif
 //if(debug != NULL)fprintf(debug,"End of FRAME !!!\n");
 if(failure == FAIL){
   remove(outputfile);
   goto EXITPOINT;
 }
 if(command_id == 1){
   goto NEXTSUBFRAME;
 }
 wave_phase += 0.1;          /* move onto next wave phase */
 if(wave_phase > 1.99999)wave_phase = 0.0;
 flash_count++; if(flash_count > 5){flash_count=0; flashing ^= 1;}
 goto NEXTFRAME;
 EXITPOINT:
 if(bKeepObjectsInRAM)FreeAllObjects();
 FreeTextureHashTable();
 if(End_of_animation && failure != FAIL){
   // if making gif image (or sequence of GIF images) do it here
   // this uses the 16 bit temporary file so that all gif images have same palette.
   Render_Message(38,0,NULL);
   // 
   Render_Message(39,0,NULL);
 }
 else{
  WindowedRenderMessage(WRM_COMPLETE);
  Render_Message(43,0,NULL);
 }
 FreeRamBuffers();
 free_render_discarded_list();
 ReleaseImageStore();
 if(CF != NULL)fclose(CF);
 return (int)failure;
}

static int TransformSceneForRendering(long *failure,long frame, long firstframe){
 long i,tFaces=0,tVertices=0;
 double light_transformation[4][4],trset[4][4],trinv[4][4];
 vector Zero_Vector;
 Zero_Vector[0]=Zero_Vector[1]=Zero_Vector[2]=0.0;
 if(Nlights > 0)for(i=0;i<Nlights;i++){
   Lights[i].shadow_buffer=NULL;
   Lights[i].object_buffer=NULL;
   Lights[i].face_buffer=NULL;
   Lights[i].atmospheric_shadow_buffer=NULL;
   if(Lights[i].type == SPOTLIGHT){
     MakeObjectTransformation(Lights[i].dPhi,0.0,Lights[i].dAlpha,
              Lights[i].internal_type,Lights[i].internal_size,
              1.0,1.0,1.0,
              Zero_Vector,Lights[i].pin,
              light_transformation,trset,trinv);
     ApplyViewingTransformToPoint(Lights[i].pin,Lights[i].p);
     R_m4by1(light_transformation,
             0.0,(double)UNIT,0.0,
             &Lights[i].d[0],&Lights[i].d[1],&Lights[i].d[2]);
     vecsub(Lights[i].p,Lights[i].d,Lights[i].d);  //d is opposite to light dir
     normalize(Lights[i].d);
     Lights[i].cone2 = min(89.9,Lights[i].cone1/2+Lights[i].falloff);
     Lights[i].cone2 *= PI/180.0;   /* cone + edge */
     Lights[i].cone1 *= PI/360.0;   /* half viewing cone angle */
     Lights[i].dot1 = cos(Lights[i].cone1);  /* for dot product */
     Lights[i].dot2 = cos(Lights[i].cone2);
     Lights[i].falloff = 1.0/(Lights[i].dot1-Lights[i].dot2);
   }
   else ApplyViewingTransformToPoint(Lights[i].pin,Lights[i].p);
   Lights[i].Ire = ((double)Lights[i].color[0])/255.0;
   Lights[i].Igr = ((double)Lights[i].color[1])/255.0;
   Lights[i].Ibl = ((double)Lights[i].color[2])/255.0;
 }
 else{
   if((Lights=(light *)X__Malloc(sizeof(light))) == NULL){
     *failure=FAIL; return FAIL;
   }
   Render_Message(50,0,NULL);
   Nlights=1;   /* camera is at origin after transform */
   Lights[0].color[0]=Lights[0].color[1]=Lights[0].color[2]=255;
   Lights[0].type=NORMAL;
   Lights[0].shadow_buffer=NULL;
   Lights[0].atmospheric_shadow_buffer=NULL;
   Lights[0].AnimatorID=0;
   Lights[0].object_buffer=NULL;
   Lights[0].face_buffer=NULL;
   Lights[0].p[0] = 0.0; Lights[0].p[1] = -0.0; Lights[0].p[2] = 0.0;
   Lights[0].d[0] = 0.0; Lights[0].d[1] = -1.0; Lights[0].p[2] = 0.0;
   Lights[0].Ire = 1.0;
   Lights[0].Igr = 1.0;
   Lights[0].Ibl = 1.0;
   Lights[0].dc=FALSE;
   Lights[0].dc_c=1.0;
   Lights[0].dc_l=0.0;
   Lights[0].dc_q=0.0;
 }
 if(R_Nground > 0){
  ApplyViewingTransformToPoint(Ground.pin,Ground.p);
  ApplyViewingTransformToPoint(Ground.xin,Ground.x);
  ApplyViewingTransformToPoint(Ground.yin,Ground.y);
  vecsub(Ground.x,Ground.p,Ground.dx);
  vecsub(Ground.y,Ground.p,Ground.dy);
  cross(Ground.dx,Ground.dy,Ground.n);
  normalize(Ground.n);
  Ground.lengthx=R_length(Ground.dx);
  Ground.lengthy=R_length(Ground.dy);
  Ground.bump=1.0/max(1.0,Ground.lengthx);
  Ground.range=Ground.lengthy/Ground.lengthx/2.0;
  Ground.range *= Ground.range;
  if(ambient_flag == 0)Ground.ambient_light=ground_ambient_light;
  veccopy(Ground.dy,Ground.dyy);
  normalize(Ground.dyy);
  vecscale(Ground.lengthx,Ground.dyy,Ground.dyy);
  if(Ground.texture > 0 && Ground.texture < 4)Ground.shiny = 1;
  else                                        Ground.shiny = 0;
  if(frame == firstframe)init_ripples();
  if(Ground.mapped){
    ApplyViewingTransformToPoint(Ground.map.pin,Ground.map.p);
    ApplyViewingTransformToPoint(Ground.map.xin,Ground.map.x);
    ApplyViewingTransformToPoint(Ground.map.yin,Ground.map.y);
    vecsub(Ground.map.x,Ground.map.p,Ground.map.x);
    vecsub(Ground.map.y,Ground.map.p,Ground.map.y);
    cross (Ground.map.x,Ground.map.y,Ground.map.n);
    normalize(Ground.map.n);
  }
 }
 if(Nparticles > 0 && ParticleS != NULL){  // Transform the particle system & build the particles ready to go 
   for(i=0;i<Nparticles;i++){  // number of particle systems
     long np=ParticleS[i].Rate;
     ParticleSystem *Ps;
     Ps=&(ParticleS[i]);
     Ps->particles=NULL;
     if(np > 0){
       Ps->particles=(Particle *)X__Malloc(np*sizeof(Particle));
       if(Ps->particles != NULL){
         if(Ps->bSingle)SetUpSingleParticle(Ps); // set up a particle system that only needs a single particle
         else           SetUpParticles(Ps);   
       }
     } 
   }
 }

 if(ambient_flag == 0)ambient_light=object_ambient_light;
 if(Sky.type == SKYMAPPED){  /* set up cylindrical map  for use of skymapped texture */
   if(Sky.mapped){           /* used when doing a ray-tracing                        */
     ApplyViewingTransformToPoint(Sky.map.pin,Sky.map.p);
     ApplyViewingTransformToPoint(Sky.map.xin,Sky.map.x);
     ApplyViewingTransformToPoint(Sky.map.yin,Sky.map.y);
     vecsub(Sky.map.x,Sky.map.p,Sky.map.x);
     vecsub(Sky.map.y,Sky.map.p,Sky.map.y);
     cross (Sky.map.x,Sky.map.y,Sky.map.n);
     normalize(Sky.map.n);
   }
 }
 if(ObjectCount > 0)for(i=0;i<ObjectCount;i++){
   if(!Object[i].in_use || Object[i].NoVertices == 0 
                        || Object[i].NoFaces == 0)continue;
   tVertices += Object[i].NoVertices;
   tFaces    += Object[i].NoFaces;
   Object[i].ambient_light=ambient_light;
   if(TransformObjectIntoPosition(i) == FAIL){
     *failure=FAIL;
     return FAIL;
   }
 }
 if(!bRenderOpenGL){ // Only for software renderer
   for(i=0;i<Nlights;i++)if(Lights[i].type == SPOTLIGHT){
     SetLightShadow(i);
   }
 }
 else trace_reflections = trace_refractions = trace_shadows = 0; // NOT for H/W renderer

 // Calculate vertex normals - for each vertex in the faces - moved from the RenderHide function!!!
 Render_Message(57,0,NULL);
 MakeVertexNormals();
 // // end of move
 if(trace_reflections || trace_refractions || trace_shadows){
   if(buildBST() == FAIL){ Render_Message(45,0,NULL);  *failure=FAIL;  return FAIL; }
   // need to re-calcalculate this since objects now split
   if(ObjectCount > 0)for(i=0;i<ObjectCount;i++)CalculateObjectScreenCoordinates(i);
 }
 if(!(trace_reflections || trace_refractions || trace_shadows)){
   char tstr[256],text_string[256];
   LoadString(hThisInstance,IDX_MISC_STATUS1,
              text_string,sizeof(text_string));
   sprintf(tstr,text_string,
           tFaces,tVertices,ObjectCount);
   WindowedRenderInfo(tstr);
 }
 return OK;
}

static short TransformObjectIntoPosition(long O){
   long i,j;
   double temp4,xx,yy,theta_max,
          trset[4][4];  // object transform - everything but WITHOUT the view.
   vertex   *v;
   face     *f;
   Object[O].xmin = BIGP;   Object[O].xmax = BIGN;
   Object[O].ymin = BIGP;   Object[O].ymax = BIGN;
   MakeObjectTransformation(
           Object[O].fi,Object[O].theta,Object[O].alpha,
           Object[O].im,Object[O].ima,
           Object[O].sx,Object[O].sy,Object[O].sz,
           Object[O].Centre,Object[O].Offset,
           Object[O].trpos,trset,
           Object[O].trinv);
   if((j=Object[O].NoMaps) > 0){
     imap *Map;
     for(i=0;i<j;i++){
       Map=(Object[O].Mbase+i);
       TransformMappingRectangle(Object[O].trpos,
               Map->pin,Map->xin,Map->yin,
               Map->p,Map->x,Map->y,
               Map->n);
       if(Map->bp >= 0){ // Bump map is applied
         theta_max=80 * 0.017453; theta_max=tan(theta_max); /*  max angle of bend in surface normal */
         Map->bumpy = max(1.0,R_length(Map->y));
         Map->bumpy = -((double)Map->bp)*0.01*theta_max
                          /Map->bumpy/256;
         if(Map->map == CYLINDER ||
            Map->map == MAP_SPHERICAL ||
            Map->map == CYLINDER_MOZIAC)
               Map->bumpx = 1.0;
         else  Map->bumpx = max(1.0,R_length(Map->x));
         Map->bumpx = -((double)Map->bp)*0.01*theta_max
                          /Map->bumpx/256;
       }
       Map->pd=((double)Map->pp)*0.01;   // surface percentage 
       if(Map->rp >= 0)Map->rd=((double)Map->rp)*0.01;   // reflection percentage
       else Map->rd=0.0;
     }
   }
   // Allow for the transform of the objects material axes - only used by hardware renderer
   if((j=Object[O].NoMats) > 0){
     matl *Mat;
     for(i=0;i<j;i++){
       Mat=(Object[O].Tbase+i);
       TransformMappingRectangle(Object[O].trpos,
             Mat->ax.boin,
             Mat->ax.buin,
             Mat->ax.bvin,
             Mat->ax.bo, /* material axes */
             Mat->ax.bu,
             Mat->ax.bv,
             Mat->ax.bn);
       Mat->ax.tl=max(1.0,R_length(Mat->ax.bu));
       Mat->ax.tv=max(1.0,R_length(Mat->ax.bv));
       vecscale(1.0/Mat->ax.tl,Mat->ax.bu,Mat->ax.bu_norm);
       vecscale(1.0/Mat->ax.tv,Mat->ax.bv,Mat->ax.bv_norm);
     }
   }
   TransformMappingRectangle(Object[O].trpos,
             Object[O].Abase.boin,
             Object[O].Abase.buin,
             Object[O].Abase.bvin,
             Object[O].Abase.bo, /* shader axes */
             Object[O].Abase.bu,
             Object[O].Abase.bv,
             Object[O].Abase.bn);
   Object[O].Abase.tl=max(1.0,R_length(Object[O].Abase.bu));
   Object[O].Abase.tv=max(1.0,R_length(Object[O].Abase.bv));
   vecscale(1.0/Object[O].Abase.tl,
            Object[O].Abase.bu,Object[O].Abase.bu_norm);
   vecscale(1.0/Object[O].Abase.tv,
            Object[O].Abase.bv,Object[O].Abase.bv_norm);
   // Transform the vertices into position
   v=Object[O].Vbase;
   Object[O].visibility=NO;
   if(Object[O].effect >= 0){
     EffectObjectVertices(0,O); /* locally  */
     for(i=0;i<Object[O].NoVertices;i++){
       R_m4by1(trset, (v+i)->p[0], (v+i)->p[1], (v+i)->p[2]
                    ,&(v+i)->p[0],&(v+i)->p[1],&(v+i)->p[2]);
     }
     EffectObjectVertices(1,O); /* globally */
     for(i=0;i<Object[O].NoVertices;i++){
       R_m4by1(ViewTransform,(v+i)->p[0], (v+i)->p[1], (v+i)->p[2]
                  ,&(v+i)->p[0],&(v+i)->p[1],&(v+i)->p[2]);
       if((v+i)->p[1] > 1.000)Object[O].visibility=YES;
     }
   }
   else{
     for(i=0;i<Object[O].NoVertices;i++){
       R_m4by1(Object[O].trpos, (v+i)->p[0], (v+i)->p[1], (v+i)->p[2]
                            ,&(v+i)->p[0],&(v+i)->p[1],&(v+i)->p[2]);
       if((v+i)->p[1] > 1.000)Object[O].visibility=YES;
     }
   }

   if(Object[O].visibility == YES){
     if(ClipObject(O) == FAIL)return FAIL;
   }
   v=Object[O].Vbase;
   CalculateObjectScreenCoordinates(O);
   return OK;
}

static CalculateObjectScreenCoordinates(long O){
 long i,j;
 double temp4,xx,yy;
  vertex   *v;
  face     *f;
  v=Object[O].Vbase;
  for(i=0;i<Object[O].NoVertices;i++){
    (v+i)->ip[0] = (long)(v+i)->p[0]; // assign integer coopy
    (v+i)->ip[1] = (long)(v+i)->p[1];
    (v+i)->ip[2] = (long)(v+i)->p[2];
    (v+i)->p[0] = (double)(v+i)->ip[0]; // make sure final points are also integers 
    (v+i)->p[1] = (double)(v+i)->ip[1];
    (v+i)->p[2] = (double)(v+i)->ip[2];
    if((v+i)->p[1] >= FRONT_CLIPPING_PLANE){  /* point on or in front of view plane */
     temp4=(scalex*((v+i)->p[0])/((v+i)->p[1]));
     xx=(double)Xcentre + temp4;
     (Object[O].Vbase+i)->x=xx;
     temp4=(scaley*((v+i)->p[2])/((v+i)->p[1]));
     yy=(double)Ycentre - temp4;
     (Object[O].Vbase+i)->y=yy;
    }
    else{ /* just dummy it any face with this node will not be used */
     (Object[O].Vbase+i)->x=xx=(double)Xcentre;  /* will be scrapped later */
     (Object[O].Vbase+i)->y=yy=(double)Ycentre;
    }
    if(xx < 0)xx = -1; if(xx > XMAX) xx = XMAX+1; // don't let bounds get outside screen
    if(yy < 0)yy = -1; if(yy > YMAX) yy = YMAX+1;
    if(xx < Object[O].xmin) Object[O].xmin = xx;
    if(xx > Object[O].xmax) Object[O].xmax = xx;
    if(yy < Object[O].ymin) Object[O].ymin = yy;
    if(yy > Object[O].ymax) Object[O].ymax = yy;
   }
   v=Object[O].Vbase;     /* NB the object may be invisible but its */
   f=Object[O].Fbase;     /* shadow/reflection may be !!            */
   CalculateFaceNormals(v,f,O);

}

static int PsameSide(vector v, vector p0, vector n){
  vector pv;                            /* after reflection - remove faces  */
  VECSUB(p0,v,pv)                       /* if all vertices are on same side */
  if(DOT(pv,n)*DOT(p0,n) > 0)return 1;  /* as (0,0,0) - put off screen      */
  return 0;
}

static void CalculateFaceNormals(vertex *v, face *f, long O){
 long i,badflag;
 double c,ftop,fbottom,fleft,fright;
 vector p1,p2,p0;
 for(i=0;i<Object[O].NoFaces;i++){
    p0[0]=(v+f->V[0])->p[0];
    p0[1]=(v+f->V[0])->p[1];
    p0[2]=(v+f->V[0])->p[2];
    p1[0]=(v+f->V[1])->p[0];
    p1[1]=(v+f->V[1])->p[1];
    p1[2]=(v+f->V[1])->p[2];
    p2[0]=(v+f->V[2])->p[0];
    p2[1]=(v+f->V[2])->p[1];
    p2[2]=(v+f->V[2])->p[2];
    vecsub(p2,p0,p2);
    vecsub(p1,p0,p1);
    cross(p1,p2,f->n);
    if(normalize(f->n) == 1)badflag=1; else badflag=0;
    c=dot(p0,f->n);
    f->c=(double)c;
//    if(c > 0.0){ /* all normals point to camera */  // Removed - seems not necessary
//      vecscale((double)(-1.0),f->n,f->n);
//      f->c=(double)c*(-1.0);
//    }
    /* get face screen limits */
    ftop=min((v+(f->V[0]))->y,(v+(f->V[1]))->y);
    ftop=min((v+(f->V[2]))->y,ftop);
    fbottom=max((v+(f->V[0]))->y,(v+(f->V[1]))->y);
    fbottom=max((v+(f->V[2]))->y,fbottom)+1;
    fleft=min((v+(f->V[0]))->x,(v+(f->V[1]))->x);
    fleft=min((v+(f->V[2]))->x,fleft);
    fright=max((v+(f->V[0]))->x,(v+(f->V[1]))->x);
    fright=max((v+(f->V[2]))->x,fright)+1;
    if(ftop < 0.0)f->top= -1;
    else if(ftop > YMAX)f->top=YMAX+1;
    else f->top=(short)ftop;
    if(fbottom < 0.0)f->bottom= -1;
    else if(fbottom > YMAX)f->bottom=YMAX+1;
    else f->bottom=(short)fbottom;
    if(fleft < 0.0)f->left= -1;
    else if(fleft > XMAX)f->left=XMAX+1;
    else f->left=(short)fleft;
    if(fright < 0.0)f->right= -1;
    else if(fright > XMAX)f->right=XMAX+1;
    else f->right=(short)fright;
/* eliminate faces with all vertices behind clipping plane,
   faces that span the clipping plane have been cliped in ClipObject,
   by setting the face top value to  > YMAX this face will then
   fail the first test in Active.  Also eliminate faces to left
   or right of screen by using the same trick */
    if( ( v[ f->V[0] ].p[1] <= FRONT_CLIPPING_PLANE)  /* nodes in face are either behind */
     && ( v[ f->V[1] ].p[1] <= FRONT_CLIPPING_PLANE)  /* or on viewing plane */
     && ( v[ f->V[2] ].p[1] <= FRONT_CLIPPING_PLANE)){
       f->top=YMAX+1;
    }
    if(f->left >= XMAX)      f->top=YMAX+1;
    if(f->right < XMIN)      f->top=YMAX+1;
/* eliminate faces that are perpendicular to the viewing plane */
    if(fabs(f->c) < 1.e-4)   f->top=YMAX+1;
/* and faces with bad normals this put in for DEC aXP and may be wrong */
    if(badflag == 1){
      f->top=YMAX+1; f->n[0]=f->n[1]=f->n[2]=1.0;
    }
    f++;
 }
}

/*  Do the scan line rendering here */

/* Functions to build the phong smoothing vectors and do the scanline */
/* algorithm. The geometry calculations are doen in file   GEO.C      */
/* and the surface properties are calculated in TEXTURE.C + TEXTUR1.C */
/* Also inclued the "CORE" of the scanline algorithm                  */

typedef struct PHONG1_tag { 
  int fid,vid;
} PHONG1;

typedef struct PHONG_tag { 
  int n;
  PHONG1 fv[8];   /* 10 seems to be too big */
} phong;

void MakeVertexNormals(void){   /* This is a horrible thing that asembles */
                                /* the PHONG vectors 3 for each FACE      */
 vertex   *v;                   /* umpteen different procedures have been */
 face     *f;                   /* tried - this gives the best results    */
                                /* the diff. only occurs when faces are   */
                                /* perpend.r to the line of sight.        */
 long i,j,k,O,vi,ni,fj,vj,fk;   /* All other faces are turned to face the */
 double c;                      /* camera there is no problem there.       */
 vector nn;                     /* TRY AND BUILD MODELS WITH CONSISTENT NORMALS INSTEAD */     
 phong *ph;
 for(O=0; O<ObjectCount; O++){
   if(!Object[O].in_use || Object[O].NoVertices == 0 || Object[O].NoFaces == 0)continue;
   v=Object[O].Vbase;
   f=Object[O].Fbase;
 
   for(i=0;i<Object[O].NoFaces;i++){
     for(j=0;j<3;j++)VECCOPY(f[i].n,f[i].pn[j]);
   }
   if((ph = (phong *)X__Malloc(Object[O].NoVertices*sizeof(phong))) == NULL){
     Render_Message(11,0,NULL);
     return;
   }
   for(i=0;i<Object[O].NoVertices;i++){
     ph[i].n=0;
   }
   for(i=0;i<Object[O].NoFaces;i++){
     if(1){ /* need to smooth all faces because a material will need this */
       for(j=0;j<3;j++){  /* make list of faces adjacent to vertex */
         vi=f[i].V[j];
         ni=ph[vi].n;
         if(ni < 8){ /* for windows just use ? (10 too big) so no reallocation needed */
           ph[vi].fv[ni].fid=i;
           ph[vi].fv[ni].vid=j;
           ph[vi].n++;
         }
       }
     }
   }  /* now we have a list of faces adjacent to each vertex */
   {   
     for(i=0;i<Object[O].NoVertices;i++){
       if((ni=ph[i].n) > 0){
         for(j=0;j<ni;j++){
           fj=ph[i].fv[j].fid; vj=ph[i].fv[j].vid;
           for(k=0;k<ni;k++)if(k != j){
             fk=ph[i].fv[k].fid;
             if((c=dot(f[fj].n,f[fk].n)) > smoothing_angle /*0.01*/){ /* keep same */
               vecsum(f[fj].pn[vj],f[fk].n,f[fj].pn[vj]);
             }
             else if(c < -smoothing_angle /*-0.01*/){  /* invert before adding */
               nn[0] = -f[fk].n[0]; nn[1] = -f[fk].n[1]; nn[2] = -f[fk].n[2];
               vecsum(f[fj].pn[vj],nn,f[fj].pn[vj]);
             }
           }
         }
       }
     }
   }
   for(i=0;i<Object[O].NoFaces;i++){ /* normalize vertex vectors */
     for(j=0;j<3;j++)normalize(f[i].pn[j]);
   }
   X__Free(ph);
 }
}

typedef struct THSTART_tag{ 
 int start,skip;
 HANDLE h;
} THSTART;

static BOOL all_terminate_flag=FALSE; 
static long last_update=0;

void RenderMultiThreaded(void *arg){
 long i,j,k,l,m,Wsky;
 double d2,xl,xr,Rsky=0.0;
 vertex *v;
 face   *f;
 THD    thd,*p;
 THSTART *s=(THSTART *)arg;
 //{char temp[255]; sprintf(temp,"Normal Thread %ld -> %ld",s->start,s->skip);
 //MessageBox(NULL,temp,"Thread",MB_OK);}
 SetThreadPriority(GetCurrentThread(),THREAD_PRIORITY_BELOW_NORMAL);
 p=&thd; if(!AllocateThreadStorage(p))goto THDERROR;
 //MessageBeep(MB_OK);
 for(l=s->start*aaYstep;l<YMAX;l+=(aaYstep*(s->skip))){
   for(i=0;i<XMAX;i++){p->Xbuffer[i] = -1; p->Xobject[i] = -4;}
   for(m=0;m<aaYstep;m++){
     k=l+m;
     d2=(double)(Ycentre-k);
     d2/=scaley;
     Wsky=PutBackIntersection(k,d2,p->Alfa,p->Zground,
                              p->Zglass,p->ZglassO,p->Zglassd,
                              p->Zbuffer,p->Zobject,p->Zdepth,p->Zposn,
                              &Rsky);
     for(i=0;i<ObjectCount;i++){
       if(!Object[i].in_use)continue;
       if((k > Object[i].ymin) && (k < Object[i].ymax) && !Object[i].wireframe
               &&(Object[i].visibility == YES)){
        v=Object[i].Vbase;
        f=Object[i].Fbase;
        for(j=0;j<Object[i].NoFaces;j++)
         if( Active(k,v,f+j,&xl,&xr) ){
           UpdateScanBuffers(xl,xr,j,i,f+j,d2,
                           p->Zglass,p->ZglassO,p->Zglassd,
                           p->Zbuffer,p->Zobject,p->Zdepth,p->Zposn);
         }
       }
     }
     if(ShadedScanline(
                    k,d2,p->Red,p->Green,p->Blue,
                    p->Zground,Wsky,Rsky,
                    p->Zglass,p->ZglassO,p->Zglassd,
                    p->Zbuffer,p->Zobject,p->Zdepth,p->Zposn) == FAIL){
       goto THDERROR;
     }
     if(alfachannelON == YES)FillAlfaLine(p->Alfa,p->ZglassO,p->Zobject);
     if(AntiAliasLine(k,anti_alias,
                      p->Red,p->Green,p->Blue,p->Alfa,
                      p->L_Red,p->L_Green,p->L_Blue,p->L_Alfa,
                      p->LL_Red,p->LL_Green,p->LL_Blue,p->LL_Alfa) == FAIL){
       Render_Message(0,0,NULL);
       goto THDERROR;
     }
     if(fszBuffer != NULL)ScanlineToZbuffer(k,p->Zdepth);
     if(ObjectIdBuffer != NULL)ScanlineToZobject(k,p->Zobject);
     if(!renderer_silent){
       long ud;
       if     (anti_alias == ULTRA)                        ud=((k+1)/3);
       else if(anti_alias == MEDIUM || anti_alias == HIGH )ud=((k+1)/2);
       else                                                ud=(k+1);
       if(ud > last_update){
         last_update=ud;
         UpdateNTTrace(ud);
       }
     }
     if(all_terminate_flag)goto THDEND;
   }
 }
 goto THDEND;
 THDERROR:
 all_terminate_flag=TRUE;
 THDEND:
 FreeThreadStorage(p);
 SetEvent(s->h);
 _endthread();
 return;
}

void FastAntiAliasRenderMultiThreaded(void *arg){
 long i,j,k,l,m,Wsky;
 double d2,xl,xr,Rsky=0.0;
 vertex *v;
 face   *f;
 THD    thd,*p;
 THSTART *s=(THSTART *)arg;
 SetThreadPriority(GetCurrentThread(),THREAD_PRIORITY_BELOW_NORMAL);
 p=&thd; if(!AllocateThreadStorage(p))goto THDERROR; // allocate local storage for this thread */
//{char temp[255]; sprintf(temp,"Thread %ld -> %ld",s->start,s->skip);
//MessageBox(NULL,temp,"Thread",MB_OK);}
//MessageBeep(MB_OK);
 for(l=s->start*aaYstep;l<YMAX;l+=(aaYstep*(s->skip))){
   for(i=0;i<XMAX;i++){p->Xbuffer[i] = -1; p->Xobject[i] = -4;}
   for(m=0;m<aaYstep;m++){
//Sleep(0);
     k=l+m;
     d2=(double)(Ycentre-k);
     d2/=scaley;
     Wsky=PutBackIntersection(k,d2,p->Alfa,p->Zground,
                              p->Zglass,p->ZglassO,p->Zglassd,
                              p->Zbuffer,p->Zobject,p->Zdepth,p->Zposn,
                              &Rsky);
     for(i=0;i<ObjectCount;i++){
       if(!Object[i].in_use)continue;
       if((k > Object[i].ymin) && (k < Object[i].ymax) && !Object[i].wireframe
               &&(Object[i].visibility == YES)){
        v=Object[i].Vbase;
        f=Object[i].Fbase;
        for(j=0;j<Object[i].NoFaces;j++)
         if( Active(k,v,f+j,&xl,&xr) ){
           UpdateScanBuffers(xl,xr,j,i,f+j,d2,
                           p->Zglass,p->ZglassO,p->Zglassd,
                           p->Zbuffer,p->Zobject,p->Zdepth,p->Zposn);
         }
       }
     }
     if(alfachannelON == YES)FillAlfaLine(p->Alfa,p->ZglassO,p->Zobject);
     if(FastAntiAliasShadedScanline(
                         k,m,d2,p->Red,p->Green,p->Blue,
                         p->Zground,Wsky,Rsky,p->Xbuffer,p->Xobject,
                         p->Zglass,p->ZglassO,p->Zglassd,
                         p->Zbuffer,p->Zobject,p->Zdepth,p->Zposn) == FAIL){
       goto THDERROR;
     }
     if(AntiAliasLine(k,anti_alias,
                      p->Red,p->Green,p->Blue,p->Alfa,
                      p->L_Red,p->L_Green,p->L_Blue,p->L_Alfa,
                      p->LL_Red,p->LL_Green,p->LL_Blue,p->LL_Alfa) == FAIL){
       Render_Message(0,0,NULL);
       goto THDERROR;
     }
     if(fszBuffer != NULL)ScanlineToZbuffer(k,p->Zdepth);
     if(ObjectIdBuffer != NULL)ScanlineToZobject(k,p->Zobject);
     if(!renderer_silent){
       long ud;
       if     (anti_alias == ULTRA)                        ud=((k+1)/3);
       else if(anti_alias == MEDIUM || anti_alias == HIGH )ud=((k+1)/2);
       else                                                ud=(k+1);
       if(ud > last_update){
         last_update=ud;
         UpdateNTTrace(ud);
       }
     }
     if(all_terminate_flag)goto THDEND;
     for(i=0;i<XMAX;i++){p->Xbuffer[i] = p->Zbuffer[i]; p->Xobject[i] = p->Zobject[i];}
   }
 }
 goto THDEND;
 THDERROR:
 all_terminate_flag=TRUE;
 THDEND:
 FreeThreadStorage(p);
 SetEvent(s->h);
 _endthread();
 return;
}

long RenderHide(void){  /* only get phong shading if each sample diff */
 void (*fp)(void *);
 long i,iThrd;
 HANDLE hThrd[16],hEvent[16]; // render in up to 16 threads/
 THSTART Sup[16],*p;
 DWORD tID,result,Np;
 char str[16];
 if(R_terminator() == FAIL)return FAIL;
 Render_Message(60,0,NULL);
 if(R_Nground > 0){
   Render_Message(52,0,NULL);
   ShadowGround();
 }
 if(R_terminator() == FAIL)return FAIL;
// MakeVertexNormals();  // removed
 if(R_terminator() == FAIL)return FAIL;
 if(R_Nground > 0 && Ground.refl > 0.0){
   Render_Message(58,0,NULL);
   Mirror_In_Ground();
 }
 if(Nthreads > 0)Np=Nthreads;
 else            Np=min(16,Nprocessors);
 sprintf(str,"%ld processors %ld",Nprocessors,Np);
 if(in_mirror_phase)Render_Message(99,0,NULL);
 else Render_Message(100,0,str);
 for(i=XMIN;i<XMAX;i++){
   DL[i]=(double)(i - Xcentre);        DL[i]/=scalex;
   DR[i]=(double)(i+1-Xcentre);        DR[i]/=scalex;
   D1[i]=(double)(i - Xcentre) + 0.5;  D1[i]/=scalex;
 }
 GetSkyLocation();
 all_terminate_flag=FALSE; last_update=0;
 //{char temp[255]; sprintf(temp,"Nps=%ld XMAX=%ld YMAX=%ld aaYstep=%ld,aaXstep=%ld",
 //Nprocessors,XMAX,YMAX,aaYstep,aaXstep); MessageBox(NULL,temp,"Debug",MB_OK);}
 for(i=0;i<Np;i++){
   Sup[i].start=i; Sup[i].skip=Np;
   hEvent[i]=CreateEvent(NULL,TRUE,FALSE,NULL);
   p=&Sup[i]; p->h=hEvent[i];
   if(anti_alias_edges == YES && anti_alias > LOW)
        fp=FastAntiAliasRenderMultiThreaded;
   else fp=RenderMultiThreaded;
//fp=RenderMultiThreaded;
//fp=FastAntiAliasRenderMultiThreaded;
#if  __WATCOMC__ && __WATCOMC__ < 1100
  iThrd=_beginthread(fp,0,65536,(void *)p);
#else
  iThrd=_beginthread(fp,0,(void *)p);
#endif
   if(iThrd == -1){
     MessageBox(NULL,"Error Creating Thread",NULL,MB_OK);
     return FAIL;
   }
   hThrd[i]=(HANDLE)iThrd;
 }
 while(1){
   if(!all_terminate_flag && renderer_NT_abort_flag){
     for(i=0;i<Np;i++)SuspendThread(hThrd[i]);
     if(ConfirmNTabort()){
       for(i=0;i<Np;i++)ResumeThread(hThrd[i]);
       all_terminate_flag=TRUE;
       WaitForMultipleObjects(Np,hEvent,TRUE,INFINITE);
       break;
     }
     else renderer_NT_abort_flag=0;
     for(i=0;i<Np;i++)ResumeThread(hThrd[i]);
   }
   result=WaitForMultipleObjects(Np,hEvent,TRUE,75);
   if(result == WAIT_TIMEOUT)RenderYield();
   else break;
 }
 for(i=0;i<Np;i++){
   CloseHandle(hEvent[i]);
 }
 if(all_terminate_flag)return FAIL;
 return 0;
}