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.
40 #define INITIAL_LOCAL_LIGHT (F1_0/4) // local light value in segment of occurence (of light emission)
43 #include "editor/editor.h"
47 //used for checking if points have been rotated
48 int Clear_window_color=-1;
49 int Clear_window=2; // 1 = Clear whole background window, 2 = clear view portals into rest of world, 0 = no clear
52 short Rotated_last[MAX_VERTICES];
54 // When any render function needs to know what's looking at it, it should
55 // access Viewer members.
56 object * Viewer = NULL;
58 vms_vector Viewer_eye; //valid during render
63 fix Render_zoom = 0x9000; //the player's zoom factor
65 fix Render_zoom = 0xB000;
69 ubyte object_rendered[MAX_OBJECTS];
72 #define DEFAULT_RENDER_DEPTH 16
73 int Render_depth=DEFAULT_RENDER_DEPTH; //how many segments deep to render
75 int Detriangulation_on = 1; // 1 = allow rendering of triangulated side as a quad, 0 = don't allow
78 int Render_only_bottom=0;
79 int Bottom_bitmap_num = 9;
82 fix Face_reflectivity = (F1_0/2);
84 #if 0 //this stuff could probably just be deleted
86 int inc_render_depth(void)
88 return ++Render_depth;
91 int dec_render_depth(void)
93 return Render_depth==1?Render_depth:--Render_depth;
96 int reset_render_depth(void)
98 return Render_depth = DEFAULT_RENDER_DEPTH;
104 int _search_mode = 0; //true if looking for curseg,side,face
105 short _search_x,_search_y; //pixel we're looking at
106 int found_seg,found_side,found_face,found_poly;
108 #define _search_mode 0
111 #ifdef NDEBUG //if no debug code, set these vars to constants
113 #define Outline_mode 0
114 #define Show_only_curside 0
118 int Outline_mode=0,Show_only_curside=0;
120 int toggle_outline_mode(void)
122 return Outline_mode = !Outline_mode;
125 int toggle_show_only_curside(void)
127 return Show_only_curside = !Show_only_curside;
130 void draw_outline(int nverts,g3s_point **pointlist)
134 gr_setcolor(BM_XRGB(63,63,63));
136 for (i=0;i<nverts-1;i++)
137 g3_draw_line(pointlist[i],pointlist[i+1]);
139 g3_draw_line(pointlist[i],pointlist[0]);
144 grs_canvas * reticle_canvas = NULL;
146 void free_reticle_canvas()
148 if (reticle_canvas) {
149 d_free( reticle_canvas->cv_bitmap.bm_data );
150 d_free( reticle_canvas );
151 reticle_canvas = NULL;
155 extern void show_reticle(int force_big);
157 // Draw the reticle in 3D for head tracking
158 void draw_3d_reticle(fix eye_offset)
160 g3s_point reticle_points[4];
162 g3s_point *pointlist[4];
165 grs_canvas *saved_canvas;
166 int saved_interp_method;
168 // if (!Use_player_head_angles) return;
170 for (i=0; i<4; i++ ) {
171 pointlist[i] = &reticle_points[i];
172 uvl[i].l = MAX_LIGHT;
174 uvl[0].u = 0; uvl[0].v = 0;
175 uvl[1].u = F1_0; uvl[1].v = 0;
176 uvl[2].u = F1_0; uvl[2].v = F1_0;
177 uvl[3].u = 0; uvl[3].v = F1_0;
179 vm_vec_scale_add( &v1, &Viewer->pos, &Viewer->orient.fvec, F1_0*4 );
180 vm_vec_scale_add2(&v1,&Viewer->orient.rvec,eye_offset);
182 vm_vec_scale_add( &v2, &v1, &Viewer->orient.rvec, -F1_0*1 );
183 vm_vec_scale_add2( &v2, &Viewer->orient.uvec, F1_0*1 );
184 g3_rotate_point(&reticle_points[0],&v2);
186 vm_vec_scale_add( &v2, &v1, &Viewer->orient.rvec, +F1_0*1 );
187 vm_vec_scale_add2( &v2, &Viewer->orient.uvec, F1_0*1 );
188 g3_rotate_point(&reticle_points[1],&v2);
190 vm_vec_scale_add( &v2, &v1, &Viewer->orient.rvec, +F1_0*1 );
191 vm_vec_scale_add2( &v2, &Viewer->orient.uvec, -F1_0*1 );
192 g3_rotate_point(&reticle_points[2],&v2);
194 vm_vec_scale_add( &v2, &v1, &Viewer->orient.rvec, -F1_0*1 );
195 vm_vec_scale_add2( &v2, &Viewer->orient.uvec, -F1_0*1 );
196 g3_rotate_point(&reticle_points[3],&v2);
198 if ( reticle_canvas == NULL ) {
199 reticle_canvas = gr_create_canvas(64,64);
200 if ( !reticle_canvas )
201 Error( "Couldn't malloc reticle_canvas" );
202 atexit( free_reticle_canvas );
203 reticle_canvas->cv_bitmap.bm_handle = 0;
204 reticle_canvas->cv_bitmap.bm_flags = BM_FLAG_TRANSPARENT;
207 saved_canvas = grd_curcanv;
208 gr_set_current_canvas(reticle_canvas);
209 gr_clear_canvas( TRANSPARENCY_COLOR ); // Clear to Xparent
211 gr_set_current_canvas(saved_canvas);
213 saved_interp_method=Interpolation_method;
214 Interpolation_method = 3; // The best, albiet slowest.
215 g3_draw_tmap(4,pointlist,uvl,&reticle_canvas->cv_bitmap);
216 Interpolation_method = saved_interp_method;
220 extern fix Seismic_tremor_magnitude;
224 #define FLASH_CYCLE_RATE f1_0
226 fix Flash_rate = FLASH_CYCLE_RATE;
228 //cycle the flashing light for when mine destroyed
231 static fixang flash_ang=0;
233 if (!Control_center_destroyed && !Seismic_tremor_magnitude)
236 if (Endlevel_sequence)
239 if (PaletteBlueAdd > 10 ) //whiting out
242 // flash_ang += fixmul(FLASH_CYCLE_RATE,FrameTime);
243 if (Seismic_tremor_magnitude) {
246 added_flash = abs(Seismic_tremor_magnitude);
247 if (added_flash < F1_0)
250 flash_ang += fixmul(Flash_rate, fixmul(FrameTime, added_flash+F1_0));
251 fix_fastsincos(flash_ang,&flash_scale,NULL);
252 flash_scale = (flash_scale + F1_0*3)/4; // gets in range 0.5 to 1.0
254 flash_ang += fixmul(Flash_rate,FrameTime);
255 fix_fastsincos(flash_ang,&flash_scale,NULL);
256 flash_scale = (flash_scale + f1_0)/2;
257 if (Difficulty_level == 0)
258 flash_scale = (flash_scale+F1_0*3)/4;
264 // ----------------------------------------------------------------------------
266 // It would be nice to not have to pass in segnum and sidenum, but
267 // they are used for our hideously hacked in headlight system.
268 // vp is a pointer to vertex ids.
269 // tmap1, tmap2 are texture map ids. tmap2 is the pasty one.
270 void render_face(int segnum, int sidenum, int nv, short *vp, int tmap1, int tmap2, uvl *uvlp, int wid_flags)
272 // -- Using new headlight system...fix face_light;
275 grs_bitmap *bm2 = NULL;
281 g3s_point *pointlist[8];
285 for (i=0; i<nv; i++) {
286 uvl_copy[i] = uvlp[i];
287 pointlist[i] = &Segment_points[vp[i]];
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)
297 g3_draw_poly(nv, pointlist); // draw as flat poly
299 Gr_scanline_darkening_level = GR_FADE_LEVELS;
304 // -- Using new headlight system...face_light = -vm_vec_dot(&Viewer->orient.fvec,norm);
306 if (tmap1 >= NumTextures) {
307 mprintf((0,"Invalid tmap number %d, NumTextures=%d, changing to 0\n",tmap1,NumTextures));
313 Segments[segnum].sides[sidenum].tmap_num = 0;
317 if (ogl_alttexmerge){
318 PIGGY_PAGE_IN(Textures[tmap1]);
319 bm = &GameBitmaps[Textures[tmap1].index];
321 PIGGY_PAGE_IN(Textures[tmap2&0x3FFF]);
322 bm2 = &GameBitmaps[Textures[tmap2&0x3FFF].index];
324 if (!OGL_SUPER_TRANSPARENT_OK && bm2 && (bm2->bm_flags & BM_FLAG_SUPER_TRANSPARENT))
326 bm = texmerge_get_cached_bitmap( tmap1, tmap2 );
332 // New code for overlapping textures...
334 bm = texmerge_get_cached_bitmap( tmap1, tmap2 );
336 bm = &GameBitmaps[Textures[tmap1].index];
337 PIGGY_PAGE_IN(Textures[tmap1]);
340 Assert( !(bm->bm_flags & BM_FLAG_PAGED_OUT) );
342 //reflect = fl2f((1.0-TmapInfo[p->tmap_num].reflect)/2.0 + 0.5);
343 //reflect = fl2f((1.0-TmapInfo[p->tmap_num].reflect));
345 reflect = Face_reflectivity; // f1_0; //until we figure this stuff out...
347 //set light values for each vertex & build pointlist
351 // -- Using new headlight system...face_light = fixmul(face_light,reflect);
355 //the uvl struct has static light already in it
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);
361 //add in dynamic light (from explosions, etc.)
362 uvl_copy[i].l += Dynamic_light[vp[i]];
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);
367 //saturate at max value
368 if (uvl_copy[i].l > MAX_LIGHT)
369 uvl_copy[i].l = MAX_LIGHT;
375 if ((Render_only_bottom) && (sidenum == WBOTTOM))
376 g3_draw_tmap(nv,pointlist,(g3s_uvl *) uvl_copy,&GameBitmaps[Textures[Bottom_bitmap_num].index]);
382 g3_draw_tmap_2(nv,pointlist,(g3s_uvl *) uvl_copy,bm,bm2,((tmap2&0xC000)>>14) & 3);
385 g3_draw_tmap(nv,pointlist,(g3s_uvl *) uvl_copy,bm);
388 if (Outline_mode) draw_outline(nv, pointlist);
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)
404 g3s_point *pointlist[4];
407 bm = texmerge_get_cached_bitmap( tmap1, tmap2 );
409 bm = &GameBitmaps[Textures[tmap1].index];
411 for (i=0; i<nv; i++) {
412 uvl_copy[i] = uvlp[i];
413 pointlist[i] = &Segment_points[vp[i]];
417 gr_pixel(_search_x,_search_y); //set our search pixel to color zero
418 gr_setcolor(1); //and render in color one
419 save_lighting = Lighting_on;
421 //g3_draw_poly(nv,vp);
422 g3_draw_tmap(nv,pointlist, (g3s_uvl *)uvl_copy, bm);
423 Lighting_on = save_lighting;
425 if (gr_ugpixel(&grd_curcanv->cv_bitmap,_search_x,_search_y) == 1) {
427 found_side = sidenum;
428 found_face = facenum;
434 fix Tulate_min_dot = (F1_0/4);
435 //--unused-- fix Tulate_min_ratio = (2*F1_0);
436 fix Min_n0_n1_dot = (F1_0*15/16);
438 extern int contains_flare(segment *segp, int sidenum);
439 extern fix Obj_light_xlate[16];
441 // -----------------------------------------------------------------------------------
443 // Check for normal facing. If so, render faces on side dictated by sidep->type.
444 void render_side(segment *segp, int sidenum)
446 short vertnum_list[4];
447 side *sidep = &segp->sides[sidenum];
449 fix v_dot_n0, v_dot_n1;
451 fix min_dot, max_dot;
452 vms_vector normals[2];
456 wid_flags = WALL_IS_DOORWAY(segp,sidenum);
458 if (!(wid_flags & WID_RENDER_FLAG)) //if (WALL_IS_DOORWAY(segp, sidenum) == WID_NO_WALL)
462 get_side_normals(segp, sidenum, &normals[0], &normals[1] );
464 normals[0] = segp->sides[sidenum].normals[0];
465 normals[1] = segp->sides[sidenum].normals[1];
468 // ========== Mark: Here is the change...beginning here: ==========
470 if (sidep->type == SIDE_IS_QUAD) {
472 vm_vec_sub(&tvec, &Viewer_eye, &Vertices[segp->verts[Side_to_verts[sidenum][0]]]);
474 // -- Old, slow way -- // Regardless of whether this side is comprised of a single quad, or two triangles, we need to know one normal, so
475 // -- Old, slow way -- // deal with it, get the dot product.
476 // -- Old, slow way -- if (sidep->type == SIDE_IS_TRI_13)
477 // -- Old, slow way -- vm_vec_normalized_dir(&tvec, &Viewer_eye, &Vertices[segp->verts[Side_to_verts[sidenum][1]]]);
478 // -- Old, slow way -- else
479 // -- Old, slow way -- vm_vec_normalized_dir(&tvec, &Viewer_eye, &Vertices[segp->verts[Side_to_verts[sidenum][0]]]);
481 get_side_verts(vertnum_list, SEGMENT_NUMBER(segp), sidenum);
482 v_dot_n0 = vm_vec_dot(&tvec, &normals[0]);
484 // -- flare creates point -- {
485 // -- flare creates point -- int flare_index;
486 // -- flare creates point --
487 // -- flare creates point -- flare_index = contains_flare(segp, sidenum);
488 // -- flare creates point --
489 // -- flare creates point -- if (flare_index != -1) {
490 // -- flare creates point -- int tri;
491 // -- flare creates point -- fix u, v, l;
492 // -- flare creates point -- vms_vector *hit_point;
493 // -- flare creates point -- short vertnum_list[4];
494 // -- flare creates point --
495 // -- flare creates point -- hit_point = &Objects[flare_index].pos;
496 // -- flare creates point --
497 // -- flare creates point -- find_hitpoint_uv( &u, &v, &l, hit_point, segp, sidenum, 0); // last parm means always use face 0.
498 // -- flare creates point --
499 // -- flare creates point -- get_side_verts(vertnum_list, SEGMENT_NUMBER(segp), sidenum);
500 // -- flare creates point --
501 // -- flare creates point -- g3_rotate_point(&Segment_points[MAX_VERTICES-1], hit_point);
502 // -- flare creates point --
503 // -- flare creates point -- for (tri=0; tri<4; tri++) {
504 // -- flare creates point -- short tri_verts[3];
505 // -- flare creates point -- uvl tri_uvls[3];
506 // -- flare creates point --
507 // -- flare creates point -- tri_verts[0] = vertnum_list[tri];
508 // -- flare creates point -- tri_verts[1] = vertnum_list[(tri+1) % 4];
509 // -- flare creates point -- tri_verts[2] = MAX_VERTICES-1;
510 // -- flare creates point --
511 // -- flare creates point -- tri_uvls[0] = sidep->uvls[tri];
512 // -- flare creates point -- tri_uvls[1] = sidep->uvls[(tri+1)%4];
513 // -- flare creates point -- tri_uvls[2].u = u;
514 // -- flare creates point -- tri_uvls[2].v = v;
515 // -- flare creates point -- tri_uvls[2].l = F1_0;
516 // -- flare creates point --
517 // -- flare creates point -- render_face(SEGMENT_NUMBER(segp), sidenum, 3, tri_verts, sidep->tmap_num, sidep->tmap_num2, tri_uvls, &normals[0]);
518 // -- flare creates point -- }
519 // -- flare creates point --
520 // -- flare creates point -- return;
521 // -- flare creates point -- }
522 // -- flare creates point -- }
525 render_face(SEGMENT_NUMBER(segp), sidenum, 4, vertnum_list, sidep->tmap_num, sidep->tmap_num2, sidep->uvls, wid_flags);
527 check_face(SEGMENT_NUMBER(segp), sidenum, 0, 4, vertnum_list, sidep->tmap_num, sidep->tmap_num2, sidep->uvls);
531 // Regardless of whether this side is comprised of a single quad, or two triangles, we need to know one normal, so
532 // deal with it, get the dot product.
533 if (sidep->type == SIDE_IS_TRI_13)
534 vm_vec_normalized_dir_quick(&tvec, &Viewer_eye, &Vertices[segp->verts[Side_to_verts[sidenum][1]]]);
536 vm_vec_normalized_dir_quick(&tvec, &Viewer_eye, &Vertices[segp->verts[Side_to_verts[sidenum][0]]]);
538 get_side_verts(vertnum_list, SEGMENT_NUMBER(segp), sidenum);
540 v_dot_n0 = vm_vec_dot(&tvec, &normals[0]);
542 // ========== Mark: The change ends here. ==========
544 // Although this side has been triangulated, because it is not planar, see if it is acceptable
545 // to render it as a single quadrilateral. This is a function of how far away the viewer is, how non-planar
546 // the face is, how normal to the surfaces the view is.
547 // Now, if both dot products are close to 1.0, then render two triangles as a single quad.
548 v_dot_n1 = vm_vec_dot(&tvec, &normals[1]);
550 if (v_dot_n0 < v_dot_n1) {
558 // Determine whether to detriangulate side: (speed hack, assumes Tulate_min_ratio == F1_0*2, should fixmul(min_dot, Tulate_min_ratio))
559 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 // The other detriangulation code doesn't deal well with badly non-planar sides.
563 n0_dot_n1 = vm_vec_dot(&normals[0], &normals[1]);
564 if (n0_dot_n1 < Min_n0_n1_dot)
567 render_face(SEGMENT_NUMBER(segp), sidenum, 4, vertnum_list, sidep->tmap_num, sidep->tmap_num2, sidep->uvls, wid_flags);
569 check_face(SEGMENT_NUMBER(segp), sidenum, 0, 4, vertnum_list, sidep->tmap_num, sidep->tmap_num2, sidep->uvls);
573 if (sidep->type == SIDE_IS_TRI_02) {
575 render_face(SEGMENT_NUMBER(segp), sidenum, 3, vertnum_list, sidep->tmap_num, sidep->tmap_num2, sidep->uvls, wid_flags);
577 check_face(SEGMENT_NUMBER(segp), sidenum, 0, 3, vertnum_list, sidep->tmap_num, sidep->tmap_num2, sidep->uvls);
582 temp_uvls[0] = sidep->uvls[0]; temp_uvls[1] = sidep->uvls[2]; temp_uvls[2] = sidep->uvls[3];
583 vertnum_list[1] = vertnum_list[2]; vertnum_list[2] = vertnum_list[3]; // want to render from vertices 0, 2, 3 on side
584 render_face(SEGMENT_NUMBER(segp), sidenum, 3, &vertnum_list[0], sidep->tmap_num, sidep->tmap_num2, temp_uvls, wid_flags);
586 check_face(SEGMENT_NUMBER(segp), sidenum, 1, 3, vertnum_list, sidep->tmap_num, sidep->tmap_num2, sidep->uvls);
589 } else if (sidep->type == SIDE_IS_TRI_13) {
591 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
593 check_face(SEGMENT_NUMBER(segp), sidenum, 1, 3, &vertnum_list[1], sidep->tmap_num, sidep->tmap_num2, sidep->uvls);
598 temp_uvls[0] = sidep->uvls[0]; temp_uvls[1] = sidep->uvls[1]; temp_uvls[2] = sidep->uvls[3];
599 vertnum_list[2] = vertnum_list[3]; // want to render from vertices 0,1,3
600 render_face(SEGMENT_NUMBER(segp), sidenum, 3, vertnum_list, sidep->tmap_num, sidep->tmap_num2, temp_uvls, wid_flags);
602 check_face(SEGMENT_NUMBER(segp), sidenum, 0, 3, vertnum_list, sidep->tmap_num, sidep->tmap_num2, sidep->uvls);
607 Error("Illegal side type in render_side, type = %i, segment # = %i, side # = %i\n", sidep->type, SEGMENT_NUMBER(segp), sidenum);
614 void render_object_search(object *obj)
618 //note that we draw each pixel object twice, since we cannot control
619 //what color the object draws in, so we try color 0, then color 1,
620 //in case the object itself is rendering color 0
623 gr_pixel(_search_x,_search_y); //set our search pixel to color zero
625 if (gr_ugpixel(&grd_curcanv->cv_bitmap,_search_x,_search_y) != 0)
629 gr_pixel(_search_x,_search_y); //set our search pixel to color zero
631 if (gr_ugpixel(&grd_curcanv->cv_bitmap,_search_x,_search_y) != 1)
635 if (obj->segnum != -1)
636 Cursegp = &Segments[obj->segnum];
637 found_seg = -(OBJECT_NUMBER(obj)+1);
642 extern ubyte DemoDoingRight,DemoDoingLeft;
644 void do_render_object(int objnum, int window_num)
647 int save_3d_outline=0;
649 object *obj = &Objects[objnum];
653 Assert(objnum < MAX_OBJECTS);
656 if (object_rendered[objnum]) { //already rendered this...
657 Int3(); //get Matt!!!
661 object_rendered[objnum] = 1;
664 if (Newdemo_state==ND_STATE_PLAYBACK)
666 if ((DemoDoingLeft==6 || DemoDoingRight==6) && Objects[objnum].type==OBJ_PLAYER)
668 // A nice fat hack: keeps the player ship from showing up in the
669 // small extra view when guiding a missile in the big window
671 mprintf ((0,"Returning from render_object prematurely...\n"));
676 // Added by MK on 09/07/94 (at about 5:28 pm, CDT, on a beautiful, sunny late summer day!) so
677 // that the guided missile system will know what objects to look at.
678 // I didn't know we had guided missiles before the release of D1. --MK
679 if ((Objects[objnum].type == OBJ_ROBOT) || (Objects[objnum].type == OBJ_PLAYER)) {
680 //Assert(Window_rendered_data[window_num].rendered_objects < MAX_RENDERED_OBJECTS);
681 // This peculiar piece of code makes us keep track of the most recently rendered objects, which
682 // are probably the higher priority objects, without overflowing the buffer
683 if (Window_rendered_data[window_num].num_objects >= MAX_RENDERED_OBJECTS) {
685 Window_rendered_data[window_num].num_objects /= 2;
687 Window_rendered_data[window_num].rendered_objects[Window_rendered_data[window_num].num_objects++] = objnum;
690 if ((count++ > MAX_OBJECTS) || (obj->next == objnum)) {
691 Int3(); // infinite loop detected
692 obj->next = -1; // won't this clean things up?
693 return; // get out of this infinite loop!
696 //g3_draw_object(obj->class_id,&obj->pos,&obj->orient,obj->size);
698 //check for editor object
701 if (Function_mode==FMODE_EDITOR && objnum==Cur_object_index) {
702 save_3d_outline = g3d_interp_outline;
703 g3d_interp_outline=1;
709 render_object_search(obj);
715 for (n=obj->attached_obj;n!=-1;n=Objects[n].ctype.expl_info.next_attach) {
717 Assert(Objects[n].type == OBJ_FIREBALL);
718 Assert(Objects[n].control_type == CT_EXPLOSION);
719 Assert(Objects[n].flags & OF_ATTACHED);
721 render_object(&Objects[n]);
726 if (Function_mode==FMODE_EDITOR && objnum==Cur_object_index)
727 g3d_interp_outline = save_3d_outline;
731 //DEBUG mprintf( (0, "%d ", objnum ));
737 int window_check=1,draw_edges=0,new_seg_sorting=1,pre_draw_segs=0;
738 int no_migrate_segs=1,migrate_objects=1,behind_check=1;
739 int check_window_check=0;
742 #define window_check 1
744 #define new_seg_sorting 1
745 #define pre_draw_segs 0
746 #define no_migrate_segs 1
747 #define migrate_objects 1
748 #define behind_check 1
749 #define check_window_check 0
752 //increment counter for checking if points rotated
753 //This must be called at the start of the frame if rotate_list() will be used
754 void render_start_frame()
758 if (RL_framecount==0) { //wrap!
760 memset(Rotated_last,0,sizeof(Rotated_last)); //clear all to zero
761 RL_framecount=1; //and set this frame to 1
765 //Given a lit of point numbers, rotate any that haven't been rotated this frame
766 g3s_codes rotate_list(int nv,short *pointnumlist)
772 cc.and = 0xff; cc.or = 0;
776 pnum = pointnumlist[i];
778 pnt = &Segment_points[pnum];
780 if (Rotated_last[pnum] != RL_framecount) {
782 g3_rotate_point(pnt,&Vertices[pnum]);
784 Rotated_last[pnum] = RL_framecount;
787 cc.and &= pnt->p3_codes;
788 cc.or |= pnt->p3_codes;
795 //Given a lit of point numbers, project any that haven't been projected
796 void project_list(int nv,short *pointnumlist)
802 pnum = pointnumlist[i];
804 if (!(Segment_points[pnum].p3_flags & PF_PROJECTED))
806 g3_project_point(&Segment_points[pnum]);
812 // -----------------------------------------------------------------------------------
813 void render_segment(int segnum, int window_num)
815 segment *seg = &Segments[segnum];
819 Assert(segnum!=-1 && segnum<=Highest_segment_index);
821 cc=rotate_list(8,seg->verts);
823 if (! cc.and) { //all off screen?
825 //mprintf( (0, "!"));
826 //DEBUG mprintf( (0, "[Segment %d: ", segnum ));
828 // set_segment_local_light_value(segnum,INITIAL_LOCAL_LIGHT);
830 if (Viewer->type!=OBJ_ROBOT)
831 Automap_visited[segnum]=1;
833 for (sn=0; sn<MAX_SIDES_PER_SEGMENT; sn++)
834 render_side(seg, sn);
837 //draw any objects that happen to be in this segment
840 //object_sort_segment_objects( seg );
843 if (!migrate_objects) {
845 for (objnum=seg->objects;objnum!=-1;objnum=Objects[objnum].next)
846 do_render_object(objnum, window_num);
850 //DEBUG mprintf( (0, "]\n", segnum ));
854 // ----- This used to be called when Show_only_curside was set.
855 // ----- It is wholly and superiorly replaced by render_side.
856 // -- //render one side of one segment
857 // -- void render_seg_side(segment *seg,int _side)
860 // -- short vertnum_list[4];
862 // -- cc=g3_rotate_list(8,&seg->verts);
864 // -- if (! cc.and) { //all off screen?
870 // -- s=&seg->sides[_side];
872 // -- for (f=s->faces,fn=s->num_faces;fn;fn--,f++)
873 // -- for (p=f->polys,pn=f->num_polys;pn;pn--,p++) {
874 // -- grs_bitmap *tmap;
876 // -- for (i=0;i<p->num_vertices;i++) vertnum_list[i] = seg->verts[p->verts[i]];
878 // -- if (p->tmap_num >= NumTextures) {
879 // -- Warning("Invalid tmap number %d, NumTextures=%d\n...Changing in poly structure to tmap 0",p->tmap_num,NumTextures);
880 // -- p->tmap_num = 0; //change it permanantly
883 // -- tmap = Textures[p->tmap_num];
885 // -- g3_check_and_draw_tmap(p->num_vertices,vertnum_list,(g3s_uvl *) &p->uvls,tmap,&f->normal);
887 // -- if (Outline_mode) draw_outline(p->num_vertices,vertnum_list);
893 #define CROSS_WIDTH i2f(8)
894 #define CROSS_HEIGHT i2f(8)
898 //draw outline for curside
899 void outline_seg_side(segment *seg,int _side,int edge,int vert)
903 cc=rotate_list(8,seg->verts);
905 if (! cc.and) { //all off screen?
909 s=&seg->sides[_side];
911 //render curedge of curside of curseg in green
913 gr_setcolor(BM_XRGB(0,63,0));
914 g3_draw_line(&Segment_points[seg->verts[Side_to_verts[_side][edge]]],&Segment_points[seg->verts[Side_to_verts[_side][(edge+1)%4]]]);
916 //draw a little cross at the current vert
918 pnt = &Segment_points[seg->verts[Side_to_verts[_side][vert]]];
920 g3_project_point(pnt); //make sure projected
922 // gr_setcolor(BM_XRGB(0,0,63));
923 // gr_line(pnt->p3_sx-CROSS_WIDTH,pnt->p3_sy,pnt->p3_sx+CROSS_WIDTH,pnt->p3_sy);
924 // gr_line(pnt->p3_sx,pnt->p3_sy-CROSS_HEIGHT,pnt->p3_sx,pnt->p3_sy+CROSS_HEIGHT);
926 gr_line(pnt->p3_sx-CROSS_WIDTH,pnt->p3_sy,pnt->p3_sx,pnt->p3_sy-CROSS_HEIGHT);
927 gr_line(pnt->p3_sx,pnt->p3_sy-CROSS_HEIGHT,pnt->p3_sx+CROSS_WIDTH,pnt->p3_sy);
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);
935 #if 0 //this stuff could probably just be deleted
937 #define DEFAULT_PERSPECTIVE_DEPTH 6
939 int Perspective_depth=DEFAULT_PERSPECTIVE_DEPTH; //how many levels deep to render in perspective
941 int inc_perspective_depth(void)
943 return ++Perspective_depth;
947 int dec_perspective_depth(void)
949 return Perspective_depth==1?Perspective_depth:--Perspective_depth;
953 int reset_perspective_depth(void)
955 return Perspective_depth = DEFAULT_PERSPECTIVE_DEPTH;
960 typedef struct window {
961 short left,top,right,bot;
964 ubyte code_window_point(fix x,fix y,window *w)
968 if (x <= w->left) code |= 1;
969 if (x >= w->right) code |= 2;
971 if (y <= w->top) code |= 4;
972 if (y >= w->bot) code |= 8;
978 void draw_window_box(int color,short left,short top,short right,short bot)
984 l=left; t=top; r=right; b=bot;
986 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))
991 if (r>=grd_curcanv->cv_bitmap.bm_w) r=grd_curcanv->cv_bitmap.bm_w-1;
992 if (b>=grd_curcanv->cv_bitmap.bm_h) b=grd_curcanv->cv_bitmap.bm_h-1;
994 gr_line(i2f(l),i2f(t),i2f(r),i2f(t));
995 gr_line(i2f(r),i2f(t),i2f(r),i2f(b));
996 gr_line(i2f(r),i2f(b),i2f(l),i2f(b));
997 gr_line(i2f(l),i2f(b),i2f(l),i2f(t));
1002 int matt_find_connect_side(int seg0,int seg1);
1005 char visited2[MAX_SEGMENTS];
1008 unsigned char visited[MAX_SEGMENTS];
1009 short Render_list[MAX_RENDER_SEGS];
1010 short Seg_depth[MAX_RENDER_SEGS]; //depth for each seg in Render_list
1011 ubyte processed[MAX_RENDER_SEGS]; //whether each entry has been processed
1012 int lcnt_save,scnt_save;
1013 //@@short *persp_ptr;
1014 short render_pos[MAX_SEGMENTS]; //where in render_list does this segment appear?
1015 //ubyte no_render_flag[MAX_RENDER_SEGS];
1016 window render_windows[MAX_RENDER_SEGS];
1018 short render_obj_list[MAX_RENDER_SEGS+N_EXTRA_OBJ_LISTS][OBJS_PER_SEG];
1024 #define RED BM_XRGB(63,0,0)
1025 #define WHITE BM_XRGB(63,63,63)
1027 //Given two sides of segment, tell the two verts which form the
1029 short Two_sides_to_edge[6][6][2] = {
1030 { {-1,-1}, {3,7}, {-1,-1}, {2,6}, {6,7}, {2,3} },
1031 { {3,7}, {-1,-1}, {0,4}, {-1,-1}, {4,7}, {0,3} },
1032 { {-1,-1}, {0,4}, {-1,-1}, {1,5}, {4,5}, {0,1} },
1033 { {2,6}, {-1,-1}, {1,5}, {-1,-1}, {5,6}, {1,2} },
1034 { {6,7}, {4,7}, {4,5}, {5,6}, {-1,-1}, {-1,-1} },
1035 { {2,3}, {0,3}, {0,1}, {1,2}, {-1,-1}, {-1,-1} }
1038 //given an edge specified by two verts, give the two sides on that edge
1039 int Edge_to_sides[8][8][2] = {
1040 { {-1,-1}, {2,5}, {-1,-1}, {1,5}, {1,2}, {-1,-1}, {-1,-1}, {-1,-1} },
1041 { {2,5}, {-1,-1}, {3,5}, {-1,-1}, {-1,-1}, {2,3}, {-1,-1}, {-1,-1} },
1042 { {-1,-1}, {3,5}, {-1,-1}, {0,5}, {-1,-1}, {-1,-1}, {0,3}, {-1,-1} },
1043 { {1,5}, {-1,-1}, {0,5}, {-1,-1}, {-1,-1}, {-1,-1}, {-1,-1}, {0,1} },
1044 { {1,2}, {-1,-1}, {-1,-1}, {-1,-1}, {-1,-1}, {2,4}, {-1,-1}, {1,4} },
1045 { {-1,-1}, {2,3}, {-1,-1}, {-1,-1}, {2,4}, {-1,-1}, {3,4}, {-1,-1} },
1046 { {-1,-1}, {-1,-1}, {0,3}, {-1,-1}, {-1,-1}, {3,4}, {-1,-1}, {0,4} },
1047 { {-1,-1}, {-1,-1}, {-1,-1}, {0,1}, {1,4}, {-1,-1}, {0,4}, {-1,-1} },
1050 //@@//perform simple check on tables
1055 //@@ for (i=0;i<8;i++)
1056 //@@ for (j=0;j<8;j++)
1057 //@@ Assert(Edge_to_sides[i][j][0] == Edge_to_sides[j][i][0] &&
1058 //@@ Edge_to_sides[i][j][1] == Edge_to_sides[j][i][1]);
1060 //@@ for (i=0;i<6;i++)
1061 //@@ for (j=0;j<6;j++)
1062 //@@ Assert(Two_sides_to_edge[i][j][0] == Two_sides_to_edge[j][i][0] &&
1063 //@@ Two_sides_to_edge[i][j][1] == Two_sides_to_edge[j][i][1]);
1069 //given an edge, tell what side is on that edge
1070 int find_seg_side(segment *seg,short *verts,int notside)
1085 for (i=0; i<8; i++) {
1086 int svv = *vp++; // seg->verts[i];
1088 if (vv0==-1 && svv == v0) {
1094 if (vv1==-1 && svv == v1) {
1101 Assert(vv0!=-1 && vv1!=-1);
1103 eptr = Edge_to_sides[vv0][vv1];
1108 Assert(side0!=-1 && side1!=-1);
1110 if (side0 != notside) {
1111 Assert(side1==notside);
1115 Assert(side0==notside);
1121 //find the two segments that join a given seg though two sides, and
1122 //the sides of those segments the abut.
1123 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)
1125 segment *seg0,*seg1;
1126 short edge_verts[2];
1127 int notside0,notside1;
1128 int edgeside0,edgeside1;
1130 Assert(s0!=-1 && s1!=-1);
1132 seg0 = &Segments[seg->children[s0]];
1133 seg1 = &Segments[seg->children[s1]];
1135 edge_verts[0] = seg->verts[Two_sides_to_edge[s0][s1][0]];
1136 edge_verts[1] = seg->verts[Two_sides_to_edge[s0][s1][1]];
1138 Assert(edge_verts[0]!=-1 && edge_verts[1]!=-1);
1140 notside0 = find_connect_side(seg,seg0);
1141 Assert(notside0 != -1);
1142 notside1 = find_connect_side(seg,seg1);
1143 Assert(notside1 != -1);
1145 edgeside0 = find_seg_side(seg0,edge_verts,notside0);
1146 edgeside1 = find_seg_side(seg1,edge_verts,notside1);
1148 //deal with the case where an edge is shared by more than two segments
1150 //@@ if (IS_CHILD(seg0->children[edgeside0])) {
1151 //@@ segment *seg00;
1154 //@@ seg00 = &Segments[seg0->children[edgeside0]];
1156 //@@ if (seg00 != seg1) {
1158 //@@ notside00 = find_connect_side(seg0,seg00);
1159 //@@ Assert(notside00 != -1);
1161 //@@ edgeside0 = find_seg_side(seg00,edge_verts,notside00);
1167 //@@ if (IS_CHILD(seg1->children[edgeside1])) {
1168 //@@ segment *seg11;
1171 //@@ seg11 = &Segments[seg1->children[edgeside1]];
1173 //@@ if (seg11 != seg0) {
1174 //@@ notside11 = find_connect_side(seg1,seg11);
1175 //@@ Assert(notside11 != -1);
1177 //@@ edgeside1 = find_seg_side(seg11,edge_verts,notside11);
1182 // if ( IS_CHILD(seg0->children[edgeside0]) ||
1183 // IS_CHILD(seg1->children[edgeside1]))
1187 get_side_normals(seg0, edgeside0, norm0_0, norm0_1 );
1188 get_side_normals(seg1, edgeside1, norm1_0, norm1_1 );
1190 *norm0_0 = seg0->sides[edgeside0].normals[0];
1191 *norm0_1 = seg0->sides[edgeside0].normals[1];
1192 *norm1_0 = seg1->sides[edgeside1].normals[0];
1193 *norm1_1 = seg1->sides[edgeside1].normals[1];
1196 *pnt0 = &Vertices[seg0->verts[Side_to_verts[edgeside0][seg0->sides[edgeside0].type==3?1:0]]];
1197 *pnt1 = &Vertices[seg1->verts[Side_to_verts[edgeside1][seg1->sides[edgeside1].type==3?1:0]]];
1202 //see if the order matters for these two children.
1203 //returns 0 if order doesn't matter, 1 if c0 before c1, -1 if c1 before c0
1204 int compare_children(segment *seg,short c0,short c1)
1206 vms_vector norm0_0,norm0_1,*pnt0,temp;
1207 vms_vector norm1_0,norm1_1,*pnt1;
1208 fix d0_0,d0_1,d1_0,d1_1,d0,d1;
1211 if (Side_opposite[c0] == c1) return 0;
1213 Assert(c0!=-1 && c1!=-1);
1215 //find normals of adjoining sides
1217 t = find_joining_side_norms(&norm0_0,&norm0_1,&norm1_0,&norm1_1,&pnt0,&pnt1,seg,c0,c1);
1222 vm_vec_sub(&temp,&Viewer_eye,pnt0);
1223 d0_0 = vm_vec_dot(&norm0_0,&temp);
1224 d0_1 = vm_vec_dot(&norm0_1,&temp);
1226 vm_vec_sub(&temp,&Viewer_eye,pnt1);
1227 d1_0 = vm_vec_dot(&norm1_0,&temp);
1228 d1_1 = vm_vec_dot(&norm1_1,&temp);
1230 d0 = (d0_0 < 0 || d0_1 < 0)?-1:1;
1231 d1 = (d1_0 < 0 || d1_1 < 0)?-1:1;
1233 if (d0 < 0 && d1 < 0)
1245 int ssc_total=0,ssc_swaps=0;
1247 //short the children of segment to render in the correct order
1248 //returns non-zero if swaps were made
1249 int sort_seg_children(segment *seg,int n_children,short *child_list)
1253 int made_swaps,count;
1255 if (n_children == 0) return 0;
1259 //for each child, compare with other children and see if order matters
1260 //if order matters, fix if wrong
1267 for (i=0;i<n_children-1;i++)
1268 for (j=i+1;child_list[i]!=-1 && j<n_children;j++)
1269 if (child_list[j]!=-1) {
1270 r = compare_children(seg,child_list[i],child_list[j]);
1273 int temp = child_list[i];
1274 child_list[i] = child_list[j];
1275 child_list[j] = temp;
1280 } while (made_swaps && ++count<n_children);
1288 void add_obj_to_seglist(int objnum,int listnum)
1290 int i,checkn,marker;
1294 //first, find a slot
1296 //mprintf((0,"adding obj %d to %d",objnum,listnum));
1300 for (i=0;render_obj_list[checkn][i] >= 0;i++);
1302 Assert(i < OBJS_PER_SEG);
1304 marker = render_obj_list[checkn][i];
1308 //Assert(checkn < MAX_RENDER_SEGS+N_EXTRA_OBJ_LISTS);
1309 if (checkn >= MAX_RENDER_SEGS+N_EXTRA_OBJ_LISTS) {
1315 } while (marker != -1);
1317 //mprintf((0," slot %d,%d",checkn,i));
1320 //now we have found a slot. put object in it
1322 if (i != OBJS_PER_SEG-1) {
1324 render_obj_list[checkn][i] = objnum;
1325 render_obj_list[checkn][i+1] = -1;
1327 else { //chain to additional list
1330 //find an available sublist
1332 for (lookn=MAX_RENDER_SEGS;render_obj_list[lookn][0]!=-1 && lookn<MAX_RENDER_SEGS+N_EXTRA_OBJ_LISTS;lookn++);
1334 //Assert(lookn<MAX_RENDER_SEGS+N_EXTRA_OBJ_LISTS);
1335 if (lookn >= MAX_RENDER_SEGS+N_EXTRA_OBJ_LISTS) {
1340 render_obj_list[checkn][i] = -lookn;
1341 render_obj_list[lookn][0] = objnum;
1342 render_obj_list[lookn][1] = -1;
1346 //mprintf((0," added!\n"));
1350 // the following is a drop-in replacement for the broken libc qsort on solaris
1351 // taken from http://www.snippets.org/snippets/portable/RG_QSORT+C.php3
1353 #define qsort qsort_dropin
1355 /******************************************************************/
1356 /* qsort.c -- Non-Recursive ANSI Quicksort function */
1357 /* Public domain by Raymond Gardner, Englewood CO February 1991 */
1358 /******************************************************************/
1359 #define COMP(a, b) ((*comp)((void *)(a), (void *)(b)))
1360 #define T 7 // subfiles of <= T elements will be insertion sorteded (T >= 3)
1361 #define SWAP(a, b) (swap_bytes((char *)(a), (char *)(b), size))
1363 static void swap_bytes(char *a, char *b, size_t nbytes)
1367 tmp = *a; *a++ = *b; *b++ = tmp;
1368 } while ( --nbytes );
1371 void qsort(void *basep, size_t nelems, size_t size,
1372 int (*comp)(const void *, const void *))
1374 char *stack[40], **sp; /* stack and stack pointer */
1375 char *i, *j, *limit; /* scan and limit pointers */
1376 size_t thresh; /* size of T elements in bytes */
1377 char *base; /* base pointer as char * */
1378 base = (char *)basep; /* set up char * base pointer */
1379 thresh = T * size; /* init threshold */
1380 sp = stack; /* init stack pointer */
1381 limit = base + nelems * size;/* pointer past end of array */
1382 for ( ;; ) { /* repeat until break... */
1383 if ( limit - base > thresh ) { /* if more than T elements */
1384 /* swap base with middle */
1385 SWAP((((limit-base)/size)/2)*size+base, base);
1386 i = base + size; /* i scans left to right */
1387 j = limit - size; /* j scans right to left */
1388 if ( COMP(i, j) > 0 ) /* Sedgewick's */
1389 SWAP(i, j); /* three-element sort */
1390 if ( COMP(base, j) > 0 ) /* sets things up */
1391 SWAP(base, j); /* so that */
1392 if ( COMP(i, base) > 0 ) /* *i <= *base <= *j */
1393 SWAP(i, base); /* *base is pivot element */
1394 for ( ;; ) { /* loop until break */
1395 do /* move i right */
1396 i += size; /* until *i >= pivot */
1397 while ( COMP(i, base) < 0 );
1398 do /* move j left */
1399 j -= size; /* until *j <= pivot */
1400 while ( COMP(j, base) > 0 );
1401 if ( i > j ) /* if pointers crossed */
1402 break; /* break loop */
1403 SWAP(i, j); /* else swap elements, keep scanning*/
1405 SWAP(base, j); /* move pivot into correct place */
1406 if ( j - base > limit - i ) { /* if left subfile larger */
1407 sp[0] = base; /* stack left subfile base */
1408 sp[1] = j; /* and limit */
1409 base = i; /* sort the right subfile */
1410 } else { /* else right subfile larger*/
1411 sp[0] = i; /* stack right subfile base */
1412 sp[1] = limit; /* and limit */
1413 limit = j; /* sort the left subfile */
1415 sp += 2; /* increment stack pointer */
1416 } else { /* else subfile is small, use insertion sort */
1417 for ( j = base, i = j+size; i < limit; j = i, i += size )
1418 for ( ; COMP(j, j+size) > 0; j -= size ) {
1423 if ( sp != stack ) { /* if any entries on stack */
1424 sp -= 2; /* pop the base and limit */
1427 } else /* else stack empty, done */
1432 #endif // __sun__ qsort drop-in replacement
1434 #define SORT_LIST_SIZE 100
1436 typedef struct sort_item {
1441 sort_item sort_list[SORT_LIST_SIZE];
1444 //compare function for object sort.
1445 int sort_func(const sort_item *a,const sort_item *b)
1448 object *obj_a,*obj_b;
1450 delta_dist = a->dist - b->dist;
1452 obj_a = &Objects[a->objnum];
1453 obj_b = &Objects[b->objnum];
1455 if (abs(delta_dist) < (obj_a->size + obj_b->size)) { //same position
1457 //these two objects are in the same position. see if one is a fireball
1458 //or laser or something that should plot on top. Don't do this for
1459 //the afterburner blobs, though.
1461 if (obj_a->type == OBJ_WEAPON || (obj_a->type == OBJ_FIREBALL && obj_a->id != VCLIP_AFTERBURNER_BLOB))
1462 if (!(obj_b->type == OBJ_WEAPON || obj_b->type == OBJ_FIREBALL))
1463 return -1; //a is weapon, b is not, so say a is closer
1464 else; //both are weapons
1466 if (obj_b->type == OBJ_WEAPON || (obj_b->type == OBJ_FIREBALL && obj_b->id != VCLIP_AFTERBURNER_BLOB))
1467 return 1; //b is weapon, a is not, so say a is farther
1469 //no special case, fall through to normal return
1472 return delta_dist; //return distance
1475 void build_object_lists(int n_segs)
1479 //mprintf((0,"build n_segs=%d",n_segs));
1481 for (nn=0;nn<MAX_RENDER_SEGS+N_EXTRA_OBJ_LISTS;nn++)
1482 render_obj_list[nn][0] = -1;
1484 for (nn=0;nn<n_segs;nn++) {
1487 segnum = Render_list[nn];
1489 //mprintf((0,"nn=%d seg=%d ",nn,segnum));
1495 for (objnum=Segments[segnum].objects;objnum!=-1;objnum = obj->next) {
1496 int new_segnum,did_migrate,list_pos;
1498 obj = &Objects[objnum];
1500 Assert( obj->segnum == segnum );
1502 if (obj->flags & OF_ATTACHED)
1503 continue; //ignore this object
1505 new_segnum = segnum;
1508 //mprintf((0,"objnum=%d ",objnum));
1509 if (obj->type != OBJ_CNTRLCEN && !(obj->type==OBJ_ROBOT && obj->id==65)) //don't migrate controlcen
1515 m = get_seg_masks(&obj->pos, new_segnum, obj->size, __FILE__, __LINE__);
1520 for (sn=0,sf=1;sn<6;sn++,sf<<=1)
1521 if (m.sidemask & sf) {
1522 segment *seg = &Segments[new_segnum];
1524 if (WALL_IS_DOORWAY(seg,sn) & WID_FLY_FLAG) { //can explosion migrate through
1525 int child = seg->children[sn];
1528 for (checknp=list_pos;checknp--;)
1529 if (Render_list[checknp] == child) {
1530 //mprintf((0,"mig from %d to %d ",new_segnum,child));
1539 } while (0); //while (did_migrate);
1541 add_obj_to_seglist(objnum,list_pos);
1548 //mprintf((0,"done build "));
1550 //now that there's a list for each segment, sort the items in those lists
1551 for (nn=0;nn<n_segs;nn++) {
1554 segnum = Render_list[nn];
1556 //mprintf((0,"nn=%d seg=%d ",nn,segnum));
1561 //first count the number of objects & copy into sort list
1564 i = n_sort_items = 0;
1565 while ((t=render_obj_list[lookn][i++])!=-1)
1569 if (n_sort_items < SORT_LIST_SIZE-1) { //add if room
1570 sort_list[n_sort_items].objnum = t;
1571 //NOTE: maybe use depth, not dist - quicker computation
1572 sort_list[n_sort_items].dist = vm_vec_dist_quick(&Objects[t].pos,&Viewer_eye);
1575 else { //no room for object
1579 FILE *tfile=fopen("sortlist.out","wt");
1581 //I find this strange, so I'm going to write out
1582 //some information to look at later
1584 for (ii=0;ii<SORT_LIST_SIZE;ii++) {
1585 int objnum = sort_list[ii].objnum;
1587 fprintf(tfile,"Obj %3d Type = %2d Id = %2d Dist = %08x Segnum = %3d\n",
1588 objnum,Objects[objnum].type,Objects[objnum].id,sort_list[ii].dist,Objects[objnum].segnum);
1594 Int3(); //Get Matt!!!
1596 //Now try to find a place for this object by getting rid
1597 //of an object we don't care about
1599 for (ii=0;ii<SORT_LIST_SIZE;ii++) {
1600 int objnum = sort_list[ii].objnum;
1601 object *obj = &Objects[objnum];
1602 int type = obj->type;
1604 //replace debris & fireballs
1605 if (type == OBJ_DEBRIS || type == OBJ_FIREBALL) {
1606 fix dist = vm_vec_dist_quick(&Objects[t].pos,&Viewer_eye);
1608 //don't replace same kind of object unless new
1611 if (Objects[t].type != type || dist < sort_list[ii].dist) {
1612 sort_list[ii].objnum = t;
1613 sort_list[ii].dist = dist;
1619 Int3(); //still couldn't find a slot
1624 #if defined(__WATCOMC__) || defined(MACINTOSH)
1625 qsort(sort_list,n_sort_items,sizeof(*sort_list),
1628 qsort(sort_list,n_sort_items,sizeof(*sort_list),
1629 (int (*)(const void*,const void*))sort_func);
1632 //now copy back into list
1637 while ((t=render_obj_list[lookn][i])!=-1 && n>0)
1641 render_obj_list[lookn][i++] = sort_list[--n].objnum;
1642 render_obj_list[lookn][i] = -1; //mark (possibly new) end
1647 int Use_player_head_angles = 0;
1648 vms_angvec Player_head_angles;
1650 extern int Num_tmaps_drawn;
1651 extern int Total_pixels;
1652 //--unused-- int Total_num_tmaps_drawn=0;
1655 extern ubyte RenderingType;
1657 void start_lighting_frame(object *viewer);
1660 fix Zoom_factor=F1_0;
1662 //renders onto current canvas
1663 void render_frame(fix eye_offset, int window_num)
1667 //Total_num_tmaps_drawn += Num_tmaps_drawn;
1668 //if ((FrameCount > 0) && (Total_num_tmaps_drawn))
1669 // 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));
1670 //Num_tmaps_drawn = 0;
1672 if (Endlevel_sequence) {
1673 render_endlevel_frame(eye_offset);
1679 if ( Newdemo_state == ND_STATE_RECORDING && eye_offset >= 0 ) {
1681 //mprintf((0, "Objnum=%d objtype=%d objid=%d\n", OBJECT_NUMBER(Viewer), Viewer->type, Viewer->id));
1683 if (RenderingType==0)
1684 newdemo_record_start_frame(FrameCount, FrameTime );
1685 if (RenderingType!=255)
1686 newdemo_record_viewer_object(Viewer);
1692 start_lighting_frame(Viewer); //this is for ugly light-smoothing hack
1696 Viewer_eye = Viewer->pos;
1698 // if (Viewer->type == OBJ_PLAYER && (Cockpit_mode.intval != CM_REAR_VIEW))
1699 // vm_vec_scale_add2(&Viewer_eye,&Viewer->orient.fvec,(Viewer->size*3)/4);
1702 vm_vec_scale_add2(&Viewer_eye,&Viewer->orient.rvec,eye_offset);
1706 if (Function_mode==FMODE_EDITOR)
1707 Viewer_eye = Viewer->pos;
1710 start_seg_num = find_point_seg(&Viewer_eye,Viewer->segnum);
1712 if (start_seg_num==-1)
1713 start_seg_num = Viewer->segnum;
1715 if (Viewer==ConsoleObject && Use_player_head_angles) {
1716 vms_matrix headm,viewm;
1717 vm_angles_2_matrix(&headm,&Player_head_angles);
1718 vm_matrix_x_matrix(&viewm,&Viewer->orient,&headm);
1719 g3_set_view_matrix(&Viewer_eye,&viewm,Render_zoom);
1720 //@@} else if ((Cockpit_mode.intval == CM_REAR_VIEW) && (Viewer == ConsoleObject)) {
1721 } else if (Rear_view && (Viewer==ConsoleObject)) {
1722 vms_matrix headm,viewm;
1723 Player_head_angles.p = Player_head_angles.b = 0;
1724 Player_head_angles.h = 0x7fff;
1725 vm_angles_2_matrix(&headm,&Player_head_angles);
1726 vm_matrix_x_matrix(&viewm,&Viewer->orient,&headm);
1727 g3_set_view_matrix(&Viewer_eye,&viewm,Render_zoom);
1730 if (keyd_pressed[KEY_RSHIFT] ) {
1731 Zoom_factor += FrameTime*4;
1732 if (Zoom_factor > F1_0*5 ) Zoom_factor=F1_0*5;
1734 Zoom_factor -= FrameTime*4;
1735 if (Zoom_factor < F1_0 ) Zoom_factor = F1_0;
1737 g3_set_view_matrix(&Viewer_eye,&Viewer->orient,fixdiv(Render_zoom,Zoom_factor));
1739 g3_set_view_matrix(&Viewer_eye,&Viewer->orient,Render_zoom);
1743 if (Clear_window == 1) {
1744 if (Clear_window_color == -1)
1745 Clear_window_color = BM_XRGB(0, 0, 0); //BM_XRGB(31, 15, 7);
1746 gr_clear_canvas(Clear_window_color);
1749 if (Show_only_curside)
1750 gr_clear_canvas(Clear_window_color);
1753 render_mine(start_seg_num, eye_offset, window_num);
1755 if (Use_player_head_angles )
1756 draw_3d_reticle(eye_offset);
1762 // -- Moved from here by MK, 05/17/95, wrong if multiple renders/frame! FrameCount++; //we have rendered a frame
1765 int first_terminal_seg;
1767 void update_rendered_data(int window_num, object *viewer, int rear_view_flag, int user)
1769 Assert(window_num < MAX_RENDERED_WINDOWS);
1770 Window_rendered_data[window_num].frame = FrameCount;
1771 Window_rendered_data[window_num].viewer = viewer;
1772 Window_rendered_data[window_num].rear_view = rear_view_flag;
1773 Window_rendered_data[window_num].user = user;
1776 //build a list of segments to be rendered
1777 //fills in Render_list & N_render_segs
1778 void build_segment_list(int start_seg_num, int window_num)
1784 memset(visited, 0, sizeof(visited[0])*(Highest_segment_index+1));
1785 memset(render_pos, -1, sizeof(render_pos[0])*(Highest_segment_index+1));
1786 //memset(no_render_flag, 0, sizeof(no_render_flag[0])*(MAX_RENDER_SEGS));
1787 memset(processed, 0, sizeof(processed));
1790 memset(visited2, 0, sizeof(visited2[0])*(Highest_segment_index+1));
1795 Render_list[lcnt] = start_seg_num; visited[start_seg_num]=1;
1796 Seg_depth[lcnt] = 0;
1799 render_pos[start_seg_num] = 0;
1803 render_segment(start_seg_num, window_num);
1806 render_windows[0].left=render_windows[0].top=0;
1807 render_windows[0].right=grd_curcanv->cv_bitmap.bm_w-1;
1808 render_windows[0].bot=grd_curcanv->cv_bitmap.bm_h-1;
1810 //breadth-first renderer
1814 for (l=0;l<Render_depth;l++) {
1816 //while (scnt < ecnt) {
1817 for (scnt=0;scnt < ecnt;scnt++) {
1820 short child_list[MAX_SIDES_PER_SEGMENT]; //list of ordered sides to process
1821 int n_children; //how many sides in child_list
1824 if (processed[scnt])
1829 segnum = Render_list[scnt];
1830 check_w = &render_windows[scnt];
1834 draw_window_box(RED,check_w->left,check_w->top,check_w->right,check_w->bot);
1837 if (segnum == -1) continue;
1839 seg = &Segments[segnum];
1842 //look at all sides of this segment.
1843 //tricky code to look at sides in correct order follows
1845 for (c=n_children=0;c<MAX_SIDES_PER_SEGMENT;c++) { //build list of sides
1848 wid = WALL_IS_DOORWAY(seg, c);
1850 ch=seg->children[c];
1852 if ( (window_check || !visited[ch]) && (wid & WID_RENDPAST_FLAG) ) {
1854 sbyte *sv = Side_to_verts[c];
1855 ubyte codes_and=0xff;
1858 rotate_list(8,seg->verts);
1862 codes_and &= Segment_points[seg->verts[sv[i]]].p3_codes;
1864 if (codes_and & CC_BEHIND) continue;
1867 child_list[n_children++] = c;
1871 //now order the sides in some magical way
1873 if (new_seg_sorting)
1874 sort_seg_children(seg,n_children,child_list);
1876 //for (c=0;c<MAX_SIDES_PER_SEGMENT;c++) {
1877 // ch=seg->children[c];
1879 for (c=0;c<n_children;c++) {
1882 siden = child_list[c];
1883 ch=seg->children[siden];
1884 //if ( (window_check || !visited[ch])&& (WALL_IS_DOORWAY(seg, c))) {
1888 ubyte codes_and_3d,codes_and_2d;
1889 short _x,_y,min_x=32767,max_x=-32767,min_y=32767,max_y=-32767;
1890 int no_proj_flag=0; //a point wasn't projected
1894 rotate_list(8,seg->verts);
1895 project_list(8,seg->verts);
1899 for (i=0,codes_and_3d=codes_and_2d=0xff;i<4;i++) {
1900 int p = seg->verts[Side_to_verts[siden][i]];
1901 g3s_point *pnt = &Segment_points[p];
1903 if (! (pnt->p3_flags&PF_PROJECTED)) {no_proj_flag=1; break;}
1905 _x = f2i(pnt->p3_sx);
1906 _y = f2i(pnt->p3_sy);
1908 codes_and_3d &= pnt->p3_codes;
1909 codes_and_2d &= code_window_point(_x,_y,check_w);
1913 gr_setcolor(BM_XRGB(31,0,31));
1914 gr_line(pnt->p3_sx,pnt->p3_sy,
1915 Segment_points[seg->verts[Side_to_verts[siden][(i+1)%4]]].p3_sx,
1916 Segment_points[seg->verts[Side_to_verts[siden][(i+1)%4]]].p3_sy);
1920 if (_x < min_x) min_x = _x;
1921 if (_x > max_x) max_x = _x;
1923 if (_y < min_y) min_y = _y;
1924 if (_y > max_y) max_y = _y;
1930 draw_window_box(WHITE,min_x,min_y,max_x,max_y);
1933 if (no_proj_flag || (!codes_and_3d && !codes_and_2d)) { //maybe add this segment
1934 int rp = render_pos[ch];
1935 window *new_w = &render_windows[lcnt];
1937 if (no_proj_flag) *new_w = *check_w;
1939 new_w->left = max(check_w->left,min_x);
1940 new_w->right = min(check_w->right,max_x);
1941 new_w->top = max(check_w->top,min_y);
1942 new_w->bot = min(check_w->bot,max_y);
1945 //see if this seg already visited, and if so, does current window
1946 //expand the old window?
1948 if (new_w->left < render_windows[rp].left ||
1949 new_w->top < render_windows[rp].top ||
1950 new_w->right > render_windows[rp].right ||
1951 new_w->bot > render_windows[rp].bot) {
1953 new_w->left = min(new_w->left,render_windows[rp].left);
1954 new_w->right = max(new_w->right,render_windows[rp].right);
1955 new_w->top = min(new_w->top,render_windows[rp].top);
1956 new_w->bot = max(new_w->bot,render_windows[rp].bot);
1958 if (no_migrate_segs) {
1959 //no_render_flag[lcnt] = 1;
1960 Render_list[lcnt] = -1;
1961 render_windows[rp] = *new_w; //get updated window
1962 processed[rp] = 0; //force reprocess
1973 draw_window_box(5,new_w->left,new_w->top,new_w->right,new_w->bot);
1976 render_pos[ch] = lcnt;
1977 Render_list[lcnt] = ch;
1978 Seg_depth[lcnt] = l;
1980 if (lcnt >= MAX_RENDER_SEGS) {mprintf((0,"Too many segs in render list!!\n")); goto done_list;}
1985 render_segment(ch, window_num);
1993 Render_list[lcnt] = ch;
1994 Seg_depth[lcnt] = l;
1996 if (lcnt >= MAX_RENDER_SEGS) {mprintf((0,"Too many segs in render list!!\n")); goto done_list;}
2012 first_terminal_seg = scnt;
2013 N_render_segs = lcnt;
2017 //renders onto current canvas
2018 void render_mine(int start_seg_num,fix eye_offset, int window_num)
2025 // Initialize number of objects (actually, robots!) rendered this frame.
2026 Window_rendered_data[window_num].num_objects = 0;
2033 for (i=0;i<=Highest_object_index;i++)
2034 object_rendered[i] = 0;
2037 //set up for rendering
2039 render_start_frame();
2043 if (Show_only_curside) {
2044 rotate_list(8,Cursegp->verts);
2045 render_side(Cursegp,Curside);
2046 goto done_rendering;
2058 //NOTE LINK TO ABOVE!!
2059 build_segment_list(start_seg_num, window_num); //fills in Render_list & N_render_segs
2064 if (!window_check) {
2065 Window_clip_left = Window_clip_top = 0;
2066 Window_clip_right = grd_curcanv->cv_bitmap.bm_w-1;
2067 Window_clip_bot = grd_curcanv->cv_bitmap.bm_h-1;
2072 if (!(_search_mode)) {
2075 for (i=0;i<N_render_segs;i++) {
2078 segnum = Render_list[i];
2082 if (visited2[segnum])
2085 visited2[segnum] = 1;
2091 if (!(_search_mode))
2092 build_object_lists(N_render_segs);
2094 if (eye_offset<=0) // Do for left eye or zero.
2095 set_dynamic_light();
2097 if (!_search_mode && Clear_window == 2) {
2098 if (first_terminal_seg < N_render_segs) {
2101 if (Clear_window_color == -1)
2102 Clear_window_color = BM_XRGB(0, 0, 0); //BM_XRGB(31, 15, 7);
2104 gr_setcolor(Clear_window_color);
2106 for (i=first_terminal_seg; i<N_render_segs; i++) {
2107 if (Render_list[i] != -1) {
2109 if ((render_windows[i].left == -1) || (render_windows[i].top == -1) || (render_windows[i].right == -1) || (render_windows[i].bot == -1))
2113 //NOTE LINK TO ABOVE!
2114 gr_rect(render_windows[i].left, render_windows[i].top, render_windows[i].right, render_windows[i].bot);
2120 for (nn=N_render_segs;nn--;) {
2124 // Interpolation_method = 0;
2125 segnum = Render_list[nn];
2126 Current_seg_depth = Seg_depth[nn];
2128 //if (!no_render_flag[nn])
2129 if (segnum!=-1 && (_search_mode || visited[segnum]!=255)) {
2130 //set global render window vars
2133 Window_clip_left = render_windows[nn].left;
2134 Window_clip_top = render_windows[nn].top;
2135 Window_clip_right = render_windows[nn].right;
2136 Window_clip_bot = render_windows[nn].bot;
2139 //mprintf((0," %d",segnum));
2141 render_segment(segnum, window_num);
2142 visited[segnum]=255;
2144 if (window_check) { //reset for objects
2145 Window_clip_left = Window_clip_top = 0;
2146 Window_clip_right = grd_curcanv->cv_bitmap.bm_w-1;
2147 Window_clip_bot = grd_curcanv->cv_bitmap.bm_h-1;
2150 if (migrate_objects) {
2151 //int n_expl_objs=0,expl_objs[5],i;
2153 int save_linear_depth = Max_linear_depth;
2155 Max_linear_depth = Max_linear_depth_objects;
2159 //mprintf((0,"render objs seg %d",segnum));
2161 for (objnp=0;render_obj_list[listnum][objnp]!=-1;) {
2162 int ObjNumber = render_obj_list[listnum][objnp];
2164 if (ObjNumber >= 0) {
2166 //mprintf( (0, "Type: %d\n", Objects[ObjNumber].type ));
2168 //if (Objects[ObjNumber].type == OBJ_FIREBALL && n_expl_objs<5) {
2169 // expl_objs[n_expl_objs++] = ObjNumber;
2172 if ( (Objects[ObjNumber].type==OBJ_WEAPON) && //if its a weapon
2173 (Objects[ObjNumber].lifeleft==Laser_max_time ) && // and its in it's first frame
2174 (Hack_nlasers< MAX_HACKED_LASERS) && // and we have space for it
2175 (Objects[ObjNumber].laser_info.parent_num>-1) && // and it has a parent
2176 (OBJECT_NUMBER(Viewer) == Objects[ObjNumber].laser_info.parent_num) // and it's parent is the viewer
2178 Hack_laser_list[Hack_nlasers++] = ObjNumber; //then make it draw after everything else.
2179 //mprintf( (0, "O%d ", ObjNumber ));
2182 do_render_object(ObjNumber, window_num); // note link to above else
2188 listnum = -ObjNumber;
2195 //for (i=0;i<n_expl_objs;i++)
2196 // do_render_object(expl_objs[i], window_num);
2198 //mprintf((0,"done seg %d\n",segnum));
2200 Max_linear_depth = save_linear_depth;
2207 //mprintf((0,"\n"));
2211 // Draw the hacked lasers last
2212 for (i=0; i < Hack_nlasers; i++ ) {
2213 //mprintf( (0, "D%d ", Hack_laser_list[i] ));
2214 do_render_object(Hack_laser_list[i], window_num);
2218 // -- commented out by mk on 09/14/94...did i do a good thing?? object_render_targets();
2222 //draw curedge stuff
2223 if (Outline_mode) outline_seg_side(Cursegp,Curside,Curedge,Curvert);
2234 extern int render_3d_in_big_window;
2236 //finds what segment is at a given x&y - seg,side,face are filled in
2237 //works on last frame rendered. returns true if found
2238 //if seg<0, then an object was found, and the object number is -seg-1
2239 int find_seg_side_face(short x,short y,int *seg,int *side,int *face,int *poly)
2243 _search_x = x; _search_y = y;
2247 if (render_3d_in_big_window) {
2248 grs_canvas temp_canvas;
2250 gr_init_sub_canvas(&temp_canvas,canv_offscreen,0,0,
2251 LargeView.ev_canv->cv_bitmap.bm_w,LargeView.ev_canv->cv_bitmap.bm_h);
2253 gr_set_current_canvas(&temp_canvas);
2258 gr_set_current_canvas(&VR_render_sub_buffer[0]); //render off-screen
2269 // mprintf((0,"found seg=%d, side=%d, face=%d, poly=%d\n",found_seg,found_side,found_face,found_poly));
2271 return (found_seg!=-1);