/*
* Portions of this file are copyright Rebirth contributors and licensed as
* described in COPYING.txt.
* Portions of this file are copyright Parallax Software and licensed
* according to the Parallax license below.
* See COPYING.txt for license details.
THE COMPUTER CODE CONTAINED HEREIN IS THE SOLE PROPERTY OF PARALLAX
SOFTWARE CORPORATION ("PARALLAX"). PARALLAX, IN DISTRIBUTING THE CODE TO
END-USERS, AND SUBJECT TO ALL OF THE TERMS AND CONDITIONS HEREIN, GRANTS A
ROYALTY-FREE, PERPETUAL LICENSE TO SUCH END-USERS FOR USE BY SUCH END-USERS
IN USING, DISPLAYING, AND CREATING DERIVATIVE WORKS THEREOF, SO LONG AS
SUCH USE, DISPLAY OR CREATION IS FOR NON-COMMERCIAL, ROYALTY OR REVENUE
FREE PURPOSES. IN NO EVENT SHALL THE END-USER USE THE COMPUTER CODE
CONTAINED HEREIN FOR REVENUE-BEARING PURPOSES. THE END-USER UNDERSTANDS
AND AGREES TO THE TERMS HEREIN AND ACCEPTS THE SAME BY USE OF THIS FILE.
COPYRIGHT 1993-1999 PARALLAX SOFTWARE CORPORATION. ALL RIGHTS RESERVED.
*/
/*
*
* Header file for stuff moved from segment.c to gameseg.c.
*
*/
#pragma once
#include "pstypes.h"
#include "maths.h"
#include "vecmat.h"
#include "segment.h"
#ifdef __cplusplus
#include <utility>
#include "dxxsconf.h"
#include "dsx-ns.h"
#include <array>
namespace dcx {
struct segmasks
{
short facemask; //which faces sphere pokes through (12 bits)
sbyte sidemask; //which sides sphere pokes through (6 bits)
sbyte centermask; //which sides center point is on back of (6 bits)
};
struct segment_depth_array_t : public std::array<ubyte, MAX_SEGMENTS> {};
struct side_vertnum_list_t : std::array<unsigned, 4> {};
struct vertex_array_list_t : std::array<unsigned, 6> {};
struct vertex_vertnum_pair
{
unsigned vertex, vertnum;
};
using vertex_vertnum_array_list = std::array<vertex_vertnum_pair, 6>;
#ifdef dsx
__attribute_warn_unused_result
uint_fast32_t find_connect_side(vcsegidx_t base_seg, const shared_segment &con_seg);
void compute_center_point_on_side(fvcvertptr &vcvertptr, vms_vector &vp, const shared_segment &sp, unsigned side);
static inline vms_vector compute_center_point_on_side(fvcvertptr &vcvertptr, const shared_segment &sp, const unsigned side)
{
vms_vector v;
return compute_center_point_on_side(vcvertptr, v, sp, side), v;
}
void compute_segment_center(fvcvertptr &vcvertptr, vms_vector &vp, const shared_segment &sp);
static inline vms_vector compute_segment_center(fvcvertptr &vcvertptr, const shared_segment &sp)
{
vms_vector v;
compute_segment_center(vcvertptr, v, sp);
return v;
}
// Fill in array with four absolute point numbers for a given side
void get_side_verts(side_vertnum_list_t &vertlist, const shared_segment &seg, unsigned sidenum);
static inline side_vertnum_list_t get_side_verts(const shared_segment &segnum, const unsigned sidenum)
{
side_vertnum_list_t r;
return get_side_verts(r, segnum, sidenum), r;
}
#endif
}
#ifdef dsx
namespace dsx {
#if defined(DXX_BUILD_DESCENT_II) || DXX_USE_EDITOR
extern int Doing_lighting_hack_flag;
#endif
#if DXX_USE_EDITOR
// Create all vertex lists (1 or 2) for faces on a side.
// Sets:
// num_faces number of lists
// vertices vertices in all (1 or 2) faces
// If there is one face, it has 4 vertices.
// If there are two faces, they both have three vertices, so face #0 is stored in vertices 0,1,2,
// face #1 is stored in vertices 3,4,5.
// Note: these are not absolute vertex numbers, but are relative to the segment
// Note: for triagulated sides, the middle vertex of each trianle is the one NOT
// adjacent on the diagonal edge
uint_fast32_t create_all_vertex_lists(vertex_array_list_t &vertices, const shared_segment &seg, const shared_side &sidep, uint_fast32_t sidenum);
__attribute_warn_unused_result
static inline std::pair<uint_fast32_t, vertex_array_list_t> create_all_vertex_lists(const shared_segment &segnum, const shared_side &sidep, const uint_fast32_t sidenum)
{
vertex_array_list_t r;
const auto &&n = create_all_vertex_lists(r, segnum, sidep, sidenum);
return {n, r};
}
#endif
//like create_all_vertex_lists(), but generate absolute point numbers
uint_fast32_t create_abs_vertex_lists(vertex_array_list_t &vertices, const shared_segment &segnum, const shared_side &sidep, uint_fast32_t sidenum);
__attribute_warn_unused_result
static inline std::pair<uint_fast32_t, vertex_array_list_t> create_abs_vertex_lists(const shared_segment &segnum, const shared_side &sidep, const uint_fast32_t sidenum)
{
vertex_array_list_t r;
const auto &&n = create_abs_vertex_lists(r, segnum, sidep, sidenum);
return {n, r};
}
__attribute_warn_unused_result
static inline std::pair<uint_fast32_t, vertex_array_list_t> create_abs_vertex_lists(const shared_segment &segp, const uint_fast32_t sidenum)
{
return create_abs_vertex_lists(segp, segp.sides[sidenum], sidenum);
}
// -----------------------------------------------------------------------------------
// Like create all vertex lists, but returns the vertnums (relative to
// the side) for each of the faces that make up the side.
// If there is one face, it has 4 vertices.
// If there are two faces, they both have three vertices, so face #0 is stored in vertices 0,1,2,
// face #1 is stored in vertices 3,4,5.
void create_all_vertnum_lists(vertex_vertnum_array_list &vertnums, const shared_segment &seg, const shared_side &sidep, uint_fast32_t sidenum);
__attribute_warn_unused_result
static inline vertex_vertnum_array_list create_all_vertnum_lists(const shared_segment &segnum, const shared_side &sidep, const uint_fast32_t sidenum)
{
vertex_vertnum_array_list r;
return create_all_vertnum_lists(r, segnum, sidep, sidenum), r;
}
}
namespace dcx {
// Given a side, return the number of faces
bool get_side_is_quad(const shared_side &sidep);
struct WALL_IS_DOORWAY_mask_t;
}
namespace dsx {
//returns 3 different bitmasks with info telling if this sphere is in
//this segment. See segmasks structure for info on fields
segmasks get_seg_masks(fvcvertptr &, const vms_vector &checkp, const shared_segment &segnum, fix rad);
//this macro returns true if the segnum for an object is correct
#define check_obj_seg(vcvertptr, obj) (get_seg_masks(vcvertptr, (obj)->pos, vcsegptr((obj)->segnum), 0).centermask == 0)
//Tries to find a segment for a point, in the following way:
// 1. Check the given segment
// 2. Recursively trace through attached segments
// 3. Check all the segmentns
//Returns segnum if found, or -1
imsegptridx_t find_point_seg(const d_level_shared_segment_state &, d_level_unique_segment_state &, const vms_vector &p, imsegptridx_t segnum);
icsegptridx_t find_point_seg(const d_level_shared_segment_state &, const vms_vector &p, icsegptridx_t segnum);
// ----------------------------------------------------------------------------------------------------------
// Determine whether seg0 and seg1 are reachable using wid_flag to go through walls.
// For example, set to WID_RENDPAST_FLAG to see if sound can get from one segment to the other.
// set to WID_FLY_FLAG to see if a robot could fly from one to the other.
// Search up to a maximum depth of max_depth.
// Return the distance.
vm_distance find_connected_distance(const vms_vector &p0, vcsegptridx_t seg0, const vms_vector &p1, vcsegptridx_t seg1, int max_depth, WALL_IS_DOORWAY_mask_t wid_flag);
//create a matrix that describes the orientation of the given segment
void extract_orient_from_segment(fvcvertptr &vcvertptr, vms_matrix &m, const shared_segment &seg);
void validate_segment_all(d_level_shared_segment_state &);
#if DXX_USE_EDITOR
// In segment.c
// Make a just-modified segment valid.
// check all sides to see how many faces they each should have (0,1,2)
// create new vector normals
void validate_segment(fvcvertptr &vcvertptr, vmsegptridx_t sp);
// Extract the forward vector from segment *sp, return in *vp.
// The forward vector is defined to be the vector from the the center of the front face of the segment
// to the center of the back face of the segment.
void extract_forward_vector_from_segment(fvcvertptr &, const shared_segment &sp, vms_vector &vp);
// Extract the right vector from segment *sp, return in *vp.
// The forward vector is defined to be the vector from the the center of the left face of the segment
// to the center of the right face of the segment.
void extract_right_vector_from_segment(fvcvertptr &, const shared_segment &sp, vms_vector &vp);
// Extract the up vector from segment *sp, return in *vp.
// The forward vector is defined to be the vector from the the center of the bottom face of the segment
// to the center of the top face of the segment.
void extract_up_vector_from_segment(fvcvertptr &, const shared_segment &sp, vms_vector &vp);
void create_walls_on_side(fvcvertptr &, shared_segment &sp, unsigned sidenum);
void validate_segment_side(fvcvertptr &, vmsegptridx_t sp, unsigned sidenum);
#endif
void pick_random_point_in_seg(fvcvertptr &vcvertptr, vms_vector &new_pos, const shared_segment &sp);
static inline vms_vector pick_random_point_in_seg(fvcvertptr &vcvertptr, const shared_segment &sp)
{
vms_vector v;
return pick_random_point_in_seg(vcvertptr, v, sp), v;
}
int check_segment_connections(void);
unsigned set_segment_depths(vcsegidx_t start_seg, const std::array<uint8_t, MAX_SEGMENTS> *limit, segment_depth_array_t &depths);
#if defined(DXX_BUILD_DESCENT_I)
static inline void flush_fcd_cache() {}
#elif defined(DXX_BUILD_DESCENT_II)
void flush_fcd_cache();
void apply_all_changed_light(const d_level_shared_destructible_light_state &LevelSharedDestructibleLightState, fvmsegptridx &vmsegptridx);
void set_ambient_sound_flags(void);
#endif
}
#endif
#endif