void get_default_virtual_cockpit_adi_angles (matrix3x3 attitude, float *heading, float *pitch, float *roll)
{
matrix3x3
inverse_attitude,
heading_rotation,
result;
//
// get inverse attitude (attiude * inverse attitude = identity) which aligns the ADI with the world axis
//
inverse_attitude[0][0] = attitude[0][0];
inverse_attitude[1][0] = attitude[0][1];
inverse_attitude[2][0] = attitude[0][2];
inverse_attitude[0][1] = attitude[1][0];
inverse_attitude[1][1] = attitude[1][1];
inverse_attitude[2][1] = attitude[1][2];
inverse_attitude[0][2] = attitude[2][0];
inverse_attitude[1][2] = attitude[2][1];
inverse_attitude[2][2] = attitude[2][2];
//
// rotate heading so that the ADI pitch markings face the pilot
//
get_3d_transformation_matrix (heading_rotation, get_heading_from_attitude_matrix (attitude), 0.0, 0.0);
multiply_matrix3x3_matrix3x3 (result, heading_rotation, inverse_attitude);
*heading = get_heading_from_attitude_matrix (result);
*pitch = get_pitch_from_attitude_matrix (result);
*roll = get_roll_from_attitude_matrix (result);
}
static float get_local_float_value (entity *en, float_types type)
{
mobile
*raw;
float
value;
raw = (mobile *) get_local_entity_data (en);
switch (type)
{
////////////////////////////////////////
case FLOAT_TYPE_ALTITUDE:
////////////////////////////////////////
{
value = raw->position.y;
break;
}
////////////////////////////////////////
case FLOAT_TYPE_HEADING:
////////////////////////////////////////
{
value = get_heading_from_attitude_matrix (raw->attitude);
break;
}
////////////////////////////////////////
case FLOAT_TYPE_HIGH_VELOCITY:
case FLOAT_TYPE_LOW_VELOCITY:
case FLOAT_TYPE_MEDIUM_VELOCITY:
case FLOAT_TYPE_VELOCITY:
case FLOAT_TYPE_VERY_HIGH_VELOCITY:
////////////////////////////////////////
{
value = raw->velocity;
break;
}
////////////////////////////////////////
default:
////////////////////////////////////////
{
debug_fatal_invalid_float_type (en, type);
break;
}
}
return (value);
}
static float get_local_float_value (entity *en, float_types type)
{
camera
*raw;
float
value;
raw = get_local_entity_data (en);
switch (type)
{
////////////////////////////////////////
case FLOAT_TYPE_HEADING:
////////////////////////////////////////
{
value = get_heading_from_attitude_matrix (raw->attitude);
break;
}
////////////////////////////////////////
case FLOAT_TYPE_PITCH:
////////////////////////////////////////
{
value = get_pitch_from_attitude_matrix (raw->attitude);
break;
}
////////////////////////////////////////
case FLOAT_TYPE_ROLL:
////////////////////////////////////////
{
value = get_roll_from_attitude_matrix (raw->attitude);
break;
}
////////////////////////////////////////
default:
////////////////////////////////////////
{
debug_fatal_invalid_float_type (en, type);
break;
}
}
return (value);
}
void update_static_camera (camera *raw)
{
float
heading,
pitch;
ASSERT (raw);
heading = get_heading_from_attitude_matrix (raw->attitude);
pitch = get_pitch_from_attitude_matrix (raw->attitude);
//
// adjust camera heading
//
if (adjust_view_left_key || joystick_pov_left)
{
heading -= STATIC_CAMERA_ROTATE_RATE * get_delta_time ();
}
else if (adjust_view_right_key || joystick_pov_right)
{
heading += STATIC_CAMERA_ROTATE_RATE * get_delta_time ();
}
heading = wrap_angle (heading);
//
// adjust camera pitch
//
if (adjust_view_up_key || joystick_pov_up)
{
pitch += STATIC_CAMERA_ROTATE_RATE * get_delta_time ();
pitch = min (STATIC_CAMERA_ROTATE_UP_LIMIT, pitch);
}
else if (adjust_view_down_key || joystick_pov_down)
{
pitch -= STATIC_CAMERA_ROTATE_RATE * get_delta_time ();
pitch = max (STATIC_CAMERA_ROTATE_DOWN_LIMIT, pitch);
}
get_3d_transformation_matrix (raw->attitude, heading, pitch, 0.0);
}
static void get_local_attitude_angles (entity *en, float *heading, float *pitch, float *roll)
{
camera
*raw;
ASSERT (heading);
ASSERT (pitch);
ASSERT (roll);
raw = get_local_entity_data (en);
*heading = get_heading_from_attitude_matrix (raw->attitude);
*pitch = get_pitch_from_attitude_matrix (raw->attitude);
*roll = get_roll_from_attitude_matrix (raw->attitude);
}
static entity *create_local (entity_types type, int index, char *pargs)
{
entity
*en;
routed_vehicle
*raw;
entity_sub_types
group_sub_type;
float
heading;
vec3d
*face_normal;
////////////////////////////////////////
//
// VALIDATE
//
////////////////////////////////////////
validate_local_create_entity_index (index);
#if DEBUG_MODULE
debug_log_entity_args (ENTITY_DEBUG_LOCAL, ENTITY_DEBUG_CREATE, NULL, type, index);
#endif
en = get_free_entity (index);
if (en)
{
////////////////////////////////////////
//
// MALLOC ENTITY DATA
//
////////////////////////////////////////
set_local_entity_type (en, type);
raw = malloc_fast_mem (sizeof (routed_vehicle));
set_local_entity_data (en, raw);
////////////////////////////////////////
//
// INITIALISE ALL ENTITY DATA TO 'WORKING' DEFAULT VALUES
//
// DO NOT USE ACCESS FUNCTIONS
//
// DO NOT USE RANDOM VALUES
//
////////////////////////////////////////
memset (raw, 0, sizeof (routed_vehicle));
//
// mobile
//
raw->vh.mob.sub_type = ENTITY_SUB_TYPE_UNINITIALISED;
raw->vh.mob.position.x = MID_MAP_X;
raw->vh.mob.position.y = MID_MAP_Y;
raw->vh.mob.position.z = MID_MAP_Z;
get_identity_matrix3x3 (raw->vh.mob.attitude);
raw->vh.mob.alive = TRUE;
raw->vh.mob.side = ENTITY_SIDE_UNINITIALISED;
raw->vh.operational_state = OPERATIONAL_STATE_UNKNOWN;
//
// vehicle
//
raw->vh.object_3d_shape = OBJECT_3D_INVALID_OBJECT_INDEX;
raw->vh.weapon_config_type = WEAPON_CONFIG_TYPE_UNINITIALISED;
raw->vh.selected_weapon = ENTITY_SUB_TYPE_WEAPON_NO_WEAPON;
raw->vh.weapon_vector.x = 0.0;
raw->vh.weapon_vector.y = 0.0;
raw->vh.weapon_vector.z = 1.0;
raw->vh.weapon_to_target_vector.x = 0.0;
raw->vh.weapon_to_target_vector.y = 0.0;
raw->vh.weapon_to_target_vector.z = -1.0;
raw->vh.loading_door_state = VEHICLE_LOADING_DOORS_OPEN_FLOAT_VALUE;
//
// routed
//
////////////////////////////////////////
//
// OVERWRITE DEFAULT VALUES WITH GIVEN ATTRIBUTES
//
////////////////////////////////////////
set_local_entity_attributes (en, pargs);
////////////////////////////////////////
//
// CHECK MANDATORY ATTRIBUTES HAVE BEEN GIVEN
//
////////////////////////////////////////
ASSERT (raw->vh.member_link.parent);
ASSERT (get_local_entity_type (raw->vh.member_link.parent) == ENTITY_TYPE_GROUP);
////////////////////////////////////////
//
// RESOLVE DEFAULT VALUES
//
////////////////////////////////////////
raw->sub_route = NULL;
//
// side
//
if (raw->vh.mob.side == ENTITY_SIDE_UNINITIALISED)
{
raw->vh.mob.side = get_local_entity_int_value (raw->vh.member_link.parent, INT_TYPE_SIDE);
}
ASSERT (raw->vh.mob.side != ENTITY_SIDE_NEUTRAL);
//
// sub_type
//
if (raw->vh.mob.sub_type == ENTITY_SUB_TYPE_UNINITIALISED)
{
group_sub_type = get_local_entity_int_value (raw->vh.member_link.parent, INT_TYPE_ENTITY_SUB_TYPE);
if (raw->vh.mob.side == ENTITY_SIDE_BLUE_FORCE)
{
raw->vh.mob.sub_type = group_database[group_sub_type].default_blue_force_sub_type;
}
else
{
raw->vh.mob.sub_type = group_database[group_sub_type].default_red_force_sub_type;
}
}
ASSERT (entity_sub_type_vehicle_valid (raw->vh.mob.sub_type));
//
// 3D shape
//
if (raw->vh.object_3d_shape == OBJECT_3D_INVALID_OBJECT_INDEX)
{
raw->vh.object_3d_shape = vehicle_database[raw->vh.mob.sub_type].default_3d_shape;
}
//
// weapon config
//
if (raw->vh.weapon_config_type == WEAPON_CONFIG_TYPE_UNINITIALISED)
{
raw->vh.weapon_config_type = vehicle_database[raw->vh.mob.sub_type].default_weapon_config_type;
}
ASSERT (weapon_config_type_valid (raw->vh.weapon_config_type));
//
// damage levels
//
raw->vh.damage_level = vehicle_database[raw->vh.mob.sub_type].initial_damage_level;
//
// radar dish rotation (ok to use a random number as this is for visual effect only)
//
raw->vh.radar_rotation_state = frand1 ();
////////////////////////////////////////
//
// BUILD COMPONENTS
//
////////////////////////////////////////
//
// 3D object
//
raw->vh.inst3d = construct_3d_object (raw->vh.object_3d_shape);
set_routed_vehicle_id_number (en);
set_initial_rotation_angle_of_routed_vehicle_wheels (raw->vh.inst3d);
//
// align with terrain
//
get_3d_terrain_point_data (raw->vh.mob.position.x, raw->vh.mob.position.z, &raw->vh.terrain_info);
heading = get_heading_from_attitude_matrix (raw->vh.mob.attitude);
face_normal = get_3d_terrain_point_data_normal (&raw->vh.terrain_info);
get_3d_transformation_matrix_from_face_normal_and_heading (raw->vh.mob.attitude, face_normal, heading);
//
// weapon config
//
raw->vh.weapon_package_status_array = malloc_fast_mem (SIZE_WEAPON_PACKAGE_STATUS_ARRAY);
memset (raw->vh.weapon_package_status_array, 0, SIZE_WEAPON_PACKAGE_STATUS_ARRAY);
load_local_entity_weapon_config (en);
//
// update force info
//
add_to_force_info (get_local_force_entity (raw->vh.mob.side), en);
////////////////////////////////////////
//
// LINK INTO SYSTEM
//
////////////////////////////////////////
insert_local_entity_into_parents_child_list (en, LIST_TYPE_MEMBER, raw->vh.member_link.parent, raw->vh.member_link.child_pred);
//
// insert into LIST_TYPE_MEMBER before LIST_TYPE_VIEW
//
insert_local_entity_into_parents_child_list (en, LIST_TYPE_VIEW, get_camera_entity (), get_local_entity_view_list_pred (en));
insert_local_entity_into_parents_child_list (en, LIST_TYPE_SECTOR, get_local_sector_entity (&raw->vh.mob.position), NULL);
insert_local_entity_into_parents_child_list (en, LIST_TYPE_UPDATE, get_update_entity (), NULL);
}
return (en);
}
void update_vector_altitude_dynamics (void)
{
static float
last_ground_height = 0;
matrix3x3
attitude;
float
heading,
pitch,
roll,
ground_height,
centre_of_gravity_to_ground_distance;
vec3d
position,
*face_normal;
centre_of_gravity_to_ground_distance = get_local_entity_float_value (get_gunship_entity (), FLOAT_TYPE_CENTRE_OF_GRAVITY_TO_GROUND_DISTANCE);
get_local_entity_attitude_matrix (get_gunship_entity (), attitude);
ground_height = get_local_entity_float_value (get_gunship_entity (), FLOAT_TYPE_TERRAIN_ELEVATION);
//
// debug
//
if ((ground_height < -1000) || (ground_height > 32000))
{
debug_log ("!!!!!!!!!!!!!! GROUND HEIGHT %f", ground_height);
ground_height = last_ground_height;
}
//
// end
//
last_ground_height = ground_height;
current_flight_dynamics->altitude.value = current_flight_dynamics->position.y;
current_flight_dynamics->altitude.min = ground_height;
switch (get_local_entity_int_value (get_gunship_entity (), INT_TYPE_OPERATIONAL_STATE))
{
case OPERATIONAL_STATE_LANDED:
{
if (current_flight_dynamics->world_velocity_y.value > 0.0)
{
#if DEBUG_DYNAMICS
debug_log ("VECTOR DYN: takeoff !");
#endif
set_local_entity_int_value (get_gunship_entity (), INT_TYPE_OPERATIONAL_STATE, OPERATIONAL_STATE_NAVIGATING);
delete_local_entity_from_parents_child_list (get_gunship_entity (), LIST_TYPE_CURRENT_WAYPOINT);
transmit_entity_comms_message (ENTITY_COMMS_MOBILE_TAKEOFF, get_gunship_entity ());
}
else
{
entity
*wp;
vec3d
wp_pos;
wp = get_local_entity_parent (get_gunship_entity (), LIST_TYPE_CURRENT_WAYPOINT);
if (wp)
{
get_local_waypoint_formation_position (get_local_entity_int_value (get_gunship_entity (), INT_TYPE_FORMATION_POSITION), wp, &wp_pos);
ground_height = wp_pos.y;
}
current_flight_dynamics->world_velocity_y.value = max (current_flight_dynamics->world_velocity_y.value, 0.0);
current_flight_dynamics->velocity_y.value = max (current_flight_dynamics->velocity_y.value, 0.0);
memset (¤t_flight_dynamics->world_motion_vector, 0, sizeof (vec3d));
current_flight_dynamics->velocity_x.value = bound (current_flight_dynamics->velocity_x.value, knots_to_metres_per_second (-10), knots_to_metres_per_second (50));
current_flight_dynamics->velocity_y.value = 0;
current_flight_dynamics->velocity_z.value = bound (current_flight_dynamics->velocity_z.value, knots_to_metres_per_second (-10), knots_to_metres_per_second (50));
current_flight_dynamics->position.y = ground_height + centre_of_gravity_to_ground_distance;
current_flight_dynamics->altitude.value = ground_height + centre_of_gravity_to_ground_distance;
heading = get_heading_from_attitude_matrix (attitude);
//get_3d_terrain_face_normal (&n, current_flight_dynamics->position.x, current_flight_dynamics->position.z);
face_normal = get_local_entity_ptr_value (get_gunship_entity (), PTR_TYPE_TERRAIN_FACE_NORMAL);
get_3d_transformation_matrix_from_face_normal_and_heading (attitude, face_normal, heading);
pitch = get_pitch_from_attitude_matrix (attitude);
pitch += rad (aircraft_database [ENTITY_SUB_TYPE_AIRCRAFT_AH64D_APACHE_LONGBOW].fuselage_angle);
roll = get_roll_from_attitude_matrix (attitude);
get_3d_transformation_matrix (attitude, heading, pitch, roll);
position.x = current_flight_dynamics->position.x;
position.y = current_flight_dynamics->position.y;
position.z = current_flight_dynamics->position.z;
set_local_entity_vec3d (get_gunship_entity (), VEC3D_TYPE_POSITION, &position);
set_local_entity_attitude_matrix (get_gunship_entity (), attitude);
}
break;
}
default:
{
if (current_flight_dynamics->world_velocity_y.value < 0.0)
{
if (current_flight_dynamics->altitude.value < current_flight_dynamics->altitude.min + centre_of_gravity_to_ground_distance)
{
if (get_local_entity_int_value (get_gunship_entity (), INT_TYPE_OPERATIONAL_STATE) != OPERATIONAL_STATE_LANDED)
{
//
// need to find what wp the user is trying to land on ....
//
//entity
//*wp;
#if DEBUG_DYNAMICS
debug_log ("VECTOR DYN: landed !");
#endif
set_local_entity_int_value (get_gunship_entity (), INT_TYPE_OPERATIONAL_STATE, OPERATIONAL_STATE_LANDED);
//transmit_entity_comms_message (ENTITY_COMMS_MOBILE_LAND, get_gunship_entity (), wp);
}
}
}
break;
}
}
current_flight_dynamics->altitude.value = bound (
current_flight_dynamics->altitude.value,
current_flight_dynamics->altitude.min,
current_flight_dynamics->altitude.max);
}
static void set_local_vec3d (entity *en, vec3d_types type, vec3d *v)
{
aircraft
*raw;
ASSERT (v);
#if DEBUG_MODULE
debug_log_entity_args (ENTITY_DEBUG_LOCAL, ENTITY_DEBUG_VEC3D, en, type, v);
#endif
raw = (aircraft *) get_local_entity_data (en);
switch (type)
{
////////////////////////////////////////
case VEC3D_TYPE_MOTION_VECTOR:
////////////////////////////////////////
{
raw->mob.motion_vector = *v;
break;
}
////////////////////////////////////////
case VEC3D_TYPE_POSITION:
////////////////////////////////////////
{
float
heading;
entity
*dependent,
*special_effect,
*old_sector,
*new_sector;
//
// notify dependents of move, must be done before set_vec3d so children can work out delta positions
//
heading = 0.0;
//if (get_local_entity_type (en) == ENTITY_TYPE_HELICOPTER)
{
heading = get_heading_from_attitude_matrix (raw->mob.attitude);
dependent = get_local_entity_first_child (en, LIST_TYPE_MOVEMENT_DEPENDENT);
while (dependent)
{
#if DEBUG_MODULE_AIRCRAFT_POSITION_MESSAGE
debug_log ("AIRCRAFT VEC3D: sending set entity position %f, %f, %f", raw->mob.position.x, raw->mob.position.y, raw->mob.position.z);
#endif
notify_local_entity (ENTITY_MESSAGE_SET_ENTITY_POSITION, dependent, en, v, (double) heading, (double) raw->mob.velocity);
dependent = get_local_entity_child_succ (dependent, LIST_TYPE_MOVEMENT_DEPENDENT);
}
}
//
// Actual set_vec3d
//
raw->mob.position = *v;
//
// check if entered new sector
//
old_sector = get_local_entity_parent (en, LIST_TYPE_SECTOR);
new_sector = get_local_sector_entity (v);
if (old_sector != new_sector)
{
delete_local_entity_from_parents_child_list (en, LIST_TYPE_SECTOR);
insert_local_entity_into_parents_child_list (en, LIST_TYPE_SECTOR, new_sector, NULL);
//
// play speech for flown across "front-line"
//
if (get_comms_model () == COMMS_MODEL_SERVER)
{
if (get_local_entity_int_value (new_sector, INT_TYPE_SIDE) != get_local_entity_int_value (old_sector, INT_TYPE_SIDE))
{
play_aircraft_flown_into_new_sector_speech (en, old_sector, new_sector);
}
}
}
//
// notify special effects of move
//
special_effect = get_local_entity_first_child (en, LIST_TYPE_SPECIAL_EFFECT);
while (special_effect)
{
#if DEBUG_MODULE_AIRCRAFT_POSITION_MESSAGE
debug_log ("AIRCRAFT VEC3D: sending set entity position %f, %f, %f", raw->mob.position.x, raw->mob.position.y, raw->mob.position.z);
#endif
notify_local_entity (ENTITY_MESSAGE_SET_ENTITY_POSITION, special_effect, en, &raw->mob.position, (double) heading, (double) raw->mob.velocity);
special_effect = get_local_entity_child_succ (special_effect, LIST_TYPE_SPECIAL_EFFECT);
}
break;
}
////////////////////////////////////////
case VEC3D_TYPE_WEAPON_TO_TARGET_VECTOR:
////////////////////////////////////////
{
raw->weapon_to_target_vector = *v;
break;
}
////////////////////////////////////////
case VEC3D_TYPE_WEAPON_VECTOR:
////////////////////////////////////////
{
raw->weapon_vector = *v;
break;
}
////////////////////////////////////////
default:
////////////////////////////////////////
{
debug_fatal_invalid_vec3d_type (en, type);
break;
}
}
}
void save_screen_image_and_viewpoint_data (void)
{
char
filename[100],
large_image_filename[100],
small_image_filename[100],
viewpoint_data_filename[100];
FILE
*fp;
int
x_sec,
z_sec;
//
// find first screen shot index
//
if (!found_first_screen_shot_index)
{
while (TRUE)
{
sprintf (large_image_filename, "%sIMAGE%03d.TGA", LARGE_IMAGE_PATH, screen_shot_index);
if (file_exist (large_image_filename))
{
screen_shot_index++;
if (screen_shot_index == 1000)
{
break;
}
}
else
{
found_first_screen_shot_index = TRUE;
break;
}
}
}
//
// write screen files and viewpoint data file
//
if (screen_shot_index <= MAX_SCREEN_SHOT_INDEX)
{
sprintf (filename, "IMAGE%03d", screen_shot_index);
debug_log ("Saving screen image (%s)", filename);
sprintf (large_image_filename, "%s%s.TGA", LARGE_IMAGE_PATH, filename);
sprintf (small_image_filename, "%s%s.TGA", SMALL_IMAGE_PATH, filename);
sprintf (viewpoint_data_filename, "%s%s.TXT", VIEWPOINT_DATA_PATH, filename);
////////////////////////////////////////
if (lock_screen (video_screen))
{
save_tga_screen_with_thumbnail (large_image_filename, small_image_filename);
unlock_screen (video_screen);
}
////////////////////////////////////////
fp = safe_fopen (viewpoint_data_filename, "w");
fprintf (fp, "Image viewpoint data:\n\n");
fprintf (fp, "Map : unknown\n");
fprintf (fp, "X : %.2f\n", main_vp.x);
fprintf (fp, "Y : %.2f\n", main_vp.y);
fprintf (fp, "Z : %.2f\n", main_vp.z);
get_terrain_3d_sector (main_vp.x, main_vp.z, &x_sec, &z_sec);
fprintf (fp, "X sector (3D) : %d\n", x_sec);
fprintf (fp, "Z sector (3D) : %d\n", z_sec);
get_x_sector (x_sec, main_vp.x);
get_z_sector (z_sec, main_vp.z);
fprintf (fp, "X sector (AI) : %d\n", x_sec);
fprintf (fp, "Z sector (AI) : %d\n", z_sec);
fprintf (fp, "Heading (degs): %.2f\n", deg (get_heading_from_attitude_matrix (main_vp.attitude)));
fprintf (fp, "Pitch (degs) : %.2f\n", deg (get_pitch_from_attitude_matrix (main_vp.attitude)));
fprintf (fp, "Roll (degs) : %.2f\n", deg (get_roll_from_attitude_matrix (main_vp.attitude)));
safe_fclose (fp);
////////////////////////////////////////
screen_shot_index++;
}
else
{
debug_colour_log (DEBUG_COLOUR_RED, "Exceeded screen image limit");
}
}
void debug_log_entity_args (entity_debug_modes mode, entity_debug_args arg, entity *en, ...)
{
va_list
pargs;
////////////////////////////////////////
//
// trap remote args in single player game
//
////////////////////////////////////////
if (!debug_log_entity_args_enabled)
{
return;
}
if (mode == ENTITY_DEBUG_REMOTE)
{
if (direct_play_get_comms_mode () == DIRECT_PLAY_COMMS_MODE_NONE)
{
return;
}
}
////////////////////////////////////////
//
// sort debug log text
//
////////////////////////////////////////
va_start (pargs, en);
switch (arg)
{
////////////////////////////////////////
case ENTITY_DEBUG_ATTITUDE_ANGLES:
////////////////////////////////////////
{
//
// (entity_debug_modes mode, entity_debug_args arg, entity *en, float heading, float pitch, float roll)
//
float
heading,
pitch,
roll;
heading = va_arg (pargs, double);
pitch = va_arg (pargs, double);
roll = va_arg (pargs, double);
debug_log_text (mode, en, "attitude angles (h = %.3f, p = %.3f, r = %.3f)", deg (heading), deg (pitch), deg (roll));
break;
}
////////////////////////////////////////
case ENTITY_DEBUG_ATTITUDE_MATRIX:
////////////////////////////////////////
{
//
// (entity_debug_modes mode, entity_debug_args arg, entity *en, matrix3x3 attitude)
//
matrix3x3
*attitude;
float
heading,
pitch,
roll;
attitude = va_arg (pargs, matrix3x3 *);
ASSERT (attitude);
heading = get_heading_from_attitude_matrix (*attitude);
pitch = get_pitch_from_attitude_matrix (*attitude);
roll = get_roll_from_attitude_matrix (*attitude);
debug_log_text (mode, en, "attitude matrix (h = %.3f, p = %.3f, r = %.3f)", deg (heading), deg (pitch), deg (roll));
break;
}
////////////////////////////////////////
case ENTITY_DEBUG_CHAR_TYPE:
////////////////////////////////////////
{
//
// (entity_debug_modes mode, entity_debug_args arg, entity *en, char_types type)
//
char_types
type;
type = va_arg (pargs, char_types);
debug_log_text (mode, NULL, "char type = %s", get_char_type_name (type));
break;
}
////////////////////////////////////////
case ENTITY_DEBUG_CHAR_VALUE:
////////////////////////////////////////
{
//
// (entity_debug_modes mode, entity_debug_args arg, entity *en, char_types type, char value)
//
char_types
type;
char
value;
type = va_arg (pargs, char_types);
value = va_arg (pargs, int);
debug_log_text (mode, en, "%s = %c", get_char_type_name (type), value);
break;
}
////////////////////////////////////////
case ENTITY_DEBUG_CREATE:
////////////////////////////////////////
{
//
// (entity_debug_modes mode, entity_debug_args arg, entity *en, entity_types type, int index)
//
entity_types
type;
int
index;
type = va_arg (pargs, entity_types);
index = va_arg (pargs, int);
debug_log_text (mode, NULL, "create %s (index = %d): ", get_entity_type_name (type), index);
break;
}
////////////////////////////////////////
case ENTITY_DEBUG_DESTROY:
////////////////////////////////////////
{
//
// (entity_debug_modes mode, entity_debug_args arg, entity *en)
//
debug_log_text (mode, en, "destroy");
break;
}
////////////////////////////////////////
case ENTITY_DEBUG_DESTROY_FAMILY:
////////////////////////////////////////
{
//
// (entity_debug_modes mode, entity_debug_args arg, entity *en)
//
debug_log_text (mode, en, "destroy family");
break;
}
////////////////////////////////////////
case ENTITY_DEBUG_ENTITY_ATTRIBUTE:
////////////////////////////////////////
{
//
// (entity_debug_modes mode, entity_debug_args arg, entity *en, entity_attributes attr)
//
entity_attributes
attr;
attr = va_arg (pargs, entity_attributes);
debug_log_text (mode, NULL, "entity attribute = %s", get_entity_attribute_name (attr));
break;
}
////////////////////////////////////////
case ENTITY_DEBUG_ENTITY_COMMS_MESSAGE:
////////////////////////////////////////
{
//
// (entity_debug_modes mode, entity_debug_args arg, entity *en, entity_comms_messages message)
//
entity_comms_messages
message;
message = va_arg (pargs, entity_comms_messages);
debug_log_text (mode, NULL, "entity comms message = %s", get_entity_comms_message_name (message));
break;
}
////////////////////////////////////////
case ENTITY_DEBUG_ENTITY_INDEX:
////////////////////////////////////////
{
//
// (entity_debug_modes mode, entity_debug_args arg, entity *en, int index)
//
int
index;
index = va_arg (pargs, int);
debug_log_text (mode, en, "entity index = %d", index);
break;
}
////////////////////////////////////////
case ENTITY_DEBUG_ENTITY_TYPE:
////////////////////////////////////////
{
//
// (entity_debug_modes mode, entity_debug_args arg, entity *en, entity_types type)
//
entity_types
type;
type = va_arg (pargs, entity_types);
debug_log_text (mode, en, "entity type = %s", get_entity_type_name (type));
break;
}
////////////////////////////////////////
case ENTITY_DEBUG_FLOAT_TYPE:
////////////////////////////////////////
{
//
// (entity_debug_modes mode, entity_debug_args arg, entity *en, float_types type)
//
float_types
type;
type = va_arg (pargs, float_types);
debug_log_text (mode, NULL, "float type = %s", get_float_type_name (type));
break;
}
////////////////////////////////////////
case ENTITY_DEBUG_FLOAT_VALUE:
////////////////////////////////////////
{
//
// (entity_debug_modes mode, entity_debug_args arg, entity *en, float_types type, float value)
//
float_types
type;
float
value;
type = va_arg (pargs, float_types);
value = va_arg (pargs, double);
debug_log_text (mode, en, "%s = %.3f", get_float_type_name (type), value);
break;
}
////////////////////////////////////////
case ENTITY_DEBUG_INT_TYPE:
////////////////////////////////////////
{
//
// (entity_debug_modes mode, entity_debug_args arg, entity *en, int_types type)
//
int_types
type;
type = va_arg (pargs, int_types);
debug_log_text (mode, NULL, "int type = %s", get_int_type_name (type));
break;
}
////////////////////////////////////////
case ENTITY_DEBUG_INT_VALUE:
////////////////////////////////////////
{
//
// (entity_debug_modes mode, entity_debug_args arg, entity *en, int_types type, int value)
//
int_types
type;
int
value;
type = va_arg (pargs, int_types);
value = va_arg (pargs, int);
debug_log_text (mode, en, "%s = %d", get_int_type_name (type), value);
break;
}
////////////////////////////////////////
case ENTITY_DEBUG_KILL:
////////////////////////////////////////
{
//
// (entity_debug_modes mode, entity_debug_args arg, entity *en)
//
debug_log_text (mode, en, "kill");
break;
}
////////////////////////////////////////
case ENTITY_DEBUG_LIST_TYPE:
////////////////////////////////////////
{
//
// (entity_debug_modes mode, entity_debug_args arg, entity *en, list_types type)
//
list_types
type;
type = va_arg (pargs, list_types);
debug_log_text (mode, NULL, "list type = %s", get_list_type_name (type));
break;
}
////////////////////////////////////////
case ENTITY_DEBUG_LIST_TYPE_CHILD_PRED:
////////////////////////////////////////
{
//
// (entity_debug_modes mode, entity_debug_args arg, entity *en, list_types type, entity *child_pred)
//
list_types
type;
entity
*child_pred;
int
index;
type = va_arg (pargs, list_types);
child_pred = va_arg (pargs, entity *);
index = get_local_entity_safe_index (child_pred);
debug_log_text (mode, en, "%s child pred index = %d", get_list_type_name (type), index);
break;
}
////////////////////////////////////////
case ENTITY_DEBUG_LIST_TYPE_CHILD_SUCC:
////////////////////////////////////////
{
//
// (entity_debug_modes mode, entity_debug_args arg, entity *en, list_types type, entity *child_succ)
//
list_types
type;
entity
*child_succ;
int
index;
type = va_arg (pargs, list_types);
child_succ = va_arg (pargs, entity *);
index = get_local_entity_safe_index (child_succ);
debug_log_text (mode, en, "%s child succ index = %d", get_list_type_name (type), index);
break;
}
////////////////////////////////////////
case ENTITY_DEBUG_LIST_TYPE_FIRST_CHILD:
////////////////////////////////////////
{
//
// (entity_debug_modes mode, entity_debug_args arg, entity *en, list_types type, entity *first_child)
//
list_types
type;
entity
*first_child;
int
index;
type = va_arg (pargs, list_types);
first_child = va_arg (pargs, entity *);
index = get_local_entity_safe_index (first_child);
debug_log_text (mode, en, "%s first child index = %d", get_list_type_name (type), index);
break;
}
////////////////////////////////////////
case ENTITY_DEBUG_LIST_TYPE_PARENT:
////////////////////////////////////////
{
//
// (entity_debug_modes mode, entity_debug_args arg, entity *en, list_types type, entity *parent)
//
list_types
type;
entity
*parent;
int
index;
type = va_arg (pargs, list_types);
parent = va_arg (pargs, entity *);
index = get_local_entity_safe_index (parent);
debug_log_text (mode, en, "%s parent index = %d", get_list_type_name (type), index);
break;
}
////////////////////////////////////////
case ENTITY_DEBUG_PTR_TYPE:
////////////////////////////////////////
{
//
// (entity_debug_modes mode, entity_debug_args arg, entity *en, ptr_types type)
//
ptr_types
type;
type = va_arg (pargs, ptr_types);
debug_log_text (mode, NULL, "ptr type = %s", get_ptr_type_name (type));
break;
}
////////////////////////////////////////
case ENTITY_DEBUG_PTR_VALUE:
////////////////////////////////////////
{
//
// (entity_debug_modes mode, entity_debug_args arg, entity *en, ptr_types type, void *ptr)
//
ptr_types
type;
void
*ptr;
type = va_arg (pargs, ptr_types);
ptr = va_arg (pargs, void *);
debug_log_text (mode, en, "%s = 0x%x", get_ptr_type_name (type), ptr);
break;
}
////////////////////////////////////////
case ENTITY_DEBUG_STRING_TYPE:
////////////////////////////////////////
{
//
// (entity_debug_modes mode, entity_debug_args arg, entity *en, string_types type)
//
string_types
type;
type = va_arg (pargs, string_types);
debug_log_text (mode, NULL, "string type = %s", get_string_type_name (type));
break;
}
////////////////////////////////////////
case ENTITY_DEBUG_STRING:
////////////////////////////////////////
{
//
// (entity_debug_modes mode, entity_debug_args arg, entity *en, string_types type, char *s)
//
string_types
type;
char
*s;
type = va_arg (pargs, string_types);
s = va_arg (pargs, char *);
ASSERT (s);
debug_log_text (mode, en, "%s = %s", get_string_type_name (type), s);
break;
}
////////////////////////////////////////
case ENTITY_DEBUG_VEC3D_TYPE:
////////////////////////////////////////
{
//
// (entity_debug_modes mode, entity_debug_args arg, entity *en, vec3d_types type)
//
vec3d_types
type;
type = va_arg (pargs, vec3d_types);
debug_log_text (mode, NULL, "vec3d type = %s", get_vec3d_type_name (type));
break;
}
////////////////////////////////////////
case ENTITY_DEBUG_VEC3D:
////////////////////////////////////////
{
//
// (entity_debug_modes mode, entity_debug_args arg, entity *en, vec3d_types type, vec3d *v)
//
vec3d_types
type;
vec3d
*v;
type = va_arg (pargs, vec3d_types);
v = va_arg (pargs, vec3d *);
ASSERT (v);
if (type == VEC3D_TYPE_POSITION)
{
int
x_sec,
z_sec;
get_x_sector (x_sec, v->x);
get_z_sector (z_sec, v->z);
debug_log_text (mode, en, "%s = (x = %.3f, y = %.3f, z = %.3f, x sec = %d, z sec = %d)", get_vec3d_type_name (type), v->x, v->y, v->z, x_sec, z_sec);
}
else
{
debug_log_text (mode, en, "%s = (x = %.3f, y = %.3f, z = %.3f)", get_vec3d_type_name (type), v->x, v->y, v->z);
}
break;
}
////////////////////////////////////////
default:
////////////////////////////////////////
{
debug_fatal ("Invalid entity debug arg = %d", arg);
break;
}
}
va_end (pargs);
}
void draw_3d_lightning_strike ( lightning_strike *strike )
{
vertex
*polygon,
*vert,
quad[4];
float
heading,
width,
width_sin,
width_cos;
vec3d
relative_position;
int
outcode,
outcode2;
screen
*texture;
texture = system_textures[ texture_animations[lightning_strike_animation].texture_indices[strike->current_frame_number] ];
heading = get_heading_from_attitude_matrix ( visual_3d_vp->attitude );
width = 3000;
width_sin = width * sin ( -heading );
width_cos = width * cos ( -heading );
quad[0].next_vertex = &quad[1];
quad[1].next_vertex = &quad[2];
quad[2].next_vertex = &quad[3];
quad[3].next_vertex = NULL;
quad[0].x = width_cos;
quad[0].z = width_sin;
quad[0].y = 0;
quad[0].u = 0;
quad[0].v = 0;
quad[3].x = -width_cos;
quad[3].z = -width_sin;
quad[3].y = 0;
quad[3].u = 1;
quad[3].v = 0;
quad[2].x = -width_cos;
quad[2].z = -width_sin;
quad[2].y = - ( strike->position.y - strike->ground_height );
quad[2].u = 1;
quad[2].v = 1;
quad[1].x = width_cos;
quad[1].z = width_sin;
quad[1].y = - ( strike->position.y - strike->ground_height );
quad[1].u = 0;
quad[1].v = 1;
polygon = quad;
//
// Calculate the relative position of the lightning strike
//
relative_position.x = ( ( strike->position.x - visual_3d_vp->x ) * visual_3d_vp->xv.x +
( strike->position.y - visual_3d_vp->y ) * visual_3d_vp->xv.y +
( strike->position.z - visual_3d_vp->z ) * visual_3d_vp->xv.z );
relative_position.y = ( ( strike->position.x - visual_3d_vp->x ) * visual_3d_vp->yv.x +
( strike->position.y - visual_3d_vp->y ) * visual_3d_vp->yv.y +
( strike->position.z - visual_3d_vp->z ) * visual_3d_vp->yv.z );
relative_position.z = ( ( strike->position.x - visual_3d_vp->x ) * visual_3d_vp->zv.x +
( strike->position.y - visual_3d_vp->y ) * visual_3d_vp->zv.y +
( strike->position.z - visual_3d_vp->z ) * visual_3d_vp->zv.z );
{
//
// Rotate the polygon around to the users viewpoint
//
vert = polygon;
rotation_3d[0][0] = ( visual_3d_vp->xv.x );
rotation_3d[0][1] = ( visual_3d_vp->yv.x );
rotation_3d[0][2] = ( visual_3d_vp->zv.x );
rotation_3d[1][0] = ( visual_3d_vp->xv.y );
rotation_3d[1][1] = ( visual_3d_vp->yv.y );
rotation_3d[1][2] = ( visual_3d_vp->zv.y );
rotation_3d[2][0] = ( visual_3d_vp->xv.z );
rotation_3d[2][1] = ( visual_3d_vp->yv.z );
rotation_3d[2][2] = ( visual_3d_vp->zv.z );
outcode = 0;
outcode2 = CLIP_LEFT | CLIP_RIGHT | CLIP_TOP | CLIP_BOTTOM | CLIP_HITHER | CLIP_YONDER;
clip_3d_coord = 0;
while ( vert )
{
float
x,
y,
z;
x = vert->x * rotation_3d[0][0] + vert->y * rotation_3d[1][0] + vert->z * rotation_3d[2][0] + relative_position.x;
y = vert->x * rotation_3d[0][1] + vert->y * rotation_3d[1][1] + vert->z * rotation_3d[2][1] + relative_position.y;
z = vert->x * rotation_3d[0][2] + vert->y * rotation_3d[1][2] + vert->z * rotation_3d[2][2] + relative_position.z;
x *= active_3d_environment->screen_i_scale;
y *= active_3d_environment->screen_j_scale;
if ( *( ( int * ) &z ) >= *( ( int * ) &clip_hither ) )
{
float
q,
i,
j;
float
oxmax,
oxmin,
oymax,
oymin;
int
ixmax,
ixmin,
iymax,
iymin;
q = 1.0 / z;
vert->x = x;
vert->y = y;
vert->z = z;
vert->q = q;
i = ( x * q );
j = ( y * q );
vert->j = active_3d_environment->y_origin - j;
vert->i = active_3d_environment->x_origin + i;
oxmax = active_viewport.x_max - vert->i;
oxmin = vert->i - active_viewport.x_min;
oymax = active_viewport.y_max - vert->j;
oymin = vert->j - active_viewport.y_min;
ixmax = *( ( int * ) &oxmax );
ixmin = *( ( int * ) &oxmin );
iymax = *( ( int * ) &oymax );
iymin = *( ( int * ) &oymin );
vert->outcode = generate_lookup_outcode ( ixmin, iymin, ixmax, iymax );
outcode |= vert->outcode;
outcode2 &= vert->outcode;
}
else
{
vert->outcode = CLIP_HITHER;
vert->z = z;
vert->x = x;
vert->y = y;
outcode |= vert->outcode;
outcode2 &= vert->outcode;
}
vert = vert->next_vertex;
}
if ( outcode2 )
{
return;
}
if ( outcode & CLIP_HITHER )
{
polygon = hither_clip_3d_polygon ( polygon, &outcode );
if ( !polygon )
{
return;
}
}
if ( outcode )
{
apply_perspective_to_polygon_texture ( polygon );
polygon = clip_3d_polygon ( polygon, outcode );
if ( !polygon )
{
return;
}
remove_perspective_from_polygon_texture ( polygon );
}
{
real_colour
colour,
specular;
set_d3d_alpha_fog_zbuffer ( TRUE, FALSE, TRUE, FALSE );
set_d3d_texture ( 0, texture );
set_d3d_texture_stage_state ( 0, D3DTSS_COLOROP, D3DTOP_MODULATE );
set_d3d_texture_stage_state ( 1, D3DTSS_COLOROP, D3DTOP_DISABLE );
set_d3d_int_state ( D3DRENDERSTATE_SRCBLEND, D3DBLEND_ONE );
set_d3d_int_state ( D3DRENDERSTATE_DESTBLEND, D3DBLEND_ONE );
set_d3d_texture_stage_state ( 0, D3DTSS_ADDRESSU, D3DTADDRESS_CLAMP );
set_d3d_texture_stage_state ( 0, D3DTSS_ADDRESSV, D3DTADDRESS_CLAMP );
set_d3d_texture_stage_state ( 0, D3DTSS_MAGFILTER, D3DTFG_LINEAR );
set_d3d_texture_stage_state ( 0, D3DTSS_MINFILTER, D3DTFN_LINEAR );
set_d3d_texture_stage_state ( 0, D3DTSS_MIPFILTER, D3DTFP_POINT );
colour.red = 255;
colour.green = 255;
colour.blue = 255;
colour.alpha = 255;
specular.colour = 0;
draw_wbuffered_flat_shaded_textured_polygon ( polygon, colour, specular );
}
}
}
static void draw_2d_eo_display (eo_params *eo, target_acquisition_systems system, int damaged, int valid_3d)
{
const char
*s;
char
buffer[200];
int
heading_readout;
float
width,
heading,
marker_position,
target_range = 0.0,
y_adjust,
i,
j,
x,
y;
entity
*source,
*target;
vec3d
*source_position,
target_point;
viewpoint
tmp;
object_3d_visibility
visibility;
ASSERT (eo);
source = get_gunship_entity ();
source_position = get_local_entity_vec3d_ptr (source, VEC3D_TYPE_POSITION);
target = get_local_entity_parent (source, LIST_TYPE_TARGET);
target_range = get_range_to_target();
////////////////////////////////////////
//
// text
//
////////////////////////////////////////
set_mono_font_colour (MFD_EO_TEXT_COLOUR);
set_mono_font_type (MONO_FONT_TYPE_7X12);
//
// sensor type
//
y_adjust = 5.0;
set_2d_mono_font_position (-1.0, 1.0);
set_mono_font_rel_position (1.0, y_adjust);
switch (system)
{
case TARGET_ACQUISITION_SYSTEM_FLIR:
{
print_mono_font_string ("FLIR");
break;
}
case TARGET_ACQUISITION_SYSTEM_LLLTV:
{
print_mono_font_string ("LLLTV");
break;
}
case TARGET_ACQUISITION_SYSTEM_PERISCOPE:
{
print_mono_font_string ("SCOPE");
break;
}
default:
{
print_mono_font_string ("XXX");
break;
}
}
//
// damaged
//
if (damaged)
{
draw_2d_line (-0.5, -0.5, 0.5, 0.5, MFD_COLOUR1);
draw_2d_line ( 0.5, -0.5, -0.5, 0.5, MFD_COLOUR1);
return;
}
//
// heading
//
heading = get_heading_from_attitude_matrix (eo_vp.attitude);
if (heading < 0.0)
{
heading += rad (360.0);
}
heading_readout = (int) deg (heading);
if (heading_readout == 0)
{
heading_readout = 360;
}
sprintf (buffer, "%d", heading_readout);
width = get_mono_font_string_width (buffer);
set_2d_mono_font_position (0.0, 1.0);
set_mono_font_rel_position ((-width * 0.5) + 1.0, y_adjust);
print_mono_font_string (buffer);
// airspeed
sprintf(buffer, "%+04.0f", current_flight_dynamics->indicated_airspeed.value);
set_2d_mono_font_position (-1.0, 1.0);
set_mono_font_rel_position(1.0, 18.0);
print_mono_font_string(buffer);
// altitude
if (current_flight_dynamics->radar_altitude.value < 300.0)
{
sprintf(buffer, "R%03.0f", current_flight_dynamics->radar_altitude.value);
set_2d_mono_font_position (1.0, 1.0);
set_mono_font_rel_position(-get_mono_font_string_width(buffer) - 2.0, 18.0);
print_mono_font_string(buffer);
}
//
// low light
//
if (eo_low_light)
{
y_adjust = 32.0;
set_2d_mono_font_position (-1.0, 1.0);
set_mono_font_rel_position (1.0, y_adjust);
print_mono_font_string ("LO LIGHT");
}
//
// field of view
//
switch (eo->field_of_view)
{
case EO_FOV_NARROW:
case EO_FOV_MEDIUM:
{
s = "NARROW";
break;
}
case EO_FOV_WIDE:
{
s = "WIDE";
break;
}
default:
{
s = "XXX";
break;
}
}
width = get_mono_font_string_width (s);
width += 2.0;
y_adjust = 5.0;
set_2d_mono_font_position (1.0, 1.0);
set_mono_font_rel_position (-width, y_adjust);
print_mono_font_string (s);
//
// target name
//
y_adjust = -12.0;
s = get_target_display_name (target, buffer, TRUE);
if (s)
{
set_2d_mono_font_position (-1.0, -1.0);
set_mono_font_rel_position (1.0, y_adjust);
print_mono_font_string (s);
}
//
// target range
//
if (target_range > 0.0)
{
sprintf (buffer, "%.1fKm", target_range * (1.0 / 1000.0));
width = get_mono_font_string_width (buffer);
set_2d_mono_font_position (1.0, -1.0);
width += 2.0;
set_mono_font_rel_position (-width, y_adjust);
print_mono_font_string (buffer);
}
//
// locked
//
if (eo_is_locked())
{
y_adjust = -25.0;
set_2d_mono_font_position (-1.0, -1.0);
set_mono_font_rel_position (1.0, y_adjust);
print_mono_font_string ("LOCKED");
}
// Jabberwock 031107 Designated targets
target = get_local_entity_parent (get_gunship_entity (), LIST_TYPE_TARGET);
if (target && get_local_entity_parent (target, LIST_TYPE_DESIGNATED_TARGET))
{
y_adjust = -25.0;
width = get_mono_font_string_width ("MARKED");
set_2d_mono_font_position (1.0, -1.0);
set_mono_font_rel_position (-width - 1.0, y_adjust);
print_mono_font_string ("MARKED");
}
// Jabberwock 031107 ends
// added ground stabi by GCsDriver 08-12-2007
//
// 030418 loke
// draw an indication if ground stablisation is enabled
//
if (eo_ground_stabilised)
{
y_adjust = -38.0;
width = get_mono_font_string_width ("S");
set_2d_mono_font_position (1.0, -1.0);
set_mono_font_rel_position (-width, y_adjust);
print_mono_font_string ("S");
}
////////////////////////////////////////
//
// line graphics
//
////////////////////////////////////////
//
// datum
//
draw_2d_line (-0.075, 0.0, -0.025, 0.0, MFD_EO_TEXT_COLOUR);
draw_2d_line (0.035, 0.0, 0.08, 0.0, MFD_EO_TEXT_COLOUR);
draw_2d_line (0.0, -0.075, 0.0, -0.025, MFD_EO_TEXT_COLOUR);
draw_2d_line (0.0, 0.035, 0.0, 0.08, MFD_EO_TEXT_COLOUR);
//
// azimuth
//
draw_2d_line (-0.5, 0.8, 0.5, 0.8, MFD_EO_TEXT_COLOUR);
marker_position = (eo_azimuth / eo_max_azimuth) * 0.5;
draw_2d_line (-0.5, 0.8 - 0.02, -0.5, 0.8 + 0.02, MFD_EO_TEXT_COLOUR);
draw_2d_line (0.5, 0.8 - 0.02, 0.5, 0.8 + 0.02, MFD_EO_TEXT_COLOUR);
draw_2d_line (0.0, 0.8 - 0.01, 0.0, 0.8 + 0.01, MFD_EO_TEXT_COLOUR);
draw_2d_mono_sprite (large_azimuth_marker, marker_position, 0.8, MFD_EO_TEXT_COLOUR);
//
// elevation
//
draw_2d_line (-0.9, 0.1, -0.9, -0.3, MFD_EO_TEXT_COLOUR);
if (eo_elevation < 0.0)
{
marker_position = (eo_elevation / eo_min_elevation) * -0.3;
}
else
{
marker_position = (eo_elevation / eo_max_elevation) * 0.1;
}
draw_2d_line (-0.9 - 0.02, 0.1, -0.9 + 0.02, 0.1, MFD_EO_TEXT_COLOUR);
draw_2d_line (-0.9 - 0.02, -0.3, -0.9 + 0.02, -0.3, MFD_EO_TEXT_COLOUR);
draw_2d_line (-0.9 - 0.01, 0.0, -0.9 + 0.01, 0.0, MFD_EO_TEXT_COLOUR);
draw_2d_mono_sprite (large_elevation_marker, -0.9, marker_position, MFD_EO_TEXT_COLOUR);
//
// range
//
draw_2d_line (0.9, 0.0, 0.9, -0.5, MFD_EO_TEXT_COLOUR);
draw_2d_line (0.9, 0.000, 0.9 + 0.02, 0.000, MFD_EO_TEXT_COLOUR);
draw_2d_line (0.9, -0.025, 0.9 + 0.01, -0.025, MFD_EO_TEXT_COLOUR);
draw_2d_line (0.9, -0.050, 0.9 + 0.01, -0.050, MFD_EO_TEXT_COLOUR);
draw_2d_line (0.9, -0.075, 0.9 + 0.01, -0.075, MFD_EO_TEXT_COLOUR);
draw_2d_line (0.9, -0.100, 0.9 + 0.02, -0.100, MFD_EO_TEXT_COLOUR);
draw_2d_line (0.9, -0.125, 0.9 + 0.01, -0.125, MFD_EO_TEXT_COLOUR);
draw_2d_line (0.9, -0.150, 0.9 + 0.01, -0.150, MFD_EO_TEXT_COLOUR);
draw_2d_line (0.9, -0.175, 0.9 + 0.01, -0.175, MFD_EO_TEXT_COLOUR);
draw_2d_line (0.9, -0.200, 0.9 + 0.02, -0.200, MFD_EO_TEXT_COLOUR);
draw_2d_line (0.9, -0.225, 0.9 + 0.01, -0.225, MFD_EO_TEXT_COLOUR);
draw_2d_line (0.9, -0.250, 0.9 + 0.01, -0.250, MFD_EO_TEXT_COLOUR);
draw_2d_line (0.9, -0.275, 0.9 + 0.01, -0.275, MFD_EO_TEXT_COLOUR);
draw_2d_line (0.9, -0.300, 0.9 + 0.02, -0.300, MFD_EO_TEXT_COLOUR);
draw_2d_line (0.9, -0.400, 0.9 + 0.02, -0.400, MFD_EO_TEXT_COLOUR);
draw_2d_line (0.9, -0.500, 0.9 + 0.02, -0.500, MFD_EO_TEXT_COLOUR);
if (target_range > 0.0)
{
marker_position = (min (target_range, eo_max_visual_range) / eo_max_visual_range) * -0.5;
draw_2d_mono_sprite (large_range_marker, 0.9, marker_position, MFD_EO_TEXT_COLOUR);
}
// horizon
{
float roll = get_local_entity_float_value (get_gunship_entity (), FLOAT_TYPE_ROLL);
float pitch = get_local_entity_float_value (get_gunship_entity (), FLOAT_TYPE_PITCH);
float pitch_adjustment = -pitch / rad(90) * 0.5;
draw_2d_half_thick_line(-0.35, 0.0, -0.3, 0.0, MFD_EO_TEXT_COLOUR);
draw_2d_half_thick_line( 0.35, 0.0, 0.3, 0.0, MFD_EO_TEXT_COLOUR);
// draw datum
set_2d_instance_rotation (mfd_env, roll);
draw_2d_half_thick_line(-0.75, pitch_adjustment, -0.4, pitch_adjustment, MFD_EO_TEXT_COLOUR);
draw_2d_half_thick_line( 0.75, pitch_adjustment, 0.4, pitch_adjustment, MFD_EO_TEXT_COLOUR);
reset_2d_instance (mfd_env);
}
//
// target gates
//
if (valid_3d)
{
if (target)
{
if (!((!d3d_can_render_to_texture) && (!draw_large_mfd)))
{
tmp = main_vp;
main_vp = eo_vp;
get_local_entity_target_point (target, &target_point);
visibility = get_position_3d_screen_coordinates (&target_point, &i, &j);
if ((visibility == OBJECT_3D_COMPLETELY_VISIBLE) || (visibility == OBJECT_3D_PARTIALLY_VISIBLE))
{
i -= i_translate_3d;
j -= j_translate_3d;
i *= i_scale_3d;
j *= j_scale_3d;
get_2d_world_position (i, j, &x, &y);
draw_2d_line (x - 0.20, y + 0.20, x - 0.15, y + 0.20, MFD_EO_TEXT_COLOUR);
draw_2d_line (x + 0.20, y + 0.20, x + 0.15, y + 0.20, MFD_EO_TEXT_COLOUR);
draw_2d_line (x - 0.20, y - 0.20, x - 0.15, y - 0.20, MFD_EO_TEXT_COLOUR);
draw_2d_line (x + 0.20, y - 0.20, x + 0.15, y - 0.20, MFD_EO_TEXT_COLOUR);
draw_2d_line (x - 0.20, y + 0.20, x - 0.20, y + 0.15, MFD_EO_TEXT_COLOUR);
draw_2d_line (x - 0.20, y - 0.20, x - 0.20, y - 0.15, MFD_EO_TEXT_COLOUR);
draw_2d_line (x + 0.20, y + 0.20, x + 0.20, y + 0.15, MFD_EO_TEXT_COLOUR);
draw_2d_line (x + 0.20, y - 0.20, x + 0.20, y - 0.15, MFD_EO_TEXT_COLOUR);
}
main_vp = tmp;
}
}
}
}
void ship_vehicle_death_movement (entity *en)
{
ship_vehicle
*raw;
float
speed,
heading,
pitch,
roll;
vec3d
*pos,
*velocity,
new_pos;
raw = get_local_entity_data (en);
//
// work out new position
//
velocity = get_local_entity_vec3d_ptr (en, VEC3D_TYPE_MOTION_VECTOR);
pos = get_local_entity_vec3d_ptr (en, VEC3D_TYPE_POSITION);
new_pos.x = pos->x + (velocity->x * get_entity_movement_delta_time());
new_pos.y = pos->y + (velocity->y * get_entity_movement_delta_time());
new_pos.z = pos->z + (velocity->z * get_entity_movement_delta_time());
//
// update velocity
//
velocity->x -= (velocity->x * 0.2 * get_entity_movement_delta_time ());
velocity->z -= (velocity->z * 0.2 * get_entity_movement_delta_time ());
velocity->y -= (SHIP_SINK_RATE * get_entity_movement_delta_time ());
speed = get_3d_vector_magnitude (velocity);
set_local_entity_float_value (en, FLOAT_TYPE_VELOCITY, speed);
//
// update attitude
//
heading = get_heading_from_attitude_matrix (raw->vh.mob.attitude);
pitch = get_pitch_from_attitude_matrix (raw->vh.mob.attitude);
pitch += (SHIP_SINK_DELTA_PITCH_RATE * get_entity_movement_delta_time());
roll = get_roll_from_attitude_matrix (raw->vh.mob.attitude);
roll += (SHIP_SINK_DELTA_ROLL_RATE * get_entity_movement_delta_time());
get_3d_transformation_matrix (raw->vh.mob.attitude, heading, pitch, roll);
//
// set new position
//
set_local_entity_vec3d (en, VEC3D_TYPE_POSITION, &new_pos);
clear_ship_fires (en, ENTITY_SUB_TYPE_EFFECT_SMOKE_LIST_FIRE);
clear_ship_fires (en, ENTITY_SUB_TYPE_EFFECT_SMOKE_LIST_EXPLOSION_TRAIL);
//
// remove ship if totally obscured (i.e. sunk)
//
if (get_comms_model () == COMMS_MODEL_SERVER)
{
struct OBJECT_3D_BOUNDS
*bounding_box;
vec3d
d;
float
obscured_altitude;
bounding_box = get_object_3d_bounding_box (get_local_entity_int_value (en, INT_TYPE_OBJECT_3D_SHAPE));
d.x = bounding_box->xmax - bounding_box->xmin;
d.y = bounding_box->ymax - bounding_box->ymin;
d.z = bounding_box->zmax - bounding_box->zmin;
obscured_altitude = -(0.5 * get_3d_vector_magnitude (&d));
if (new_pos.y < obscured_altitude)
{
//
// ship is no longer visible
//
destroy_client_server_entity_family (en);
}
}
}
void ship_vehicle_movement (entity *en)
{
ship_vehicle
*raw;
entity
*guide,
*current_waypoint;
vec3d
wp_pos,
wp_vec,
new_pos;
float
roll,
pitch,
heading,
sqr_range,
turn_rate,
required_heading,
delta_heading,
current_velocity,
new_velocity;
raw = get_local_entity_data (en);
//
// abort if mobile is not moving (i.e. landed, or dead)
//
if (!get_local_entity_int_value (en, INT_TYPE_MOBILE_MOVING))
{
return;
}
//
// abort if the mobile has no PRIMARY guide (also stops ships from moving if just engaging)
//
guide = get_local_entity_primary_guide (en);
if (!guide)
{
return;
}
current_waypoint = get_local_entity_parent (guide, LIST_TYPE_CURRENT_WAYPOINT);
ASSERT (current_waypoint);
current_velocity = raw->vh.mob.velocity;
//
// GET WAYPOINT POSITION
//
ship_movement_get_waypoint_position (en, &wp_pos);
wp_vec.x = wp_pos.x - raw->vh.mob.position.x;
wp_vec.y = 0;
wp_vec.z = wp_pos.z - raw->vh.mob.position.z;
sqr_range = ((wp_vec.x * wp_vec.x) + (wp_vec.z * wp_vec.z));
#if DEBUG_MODULE
create_vectored_debug_3d_object (&wp_pos, (vec3d *) &raw->vh.mob.attitude [1], OBJECT_3D_RED_ARROW, 0, 0.20);
#endif
// ????
if (fabs (sqr_range) < 1 * CENTIMETRE)
{
wp_vec.z = 0;
wp_vec.y = 0;
wp_vec.z = 1;
}
////////////////////////////////////////
//
// angles
//
////////////////////////////////////////
// heading
normalise_3d_vector (&wp_vec);
heading = get_heading_from_attitude_matrix (raw->vh.mob.attitude);
required_heading = atan2 (wp_vec.x, wp_vec.z);
{
float
angle,
range,
v;
range = sqrt (sqr_range);
v = sqrt (0.5 * range * vehicle_database [raw->vh.mob.sub_type].g_max);
angle = ((raw->vh.mob.attitude [2][0] * wp_vec.x) + (raw->vh.mob.attitude [2][2] * wp_vec.z));
if (angle < 0.707) // 45 degs.
{
// wp behind ship
#if DEBUG_MODULE
debug_log ("SH_MOVE: ship cannot reach wp at vel %f m/s (max v %f), range %f, g %f", raw->vh.mob.velocity, v, range, vehicle_database [raw->vh.mob.sub_type].g_max);
#endif
new_velocity = bound (v, 0.0, get_local_entity_float_value (guide, FLOAT_TYPE_VELOCITY));
}
else
{
#if DEBUG_MODULE
debug_log ("SH_MOVE: ship can reach wp at vel %f m/s (max v %f), range %f, g %f", raw->vh.mob.velocity, v, range, vehicle_database [raw->vh.mob.sub_type].g_max);
#endif
new_velocity = get_local_entity_float_value (guide, FLOAT_TYPE_VELOCITY);
}
}
turn_rate = 0.0;
if (raw->vh.mob.velocity != 0.0)
{
turn_rate = fabs (vehicle_database [raw->vh.mob.sub_type].g_max / raw->vh.mob.velocity);
}
delta_heading = required_heading - heading;
if (delta_heading <= -PI)
{
delta_heading += PI2;
}
if (delta_heading >= PI)
{
delta_heading -= PI2;
}
delta_heading = bound (delta_heading, -turn_rate, turn_rate);
heading += delta_heading * get_entity_movement_delta_time ();
pitch = 0.0;
roll = 0.0;
////////////////////////////////////////
//
// attitude
//
////////////////////////////////////////
get_3d_transformation_matrix (raw->vh.mob.attitude, heading, rad (pitch), rad (roll));
////////////////////////////////////////
//
// velocity
//
////////////////////////////////////////
{
float
maximum_acceleration,
required_acceleration;
required_acceleration = (new_velocity - raw->vh.mob.velocity);
maximum_acceleration = get_local_entity_float_value (en, FLOAT_TYPE_MAX_ACCELERATION);
raw->vh.mob.velocity += min (required_acceleration, maximum_acceleration) * get_entity_movement_delta_time ();
}
////////////////////////////////////////
//
// position
//
////////////////////////////////////////
new_pos.x = raw->vh.mob.position.x + (raw->vh.mob.velocity * raw->vh.mob.zv.x * get_entity_movement_delta_time ());
new_pos.y = 0.0;
new_pos.z = raw->vh.mob.position.z + (raw->vh.mob.velocity * raw->vh.mob.zv.z * get_entity_movement_delta_time ());
bound_position_to_map_volume (&new_pos);
//
// Calculate motion vector for view system
//
raw->vh.mob.motion_vector.x = (new_pos.x - raw->vh.mob.position.x) * get_one_over_delta_time ();
raw->vh.mob.motion_vector.y = 0.0;
raw->vh.mob.motion_vector.z = (new_pos.z - raw->vh.mob.position.z) * get_one_over_delta_time ();
new_pos.y = 0.0;
set_local_entity_vec3d (en, VEC3D_TYPE_POSITION, &new_pos);
}