home *** CD-ROM | disk | FTP | other *** search
/ Amiga ACS 1998 #6 / amigaacscoverdisc1998-061998.iso / games / descent / source / main / editor / medmisc.c < prev    next >
Text File  |  1998-06-08  |  18KB  |  683 lines
  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-1998 PARALLAX SOFTWARE CORPORATION.  ALL RIGHTS RESERVED.
  12. */
  13. /*
  14.  * $Source: f:/miner/source/main/editor/rcs/medmisc.c $
  15.  * $Revision: 2.1 $
  16.  * $Author: john $
  17.  * $Date: 1995/03/06 15:20:50 $
  18.  * 
  19.  * Miscellaneous functions stripped out of med.c
  20.  * 
  21.  * $Log: medmisc.c $
  22.  * Revision 2.1  1995/03/06  15:20:50  john
  23.  * New screen mode method.
  24.  * 
  25.  * Revision 2.0  1995/02/27  11:36:40  john
  26.  * Version 2.0. Ansi-fied.
  27.  * 
  28.  * Revision 1.31  1994/11/27  23:17:20  matt
  29.  * Made changes for new mprintf calling convention
  30.  * 
  31.  * Revision 1.30  1994/11/17  14:48:11  mike
  32.  * validation functions moved from editor to game.
  33.  * 
  34.  * Revision 1.29  1994/08/25  21:56:15  mike
  35.  * IS_CHILD stuff.
  36.  * 
  37.  * Revision 1.28  1994/08/09  16:06:00  john
  38.  * Added the ability to place players.  Made old
  39.  * Player variable be ConsoleObject.
  40.  * 
  41.  * Revision 1.27  1994/07/21  17:25:43  matt
  42.  * Took out unused func medlisp_create_new_mine() and its prototype
  43.  * 
  44.  * Revision 1.26  1994/07/21  13:27:01  matt
  45.  * Cleaned up render code and added error checking
  46.  * 
  47.  * Revision 1.25  1994/07/20  15:32:52  matt
  48.  * Added func to call g3_point_2_vec() for texture-mapped window
  49.  * 
  50.  * Revision 1.24  1994/07/15  15:26:53  yuan
  51.  * Fixed warning
  52.  * 
  53.  * Revision 1.23  1994/07/14  14:45:16  yuan
  54.  * Added function to set default segment and attach.
  55.  * 
  56.  * Revision 1.22  1994/07/14  09:46:34  yuan
  57.  * Make E attach segment as well as make default.
  58.  * 
  59.  * 
  60.  * Revision 1.21  1994/07/11  18:39:17  john
  61.  * Reversed y axis roll.
  62.  * 
  63.  * Revision 1.20  1994/07/06  16:36:32  mike
  64.  * Add hook for game to render wireframe view: draw_world_from_game.
  65.  * 
  66.  * Revision 1.19  1994/06/24  14:08:31  john
  67.  * Changed calling params for render_frame.
  68.  * 
  69.  * Revision 1.18  1994/06/23  15:54:02  matt
  70.  * Finished hacking in 3d rendering in big window
  71.  * 
  72.  * Revision 1.17  1994/06/22  00:32:56  matt
  73.  * New version, without all the errors of the last version. Sorry.
  74.  * 
  75.  * Revision 1.15  1994/05/23  14:48:54  mike
  76.  * make current segment be add segment.
  77.  * 
  78.  * Revision 1.14  1994/05/19  12:09:35  matt
  79.  * Use new vecmat macros and globals
  80.  * 
  81.  * Revision 1.13  1994/05/14  17:17:55  matt
  82.  * Got rid of externs in source (non-header) files
  83.  * 
  84.  * Revision 1.12  1994/05/09  23:35:06  mike
  85.  * Add ClearFoundList, which is probably no longer being called.
  86.  * 
  87.  * Revision 1.11  1994/05/04  14:11:40  mike
  88.  * Increase render depth from 4 to 6 by default.
  89.  * 
  90.  * Revision 1.10  1994/04/27  21:00:25  matt
  91.  * Made texture-mapped window redraw when editor state variables (such as
  92.  * current object) have changed.
  93.  * 
  94.  * Revision 1.9  1994/03/31  12:03:38  matt
  95.  * Cleaned up includes
  96.  * 
  97.  * Revision 1.8  1994/02/17  11:31:21  matt
  98.  * Changes in object system
  99.  * 
  100.  * Revision 1.7  1994/02/11  11:05:14  yuan
  101.  * Make chase mode unsettable... Gives a warning on the mono.
  102.  * 
  103.  * Revision 1.6  1994/01/21  17:37:24  matt
  104.  * Moved code from render_frame() to caller, making code cleaner
  105.  * 
  106.  * Revision 1.5  1994/01/11  18:12:43  yuan
  107.  * compress_mines removed.  Now it is called within
  108.  * the gamesave.min save whenever we go into the game.
  109.  * 
  110.  * Revision 1.4  1994/01/05  10:54:15  john
  111.  * New object code by John
  112.  * 
  113.  * Revision 1.3  1993/12/29  16:15:27  mike
  114.  * Kill scale field from segment struct.
  115.  * 
  116.  * Revision 1.2  1993/12/17  12:05:00  john
  117.  * Took stuff out of med.c; moved into medsel.c, meddraw.c, medmisc.c
  118.  * 
  119.  * Revision 1.1  1993/12/17  08:35:47  john
  120.  * Initial revision
  121.  * 
  122.  * 
  123.  */
  124.  
  125.  
  126. #pragma off (unreferenced)
  127. static char rcsid[] = "$Id: medmisc.c 2.1 1995/03/06 15:20:50 john Exp $";
  128. #pragma on (unreferenced)
  129.  
  130. #include <stdio.h>
  131. #include <stdlib.h>
  132. #include <stdarg.h>
  133. #include <string.h>
  134. #include <process.h>
  135.  
  136. #include "gr.h"
  137. #include "ui.h"
  138. #include "3d.h"
  139.  
  140. #include "mem.h"
  141. #include "error.h"
  142. #include "mono.h"
  143. #include "key.h"
  144. #include "func.h"
  145.  
  146. #include "inferno.h"
  147. #include "editor.h"
  148. #include "segment.h"
  149.  
  150. #include "render.h"
  151. #include "screens.h"
  152. #include "object.h"
  153.  
  154. #include "texpage.h"        // For texpage_goto_first
  155. #include "meddraw.h"        // For draw_World
  156. #include "game.h"
  157.  
  158. //return 2d distance, i.e, sqrt(x*x + y*y)
  159. long dist_2d(long x,long y);
  160.  
  161. #pragma aux dist_2d parm [eax] [ebx] value [eax] modify [ecx edx] = \
  162.     "imul    eax"            \
  163.     "xchg    ebx,eax"        \
  164.     "mov    ecx,edx"        \
  165.     "imul    eax"            \
  166.     "add    eax,ebx"        \
  167.     "adc    edx,ecx"        \
  168.     "call    quad_sqrt";
  169.  
  170. // Given mouse movement in dx, dy, returns a 3x3 rotation matrix in RotMat.
  171. // Taken from Graphics Gems III, page 51, "The Rolling Ball"
  172.  
  173. void GetMouseRotation( int idx, int idy, vms_matrix * RotMat )
  174. {
  175.     fix dr, cos_theta, sin_theta, denom, cos_theta1;
  176.     fix Radius = i2f(100);
  177.     fix dx,dy;
  178.     fix dxdr,dydr;
  179.  
  180.     idy *= -1;
  181.  
  182.     dx = i2f(idx); dy = i2f(idy);
  183.  
  184.     dr = dist_2d(dx,dy);
  185.  
  186.     denom = dist_2d(Radius,dr);
  187.  
  188.     cos_theta = fixdiv(Radius,denom);
  189.     sin_theta = fixdiv(dr,denom);
  190.  
  191.     cos_theta1 = f1_0 - cos_theta;
  192.  
  193.     dxdr = fixdiv(dx,dr);
  194.     dydr = fixdiv(dy,dr);
  195.  
  196.     RotMat->rvec.x = cos_theta + fixmul(fixmul(dydr,dydr),cos_theta1);
  197.     RotMat->uvec.x = - fixmul(fixmul(dxdr,dydr),cos_theta1);
  198.     RotMat->fvec.x = fixmul(dxdr,sin_theta);
  199.  
  200.     RotMat->rvec.y = RotMat->uvec.x;
  201.     RotMat->uvec.y = cos_theta + fixmul(fixmul(dxdr,dxdr),cos_theta1);
  202.     RotMat->fvec.y = fixmul(dydr,sin_theta);
  203.  
  204.     RotMat->rvec.z = -RotMat->fvec.x;
  205.     RotMat->uvec.z = -RotMat->fvec.y;
  206.     RotMat->fvec.z = cos_theta;
  207.  
  208. }
  209.  
  210. int Gameview_lockstep;        //if set, view is locked to Curseg
  211.  
  212. int ToggleLockstep()
  213. {
  214.     Gameview_lockstep = !Gameview_lockstep;
  215.     if (Gameview_lockstep == 0) {
  216.         if (last_keypress != KEY_L)
  217.             diagnostic_message("[L] - Lock mode OFF");
  218.         else
  219.             diagnostic_message("Lock mode OFF");
  220.     }
  221.     if (Gameview_lockstep) {
  222.         if (last_keypress != KEY_L)
  223.             diagnostic_message("[L] Lock mode ON");
  224.         else
  225.             diagnostic_message("Lock mode ON");
  226.  
  227.       Cursegp = &Segments[ConsoleObject->segnum];
  228.         med_create_new_segment_from_cursegp();
  229.         set_view_target_from_segment(Cursegp);
  230.         Update_flags = UF_ED_STATE_CHANGED;
  231.     }
  232.     return Gameview_lockstep;
  233. }
  234.  
  235. int medlisp_delete_segment(void)
  236. {
  237.     if (!med_delete_segment(Cursegp)) {
  238.         if (Lock_view_to_cursegp)
  239.             set_view_target_from_segment(Cursegp);
  240.           autosave_mine(mine_filename);
  241.           strcpy(undo_status[Autosave_count], "Delete Segment UNDONE.");
  242.         Update_flags |= UF_WORLD_CHANGED;
  243.         mine_changed = 1;
  244.         diagnostic_message("Segment deleted.");
  245.         warn_if_concave_segments();     // This could be faster -- just check if deleted segment was concave, warn accordingly
  246.     }
  247.  
  248.     return 1;
  249. }
  250.  
  251. int medlisp_scale_segment(void)
  252. {
  253.     vms_matrix    rotmat;
  254.     vms_vector    scale;
  255.  
  256.     scale.x = fl2f((float) func_get_param(0));
  257.     scale.y = fl2f((float) func_get_param(1));
  258.     scale.z = fl2f((float) func_get_param(2));
  259.     med_create_new_segment(&scale);
  260.     med_rotate_segment(Cursegp,vm_angles_2_matrix(&rotmat,&Seg_orientation));
  261.     Update_flags |= UF_WORLD_CHANGED;
  262.     mine_changed = 1;
  263.  
  264.     return 1;
  265. }
  266.  
  267. int medlisp_rotate_segment(void)
  268. {
  269.     vms_matrix    rotmat;
  270.  
  271.     Seg_orientation.p = func_get_param(0);
  272.     Seg_orientation.b = func_get_param(1);
  273.     Seg_orientation.h = func_get_param(2);
  274.     med_rotate_segment(Cursegp,vm_angles_2_matrix(&rotmat,&Seg_orientation));
  275.     Update_flags |= UF_WORLD_CHANGED | UF_VIEWPOINT_MOVED;
  276.     mine_changed = 1;
  277.     return 1;
  278. }
  279.  
  280. int ToggleLockViewToCursegp(void)
  281. {
  282.     Lock_view_to_cursegp = !Lock_view_to_cursegp;
  283.     Update_flags = UF_ED_STATE_CHANGED;
  284.     if (Lock_view_to_cursegp) {
  285.         if (last_keypress != KEY_V+KEY_CTRLED)
  286.             diagnostic_message("[ctrl-V] View locked to Cursegp.");
  287.         else
  288.             diagnostic_message("View locked to Cursegp.");
  289.         set_view_target_from_segment(Cursegp);
  290.     } else {
  291.         if (last_keypress != KEY_V+KEY_CTRLED)
  292.             diagnostic_message("[ctrl-V] View not locked to Cursegp.");
  293.         else
  294.             diagnostic_message("View not locked to Cursegp.");
  295.     }
  296.     return Lock_view_to_cursegp;
  297. }
  298.  
  299. int ToggleDrawAllSegments()
  300. {
  301.     Draw_all_segments = !Draw_all_segments;
  302.     Update_flags = UF_ED_STATE_CHANGED;
  303.     if (Draw_all_segments == 1) {
  304.         if (last_keypress != KEY_A+KEY_CTRLED)
  305.             diagnostic_message("[ctrl-A] Draw all segments ON.");
  306.         else
  307.             diagnostic_message("Draw all segments ON.");
  308.     }
  309.     if (Draw_all_segments == 0) {
  310.         if (last_keypress != KEY_A+KEY_CTRLED)
  311.             diagnostic_message("[ctrl-A] Draw all segments OFF.");
  312.         else
  313.             diagnostic_message("Draw all segments OFF.");
  314.     }
  315.     return Draw_all_segments;
  316. }
  317.  
  318. int    Big_depth=6;
  319.  
  320. int IncreaseDrawDepth(void)
  321. {
  322.     Big_depth++;
  323.     Update_flags = UF_ED_STATE_CHANGED;
  324.     return 1;
  325. }
  326.  
  327. int DecreaseDrawDepth(void)
  328. {
  329.     if (Big_depth > 1) {
  330.         Big_depth--;
  331.         Update_flags = UF_ED_STATE_CHANGED;
  332.     }
  333.     return 1;
  334. }
  335.  
  336.  
  337. int ToggleCoordAxes()
  338. {
  339.             //  Toggle display of coordinate axes.
  340.     Show_axes_flag = !Show_axes_flag;
  341.     LargeView.ev_changed = 1;
  342.     if (Show_axes_flag == 1) {
  343.         if (last_keypress != KEY_D+KEY_CTRLED)
  344.             diagnostic_message("[ctrl-D] Coordinate axes ON.");
  345.         else
  346.             diagnostic_message("Coordinate axes ON.");
  347.     }
  348.     if (Show_axes_flag == 0) {
  349.         if (last_keypress != KEY_D+KEY_CTRLED)
  350.             diagnostic_message("[ctrl-D] Coordinate axes OFF.");
  351.         else
  352.             diagnostic_message("Coordinate axes OFF.");
  353.     }
  354.     return Show_axes_flag;
  355. }
  356.  
  357. int med_keypad_goto_prev()
  358. {
  359.     ui_pad_goto_prev();
  360.     return 0;
  361. }
  362.  
  363. int med_keypad_goto_next()
  364. {
  365.     ui_pad_goto_next();
  366.     return 0;
  367. }
  368.  
  369. int med_keypad_goto()
  370. {
  371.     ui_pad_goto(func_get_param(0));
  372.     return 0;
  373. }
  374.  
  375. int render_3d_in_big_window=0;
  376.  
  377. int medlisp_update_screen()
  378. {
  379.     int vn;
  380.  
  381. if (!render_3d_in_big_window)
  382.     for (vn=0;vn<N_views;vn++)
  383.         if (Views[vn]->ev_changed || (Update_flags & (UF_WORLD_CHANGED|UF_VIEWPOINT_MOVED|UF_ED_STATE_CHANGED))) {
  384.             draw_world(Views[vn]->ev_canv,Views[vn],Cursegp,Big_depth);
  385.             Views[vn]->ev_changed = 0;
  386.         }
  387.  
  388.     if (Update_flags & (UF_WORLD_CHANGED|UF_GAME_VIEW_CHANGED|UF_ED_STATE_CHANGED)) {
  389.         grs_canvas temp_canvas;
  390.         grs_canvas *render_canv,*show_canv;
  391.         
  392.         if (render_3d_in_big_window) {
  393.             
  394.             gr_init_sub_canvas(&temp_canvas,canv_offscreen,0,0,
  395.                 LargeView.ev_canv->cv_bitmap.bm_w,LargeView.ev_canv->cv_bitmap.bm_h);
  396.  
  397.             render_canv = &temp_canvas;
  398.             show_canv = LargeView.ev_canv;
  399.  
  400.         }
  401.         else {
  402.             render_canv    = VR_offscreen_buffer;
  403.             show_canv    = Canv_editor_game;
  404.         }
  405.  
  406.         gr_set_current_canvas(render_canv);
  407.         render_frame(0);
  408.  
  409.         Assert(render_canv->cv_bitmap.bm_w == show_canv->cv_bitmap.bm_w &&
  410.                  render_canv->cv_bitmap.bm_h == show_canv->cv_bitmap.bm_h);
  411.  
  412.         ui_mouse_hide();
  413.         gr_bm_ubitblt(show_canv->cv_bitmap.bm_w,show_canv->cv_bitmap.bm_h,
  414.                           0,0,0,0,&render_canv->cv_bitmap,&show_canv->cv_bitmap);
  415.         ui_mouse_show();
  416.     }
  417.  
  418.     Update_flags=UF_NONE;       //clear flags
  419.  
  420.     return 1;
  421. }
  422.  
  423. med_point_2_vec(grs_canvas *canv,vms_vector *v,short sx,short sy)
  424. {
  425.     gr_set_current_canvas(canv);
  426.  
  427.     g3_start_frame();
  428.     g3_set_view_matrix(&Viewer->pos,&Viewer->orient,Render_zoom);
  429.  
  430.     g3_point_2_vec(v,sx,sy);
  431.  
  432.     g3_end_frame();
  433. }
  434.  
  435.  
  436.  
  437. void draw_world_from_game(void)
  438. {
  439.     if (ModeFlag == 2)
  440.         draw_world(Views[0]->ev_canv,Views[0],Cursegp,Big_depth);
  441. }
  442.  
  443. int UndoCommand()
  444. {   int u;
  445.  
  446.     u = undo();
  447.     if (Lock_view_to_cursegp)
  448.         set_view_target_from_segment(Cursegp);
  449.     if (u == 0) {
  450.         if (Autosave_count==9) diagnostic_message(undo_status[0]);
  451.             else
  452.                 diagnostic_message(undo_status[Autosave_count+1]);
  453.         }
  454.         else
  455.      if (u == 1) diagnostic_message("Can't Undo.");
  456.         else
  457.      if (u == 2) diagnostic_message("Can't Undo - Autosave OFF");
  458.     Update_flags |= UF_WORLD_CHANGED;
  459.      mine_changed = 1;
  460.     warn_if_concave_segments();
  461.     return 1;
  462. }
  463.  
  464.  
  465. int ToggleAutosave()
  466. {
  467.     Autosave_flag = !Autosave_flag;
  468.     if (Autosave_flag == 1) 
  469.       diagnostic_message("Autosave ON.");
  470.         else
  471.         diagnostic_message("Autosave OFF.");
  472.    return Autosave_flag;
  473. }
  474.  
  475.  
  476. int AttachSegment()
  477. {
  478.    if (med_attach_segment(Cursegp, &New_segment, Curside, AttachSide)==4) // Used to be WBACK instead of Curside
  479.         diagnostic_message("Cannot attach segment - already a connection on current side.");
  480.    else {
  481.         if (Lock_view_to_cursegp)
  482.             set_view_target_from_segment(Cursegp);
  483.         vm_angvec_make(&Seg_orientation,0,0,0);
  484.         Curside = WBACK;
  485.         Update_flags |= UF_WORLD_CHANGED;
  486.        autosave_mine(mine_filename);
  487.        strcpy(undo_status[Autosave_count], "Attach Segment UNDONE.\n");
  488.         mine_changed = 1;
  489.         warn_if_concave_segment(Cursegp);
  490.       }
  491.     return 1;
  492. }
  493.  
  494. int ForceTotalRedraw()
  495. {
  496.     Update_flags = UF_ALL;
  497.     return 1;
  498. }
  499.  
  500.  
  501. #if ORTHO_VIEWS
  502. int SyncLargeView()
  503. {
  504.     // Make large view be same as one of the orthogonal views.
  505.     Large_view_index = (Large_view_index + 1) % 3;  // keep in 0,1,2 for top, front, right
  506.     switch (Large_view_index) {
  507.         case 0: LargeView.ev_matrix = TopView.ev_matrix; break;
  508.         case 1: LargeView.ev_matrix = FrontView.ev_matrix; break;
  509.         case 2: LargeView.ev_matrix = RightView.ev_matrix; break;
  510.     }
  511.     Update_flags |= UF_VIEWPOINT_MOVED;
  512.     return 1;
  513. }
  514. #endif
  515.  
  516. int DeleteCurSegment()
  517. {
  518.     // Delete current segment.
  519.     med_delete_segment(Cursegp);
  520.     autosave_mine(mine_filename);
  521.     strcpy(undo_status[Autosave_count], "Delete segment UNDONE.");
  522.     if (Lock_view_to_cursegp)
  523.         set_view_target_from_segment(Cursegp);
  524.     Update_flags |= UF_WORLD_CHANGED;
  525.     mine_changed = 1;
  526.     diagnostic_message("Segment deleted.");
  527.     warn_if_concave_segments();     // This could be faster -- just check if deleted segment was concave, warn accordingly
  528.  
  529.     return 1;
  530. }
  531.  
  532. int CreateDefaultNewSegment()
  533. {
  534.     // Create a default segment for New_segment.
  535.     vms_vector  tempvec;
  536.     med_create_new_segment(vm_vec_make(&tempvec,DEFAULT_X_SIZE,DEFAULT_Y_SIZE,DEFAULT_Z_SIZE));
  537.     mine_changed = 1;
  538.  
  539.     return 1;
  540. }
  541.  
  542. int CreateDefaultNewSegmentandAttach()
  543. {
  544.     CreateDefaultNewSegment();
  545.     AttachSegment();
  546.  
  547.     return 1;
  548. }
  549.  
  550. int ExchangeMarkAndCurseg()
  551. {
  552.     // If Markedsegp != Cursegp, and Markedsegp->segnum != -1, exchange Markedsegp and Cursegp
  553.     if (Markedsegp)
  554.         if (Markedsegp->segnum != -1) {
  555.             segment *tempsegp;
  556.             int     tempside;
  557.             tempsegp = Markedsegp;  Markedsegp = Cursegp;   Cursegp = tempsegp;
  558.             tempside = Markedside;  Markedside = Curside;   Curside = tempside;
  559.             med_create_new_segment_from_cursegp();
  560.             Update_flags |= UF_ED_STATE_CHANGED;
  561.             mine_changed = 1;
  562.         }
  563.     return 1;
  564. }
  565.  
  566. int medlisp_add_segment()
  567. {
  568.     AttachSegment();
  569. //segment *ocursegp = Cursegp;
  570. //    med_attach_segment(Cursegp, &New_segment, Curside, WFRONT); // Used to be WBACK instead of Curside
  571. //med_propagate_tmaps_to_segments(ocursegp,Cursegp);
  572. //    set_view_target_from_segment(Cursegp);
  573. ////    while (!vm_angvec_make(&Seg_orientation,0,0,0));
  574. //    Curside = WBACK;
  575.  
  576.     return 1;
  577. }
  578.  
  579.  
  580. int ClearSelectedList(void)
  581. {
  582.     N_selected_segs = 0;
  583.     Update_flags |= UF_WORLD_CHANGED;
  584.  
  585.     diagnostic_message("Selected list cleared.");
  586.  
  587.     return 1;
  588. }
  589.  
  590.  
  591. int ClearFoundList(void)
  592. {
  593.     N_found_segs = 0;
  594.     Update_flags |= UF_WORLD_CHANGED;
  595.  
  596.     diagnostic_message("Found list cleared.");
  597.  
  598.     return 1;
  599. }
  600.  
  601.  
  602.  
  603.  
  604. // ---------------------------------------------------------------------------------------------------
  605. // Do chase mode.
  606. //    View current segment (Cursegp) from the previous segment.
  607. void set_chase_matrix(segment *sp)
  608. {
  609.     int            v;
  610.     vms_vector    forvec = ZERO_VECTOR, upvec;
  611.     vms_vector    tv = ZERO_VECTOR;
  612.     segment        *psp;
  613.  
  614.     // move back two segments, if possible, else move back one, if possible, else use current
  615.     if (IS_CHILD(sp->children[WFRONT])) {
  616.         psp = &Segments[sp->children[WFRONT]];
  617.         if (IS_CHILD(psp->children[WFRONT]))
  618.             psp = &Segments[psp->children[WFRONT]];
  619.     } else
  620.         psp = sp;
  621.  
  622.     for (v=0; v<MAX_VERTICES_PER_SEGMENT; v++)
  623.         vm_vec_add2(&forvec,&Vertices[sp->verts[v]]);
  624.     vm_vec_scale(&forvec,F1_0/MAX_VERTICES_PER_SEGMENT);
  625.  
  626.     for (v=0; v<MAX_VERTICES_PER_SEGMENT; v++)
  627.         vm_vec_add2(&tv,&Vertices[psp->verts[v]]);
  628.     vm_vec_scale(&tv,F1_0/MAX_VERTICES_PER_SEGMENT);
  629.  
  630.     Ed_view_target = forvec;
  631.  
  632.     vm_vec_sub2(&forvec,&tv);
  633.  
  634.     extract_up_vector_from_segment(psp,&upvec);
  635.  
  636.     if (!((forvec.x == 0) && (forvec.y == 0) && (forvec.z == 0)))
  637.         vm_vector_2_matrix(&LargeView.ev_matrix,&forvec,&upvec,NULL);
  638. }
  639.  
  640.  
  641.  
  642. // ---------------------------------------------------------------------------------------------------
  643. void set_view_target_from_segment(segment *sp)
  644. {
  645.     vms_vector    tv = ZERO_VECTOR;
  646.     int            v;
  647.  
  648.     if (Funky_chase_mode)
  649.         {
  650.         mprintf((0, "Trying to set chase mode\n"));
  651.         //set_chase_matrix(sp);
  652.         }
  653.     else {
  654.         for (v=0; v<MAX_VERTICES_PER_SEGMENT; v++)
  655.             vm_vec_add2(&tv,&Vertices[sp->verts[v]]);
  656.  
  657.         vm_vec_scale(&tv,F1_0/MAX_VERTICES_PER_SEGMENT);
  658.  
  659.         Ed_view_target = tv;
  660.  
  661.     }
  662.     Update_flags |= UF_VIEWPOINT_MOVED;
  663.  
  664. }
  665.  
  666.  
  667.  
  668.  
  669.  
  670.  
  671.  
  672.  
  673.  
  674.  
  675.  
  676.  
  677.  
  678.  
  679.  
  680.  
  681.  
  682. 
  683.