Subversion Repositories Games.Descent

/*

 * 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.

*/

/*

 *

 * Functions moved from segment.c to make editor separable from game.

 *

 */

#include <algorithm>

#include <cassert>

#include <stdlib.h>

#include <stdio.h>

#include <string.h>     //      for memset()

#include "u_mem.h"

#include "inferno.h"

#include "game.h"

#include "dxxerror.h"

#include "console.h"

#include "vecmat.h"

#include "gameseg.h"

#include "gameseq.h"

#include "wall.h"

#include "fuelcen.h"

#include "textures.h"

#include "fvi.h"

#include "object.h"

#include "byteutil.h"

#include "lighting.h"

#include "mission.h"

#if DXX_USE_EDITOR

#include "editor/editor.h"

#endif

#include "compiler-range_for.h"

#include "d_range.h"

#include "cast_range_result.h"

using std::min;

namespace {

        /* The array can be of any type that can hold values in the range

         * [0, AMBIENT_SEGMENT_DEPTH].

         */

struct segment_lava_depth_array : std::array<uint8_t, MAX_SEGMENTS> {};

struct segment_water_depth_array : std::array<uint8_t, MAX_SEGMENTS> {};

class abs_vertex_lists_predicate

{

        const std::array<unsigned, MAX_VERTICES_PER_SEGMENT> &m_vp;

        const std::array<unsigned, 4> &m_sv;

public:

        abs_vertex_lists_predicate(const shared_segment &seg, const uint_fast32_t sidenum) :

                m_vp(seg.verts), m_sv(Side_to_verts_int[sidenum])

        {

        }

        unsigned operator()(const uint_fast32_t vv) const

        {

                return m_vp[m_sv[vv]];

        }

};

class all_vertnum_lists_predicate : public abs_vertex_lists_predicate

{

public:

        using abs_vertex_lists_predicate::abs_vertex_lists_predicate;

        vertex_vertnum_pair operator()(const uint_fast32_t vv) const

        {

                return {this->abs_vertex_lists_predicate::operator()(vv), static_cast<unsigned>(vv)};

        }

};

struct verts_for_normal

{

        std::array<unsigned, 4> vsorted;

        bool negate_flag;

};

constexpr vm_distance fcd_abort_cache_value{F1_0 * 1000};

constexpr vm_distance fcd_abort_return_value{-1};

}

namespace dcx {

// How far a point can be from a plane, and still be "in" the plane

#define PLANE_DIST_TOLERANCE    250

static uint_fast32_t find_connect_child(const vcsegidx_t base_seg, const std::array<segnum_t, MAX_SIDES_PER_SEGMENT> &children)

{

        const auto &&b = begin(children);

        return std::distance(b, std::find(b, end(children), base_seg));

}

static void compute_center_point_on_side(fvcvertptr &vcvertptr, vms_vector &r, const std::array<unsigned, MAX_VERTICES_PER_SEGMENT> &verts, const unsigned side)

{

        vms_vector vp;

        vm_vec_zero(vp);

        range_for (auto &v, Side_to_verts[side])

                vm_vec_add2(vp, vcvertptr(verts[v]));

        vm_vec_copy_scale(r, vp, F1_0 / 4);

}

static void compute_segment_center(fvcvertptr &vcvertptr, vms_vector &r, const std::array<unsigned, MAX_VERTICES_PER_SEGMENT> &verts)

{

        vms_vector vp;

        vm_vec_zero(vp);

        range_for (auto &v, verts)

                vm_vec_add2(vp, vcvertptr(v));

        vm_vec_copy_scale(r, vp, F1_0 / 8);

}

// ------------------------------------------------------------------------------------------

// Compute the center point of a side of a segment.

//      The center point is defined to be the average of the 4 points defining the side.

void compute_center_point_on_side(fvcvertptr &vcvertptr, vms_vector &vp, const shared_segment &sp, const unsigned side)

{

        compute_center_point_on_side(vcvertptr, vp, sp.verts, side);

}

// ------------------------------------------------------------------------------------------

// Compute segment center.

//      The center point is defined to be the average of the 8 points defining the segment.

void compute_segment_center(fvcvertptr &vcvertptr, vms_vector &vp, const shared_segment &sp)

{

        compute_segment_center(vcvertptr, vp, sp.verts);

}

// -----------------------------------------------------------------------------

//      Given two segments, return the side index in the connecting segment which connects to the base segment

//      Optimized by MK on 4/21/94 because it is a 2% load.

uint_fast32_t find_connect_side(const vcsegidx_t base_seg, const shared_segment &con_seg)

{

        return find_connect_child(base_seg, con_seg.children);

}

// -----------------------------------------------------------------------------------

//      Given a side, return the number of faces

bool get_side_is_quad(const shared_side &sidep)

{

        switch (sidep.get_type())

        {

                case side_type::quad:

                        return true;

                case side_type::tri_02:

                case side_type::tri_13:

                        return false;

                default:

                        throw shared_side::illegal_type(sidep);

        }

}

// Fill in array with four absolute point numbers for a given side

static void get_side_verts(side_vertnum_list_t &vertlist, const std::array<unsigned, MAX_VERTICES_PER_SEGMENT> &vp, const unsigned sidenum)

{

        auto &sv = Side_to_verts[sidenum];

        for (unsigned i = 4; i--;)

                vertlist[i] = vp[sv[i]];

}

void get_side_verts(side_vertnum_list_t &vertlist, const shared_segment &segp, const unsigned sidenum)

{

        get_side_verts(vertlist, segp.verts, sidenum);

}

}

namespace dsx {

__attribute_cold

__noreturn

static void create_vertex_list_from_invalid_side(const shared_segment &segp, const shared_side &sidep)

{

        throw shared_side::illegal_type(segp, sidep);

}

template <typename T, typename V>

static uint_fast32_t create_vertex_lists_from_values(T &va, const shared_segment &segp, const shared_side &sidep, const V &&f0, const V &&f1, const V &&f2, const V &&f3)

{

        const auto type = sidep.get_type();

        if (type == side_type::tri_13)

        {

                va[0] = va[5] = f3;

                va[1] = f0;

                va[2] = va[3] = f1;

                va[4] = f2;

                return 2;

        }

        va[0] = f0;

        va[1] = f1;

        va[2] = f2;

        switch (type)

        {

                case side_type::quad:

                        va[3] = f3;

                        /* Unused, but required to prevent bogus

                         * -Wmaybe-uninitialized in check_segment_connections

                         */

                        va[4] = va[5] = {};

                        DXX_MAKE_MEM_UNDEFINED(&va[4], 2 * sizeof(va[4]));

                        return 1;

                case side_type::tri_02:

                        va[3] = f2;

                        va[4] = f3;

                        va[5] = f0;

                        //IMPORTANT: DON'T CHANGE THIS CODE WITHOUT CHANGING GET_SEG_MASKS()

                        //CREATE_ABS_VERTEX_LISTS(), CREATE_ALL_VERTEX_LISTS(), CREATE_ALL_VERTNUM_LISTS()

                        return 2;

                default:

                        create_vertex_list_from_invalid_side(segp, sidep);

        }

}

template <typename T, typename F>

static inline uint_fast32_t create_vertex_lists_by_predicate(T &va, const shared_segment &segp, const shared_side &sidep, const F &&f)

{

        return create_vertex_lists_from_values(va, segp, sidep, f(0), f(1), f(2), f(3));

}

#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 &segp, const shared_side &sidep, const uint_fast32_t sidenum)

{

        assert(sidenum < Side_to_verts_int.size());

        auto &sv = Side_to_verts_int[sidenum];

        return create_vertex_lists_by_predicate(vertices, segp, sidep, [&sv](const uint_fast32_t vv) {

                return sv[vv];

        });

}

#endif

// -----------------------------------------------------------------------------------

// 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 &segp, const shared_side &sidep, const uint_fast32_t sidenum)

{

        create_vertex_lists_by_predicate(vertnums, segp, sidep, all_vertnum_lists_predicate(segp, sidenum));

}

// -----

// 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 &segp, const shared_side &sidep, const uint_fast32_t sidenum)

{

        return create_vertex_lists_by_predicate(vertices, segp, sidep, abs_vertex_lists_predicate(segp, sidenum));

}

//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 &vcvertptr, const vms_vector &checkp, const shared_segment &seg, const fix rad)

{

        int                     sn,facebit,sidebit;

        segmasks                masks{};

        //check point against each side of segment. return bitmask

        for (sn=0,facebit=sidebit=1;sn<6;sn++,sidebit<<=1) {

                auto &s = seg.sides[sn];

                // Get number of faces on this side, and at vertex_list, store vertices.

                //      If one face, then vertex_list indicates a quadrilateral.

                //      If two faces, then 0,1,2 define one triangle, 3,4,5 define the second.

                const auto v = create_abs_vertex_lists(seg, s, sn);

                const auto &num_faces = v.first;

                const auto &vertex_list = v.second;

                //ok...this is important.  If a side has 2 faces, we need to know if

                //those faces form a concave or convex side.  If the side pokes out,

                //then a point is on the back of the side if it is behind BOTH faces,

                //but if the side pokes in, a point is on the back if behind EITHER face.

                if (num_faces==2) {

                        int     side_count,center_count;

                        const auto vertnum = min(vertex_list[0],vertex_list[2]);

                        const auto &&mvert = vcvertptr(vertnum);

                        auto a = vertex_list[4] < vertex_list[1]

                                ? std::make_pair(vertex_list[4], &s.normals[0])

                                : std::make_pair(vertex_list[1], &s.normals[1]);

                        const auto mdist = vm_dist_to_plane(vcvertptr(a.first), *a.second, mvert);

                        side_count = center_count = 0;

                        for (int fn=0;fn<2;fn++,facebit<<=1) {

                                const auto dist = vm_dist_to_plane(checkp, s.normals[fn], mvert);

                                if (dist-rad < -PLANE_DIST_TOLERANCE) {

                                        if (dist < -PLANE_DIST_TOLERANCE)       //in front of face

                                                center_count++;

                                        masks.facemask |= facebit;

                                        side_count++;

                                }

                        }

                        if (!(mdist > PLANE_DIST_TOLERANCE)) {          //must be behind both faces

                                if (side_count==2)

                                        masks.sidemask |= sidebit;

                                if (center_count==2)

                                        masks.centermask |= sidebit;

                        }

                        else {                                                  //must be behind at least one face

                                if (side_count)

                                        masks.sidemask |= sidebit;

                                if (center_count)

                                        masks.centermask |= sidebit;

                        }

                }

                else {                          //only one face on this side

                        //use lowest point number

                        auto b = begin(vertex_list);

                        const auto vertnum = *std::min_element(b, std::next(b, 4));

                        const auto &&mvert = vcvertptr(vertnum);

                        const auto dist = vm_dist_to_plane(checkp, s.normals[0], mvert);

                        if (dist-rad < -PLANE_DIST_TOLERANCE) {

                                if (dist < -PLANE_DIST_TOLERANCE)

                                        masks.centermask |= sidebit;

                                masks.facemask |= facebit;

                                masks.sidemask |= sidebit;

                        }

                        facebit <<= 2;

                }

        }

        return masks;

}

//this was converted from get_seg_masks()...it fills in an array of 6

//elements for the distace behind each side, or zero if not behind

//only gets centermask, and assumes zero rad

static uint8_t get_side_dists(fvcvertptr &vcvertptr, const vms_vector &checkp, const shared_segment &segnum, std::array<fix, 6> &side_dists)

{

        int                     sn,facebit,sidebit;

        ubyte                   mask;

        auto &sides = segnum.sides;

        //check point against each side of segment. return bitmask

        mask = 0;

        side_dists = {};

        for (sn=0,facebit=sidebit=1;sn<6;sn++,sidebit<<=1) {

                auto &s = sides[sn];

                // Get number of faces on this side, and at vertex_list, store vertices.

                //      If one face, then vertex_list indicates a quadrilateral.

                //      If two faces, then 0,1,2 define one triangle, 3,4,5 define the second.

                const auto v = create_abs_vertex_lists(segnum, s, sn);

                const auto &num_faces = v.first;

                const auto &vertex_list = v.second;

                //ok...this is important.  If a side has 2 faces, we need to know if

                //those faces form a concave or convex side.  If the side pokes out,

                //then a point is on the back of the side if it is behind BOTH faces,

                //but if the side pokes in, a point is on the back if behind EITHER face.

                if (num_faces==2) {

                        int     center_count;

                        const auto vertnum = min(vertex_list[0],vertex_list[2]);

                        auto &mvert = *vcvertptr(vertnum);

                        auto a = vertex_list[4] < vertex_list[1]

                                ? std::make_pair(vertex_list[4], &s.normals[0])

                                : std::make_pair(vertex_list[1], &s.normals[1]);

                        const auto mdist = vm_dist_to_plane(vcvertptr(a.first), *a.second, mvert);

                        center_count = 0;

                        for (int fn=0;fn<2;fn++,facebit<<=1) {

                                const auto dist = vm_dist_to_plane(checkp, s.normals[fn], mvert);

                                if (dist < -PLANE_DIST_TOLERANCE) {     //in front of face

                                        center_count++;

                                        side_dists[sn] += dist;

                                }

                        }

                        if (!(mdist > PLANE_DIST_TOLERANCE)) {          //must be behind both faces

                                if (center_count==2) {

                                        mask |= sidebit;

                                        side_dists[sn] /= 2;            //get average

                                }

                        }

                        else {                                                  //must be behind at least one face

                                if (center_count) {

                                        mask |= sidebit;

                                        if (center_count==2)

                                                side_dists[sn] /= 2;            //get average

                                }

                        }

                }

                else {                          //only one face on this side

                        //use lowest point number

                        auto b = begin(vertex_list);

                        auto vertnum = *std::min_element(b, std::next(b, 4));

                        const auto dist = vm_dist_to_plane(checkp, s.normals[0], vcvertptr(vertnum));

                        if (dist < -PLANE_DIST_TOLERANCE) {

                                mask |= sidebit;

                                side_dists[sn] = dist;

                        }

                        facebit <<= 2;

                }

        }

        return mask;

}

#ifndef NDEBUG

//returns true if errors detected

static int check_norms(const shared_segment &segp, const unsigned sidenum, const unsigned facenum, const shared_segment &csegp, const unsigned csidenum, const unsigned cfacenum)

{

        const auto &n0 = segp.sides[sidenum].normals[facenum];

        const auto &n1 = csegp.sides[csidenum].normals[cfacenum];

        if (n0.x != -n1.x || n0.y != -n1.y || n0.z != -n1.z)

                return 1;

        else

                return 0;

}

static void invert_shared_side_triangle_type(shared_side &s)

{

        const auto t = s.get_type();

        side_type nt;

        switch (t)

        {

                case side_type::tri_02:

                        nt = side_type::tri_13;

                        break;

                case side_type::tri_13:

                        nt = side_type::tri_02;

                        break;

                default:

                        return;

        }

        s.set_type(nt);

}

#endif

//heavy-duty error checking

int check_segment_connections(void)

{

        int errors=0;

        range_for (const auto &&seg, vmsegptridx)

        {

                range_for (const int sidenum, xrange(6u)) {

#ifndef NDEBUG

                        const auto v = create_abs_vertex_lists(seg, sidenum);

                        const auto &num_faces = v.first;

                        const auto &vertex_list = v.second;

#endif

                        auto csegnum = seg->children[sidenum];

                        if (IS_CHILD(csegnum)) {

                                auto cseg = vcsegptr(csegnum);

                                auto csidenum = find_connect_side(seg,cseg);

                                if (csidenum == side_none)

                                {

                                        shared_segment &rseg = *seg;

                                        const shared_segment &rcseg = *cseg;

                                        const unsigned segi = seg.get_unchecked_index();

                                        LevelError("Segment #%u side %u has asymmetric link to segment %u.  Coercing to segment_none; Segments[%u].children={%hu, %hu, %hu, %hu, %hu, %hu}, Segments[%u].children={%hu, %hu, %hu, %hu, %hu, %hu}.", segi, sidenum, csegnum, segi, rseg.children[0], rseg.children[1], rseg.children[2], rseg.children[3], rseg.children[4], rseg.children[5], csegnum, rcseg.children[0], rcseg.children[1], rcseg.children[2], rcseg.children[3], rcseg.children[4], rcseg.children[5]);

                                        rseg.children[sidenum] = segment_none;

                                        errors = 1;

                                        continue;

                                }

#ifndef NDEBUG

                                const auto cv = create_abs_vertex_lists(cseg, csidenum);

                                const auto &con_num_faces = cv.first;

                                const auto &con_vertex_list = cv.second;

                                if (con_num_faces != num_faces) {

                                        LevelError("Segment #%u side %u: wrong faces: con_num_faces=%" PRIuFAST32 " num_faces=%" PRIuFAST32 ".", seg.get_unchecked_index(), sidenum, con_num_faces, num_faces);

                                        errors = 1;

                                }

                                else

                                        if (num_faces == 1) {

                                                int t;

                                                for (t=0;t<4 && con_vertex_list[t]!=vertex_list[0];t++);

                                                if (t==4 ||

                                                         vertex_list[0] != con_vertex_list[t] ||

                                                         vertex_list[1] != con_vertex_list[(t+3)%4] ||

                                                         vertex_list[2] != con_vertex_list[(t+2)%4] ||

                                                         vertex_list[3] != con_vertex_list[(t+1)%4]) {

                                                        LevelError("Segment #%u side %u: bad vertices.", seg.get_unchecked_index(), sidenum);

                                                        errors = 1;

                                                }

                                                else

                                                        errors |= check_norms(seg,sidenum,0,cseg,csidenum,0);

                                        }

                                        else {

                                                if (vertex_list[1] == con_vertex_list[1]) {

                                                        if (vertex_list[4] != con_vertex_list[4] ||

                                                                 vertex_list[0] != con_vertex_list[2] ||

                                                                 vertex_list[2] != con_vertex_list[0] ||

                                                                 vertex_list[3] != con_vertex_list[5] ||

                                                                 vertex_list[5] != con_vertex_list[3]) {

                                                                auto &cside = vmsegptr(csegnum)->shared_segment::sides[csidenum];

                                                                invert_shared_side_triangle_type(cside);

                                                        } else {

                                                                errors |= check_norms(seg,sidenum,0,cseg,csidenum,0);

                                                                errors |= check_norms(seg,sidenum,1,cseg,csidenum,1);

                                                        }

                                                } else {

                                                        if (vertex_list[1] != con_vertex_list[4] ||

                                                                 vertex_list[4] != con_vertex_list[1] ||

                                                                 vertex_list[0] != con_vertex_list[5] ||

                                                                 vertex_list[5] != con_vertex_list[0] ||

                                                                 vertex_list[2] != con_vertex_list[3] ||

                                                                 vertex_list[3] != con_vertex_list[2]) {

                                                                auto &cside = vmsegptr(csegnum)->shared_segment::sides[csidenum];

                                                                invert_shared_side_triangle_type(cside);

                                                        } else {

                                                                errors |= check_norms(seg,sidenum,0,cseg,csidenum,1);

                                                                errors |= check_norms(seg,sidenum,1,cseg,csidenum,0);

                                                        }

                                                }

                                        }

#endif

                        }

                }

        }

        return errors;

}

// Used to become a constant based on editor, but I wanted to be able to set

// this for omega blob find_point_seg calls.

// Would be better to pass a paremeter to the routine...--MK, 01/17/96

#if defined(DXX_BUILD_DESCENT_II) || DXX_USE_EDITOR

int     Doing_lighting_hack_flag=0;

#else

#define Doing_lighting_hack_flag 0

#endif

// figure out what seg the given point is in, tracing through segments

// returns segment number, or -1 if can't find segment

static icsegptridx_t trace_segs(const d_level_shared_segment_state &LevelSharedSegmentState, const vms_vector &p0, const vcsegptridx_t oldsegnum, const unsigned recursion_count, visited_segment_bitarray_t &visited)

{

        int centermask;

        std::array<fix, 6> side_dists;

        fix biggest_val;

        int sidenum, bit, biggest_side;

        if (recursion_count >= LevelSharedSegmentState.Num_segments) {

                con_puts(CON_DEBUG, "trace_segs: Segment not found");

                return segment_none;

        }

        if (auto &&vs = visited[oldsegnum])

                return segment_none;

        else

                vs = true;

        auto &LevelSharedVertexState = LevelSharedSegmentState.get_vertex_state();

        auto &Vertices = LevelSharedVertexState.get_vertices();

        centermask = get_side_dists(Vertices.vcptr, p0, oldsegnum, side_dists);         //check old segment

        if (centermask == 0) // we are in the old segment

                return oldsegnum; //..say so

        for (;;) {

                auto seg = oldsegnum;

                biggest_side = -1;

                biggest_val = 0;

                for (sidenum = 0, bit = 1; sidenum < 6; sidenum++, bit <<= 1)

                {

                        if ((centermask & bit) && IS_CHILD(seg->children[sidenum])

                            && side_dists[sidenum] < biggest_val) {

                                biggest_val = side_dists[sidenum];

                                biggest_side = sidenum;

                        }

                }

                if (biggest_side == -1)

                        break;

                side_dists[biggest_side] = 0;

                // trace into adjacent segment:

                const auto &&check = trace_segs(LevelSharedSegmentState, p0, oldsegnum.absolute_sibling(seg->children[biggest_side]), recursion_count + 1, visited);

                if (check != segment_none)              //we've found a segment

                        return check;

        }

        return segment_none;            //we haven't found a segment

}

imsegptridx_t find_point_seg(const d_level_shared_segment_state &LevelSharedSegmentState, d_level_unique_segment_state &, const vms_vector &p, const imsegptridx_t segnum)

{

        return segnum.rebind_policy(find_point_seg(LevelSharedSegmentState, p, segnum));

}

//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 segments

//Returns segnum if found, or -1

icsegptridx_t find_point_seg(const d_level_shared_segment_state &LevelSharedSegmentState, const vms_vector &p, const icsegptridx_t segnum)

{

        //allow segnum==-1, meaning we have no idea what segment point is in

        if (segnum != segment_none) {

                visited_segment_bitarray_t visited;

                const auto &&newseg = trace_segs(LevelSharedSegmentState, p, segnum, 0, visited);

                if (newseg != segment_none)                     //we found a segment!

                        return newseg;

        }

        //couldn't find via attached segs, so search all segs

        //      MK: 10/15/94

        //      This Doing_lighting_hack_flag thing added by mk because the hundreds of scrolling messages were

        //      slowing down lighting, and in about 98% of cases, it would just return -1 anyway.

        //      Matt: This really should be fixed, though.  We're probably screwing up our lighting in a few places.

        if (!Doing_lighting_hack_flag) {

                auto &Segments = LevelSharedSegmentState.get_segments();

                auto &LevelSharedVertexState = LevelSharedSegmentState.get_vertex_state();

                auto &Vertices = LevelSharedVertexState.get_vertices();

                range_for (const auto &&segp, Segments.vmptridx)

                {

                        if (get_seg_masks(Vertices.vcptr, p, segp, 0).centermask == 0)

                                return segp;

                }

        }

        return segment_none;

}

//--repair-- // ------------------------------------------------------------------------------

//--repair-- void clsd_repair_center(int segnum)

//--repair-- {

//--repair--    int     sidenum;

//--repair--

//--repair--    //      --- Set repair center bit for all repair center segments.

//--repair--    if (Segments[segnum].special == SEGMENT_IS_REPAIRCEN) {

//--repair--            Lsegments[segnum].special_type |= SS_REPAIR_CENTER;

//--repair--            Lsegments[segnum].special_segment = segnum;

//--repair--    }

//--repair--

//--repair--    //      --- Set repair center bit for all segments adjacent to a repair center.

//--repair--    for (sidenum=0; sidenum < MAX_SIDES_PER_SEGMENT; sidenum++) {

//--repair--            int     s = Segments[segnum].children[sidenum];

//--repair--

//--repair--            if ( (s != -1) && (Segments[s].special==SEGMENT_IS_REPAIRCEN) ) {

//--repair--                    Lsegments[segnum].special_type |= SS_REPAIR_CENTER;

//--repair--                    Lsegments[segnum].special_segment = s;

//--repair--            }

//--repair--    }

//--repair-- }

//--repair-- // ------------------------------------------------------------------------------

//--repair-- // --- Set destination points for all Materialization centers.

//--repair-- void clsd_materialization_center(int segnum)

//--repair-- {

//--repair--    if (Segments[segnum].special == SEGMENT_IS_ROBOTMAKER) {

//--repair--

//--repair--    }

//--repair-- }

//--repair--

//--repair-- int        Lsegment_highest_segment_index, Lsegment_highest_vertex_index;

//--repair--

//--repair-- // ------------------------------------------------------------------------------

//--repair-- // Create data specific to mine which doesn't get written to disk.

//--repair-- // Highest_segment_index and Highest_object_index must be valid.

//--repair-- // 07/21:  set repair center bit

//--repair-- void create_local_segment_data(void)

//--repair-- {

//--repair--    int     segnum;

//--repair--

//--repair--    //      --- Initialize all Lsegments.

//--repair--    for (segnum=0; segnum <= Highest_segment_index; segnum++) {

//--repair--            Lsegments[segnum].special_type = 0;

//--repair--            Lsegments[segnum].special_segment = -1;

//--repair--    }

//--repair--

//--repair--    for (segnum=0; segnum <= Highest_segment_index; segnum++) {

//--repair--

//--repair--            clsd_repair_center(segnum);

//--repair--            clsd_materialization_center(segnum);

//--repair--    

//--repair--    }

//--repair--

//--repair--    //      Set check variables.

//--repair--    //      In main game loop, make sure these are valid, else Lsegments is not valid.

//--repair--    Lsegment_highest_segment_index = Highest_segment_index;

//--repair--    Lsegment_highest_vertex_index = Highest_vertex_index;

//--repair-- }

//--repair--

//--repair-- // ------------------------------------------------------------------------------------------

//--repair-- // Sort of makes sure create_local_segment_data has been called for the currently executing mine.

//--repair-- // It is not failsafe, as you will see if you look at the code.

//--repair-- // Returns 1 if Lsegments appears valid, 0 if not.

//--repair-- int check_lsegments_validity(void)

//--repair-- {

//--repair--    return ((Lsegment_highest_segment_index == Highest_segment_index) && (Lsegment_highest_vertex_index == Highest_vertex_index));

//--repair-- }

}

#define MAX_LOC_POINT_SEGS      64

namespace dsx {

#if defined(DXX_BUILD_DESCENT_I)

static inline void add_to_fcd_cache(int seg0, int seg1, int depth, vm_distance dist)

{

        (void)(seg0||seg1||depth||dist);

}

#elif defined(DXX_BUILD_DESCENT_II)

#define MIN_CACHE_FCD_DIST      (F1_0*80)       //      Must be this far apart for cache lookup to succeed.  Recognizes small changes in distance matter at small distances.

#define MAX_FCD_CACHE   8

namespace {

struct fcd_data {

        segnum_t        seg0, seg1;

        int csd;

        vm_distance dist;

};

}

int     Fcd_index = 0;

static std::array<fcd_data, MAX_FCD_CACHE> Fcd_cache;

fix64   Last_fcd_flush_time;