main/render.c

   1 /*
   2 THE COMPUTER CODE CONTAINED HEREIN IS THE SOLE PROPERTY OF PARALLAX
   3 SOFTWARE CORPORATION ("PARALLAX").  PARALLAX, IN DISTRIBUTING THE CODE TO
   4 END-USERS, AND SUBJECT TO ALL OF THE TERMS AND CONDITIONS HEREIN, GRANTS A
   5 ROYALTY-FREE, PERPETUAL LICENSE TO SUCH END-USERS FOR USE BY SUCH END-USERS
   6 IN USING, DISPLAYING,  AND CREATING DERIVATIVE WORKS THEREOF, SO LONG AS
   7 SUCH USE, DISPLAY OR CREATION IS FOR NON-COMMERCIAL, ROYALTY OR REVENUE
   8 FREE PURPOSES.  IN NO EVENT SHALL THE END-USER USE THE COMPUTER CODE
   9 CONTAINED HEREIN FOR REVENUE-BEARING PURPOSES.  THE END-USER UNDERSTANDS
  10 AND AGREES TO THE TERMS HEREIN AND ACCEPTS THE SAME BY USE OF THIS FILE.
  11 COPYRIGHT 1993-1999 PARALLAX SOFTWARE CORPORATION.  ALL RIGHTS RESERVED.
  12 */
  13
  14 /*
  15  *
  16  * Rendering Stuff
  17  *
  18  */
  19
  20 #ifdef HAVE_CONFIG_H
  21 #include <conf.h>
  22 #endif
  23
  24 #include <stdlib.h>
  25 #include <stdio.h>
  26 #include <string.h>
  27
  28 #include "inferno.h"
  29 #include "dxxerror.h"
  30 #include "texmap.h"
  31 #include "mono.h"
  32 #include "3d.h"
  33 #include "key.h"
  34 #include "u_mem.h"
  35 #ifdef OGL
  36 #include "ogl_init.h"
  37 #endif
  38 #ifdef EDITOR
  39 #include "editor/editor.h"
  40 #endif
  41
  42
  43 #define INITIAL_LOCAL_LIGHT (F1_0/4)    // local light value in segment of occurence (of light emission)
  44
  45 //used for checking if points have been rotated
  46 int     Clear_window_color=-1;
  47 int     Clear_window=2; // 1 = Clear whole background window, 2 = clear view portals into rest of world, 0 = no clear
  48
  49 int RL_framecount=-1;
  50 short Rotated_last[MAX_VERTICES];
  51
  52 // When any render function needs to know what's looking at it, it should
  53 // access Viewer members.
  54 object * Viewer = NULL;
  55
  56 vms_vector Viewer_eye;  //valid during render
  57
  58 int     N_render_segs;
  59
  60 #ifndef MACINTOSH
  61 fix Render_zoom = 0x9000;                                       //the player's zoom factor
  62 #else
  63 fix Render_zoom = 0xB000;
  64 #endif
  65
  66 #ifndef NDEBUG
  67 ubyte object_rendered[MAX_OBJECTS];
  68 #endif
  69
  70 #define DEFAULT_RENDER_DEPTH 16
  71 int Render_depth=DEFAULT_RENDER_DEPTH;          //how many segments deep to render
  72
  73 int     Detriangulation_on = 1;                                 // 1 = allow rendering of triangulated side as a quad, 0 = don't allow
  74
  75 #ifdef EDITOR
  76 int     Render_only_bottom=0;
  77 int     Bottom_bitmap_num = 9;
  78 #endif
  79
  80 fix     Face_reflectivity = (F1_0/2);
  81
  82 #if 0           //this stuff could probably just be deleted
  83
  84 int inc_render_depth(void)
  85 {
  86         return ++Render_depth;
  87 }
  88
  89 int dec_render_depth(void)
  90 {
  91         return Render_depth==1?Render_depth:--Render_depth;
  92 }
  93
  94 int reset_render_depth(void)
  95 {
  96         return Render_depth = DEFAULT_RENDER_DEPTH;
  97 }
  98
  99 #endif
 100
 101 #ifdef EDITOR
 102 int _search_mode = 0;                   //true if looking for curseg,side,face
 103 short _search_x,_search_y;      //pixel we're looking at
 104 int found_seg,found_side,found_face,found_poly;
 105 #else
 106 #define _search_mode 0
 107 #endif
 108
 109 #ifdef NDEBUG           //if no debug code, set these vars to constants
 110
 111 #define Outline_mode 0
 112 #define Show_only_curside 0
 113
 114 #else
 115
 116 int Outline_mode=0,Show_only_curside=0;
 117
 118 int toggle_outline_mode(void)
 119 {
 120         return Outline_mode = !Outline_mode;
 121 }
 122
 123 int toggle_show_only_curside(void)
 124 {
 125         return Show_only_curside = !Show_only_curside;
 126 }
 127
 128 void draw_outline(int nverts,g3s_point **pointlist)
 129 {
 130         int i;
 131
 132         gr_setcolor(BM_XRGB(63,63,63));
 133
 134         for (i=0;i<nverts-1;i++)
 135                 g3_draw_line(pointlist[i],pointlist[i+1]);
 136
 137         g3_draw_line(pointlist[i],pointlist[0]);
 138
 139 }
 140 #endif
 141
 142 grs_canvas * reticle_canvas = NULL;
 143
 144 void free_reticle_canvas()
 145 {
 146         if (reticle_canvas)     {
 147                 d_free( reticle_canvas->cv_bitmap.bm_data );
 148                 d_free( reticle_canvas );
 149                 reticle_canvas  = NULL;
 150         }
 151 }
 152
 153 extern void show_reticle(int force_big);
 154
 155 // Draw the reticle in 3D for head tracking
 156 void draw_3d_reticle(fix eye_offset)
 157 {
 158         g3s_point       reticle_points[4];
 159         g3s_uvl         uvl[4];
 160         g3s_point       *pointlist[4];
 161         int                     i;
 162         vms_vector v1, v2;
 163         grs_canvas *saved_canvas;
 164         int saved_interp_method;
 165
 166 //      if (!Use_player_head_angles) return;
 167
 168         for (i=0; i<4; i++ )    {
 169                 pointlist[i] = &reticle_points[i];
 170                 uvl[i].l = MAX_LIGHT;
 171         }
 172         uvl[0].u = 0; uvl[0].v = 0;
 173         uvl[1].u = F1_0; uvl[1].v = 0;
 174         uvl[2].u = F1_0; uvl[2].v = F1_0;
 175         uvl[3].u = 0; uvl[3].v = F1_0;
 176
 177         vm_vec_scale_add( &v1, &Viewer->pos, &Viewer->orient.fvec, F1_0*4 );
 178         vm_vec_scale_add2(&v1,&Viewer->orient.rvec,eye_offset);
 179
 180         vm_vec_scale_add( &v2, &v1, &Viewer->orient.rvec, -F1_0*1 );
 181         vm_vec_scale_add2( &v2, &Viewer->orient.uvec, F1_0*1 );
 182         g3_rotate_point(&reticle_points[0],&v2);
 183
 184         vm_vec_scale_add( &v2, &v1, &Viewer->orient.rvec, +F1_0*1 );
 185         vm_vec_scale_add2( &v2, &Viewer->orient.uvec, F1_0*1 );
 186         g3_rotate_point(&reticle_points[1],&v2);
 187
 188         vm_vec_scale_add( &v2, &v1, &Viewer->orient.rvec, +F1_0*1 );
 189         vm_vec_scale_add2( &v2, &Viewer->orient.uvec, -F1_0*1 );
 190         g3_rotate_point(&reticle_points[2],&v2);
 191
 192         vm_vec_scale_add( &v2, &v1, &Viewer->orient.rvec, -F1_0*1 );
 193         vm_vec_scale_add2( &v2, &Viewer->orient.uvec, -F1_0*1 );
 194         g3_rotate_point(&reticle_points[3],&v2);
 195
 196         if ( reticle_canvas == NULL )   {
 197                 reticle_canvas = gr_create_canvas(64,64);
 198                 if ( !reticle_canvas )
 199                         Error( "Couldn't malloc reticle_canvas" );
 200                 atexit( free_reticle_canvas );
 201                 reticle_canvas->cv_bitmap.bm_handle = 0;
 202                 reticle_canvas->cv_bitmap.bm_flags = BM_FLAG_TRANSPARENT;
 203         }
 204
 205         saved_canvas = grd_curcanv;
 206         gr_set_current_canvas(reticle_canvas);
 207         gr_clear_canvas( TRANSPARENCY_COLOR );          // Clear to Xparent
 208         show_reticle(1);
 209         gr_set_current_canvas(saved_canvas);
 210
 211         saved_interp_method=Interpolation_method;
 212         Interpolation_method    = 3;            // The best, albiet slowest.
 213         g3_draw_tmap(4,pointlist,uvl,&reticle_canvas->cv_bitmap);
 214         Interpolation_method    = saved_interp_method;
 215 }
 216
 217
 218 extern fix Seismic_tremor_magnitude;
 219
 220 fix flash_scale;
 221
 222 #define FLASH_CYCLE_RATE f1_0
 223
 224 fix Flash_rate = FLASH_CYCLE_RATE;
 225
 226 //cycle the flashing light for when mine destroyed
 227 void flash_frame()
 228 {
 229         static fixang flash_ang=0;
 230
 231         if (!Control_center_destroyed && !Seismic_tremor_magnitude)
 232                 return;
 233
 234         if (Endlevel_sequence)
 235                 return;
 236
 237         if (PaletteBlueAdd > 10 )               //whiting out
 238                 return;
 239
 240 //      flash_ang += fixmul(FLASH_CYCLE_RATE,FrameTime);
 241         if (Seismic_tremor_magnitude) {
 242                 fix     added_flash;
 243
 244                 added_flash = abs(Seismic_tremor_magnitude);
 245                 if (added_flash < F1_0)
 246                         added_flash *= 16;
 247
 248                 flash_ang += fixmul(Flash_rate, fixmul(FrameTime, added_flash+F1_0));
 249                 fix_fastsincos(flash_ang,&flash_scale,NULL);
 250                 flash_scale = (flash_scale + F1_0*3)/4; //      gets in range 0.5 to 1.0
 251         } else {
 252                 flash_ang += fixmul(Flash_rate,FrameTime);
 253                 fix_fastsincos(flash_ang,&flash_scale,NULL);
 254                 flash_scale = (flash_scale + f1_0)/2;
 255                 if (Difficulty_level == 0)
 256                         flash_scale = (flash_scale+F1_0*3)/4;
 257         }
 258
 259
 260 }
 261
 262 // ----------------------------------------------------------------------------
 263 //      Render a face.
 264 //      It would be nice to not have to pass in segnum and sidenum, but
 265 //      they are used for our hideously hacked in headlight system.
 266 //      vp is a pointer to vertex ids.
 267 //      tmap1, tmap2 are texture map ids.  tmap2 is the pasty one.
 268 void render_face(int segnum, int sidenum, int nv, short *vp, int tmap1, int tmap2, uvl *uvlp, int wid_flags)
 269 {
 270         // -- Using new headlight system...fix                  face_light;
 271         grs_bitmap  *bm;
 272 #ifdef OGL
 273         grs_bitmap  *bm2 = NULL;
 274 #endif
 275
 276         fix                     reflect;
 277         g3s_uvl                 uvl_copy[8];
 278         int                     i;
 279         g3s_point               *pointlist[8];
 280
 281         Assert(nv <= 8);
 282
 283         for (i=0; i<nv; i++) {
 284                 uvl_copy[i].u = uvlp[i].u;
 285                 uvl_copy[i].v = uvlp[i].v;
 286                 uvl_copy[i].l = uvlp[i].l;
 287                 pointlist[i] = &Segment_points[vp[i]];
 288         }
 289
 290         //handle cloaked walls
 291         if (wid_flags & WID_CLOAKED_FLAG) {
 292                 int wall_num = Segments[segnum].sides[sidenum].wall_num;
 293                 Assert(wall_num != -1);
 294                 Gr_scanline_darkening_level = Walls[wall_num].cloak_value;
 295                 gr_setcolor(BM_XRGB(0, 0, 0));  // set to black (matters for s3)
 296
 297                 g3_draw_poly(nv, pointlist);    // draw as flat poly
 298
 299                 Gr_scanline_darkening_level = GR_FADE_LEVELS;
 300
 301                 return;
 302         }
 303
 304         // -- Using new headlight system...face_light = -vm_vec_dot(&Viewer->orient.fvec,norm);
 305
 306         if (tmap1 >= NumTextures) {
 307                 mprintf((0,"Invalid tmap number %d, NumTextures=%d, changing to 0\n",tmap1,NumTextures));
 308
 309         #ifndef RELEASE
 310                 Int3();
 311         #endif
 312
 313                 Segments[segnum].sides[sidenum].tmap_num = 0;
 314         }
 315
 316 #ifdef OGL
 317         if (ogl_alttexmerge){
 318                 PIGGY_PAGE_IN(Textures[tmap1]);
 319                 bm = &GameBitmaps[Textures[tmap1].index];
 320                 if (tmap2){
 321                         PIGGY_PAGE_IN(Textures[tmap2&0x3FFF]);
 322                         bm2 = &GameBitmaps[Textures[tmap2&0x3FFF].index];
 323                 }
 324                 if (!OGL_SUPER_TRANSPARENT_OK && bm2 && (bm2->bm_flags & BM_FLAG_SUPER_TRANSPARENT))
 325                 {
 326                         bm = texmerge_get_cached_bitmap( tmap1, tmap2 );
 327                         bm2 = NULL;
 328                 }
 329         } else
 330 #endif
 331
 332                 // New code for overlapping textures...
 333                 if (tmap2 != 0) {
 334                         bm = texmerge_get_cached_bitmap( tmap1, tmap2 );
 335                 } else {
 336                         bm = &GameBitmaps[Textures[tmap1].index];
 337                         PIGGY_PAGE_IN(Textures[tmap1]);
 338                 }
 339
 340         Assert( !(bm->bm_flags & BM_FLAG_PAGED_OUT) );
 341
 342         //reflect = fl2f((1.0-TmapInfo[p->tmap_num].reflect)/2.0 + 0.5);
 343         //reflect = fl2f((1.0-TmapInfo[p->tmap_num].reflect));
 344
 345         reflect = Face_reflectivity;            // f1_0;        //until we figure this stuff out...
 346
 347         //set light values for each vertex & build pointlist
 348         {
 349                 int i;
 350
 351                 // -- Using new headlight system...face_light = fixmul(face_light,reflect);
 352
 353                 for (i=0;i<nv;i++) {
 354
 355                         //the uvl struct has static light already in it
 356
 357                         //scale static light for destruction effect
 358                         if (Control_center_destroyed || Seismic_tremor_magnitude)       //make lights flash
 359                                 uvl_copy[i].l = fixmul(flash_scale,uvl_copy[i].l);
 360
 361                         //add in dynamic light (from explosions, etc.)
 362                         uvl_copy[i].l += Dynamic_light[vp[i]];
 363
 364                         //add in light from player's headlight
 365                         // -- Using new headlight system...uvl_copy[i].l += compute_headlight_light(&Segment_points[vp[i]].p3_vec,face_light);
 366
 367                         //saturate at max value
 368                         if (uvl_copy[i].l > MAX_LIGHT)
 369                                 uvl_copy[i].l = MAX_LIGHT;
 370
 371                 }
 372         }
 373
 374 #ifdef EDITOR
 375         if ((Render_only_bottom) && (sidenum == WBOTTOM))
 376                 g3_draw_tmap(nv,pointlist,uvl_copy,&GameBitmaps[Textures[Bottom_bitmap_num].index]);
 377         else
 378 #endif
 379
 380 #ifdef OGL
 381                 if (bm2){
 382                         g3_draw_tmap_2(nv,pointlist,uvl_copy,bm,bm2,((tmap2&0xC000)>>14) & 3);
 383                 }else
 384 #endif
 385                         g3_draw_tmap(nv,pointlist,uvl_copy,bm);
 386
 387 #ifndef NDEBUG
 388         if (Outline_mode) draw_outline(nv, pointlist);
 389 #endif
 390 }
 391
 392 #ifdef EDITOR
 393 // ----------------------------------------------------------------------------
 394 //      Only called if editor active.
 395 //      Used to determine which face was clicked on.
 396 void check_face(int segnum, int sidenum, int facenum, int nv, short *vp, int tmap1, int tmap2, uvl *uvlp)
 397 {
 398         int     i;
 399
 400         if (_search_mode) {
 401                 int save_lighting;
 402                 grs_bitmap *bm;
 403                 g3s_uvl uvl_copy[8];
 404                 g3s_point *pointlist[4];
 405
 406                 if (tmap2 > 0 )
 407                         bm = texmerge_get_cached_bitmap( tmap1, tmap2 );
 408                 else
 409                         bm = &GameBitmaps[Textures[tmap1].index];
 410
 411                 for (i=0; i<nv; i++) {
 412                         uvl_copy[i].u = uvlp[i].u;
 413                         uvl_copy[i].v = uvlp[i].v;
 414                         uvl_copy[i].l = uvlp[i].l;
 415                         pointlist[i] = &Segment_points[vp[i]];
 416                 }
 417
 418                 gr_setcolor(0);
 419                 gr_pixel(_search_x,_search_y);  //set our search pixel to color zero
 420                 gr_setcolor(1);                                 //and render in color one
 421  save_lighting = Lighting_on;
 422  Lighting_on = 2;
 423                 //g3_draw_poly(nv,vp);
 424                 g3_draw_tmap(nv,pointlist, uvl_copy, bm);
 425  Lighting_on = save_lighting;
 426
 427                 if (gr_ugpixel(&grd_curcanv->cv_bitmap,_search_x,_search_y) == 1) {
 428                         found_seg = segnum;
 429                         found_side = sidenum;
 430                         found_face = facenum;
 431                 }
 432         }
 433 }
 434 #endif
 435
 436 fix     Tulate_min_dot = (F1_0/4);
 437 //--unused-- fix        Tulate_min_ratio = (2*F1_0);
 438 fix     Min_n0_n1_dot   = (F1_0*15/16);
 439
 440 extern int contains_flare(segment *segp, int sidenum);
 441 extern fix      Obj_light_xlate[16];
 442
 443 // -----------------------------------------------------------------------------------
 444 //      Render a side.
 445 //      Check for normal facing.  If so, render faces on side dictated by sidep->type.
 446 void render_side(segment *segp, int sidenum)
 447 {
 448         short                   vertnum_list[4];
 449         side                    *sidep = &segp->sides[sidenum];
 450         vms_vector      tvec;
 451         fix                     v_dot_n0, v_dot_n1;
 452         uvl                     temp_uvls[3];
 453         fix                     min_dot, max_dot;
 454         vms_vector  normals[2];
 455         int                     wid_flags;
 456
 457
 458         wid_flags = WALL_IS_DOORWAY(segp,sidenum);
 459
 460         if (!(wid_flags & WID_RENDER_FLAG))             //if (WALL_IS_DOORWAY(segp, sidenum) == WID_NO_WALL)
 461                 return;
 462
 463 #ifdef COMPACT_SEGS
 464         get_side_normals(segp, sidenum, &normals[0], &normals[1] );
 465 #else
 466         normals[0] = segp->sides[sidenum].normals[0];
 467         normals[1] = segp->sides[sidenum].normals[1];
 468 #endif
 469
 470         //      ========== Mark: Here is the change...beginning here: ==========
 471
 472         if (sidep->type == SIDE_IS_QUAD) {
 473
 474                 vm_vec_sub(&tvec, &Viewer_eye, &Vertices[segp->verts[Side_to_verts[sidenum][0]]]);
 475
 476                 // -- Old, slow way --  //      Regardless of whether this side is comprised of a single quad, or two triangles, we need to know one normal, so
 477                 // -- Old, slow way --  //      deal with it, get the dot product.
 478                 // -- Old, slow way --  if (sidep->type == SIDE_IS_TRI_13)
 479                 // -- Old, slow way --          vm_vec_normalized_dir(&tvec, &Viewer_eye, &Vertices[segp->verts[Side_to_verts[sidenum][1]]]);
 480                 // -- Old, slow way --  else
 481                 // -- Old, slow way --          vm_vec_normalized_dir(&tvec, &Viewer_eye, &Vertices[segp->verts[Side_to_verts[sidenum][0]]]);
 482
 483                 get_side_verts(vertnum_list, SEGMENT_NUMBER(segp), sidenum);
 484                 v_dot_n0 = vm_vec_dot(&tvec, &normals[0]);
 485
 486 // -- flare creates point -- {
 487 // -- flare creates point --    int     flare_index;
 488 // -- flare creates point --
 489 // -- flare creates point --    flare_index = contains_flare(segp, sidenum);
 490 // -- flare creates point --
 491 // -- flare creates point --    if (flare_index != -1) {
 492 // -- flare creates point --            int                     tri;
 493 // -- flare creates point --            fix                     u, v, l;
 494 // -- flare creates point --            vms_vector      *hit_point;
 495 // -- flare creates point --            short                   vertnum_list[4];
 496 // -- flare creates point --
 497 // -- flare creates point --            hit_point = &Objects[flare_index].pos;
 498 // -- flare creates point --
 499 // -- flare creates point --            find_hitpoint_uv( &u, &v, &l, hit_point, segp, sidenum, 0);     //      last parm means always use face 0.
 500 // -- flare creates point --
 501 // -- flare creates point --            get_side_verts(vertnum_list, SEGMENT_NUMBER(segp), sidenum);
 502 // -- flare creates point --
 503 // -- flare creates point --            g3_rotate_point(&Segment_points[MAX_VERTICES-1], hit_point);
 504 // -- flare creates point --
 505 // -- flare creates point --            for (tri=0; tri<4; tri++) {
 506 // -- flare creates point --                    short   tri_verts[3];
 507 // -- flare creates point --                    uvl     tri_uvls[3];
 508 // -- flare creates point --
 509 // -- flare creates point --                    tri_verts[0] = vertnum_list[tri];
 510 // -- flare creates point --                    tri_verts[1] = vertnum_list[(tri+1) % 4];
 511 // -- flare creates point --                    tri_verts[2] = MAX_VERTICES-1;
 512 // -- flare creates point --
 513 // -- flare creates point --                    tri_uvls[0] = sidep->uvls[tri];
 514 // -- flare creates point --                    tri_uvls[1] = sidep->uvls[(tri+1)%4];
 515 // -- flare creates point --                    tri_uvls[2].u = u;
 516 // -- flare creates point --                    tri_uvls[2].v = v;
 517 // -- flare creates point --                    tri_uvls[2].l = F1_0;
 518 // -- flare creates point --
 519 // -- flare creates point --                    render_face(SEGMENT_NUMBER(segp), sidenum, 3, tri_verts, sidep->tmap_num, sidep->tmap_num2, tri_uvls, &normals[0]);
 520 // -- flare creates point --            }
 521 // -- flare creates point --
 522 // -- flare creates point --    return;
 523 // -- flare creates point --    }
 524 // -- flare creates point -- }
 525
 526                 if (v_dot_n0 >= 0) {
 527                         render_face(SEGMENT_NUMBER(segp), sidenum, 4, vertnum_list, sidep->tmap_num, sidep->tmap_num2, sidep->uvls, wid_flags);
 528                         #ifdef EDITOR
 529                         check_face(SEGMENT_NUMBER(segp), sidenum, 0, 4, vertnum_list, sidep->tmap_num, sidep->tmap_num2, sidep->uvls);
 530                         #endif
 531                 }
 532         } else {
 533                 //      Regardless of whether this side is comprised of a single quad, or two triangles, we need to know one normal, so
 534                 //      deal with it, get the dot product.
 535                 if (sidep->type == SIDE_IS_TRI_13)
 536                         vm_vec_normalized_dir_quick(&tvec, &Viewer_eye, &Vertices[segp->verts[Side_to_verts[sidenum][1]]]);
 537                 else
 538                         vm_vec_normalized_dir_quick(&tvec, &Viewer_eye, &Vertices[segp->verts[Side_to_verts[sidenum][0]]]);
 539
 540                 get_side_verts(vertnum_list, SEGMENT_NUMBER(segp), sidenum);
 541
 542                 v_dot_n0 = vm_vec_dot(&tvec, &normals[0]);
 543
 544                 //      ========== Mark: The change ends here. ==========
 545
 546                 //      Although this side has been triangulated, because it is not planar, see if it is acceptable
 547                 //      to render it as a single quadrilateral.  This is a function of how far away the viewer is, how non-planar
 548                 //      the face is, how normal to the surfaces the view is.
 549                 //      Now, if both dot products are close to 1.0, then render two triangles as a single quad.
 550                 v_dot_n1 = vm_vec_dot(&tvec, &normals[1]);
 551
 552                 if (v_dot_n0 < v_dot_n1) {
 553                         min_dot = v_dot_n0;
 554                         max_dot = v_dot_n1;
 555                 } else {
 556                         min_dot = v_dot_n1;
 557                         max_dot = v_dot_n0;
 558                 }
 559
 560                 //      Determine whether to detriangulate side: (speed hack, assumes Tulate_min_ratio == F1_0*2, should fixmul(min_dot, Tulate_min_ratio))
 561                 if (Detriangulation_on && ((min_dot+F1_0/256 > max_dot) || ((Viewer->segnum != SEGMENT_NUMBER(segp)) && (min_dot > Tulate_min_dot) && (max_dot < min_dot*2)))) {
 562                         fix     n0_dot_n1;
 563
 564                         //      The other detriangulation code doesn't deal well with badly non-planar sides.
 565                         n0_dot_n1 = vm_vec_dot(&normals[0], &normals[1]);
 566                         if (n0_dot_n1 < Min_n0_n1_dot)
 567                                 goto im_so_ashamed;
 568
 569                         render_face(SEGMENT_NUMBER(segp), sidenum, 4, vertnum_list, sidep->tmap_num, sidep->tmap_num2, sidep->uvls, wid_flags);
 570                         #ifdef EDITOR
 571                         check_face(SEGMENT_NUMBER(segp), sidenum, 0, 4, vertnum_list, sidep->tmap_num, sidep->tmap_num2, sidep->uvls);
 572                         #endif
 573                 } else {
 574 im_so_ashamed: ;
 575                         if (sidep->type == SIDE_IS_TRI_02) {
 576                                 if (v_dot_n0 >= 0) {
 577                                         render_face(SEGMENT_NUMBER(segp), sidenum, 3, vertnum_list, sidep->tmap_num, sidep->tmap_num2, sidep->uvls, wid_flags);
 578                                         #ifdef EDITOR
 579                                         check_face(SEGMENT_NUMBER(segp), sidenum, 0, 3, vertnum_list, sidep->tmap_num, sidep->tmap_num2, sidep->uvls);
 580                                         #endif
 581                                 }
 582
 583                                 if (v_dot_n1 >= 0) {
 584                                         temp_uvls[0] = sidep->uvls[0];          temp_uvls[1] = sidep->uvls[2];          temp_uvls[2] = sidep->uvls[3];
 585                                         vertnum_list[1] = vertnum_list[2];      vertnum_list[2] = vertnum_list[3];      // want to render from vertices 0, 2, 3 on side
 586                                         render_face(SEGMENT_NUMBER(segp), sidenum, 3, &vertnum_list[0], sidep->tmap_num, sidep->tmap_num2, temp_uvls, wid_flags);
 587                                         #ifdef EDITOR
 588                                         check_face(SEGMENT_NUMBER(segp), sidenum, 1, 3, vertnum_list, sidep->tmap_num, sidep->tmap_num2, sidep->uvls);
 589                                         #endif
 590                                 }
 591                         } else if (sidep->type ==  SIDE_IS_TRI_13) {
 592                                 if (v_dot_n1 >= 0) {
 593                                         render_face(SEGMENT_NUMBER(segp), sidenum, 3, &vertnum_list[1], sidep->tmap_num, sidep->tmap_num2, &sidep->uvls[1], wid_flags); // rendering 1,2,3, so just skip 0
 594                                         #ifdef EDITOR
 595                                         check_face(SEGMENT_NUMBER(segp), sidenum, 1, 3, &vertnum_list[1], sidep->tmap_num, sidep->tmap_num2, sidep->uvls);
 596                                         #endif
 597                                 }
 598
 599                                 if (v_dot_n0 >= 0) {
 600                                         temp_uvls[0] = sidep->uvls[0];          temp_uvls[1] = sidep->uvls[1];          temp_uvls[2] = sidep->uvls[3];
 601                                         vertnum_list[2] = vertnum_list[3];              // want to render from vertices 0,1,3
 602                                         render_face(SEGMENT_NUMBER(segp), sidenum, 3, vertnum_list, sidep->tmap_num, sidep->tmap_num2, temp_uvls, wid_flags);
 603                                         #ifdef EDITOR
 604                                         check_face(SEGMENT_NUMBER(segp), sidenum, 0, 3, vertnum_list, sidep->tmap_num, sidep->tmap_num2, sidep->uvls);
 605                                         #endif
 606                                 }
 607
 608                         } else
 609                                 Error("Illegal side type in render_side, type = %i, segment # = %i, side # = %i\n", sidep->type, SEGMENT_NUMBER(segp), sidenum);
 610                 }
 611         }
 612
 613 }
 614
 615 #ifdef EDITOR
 616 void render_object_search(object *obj)
 617 {
 618         int changed=0;
 619
 620         //note that we draw each pixel object twice, since we cannot control
 621         //what color the object draws in, so we try color 0, then color 1,
 622         //in case the object itself is rendering color 0
 623
 624         gr_setcolor(0);
 625         gr_pixel(_search_x,_search_y);  //set our search pixel to color zero
 626         render_object(obj);
 627         if (gr_ugpixel(&grd_curcanv->cv_bitmap,_search_x,_search_y) != 0)
 628                 changed=1;
 629
 630         gr_setcolor(1);
 631         gr_pixel(_search_x,_search_y);  //set our search pixel to color zero
 632         render_object(obj);
 633         if (gr_ugpixel(&grd_curcanv->cv_bitmap,_search_x,_search_y) != 1)
 634                 changed=1;
 635
 636         if (changed) {
 637                 if (obj->segnum != -1)
 638                         Cursegp = &Segments[obj->segnum];
 639                 found_seg = -(OBJECT_NUMBER(obj)+1);
 640         }
 641 }
 642 #endif
 643
 644 extern ubyte DemoDoingRight,DemoDoingLeft;
 645
 646 void do_render_object(int objnum, int window_num)
 647 {
 648         #ifdef EDITOR
 649         int save_3d_outline=0;
 650         #endif
 651         object *obj = &Objects[objnum];
 652         int count = 0;
 653         int n;
 654
 655         Assert(objnum < MAX_OBJECTS);
 656
 657         #ifndef NDEBUG
 658         if (object_rendered[objnum]) {          //already rendered this...
 659                 Int3();         //get Matt!!!
 660                 return;
 661         }
 662
 663         object_rendered[objnum] = 1;
 664         #endif
 665
 666    if (Newdemo_state==ND_STATE_PLAYBACK)
 667          {
 668           if ((DemoDoingLeft==6 || DemoDoingRight==6) && Objects[objnum].type==OBJ_PLAYER)
 669                 {
 670                         // A nice fat hack: keeps the player ship from showing up in the
 671                         // small extra view when guiding a missile in the big window
 672
 673                         mprintf ((0,"Returning from render_object prematurely...\n"));
 674                         return;
 675                 }
 676          }
 677
 678         //      Added by MK on 09/07/94 (at about 5:28 pm, CDT, on a beautiful, sunny late summer day!) so
 679         //      that the guided missile system will know what objects to look at.
 680         //      I didn't know we had guided missiles before the release of D1. --MK
 681         if ((Objects[objnum].type == OBJ_ROBOT) || (Objects[objnum].type == OBJ_PLAYER)) {
 682                 //Assert(Window_rendered_data[window_num].rendered_objects < MAX_RENDERED_OBJECTS);
 683                 //      This peculiar piece of code makes us keep track of the most recently rendered objects, which
 684                 //      are probably the higher priority objects, without overflowing the buffer
 685                 if (Window_rendered_data[window_num].num_objects >= MAX_RENDERED_OBJECTS) {
 686                         Int3();
 687                         Window_rendered_data[window_num].num_objects /= 2;
 688                 }
 689                 Window_rendered_data[window_num].rendered_objects[Window_rendered_data[window_num].num_objects++] = objnum;
 690         }
 691
 692         if ((count++ > MAX_OBJECTS) || (obj->next == objnum)) {
 693                 Int3();                                 // infinite loop detected
 694                 obj->next = -1;         // won't this clean things up?
 695                 return;                                 // get out of this infinite loop!
 696         }
 697
 698                 //g3_draw_object(obj->class_id,&obj->pos,&obj->orient,obj->size);
 699
 700         //check for editor object
 701
 702         #ifdef EDITOR
 703         if (Function_mode==FMODE_EDITOR && objnum==Cur_object_index) {
 704                 save_3d_outline = g3d_interp_outline;
 705                 g3d_interp_outline=1;
 706         }
 707         #endif
 708
 709         #ifdef EDITOR
 710         if (_search_mode)
 711                 render_object_search(obj);
 712         else
 713         #endif
 714                 //NOTE LINK TO ABOVE
 715                 render_object(obj);
 716
 717         for (n=obj->attached_obj;n!=-1;n=Objects[n].ctype.expl_info.next_attach) {
 718
 719                 Assert(Objects[n].type == OBJ_FIREBALL);
 720                 Assert(Objects[n].control_type == CT_EXPLOSION);
 721                 Assert(Objects[n].flags & OF_ATTACHED);
 722
 723                 render_object(&Objects[n]);
 724         }
 725
 726
 727         #ifdef EDITOR
 728         if (Function_mode==FMODE_EDITOR && objnum==Cur_object_index)
 729                 g3d_interp_outline = save_3d_outline;
 730         #endif
 731
 732
 733         //DEBUG mprintf( (0, "%d ", objnum ));
 734
 735 }
 736
 737 #ifndef NDEBUG
 738 int     draw_boxes=0;
 739 int window_check=1,draw_edges=0,new_seg_sorting=1,pre_draw_segs=0;
 740 int no_migrate_segs=1,migrate_objects=1,behind_check=1;
 741 int check_window_check=0;
 742 #else
 743 #define draw_boxes                      0
 744 #define window_check                    1
 745 #define draw_edges                      0
 746 #define new_seg_sorting         1
 747 #define pre_draw_segs           0
 748 #define no_migrate_segs         1
 749 #define migrate_objects         1
 750 #define behind_check                    1
 751 #define check_window_check      0
 752 #endif
 753
 754 //increment counter for checking if points rotated
 755 //This must be called at the start of the frame if rotate_list() will be used
 756 void render_start_frame()
 757 {
 758         RL_framecount++;
 759
 760         if (RL_framecount==0) {         //wrap!
 761
 762                 memset(Rotated_last,0,sizeof(Rotated_last));            //clear all to zero
 763                 RL_framecount=1;                                                                                        //and set this frame to 1
 764         }
 765 }
 766
 767 //Given a lit of point numbers, rotate any that haven't been rotated this frame
 768 g3s_codes rotate_list(int nv,short *pointnumlist)
 769 {
 770         int i,pnum;
 771         g3s_point *pnt;
 772         g3s_codes cc;
 773
 774         cc.and = 0xff;  cc.or = 0;
 775
 776         for (i=0;i<nv;i++) {
 777
 778                 pnum = pointnumlist[i];
 779
 780                 pnt = &Segment_points[pnum];
 781
 782                 if (Rotated_last[pnum] != RL_framecount) {
 783
 784                         g3_rotate_point(pnt,&Vertices[pnum]);
 785
 786                         Rotated_last[pnum] = RL_framecount;
 787                 }
 788
 789                 cc.and &= pnt->p3_codes;
 790                 cc.or  |= pnt->p3_codes;
 791         }
 792
 793         return cc;
 794
 795 }
 796
 797 //Given a lit of point numbers, project any that haven't been projected
 798 void project_list(int nv,short *pointnumlist)
 799 {
 800         int i,pnum;
 801
 802         for (i=0;i<nv;i++) {
 803
 804                 pnum = pointnumlist[i];
 805
 806                 if (!(Segment_points[pnum].p3_flags & PF_PROJECTED))
 807
 808                         g3_project_point(&Segment_points[pnum]);
 809
 810         }
 811 }
 812
 813
 814 // -----------------------------------------------------------------------------------
 815 void render_segment(int segnum, int window_num)
 816 {
 817         segment         *seg = &Segments[segnum];
 818         g3s_codes       cc;
 819         int                     sn;
 820
 821         Assert(segnum!=-1 && segnum<=Highest_segment_index);
 822
 823         cc=rotate_list(8,seg->verts);
 824
 825         if (! cc.and) {         //all off screen?
 826
 827 //mprintf( (0, "!"));
 828                 //DEBUG mprintf( (0, "[Segment %d: ", segnum ));
 829
 830                 // set_segment_local_light_value(segnum,INITIAL_LOCAL_LIGHT);
 831
 832                 if (Viewer->type!=OBJ_ROBOT)
 833                         Automap_visited[segnum]=1;
 834
 835                 for (sn=0; sn<MAX_SIDES_PER_SEGMENT; sn++)
 836                         render_side(seg, sn);
 837         }
 838
 839         //draw any objects that happen to be in this segment
 840
 841         //sort objects!
 842         //object_sort_segment_objects( seg );
 843
 844         #ifndef NDEBUG
 845         if (!migrate_objects) {
 846                 int objnum;
 847                 for (objnum=seg->objects;objnum!=-1;objnum=Objects[objnum].next)
 848                         do_render_object(objnum, window_num);
 849         }
 850         #endif
 851
 852         //DEBUG mprintf( (0, "]\n", segnum ));
 853
 854 }
 855
 856 // ----- This used to be called when Show_only_curside was set.
 857 // ----- It is wholly and superiorly replaced by render_side.
 858 // -- //render one side of one segment
 859 // -- void render_seg_side(segment *seg,int _side)
 860 // -- {
 861 // --   g3s_codes cc;
 862 // --   short vertnum_list[4];
 863 // --
 864 // --   cc=g3_rotate_list(8,&seg->verts);
 865 // --
 866 // --   if (! cc.and) {         //all off screen?
 867 // --           int fn,pn,i;
 868 // --           side *s;
 869 // --           face *f;
 870 // --           poly *p;
 871 // --
 872 // --           s=&seg->sides[_side];
 873 // --
 874 // --           for (f=s->faces,fn=s->num_faces;fn;fn--,f++)
 875 // --                   for (p=f->polys,pn=f->num_polys;pn;pn--,p++) {
 876 // --                           grs_bitmap *tmap;
 877 // --
 878 // --                           for (i=0;i<p->num_vertices;i++) vertnum_list[i] = seg->verts[p->verts[i]];
 879 // --
 880 // --                           if (p->tmap_num >= NumTextures) {
 881 // --                                   Warning("Invalid tmap number %d, NumTextures=%d\n...Changing in poly structure to tmap 0",p->tmap_num,NumTextures);
 882 // --                                   p->tmap_num = 0;                //change it permanantly
 883 // --                           }
 884 // --
 885 // --                           tmap = Textures[p->tmap_num];
 886 // --
 887 // --                           g3_check_and_draw_tmap(p->num_vertices,vertnum_list,(g3s_uvl *) &p->uvls,tmap,&f->normal);
 888 // --
 889 // --                           if (Outline_mode) draw_outline(p->num_vertices,vertnum_list);
 890 // --                   }
 891 // --           }
 892 // --
 893 // -- }
 894
 895 #define CROSS_WIDTH  i2f(8)
 896 #define CROSS_HEIGHT i2f(8)
 897
 898 #ifndef NDEBUG
 899
 900 //draw outline for curside
 901 void outline_seg_side(segment *seg,int _side,int edge,int vert)
 902 {
 903         g3s_codes cc;
 904
 905         cc=rotate_list(8,seg->verts);
 906
 907         if (! cc.and) {         //all off screen?
 908                 side *s;
 909                 g3s_point *pnt;
 910
 911                 s=&seg->sides[_side];
 912
 913                 //render curedge of curside of curseg in green
 914
 915                 gr_setcolor(BM_XRGB(0,63,0));
 916                 g3_draw_line(&Segment_points[seg->verts[Side_to_verts[_side][edge]]],&Segment_points[seg->verts[Side_to_verts[_side][(edge+1)%4]]]);
 917
 918                 //draw a little cross at the current vert
 919
 920                 pnt = &Segment_points[seg->verts[Side_to_verts[_side][vert]]];
 921
 922                 g3_project_point(pnt);          //make sure projected
 923
 924 //              gr_setcolor(BM_XRGB(0,0,63));
 925 //              gr_line(pnt->p3_sx-CROSS_WIDTH,pnt->p3_sy,pnt->p3_sx+CROSS_WIDTH,pnt->p3_sy);
 926 //              gr_line(pnt->p3_sx,pnt->p3_sy-CROSS_HEIGHT,pnt->p3_sx,pnt->p3_sy+CROSS_HEIGHT);
 927
 928                 gr_line(pnt->p3_sx-CROSS_WIDTH,pnt->p3_sy,pnt->p3_sx,pnt->p3_sy-CROSS_HEIGHT);
 929                 gr_line(pnt->p3_sx,pnt->p3_sy-CROSS_HEIGHT,pnt->p3_sx+CROSS_WIDTH,pnt->p3_sy);
 930                 gr_line(pnt->p3_sx+CROSS_WIDTH,pnt->p3_sy,pnt->p3_sx,pnt->p3_sy+CROSS_HEIGHT);
 931                 gr_line(pnt->p3_sx,pnt->p3_sy+CROSS_HEIGHT,pnt->p3_sx-CROSS_WIDTH,pnt->p3_sy);
 932         }
 933 }
 934
 935 #endif
 936
 937 #if 0           //this stuff could probably just be deleted
 938
 939 #define DEFAULT_PERSPECTIVE_DEPTH 6
 940
 941 int Perspective_depth=DEFAULT_PERSPECTIVE_DEPTH;        //how many levels deep to render in perspective
 942
 943 int inc_perspective_depth(void)
 944 {
 945         return ++Perspective_depth;
 946
 947 }
 948
 949 int dec_perspective_depth(void)
 950 {
 951         return Perspective_depth==1?Perspective_depth:--Perspective_depth;
 952
 953 }
 954
 955 int reset_perspective_depth(void)
 956 {
 957         return Perspective_depth = DEFAULT_PERSPECTIVE_DEPTH;
 958
 959 }
 960 #endif
 961
 962 typedef struct window {
 963         short left,top,right,bot;
 964 } window;
 965
 966 ubyte code_window_point(fix x,fix y,window *w)
 967 {
 968         ubyte code=0;
 969
 970         if (x <= w->left)  code |= 1;
 971         if (x >= w->right) code |= 2;
 972
 973         if (y <= w->top) code |= 4;
 974         if (y >= w->bot) code |= 8;
 975
 976         return code;
 977 }
 978
 979 #ifndef NDEBUG
 980 void draw_window_box(int color,short left,short top,short right,short bot)
 981 {
 982         short l,t,r,b;
 983
 984         gr_setcolor(color);
 985
 986         l=left; t=top; r=right; b=bot;
 987
 988         if ( r<0 || b<0 || l>=grd_curcanv->cv_bitmap.bm_w || (t>=grd_curcanv->cv_bitmap.bm_h && b>=grd_curcanv->cv_bitmap.bm_h))
 989                 return;
 990
 991         if (l<0) l=0;
 992         if (t<0) t=0;
 993         if (r>=grd_curcanv->cv_bitmap.bm_w) r=grd_curcanv->cv_bitmap.bm_w-1;
 994         if (b>=grd_curcanv->cv_bitmap.bm_h) b=grd_curcanv->cv_bitmap.bm_h-1;
 995
 996         gr_line(i2f(l),i2f(t),i2f(r),i2f(t));
 997         gr_line(i2f(r),i2f(t),i2f(r),i2f(b));
 998         gr_line(i2f(r),i2f(b),i2f(l),i2f(b));
 999         gr_line(i2f(l),i2f(b),i2f(l),i2f(t));
1000
1001 }
1002 #endif
1003
1004 int matt_find_connect_side(int seg0,int seg1);
1005
1006 #ifndef NDEBUG
1007 char visited2[MAX_SEGMENTS];
1008 #endif
1009
1010 unsigned char visited[MAX_SEGMENTS];
1011 short Render_list[MAX_RENDER_SEGS];
1012 short Seg_depth[MAX_RENDER_SEGS];               //depth for each seg in Render_list
1013 ubyte processed[MAX_RENDER_SEGS];               //whether each entry has been processed
1014 int     lcnt_save,scnt_save;
1015 //@@short *persp_ptr;
1016 short render_pos[MAX_SEGMENTS]; //where in render_list does this segment appear?
1017 //ubyte no_render_flag[MAX_RENDER_SEGS];
1018 window render_windows[MAX_RENDER_SEGS];
1019
1020 short render_obj_list[MAX_RENDER_SEGS+N_EXTRA_OBJ_LISTS][OBJS_PER_SEG];
1021
1022 //for objects
1023
1024
1025
1026 #define RED   BM_XRGB(63,0,0)
1027 #define WHITE BM_XRGB(63,63,63)
1028
1029 //Given two sides of segment, tell the two verts which form the
1030 //edge between them
1031 short Two_sides_to_edge[6][6][2] = {
1032         { {-1,-1}, {3,7}, {-1,-1}, {2,6}, {6,7}, {2,3} },
1033         { {3,7}, {-1,-1}, {0,4}, {-1,-1}, {4,7}, {0,3} },
1034         { {-1,-1}, {0,4}, {-1,-1}, {1,5}, {4,5}, {0,1} },
1035         { {2,6}, {-1,-1}, {1,5}, {-1,-1}, {5,6}, {1,2} },
1036         { {6,7}, {4,7}, {4,5}, {5,6}, {-1,-1}, {-1,-1} },
1037         { {2,3}, {0,3}, {0,1}, {1,2}, {-1,-1}, {-1,-1} }
1038 };
1039
1040 //given an edge specified by two verts, give the two sides on that edge
1041 int Edge_to_sides[8][8][2] = {
1042         { {-1,-1}, {2,5}, {-1,-1}, {1,5}, {1,2}, {-1,-1}, {-1,-1}, {-1,-1} },
1043         { {2,5}, {-1,-1}, {3,5}, {-1,-1}, {-1,-1}, {2,3}, {-1,-1}, {-1,-1} },
1044         { {-1,-1}, {3,5}, {-1,-1}, {0,5}, {-1,-1}, {-1,-1}, {0,3}, {-1,-1} },
1045         { {1,5}, {-1,-1}, {0,5}, {-1,-1}, {-1,-1}, {-1,-1}, {-1,-1}, {0,1} },
1046         { {1,2}, {-1,-1}, {-1,-1}, {-1,-1}, {-1,-1}, {2,4}, {-1,-1}, {1,4} },
1047         { {-1,-1}, {2,3}, {-1,-1}, {-1,-1}, {2,4}, {-1,-1}, {3,4}, {-1,-1} },
1048         { {-1,-1}, {-1,-1}, {0,3}, {-1,-1}, {-1,-1}, {3,4}, {-1,-1}, {0,4} },
1049         { {-1,-1}, {-1,-1}, {-1,-1}, {0,1}, {1,4}, {-1,-1}, {0,4}, {-1,-1} },
1050 };
1051
1052 //@@//perform simple check on tables
1053 //@@check_check()
1054 //@@{
1055 //@@    int i,j;
1056 //@@
1057 //@@    for (i=0;i<8;i++)
1058 //@@            for (j=0;j<8;j++)
1059 //@@                    Assert(Edge_to_sides[i][j][0] == Edge_to_sides[j][i][0] &&
1060 //@@                                    Edge_to_sides[i][j][1] == Edge_to_sides[j][i][1]);
1061 //@@
1062 //@@    for (i=0;i<6;i++)
1063 //@@            for (j=0;j<6;j++)
1064 //@@                    Assert(Two_sides_to_edge[i][j][0] == Two_sides_to_edge[j][i][0] &&
1065 //@@                                    Two_sides_to_edge[i][j][1] == Two_sides_to_edge[j][i][1]);
1066 //@@
1067 //@@
1068 //@@}
1069
1070
1071 //given an edge, tell what side is on that edge
1072 int find_seg_side(segment *seg,short *verts,int notside)
1073 {
1074         int i;
1075         int vv0=-1,vv1=-1;
1076         int side0,side1;
1077         int *eptr;
1078         int     v0,v1;
1079         short   *vp;
1080
1081 //@@    check_check();
1082
1083         v0 = verts[0];
1084         v1 = verts[1];
1085         vp = seg->verts;
1086
1087         for (i=0; i<8; i++) {
1088                 int svv = *vp++;        // seg->verts[i];
1089
1090                 if (vv0==-1 && svv == v0) {
1091                         vv0 = i;
1092                         if (vv1 != -1)
1093                                 break;
1094                 }
1095
1096                 if (vv1==-1 && svv == v1) {
1097                         vv1 = i;
1098                         if (vv0 != -1)
1099                                 break;
1100                 }
1101         }
1102
1103         Assert(vv0!=-1 && vv1!=-1);
1104
1105         eptr = Edge_to_sides[vv0][vv1];
1106
1107         side0 = eptr[0];
1108         side1 = eptr[1];
1109
1110         Assert(side0!=-1 && side1!=-1);
1111
1112         if (side0 != notside) {
1113                 Assert(side1==notside);
1114                 return side0;
1115         }
1116         else {
1117                 Assert(side0==notside);
1118                 return side1;
1119         }
1120
1121 }
1122
1123 //find the two segments that join a given seg though two sides, and
1124 //the sides of those segments the abut.
1125 int find_joining_side_norms(vms_vector *norm0_0,vms_vector *norm0_1,vms_vector *norm1_0,vms_vector *norm1_1,vms_vector **pnt0,vms_vector **pnt1,segment *seg,int s0,int s1)
1126 {
1127         segment *seg0,*seg1;
1128         short edge_verts[2];
1129         int notside0,notside1;
1130         int edgeside0,edgeside1;
1131
1132         Assert(s0!=-1 && s1!=-1);
1133
1134         seg0 = &Segments[seg->children[s0]];
1135         seg1 = &Segments[seg->children[s1]];
1136
1137         edge_verts[0] = seg->verts[Two_sides_to_edge[s0][s1][0]];
1138         edge_verts[1] = seg->verts[Two_sides_to_edge[s0][s1][1]];
1139
1140         Assert(edge_verts[0]!=-1 && edge_verts[1]!=-1);
1141
1142         notside0 = find_connect_side(seg,seg0);
1143         Assert(notside0 != -1);
1144         notside1 = find_connect_side(seg,seg1);
1145         Assert(notside1 != -1);
1146
1147         edgeside0 = find_seg_side(seg0,edge_verts,notside0);
1148         edgeside1 = find_seg_side(seg1,edge_verts,notside1);
1149
1150         //deal with the case where an edge is shared by more than two segments
1151
1152 //@@    if (IS_CHILD(seg0->children[edgeside0])) {
1153 //@@            segment *seg00;
1154 //@@            int notside00;
1155 //@@
1156 //@@            seg00 = &Segments[seg0->children[edgeside0]];
1157 //@@
1158 //@@            if (seg00 != seg1) {
1159 //@@
1160 //@@                    notside00 = find_connect_side(seg0,seg00);
1161 //@@                    Assert(notside00 != -1);
1162 //@@
1163 //@@                    edgeside0 = find_seg_side(seg00,edge_verts,notside00);
1164 //@@                    seg0 = seg00;
1165 //@@            }
1166 //@@
1167 //@@    }
1168 //@@
1169 //@@    if (IS_CHILD(seg1->children[edgeside1])) {
1170 //@@            segment *seg11;
1171 //@@            int notside11;
1172 //@@
1173 //@@            seg11 = &Segments[seg1->children[edgeside1]];
1174 //@@
1175 //@@            if (seg11 != seg0) {
1176 //@@                    notside11 = find_connect_side(seg1,seg11);
1177 //@@                    Assert(notside11 != -1);
1178 //@@
1179 //@@                    edgeside1 = find_seg_side(seg11,edge_verts,notside11);
1180 //@@                    seg1 = seg11;
1181 //@@            }
1182 //@@    }
1183
1184 //      if ( IS_CHILD(seg0->children[edgeside0]) ||
1185 //                IS_CHILD(seg1->children[edgeside1]))
1186 //              return 0;
1187
1188         #ifdef COMPACT_SEGS
1189                 get_side_normals(seg0, edgeside0, norm0_0, norm0_1 );
1190                 get_side_normals(seg1, edgeside1, norm1_0, norm1_1 );
1191         #else
1192                 *norm0_0 = seg0->sides[edgeside0].normals[0];
1193                 *norm0_1 = seg0->sides[edgeside0].normals[1];
1194                 *norm1_0 = seg1->sides[edgeside1].normals[0];
1195                 *norm1_1 = seg1->sides[edgeside1].normals[1];
1196         #endif
1197
1198         *pnt0 = &Vertices[seg0->verts[Side_to_verts[edgeside0][seg0->sides[edgeside0].type==3?1:0]]];
1199         *pnt1 = &Vertices[seg1->verts[Side_to_verts[edgeside1][seg1->sides[edgeside1].type==3?1:0]]];
1200
1201         return 1;
1202 }
1203
1204 //see if the order matters for these two children.
1205 //returns 0 if order doesn't matter, 1 if c0 before c1, -1 if c1 before c0
1206 int compare_children(segment *seg,short c0,short c1)
1207 {
1208         vms_vector norm0_0,norm0_1,*pnt0,temp;
1209         vms_vector norm1_0,norm1_1,*pnt1;
1210         fix d0_0,d0_1,d1_0,d1_1,d0,d1;
1211 int t;
1212
1213         if (Side_opposite[c0] == c1) return 0;
1214
1215         Assert(c0!=-1 && c1!=-1);
1216
1217         //find normals of adjoining sides
1218
1219         t = find_joining_side_norms(&norm0_0,&norm0_1,&norm1_0,&norm1_1,&pnt0,&pnt1,seg,c0,c1);
1220
1221 //if (!t)
1222 // return 0;
1223
1224         vm_vec_sub(&temp,&Viewer_eye,pnt0);
1225         d0_0 = vm_vec_dot(&norm0_0,&temp);
1226         d0_1 = vm_vec_dot(&norm0_1,&temp);
1227
1228         vm_vec_sub(&temp,&Viewer_eye,pnt1);
1229         d1_0 = vm_vec_dot(&norm1_0,&temp);
1230         d1_1 = vm_vec_dot(&norm1_1,&temp);
1231
1232         d0 = (d0_0 < 0 || d0_1 < 0)?-1:1;
1233         d1 = (d1_0 < 0 || d1_1 < 0)?-1:1;
1234
1235         if (d0 < 0 && d1 < 0)
1236                 return 0;
1237
1238         if (d0 < 0)
1239                 return 1;
1240         else if (d1 < 0)
1241                 return -1;
1242         else
1243                 return 0;
1244
1245 }
1246
1247 int ssc_total=0,ssc_swaps=0;
1248
1249 //short the children of segment to render in the correct order
1250 //returns non-zero if swaps were made
1251 int sort_seg_children(segment *seg,int n_children,short *child_list)
1252 {
1253         int i,j;
1254         int r;
1255         int made_swaps,count;
1256
1257         if (n_children == 0) return 0;
1258
1259  ssc_total++;
1260
1261         //for each child,  compare with other children and see if order matters
1262         //if order matters, fix if wrong
1263
1264         count = 0;
1265
1266         do {
1267                 made_swaps = 0;
1268
1269                 for (i=0;i<n_children-1;i++)
1270                         for (j=i+1;child_list[i]!=-1 && j<n_children;j++)
1271                                 if (child_list[j]!=-1) {
1272                                         r = compare_children(seg,child_list[i],child_list[j]);
1273
1274                                         if (r == 1) {
1275                                                 int temp = child_list[i];
1276                                                 child_list[i] = child_list[j];
1277                                                 child_list[j] = temp;
1278                                                 made_swaps=1;
1279                                         }
1280                                 }
1281
1282         } while (made_swaps && ++count<n_children);
1283
1284  if (count)
1285   ssc_swaps++;
1286
1287         return count;
1288 }
1289
1290 void add_obj_to_seglist(int objnum,int listnum)
1291 {
1292         int i,checkn,marker;
1293
1294         checkn = listnum;
1295
1296         //first, find a slot
1297
1298 //mprintf((0,"adding obj %d to %d",objnum,listnum));
1299
1300         do {
1301
1302                 for (i=0;render_obj_list[checkn][i] >= 0;i++);
1303
1304                 Assert(i < OBJS_PER_SEG);
1305
1306                 marker = render_obj_list[checkn][i];
1307
1308                 if (marker != -1) {
1309                         checkn = -marker;
1310                         //Assert(checkn < MAX_RENDER_SEGS+N_EXTRA_OBJ_LISTS);
1311                         if (checkn >= MAX_RENDER_SEGS+N_EXTRA_OBJ_LISTS) {
1312                                 Int3();
1313                                 return;
1314                         }
1315                 }
1316
1317         } while (marker != -1);
1318
1319 //mprintf((0,"  slot %d,%d",checkn,i));
1320
1321
1322         //now we have found a slot.  put object in it
1323
1324         if (i != OBJS_PER_SEG-1) {
1325
1326                 render_obj_list[checkn][i] = objnum;
1327                 render_obj_list[checkn][i+1] = -1;
1328         }
1329         else {                          //chain to additional list
1330                 int lookn;
1331
1332                 //find an available sublist
1333
1334                 for (lookn=MAX_RENDER_SEGS;render_obj_list[lookn][0]!=-1 && lookn<MAX_RENDER_SEGS+N_EXTRA_OBJ_LISTS;lookn++);
1335
1336                 //Assert(lookn<MAX_RENDER_SEGS+N_EXTRA_OBJ_LISTS);
1337                 if (lookn >= MAX_RENDER_SEGS+N_EXTRA_OBJ_LISTS) {
1338                         Int3();
1339                         return;
1340                 }
1341
1342                 render_obj_list[checkn][i] = -lookn;
1343                 render_obj_list[lookn][0] = objnum;
1344                 render_obj_list[lookn][1] = -1;
1345
1346         }
1347
1348 //mprintf((0,"  added!\n"));
1349
1350 }
1351 #ifdef __sun__
1352 // the following is a drop-in replacement for the broken libc qsort on solaris
1353 // taken from http://www.snippets.org/snippets/portable/RG_QSORT+C.php3
1354
1355 #define qsort qsort_dropin
1356
1357 /******************************************************************/
1358 /* qsort.c  --  Non-Recursive ANSI Quicksort function             */
1359 /* Public domain by Raymond Gardner, Englewood CO  February 1991  */
1360 /******************************************************************/
1361 #define  COMP(a, b)  ((*comp)((void *)(a), (void *)(b)))
1362 #define  T 7 // subfiles of <= T elements will be insertion sorteded (T >= 3)
1363 #define  SWAP(a, b)  (swap_bytes((char *)(a), (char *)(b), size))
1364
1365 static void swap_bytes(char *a, char *b, size_t nbytes)
1366 {
1367    char tmp;
1368    do {
1369       tmp = *a; *a++ = *b; *b++ = tmp;
1370    } while ( --nbytes );
1371 }
1372
1373 void qsort(void *basep, size_t nelems, size_t size,
1374                             int (*comp)(const void *, const void *))
1375 {
1376    char *stack[40], **sp;       /* stack and stack pointer        */
1377    char *i, *j, *limit;         /* scan and limit pointers        */
1378    size_t thresh;               /* size of T elements in bytes    */
1379    char *base;                  /* base pointer as char *         */
1380    base = (char *)basep;        /* set up char * base pointer     */
1381    thresh = T * size;           /* init threshold                 */
1382    sp = stack;                  /* init stack pointer             */
1383    limit = base + nelems * size;/* pointer past end of array      */
1384    for ( ;; ) {                 /* repeat until break...          */
1385       if ( limit - base > thresh ) {  /* if more than T elements  */
1386                                       /*   swap base with middle  */
1387          SWAP((((limit-base)/size)/2)*size+base, base);
1388          i = base + size;             /* i scans left to right    */
1389          j = limit - size;            /* j scans right to left    */
1390          if ( COMP(i, j) > 0 )        /* Sedgewick's              */
1391             SWAP(i, j);               /*    three-element sort    */
1392          if ( COMP(base, j) > 0 )     /*        sets things up    */
1393             SWAP(base, j);            /*            so that       */
1394          if ( COMP(i, base) > 0 )     /*      *i <= *base <= *j   */
1395             SWAP(i, base);            /* *base is pivot element   */
1396          for ( ;; ) {                 /* loop until break         */
1397             do                        /* move i right             */
1398                i += size;             /*        until *i >= pivot */
1399             while ( COMP(i, base) < 0 );
1400             do                        /* move j left              */
1401                j -= size;             /*        until *j <= pivot */
1402             while ( COMP(j, base) > 0 );
1403             if ( i > j )              /* if pointers crossed      */
1404                break;                 /*     break loop           */
1405             SWAP(i, j);       /* else swap elements, keep scanning*/
1406          }
1407          SWAP(base, j);         /* move pivot into correct place  */
1408          if ( j - base > limit - i ) {  /* if left subfile larger */
1409             sp[0] = base;             /* stack left subfile base  */
1410             sp[1] = j;                /*    and limit             */
1411             base = i;                 /* sort the right subfile   */
1412          } else {                     /* else right subfile larger*/
1413             sp[0] = i;                /* stack right subfile base */
1414             sp[1] = limit;            /*    and limit             */
1415             limit = j;                /* sort the left subfile    */
1416          }
1417          sp += 2;                     /* increment stack pointer  */
1418       } else {      /* else subfile is small, use insertion sort  */
1419          for ( j = base, i = j+size; i < limit; j = i, i += size )
1420             for ( ; COMP(j, j+size) > 0; j -= size ) {
1421                SWAP(j, j+size);
1422                if ( j == base )
1423                   break;
1424             }
1425          if ( sp != stack ) {         /* if any entries on stack  */
1426             sp -= 2;                  /* pop the base and limit   */
1427             base = sp[0];
1428             limit = sp[1];
1429          } else                       /* else stack empty, done   */
1430             break;
1431       }
1432    }
1433 }
1434 #endif // __sun__ qsort drop-in replacement
1435
1436 #define SORT_LIST_SIZE 100
1437
1438 typedef struct sort_item {
1439         int objnum;
1440         fix dist;
1441 } sort_item;
1442
1443 sort_item sort_list[SORT_LIST_SIZE];
1444 int n_sort_items;
1445
1446 //compare function for object sort.
1447 int sort_func(const sort_item *a,const sort_item *b)
1448 {
1449         fix delta_dist;
1450         object *obj_a,*obj_b;
1451
1452         delta_dist = a->dist - b->dist;
1453
1454         obj_a = &Objects[a->objnum];
1455         obj_b = &Objects[b->objnum];
1456
1457         if (abs(delta_dist) < (obj_a->size + obj_b->size)) {            //same position
1458
1459                 //these two objects are in the same position.  see if one is a fireball
1460                 //or laser or something that should plot on top.  Don't do this for
1461                 //the afterburner blobs, though.
1462
1463                 if (obj_a->type == OBJ_WEAPON || (obj_a->type == OBJ_FIREBALL && obj_a->id != VCLIP_AFTERBURNER_BLOB))
1464                         if (!(obj_b->type == OBJ_WEAPON || obj_b->type == OBJ_FIREBALL))
1465                                 return -1;      //a is weapon, b is not, so say a is closer
1466                         else;                           //both are weapons
1467                 else
1468                         if (obj_b->type == OBJ_WEAPON || (obj_b->type == OBJ_FIREBALL && obj_b->id != VCLIP_AFTERBURNER_BLOB))
1469                                 return 1;       //b is weapon, a is not, so say a is farther
1470
1471                 //no special case, fall through to normal return
1472         }
1473
1474         return delta_dist;      //return distance
1475 }
1476
1477 void build_object_lists(int n_segs)
1478 {
1479         int nn;
1480
1481 //mprintf((0,"build n_segs=%d",n_segs));
1482
1483         for (nn=0;nn<MAX_RENDER_SEGS+N_EXTRA_OBJ_LISTS;nn++)
1484                 render_obj_list[nn][0] = -1;
1485
1486         for (nn=0;nn<n_segs;nn++) {
1487                 int segnum;
1488
1489                 segnum = Render_list[nn];
1490
1491 //mprintf((0,"nn=%d seg=%d ",nn,segnum));
1492
1493                 if (segnum != -1) {
1494                         int objnum;
1495                         object *obj;
1496
1497                         for (objnum=Segments[segnum].objects;objnum!=-1;objnum = obj->next) {
1498                                 int new_segnum,did_migrate,list_pos;
1499
1500                                 obj = &Objects[objnum];
1501
1502                                 Assert( obj->segnum == segnum );
1503
1504                                 if (obj->flags & OF_ATTACHED)
1505                                         continue;               //ignore this object
1506
1507                                 new_segnum = segnum;
1508                                 list_pos = nn;
1509
1510 //mprintf((0,"objnum=%d ",objnum));
1511                                 if (obj->type != OBJ_CNTRLCEN && !(obj->type==OBJ_ROBOT && obj->id==65))                //don't migrate controlcen
1512                                 do {
1513                                         segmasks m;
1514
1515                                         did_migrate = 0;
1516
1517                                         m = get_seg_masks(&obj->pos, new_segnum, obj->size, __FILE__, __LINE__);
1518
1519                                         if (m.sidemask) {
1520                                                 int sn,sf;
1521
1522                                                 for (sn=0,sf=1;sn<6;sn++,sf<<=1)
1523                                                         if (m.sidemask & sf) {
1524                                                                 segment *seg = &Segments[new_segnum];
1525
1526                                                                 if (WALL_IS_DOORWAY(seg,sn) & WID_FLY_FLAG) {           //can explosion migrate through
1527                                                                         int child = seg->children[sn];
1528                                                                         int checknp;
1529
1530                                                                         for (checknp=list_pos;checknp--;)
1531                                                                                 if (Render_list[checknp] == child) {
1532 //mprintf((0,"mig from %d to %d ",new_segnum,child));
1533                                                                                         new_segnum = child;
1534                                                                                         list_pos = checknp;
1535                                                                                         did_migrate = 1;
1536                                                                                 }
1537                                                                 }
1538                                                         }
1539                                         }
1540
1541                                 } while (0);    //while (did_migrate);
1542
1543                                 add_obj_to_seglist(objnum,list_pos);
1544
1545                         }
1546
1547                 }
1548         }
1549
1550 //mprintf((0,"done build "));
1551
1552         //now that there's a list for each segment, sort the items in those lists
1553         for (nn=0;nn<n_segs;nn++) {
1554                 int segnum;
1555
1556                 segnum = Render_list[nn];
1557
1558 //mprintf((0,"nn=%d seg=%d ",nn,segnum));
1559
1560                 if (segnum != -1) {
1561                         int t,lookn,i,n;
1562
1563                         //first count the number of objects & copy into sort list
1564
1565                         lookn = nn;
1566                         i = n_sort_items = 0;
1567                         while ((t=render_obj_list[lookn][i++])!=-1)
1568                                 if (t<0)
1569                                         {lookn = -t; i=0;}
1570                                 else
1571                                         if (n_sort_items < SORT_LIST_SIZE-1) {          //add if room
1572                                                 sort_list[n_sort_items].objnum = t;
1573                                                 //NOTE: maybe use depth, not dist - quicker computation
1574                                                 sort_list[n_sort_items].dist = vm_vec_dist_quick(&Objects[t].pos,&Viewer_eye);
1575                                                 n_sort_items++;
1576                                         }
1577                                         else {                  //no room for object
1578                                                 int ii;
1579
1580                                                 #ifndef NDEBUG
1581                                                 FILE *tfile=fopen("sortlist.out","wt");
1582
1583                                                 //I find this strange, so I'm going to write out
1584                                                 //some information to look at later
1585                                                 if (tfile) {
1586                                                         for (ii=0;ii<SORT_LIST_SIZE;ii++) {
1587                                                                 int objnum = sort_list[ii].objnum;
1588
1589                                                                 fprintf(tfile,"Obj %3d  Type = %2d  Id = %2d  Dist = %08x  Segnum = %3d\n",
1590                                                                         objnum,Objects[objnum].type,Objects[objnum].id,sort_list[ii].dist,Objects[objnum].segnum);
1591                                                         }
1592                                                         fclose(tfile);
1593                                                 }
1594                                                 #endif
1595
1596                                                 Int3(); //Get Matt!!!
1597
1598                                                 //Now try to find a place for this object by getting rid
1599                                                 //of an object we don't care about
1600
1601                                                 for (ii=0;ii<SORT_LIST_SIZE;ii++) {
1602                                                         int objnum = sort_list[ii].objnum;
1603                                                         object *obj = &Objects[objnum];
1604                                                         int type = obj->type;
1605
1606                                                         //replace debris & fireballs
1607                                                         if (type == OBJ_DEBRIS || type == OBJ_FIREBALL) {
1608                                                                 fix dist = vm_vec_dist_quick(&Objects[t].pos,&Viewer_eye);
1609
1610                                                                 //don't replace same kind of object unless new
1611                                                                 //one is closer
1612
1613                                                                 if (Objects[t].type != type || dist < sort_list[ii].dist) {
1614                                                                         sort_list[ii].objnum = t;
1615                                                                         sort_list[ii].dist = dist;
1616                                                                         break;
1617                                                                 }
1618                                                         }
1619                                                 }
1620
1621                                                 Int3(); //still couldn't find a slot
1622                                         }
1623
1624
1625                         //now call qsort
1626                 #if defined(__WATCOMC__) || defined(MACINTOSH)
1627                         qsort(sort_list,n_sort_items,sizeof(*sort_list),
1628                                    sort_func);
1629                 #else
1630                         qsort(sort_list,n_sort_items,sizeof(*sort_list),
1631                                         (int (*)(const void*,const void*))sort_func);
1632                 #endif
1633
1634                         //now copy back into list
1635
1636                         lookn = nn;
1637                         i = 0;
1638                         n = n_sort_items;
1639                         while ((t=render_obj_list[lookn][i])!=-1 && n>0)
1640                                 if (t<0)
1641                                         {lookn = -t; i=0;}
1642                                 else
1643                                         render_obj_list[lookn][i++] = sort_list[--n].objnum;
1644                         render_obj_list[lookn][i] = -1; //mark (possibly new) end
1645                 }
1646         }
1647 }
1648
1649 int Use_player_head_angles = 0;
1650 vms_angvec Player_head_angles;
1651
1652 extern int Num_tmaps_drawn;
1653 extern int Total_pixels;
1654 //--unused-- int Total_num_tmaps_drawn=0;
1655
1656 int Rear_view=0;
1657 extern ubyte RenderingType;
1658
1659 void start_lighting_frame(object *viewer);
1660
1661 #ifdef JOHN_ZOOM
1662 fix Zoom_factor=F1_0;
1663 #endif
1664 //renders onto current canvas
1665 void render_frame(fix eye_offset, int window_num)
1666 {
1667         int start_seg_num;
1668
1669 //Total_num_tmaps_drawn += Num_tmaps_drawn;
1670 //if ((FrameCount > 0) && (Total_num_tmaps_drawn))
1671 //      mprintf((0, "Frame: %4i, total = %6i, Avg = %7.3f, Avgpix=%7.3f\n", Num_tmaps_drawn, Total_num_tmaps_drawn, (float) Total_num_tmaps_drawn/FrameCount, (float) Total_pixels/Total_num_tmaps_drawn));
1672 //Num_tmaps_drawn = 0;
1673
1674         if (Endlevel_sequence) {
1675                 render_endlevel_frame(eye_offset);
1676                 FrameCount++;
1677                 return;
1678         }
1679
1680 #ifdef NEWDEMO
1681         if ( Newdemo_state == ND_STATE_RECORDING && eye_offset >= 0 )   {
1682
1683           //mprintf((0, "Objnum=%d objtype=%d objid=%d\n", OBJECT_NUMBER(Viewer), Viewer->type, Viewer->id));
1684
1685       if (RenderingType==0)
1686                 newdemo_record_start_frame(FrameCount, FrameTime );
1687       if (RenderingType!=255)
1688                 newdemo_record_viewer_object(Viewer);
1689         }
1690 #endif
1691
1692    //Here:
1693
1694         start_lighting_frame(Viewer);           //this is for ugly light-smoothing hack
1695
1696         g3_start_frame();
1697
1698         Viewer_eye = Viewer->pos;
1699
1700 //      if (Viewer->type == OBJ_PLAYER && (Cockpit_mode.intval != CM_REAR_VIEW))
1701 //              vm_vec_scale_add2(&Viewer_eye,&Viewer->orient.fvec,(Viewer->size*3)/4);
1702
1703         if (eye_offset) {
1704                 vm_vec_scale_add2(&Viewer_eye,&Viewer->orient.rvec,eye_offset);
1705         }
1706
1707         #ifdef EDITOR
1708         if (Function_mode==FMODE_EDITOR)
1709                 Viewer_eye = Viewer->pos;
1710         #endif
1711
1712         start_seg_num = find_point_seg(&Viewer_eye,Viewer->segnum);
1713
1714         if (start_seg_num==-1)
1715                 start_seg_num = Viewer->segnum;
1716
1717         if (Viewer==ConsoleObject && Use_player_head_angles) {
1718                 vms_matrix headm,viewm;
1719                 vm_angles_2_matrix(&headm,&Player_head_angles);
1720                 vm_matrix_x_matrix(&viewm,&Viewer->orient,&headm);
1721                 g3_set_view_matrix(&Viewer_eye,&viewm,Render_zoom);
1722         //@@} else if ((Cockpit_mode.intval == CM_REAR_VIEW) && (Viewer == ConsoleObject)) {
1723         } else if (Rear_view && (Viewer==ConsoleObject)) {
1724                 vms_matrix headm,viewm;
1725                 Player_head_angles.p = Player_head_angles.b = 0;
1726                 Player_head_angles.h = 0x7fff;
1727                 vm_angles_2_matrix(&headm,&Player_head_angles);
1728                 vm_matrix_x_matrix(&viewm,&Viewer->orient,&headm);
1729                 g3_set_view_matrix(&Viewer_eye,&viewm,Render_zoom);
1730         } else  {
1731 #ifdef JOHN_ZOOM
1732                 if (keyd_pressed[KEY_RSHIFT] )  {
1733                         Zoom_factor += FrameTime*4;
1734                         if (Zoom_factor > F1_0*5 ) Zoom_factor=F1_0*5;
1735                 } else {
1736                         Zoom_factor -= FrameTime*4;
1737                         if (Zoom_factor < F1_0 ) Zoom_factor = F1_0;
1738                 }
1739                 g3_set_view_matrix(&Viewer_eye,&Viewer->orient,fixdiv(Render_zoom,Zoom_factor));
1740 #else
1741                 g3_set_view_matrix(&Viewer_eye,&Viewer->orient,Render_zoom);
1742 #endif
1743         }
1744
1745         if (Clear_window == 1) {
1746                 if (Clear_window_color == -1)
1747                         Clear_window_color = BM_XRGB(0, 0, 0);  //BM_XRGB(31, 15, 7);
1748                 gr_clear_canvas(Clear_window_color);
1749         }
1750         #ifndef NDEBUG
1751         if (Show_only_curside)
1752                 gr_clear_canvas(Clear_window_color);
1753         #endif
1754
1755         render_mine(start_seg_num, eye_offset, window_num);
1756
1757         if (Use_player_head_angles )
1758                 draw_3d_reticle(eye_offset);
1759
1760         g3_end_frame();
1761
1762    //RenderingType=0;
1763
1764         // -- Moved from here by MK, 05/17/95, wrong if multiple renders/frame! FrameCount++;           //we have rendered a frame
1765 }
1766
1767 int first_terminal_seg;
1768
1769 void update_rendered_data(int window_num, object *viewer, int rear_view_flag, int user)
1770 {
1771         Assert(window_num < MAX_RENDERED_WINDOWS);
1772         Window_rendered_data[window_num].frame = FrameCount;
1773         Window_rendered_data[window_num].viewer = viewer;
1774         Window_rendered_data[window_num].rear_view = rear_view_flag;
1775         Window_rendered_data[window_num].user = user;
1776 }
1777
1778 //build a list of segments to be rendered
1779 //fills in Render_list & N_render_segs
1780 void build_segment_list(int start_seg_num, int window_num)
1781 {
1782         int     lcnt,scnt,ecnt;
1783         int     l,c;
1784         int     ch;
1785
1786         memset(visited, 0, sizeof(visited[0])*(Highest_segment_index+1));
1787         memset(render_pos, -1, sizeof(render_pos[0])*(Highest_segment_index+1));
1788         //memset(no_render_flag, 0, sizeof(no_render_flag[0])*(MAX_RENDER_SEGS));
1789         memset(processed, 0, sizeof(processed));
1790
1791         #ifndef NDEBUG
1792         memset(visited2, 0, sizeof(visited2[0])*(Highest_segment_index+1));
1793         #endif
1794
1795         lcnt = scnt = 0;
1796
1797         Render_list[lcnt] = start_seg_num; visited[start_seg_num]=1;
1798         Seg_depth[lcnt] = 0;
1799         lcnt++;
1800         ecnt = lcnt;
1801         render_pos[start_seg_num] = 0;
1802
1803         #ifndef NDEBUG
1804         if (pre_draw_segs)
1805                 render_segment(start_seg_num, window_num);
1806         #endif
1807
1808         render_windows[0].left=render_windows[0].top=0;
1809         render_windows[0].right=grd_curcanv->cv_bitmap.bm_w-1;
1810         render_windows[0].bot=grd_curcanv->cv_bitmap.bm_h-1;
1811
1812         //breadth-first renderer
1813
1814         //build list
1815
1816         for (l=0;l<Render_depth;l++) {
1817
1818                 //while (scnt < ecnt) {
1819                 for (scnt=0;scnt < ecnt;scnt++) {
1820                         int rotated,segnum;
1821                         window *check_w;
1822                         short child_list[MAX_SIDES_PER_SEGMENT];                //list of ordered sides to process
1823                         int n_children;                                                                         //how many sides in child_list
1824                         segment *seg;
1825
1826                         if (processed[scnt])
1827                                 continue;
1828
1829                         processed[scnt]=1;
1830
1831                         segnum = Render_list[scnt];
1832                         check_w = &render_windows[scnt];
1833
1834                         #ifndef NDEBUG
1835                         if (draw_boxes)
1836                                 draw_window_box(RED,check_w->left,check_w->top,check_w->right,check_w->bot);
1837                         #endif
1838
1839                         if (segnum == -1) continue;
1840
1841                         seg = &Segments[segnum];
1842                         rotated=0;
1843
1844                         //look at all sides of this segment.
1845                         //tricky code to look at sides in correct order follows
1846
1847                         for (c=n_children=0;c<MAX_SIDES_PER_SEGMENT;c++) {              //build list of sides
1848                                 int wid;
1849
1850                                 wid = WALL_IS_DOORWAY(seg, c);
1851
1852                                 ch=seg->children[c];
1853
1854                                 if ( (window_check || !visited[ch]) && (wid & WID_RENDPAST_FLAG) ) {
1855                                         if (behind_check) {
1856                                                 sbyte *sv = Side_to_verts[c];
1857                                                 ubyte codes_and=0xff;
1858                                                 int i;
1859
1860                                                 rotate_list(8,seg->verts);
1861                                                 rotated=1;
1862
1863                                                 for (i=0;i<4;i++)
1864                                                         codes_and &= Segment_points[seg->verts[sv[i]]].p3_codes;
1865
1866                                                 if (codes_and & CC_BEHIND) continue;
1867
1868                                         }
1869                                         child_list[n_children++] = c;
1870                                 }
1871                         }
1872
1873                         //now order the sides in some magical way
1874
1875                         if (new_seg_sorting)
1876                                 sort_seg_children(seg,n_children,child_list);
1877
1878                         //for (c=0;c<MAX_SIDES_PER_SEGMENT;c++) {
1879                         //      ch=seg->children[c];
1880
1881                         for (c=0;c<n_children;c++) {
1882                                 int siden;
1883
1884                                 siden = child_list[c];
1885                                 ch=seg->children[siden];
1886                                 //if ( (window_check || !visited[ch])&& (WALL_IS_DOORWAY(seg, c))) {
1887                                 {
1888                                         if (window_check) {
1889                                                 int i;
1890                                                 ubyte codes_and_3d,codes_and_2d;
1891                                                 short _x,_y,min_x=32767,max_x=-32767,min_y=32767,max_y=-32767;
1892                                                 int no_proj_flag=0;     //a point wasn't projected
1893
1894                                                 if (rotated<2) {
1895                                                         if (!rotated)
1896                                                                 rotate_list(8,seg->verts);
1897                                                         project_list(8,seg->verts);
1898                                                         rotated=2;
1899                                                 }
1900
1901                                                 for (i=0,codes_and_3d=codes_and_2d=0xff;i<4;i++) {
1902                                                         int p = seg->verts[Side_to_verts[siden][i]];
1903                                                         g3s_point *pnt = &Segment_points[p];
1904
1905                                                         if (! (pnt->p3_flags&PF_PROJECTED)) {no_proj_flag=1; break;}
1906
1907                                                         _x = f2i(pnt->p3_sx);
1908                                                         _y = f2i(pnt->p3_sy);
1909
1910                                                         codes_and_3d &= pnt->p3_codes;
1911                                                         codes_and_2d &= code_window_point(_x,_y,check_w);
1912
1913                                                         #ifndef NDEBUG
1914                                                         if (draw_edges) {
1915                                                                 gr_setcolor(BM_XRGB(31,0,31));
1916                                                                 gr_line(pnt->p3_sx,pnt->p3_sy,
1917                                                                         Segment_points[seg->verts[Side_to_verts[siden][(i+1)%4]]].p3_sx,
1918                                                                         Segment_points[seg->verts[Side_to_verts[siden][(i+1)%4]]].p3_sy);
1919                                                         }
1920                                                         #endif
1921
1922                                                         if (_x < min_x) min_x = _x;
1923                                                         if (_x > max_x) max_x = _x;
1924
1925                                                         if (_y < min_y) min_y = _y;
1926                                                         if (_y > max_y) max_y = _y;
1927
1928                                                 }
1929
1930                                                 #ifndef NDEBUG
1931                                                 if (draw_boxes)
1932                                                         draw_window_box(WHITE,min_x,min_y,max_x,max_y);
1933                                                 #endif
1934
1935                                                 if (no_proj_flag || (!codes_and_3d && !codes_and_2d)) { //maybe add this segment
1936                                                         int rp = render_pos[ch];
1937                                                         window *new_w = &render_windows[lcnt];
1938
1939                                                         if (no_proj_flag) *new_w = *check_w;
1940                                                         else {
1941                                                                 new_w->left  = max(check_w->left,min_x);
1942                                                                 new_w->right = min(check_w->right,max_x);
1943                                                                 new_w->top   = max(check_w->top,min_y);
1944                                                                 new_w->bot   = min(check_w->bot,max_y);
1945                                                         }
1946
1947                                                         //see if this seg already visited, and if so, does current window
1948                                                         //expand the old window?
1949                                                         if (rp != -1) {
1950                                                                 if (new_w->left < render_windows[rp].left ||
1951                                                                                  new_w->top < render_windows[rp].top ||
1952                                                                                  new_w->right > render_windows[rp].right ||
1953                                                                                  new_w->bot > render_windows[rp].bot) {
1954
1955                                                                         new_w->left  = min(new_w->left,render_windows[rp].left);
1956                                                                         new_w->right = max(new_w->right,render_windows[rp].right);
1957                                                                         new_w->top   = min(new_w->top,render_windows[rp].top);
1958                                                                         new_w->bot   = max(new_w->bot,render_windows[rp].bot);
1959
1960                                                                         if (no_migrate_segs) {
1961                                                                                 //no_render_flag[lcnt] = 1;
1962                                                                                 Render_list[lcnt] = -1;
1963                                                                                 render_windows[rp] = *new_w;            //get updated window
1964                                                                                 processed[rp] = 0;              //force reprocess
1965                                                                                 goto no_add;
1966                                                                         }
1967                                                                         else
1968                                                                                 Render_list[rp]=-1;
1969                                                                 }
1970                                                                 else goto no_add;
1971                                                         }
1972
1973                                                         #ifndef NDEBUG
1974                                                         if (draw_boxes)
1975                                                                 draw_window_box(5,new_w->left,new_w->top,new_w->right,new_w->bot);
1976                                                         #endif
1977
1978                                                         render_pos[ch] = lcnt;
1979                                                         Render_list[lcnt] = ch;
1980                                                         Seg_depth[lcnt] = l;
1981                                                         lcnt++;
1982                                                         if (lcnt >= MAX_RENDER_SEGS) {mprintf((0,"Too many segs in render list!!\n")); goto done_list;}
1983                                                         visited[ch] = 1;
1984
1985                                                         #ifndef NDEBUG
1986                                                         if (pre_draw_segs)
1987                                                                 render_segment(ch, window_num);
1988                                                         #endif
1989 no_add:
1990         ;
1991
1992                                                 }
1993                                         }
1994                                         else {
1995                                                 Render_list[lcnt] = ch;
1996                                                 Seg_depth[lcnt] = l;
1997                                                 lcnt++;
1998                                                 if (lcnt >= MAX_RENDER_SEGS) {mprintf((0,"Too many segs in render list!!\n")); goto done_list;}
1999                                                 visited[ch] = 1;
2000                                         }
2001                                 }
2002                         }
2003                 }
2004
2005                 scnt = ecnt;
2006                 ecnt = lcnt;
2007
2008         }
2009 done_list:
2010
2011         lcnt_save = lcnt;
2012         scnt_save = scnt;
2013
2014         first_terminal_seg = scnt;
2015         N_render_segs = lcnt;
2016
2017 }
2018
2019 //renders onto current canvas
2020 void render_mine(int start_seg_num,fix eye_offset, int window_num)
2021 {
2022 #ifndef NDEBUG
2023         int             i;
2024 #endif
2025         int             nn;
2026
2027         //      Initialize number of objects (actually, robots!) rendered this frame.
2028         Window_rendered_data[window_num].num_objects = 0;
2029
2030 #ifdef LASER_HACK
2031         Hack_nlasers = 0;
2032 #endif
2033
2034         #ifndef NDEBUG
2035         for (i=0;i<=Highest_object_index;i++)
2036                 object_rendered[i] = 0;
2037         #endif
2038
2039         //set up for rendering
2040
2041         render_start_frame();
2042
2043
2044         #if defined(EDITOR)
2045         if (Show_only_curside) {
2046                 rotate_list(8,Cursegp->verts);
2047                 render_side(Cursegp,Curside);
2048                 goto done_rendering;
2049         }
2050         #endif
2051
2052
2053         #ifdef EDITOR
2054         if (_search_mode)       {
2055                 //lcnt = lcnt_save;
2056                 //scnt = scnt_save;
2057         }
2058         else
2059         #endif
2060                 //NOTE LINK TO ABOVE!!
2061                 build_segment_list(start_seg_num, window_num);          //fills in Render_list & N_render_segs
2062
2063         //render away
2064
2065         #ifndef NDEBUG
2066         if (!window_check) {
2067                 Window_clip_left  = Window_clip_top = 0;
2068                 Window_clip_right = grd_curcanv->cv_bitmap.bm_w-1;
2069                 Window_clip_bot   = grd_curcanv->cv_bitmap.bm_h-1;
2070         }
2071         #endif
2072
2073         #ifndef NDEBUG
2074         if (!(_search_mode)) {
2075                 int i;
2076
2077                 for (i=0;i<N_render_segs;i++) {
2078                         int segnum;
2079
2080                         segnum = Render_list[i];
2081
2082                         if (segnum != -1)
2083                         {
2084                                 if (visited2[segnum])
2085                                         Int3();         //get Matt
2086                                 else
2087                                         visited2[segnum] = 1;
2088                         }
2089                 }
2090         }
2091         #endif
2092
2093         if (!(_search_mode))
2094                 build_object_lists(N_render_segs);
2095
2096         if (eye_offset<=0)              // Do for left eye or zero.
2097                 set_dynamic_light();
2098
2099         if (!_search_mode && Clear_window == 2) {
2100                 if (first_terminal_seg < N_render_segs) {
2101                         int i;
2102
2103                         if (Clear_window_color == -1)
2104                                 Clear_window_color = BM_XRGB(0, 0, 0);  //BM_XRGB(31, 15, 7);
2105
2106                         gr_setcolor(Clear_window_color);
2107
2108                         for (i=first_terminal_seg; i<N_render_segs; i++) {
2109                                 if (Render_list[i] != -1) {
2110                                         #ifndef NDEBUG
2111                                         if ((render_windows[i].left == -1) || (render_windows[i].top == -1) || (render_windows[i].right == -1) || (render_windows[i].bot == -1))
2112                                                 Int3();
2113                                         else
2114                                         #endif
2115                                                 //NOTE LINK TO ABOVE!
2116                                                 gr_rect(render_windows[i].left, render_windows[i].top, render_windows[i].right, render_windows[i].bot);
2117                                 }
2118                         }
2119                 }
2120         }
2121
2122         for (nn=N_render_segs;nn--;) {
2123                 int segnum;
2124                 int objnp;
2125
2126                 // Interpolation_method = 0;
2127                 segnum = Render_list[nn];
2128                 Current_seg_depth = Seg_depth[nn];
2129
2130                 //if (!no_render_flag[nn])
2131                 if (segnum!=-1 && (_search_mode || visited[segnum]!=255)) {
2132                         //set global render window vars
2133
2134                         if (window_check) {
2135                                 Window_clip_left  = render_windows[nn].left;
2136                                 Window_clip_top   = render_windows[nn].top;
2137                                 Window_clip_right = render_windows[nn].right;
2138                                 Window_clip_bot   = render_windows[nn].bot;
2139                         }
2140
2141                         //mprintf((0," %d",segnum));
2142
2143                         render_segment(segnum, window_num);
2144                         visited[segnum]=255;
2145
2146                         if (window_check) {             //reset for objects
2147                                 Window_clip_left  = Window_clip_top = 0;
2148                                 Window_clip_right = grd_curcanv->cv_bitmap.bm_w-1;
2149                                 Window_clip_bot   = grd_curcanv->cv_bitmap.bm_h-1;
2150                         }
2151
2152                         if (migrate_objects) {
2153                                 //int n_expl_objs=0,expl_objs[5],i;
2154                                 int listnum;
2155                                 int save_linear_depth = Max_linear_depth;
2156
2157                                 Max_linear_depth = Max_linear_depth_objects;
2158
2159                                 listnum = nn;
2160
2161                                 //mprintf((0,"render objs seg %d",segnum));
2162
2163                                 for (objnp=0;render_obj_list[listnum][objnp]!=-1;)      {
2164                                         int ObjNumber = render_obj_list[listnum][objnp];
2165
2166                                         if (ObjNumber >= 0) {
2167
2168                                                 //mprintf( (0, "Type: %d\n", Objects[ObjNumber].type ));
2169
2170                                                 //if (Objects[ObjNumber].type == OBJ_FIREBALL && n_expl_objs<5) {
2171                                                 //      expl_objs[n_expl_objs++] = ObjNumber;
2172                                                 //} else
2173                                                 #ifdef LASER_HACK
2174                                                 if (    (Objects[ObjNumber].type==OBJ_WEAPON) &&                                                                //if its a weapon
2175                                                                 (Objects[ObjNumber].lifeleft==Laser_max_time ) &&       //  and its in it's first frame
2176                                                                 (Hack_nlasers< MAX_HACKED_LASERS) &&                                                                    //  and we have space for it
2177                                                                 (Objects[ObjNumber].laser_info.parent_num>-1) &&                                        //  and it has a parent
2178                                                                 (OBJECT_NUMBER(Viewer) == Objects[ObjNumber].laser_info.parent_num) // and it's parent is the viewer
2179                                                    )            {
2180                                                         Hack_laser_list[Hack_nlasers++] = ObjNumber;                                                            //then make it draw after everything else.
2181                                                         //mprintf( (0, "O%d ", ObjNumber ));
2182                                                 } else
2183                                                 #endif
2184                                                         do_render_object(ObjNumber, window_num);        // note link to above else
2185
2186                                                 objnp++;
2187                                         }
2188                                         else {
2189
2190                                                 listnum = -ObjNumber;
2191                                                 objnp = 0;
2192
2193                                         }
2194
2195                                 }
2196
2197                                 //for (i=0;i<n_expl_objs;i++)
2198                                 //      do_render_object(expl_objs[i], window_num);
2199
2200                                 //mprintf((0,"done seg %d\n",segnum));
2201
2202                                 Max_linear_depth = save_linear_depth;
2203
2204                         }
2205
2206                 }
2207         }
2208
2209         //mprintf((0,"\n"));
2210
2211
2212 #ifdef LASER_HACK
2213         // Draw the hacked lasers last
2214         for (i=0; i < Hack_nlasers; i++ )       {
2215                 //mprintf( (0, "D%d ", Hack_laser_list[i] ));
2216                 do_render_object(Hack_laser_list[i], window_num);
2217         }
2218 #endif
2219
2220         // -- commented out by mk on 09/14/94...did i do a good thing??  object_render_targets();
2221
2222 #ifdef EDITOR
2223         #ifndef NDEBUG
2224         //draw curedge stuff
2225         if (Outline_mode) outline_seg_side(Cursegp,Curside,Curedge,Curvert);
2226         #endif
2227
2228 done_rendering:
2229         ;
2230
2231 #endif
2232
2233 }
2234 #ifdef EDITOR
2235
2236 extern int render_3d_in_big_window;
2237
2238 //finds what segment is at a given x&y -  seg,side,face are filled in
2239 //works on last frame rendered. returns true if found
2240 //if seg<0, then an object was found, and the object number is -seg-1
2241 int find_seg_side_face(short x,short y,int *seg,int *side,int *face,int *poly)
2242 {
2243         _search_mode = -1;
2244
2245         _search_x = x; _search_y = y;
2246
2247         found_seg = -1;
2248
2249         if (render_3d_in_big_window) {
2250                 grs_canvas temp_canvas;
2251
2252                 gr_init_sub_canvas(&temp_canvas,canv_offscreen,0,0,
2253                         LargeView.ev_canv->cv_bitmap.bm_w,LargeView.ev_canv->cv_bitmap.bm_h);
2254
2255                 gr_set_current_canvas(&temp_canvas);
2256
2257                 render_frame(0, 0);
2258         }
2259         else {
2260                 gr_set_current_canvas(&VR_render_sub_buffer[0]);        //render off-screen
2261                 render_frame(0, 0);
2262         }
2263
2264         _search_mode = 0;
2265
2266         *seg = found_seg;
2267         *side = found_side;
2268         *face = found_face;
2269         *poly = found_poly;
2270
2271 //      mprintf((0,"found seg=%d, side=%d, face=%d, poly=%d\n",found_seg,found_side,found_face,found_poly));
2272
2273         return (found_seg!=-1);
2274
2275 }
2276
2277 #endif