FS2_Open
Open source remastering of the Freespace 2 engine
fredrender.cpp
Go to the documentation of this file.
1 /*
2  * Copyright (C) Volition, Inc. 1999. All rights reserved.
3  *
4  * All source code herein is the property of Volition, Inc. You may not sell
5  * or otherwise commercially exploit the source or things you created based on the
6  * source.
7  *
8 */
9 
10 
11 
12 #include "stdafx.h"
13 #include "FRED.h"
14 #include "FREDDoc.h"
15 #include "FREDView.h"
16 #include "MainFrm.h"
17 
18 #include <stdio.h>
19 #include <stdlib.h>
20 #include <string.h>
21 #include <float.h>
22 
23 #include "Management.h"
24 #include "math/vecmat.h"
25 #include "graphics/tmapper.h"
26 #include "graphics/2d.h"
27 #include "render/3d.h"
28 #include "model/model.h"
29 #include "bmpman/bmpman.h"
30 #include "io/key.h"
31 #include "physics/physics.h"
32 #include "math/floating.h"
33 #include "object/object.h"
34 #include "model/model.h"
35 #include "palman/palman.h"
36 #include "editor.h"
37 #include "ship/ship.h"
38 #include "cfile/cfile.h"
39 #include "mission/missionparse.h"
40 #include "globalincs/linklist.h"
41 #include "math/fvi.h"
42 #include "render/3dinternal.h"
43 #include "weapon/weapon.h"
44 #include "wing.h"
45 #include "FredRender.h"
46 #include <windows.h>
47 #include "starfield/starfield.h"
48 #include "io/timer.h"
49 #include "lighting/lighting.h"
50 #include "asteroid/asteroid.h"
51 #include "jumpnode/jumpnode.h"
52 #include "graphics/font.h"
53 #include "cmdline/cmdline.h"
54 #include "iff_defs/iff_defs.h"
55 #include "mod_table/mod_table.h"
56 
57 extern float flFrametime;
58 extern subsys_to_render Render_subsys;
59 
60 #ifdef _DEBUG
61 #undef THIS_FILE
62 static char THIS_FILE[] = __FILE__;
63 #endif
64 
65 #define MAX_FRAMETIME (F1_0/4) // Frametime gets saturated at this.
66 #define MIN_FRAMETIME (F1_0/120)
67 #define LOLLIPOP_SIZE 2.5f
68 #define CONVERT_DEGREES 57.29578f // conversion factor from radians to degrees
69 
70 const float FRED_DEFAULT_HTL_FOV = 0.485f;
71 const float FRED_BRIEFING_HTL_FOV = 0.325f;
72 const float FRED_DEAFULT_HTL_DRAW_DIST = 300000.0f;
73 
74 int Aa_gridlines = 0;
75 int Fred_outline = 0;
76 int inited = -1;
77 int player_start1;
78 int Editing_mode = 1;
79 int Control_mode = 0;
80 int last_x=0, last_y=0;
81 int Show_grid = 1;
82 int Show_outlines = 0;
83 int Show_stars = 1;
84 int Show_grid_positions = 1;
85 int Show_coordinates = 0;
86 int Show_distances = 0;
87 int Show_horizon = 0;
88 int Show_asteroid_field = 1;
89 int Lookat_mode = 0;
90 int Single_axis_constraint = 0;
91 int Universal_heading = 0;
92 int Flying_controls_mode = 1;
93 int Group_rotate = 1;
94 int info_popup_active = 0;
95 int rendering_order[MAX_SHIPS];
96 int render_count = 0;
97 int Last_cursor_over = -1;
98 int True_rw, True_rh;
99 int Fixed_briefing_size = 1;
100 
101 fix lasttime = 0;
102 vec3d my_pos = {0.0f, 0.0f, -5.0f};
103 vec3d view_pos, eye_pos, Viewer_pos, Last_eye_pos = { 0.0f };
104 vec3d Last_control_pos = { 0.0f };
105 vec3d Grid_center;
106 vec3d Constraint = { 1.0f, 0.0f, 1.0f };
107 vec3d Anticonstraint = { 0.0f, 1.0f, 0.0f };
108 vec3d Tp1, Tp2; // test points
109 matrix Grid_gmatrix;
110 matrix my_orient = IDENTITY_MATRIX;
111 matrix trackball_orient = IDENTITY_MATRIX;
112 matrix view_orient = IDENTITY_MATRIX, eye_orient, Last_eye_orient = IDENTITY_MATRIX;
113 matrix Last_control_orient = IDENTITY_MATRIX;
114 physics_info view_physics;
115 control_info view_controls;
116 CWnd info_popup;
117 
118 static vec3d Global_light_world = { 0.208758f, -0.688253f, -0.694782f };
119 
120 void display_distances();
121 void render_model_x(vec3d *pos, grid *gridp, int col_scheme = 0);
122 void render_model_x_htl(vec3d *pos, grid *gridp, int col_scheme = 0);
123 void draw_orient_sphere(object *obj, int r, int g, int b);
124 void draw_orient_sphere2(int col, object *obj, int r, int g, int b);
125 void render_compass(void);
126 void draw_compass_arrow(vec3d *v0);
127 void process_controls(vec3d *pos, matrix *orient, float frametime, int key, int mode = 0);
128 void render_one_model(object *objp);
129 void inc_mission_time();
130 void draw_asteroid_field();
131 void hilight_bitmap();
132 
133 color colour_white;
134 color colour_green;
135 color colour_black;
136 color colour_yellow;
137 
138 #define FRED_COLOUR_WHITE 0xffffff
139 #define FRED_COLOUR_YELLOW 0x9fff00
140 
141 void fred_enable_htl()
142 {
143  gr_set_proj_matrix((4.0f/9.0f) * PI * (Briefing_dialog ? Briefing_window_FOV : FRED_DEFAULT_HTL_FOV), gr_screen.aspect*(float)gr_screen.clip_width/(float)gr_screen.clip_height, 1.0f, FRED_DEAFULT_HTL_DRAW_DIST);
144  gr_set_view_matrix(&Eye_position, &Eye_matrix);
145 }
146 
147 void fred_disable_htl()
148 {
149  gr_end_proj_matrix();
150  gr_end_view_matrix();
151 }
152 
153 // Called every time a new mission is created (and erasing old mission from memory).
154 // New mission should be blank at this point.
155 void fred_render_init()
156 {
157  vec3d f, u, r;
158 
159  physics_init(&view_physics);
160  view_physics.max_vel.xyz.z = 5.0f; //forward/backward
161  view_physics.max_rotvel.xyz.x = 1.5f; //pitch
162  memset(&view_controls, 0, sizeof(control_info));
163 
164  vm_vec_make(&view_pos, 0.0f, 150.0f, -200.0f);
165  vm_vec_make(&f, 0.0f, -0.5f, 0.866025404f); // 30 degree angle
166  vm_vec_make(&u, 0.0f, 0.866025404f, 0.5f);
167  vm_vec_make(&r, 1.0f, 0.0f, 0.0f);
168  vm_vector_2_matrix(&view_orient, &f, &u, &r);
169 
170  The_grid = create_default_grid();
171  maybe_create_new_grid(The_grid, &view_pos, &view_orient, 1);
172 // vm_set_identity(&view_orient);
173 
174  gr_init_alphacolor( &colour_white, 255,255,255,255);
175  gr_init_alphacolor( &colour_green, 0,200,0,255);
176  gr_init_alphacolor( &colour_yellow, 200,255,0,255);
177  gr_init_alphacolor( &colour_black, 0,0,0,255);
178 }
179 
180 void level_object(matrix *orient)
181 {
182  vec3d u;
183 
184  u = orient->vec.uvec = The_grid->gmatrix.vec.uvec;
185  if (u.xyz.x) // y-z plane
186  {
187  orient->vec.fvec.xyz.x = orient->vec.rvec.xyz.x = 0.0f;
188 
189  } else if (u.xyz.y) { // x-z plane
190  orient->vec.fvec.xyz.y = orient->vec.rvec.xyz.y = 0.0f;
191 
192  } else if (u.xyz.z) { // x-y plane
193  orient->vec.fvec.xyz.z = orient->vec.rvec.xyz.z = 0.0f;
194  }
195 
196  vm_fix_matrix(orient);
197 }
198 
199 void level_controlled()
200 {
201  int cmode, count = 0;
202  object *objp;
203 
204  cmode = Control_mode;
205  if ((viewpoint == 1) && !cmode)
206  cmode = 2;
207 
208  switch (cmode) {
209  case 0: // Control the viewer's location and orientation
210  level_object(&view_orient);
211  break;
212 
213  case 2: // Control viewpoint object
214  level_object(&Objects[view_obj].orient);
215  object_moved(&Objects[view_obj]);
216  set_modified();
217  FREDDoc_ptr->autosave("level object");
218  break;
219 
220  case 1: // Control the current object's location and orientation
221  objp = GET_FIRST(&obj_used_list);
222  while (objp != END_OF_LIST(&obj_used_list)) {
223  if (objp->flags & OF_MARKED)
224  level_object(&objp->orient);
225 
226  objp = GET_NEXT(objp);
227  }
228 
229  objp = GET_FIRST(&obj_used_list);
230  while (objp != END_OF_LIST(&obj_used_list)) {
231  if (objp->flags & OF_MARKED) {
232  object_moved(objp);
233  count++;
234  }
235 
236  objp = GET_NEXT(objp);
237  }
238 
239  if (count) {
240  if (count > 1)
241  FREDDoc_ptr->autosave("level objects");
242  else
243  FREDDoc_ptr->autosave("level object");
244 
245  set_modified();
246  }
247 
248  break;
249  }
250 
251  return;
252 }
253 
254 void align_vector_to_axis(vec3d *v)
255 {
256  float x, y, z;
257 
258  x = v->xyz.x;
259  if (x < 0)
260  x = -x;
261 
262  y = v->xyz.y;
263  if (y < 0)
264  y = -y;
265 
266  z = v->xyz.z;
267  if (z < 0)
268  z = -z;
269 
270  if ((x > y) && (x > z)) { // x axis
271  if (v->xyz.x < 0) // negative x
272  vm_vec_make(v, -1.0f, 0.0f, 0.0f);
273  else // positive x
274  vm_vec_make(v, 1.0f, 0.0f, 0.0f);
275 
276  } else if (y > z) { // y axis
277  if (v->xyz.y < 0) // negative y
278  vm_vec_make(v, 0.0f, -1.0f, 0.0f);
279  else // positive y
280  vm_vec_make(v, 0.0f, 1.0f, 0.0f);
281 
282  } else { // z axis
283  if (v->xyz.z < 0) // negative z
284  vm_vec_make(v, 0.0f, 0.0f, -1.0f);
285  else // positive z
286  vm_vec_make(v, 0.0f, 0.0f, 1.0f);
287  }
288 }
289 
290 void verticalize_object(matrix *orient)
291 {
292  align_vector_to_axis(&orient->vec.fvec);
293  align_vector_to_axis(&orient->vec.uvec);
294  align_vector_to_axis(&orient->vec.rvec);
295  vm_fix_matrix(orient); // just in case something odd occurs.
296 }
297 
298 void verticalize_controlled()
299 {
300  int cmode, count = 0;
301  object *objp;
302 
303  cmode = Control_mode;
304  if ((viewpoint == 1) && !cmode)
305  cmode = 2;
306 
307  switch (cmode) {
308  case 0: // Control the viewer's location and orientation
309  verticalize_object(&view_orient);
310  break;
311 
312  case 2: // Control viewpoint object
313  verticalize_object(&Objects[view_obj].orient);
314  object_moved(&Objects[view_obj]);
315  FREDDoc_ptr->autosave("align object");
316  set_modified();
317  break;
318 
319  case 1: // Control the current object's location and orientation
320  objp = GET_FIRST(&obj_used_list);
321  while (objp != END_OF_LIST(&obj_used_list)) {
322  if (objp->flags & OF_MARKED)
323  verticalize_object(&objp->orient);
324 
325  objp = GET_NEXT(objp);
326  }
327 
328  objp = GET_FIRST(&obj_used_list);
329  while (objp != END_OF_LIST(&obj_used_list)) {
330  if (objp->flags & OF_MARKED) {
331  object_moved(objp);
332  count++;
333  }
334 
335  objp = GET_NEXT(objp);
336  }
337 
338  if (count) {
339  if (count > 1)
340  FREDDoc_ptr->autosave("align objects");
341  else
342  FREDDoc_ptr->autosave("align object");
343 
344  set_modified();
345  }
346 
347  break;
348  }
349 
350  return;
351 }
352 
353 void move_mouse( int btn, int mdx, int mdy )
354 {
355  int dx, dy;
356 
357  dx = mdx - last_x;
358  dy = mdy - last_y;
359  last_x = mdx;
360  last_y = mdy;
361 
362  if ( btn & 1 ) {
363  matrix tempm, mousem;
364 
365  if ( dx || dy ) {
366  vm_trackball( dx, dy, &mousem );
367  vm_matrix_x_matrix(&tempm, &trackball_orient, &mousem);
368  trackball_orient = tempm;
369  view_orient = trackball_orient;
370  }
371  }
372 
373  if ( btn & 2 ) {
374  my_pos.xyz.z += (float)dy;
375  }
376 }
377 
379 void process_system_keys(int key)
380 {
381 // mprintf(("Key = %d\n", key));
382  switch (key) {
383 
384  case KEY_LAPOSTRO:
385  CFREDView::GetView()->cycle_constraint();
386  break;
387 
388  case KEY_R: // for some stupid reason, an accelerator for 'R' doesn't work.
389  Editing_mode = 2;
390  break;
391 
392  case KEY_SPACEBAR:
393  Selection_lock = !Selection_lock;
394  break;
395 
396  case KEY_ESC:
397  if (button_down)
398  cancel_drag();
399 
400  break;
401  }
402 }
403 
404 void render_waypoints(void)
405 {
406  vertex v;
407 
408  SCP_list<waypoint_list>::iterator ii;
409  SCP_vector<waypoint>::iterator jj;
410 
411  for (ii = Waypoint_lists.begin(); ii != Waypoint_lists.end(); ++ii)
412  {
413  vec3d *prev_vec = NULL;
414  for (jj = ii->get_waypoints().begin(); jj != ii->get_waypoints().end(); ++jj)
415  {
416  g3_rotate_vertex(&v, jj->get_pos());
417  if (!(v.codes & CC_BEHIND))
418  {
419  if (!(g3_project_vertex(&v) & PF_OVERFLOW))
420  {
421  if (cur_waypoint_list == &(*ii) && cur_waypoint == &(*jj))
422  gr_set_color(255, 255, 255);
423  else if (Objects[jj->get_objnum()].flags & OF_MARKED)
424  gr_set_color(160, 255, 0);
425  else
426  gr_set_color(160, 96, 0);
427 
428  g3_draw_sphere(&v, LOLLIPOP_SIZE);
429  if (prev_vec == NULL)
430  gr_set_color(160, 96, 0);
431  else
432  gr_set_color(0, 0, 0);
433 
434  g3_draw_sphere(&v, LOLLIPOP_SIZE * 0.66667f);
435  gr_set_color(160, 96, 0);
436  g3_draw_sphere(&v, LOLLIPOP_SIZE * 0.33333f);
437  }
438  }
439 
440  render_model_x(jj->get_pos(), The_grid, 1);
441 
442  gr_set_color(160, 96, 0);
443  if (prev_vec != NULL)
444  rpd_line(prev_vec, jj->get_pos());
445  prev_vec = jj->get_pos();
446  }
447  }
448 }
449 
450 // --------------------------------------------------------------------------------
451 // get_subsystem_world_pos2() returns the world position for a given subobject on a ship
452 //
453 
454 vec3d* get_subsystem_world_pos2(object* parent_obj, ship_subsys* subsys, vec3d* world_pos)
455 {
456  if (subsys == NULL) {
457  *world_pos = parent_obj->pos;
458  return world_pos;
459  }
460 
461  vm_vec_unrotate(world_pos, &subsys->system_info->pnt, &parent_obj->orient);
462  vm_vec_add2(world_pos, &parent_obj->pos);
463 
464  return world_pos;
465 }
466 
467 // returns 1 for valid bounding rect, 0 otherwise
468 int get_subsys_bounding_rect(object *ship_obj, ship_subsys *subsys, int *x1, int *x2, int *y1, int *y2)
469 {
470  if (subsys != NULL) {
471  vertex subobj_vertex;
472  vec3d subobj_pos;
473 
474  get_subsystem_world_pos2(ship_obj, subsys, &subobj_pos);
475 
476  g3_rotate_vertex(&subobj_vertex, &subobj_pos);
477 
478  g3_project_vertex(&subobj_vertex);
479  if (subobj_vertex.flags & PF_OVERFLOW) // if overflow, no point in drawing brackets
480  return 0;
481 
482  int bound_rc;
483 
484  bound_rc = subobj_find_2d_bound(subsys->system_info->radius, &ship_obj->orient, &subobj_pos, x1, y1, x2, y2);
485  if ( bound_rc != 0 )
486  return 0;
487 
488  return 1;
489  }
490 
491  return 0;
492 }
493 
494 void cancel_display_active_ship_subsystem()
495 {
496  Render_subsys.do_render = false;
497  Render_subsys.ship_obj = NULL;
498  Render_subsys.cur_subsys = NULL;
499 }
500 
501 void fredhtl_render_subsystem_bounding_box(subsys_to_render * s2r)
502 {
503 
504  vertex text_center;
505  polymodel *pm = model_get(Ship_info[Ships[s2r->ship_obj->instance].ship_info_index].model_num);
506  int subobj_num = s2r->cur_subsys->system_info->subobj_num;
507  bsp_info *bsp = &pm->submodel[subobj_num];
508  char buf[256];
509 
510  vec3d front_top_left = bsp->bounding_box[7];
511  vec3d front_top_right = bsp->bounding_box[6];
512  vec3d front_bot_left = bsp->bounding_box[4];
513  vec3d front_bot_right = bsp->bounding_box[5];
514  vec3d back_top_left = bsp->bounding_box[3];
515  vec3d back_top_right = bsp->bounding_box[2];
516  vec3d back_bot_left = bsp->bounding_box[0];
517  vec3d back_bot_right = bsp->bounding_box[1];
518 
519  gr_set_color(255, 32, 32);
520 
521  fred_enable_htl();
522 
523  //draw a cube around the subsystem
524  g3_start_instance_matrix(&s2r->ship_obj->pos, &s2r->ship_obj->orient, true);
525  g3_start_instance_matrix(&bsp->offset, &vmd_identity_matrix, true);
526  g3_draw_htl_line(&front_top_left, &front_top_right);
527  g3_draw_htl_line(&front_top_right, &front_bot_right);
528  g3_draw_htl_line(&front_bot_right, &front_bot_left);
529  g3_draw_htl_line(&front_bot_left, &front_top_left);
530 
531  g3_draw_htl_line(&back_top_left, &back_top_right);
532  g3_draw_htl_line(&back_top_right, &back_bot_right);
533  g3_draw_htl_line(&back_bot_right, &back_bot_left);
534  g3_draw_htl_line(&back_bot_left, &back_top_left);
535 
536  g3_draw_htl_line(&front_top_left, &back_top_left);
537  g3_draw_htl_line(&front_top_right, &back_top_right);
538  g3_draw_htl_line(&front_bot_left, &back_bot_left);
539  g3_draw_htl_line(&front_bot_right, &back_bot_right);
540 
541 
542  //draw another cube around a gun for a two-part turret
543  if ((s2r->cur_subsys->system_info->turret_gun_sobj >= 0) && (s2r->cur_subsys->system_info->turret_gun_sobj != s2r->cur_subsys->system_info->subobj_num))
544  {
545  bsp_info *bsp_turret = &pm->submodel[s2r->cur_subsys->system_info->turret_gun_sobj];
546 
547  vec3d front_top_left = bsp_turret->bounding_box[7];
548  vec3d front_top_right = bsp_turret->bounding_box[6];
549  vec3d front_bot_left = bsp_turret->bounding_box[4];
550  vec3d front_bot_right = bsp_turret->bounding_box[5];
551  vec3d back_top_left = bsp_turret->bounding_box[3];
552  vec3d back_top_right = bsp_turret->bounding_box[2];
553  vec3d back_bot_left = bsp_turret->bounding_box[0];
554  vec3d back_bot_right = bsp_turret->bounding_box[1];
555 
556  g3_start_instance_matrix(&bsp_turret->offset, &vmd_identity_matrix, true);
557 
558  g3_draw_htl_line(&front_top_left, &front_top_right);
559  g3_draw_htl_line(&front_top_right, &front_bot_right);
560  g3_draw_htl_line(&front_bot_right, &front_bot_left);
561  g3_draw_htl_line(&front_bot_left, &front_top_left);
562 
563  g3_draw_htl_line(&back_top_left, &back_top_right);
564  g3_draw_htl_line(&back_top_right, &back_bot_right);
565  g3_draw_htl_line(&back_bot_right, &back_bot_left);
566  g3_draw_htl_line(&back_bot_left, &back_top_left);
567 
568  g3_draw_htl_line(&front_top_left, &back_top_left);
569  g3_draw_htl_line(&front_top_right, &back_top_right);
570  g3_draw_htl_line(&front_bot_left, &back_bot_left);
571  g3_draw_htl_line(&front_bot_right, &back_bot_right);
572 
573  g3_done_instance(true);
574  }
575 
576  g3_done_instance(true);
577  g3_done_instance(true);
578 
579  fred_disable_htl();
580 
581  //draw the text. rotate the center of the subsystem into place before finding out where to put the text
582  strcpy_s(buf, Render_subsys.cur_subsys->system_info->subobj_name);
583  vec3d center_pt;
584  vm_vec_unrotate(&center_pt, &bsp->offset, &s2r->ship_obj->orient);
585  vm_vec_add2(&center_pt, &s2r->ship_obj->pos);
586  g3_rotate_vertex(&text_center, &center_pt);
587  g3_project_vertex(&text_center);
588  gr_set_color_fast(&colour_white);
589  gr_string_win( (int)text_center.screen.xyw.x, (int)text_center.screen.xyw.y, buf);
590 }
591 
592 void display_active_ship_subsystem()
593 {
594  if (cur_object_index != -1)
595  {
596  if (Objects[cur_object_index].type == OBJ_SHIP)
597  {
598 
599  object *objp = &Objects[cur_object_index];
600  int x1, y1, x2, y2;
601  char buf[256];
602 
603  // switching to a new ship, so reset
604  if (objp != Render_subsys.ship_obj) {
605  cancel_display_active_ship_subsystem();
606  return;
607  }
608 
609  if (Render_subsys.do_render)
610  {
611 
612  // get subsys name
613  strcpy_s(buf, Render_subsys.cur_subsys->system_info->subobj_name);
614 
615  if (Cmdline_nohtl)
616  {
617  // get bounding box
618  if ( get_subsys_bounding_rect(objp, Render_subsys.cur_subsys, &x1, &x2, &y1, &y2) )
619  {
620 
621  // set color
622  gr_set_color(255, 32, 32);
623 
624  // draw box
625  gr_line(x1, y1, x1, y2); gr_line(x1-1, y1, x1-1, y2);
626  gr_line(x1, y2, x2, y2); gr_line(x1, y2+1, x2, y2+1);
627  gr_line(x2, y2, x2, y1); gr_line(x2+1, y2, x2+1, y1);
628  gr_line(x2, y1, x1, y1); gr_line(x2, y1-1, x1, y1-1);
629 
630  // draw text
631  gr_set_color_fast(&colour_white);
632  gr_string_win( (x1+x2)/2, y2 + 10, buf);
633  }
634  }
635  else
636  {
637  fredhtl_render_subsystem_bounding_box(&Render_subsys);
638  }
639  }
640  else
641  {
642  cancel_display_active_ship_subsystem();
643  }
644  }
645  }
646 }
647 
648 void render_one_model_htl(object *objp);
649 void render_one_model_nohtl(object *objp);
650 void render_one_model_briefing_screen(object *objp);
651 
652 void render_models(void)
653 {
654  gr_set_color_fast(&colour_white);
655 
656  render_count = 0;
657 
658  if ( (ENVMAP == -1) && strlen(The_mission.envmap_name) ) {
659  ENVMAP = bm_load(The_mission.envmap_name);
660  }
661 
662  bool f=false;
663  if (Cmdline_nohtl)
664  {
665  obj_render_all(render_one_model_nohtl,&f);
666  }
667  else
668  {
669  fred_enable_htl();
670 
671  obj_render_all(render_one_model_htl,&f);
672 
673  fred_disable_htl();
674 
675  }
676 
677  if (Briefing_dialog)
678  {
679  obj_render_all(render_one_model_briefing_screen, &f);
680  Briefing_dialog->batch_render();
681  }
682 
683 }
684 
685 void render_one_model_briefing_screen(object *objp)
686 {
687  if (objp->type == OBJ_POINT)
688  {
689  if (objp->instance != BRIEFING_LOOKAT_POINT_ID)
690  {
691  Assert(Briefing_dialog);
692  Briefing_dialog->draw_icon(objp);
693  render_model_x_htl(&objp->pos, The_grid);
694  render_count++;
695  }
696 
697  }
698 }
699 
700 void render_one_model_nohtl(object *objp)
701 {
702  int j, z;
703  uint debug_flags = 0;
704  object *o2;
705 
706  Assert(objp->type != OBJ_NONE);
707 
708  if ( objp->type == OBJ_JUMP_NODE ) {
709  return;
710  }
711 
712  if ((objp->type == OBJ_WAYPOINT) && !Show_waypoints)
713  return;
714 
715  if ((objp->type == OBJ_START) && !Show_starts)
716  return;
717 
718  if ((objp->type == OBJ_SHIP) || (objp->type == OBJ_START)) {
719  if (!Show_ships)
720  return;
721 
722  if (!Show_iff[Ships[objp->instance].team])
723  return;
724  }
725 
726  if (objp->flags & OF_HIDDEN)
727  return;
728 
729  rendering_order[render_count] = OBJ_INDEX(objp);
730  Fred_outline = 0;
731  if ((OBJ_INDEX(objp) == cur_object_index) && !Bg_bitmap_dialog)
732  Fred_outline = FRED_COLOUR_WHITE;
733 
734  else if ((objp->flags & OF_MARKED) && !Bg_bitmap_dialog) // is it a marked object?
735  Fred_outline = FRED_COLOUR_YELLOW;
736 
737  else if ((objp->type == OBJ_SHIP) && Show_outlines) {
738  color *iff_color = iff_get_color_by_team_and_object(Ships[objp->instance].team, -1, 1, objp);
739 
740  Fred_outline = (iff_color->red << 16) | (iff_color->green << 8) | (iff_color->blue);
741 
742  } else if ((objp->type == OBJ_START) && Show_outlines) {
743  Fred_outline = 0x007f00;
744 
745  } else
746  Fred_outline = 0;
747 
748  // build flags
749  if ((Show_ship_models || Show_outlines) && ((objp->type == OBJ_SHIP) || (objp->type == OBJ_START))){
750  if (Show_ship_models){
751  j = MR_NORMAL;
752  } else {
753  j = MR_NO_POLYS;
754  }
755 
756  if(Show_dock_points){
757  debug_flags |= MR_DEBUG_BAY_PATHS;
758  }
759 
760  if(Show_paths_fred){
761  debug_flags |= MR_DEBUG_PATHS;
762  }
763 
764  z = objp->instance;
765 
766  model_clear_instance( Ship_info[Ships[z].ship_info_index].model_num );
767 
768 // if (!viewpoint || OBJ_INDEX(objp) != cur_object_index)
769  {
770  model_render_params render_info;
771 
772  if (Fred_outline) {
773  render_info.set_flags(j | MR_SHOW_OUTLINE | MR_NO_TEXTURING | MR_NO_LIGHTING);
774  render_info.set_color(Fred_outline >> 16, (Fred_outline >> 8) & 0xff, Fred_outline & 0xff);
775  } else {
776  render_info.set_flags(j);
777  }
778 
779  render_info.set_debug_flags(debug_flags);
780  render_info.set_replacement_textures(Ships[z].ship_replacement_textures);
781 
782  model_render_immediate(&render_info, Ship_info[Ships[z].ship_info_index].model_num, &objp->orient, &objp->pos);
783  }
784 
785  } else {
786  int r = 0, g = 0, b = 0;
787 
788  if (objp->type == OBJ_SHIP)
789  {
790  if (!Show_ships)
791  return;
792 
793  color *iff_color = iff_get_color_by_team_and_object(Ships[objp->instance].team, -1, 1, objp);
794 
795  r = iff_color->red;
796  g = iff_color->green;
797  b = iff_color->blue;
798 
799  } else if (objp->type == OBJ_START) {
800  r = 0; g = 127; b = 0;
801 
802  } else if (objp->type == OBJ_WAYPOINT) {
803  r = 96; g = 0; b = 112;
804 
805  } else if (objp->type == OBJ_POINT) {
806  if (objp->instance != BRIEFING_LOOKAT_POINT_ID)
807  {
808  return;
809  }
810 
811  r = 196; g = 32; b = 196;
812 
813  } else
814  Assert(0);
815 
816  if (Fred_outline)
817  draw_orient_sphere2(Fred_outline, objp, r, g, b);
818  else
819  draw_orient_sphere(objp, r, g, b);
820  }
821 
822  if (objp->type == OBJ_WAYPOINT)
823  {
824  for (j=0; j<render_count; j++)
825  {
826  o2 = &Objects[rendering_order[j]];
827  if (o2->type == OBJ_WAYPOINT)
828  if ((o2->instance == objp->instance - 1) || (o2->instance == objp->instance + 1))
829  rpd_line(&o2->pos, &objp->pos);
830  }
831  }
832 
833  render_model_x(&objp->pos, The_grid);
834  render_count++;
835 }
836 
837 void render_one_model_htl(object *objp)
838 {
839  int j, z;
840  uint debug_flags = 0;
841  object *o2;
842 
843  Assert(objp->type != OBJ_NONE);
844 
845  if ( objp->type == OBJ_JUMP_NODE ) {
846  return;
847  }
848 
849  if ((objp->type == OBJ_WAYPOINT) && !Show_waypoints)
850  return;
851 
852  if ((objp->type == OBJ_START) && !Show_starts)
853  return;
854 
855  if ((objp->type == OBJ_SHIP) || (objp->type == OBJ_START)) {
856  if (!Show_ships)
857  return;
858 
859  if (!Show_iff[Ships[objp->instance].team])
860  return;
861  }
862 
863  if (objp->flags & OF_HIDDEN)
864  return;
865 
866  rendering_order[render_count] = OBJ_INDEX(objp);
867  Fred_outline = 0;
868  if ((OBJ_INDEX(objp) == cur_object_index) && !Bg_bitmap_dialog)
869  Fred_outline = FRED_COLOUR_WHITE;
870 
871  else if ((objp->flags & OF_MARKED) && !Bg_bitmap_dialog) // is it a marked object?
872  Fred_outline = FRED_COLOUR_YELLOW;
873 
874  else if ((objp->type == OBJ_SHIP) && Show_outlines) {
875  color *iff_color = iff_get_color_by_team_and_object(Ships[objp->instance].team, -1, 1, objp);
876 
877  Fred_outline = (iff_color->red << 16) | (iff_color->green << 8) | (iff_color->blue);
878 
879  } else if ((objp->type == OBJ_START) && Show_outlines) {
880  Fred_outline = 0x007f00;
881 
882  } else
883  Fred_outline = 0;
884 
885  // build flags
886  if ((Show_ship_models || Show_outlines) && ((objp->type == OBJ_SHIP) || (objp->type == OBJ_START))){
887  g3_start_instance_matrix(&Eye_position, &Eye_matrix, 0);
888 
889  j = MR_NORMAL;
890 
891  if(Show_dock_points){
892  debug_flags |= MR_DEBUG_BAY_PATHS;
893  }
894 
895  if(Show_paths_fred){
896  debug_flags |= MR_DEBUG_PATHS;
897  }
898 
899  z = objp->instance;
900 
901  model_clear_instance( Ship_info[Ships[z].ship_info_index].model_num );
902 
903  if(!Lighting_on) {
904  j |= MR_NO_LIGHTING;
905  gr_set_lighting(false,false);
906  }
907 
908  if (FullDetail) {
909  j |= MR_FULL_DETAIL;
910  }
911 
912  model_render_params render_info;
913 
914  render_info.set_debug_flags(debug_flags);
915  render_info.set_replacement_textures(Ships[z].ship_replacement_textures);
916 
917  if (Fred_outline) {
918  render_info.set_color(Fred_outline >> 16, (Fred_outline >> 8) & 0xff, Fred_outline & 0xff);
919  render_info.set_flags(j | MR_SHOW_OUTLINE_HTL | MR_NO_LIGHTING | MR_NO_POLYS | MR_NO_TEXTURING);
920  model_render_immediate(&render_info, Ship_info[Ships[z].ship_info_index].model_num, &objp->orient, &objp->pos);
921  }
922 
923  g3_done_instance(0);
924 
925  if ( Show_ship_models ) {
926  render_info.set_flags(j);
927  model_render_immediate(&render_info, Ship_info[Ships[z].ship_info_index].model_num, &objp->orient, &objp->pos);
928  }
929  } else {
930  int r = 0, g = 0, b = 0;
931 
932  if (objp->type == OBJ_SHIP)
933  {
934  if (!Show_ships) {
935  return;
936  }
937 
938  color *iff_color = iff_get_color_by_team_and_object(Ships[objp->instance].team, -1, 1, objp);
939 
940  r = iff_color->red;
941  g = iff_color->green;
942  b = iff_color->blue;
943 
944  } else if (objp->type == OBJ_START) {
945  r = 0; g = 127; b = 0;
946 
947  } else if (objp->type == OBJ_WAYPOINT) {
948  r = 96; g = 0; b = 112;
949 
950  } else if (objp->type == OBJ_POINT) {
951  if (objp->instance != BRIEFING_LOOKAT_POINT_ID) {
952  Assert(Briefing_dialog);
953  return;
954  }
955 
956  r = 196; g = 32; b = 196;
957 
958  } else
959  Assert(0);
960 
961  float size = fl_sqrt(vm_vec_dist(&eye_pos, &objp->pos) / 20.0f);
962 
963  if (size < LOLLIPOP_SIZE)
964  size = LOLLIPOP_SIZE;
965 
966  if (Fred_outline)
967  {
968  gr_set_color(__min(r*2,255),__min(g*2,255),__min(b*2,255));
969  g3_draw_htl_sphere(&objp->pos, size * 1.5f);
970  }
971  else
972  {
973  gr_set_color(r,g,b);
974  g3_draw_htl_sphere(&objp->pos, size);
975  }
976  }
977 
978  if (objp->type == OBJ_WAYPOINT)
979  {
980  for (j=0; j<render_count; j++)
981  {
982  o2 = &Objects[rendering_order[j]];
983  if (o2->type == OBJ_WAYPOINT)
984  {
985  if ((o2->instance == objp->instance - 1) || (o2->instance == objp->instance + 1))
986  {
987  g3_draw_htl_line(&o2->pos, &objp->pos);
988  }
989  }
990  }
991  }
992 
993  render_model_x_htl(&objp->pos, The_grid);
994  render_count++;
995 }
996 
997 void display_distances()
998 {
999  char buf[20];
1000  object *objp, *o2;
1001  vec3d pos;
1002  vertex v;
1003 
1004 
1005  gr_set_color(255, 0, 0);
1006  objp = GET_FIRST(&obj_used_list);
1007  while (objp != END_OF_LIST(&obj_used_list))
1008  {
1009  if (objp->flags & OF_MARKED)
1010  {
1011  o2 = GET_NEXT(objp);
1012  while (o2 != END_OF_LIST(&obj_used_list))
1013  {
1014  if (o2->flags & OF_MARKED)
1015  {
1016  rpd_line(&objp->pos, &o2->pos);
1017  vm_vec_avg(&pos, &objp->pos, &o2->pos);
1018  g3_rotate_vertex(&v, &pos);
1019  if (!(v.codes & CC_BEHIND))
1020  if (!(g3_project_vertex(&v) & PF_OVERFLOW)) {
1021  sprintf(buf, "%.1f", vm_vec_dist(&objp->pos, &o2->pos));
1022  gr_set_color_fast(&colour_white);
1023  gr_string_win((int) v.screen.xyw.x, (int) v.screen.xyw.y, buf);
1024  }
1025  }
1026 
1027  o2 = GET_NEXT(o2);
1028  }
1029  }
1030 
1031  objp = GET_NEXT(objp);
1032  }
1033 }
1034 
1035 void display_ship_info()
1036 {
1037  char buf[512], pos[80];
1038  int render = 1;
1039  object *objp;
1040  vertex v;
1041 
1042  objp = GET_FIRST(&obj_used_list);
1043  while (objp != END_OF_LIST(&obj_used_list)) {
1044  Assert(objp->type != OBJ_NONE);
1045  Fred_outline = 0;
1046  render = 1;
1047  if (OBJ_INDEX(objp) == cur_object_index)
1048  Fred_outline = FRED_COLOUR_WHITE;
1049  else if (objp->flags & OF_MARKED) // is it a marked object?
1050  Fred_outline = FRED_COLOUR_YELLOW;
1051  else
1052  Fred_outline = 0;
1053 
1054  if ((objp->type == OBJ_WAYPOINT) && !Show_waypoints)
1055  render = 0;
1056 
1057  if ((objp->type == OBJ_START) && !Show_starts)
1058  render = 0;
1059 
1060  if ((objp->type == OBJ_SHIP) || (objp->type == OBJ_START)) {
1061  if (!Show_ships)
1062  render = 0;
1063 
1064  if (!Show_iff[Ships[objp->instance].team])
1065  render = 0;
1066  }
1067 
1068  if (objp->flags & OF_HIDDEN)
1069  render = 0;
1070 
1071  g3_rotate_vertex(&v, &objp->pos);
1072  if (!(v.codes & CC_BEHIND) && render)
1073  if (!(g3_project_vertex(&v) & PF_OVERFLOW)) {
1074  *buf = 0;
1075  if (Show_ship_info)
1076  {
1077  if ((objp->type == OBJ_SHIP) || (objp->type == OBJ_START)) {
1078  ship *shipp;
1079  int ship_type;
1080 
1081  shipp = &Ships[objp->instance];
1082  ship_type = shipp->ship_info_index;
1083  ASSERT(ship_type >= 0);
1084  sprintf(buf, "%s\n%s", shipp->ship_name, Ship_info[ship_type].short_name);
1085 
1086  } else if (objp->type == OBJ_WAYPOINT) {
1087  int idx;
1088  waypoint_list *wp_list = find_waypoint_list_with_instance(objp->instance, &idx);
1089  Assert(wp_list != NULL);
1090  sprintf(buf, "%s\nWaypoint %d", wp_list->get_name(), idx + 1);
1091 
1092  } else if (objp->type == OBJ_POINT) {
1093  if (objp->instance == BRIEFING_LOOKAT_POINT_ID)
1094  strcpy_s(buf, "Camera lookat point");
1095  else
1096  strcpy_s(buf, "Briefing icon");
1097 
1098  } else if (objp->type == OBJ_JUMP_NODE) {
1099  strcpy_s(buf, "Jump Node");
1100  } else
1101  Assert(0);
1102  }
1103 
1104  if (Show_coordinates)
1105  {
1106  sprintf(pos, "(%.0f,%.0f,%.0f)", objp->pos.xyz.x, objp->pos.xyz.y, objp->pos.xyz.z);
1107  if (*buf)
1108  strcat_s(buf, "\n");
1109 
1110  strcat_s(buf, pos);
1111  }
1112 
1113  if (*buf)
1114  {
1115  if (Fred_outline == FRED_COLOUR_WHITE)
1116  gr_set_color_fast(&colour_green);
1117  else if (Fred_outline == FRED_COLOUR_YELLOW)
1118  gr_set_color_fast(&colour_yellow);
1119  else
1120  gr_set_color_fast(&colour_white);
1121 
1122  gr_string_win((int) v.screen.xyw.x, (int) v.screen.xyw.y, buf);
1123  }
1124  }
1125 
1126  objp = GET_NEXT(objp);
1127  }
1128 }
1129 
1130 void draw_orient_sphere(object *obj, int r, int g, int b)
1131 {
1132  int flag = 0;
1133  vertex v;
1134  vec3d v1, v2;
1135  float size;
1136 
1137  size = fl_sqrt(vm_vec_dist(&eye_pos, &obj->pos) / 20.0f);
1138  if (size < LOLLIPOP_SIZE)
1139  size = LOLLIPOP_SIZE;
1140 
1141  if ((obj->type != OBJ_WAYPOINT) && (obj->type != OBJ_POINT))
1142  {
1143  flag = (vm_vec_dot(&eye_orient.vec.fvec, &obj->orient.vec.fvec) < 0.0f);
1144  v1 = v2 = obj->pos;
1145  vm_vec_scale_add2(&v1, &obj->orient.vec.fvec, size);
1146  vm_vec_scale_add2(&v2, &obj->orient.vec.fvec, size * 1.5f);
1147 
1148  if (!flag) {
1149  gr_set_color(192, 192, 192);
1150  rpd_line(&v1, &v2);
1151  }
1152  }
1153 
1154  gr_set_color(r, g, b);
1155  g3_rotate_vertex(&v, &obj->pos);
1156  if (!(v.codes & CC_BEHIND))
1157  if (!(g3_project_vertex(&v) & PF_OVERFLOW))
1158  g3_draw_sphere(&v, size);
1159 
1160  if (flag) {
1161  gr_set_color(192, 192, 192);
1162  rpd_line(&v1, &v2);
1163  }
1164 }
1165 
1166 void draw_orient_sphere2(int col, object *obj, int r, int g, int b)
1167 {
1168  int flag = 0;
1169  vertex v;
1170  vec3d v1, v2;
1171  float size;
1172 
1173  size = fl_sqrt(vm_vec_dist(&eye_pos, &obj->pos) / 20.0f);
1174  if (size < LOLLIPOP_SIZE)
1175  size = LOLLIPOP_SIZE;
1176 
1177  if ((obj->type != OBJ_WAYPOINT) && (obj->type != OBJ_POINT))
1178  {
1179  flag = (vm_vec_dot(&eye_orient.vec.fvec, &obj->orient.vec.fvec) < 0.0f);
1180 
1181  v1 = v2 = obj->pos;
1182  vm_vec_scale_add2(&v1, &obj->orient.vec.fvec, size);
1183  vm_vec_scale_add2(&v2, &obj->orient.vec.fvec, size * 1.5f);
1184 
1185  if (!flag) {
1186  gr_set_color(192, 192, 192);
1187  rpd_line(&v1, &v2);
1188  }
1189  }
1190 
1191  g3_rotate_vertex(&v, &obj->pos);
1192  if (!(v.codes & CC_BEHIND))
1193  if (!(g3_project_vertex(&v) & PF_OVERFLOW))
1194  {
1195  gr_set_color((col >> 16) & 0xff, (col >> 8) & 0xff, col & 0xff);
1196  g3_draw_sphere(&v, size);
1197  gr_set_color(r, g, b);
1198  g3_draw_sphere(&v, size * 0.75f);
1199  }
1200 
1201  if (flag) {
1202  gr_set_color(192, 192, 192);
1203  rpd_line(&v1, &v2);
1204  }
1205 }
1206 
1207 void render_model_x(vec3d *pos, grid *gridp, int col_scheme)
1208 {
1209  vec3d gpos; // Location of point on grid.
1210  vec3d tpos;
1211  float dxz;
1212  plane tplane;
1213  vec3d *gv;
1214 
1215  if (!Show_grid_positions)
1216  return;
1217 
1218  tplane.A = gridp->gmatrix.vec.uvec.xyz.x;
1219  tplane.B = gridp->gmatrix.vec.uvec.xyz.y;
1220  tplane.C = gridp->gmatrix.vec.uvec.xyz.z;
1221  tplane.D = gridp->planeD;
1222 
1223  compute_point_on_plane(&gpos, &tplane, pos);
1224  dxz = vm_vec_dist(pos, &gpos)/8.0f;
1225  gv = &gridp->gmatrix.vec.uvec;
1226  if (gv->xyz.x * pos->xyz.x + gv->xyz.y * pos->xyz.y + gv->xyz.z * pos->xyz.z < -gridp->planeD)
1227  gr_set_color(0, 127, 0);
1228  else
1229  gr_set_color(192, 192, 192);
1230 
1231 
1232  rpd_line(&gpos, pos); // Line from grid to object center.
1233 
1234  tpos = gpos;
1235 
1236  vm_vec_scale_add2(&gpos, &gridp->gmatrix.vec.rvec, -dxz/2);
1237  vm_vec_scale_add2(&gpos, &gridp->gmatrix.vec.fvec, -dxz/2);
1238 
1239  vm_vec_scale_add2(&tpos, &gridp->gmatrix.vec.rvec, dxz/2);
1240  vm_vec_scale_add2(&tpos, &gridp->gmatrix.vec.fvec, dxz/2);
1241 
1242  rpd_line(&gpos, &tpos);
1243 
1244  vm_vec_scale_add2(&gpos, &gridp->gmatrix.vec.rvec, dxz);
1245  vm_vec_scale_add2(&tpos, &gridp->gmatrix.vec.rvec, -dxz);
1246 
1247  rpd_line(&gpos, &tpos);
1248 }
1249 
1250 void render_model_x_htl(vec3d *pos, grid *gridp, int col_scheme)
1251 {
1252  vec3d gpos; // Location of point on grid.
1253  vec3d tpos;
1254  float dxz;
1255  plane tplane;
1256  vec3d *gv;
1257 
1258  if (!Show_grid_positions)
1259  return;
1260 
1261  tplane.A = gridp->gmatrix.vec.uvec.xyz.x;
1262  tplane.B = gridp->gmatrix.vec.uvec.xyz.y;
1263  tplane.C = gridp->gmatrix.vec.uvec.xyz.z;
1264  tplane.D = gridp->planeD;
1265 
1266  compute_point_on_plane(&gpos, &tplane, pos);
1267  dxz = vm_vec_dist(pos, &gpos)/8.0f;
1268  gv = &gridp->gmatrix.vec.uvec;
1269  if (gv->xyz.x * pos->xyz.x + gv->xyz.y * pos->xyz.y + gv->xyz.z * pos->xyz.z < -gridp->planeD)
1270  gr_set_color(0, 127, 0);
1271  else
1272  gr_set_color(192, 192, 192);
1273 
1274 
1275  g3_draw_htl_line(&gpos, pos); // Line from grid to object center.
1276 
1277  tpos = gpos;
1278 
1279  vm_vec_scale_add2(&gpos, &gridp->gmatrix.vec.rvec, -dxz/2);
1280  vm_vec_scale_add2(&gpos, &gridp->gmatrix.vec.fvec, -dxz/2);
1281 
1282  vm_vec_scale_add2(&tpos, &gridp->gmatrix.vec.rvec, dxz/2);
1283  vm_vec_scale_add2(&tpos, &gridp->gmatrix.vec.fvec, dxz/2);
1284 
1285  g3_draw_htl_line(&gpos, &tpos);
1286 
1287  vm_vec_scale_add2(&gpos, &gridp->gmatrix.vec.rvec, dxz);
1288  vm_vec_scale_add2(&tpos, &gridp->gmatrix.vec.rvec, -dxz);
1289 
1290  g3_draw_htl_line(&gpos, &tpos);
1291 }
1292 
1293 void render_active_rect(void)
1294 {
1295  if (box_marking) {
1296  gr_set_color(255, 255, 255);
1297  gr_line(marking_box.x1, marking_box.y1, marking_box.x1, marking_box.y2);
1298  gr_line(marking_box.x1, marking_box.y2, marking_box.x2, marking_box.y2);
1299  gr_line(marking_box.x2, marking_box.y2, marking_box.x2, marking_box.y1);
1300  gr_line(marking_box.x2, marking_box.y1, marking_box.x1, marking_box.y1);
1301  }
1302 }
1303 
1304 
1305 void process_movement_keys(int key, vec3d *mvec, angles *angs)
1306 {
1307  int raw_key;
1308 
1309  mvec->xyz.x = 0.0f;
1310  mvec->xyz.y = 0.0f;
1311  mvec->xyz.z = 0.0f;
1312  angs->p = 0.0f;
1313  angs->b = 0.0f;
1314  angs->h = 0.0f;
1315 
1316  raw_key = key & 0xff;
1317 
1318  switch (raw_key) {
1319  case KEY_PAD1: mvec->xyz.x += -1.0f; break;
1320  case KEY_PAD3: mvec->xyz.x += +1.0f; break;
1321  case KEY_PADPLUS: mvec->xyz.y += -1.0f; break;
1322  case KEY_PADMINUS: mvec->xyz.y += +1.0f; break;
1323  case KEY_A: mvec->xyz.z += +1.0f; break;
1324  case KEY_Z: mvec->xyz.z += -1.0f; break;
1325  case KEY_PAD4: angs->h += -0.1f; break;
1326  case KEY_PAD6: angs->h += +0.1f; break;
1327  case KEY_PAD8: angs->p += -0.1f; break;
1328  case KEY_PAD2: angs->p += +0.1f; break;
1329  case KEY_PAD7: angs->b += -0.1f; break;
1330  case KEY_PAD9: angs->b += +0.1f; break;
1331 
1332  }
1333 
1334  if (key & KEY_SHIFTED) {
1335  vm_vec_scale(mvec, 5.0f);
1336  angs->p *= 5.0f;
1337  angs->b *= 5.0f;
1338  angs->h *= 5.0f;
1339  }
1340 }
1341 
1342 void process_controls(vec3d *pos, matrix *orient, float frametime, int key, int mode)
1343 {
1344  if (Flying_controls_mode) {
1345  grid_read_camera_controls(&view_controls, frametime);
1346 
1347  if (key_get_shift_status())
1348  memset(&view_controls, 0, sizeof(control_info));
1349 
1350  if ((fabs(view_controls.pitch) > (frametime / 100)) &&
1351  (fabs(view_controls.vertical) > (frametime / 100)) &&
1352  (fabs(view_controls.heading) > (frametime / 100)) &&
1353  (fabs(view_controls.sideways) > (frametime / 100)) &&
1354  (fabs(view_controls.bank) > (frametime / 100)) &&
1355  (fabs(view_controls.forward) > (frametime / 100)))
1356  Update_window = 1;
1357 
1358  flFrametime = frametime;
1359  physics_read_flying_controls(orient, &view_physics, &view_controls, flFrametime);
1360  if (mode)
1361  physics_sim_editor(pos, orient, &view_physics, frametime);
1362  else
1363  physics_sim(pos, orient, &view_physics, frametime);
1364 
1365  } else {
1366  vec3d movement_vec, rel_movement_vec;
1367  angles rotangs;
1368  matrix newmat, rotmat;
1369 
1370  process_movement_keys(key, &movement_vec, &rotangs);
1371  vm_vec_rotate(&rel_movement_vec, &movement_vec, &The_grid->gmatrix);
1372  vm_vec_add2(pos, &rel_movement_vec);
1373 
1374  vm_angles_2_matrix(&rotmat, &rotangs);
1375  if (rotangs.h && Universal_heading)
1376  vm_transpose(orient);
1377  vm_matrix_x_matrix(&newmat, orient, &rotmat);
1378  *orient = newmat;
1379  if (rotangs.h && Universal_heading)
1380  vm_transpose(orient);
1381  }
1382 }
1383 
1384 int Fred_grid_colors_inited = 0;
1385 color Fred_grid_bright, Fred_grid_dark, Fred_grid_bright_aa, Fred_grid_dark_aa;
1386 
1387 // Renders a grid defined in a grid struct
1388 void fred_render_grid(grid *gridp)
1389 {
1390  int i, ncols, nrows;
1391 
1392  if (!Cmdline_nohtl)
1393  {
1394  fred_enable_htl();
1395  gr_zbuffer_set(0);
1396  }
1397 
1398  if ( !Fred_grid_colors_inited ) {
1399  Fred_grid_colors_inited = 1;
1400 
1401  gr_init_alphacolor( &Fred_grid_dark_aa, 64, 64, 64, 255 );
1402  gr_init_alphacolor( &Fred_grid_bright_aa, 128, 128, 128, 255 );
1403  gr_init_color( &Fred_grid_dark, 64, 64, 64 );
1404  gr_init_color( &Fred_grid_bright, 128, 128, 128 );
1405  }
1406 
1407  ncols = gridp->ncols;
1408  nrows = gridp->nrows;
1409  if (double_fine_gridlines) {
1410  ncols *= 2;
1411  nrows *= 2;
1412  }
1413 
1414  if (Aa_gridlines)
1415  gr_set_color_fast(&Fred_grid_dark_aa);
1416  else
1417  gr_set_color_fast(&Fred_grid_dark);
1418 
1419  // Draw the column lines.
1420  for (i=0; i<=ncols; i++)
1421  {
1422  if (Cmdline_nohtl) rpd_line(&gridp->gpoints1[i], &gridp->gpoints2[i]);
1423  else g3_draw_htl_line(&gridp->gpoints1[i], &gridp->gpoints2[i]);
1424  }
1425  // Draw the row lines.
1426  for (i=0; i<=nrows; i++)
1427  {
1428  if (Cmdline_nohtl) rpd_line(&gridp->gpoints3[i], &gridp->gpoints4[i]);
1429  else g3_draw_htl_line(&gridp->gpoints3[i], &gridp->gpoints4[i]);
1430  }
1431 
1432  ncols = gridp->ncols / 2;
1433  nrows = gridp->nrows / 2;
1434 
1435  // now draw the larger, brighter gridlines that is x10 the scale of smaller one.
1436  if (Aa_gridlines)
1437  gr_set_color_fast(&Fred_grid_bright_aa);
1438  else
1439  gr_set_color_fast(&Fred_grid_bright);
1440 
1441  for (i=0; i<=ncols; i++)
1442  {
1443  if (Cmdline_nohtl) rpd_line(&gridp->gpoints5[i], &gridp->gpoints6[i]);
1444  else g3_draw_htl_line(&gridp->gpoints5[i], &gridp->gpoints6[i]);
1445  }
1446 
1447  for (i=0; i<=nrows; i++)
1448  {
1449  if (Cmdline_nohtl) rpd_line(&gridp->gpoints7[i], &gridp->gpoints8[i]);
1450  else g3_draw_htl_line(&gridp->gpoints7[i], &gridp->gpoints8[i]);
1451  }
1452 
1453  if (!Cmdline_nohtl)
1454  {
1455  fred_disable_htl();
1456  gr_zbuffer_set(1);
1457  }
1458 }
1459 
1460 void render_frame()
1461 {
1462  char buf[256];
1463  int x, y, w, h, inst;
1464  vec3d pos;
1465  vertex v;
1466  angles a, a_deg; //a is in rads, a_deg is in degrees
1467 
1468  g3_end_frame(); // ** Accounted for
1469 
1470  gr_reset_clip();
1471  gr_clear();
1472 
1473  if (Briefing_dialog) {
1474  CRect rect;
1475 
1476  Fred_main_wnd->GetClientRect(rect);
1477  True_rw = rect.Width();
1478  True_rh = rect.Height();
1479  if (Fixed_briefing_size) {
1480  True_rw = BRIEF_GRID_W;
1481  True_rh = BRIEF_GRID_H;
1482 
1483  } else {
1484  if ((float) True_rh / (float) True_rw > (float) BRIEF_GRID_H / (float) BRIEF_GRID_W) {
1485  True_rh = (int) ((float) BRIEF_GRID_H * (float) True_rw / (float) BRIEF_GRID_W);
1486 
1487  } else { // Fred is wider than briefing window
1488  True_rw = (int) ((float) BRIEF_GRID_W * (float) True_rh / (float) BRIEF_GRID_H);
1489  }
1490  }
1491 
1492  g3_start_frame(0); // ** Accounted for
1493  gr_set_color(255, 255, 255);
1494  gr_line(0, True_rh, True_rw, True_rh);
1495  gr_line(True_rw, 0, True_rw, True_rh);
1496  g3_end_frame(); // ** Accounted for
1497  gr_set_clip(0, 0, True_rw, True_rh);
1498  }
1499 
1500  g3_start_frame(1); // ** Accounted for
1501  // 1 means use zbuffering
1502 
1503  gr_set_font(FONT1);
1504  light_reset();
1505 
1506  g3_set_view_matrix(&eye_pos, &eye_orient, (Briefing_dialog ? Briefing_window_FOV : FRED_DEFAULT_HTL_FOV));
1507  Viewer_pos = eye_pos; // for starfield code
1508 
1509  fred_enable_htl();
1510  if ( Bg_bitmap_dialog ) {
1511  stars_draw( Show_stars, 1, Show_stars, 0, 0 );
1512  } else {
1513  stars_draw( Show_stars, Show_stars, Show_stars, 0, 0 );
1514  }
1515  fred_disable_htl();
1516 
1517  if (Show_horizon) {
1518  gr_set_color(128, 128, 64);
1519  g3_draw_horizon_line();
1520  }
1521 
1522  if (Show_asteroid_field) {
1523  gr_set_color(192, 96, 16);
1524  draw_asteroid_field();
1525  }
1526 
1527  if (Show_grid)
1528  fred_render_grid(The_grid);
1529  if (Bg_bitmap_dialog)
1530  hilight_bitmap();
1531 
1532  gr_set_color(0, 0, 64);
1533  render_models();
1534 
1535  if (Show_distances)
1536  {
1537  display_distances();
1538  }
1539 
1540  display_ship_info();
1541  display_active_ship_subsystem();
1542  render_active_rect();
1543 
1544  if (query_valid_object(Cursor_over)) { // display a tool-tip like infobox
1545  pos = Objects[Cursor_over].pos;
1546  inst = Objects[Cursor_over].instance;
1547  if ((Objects[Cursor_over].type == OBJ_SHIP) || (Objects[Cursor_over].type == OBJ_START)) {
1548  vm_extract_angles_matrix(&a, &Objects[Cursor_over].orient);
1549 
1550  a_deg.h = a.h * CONVERT_DEGREES; // convert angles to more readable degrees
1551  a_deg.p = a.p * CONVERT_DEGREES;
1552  a_deg.b = a.b * CONVERT_DEGREES;
1553 
1554  sprintf(buf, "%s\n%s\n( %.1f , %.1f , %.1f ) \nHeading: %.2f\nPitch: %.2f\nBank: %.2f",
1555  Ships[inst].ship_name, Ship_info[Ships[inst].ship_info_index].short_name,
1556  pos.xyz.x, pos.xyz.y, pos.xyz.z, a_deg.h, a_deg.p, a_deg.b);
1557 
1558  } else if (Objects[Cursor_over].type == OBJ_WAYPOINT) {
1559  int idx;
1560  waypoint_list *wp_list = find_waypoint_list_with_instance(inst, &idx);
1561  Assert(wp_list != NULL);
1562  sprintf(buf, "%s\nWaypoint %d\n( %.1f , %.1f , %.1f ) ", wp_list->get_name(), idx + 1, pos.xyz.x, pos.xyz.y, pos.xyz.z);
1563 
1564  } else if (Objects[Cursor_over].type == OBJ_POINT) {
1565  sprintf(buf, "Briefing icon\n( %.1f , %.1f , %.1f ) ", pos.xyz.x, pos.xyz.y, pos.xyz.z);
1566 
1567  } else
1568  sprintf(buf, "( %.1f , %.1f , %.1f ) ", pos.xyz.x, pos.xyz.y, pos.xyz.z);
1569 
1570  g3_rotate_vertex(&v, &pos);
1571  if (!(v.codes & CC_BEHIND))
1572  if (!(g3_project_vertex(&v) & PF_OVERFLOW)) {
1573 
1574  gr_get_string_size(&w, &h, buf);
1575 
1576  x = (int) v.screen.xyw.x;
1577  y = (int) v.screen.xyw.y + 20;
1578 
1579  gr_set_color_fast(&colour_white);
1580  gr_rect(x-7, y-6, w+8, h+7);
1581 
1582  gr_set_color_fast(&colour_black);
1583  gr_rect(x-5, y-5, w+5, h+5);
1584 
1585  gr_set_color_fast(&colour_white);
1586  gr_string_win(x, y, buf);
1587  }
1588  }
1589 
1590  gr_set_color(0, 160, 0);
1591 
1592  fred_enable_htl();
1593  jumpnode_render_all();
1594  fred_disable_htl();
1595 
1596  sprintf(buf, "(%.1f,%.1f,%.1f)", eye_pos.xyz.x, eye_pos.xyz.y, eye_pos.xyz.z);
1597  gr_get_string_size(&w, &h, buf);
1598  gr_set_color_fast(&colour_white);
1599  gr_string_win(gr_screen.max_w - w - 2, 2, buf);
1600 
1601  g3_end_frame(); // ** Accounted for
1602  render_compass();
1603 
1604  gr_flip();
1605 
1606  gr_reset_clip();
1607  if (Briefing_dialog)
1608  gr_set_clip(0, 0, True_rw, True_rh);
1609 
1610  g3_start_frame(0); // ** Accounted for
1611  g3_set_view_matrix(&eye_pos, &eye_orient, (Briefing_dialog ? Briefing_window_FOV : FRED_DEFAULT_HTL_FOV));
1612 }
1613 
1614 void game_do_frame()
1615 {
1616  int key, cmode;
1617  vec3d viewer_position, control_pos;
1618  object *objp;
1619  matrix control_orient;
1620 
1621  inc_mission_time();
1622 
1623  viewer_position = my_orient.vec.fvec;
1624  vm_vec_scale(&viewer_position,my_pos.xyz.z);
1625 
1626  if ((viewpoint == 1) && !query_valid_object(view_obj))
1627  viewpoint = 0;
1628 
1629  key = key_inkey();
1630  process_system_keys(key);
1631  cmode = Control_mode;
1632  if ((viewpoint == 1) && !cmode)
1633  cmode = 2;
1634 
1635  control_pos = Last_control_pos;
1636  control_orient = Last_control_orient;
1637 
1638 // if ((key & KEY_MASK) == key) // unmodified
1639  switch (cmode) {
1640  case 0: // Control the viewer's location and orientation
1641  process_controls(&view_pos, &view_orient, f2fl(Frametime), key, 1);
1642  control_pos = view_pos;
1643  control_orient = view_orient;
1644  break;
1645 
1646  case 2: // Control viewpoint object
1647  process_controls(&Objects[view_obj].pos, &Objects[view_obj].orient, f2fl(Frametime), key);
1648  object_moved(&Objects[view_obj]);
1649  control_pos = Objects[view_obj].pos;
1650  control_orient = Objects[view_obj].orient;
1651  break;
1652 
1653  case 1: // Control the current object's location and orientation
1654  if (query_valid_object()) {
1655  vec3d delta_pos, leader_old_pos;
1656  matrix leader_orient, leader_transpose, tmp;
1657  object *leader;
1658 
1659  leader = &Objects[cur_object_index];
1660  leader_old_pos = leader->pos; // save original position
1661  leader_orient = leader->orient; // save original orientation
1662  vm_copy_transpose(&leader_transpose, &leader_orient);
1663 
1664  process_controls(&leader->pos, &leader->orient, f2fl(Frametime), key);
1665  vm_vec_sub(&delta_pos, &leader->pos, &leader_old_pos); // get position change
1666  control_pos = leader->pos;
1667  control_orient = leader->orient;
1668 
1669  objp = GET_FIRST(&obj_used_list);
1670  while (objp != END_OF_LIST(&obj_used_list)) {
1671  Assert(objp->type != OBJ_NONE);
1672  if ((objp->flags & OF_MARKED) && (cur_object_index != OBJ_INDEX(objp))) {
1673  if (Group_rotate) {
1674  matrix rot_trans;
1675  vec3d tmpv1, tmpv2;
1676 
1677  // change rotation matrix to rotate in opposite direction. This rotation
1678  // matrix is what the leader ship has rotated by.
1679  vm_copy_transpose(&rot_trans, &view_physics.last_rotmat);
1680 
1681  // get point relative to our point of rotation (make POR the origin). Since
1682  // only the leader has been moved yet, and not the objects, we have to use
1683  // the old leader's position.
1684  vm_vec_sub(&tmpv1, &objp->pos, &leader_old_pos);
1685 
1686  // convert point from real-world coordinates to leader's relative coordinate
1687  // system (z=forward vec, y=up vec, x=right vec
1688  vm_vec_rotate(&tmpv2, &tmpv1, &leader_orient);
1689 
1690  // now rotate the point by the transpose from above.
1691  vm_vec_rotate(&tmpv1, &tmpv2, &rot_trans);
1692 
1693  // convert point back into real-world coordinates
1694  vm_vec_rotate(&tmpv2, &tmpv1, &leader_transpose);
1695 
1696  // and move origin back to real-world origin. Object is now at its correct
1697  // position. Note we used the leader's new position, instead of old position.
1698  vm_vec_add(&objp->pos, &leader->pos, &tmpv2);
1699 
1700  // Now fix the object's orientation to what it should be.
1701  vm_matrix_x_matrix(&tmp, &objp->orient, &view_physics.last_rotmat);
1702  vm_orthogonalize_matrix(&tmp); // safety check
1703  objp->orient = tmp;
1704 
1705  } else {
1706  vm_vec_add2(&objp->pos, &delta_pos);
1707  vm_matrix_x_matrix(&tmp, &objp->orient, &view_physics.last_rotmat);
1708  objp->orient = tmp;
1709  }
1710  }
1711 
1712  objp = GET_NEXT(objp);
1713  }
1714 
1715  objp = GET_FIRST(&obj_used_list);
1716  while (objp != END_OF_LIST(&obj_used_list)) {
1717  if (objp->flags & OF_MARKED)
1718  object_moved(objp);
1719 
1720  objp = GET_NEXT(objp);
1721  }
1722 
1723  set_modified();
1724  }
1725 
1726  break;
1727 
1728  default:
1729  Assert(0);
1730  }
1731 
1732  if (Lookat_mode && query_valid_object()) {
1733  float dist;
1734 
1735  dist = vm_vec_dist(&view_pos, &Objects[cur_object_index].pos);
1736  vm_vec_scale_add(&view_pos, &Objects[cur_object_index].pos, &view_orient.vec.fvec, -dist);
1737  }
1738 
1739  switch (viewpoint)
1740  {
1741  case 0:
1742  eye_pos = view_pos;
1743  eye_orient = view_orient;
1744  break;
1745 
1746  case 1:
1747  eye_pos = Objects[view_obj].pos;
1748  eye_orient = Objects[view_obj].orient;
1749  break;
1750 
1751  default:
1752  Assert(0);
1753  }
1754 
1755  maybe_create_new_grid(The_grid, &eye_pos, &eye_orient);
1756 
1757  if (Cursor_over != Last_cursor_over) {
1758  Last_cursor_over = Cursor_over;
1759  Update_window = 1;
1760  }
1761 
1762  // redraw screen if controlled object moved or rotated
1763  if (vm_vec_cmp(&control_pos, &Last_control_pos) || vm_matrix_cmp(&control_orient, &Last_control_orient)) {
1764  Update_window = 1;
1765  Last_control_pos = control_pos;
1766  Last_control_orient = control_orient;
1767  }
1768 
1769  // redraw screen if current viewpoint moved or rotated
1770  if (vm_vec_cmp(&eye_pos, &Last_eye_pos) || vm_matrix_cmp(&eye_orient, &Last_eye_orient)) {
1771  Update_window = 1;
1772  Last_eye_pos = eye_pos;
1773  Last_eye_orient = eye_orient;
1774  }
1775 }
1776 
1777 void hilight_bitmap()
1778 {
1779  /*
1780  int i;
1781  vertex p[4];
1782 
1783  if (Starfield_bitmaps[Cur_bitmap].bitmap_index == -1) // can't draw if no bitmap
1784  return;
1785 
1786  for (i=0; i<4; i++)
1787  {
1788  g3_rotate_faraway_vertex(&p[i], &Starfield_bitmaps[Cur_bitmap].points[i]);
1789  if (p[i].codes & CC_BEHIND)
1790  return;
1791 
1792  g3_project_vertex(&p[i]);
1793  if (p[i].flags & PF_OVERFLOW)
1794  return;
1795  }
1796 
1797  gr_set_color(255, 255, 255);
1798  g3_draw_line(&p[0], &p[1]);
1799  g3_draw_line(&p[1], &p[2]);
1800  g3_draw_line(&p[2], &p[3]);
1801  g3_draw_line(&p[3], &p[0]);
1802  */
1803 }
1804 
1805 void draw_asteroid_field()
1806 {
1807  int i, j;
1808  vec3d p[8], ip[8];
1809  vertex v[8], iv[8];
1810 
1811  for (i=0; i<1 /*MAX_ASTEROID_FIELDS*/; i++)
1812  if (Asteroid_field.num_initial_asteroids) {
1813  p[0].xyz.x = p[2].xyz.x = p[4].xyz.x = p[6].xyz.x = Asteroid_field.min_bound.xyz.x;
1814  p[1].xyz.x = p[3].xyz.x = p[5].xyz.x = p[7].xyz.x = Asteroid_field.max_bound.xyz.x;
1815  p[0].xyz.y = p[1].xyz.y = p[4].xyz.y = p[5].xyz.y = Asteroid_field.min_bound.xyz.y;
1816  p[2].xyz.y = p[3].xyz.y = p[6].xyz.y = p[7].xyz.y = Asteroid_field.max_bound.xyz.y;
1817  p[0].xyz.z = p[1].xyz.z = p[2].xyz.z = p[3].xyz.z = Asteroid_field.min_bound.xyz.z;
1818  p[4].xyz.z = p[5].xyz.z = p[6].xyz.z = p[7].xyz.z = Asteroid_field.max_bound.xyz.z;
1819 
1820  for (j=0; j<8; j++)
1821  g3_rotate_vertex(&v[j], &p[j]);
1822 
1823  g3_draw_line(&v[0], &v[1]);
1824  g3_draw_line(&v[2], &v[3]);
1825  g3_draw_line(&v[4], &v[5]);
1826  g3_draw_line(&v[6], &v[7]);
1827  g3_draw_line(&v[0], &v[2]);
1828  g3_draw_line(&v[1], &v[3]);
1829  g3_draw_line(&v[4], &v[6]);
1830  g3_draw_line(&v[5], &v[7]);
1831  g3_draw_line(&v[0], &v[4]);
1832  g3_draw_line(&v[1], &v[5]);
1833  g3_draw_line(&v[2], &v[6]);
1834  g3_draw_line(&v[3], &v[7]);
1835 
1836 
1837  // maybe draw inner box
1838  if (Asteroid_field.has_inner_bound) {
1839 
1840  gr_set_color(16, 192, 92);
1841 
1842  ip[0].xyz.x = ip[2].xyz.x = ip[4].xyz.x = ip[6].xyz.x = Asteroid_field.inner_min_bound.xyz.x;
1843  ip[1].xyz.x = ip[3].xyz.x = ip[5].xyz.x = ip[7].xyz.x = Asteroid_field.inner_max_bound.xyz.x;
1844  ip[0].xyz.y = ip[1].xyz.y = ip[4].xyz.y = ip[5].xyz.y = Asteroid_field.inner_min_bound.xyz.y;
1845  ip[2].xyz.y = ip[3].xyz.y = ip[6].xyz.y = ip[7].xyz.y = Asteroid_field.inner_max_bound.xyz.y;
1846  ip[0].xyz.z = ip[1].xyz.z = ip[2].xyz.z = ip[3].xyz.z = Asteroid_field.inner_min_bound.xyz.z;
1847  ip[4].xyz.z = ip[5].xyz.z = ip[6].xyz.z = ip[7].xyz.z = Asteroid_field.inner_max_bound.xyz.z;
1848 
1849  for (j=0; j<8; j++)
1850  g3_rotate_vertex(&iv[j], &ip[j]);
1851 
1852  g3_draw_line(&iv[0], &iv[1]);
1853  g3_draw_line(&iv[2], &iv[3]);
1854  g3_draw_line(&iv[4], &iv[5]);
1855  g3_draw_line(&iv[6], &iv[7]);
1856  g3_draw_line(&iv[0], &iv[2]);
1857  g3_draw_line(&iv[1], &iv[3]);
1858  g3_draw_line(&iv[4], &iv[6]);
1859  g3_draw_line(&iv[5], &iv[7]);
1860  g3_draw_line(&iv[0], &iv[4]);
1861  g3_draw_line(&iv[1], &iv[5]);
1862  g3_draw_line(&iv[2], &iv[6]);
1863  g3_draw_line(&iv[3], &iv[7]);
1864  }
1865 
1866  }
1867 }
1868 
1869 // See if object "objnum" obstructs the vector from point p0 to point p1.
1870 // If so, return true and stuff hit point in *hitpos.
1871 // If not, return false.
1872 int object_check_collision(object *objp, vec3d *p0, vec3d *p1, vec3d *hitpos)
1873 {
1874  mc_info mc;
1875  mc_info_init(&mc);
1876 
1877  if ((objp->type == OBJ_NONE) || (objp->type == OBJ_POINT))
1878  return 0;
1879 
1880  if ((objp->type == OBJ_WAYPOINT) && !Show_waypoints)
1881  return 0;
1882 
1883  if ((objp->type == OBJ_START) && !Show_starts)
1884  return 0;
1885 
1886  if ((objp->type == OBJ_SHIP) || (objp->type == OBJ_START)) {
1887  if (!Show_ships)
1888  return 0;
1889 
1890  if (!Show_iff[Ships[objp->instance].team])
1891  return 0;
1892  }
1893 
1894  if (objp->flags & OF_HIDDEN)
1895  return 0;
1896 
1897  if ((Show_ship_models || Show_outlines) && (objp->type == OBJ_SHIP)) {
1898  mc.model_num = Ship_info[Ships[objp->instance].ship_info_index].model_num; // Fill in the model to check
1899 
1900  } else if ((Show_ship_models || Show_outlines) && (objp->type == OBJ_START)) {
1901  mc.model_num = Ship_info[Ships[objp->instance].ship_info_index].model_num; // Fill in the model to check
1902 
1903  } else
1904  return fvi_ray_sphere(hitpos, p0, p1, &objp->pos, (objp->radius > 0.1f) ? objp->radius : LOLLIPOP_SIZE);
1905 
1906  mc.model_instance_num = -1;
1907  mc.orient = &objp->orient; // The object's orient
1908  mc.pos = &objp->pos; // The object's position
1909  mc.p0 = p0; // Point 1 of ray to check
1910  mc.p1 = p1; // Point 2 of ray to check
1911  mc.flags = MC_CHECK_MODEL | MC_CHECK_RAY; // flags
1912  model_collide(&mc);
1913  *hitpos = mc.hit_point_world;
1914  if ( mc.num_hits < 1 ) {
1915  // check shield
1916  mc.orient = &objp->orient; // The object's orient
1917  mc.pos = &objp->pos; // The object's position
1918  mc.p0 = p0; // Point 1 of ray to check
1919  mc.p1 = p1; // Point 2 of ray to check
1920  mc.flags = MC_CHECK_SHIELD; // flags
1921  model_collide(&mc);
1922  *hitpos = mc.hit_point_world;
1923  }
1924 
1925  return mc.num_hits;
1926 }
1927 
1928 // Finds the closest object or waypoint under the mouse cursor and returns
1929 // its index, or -1 if nothing there.
1930 int select_object(int cx, int cy)
1931 {
1932  int best = -1;
1933  double dist, best_dist = 9e99;
1934  vec3d p0, p1, v, hitpos;
1935  vertex vt;
1936  object *ptr;
1937 
1938  if (Briefing_dialog) {
1939  best = Briefing_dialog->check_mouse_hit(cx, cy);
1940  if (best >= 0)
1941  {
1942  if(Selection_lock && !(Objects[best].flags & OF_MARKED))
1943  {
1944  return -1;
1945  }
1946  return best;
1947  }
1948  }
1949 
1950 /* gr_reset_clip();
1951  g3_start_frame(0); ////////////////
1952  g3_set_view_matrix(&eye_pos, &eye_orient, 0.5f);*/
1953 
1954  // Get 3d vector specified by mouse cursor location.
1955  g3_point_to_vec(&v, cx, cy);
1956 
1957 // g3_end_frame();
1958  if (!v.xyz.x && !v.xyz.y && !v.xyz.z) // zero vector
1959  return -1;
1960 
1961  p0 = view_pos;
1962  vm_vec_scale_add(&p1, &p0, &v, 100.0f);
1963 
1964  ptr = GET_FIRST(&obj_used_list);
1965  while (ptr != END_OF_LIST(&obj_used_list))
1966  {
1967  if (object_check_collision(ptr, &p0, &p1, &hitpos)) {
1968  hitpos.xyz.x = ptr->pos.xyz.x - view_pos.xyz.x;
1969  hitpos.xyz.y = ptr->pos.xyz.y - view_pos.xyz.y;
1970  hitpos.xyz.z = ptr->pos.xyz.z - view_pos.xyz.z;
1971  dist = hitpos.xyz.x * hitpos.xyz.x + hitpos.xyz.y * hitpos.xyz.y + hitpos.xyz.z * hitpos.xyz.z;
1972  if (dist < best_dist) {
1973  best = OBJ_INDEX(ptr);
1974  best_dist = dist;
1975  }
1976  }
1977 
1978  ptr = GET_NEXT(ptr);
1979  }
1980 
1981  if (best >= 0)
1982  {
1983  if(Selection_lock && !(Objects[best].flags & OF_MARKED))
1984  {
1985  return -1;
1986  }
1987  return best;
1988  }
1989  ptr = GET_FIRST(&obj_used_list);
1990  while (ptr != END_OF_LIST(&obj_used_list))
1991  {
1992  g3_rotate_vertex(&vt, &ptr->pos);
1993  if (!(vt.codes & CC_BEHIND))
1994  if (!(g3_project_vertex(&vt) & PF_OVERFLOW)) {
1995  hitpos.xyz.x = vt.screen.xyw.x - cx;
1996  hitpos.xyz.y = vt.screen.xyw.y - cy;
1997  dist = hitpos.xyz.x * hitpos.xyz.x + hitpos.xyz.y * hitpos.xyz.y;
1998  if ((dist < 8) && (dist < best_dist)) {
1999  best = OBJ_INDEX(ptr);
2000  best_dist = dist;
2001  }
2002  }
2003 
2004  ptr = GET_NEXT(ptr);
2005  }
2006 
2007  if(Selection_lock && !(Objects[best].flags & OF_MARKED))
2008  {
2009  return -1;
2010  }
2011 
2012  return best;
2013 }
2014 
2015 void render_compass(void)
2016 {
2017  vec3d v, eye = { 0.0f };
2018 
2019  if (!Show_compass)
2020  return;
2021 
2022  gr_set_clip(gr_screen.max_w - 100, 0, 100, 100);
2023  g3_start_frame(0); // ** Accounted for
2024  // required !!!
2025  vm_vec_scale_add2(&eye, &eye_orient.vec.fvec, -1.5f);
2026  g3_set_view_matrix(&eye, &eye_orient, 1.0f);
2027 
2028  v.xyz.x = 1.0f;
2029  v.xyz.y = v.xyz.z = 0.0f;
2030  if (vm_vec_dot(&eye, &v) < 0.0f)
2031  gr_set_color(159, 20, 20);
2032  else
2033  gr_set_color(255, 32, 32);
2034  draw_compass_arrow(&v);
2035 
2036  v.xyz.y = 1.0f;
2037  v.xyz.x = v.xyz.z = 0.0f;
2038  if (vm_vec_dot(&eye, &v) < 0.0f)
2039  gr_set_color(20, 159, 20);
2040  else
2041  gr_set_color(32, 255, 32);
2042  draw_compass_arrow(&v);
2043 
2044  v.xyz.z = 1.0f;
2045  v.xyz.x = v.xyz.y = 0.0f;
2046  if (vm_vec_dot(&eye, &v) < 0.0f)
2047  gr_set_color(20, 20, 159);
2048  else
2049  gr_set_color(32, 32, 255);
2050  draw_compass_arrow(&v);
2051 
2052  g3_end_frame(); // ** Accounted for
2053 
2054 }
2055 
2056 void draw_compass_arrow(vec3d *v0)
2057 {
2058  vec3d v1 = { 0.0f };
2059  vertex tv0, tv1;
2060 
2061  g3_rotate_vertex(&tv0, v0);
2062  g3_rotate_vertex(&tv1, &v1);
2063  g3_project_vertex(&tv0);
2064  g3_project_vertex(&tv1);
2065 // tv0.sx = (tv0.sx - tv1.sx) * 1 + tv1.sx;
2066 // tv0.sy = (tv0.sy - tv1.sy) * 1 + tv1.sy;
2067  g3_draw_line(&tv0, &tv1);
2068 }
2069 
2070 
2071 void inc_mission_time()
2072 {
2073  fix thistime;
2074 
2075  thistime = timer_get_fixed_seconds();
2076  if ( !lasttime ) {
2077  Frametime = F1_0 / 30;
2078  } else {
2079  Frametime = thistime - lasttime;
2080  }
2081 
2082  if (Frametime > MAX_FRAMETIME) {
2083  Frametime = MAX_FRAMETIME;
2084  } else if (Frametime < MIN_FRAMETIME) {
2085  if ( !Cmdline_NoFPSCap ) {
2086  thistime = MIN_FRAMETIME - Frametime;
2087  Sleep( DWORD(f2fl(thistime) * 1000.0f) );
2088  thistime = timer_get_fixed_seconds();
2089  }
2090 
2091  Frametime = MIN_FRAMETIME;
2092  }
2093 
2094  Missiontime += Frametime;
2095  lasttime = thistime;
2096 }
mc_info_init
void mc_info_init(mc_info *mc)
Definition: model.h:1138
gr_rect
void gr_rect(int x, int y, int w, int h, int resize_mode)
Definition: 2d.cpp:2068
KEY_PAD9
#define KEY_PAD9
Definition: key.h:165
model_collide
int model_collide(mc_info *mc_info_obj)
Definition: modelcollide.cpp:1230
gr_zbuffer_set
#define gr_zbuffer_set
Definition: 2d.h:817
polymodel::submodel
bsp_info * submodel
Definition: model.h:764
KEY_LAPOSTRO
#define KEY_LAPOSTRO
Definition: key.h:122
screen3d::xyw
struct screen3d::@234::@236 xyw
Frametime
fix Frametime
Definition: systemvars.cpp:21
Show_distances
int Show_distances
Definition: fredrender.cpp:86
object_check_collision
int object_check_collision(object *objp, vec3d *p0, vec3d *p1, vec3d *hitpos)
Definition: fredrender.cpp:1872
i
int i
Definition: multi_pxo.cpp:466
Missiontime
fix Missiontime
Definition: systemvars.cpp:19
fred_render_init
void fred_render_init()
Definition: fredrender.cpp:155
angles::p
float p
Definition: pstypes.h:111
ship_subsys::system_info
model_subsystem * system_info
Definition: ship.h:314
gr_clear
#define gr_clear
Definition: 2d.h:749
Aa_gridlines
int Aa_gridlines
Definition: fredrender.cpp:74
MR_SHOW_OUTLINE_HTL
#define MR_SHOW_OUTLINE_HTL
Definition: model.h:885
mc_info::pos
vec3d * pos
Definition: model.h:1113
ship::team
int team
Definition: ship.h:606
display_active_ship_subsystem
void display_active_ship_subsystem()
Definition: fredrender.cpp:592
Last_control_pos
vec3d Last_control_pos
Definition: fredrender.cpp:104
Show_coordinates
int Show_coordinates
Definition: fredrender.cpp:85
player_start1
int player_start1
Definition: fredrender.cpp:77
key_inkey
int key_inkey()
Definition: key.cpp:424
Briefing_window_FOV
float Briefing_window_FOV
Definition: mod_table.cpp:33
Show_outlines
int Show_outlines
Definition: fredrender.cpp:82
vm_matrix_x_matrix
matrix * vm_matrix_x_matrix(matrix *dest, const matrix *src0, const matrix *src1)
Definition: vecmat.cpp:1006
waypoint_list::get_name
char * get_name()
Definition: waypoint.cpp:84
MR_NORMAL
#define MR_NORMAL
Definition: model.h:858
draw_orient_sphere
void draw_orient_sphere(object *obj, int r, int g, int b)
Definition: fredrender.cpp:1130
fred_enable_htl
void fred_enable_htl()
Definition: fredrender.cpp:141
F1_0
#define F1_0
Definition: fix.h:15
h
GLfloat GLfloat GLfloat GLfloat h
Definition: Glext.h:7280
vm_vec_scale_add
void vm_vec_scale_add(vec3d *dest, const vec3d *src1, const vec3d *src2, float k)
Definition: vecmat.cpp:266
gr_flip
void gr_flip()
Definition: 2d.cpp:2113
SCP_vector
Definition: vmallocator.h:16
marking_box
Marking_box marking_box
Definition: fredview.cpp:116
bsp_info
Definition: model.h:298
model_get
polymodel * model_get(int model_num)
Definition: modelread.cpp:3134
process_system_keys
void process_system_keys(int key)
Definition: fredrender.cpp:379
gr_string_win
void gr_string_win(int x, int y, const char *s)
MIN_FRAMETIME
#define MIN_FRAMETIME
Definition: fredrender.cpp:66
BRIEFING_LOOKAT_POINT_ID
#define BRIEFING_LOOKAT_POINT_ID
Definition: fredrender.h:14
my_pos
vec3d my_pos
Definition: fredrender.cpp:102
gr_end_view_matrix
#define gr_end_view_matrix
Definition: 2d.h:896
model_subsystem::turret_gun_sobj
int turret_gun_sobj
Definition: model.h:193
level_object
void level_object(matrix *orient)
Definition: fredrender.cpp:180
view_controls
control_info view_controls
Definition: fredrender.cpp:115
g3_draw_horizon_line
void g3_draw_horizon_line()
Definition: 3ddraw.cpp:1168
KEY_PAD8
#define KEY_PAD8
Definition: key.h:164
inc_mission_time
void inc_mission_time()
Definition: fredrender.cpp:2071
flFrametime
float flFrametime
Definition: fredstubs.cpp:22
subsys_to_render::do_render
bool do_render
Definition: fredview.h:26
render_frame
void render_frame()
Definition: fredrender.cpp:1460
vm_angles_2_matrix
matrix * vm_angles_2_matrix(matrix *m, const angles *a)
Definition: vecmat.cpp:752
MAX_SHIPS
#define MAX_SHIPS
Definition: globals.h:37
object_moved
void object_moved(object *objp)
Definition: management.cpp:2326
iff_get_color_by_team_and_object
color * iff_get_color_by_team_and_object(int team, int seen_from_team, int is_bright, object *objp)
Definition: iff_defs.cpp:678
KEY_Z
#define KEY_Z
Definition: key.h:107
find_waypoint_list_with_instance
waypoint_list * find_waypoint_list_with_instance(int waypoint_instance, int *waypoint_index)
Definition: waypoint.cpp:254
fred_render_grid
void fred_render_grid(grid *gridp)
Definition: fredrender.cpp:1388
Assert
Assert(pm!=NULL)
FRED_DEFAULT_HTL_FOV
const float FRED_DEFAULT_HTL_FOV
Definition: fredrender.cpp:70
MR_NO_POLYS
#define MR_NO_POLYS
Definition: model.h:866
cancel_display_active_ship_subsystem
void cancel_display_active_ship_subsystem()
Definition: fredrender.cpp:494
vec3d
Definition: pstypes.h:88
bsp_info::bounding_box
vec3d bounding_box[8]
Definition: model.h:344
gr_init_alphacolor
void gr_init_alphacolor(color *clr, int r, int g, int b, int alpha, int type)
Definition: 2d.cpp:1173
key_get_shift_status
uint key_get_shift_status()
Definition: key.cpp:532
briefing_editor_dlg::batch_render
void batch_render()
Definition: briefingeditordlg.cpp:838
p0
hull_check p0
Definition: lua.cpp:5051
color
Definition: 2d.h:95
Show_paths_fred
int Show_paths_fred
Definition: fredview.cpp:94
Eye_matrix
matrix Eye_matrix
Definition: 3dsetup.cpp:26
subobj_find_2d_bound
int subobj_find_2d_bound(float radius, matrix *orient, vec3d *pos, int *x1, int *y1, int *x2, int *y2)
Definition: modelread.cpp:3345
KEY_PAD1
#define KEY_PAD1
Definition: key.h:157
model_render_params::set_flags
void set_flags(uint flags)
Definition: modelrender.cpp:259
maybe_create_new_grid
void maybe_create_new_grid(grid *gridp, vec3d *pos, matrix *orient, int force)
Definition: missiongrid.cpp:66
MR_NO_LIGHTING
#define MR_NO_LIGHTING
Definition: model.h:867
MC_CHECK_RAY
#define MC_CHECK_RAY
Definition: model.h:1176
KEY_PAD4
#define KEY_PAD4
Definition: key.h:160
vec3d::xyz
struct vec3d::@225::@227 xyz
Editing_mode
int Editing_mode
Definition: fredrender.cpp:78
model_render_immediate
void model_render_immediate(model_render_params *render_info, int model_num, matrix *orient, vec3d *pos, int render, bool sort)
Definition: modelrender.cpp:2636
mod_table.h
CFREDView::GetView
static CFREDView * GetView()
Definition: fredview.cpp:1520
physics_info::max_vel
vec3d max_vel
Definition: physics.h:49
f
GLclampf f
Definition: Glext.h:7097
rpd_line
void rpd_line(vec3d *v0, vec3d *v1)
Definition: missiongrid.cpp:245
Flying_controls_mode
int Flying_controls_mode
Definition: fredrender.cpp:92
vm_copy_transpose
matrix * vm_copy_transpose(matrix *dest, const matrix *src)
Definition: vecmat.cpp:984
box_marking
int box_marking
Definition: fredview.cpp:107
vm_vec_rotate
vec3d * vm_vec_rotate(vec3d *dest, const vec3d *src, const matrix *m)
Definition: vecmat.cpp:933
obj_used_list
object obj_used_list
Definition: object.cpp:53
f2fl
#define f2fl(fx)
Definition: floating.h:37
align_vector_to_axis
void align_vector_to_axis(vec3d *v)
Definition: fredrender.cpp:254
MR_SHOW_OUTLINE
#define MR_SHOW_OUTLINE
Definition: model.h:859
u
enum_h * u
Definition: lua.cpp:12649
get_subsystem_world_pos2
vec3d * get_subsystem_world_pos2(object *parent_obj, ship_subsys *subsys, vec3d *world_pos)
Definition: fredrender.cpp:454
Universal_heading
int Universal_heading
Definition: fredrender.cpp:91
Fred_main_wnd
CMainFrame * Fred_main_wnd
Definition: mainfrm.cpp:89
Constraint
vec3d Constraint
Definition: fredrender.cpp:106
mode
GLenum mode
Definition: Glext.h:5794
Last_control_orient
matrix Last_control_orient
Definition: fredrender.cpp:113
vm_vec_scale_add2
void vm_vec_scale_add2(vec3d *dest, const vec3d *src, float k)
Definition: vecmat.cpp:284
colour_green
color colour_green
Definition: fredrender.cpp:134
gr_set_color_fast
void gr_set_color_fast(color *dst)
Definition: 2d.cpp:1197
plane::A
float A
Definition: vecmat.h:73
MR_DEBUG_BAY_PATHS
#define MR_DEBUG_BAY_PATHS
Definition: model.h:930
color::blue
ubyte blue
Definition: 2d.h:102
cur_waypoint_list
waypoint_list * cur_waypoint_list
Definition: management.cpp:83
g3_draw_line
int g3_draw_line(vertex *p0, vertex *p1)
Definition: 3ddraw.cpp:112
orient
hull_check orient
Definition: lua.cpp:5049
key
int key
Definition: controlsconfig.cpp:185
Viewer_pos
vec3d Viewer_pos
Definition: fredrender.cpp:103
objp
object * objp
Definition: lua.cpp:3105
verticalize_controlled
void verticalize_controlled()
Definition: fredrender.cpp:298
asteroid_field::inner_min_bound
vec3d inner_min_bound
Definition: asteroid.h:131
v2
GLfloat GLfloat GLfloat v2
Definition: Glext.h:5640
size
GLsizeiptr size
Definition: Glext.h:5496
g3_draw_htl_sphere
void g3_draw_htl_sphere(const vec3d *position, float radius)
Definition: 3ddraw.cpp:1984
physics_info::max_rotvel
vec3d max_rotvel
Definition: physics.h:52
asteroid_field::min_bound
vec3d min_bound
Definition: asteroid.h:127
eye
Definition: model.h:594
shipp
ship * shipp
Definition: lua.cpp:9162
object::pos
vec3d pos
Definition: object.h:152
buf
GLenum GLuint GLenum GLsizei const GLchar * buf
Definition: Glext.h:7308
last_x
int last_x
Definition: fredrender.cpp:80
cmode
cmode
Definition: glcviewport.h:23
asteroid_field::max_bound
vec3d max_bound
Definition: asteroid.h:128
mc_info::p0
vec3d * p0
Definition: model.h:1114
create_default_grid
grid * create_default_grid(void)
Definition: missiongrid.cpp:229
view_pos
vec3d view_pos
Definition: fredrender.cpp:103
Bg_bitmap_dialog
bg_bitmap_dlg * Bg_bitmap_dialog
Definition: fred.cpp:58
Show_horizon
int Show_horizon
Definition: fredrender.cpp:87
Waypoint_lists
SCP_list< waypoint_list > Waypoint_lists
Definition: waypoint.cpp:9
LOLLIPOP_SIZE
#define LOLLIPOP_SIZE
Definition: fredrender.cpp:67
gr_end_proj_matrix
#define gr_end_proj_matrix
Definition: 2d.h:894
iff_defs.h
grid::nrows
int nrows
Definition: missiongrid.h:22
plane::B
float B
Definition: vecmat.h:73
render_one_model_nohtl
void render_one_model_nohtl(object *objp)
Definition: fredrender.cpp:700
model_subsystem::subobj_num
int subobj_num
Definition: model.h:175
screen::clip_height
int clip_height
Definition: 2d.h:378
double_fine_gridlines
int double_fine_gridlines
Definition: missiongrid.cpp:21
mc_info::model_num
int model_num
Definition: model.h:1110
type
GLenum type
Definition: Gl.h:1492
Fred_grid_bright_aa
color Fred_grid_bright_aa
Definition: fredrender.cpp:1385
subsys_to_render::cur_subsys
ship_subsys * cur_subsys
Definition: fredview.h:28
grid::ncols
int ncols
Definition: missiongrid.h:22
color::green
ubyte green
Definition: 2d.h:101
KEY_PAD7
#define KEY_PAD7
Definition: key.h:163
Selection_lock
int Selection_lock
Definition: fredview.cpp:97
gr_set_lighting
#define gr_set_lighting
Definition: 2d.h:924
g3_done_instance
void g3_done_instance(bool set_api=false)
Definition: 3dsetup.cpp:341
gr_set_color
void gr_set_color(int r, int g, int b)
Definition: 2d.cpp:1188
Fred_grid_bright
color Fred_grid_bright
Definition: fredrender.cpp:1385
asteroid_field::num_initial_asteroids
int num_initial_asteroids
Definition: asteroid.h:135
vm_fix_matrix
void vm_fix_matrix(matrix *m)
Definition: vecmat.cpp:1286
query_valid_object
int query_valid_object(int index)
Definition: management.cpp:1000
gr_set_clip
__inline void gr_set_clip(int x, int y, int w, int h, int resize_mode=GR_RESIZE_FULL)
Definition: 2d.h:741
KEY_A
#define KEY_A
Definition: key.h:82
vm_matrix_cmp
int vm_matrix_cmp(const matrix *a, const matrix *b)
Definition: vecmat.cpp:1426
MC_CHECK_SHIELD
#define MC_CHECK_SHIELD
Definition: model.h:1170
gr_set_view_matrix
#define gr_set_view_matrix
Definition: 2d.h:895
button_down
int button_down
Definition: fredview.cpp:100
get_subsys_bounding_rect
int get_subsys_bounding_rect(object *ship_obj, ship_subsys *subsys, int *x1, int *x2, int *y1, int *y2)
Definition: fredrender.cpp:468
int
typedef int(SCP_EXT_CALLCONV *SCPDLL_PFVERSION)(SCPDLL_Version *)
OBJ_WAYPOINT
#define OBJ_WAYPOINT
Definition: object.h:36
gr_reset_clip
#define gr_reset_clip
Definition: 2d.h:745
vm_transpose
matrix * vm_transpose(matrix *m)
Definition: vecmat.cpp:971
object::instance
int instance
Definition: object.h:150
trackball_orient
matrix trackball_orient
Definition: fredrender.cpp:111
plane::D
float D
Definition: vecmat.h:73
vm_vector_2_matrix
matrix * vm_vector_2_matrix(matrix *m, const vec3d *fvec, const vec3d *uvec, const vec3d *rvec)
Definition: vecmat.cpp:850
PF_OVERFLOW
#define PF_OVERFLOW
Definition: 3d.h:22
model_render_params::set_debug_flags
void set_debug_flags(uint flags)
Definition: modelrender.cpp:249
vm_vec_add2
void vm_vec_add2(vec3d *dest, const vec3d *src)
Definition: vecmat.cpp:178
Cmdline_nohtl
int Cmdline_nohtl
Definition: cmdline.cpp:438
OBJ_START
#define OBJ_START
Definition: object.h:35
gr_set_proj_matrix
#define gr_set_proj_matrix
Definition: 2d.h:893
Show_ship_models
int Show_ship_models
Definition: fredview.cpp:91
grid_read_camera_controls
void grid_read_camera_controls(control_info *ci, float frametime)
Definition: missiongrid.cpp:23
r
GLdouble GLdouble GLdouble r
Definition: Glext.h:5337
control_info::pitch
float pitch
Definition: physics.h:100
mc_info::flags
int flags
Definition: model.h:1116
True_rw
int True_rw
Definition: fredrender.cpp:98
matrix::vec
struct matrix::@228::@230 vec
uint
unsigned int uint
Definition: pstypes.h:64
view_orient
matrix view_orient
Definition: fredrender.cpp:112
vertex::screen
screen3d screen
Definition: pstypes.h:173
g
GLboolean GLboolean g
Definition: Glext.h:5781
briefing_editor_dlg::check_mouse_hit
int check_mouse_hit(int x, int y)
Definition: briefingeditordlg.cpp:1242
vm_vec_scale
void vm_vec_scale(vec3d *dest, float s)
Definition: vecmat.cpp:248
g3_draw_sphere
int g3_draw_sphere(vertex *pnt, float rad)
Definition: 3ddraw.cpp:475
FullDetail
int FullDetail
Definition: fredview.cpp:96
display_distances
void display_distances()
Definition: fredrender.cpp:997
grid::gmatrix
matrix gmatrix
Definition: missiongrid.h:24
MR_NO_TEXTURING
#define MR_NO_TEXTURING
Definition: model.h:868
a
GLboolean GLboolean GLboolean GLboolean a
Definition: Glext.h:5781
verticalize_object
void verticalize_object(matrix *orient)
Definition: fredrender.cpp:290
rendering_order
int rendering_order[MAX_SHIPS]
Definition: fredrender.cpp:95
physics_sim_editor
void physics_sim_editor(vec3d *position, matrix *orient, physics_info *pi, float sim_time)
Definition: physics.cpp:385
CFREDDoc::autosave
int autosave(char *desc)
Definition: freddoc.cpp:264
mc_info::p1
vec3d * p1
Definition: model.h:1115
waypoint_list
Definition: waypoint.h:33
g3_set_view_matrix
void g3_set_view_matrix(const vec3d *view_pos, const matrix *view_matrix, float zoom)
Definition: 3dsetup.cpp:152
model_clear_instance
void model_clear_instance(int model_num)
Definition: modelread.cpp:4624
KEY_PAD3
#define KEY_PAD3
Definition: key.h:159
Fred_grid_dark_aa
color Fred_grid_dark_aa
Definition: fredrender.cpp:1385
cancel_drag
void cancel_drag()
Definition: fredview.cpp:837
KEY_SHIFTED
#define KEY_SHIFTED
Definition: key.h:62
Cursor_over
int Cursor_over
Definition: fredview.cpp:103
draw_compass_arrow
void draw_compass_arrow(vec3d *v0)
Definition: fredrender.cpp:2056
v0
GLfloat v0
Definition: Glext.h:5638
grid::gpoints4
vec3d gpoints4[MAX_GRIDLINE_POINTS]
Definition: missiongrid.h:31
vm_orthogonalize_matrix
void vm_orthogonalize_matrix(matrix *m_src)
Definition: vecmat.cpp:1247
w
#define w(p)
Definition: modelsinc.h:68
sprintf
sprintf(buf,"(%f,%f,%f)", v3->xyz.x, v3->xyz.y, v3->xyz.z)
grid::gpoints7
vec3d gpoints7[MAX_GRIDLINE_POINTS]
Definition: missiongrid.h:34
control_info::forward
float forward
Definition: physics.h:105
render_model_x_htl
void render_model_x_htl(vec3d *pos, grid *gridp, int col_scheme=0)
Definition: fredrender.cpp:1250
z
GLdouble GLdouble z
Definition: Glext.h:5451
color::red
ubyte red
Definition: 2d.h:100
lasttime
fix lasttime
Definition: fredrender.cpp:101
g3_rotate_vertex
ubyte g3_rotate_vertex(vertex *dest, const vec3d *src)
Definition: 3dmath.cpp:97
physics_init
void physics_init(physics_info *pi)
Definition: physics.cpp:49
p1
hull_check p1
Definition: lua.cpp:5052
colour_black
color colour_black
Definition: fredrender.cpp:135
my_orient
matrix my_orient
Definition: fredrender.cpp:110
grid::gpoints5
vec3d gpoints5[MAX_GRIDLINE_POINTS]
Definition: missiongrid.h:32
Tp1
vec3d Tp1
Definition: fredrender.cpp:108
FRED_COLOUR_WHITE
#define FRED_COLOUR_WHITE
Definition: fredrender.cpp:138
vm_vec_dist
float vm_vec_dist(const vec3d *v0, const vec3d *v1)
Definition: vecmat.cpp:355
eye_orient
matrix eye_orient
Definition: fredrender.cpp:112
FREDDoc_ptr
CFREDDoc * FREDDoc_ptr
Definition: freddoc.cpp:90
KEY_R
#define KEY_R
Definition: key.h:99
bsp_info::offset
vec3d offset
Definition: model.h:330
vm_extract_angles_matrix
angles * vm_extract_angles_matrix(angles *a, const matrix *m)
Definition: vecmat.cpp:1027
ship
Definition: ship.h:534
Single_axis_constraint
int Single_axis_constraint
Definition: fredrender.cpp:90
eye_pos
vec3d eye_pos
Definition: fredrender.cpp:103
Show_asteroid_field
int Show_asteroid_field
Definition: fredrender.cpp:88
DWORD
unsigned long DWORD
Definition: config.h:90
plane::C
float C
Definition: vecmat.h:73
MR_DEBUG_PATHS
#define MR_DEBUG_PATHS
Definition: model.h:927
model_render_params::set_color
void set_color(color &clr)
Definition: modelrender.cpp:227
idx
int idx
Definition: multiui.cpp:761
g3_project_vertex
int g3_project_vertex(vertex *point)
Definition: 3dmath.cpp:202
jumpnode_render_all
void jumpnode_render_all()
Definition: jumpnode.cpp:473
subsys_to_render
Definition: fredview.h:24
vm_vec_unrotate
vec3d * vm_vec_unrotate(vec3d *dest, const vec3d *src, const matrix *m)
Definition: vecmat.cpp:959
draw_orient_sphere2
void draw_orient_sphere2(int col, object *obj, int r, int g, int b)
Definition: fredrender.cpp:1166
BRIEF_GRID_W
#define BRIEF_GRID_W
Definition: missionbriefcommon.h:240
x
GLint GLint GLint GLint GLint x
Definition: Glext.h:5182
Objects
object Objects[MAX_OBJECTS]
Definition: object.cpp:62
grid::gpoints6
vec3d gpoints6[MAX_GRIDLINE_POINTS]
Definition: missiongrid.h:33
KEY_PADMINUS
#define KEY_PADMINUS
Definition: key.h:166
fix
long fix
Definition: pstypes.h:54
fvi_ray_sphere
int fvi_ray_sphere(vec3d *intp, const vec3d *p0, const vec3d *p1, const vec3d *sphere_pos, float sphere_rad)
Definition: fvi.cpp:255
viewpoint
int viewpoint
Definition: fredview.cpp:98
Anticonstraint
vec3d Anticonstraint
Definition: fredrender.cpp:107
model_render_params::set_replacement_textures
void set_replacement_textures(int *textures)
Definition: modelrender.cpp:207
OBJ_INDEX
#define OBJ_INDEX(objp)
Definition: object.h:235
OF_MARKED
#define OF_MARKED
Definition: object.h:125
mc_info::hit_point_world
vec3d hit_point_world
Definition: model.h:1124
vm_vec_make
#define vm_vec_make(v, _x, _y, _z)
Definition: vecmat.h:48
vm_trackball
void vm_trackball(int idx, int idy, matrix *RotMat)
Definition: vecmat.cpp:1151
Group_rotate
int Group_rotate
Definition: fredrender.cpp:93
grid::gpoints2
vec3d gpoints2[MAX_GRIDLINE_POINTS]
Definition: missiongrid.h:29
object::orient
matrix orient
Definition: object.h:153
inited
int inited
Definition: fredrender.cpp:76
screen::max_w
int max_w
Definition: 2d.h:360
Show_iff
bool Show_iff[MAX_IFFS]
Definition: management.cpp:102
view_obj
int view_obj
Definition: fredview.cpp:99
Fred_grid_colors_inited
int Fred_grid_colors_inited
Definition: fredrender.cpp:1384
OBJ_SHIP
#define OBJ_SHIP
Definition: object.h:32
v1
GLfloat GLfloat v1
Definition: Glext.h:5639
ship_subsys
Definition: ship.h:310
control_info::bank
float bank
Definition: physics.h:104
view_physics
physics_info view_physics
Definition: fredrender.cpp:114
vertex::flags
ubyte flags
Definition: pstypes.h:178
flags
GLbitfield flags
Definition: Glext.h:6722
hilight_bitmap
void hilight_bitmap()
Definition: fredrender.cpp:1777
Show_grid_positions
int Show_grid_positions
Definition: fredrender.cpp:84
Control_mode
int Control_mode
Definition: fredrender.cpp:79
Lookat_mode
int Lookat_mode
Definition: fredrender.cpp:89
grid::gpoints1
vec3d gpoints1[MAX_GRIDLINE_POINTS]
Definition: missiongrid.h:28
set_modified
void set_modified(BOOL arg)
Definition: freddoc.cpp:676
gr_line
__inline void gr_line(int x1, int y1, int x2, int y2, int resize_mode=GR_RESIZE_FULL)
Definition: 2d.h:791
IDENTITY_MATRIX
#define IDENTITY_MATRIX
Definition: vecmat.h:64
vm_vec_sub
void vm_vec_sub(vec3d *dest, const vec3d *src0, const vec3d *src1)
Definition: vecmat.cpp:168
physics_read_flying_controls
void physics_read_flying_controls(matrix *orient, physics_info *pi, control_info *ci, float sim_time, vec3d *wash_rot)
Definition: physics.cpp:449
model_subsystem::radius
float radius
Definition: model.h:179
Eye_position
vec3d Eye_position
Definition: 3dsetup.cpp:27
bm_load
int bm_load(const char *real_filename)
Loads a bitmap so we can draw with it later.
Definition: bmpman.cpp:1119
b
GLboolean GLboolean GLboolean b
Definition: Glext.h:5781
mc_info::num_hits
int num_hits
Definition: model.h:1121
Ships
ship Ships[MAX_SHIPS]
Definition: ship.cpp:122
subsys_to_render::ship_obj
object * ship_obj
Definition: fredview.h:27
CC_BEHIND
#define CC_BEHIND
Definition: 3d.h:31
Marking_box::x1
int x1
Definition: fredview.h:21
physics_sim
void physics_sim(vec3d *position, matrix *orient, physics_info *pi, float sim_time)
Definition: physics.cpp:364
float
typedef float(SCP_EXT_CALLCONV *SCPTRACKIR_PFFLOATVOID)()
render_one_model_htl
void render_one_model_htl(object *objp)
Definition: fredrender.cpp:837
Show_stars
int Show_stars
Definition: fredrender.cpp:83
fredhtl_render_subsystem_bounding_box
void fredhtl_render_subsystem_bounding_box(subsys_to_render *s2r)
Definition: fredrender.cpp:501
FONT1
#define FONT1
Definition: font.h:65
FRED_COLOUR_YELLOW
#define FRED_COLOUR_YELLOW
Definition: fredrender.cpp:139
model_subsystem::pnt
vec3d pnt
Definition: model.h:178
Grid_gmatrix
matrix Grid_gmatrix
Definition: fredrender.cpp:109
obj_render_all
void obj_render_all(void(*render_function)(object *objp), bool *render_viewer_last)
Definition: objectsort.cpp:172
ship_obj
Definition: ship.h:1481
render_waypoints
void render_waypoints(void)
Definition: fredrender.cpp:404
render_one_model_briefing_screen
void render_one_model_briefing_screen(object *objp)
Definition: fredrender.cpp:685
strcat_s
#define strcat_s(...)
Definition: safe_strings.h:68
KEY_ESC
#define KEY_ESC
Definition: key.h:124
Render_subsys
subsys_to_render Render_subsys
Definition: fredview.cpp:70
Fixed_briefing_size
int Fixed_briefing_size
Definition: fredrender.cpp:99
CFREDView::cycle_constraint
void cycle_constraint()
Definition: fredview.cpp:2153
colour_yellow
color colour_yellow
Definition: fredrender.cpp:136
Cmdline_NoFPSCap
int Cmdline_NoFPSCap
Definition: cmdline.cpp:353
render_active_rect
void render_active_rect(void)
Definition: fredrender.cpp:1293
timer_get_fixed_seconds
fix timer_get_fixed_seconds()
Definition: timer.cpp:116
MC_CHECK_MODEL
#define MC_CHECK_MODEL
Definition: model.h:1169
render_model_x
void render_model_x(vec3d *pos, grid *gridp, int col_scheme=0)
Definition: fredrender.cpp:1207
BRIEF_GRID_H
#define BRIEF_GRID_H
Definition: missionbriefcommon.h:241
g3_end_frame
#define g3_end_frame()
Definition: 3d.h:49
screen::clip_width
int clip_width
Definition: 2d.h:378
Show_starts
int Show_starts
Definition: fredview.cpp:89
gr_screen
screen gr_screen
Definition: 2d.cpp:46
gr_get_string_size
void gr_get_string_size(int *w, int *h, const char *text, int len=9999)
Definition: font.cpp:196
info_popup
CWnd info_popup
Definition: fredrender.cpp:116
control_info::heading
float heading
Definition: physics.h:102
physics_info::last_rotmat
matrix last_rotmat
Definition: physics.h:83
model_subsystem::subobj_name
char subobj_name[MAX_NAME_LEN]
Definition: model.h:172
grid::planeD
float planeD
Definition: missiongrid.h:27
Show_dock_points
int Show_dock_points
Definition: fredview.cpp:93
Show_grid
int Show_grid
Definition: fredrender.cpp:81
fl_sqrt
#define fl_sqrt(fl)
Definition: floating.h:29
ship::ship_info_index
int ship_info_index
Definition: ship.h:539
light_reset
void light_reset()
Definition: lighting.cpp:150
p
GLfloat GLfloat p
Definition: Glext.h:8373
stars_draw
void stars_draw(int show_stars, int show_suns, int show_nebulas, int show_subspace, int env)
Definition: starfield.cpp:1813
last_y
int last_y
Definition: fredrender.cpp:80
True_rh
int True_rh
Definition: fredrender.cpp:98
Sleep
void Sleep(int mili)
info_popup_active
int info_popup_active
Definition: fredrender.cpp:94
control_info::vertical
float vertical
Definition: physics.h:101
Ship_info
SCP_vector< ship_info > Ship_info
Definition: ship.cpp:164
MR_FULL_DETAIL
#define MR_FULL_DETAIL
Definition: model.h:887
vm_vec_avg
vec3d * vm_vec_avg(vec3d *dest, const vec3d *src0, const vec3d *src1)
Definition: vecmat.cpp:217
g3_start_instance_matrix
void g3_start_instance_matrix(const vec3d *pos, const matrix *orient, bool set_api=true)
Definition: 3dsetup.cpp:249
Tp2
vec3d Tp2
Definition: fredrender.cpp:108
game_do_frame
void game_do_frame()
Definition: fredrender.cpp:1614
asteroid_field::has_inner_bound
int has_inner_bound
Definition: asteroid.h:130
vm_vec_cmp
int vm_vec_cmp(const vec3d *a, const vec3d *b)
Definition: vecmat.cpp:1415
PI
#define PI
Definition: pstypes.h:303
pos
hull_check pos
Definition: lua.cpp:5050
Show_ships
int Show_ships
Definition: fredview.cpp:88
physics_info
Definition: physics.h:36
obj
GLsizei GLsizei GLuint * obj
Definition: Glext.h:5619
mc_info::model_instance_num
int model_instance_num
Definition: model.h:1109
KEY_SPACEBAR
#define KEY_SPACEBAR
Definition: key.h:128
ENVMAP
int ENVMAP
References a map that is for environment mapping -Bobboau.
Definition: bmpman.cpp:59
vm_vec_dot
float vm_vec_dot(const vec3d *v0, const vec3d *v1)
Definition: vecmat.cpp:312
move_mouse
void move_mouse(int btn, int mdx, int mdy)
Definition: fredrender.cpp:353
SCP_list
Definition: vmallocator.h:19
asteroid_field::inner_max_bound
vec3d inner_max_bound
Definition: asteroid.h:132
control_info::sideways
float sideways
Definition: physics.h:103
count
GLint GLsizei count
Definition: Gl.h:1491
Fred_outline
int Fred_outline
Definition: fredrender.cpp:75
select_object
int select_object(int cx, int cy)
Definition: fredrender.cpp:1930
render_one_model
void render_one_model(object *objp)
MAX_FRAMETIME
#define MAX_FRAMETIME
Definition: fredrender.cpp:65
OF_HIDDEN
#define OF_HIDDEN
Definition: object.h:127
cur_object_index
int cur_object_index
Definition: management.cpp:79
Show_ship_info
int Show_ship_info
Definition: fredview.cpp:90
pm
polymodel * pm
Definition: lua.cpp:1598
The_grid
grid * The_grid
Definition: missiongrid.cpp:20
FRED_BRIEFING_HTL_FOV
const float FRED_BRIEFING_HTL_FOV
Definition: fredrender.cpp:71
KEY_PAD6
#define KEY_PAD6
Definition: key.h:162
grid::gpoints3
vec3d gpoints3[MAX_GRIDLINE_POINTS]
Definition: missiongrid.h:30
Show_compass
int Show_compass
Definition: fredview.cpp:92
model_render_params
Definition: modelrender.h:63
mc_info
Definition: model.h:1107
Asteroid_field
asteroid_field Asteroid_field
Definition: asteroid.cpp:64
compute_point_on_plane
void compute_point_on_plane(vec3d *q, const plane *planep, const vec3d *p)
Definition: vecmat.cpp:1363
OBJ_NONE
#define OBJ_NONE
Definition: object.h:31
Briefing_dialog
briefing_editor_dlg * Briefing_dialog
Definition: fred.cpp:59
vertex::codes
ubyte codes
Definition: pstypes.h:177
mission::envmap_name
char envmap_name[MAX_FILENAME_LEN]
Definition: missionparse.h:149
grid::gpoints8
vec3d gpoints8[MAX_GRIDLINE_POINTS]
Definition: missiongrid.h:35
object::flags
uint flags
Definition: object.h:151
object::radius
float radius
Definition: object.h:154
Marking_box::x2
int x2
Definition: fredview.h:21
plane
Definition: vecmat.h:72
The_mission
mission The_mission
Definition: missionparse.cpp:86
draw_asteroid_field
void draw_asteroid_field()
Definition: fredrender.cpp:1805
Marking_box::y2
int y2
Definition: fredview.h:21
KEY_PAD2
#define KEY_PAD2
Definition: key.h:158
briefing_editor_dlg::draw_icon
void draw_icon(object *objp)
Definition: briefingeditordlg.cpp:829
process_controls
void process_controls(vec3d *pos, matrix *orient, float frametime, int key, int mode=0)
Definition: fredrender.cpp:1342
FRED_DEAFULT_HTL_DRAW_DIST
const float FRED_DEAFULT_HTL_DRAW_DIST
Definition: fredrender.cpp:72
angles::h
float h
Definition: pstypes.h:111
gr_set_font
void gr_set_font(int fontnum)
Definition: font.cpp:566
model_num
int model_num
Definition: lua.cpp:4996
render_count
int render_count
Definition: fredrender.cpp:96
Show_waypoints
int Show_waypoints
Definition: object.cpp:73
object::type
char type
Definition: object.h:146
fred_disable_htl
void fred_disable_htl()
Definition: fredrender.cpp:147
Last_eye_orient
matrix Last_eye_orient
Definition: fredrender.cpp:112
CONVERT_DEGREES
#define CONVERT_DEGREES
Definition: fredrender.cpp:68
render_models
void render_models(void)
Definition: fredrender.cpp:652
cur_waypoint
waypoint * cur_waypoint
Definition: management.cpp:82
control_info
Definition: physics.h:99
OBJ_POINT
#define OBJ_POINT
Definition: object.h:40
g3_point_to_vec
void g3_point_to_vec(vec3d *v, int sx, int sy)
Definition: 3dmath.cpp:231
KEY_PADPLUS
#define KEY_PADPLUS
Definition: key.h:167
mc_info::orient
matrix * orient
Definition: model.h:1112
render_compass
void render_compass(void)
Definition: fredrender.cpp:2015
OBJ_JUMP_NODE
#define OBJ_JUMP_NODE
Definition: object.h:45
vm_vec_add
void vm_vec_add(vec3d *dest, const vec3d *src0, const vec3d *src1)
Definition: vecmat.cpp:159
v
const GLdouble * v
Definition: Glext.h:5322
gr_init_color
void gr_init_color(color *c, int r, int g, int b)
Definition: 2d.cpp:1155
vmd_identity_matrix
matrix vmd_identity_matrix
Definition: vecmat.cpp:28
process_movement_keys
void process_movement_keys(int key, vec3d *mvec, angles *angs)
Definition: fredrender.cpp:1305
Marking_box::y1
int y1
Definition: fredview.h:21
colour_white
color colour_white
Definition: fredrender.cpp:133
ship::ship_name
char ship_name[NAME_LENGTH]
Definition: ship.h:604
Last_eye_pos
vec3d Last_eye_pos
Definition: fredrender.cpp:103
screen::aspect
float aspect
Definition: 2d.h:372
angles::b
float b
Definition: pstypes.h:111
display_ship_info
void display_ship_info()
Definition: fredrender.cpp:1035
y
GLint y
Definition: Gl.h:1505
Update_window
int Update_window
Definition: fred.cpp:48
Grid_center
vec3d Grid_center
Definition: fredrender.cpp:105
g3_start_frame
#define g3_start_frame(zbuffer_flag)
Definition: 3d.h:39
Fred_grid_dark
color Fred_grid_dark
Definition: fredrender.cpp:1385
Lighting_on
int Lighting_on
Definition: fredview.cpp:95
strcpy_s
#define strcpy_s(...)
Definition: safe_strings.h:67
level_controlled
void level_controlled()
Definition: fredrender.cpp:199
Last_cursor_over
int Last_cursor_over
Definition: fredrender.cpp:97
g3_draw_htl_line
void g3_draw_htl_line(const vec3d *start, const vec3d *end)
Definition: 3ddraw.cpp:1975