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-1998 PARALLAX SOFTWARE CORPORATION.  ALL RIGHTS RESERVED.

*/

/*

 *

 * Interrogation functions for segment data structure.

 *

 */

#include <stdio.h>

#include <stdlib.h>

#include <math.h>

#include <string.h>

#include "key.h"

#include "gr.h"

#include "inferno.h"

#include "segment.h"

#include "editor.h"

#include "editor/esegment.h"

#include "dxxerror.h"

#include "object.h"

#include "gameseg.h"

#include "render.h"

#include "game.h"

#include "wall.h"

#include "switch.h"

#include "fuelcen.h"

#include "cntrlcen.h"

#include "seguvs.h"

#include "gameseq.h"

#include "kdefs.h"

#include "medwall.h"

#include "hostage.h"

#include "compiler-range_for.h"

#include "d_range.h"

#include "d_enumerate.h"

#include "d_zip.h"

#include "segiter.h"

int     Do_duplicate_vertex_check = 0;          // Gets set to 1 in med_create_duplicate_vertex, means to check for duplicate vertices in compress_mine

//      Remap all vertices in polygons in a segment through translation table xlate_verts.

int ToggleBottom(void)

{

        Render_only_bottom = !Render_only_bottom;

        Update_flags = UF_WORLD_CHANGED;

        return 0;

}

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

//      Return number of times vertex vi appears in all segments.

//      This function can be used to determine whether a vertex is used exactly once in

//      all segments, in which case it can be freely moved because it is not connected

//      to any other segment.

static int med_vertex_count(int vi)

{

        int             count;

        count = 0;

        range_for (auto &s, Segments)

        {

                auto sp = &s;

                if (sp->segnum != segment_none)

                        range_for (auto &v, s.verts)

                                if (v == vi)

                                        count++;

        }

        return count;

}

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

int is_free_vertex(int vi)

{

        return med_vertex_count(vi) == 1;

}

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

//      Return true if one fixed point number is very close to another, else return false.

static int fnear(fix f1, fix f2)

{

        return (abs(f1 - f2) <= FIX_EPSILON);

}

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

static int vnear(const vms_vector &vp1, const vms_vector &vp2)

{

        return fnear(vp1.x, vp2.x) && fnear(vp1.y, vp2.y) && fnear(vp1.z, vp2.z);

}

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

//      Add the vertex *vp to the global list of vertices, return its index.

//      Search until a matching vertex is found (has nearly the same coordinates) or until Num_vertices

// vertices have been looked at without a match.  If no match, add a new vertex.

int med_add_vertex(const vertex &vp)

{

        auto &LevelSharedVertexState = LevelSharedSegmentState.get_vertex_state();

        int     count;                                  // number of used vertices found, for loops exits when count == Num_vertices

//      set_vertex_counts();

        const auto Num_vertices = LevelSharedVertexState.Num_vertices;

        Assert(Num_vertices < MAX_SEGMENT_VERTICES);

        count = 0;

        unsigned free_index = UINT32_MAX;

        auto &Vertices = LevelSharedVertexState.get_vertices();

        auto &Vertex_active = LevelSharedVertexState.get_vertex_active();

        for (unsigned v = 0; v < MAX_SEGMENT_VERTICES && count < Num_vertices; ++v)

                if (Vertex_active[v]) {

                        count++;

                        if (vnear(vp, Vertices.vcptr(v))) {

                                return v;

                        }

                } else if (free_index == UINT32_MAX)

                        free_index = v;                                 // we want free_index to be the first free slot to add a vertex

        if (free_index == UINT32_MAX)

                free_index = Num_vertices;

        while (Vertex_active[free_index] && (free_index < MAX_VERTICES))

                free_index++;

        Assert(free_index < MAX_VERTICES);

        *Vertices.vmptr(free_index) = vp;

        Vertex_active[free_index] = 1;

        ++LevelSharedVertexState.Num_vertices;

        if (Vertices.get_count() - 1 < free_index)

                Vertices.set_count(free_index + 1);

        return free_index;

}

namespace dsx {

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

//      Returns the index of a free segment.

//      Scans the Segments array.

segnum_t get_free_segment_number(segment_array &Segments)

{

        for (segnum_t segnum=0; segnum<MAX_SEGMENTS; segnum++)

                if (Segments[segnum].segnum == segment_none) {

                        ++ LevelSharedSegmentState.Num_segments;

                        if (segnum > Highest_segment_index)

                                Segments.set_count(segnum + 1);

                        return segnum;

                }

        Assert(0);

        return 0;

}

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

//      Create a new segment, duplicating exactly, including vertex ids and children, the passed segment.

segnum_t med_create_duplicate_segment(segment_array &Segments, const segment &sp)

{

        const auto segnum = get_free_segment_number(Segments);

        auto &nsp = *Segments.vmptr(segnum);

        nsp = sp;

        nsp.objects = object_none;

        return segnum;

}

}

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

//      Add the vertex *vp to the global list of vertices, return its index.

//      This is the same as med_add_vertex, except that it does not search for the presence of the vertex.

int med_create_duplicate_vertex(const vertex &vp)

{

        auto &LevelSharedVertexState = LevelSharedSegmentState.get_vertex_state();

        const auto Num_vertices = LevelSharedVertexState.Num_vertices;

        Assert(Num_vertices < MAX_SEGMENT_VERTICES);

        Do_duplicate_vertex_check = 1;

        unsigned free_index = Num_vertices;

        auto &Vertex_active = LevelSharedVertexState.get_vertex_active();

        while (Vertex_active[free_index] && (free_index < MAX_VERTICES))

                free_index++;

        Assert(free_index < MAX_VERTICES);

        auto &Vertices = LevelSharedVertexState.get_vertices();

        *Vertices.vmptr(free_index) = vp;

        Vertex_active[free_index] = 1;

        ++LevelSharedVertexState.Num_vertices;

        if (Vertices.get_count() - 1 < free_index)

                Vertices.set_count(free_index + 1);

        return free_index;

}

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

//      Set the vertex *vp at index vnum in the global list of vertices, return its index (just for compatibility).

int med_set_vertex(const unsigned vnum, const vertex &vp)

{

        auto &LevelSharedVertexState = LevelSharedSegmentState.get_vertex_state();

        auto &Vertices = LevelSharedVertexState.get_vertices();

        *Vertices.vmptr(vnum) = vp;

        // Just in case this vertex wasn't active, mark it as active.

        auto &Vertex_active = LevelSharedVertexState.get_vertex_active();

        if (!Vertex_active[vnum]) {

                Vertex_active[vnum] = 1;

                ++LevelSharedVertexState.Num_vertices;

                if ((vnum > Vertices.get_count() - 1) && (vnum < NEW_SEGMENT_VERTICES)) {

                        Vertices.set_count(vnum + 1);

                }

        }

        return vnum;

}

namespace dsx {

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

void create_removable_wall(fvcvertptr &vcvertptr, const vmsegptridx_t sp, const unsigned sidenum, const unsigned tmap_num)

{

        create_walls_on_side(vcvertptr, sp, sidenum);

        sp->unique_segment::sides[sidenum].tmap_num = tmap_num;

        assign_default_uvs_to_side(sp, sidenum);

        assign_light_to_side(sp, sidenum);

}

#if 0

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

//      Orthogonalize matrix smat, returning result in rmat.

//      Does not modify smat.

//      Uses Gram-Schmidt process.

//      See page 172 of Strang, Gilbert, Linear Algebra and its Applications

//      Matt -- This routine should be moved to the vector matrix library.

//      It IS legal for smat == rmat.

//      We should also have the functions:

//              mat_a = mat_b * scalar;                         // we now have mat_a = mat_a * scalar;

//              mat_a = mat_b + mat_c * scalar; // or maybe not, maybe this is not primitive

void make_orthogonal(vms_matrix *rmat,vms_matrix *smat)

{

        vms_matrix              tmat;

        vms_vector              tvec1,tvec2;

        float                           dot;

        // Copy source matrix to work area.

        tmat = *smat;

        // Normalize the three rows of the matrix tmat.

        vm_vec_normalize(&tmat.xrow);

        vm_vec_normalize(&tmat.yrow);

        vm_vec_normalize(&tmat.zrow);

        //      Now, compute the first vector.

        // This is very easy -- just copy the (normalized) source vector.

        rmat->zrow = tmat.zrow;

        // Now, compute the second vector.

        // From page 172 of Strang, we use the equation:

        //              b' = b - [transpose(q1) * b] * q1

        //      where:  b  = the second row of tmat

        //                              q1 = the first row of rmat

        //                              b' = the second row of rmat

        // Compute: transpose(q1) * b

        dot = vm_vec_dot(&rmat->zrow,&tmat.yrow);

        // Compute: b - dot * q1

        rmat->yrow.x = tmat.yrow.x - fixmul(dot,rmat->zrow.x);

        rmat->yrow.y = tmat.yrow.y - fixmul(dot,rmat->zrow.y);

        rmat->yrow.z = tmat.yrow.z - fixmul(dot,rmat->zrow.z);

        // Now, compute the third vector.

        // From page 173 of Strang, we use the equation:

        //              c' = c - (q1*c)*q1 - (q2*c)*q2

        //      where:  c  = the third row of tmat

        //                              q1 = the first row of rmat

        //                              q2 = the second row of rmat

        //                              c' = the third row of rmat

        // Compute: q1*c

        dot = vm_vec_dot(&rmat->zrow,&tmat.xrow);

        tvec1.x = fixmul(dot,rmat->zrow.x);

        tvec1.y = fixmul(dot,rmat->zrow.y);

        tvec1.z = fixmul(dot,rmat->zrow.z);

        // Compute: q2*c

        dot = vm_vec_dot(&rmat->yrow,&tmat.xrow);

        tvec2.x = fixmul(dot,rmat->yrow.x);

        tvec2.y = fixmul(dot,rmat->yrow.y);

        tvec2.z = fixmul(dot,rmat->yrow.z);

        vm_vec_sub(&rmat->xrow,vm_vec_sub(&rmat->xrow,&tmat.xrow,&tvec1),&tvec2);

}

#endif

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

// Given a segment, extract the rotation matrix which defines it.

// Do this by extracting the forward, right, up vectors and then making them orthogonal.

// In the process of making the vectors orthogonal, favor them in the order forward, up, right.

// This means that the forward vector will remain unchanged.

void med_extract_matrix_from_segment(const shared_segment &sp, vms_matrix &rotmat)

{

        auto &LevelSharedVertexState = LevelSharedSegmentState.get_vertex_state();

        vms_vector      forwardvec,upvec;

        auto &Vertices = LevelSharedVertexState.get_vertices();

        auto &vcvertptr = Vertices.vcptr;

        extract_forward_vector_from_segment(vcvertptr, sp, forwardvec);

        extract_up_vector_from_segment(vcvertptr, sp, upvec);

        if (((forwardvec.x == 0) && (forwardvec.y == 0) && (forwardvec.z == 0)) || ((upvec.x == 0) && (upvec.y == 0) && (upvec.z == 0))) {

                rotmat = vmd_identity_matrix;

                return;

        }

        vm_vector_2_matrix(rotmat, forwardvec, &upvec, nullptr);

#if 0

        vms_matrix      rm;

        extract_forward_vector_from_segment(sp,&rm.zrow);

        extract_right_vector_from_segment(sp,&rm.xrow);

        extract_up_vector_from_segment(sp,&rm.yrow);

        vm_vec_normalize(&rm.xrow);

        vm_vec_normalize(&rm.yrow);

        vm_vec_normalize(&rm.zrow);

        make_orthogonal(rotmat,&rm);

        vm_vec_normalize(&rotmat->xrow);

        vm_vec_normalize(&rotmat->yrow);

        vm_vec_normalize(&rotmat->zrow);

// *rotmat = rm; // include this line (and remove the call to make_orthogonal) if you don't want the matrix orthogonalized

#endif

}

}

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

//      Given a rotation matrix *rotmat which describes the orientation of a segment

//      and a side destside, return the rotation matrix which describes the orientation for the side.

void update_matrix_based_on_side(vms_matrix &rotmat,int destside)

{

        vms_angvec      rotvec;

        switch (destside) {

                case WLEFT:

                        vm_angvec_make(&rotvec,0,0,-16384);

                        rotmat = vm_matrix_x_matrix(rotmat, vm_angles_2_matrix(rotvec));

                        break;

                case WTOP:

                        vm_angvec_make(&rotvec,-16384,0,0);

                        rotmat = vm_matrix_x_matrix(rotmat, vm_angles_2_matrix(rotvec));

                        break;

                case WRIGHT:

                        vm_angvec_make(&rotvec,0,0,16384);

                        rotmat = vm_matrix_x_matrix(rotmat, vm_angles_2_matrix(rotvec));

                        break;

                case WBOTTOM:

                        vm_angvec_make(&rotvec,+16384,-32768,0);        // bank was -32768, but I think that was an erroneous compensation

                        rotmat = vm_matrix_x_matrix(rotmat, vm_angles_2_matrix(rotvec));

                        break;

                case WFRONT:

                        vm_angvec_make(&rotvec,0,0,-32768);

                        rotmat = vm_matrix_x_matrix(rotmat, vm_angles_2_matrix(rotvec));

                        break;

                case WBACK:

                        break;

        }

}

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

static void change_vertex_occurrences(int dest, int src)

{

        // Fix vertices in groups

        range_for (auto &g, partial_range(GroupList, num_groups))

                g.vertices.replace(src, dest);

        // now scan all segments, changing occurrences of src to dest

        range_for (const auto &&segp, vmsegptr)

        {

                if (segp->segnum != segment_none)

                        range_for (auto &v, segp->verts)

                                if (v == src)

                                        v = dest;

        }

}

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

static void compress_vertices(void)

{

        auto &LevelSharedVertexState = LevelSharedSegmentState.get_vertex_state();

        const auto Num_vertices = LevelSharedVertexState.Num_vertices;

        auto &Vertices = LevelSharedVertexState.get_vertices();

        if (Vertices.get_count() == Num_vertices)

                return;

        unsigned vert = Vertices.get_count() - 1;       //MAX_SEGMENT_VERTICES-1;

        auto &vcvertptr = Vertices.vcptr;

        auto &vmvertptr = Vertices.vmptr;

        auto &Vertex_active = LevelSharedVertexState.get_vertex_active();

        for (unsigned hole = 0; hole < vert; ++hole)

                if (!Vertex_active[hole]) {

                        // found an unused vertex which is a hole if a used vertex follows (not necessarily immediately) it.

                        for ( ; (vert>hole) && (!Vertex_active[vert]); vert--)

                                ;

                        if (vert > hole) {

                                // Ok, hole is the index of a hole, vert is the index of a vertex which follows it.

                                // Copy vert into hole, update pointers to it.

                                *vmvertptr(hole) = *vcvertptr(vert);

                                change_vertex_occurrences(hole, vert);

                                vert--;

                        }

                }

        Vertices.set_count(Num_vertices);

}

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

static void compress_segments(void)

{

        auto &Objects = LevelUniqueObjectState.Objects;

        auto &vmobjptridx = Objects.vmptridx;

        if (Highest_segment_index == LevelSharedSegmentState.Num_segments - 1)

                return;

        segnum_t                hole,seg;

        seg = Highest_segment_index;

        auto &RobotCenters = LevelSharedRobotcenterState.RobotCenters;

        auto &Walls = LevelUniqueWallSubsystemState.Walls;

        auto &vmwallptr = Walls.vmptr;

        for (hole=0; hole < seg; hole++)

                if (Segments[hole].segnum == segment_none) {

                        // found an unused segment which is a hole if a used segment follows (not necessarily immediately) it.

                        for ( ; (seg>hole) && (Segments[seg].segnum == segment_none); seg--)

                                ;

                        if (seg > hole) {

                                // Ok, hole is the index of a hole, seg is the index of a segment which follows it.

                                // Copy seg into hole, update pointers to it, update Cursegp, Markedsegp if necessary.

                                Segments[hole] = Segments[seg];

                                Segments[seg].segnum = segment_none;

                                if (Cursegp == &Segments[seg])

                                        Cursegp = imsegptridx(hole);

                                if (Markedsegp == &Segments[seg])

                                        Markedsegp = imsegptridx(hole);

                                // Fix segments in groups

                                range_for (auto &g, partial_range(GroupList, num_groups))

                                        g.segments.replace(seg, hole);

                                // Fix walls

                                range_for (const auto &&w, vmwallptr)

                                        if (w->segnum == seg)

                                                w->segnum = hole;

                                // Fix fuelcenters, robotcens, and triggers... added 2/1/95 -Yuan

                                range_for (auto &f, partial_range(LevelUniqueFuelcenterState.Station, LevelUniqueFuelcenterState.Num_fuelcenters))

                                        if (f.segnum == seg)

                                                f.segnum = hole;

                                range_for (auto &f, partial_range(RobotCenters, LevelSharedRobotcenterState.Num_robot_centers))

                                        if (f.segnum == seg)

                                                f.segnum = hole;

                                auto &Triggers = LevelUniqueWallSubsystemState.Triggers;

                                auto &vmtrgptr = Triggers.vmptr;

                                range_for (const auto vt, vmtrgptr)

                                {

                                        auto &t = *vt;

                                        range_for (auto &l, partial_range(t.seg, t.num_links))

                                                if (l == seg)

                                                        l = hole;

                                }

                                auto &sp = *vmsegptr(hole);

                                range_for (auto &s, sp.children)

                                {

                                        if (IS_CHILD(s)) {

                                                // Find out on what side the segment connection to the former seg is on in *csegp.

                                                range_for (auto &t, vmsegptr(s)->children)

                                                {

                                                        if (t == seg) {

                                                                t = hole;                                       // It used to be connected to seg, so make it connected to hole

                                                        }

                                                }       // end for t

                                        }       // end if

                                }       // end for s

                                //Update object segment pointers

                                range_for (const auto objp, objects_in(sp, vmobjptridx, vmsegptr))

                                {

                                        Assert(objp->segnum == seg);

                                        objp->segnum = hole;

                                }

                                seg--;

                        }       // end if (seg > hole)

                }       // end if

        Segments.set_count(LevelSharedSegmentState.Num_segments);

        med_create_new_segment_from_cursegp();

}

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

//      Combine duplicate vertices.

//      If two vertices have the same coordinates, within some small tolerance, then assign

//      the same vertex number to the two vertices, freeing up one of the vertices.

void med_combine_duplicate_vertices(std::array<uint8_t, MAX_VERTICES> &vlp)

{

        auto &LevelSharedVertexState = LevelSharedSegmentState.get_vertex_state();

        auto &Vertices = LevelSharedVertexState.get_vertices();

        auto &vcvertptridx = Vertices.vcptridx;

        const auto &&range = make_range(vcvertptridx);

        // Note: ok to do to <, rather than <= because w for loop starts at v+1

        if (range.m_begin == range.m_end)

                return;

        for (auto i = range.m_begin;;)

        {

                const auto &&v = *i;

                if (++i == range.m_end)

                        return;

                if (vlp[v]) {

                        auto &vvp = *v;

                        auto subrange = range;

                        subrange.m_begin = i;

                        range_for (auto &&w, subrange)

                                if (vlp[w]) {   //      used to be Vertex_active[w]

                                        if (vnear(vvp, *w)) {

                                                change_vertex_occurrences(v, w);

                                        }

                                }

                }

        }

}

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

//      Compress mine at Segments and Vertices by squeezing out all holes.

//      If no holes (ie, an unused segment followed by a used segment), then no action.

//      If Cursegp or Markedsegp is a segment which gets moved to fill in a hole, then

//      they are properly updated.

void med_compress_mine(void)

{

        auto &LevelSharedVertexState = LevelSharedSegmentState.get_vertex_state();

        if (Do_duplicate_vertex_check) {

                auto &Vertex_active = LevelSharedVertexState.get_vertex_active();

                med_combine_duplicate_vertices(Vertex_active);

                Do_duplicate_vertex_check = 0;

        }

        compress_segments();

        compress_vertices();

        set_vertex_counts();

        //--repair-- create_local_segment_data();

        //      This is necessary becuase a segment search (due to click in 3d window) uses the previous frame's

        //      segment information, which could get changed by this.

        Update_flags = UF_WORLD_CHANGED;

}

namespace dsx {

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

//      Copy texture map ids for each face in sseg to dseg.

static void copy_tmap_ids(unique_segment &dseg, const unique_segment &sseg)

{

        range_for (const auto &&z, zip(sseg.sides, dseg.sides))

        {

                auto &ds = std::get<1>(z);

                ds.tmap_num = std::get<0>(z).tmap_num;

                ds.tmap_num2 = 0;

        }

}

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

//      Attach a segment with a rotated orientation.

// Return value:

//  0 = successful attach

//  1 = No room in Segments[].

//  2 = No room in Vertices[].

//  3 = newside != WFRONT -- for now, the new segment must be attached at its (own) front side

//       4 = already a face attached on destseg:destside

static int med_attach_segment_rotated(const vmsegptridx_t destseg, const vmsegptr_t newseg, int destside, int newside,const vms_matrix &attmat)

{

        auto &LevelSharedVertexState = LevelSharedSegmentState.get_vertex_state();

        auto &Vertices = LevelSharedVertexState.get_vertices();

        vms_matrix      rotmat,rotmat2,rotmat3;

        vms_vector      forvec,upvec;

        // Return if already a face attached on this side.

        if (IS_CHILD(destseg->children[destside]))

                return 4;

        const auto segnum = get_free_segment_number(Segments);

        forvec = attmat.fvec;

        upvec = attmat.uvec;

        //      We are pretty confident we can add the segment.

        const auto &&nsp = destseg.absolute_sibling(segnum);

        nsp->segnum = segnum;

        nsp->objects = object_none;

        nsp->matcen_num = -1;

        // Copy group value.

        nsp->group = destseg->group;

        // Add segment to proper group list.

        if (nsp->group > -1)

                add_segment_to_group(nsp, nsp->group);

        // Copy the texture map ids.

        copy_tmap_ids(nsp,newseg);

        // clear all connections

        for (unsigned side = 0; side < MAX_SIDES_PER_SEGMENT; ++side)

        {

                nsp->children[side] = segment_none;

                nsp->shared_segment::sides[side].wall_num = wall_none; 

        }

        // Form the connection

        destseg->children[destside] = segnum;

//      destseg->sides[destside].render_flag = 0;

        nsp->children[newside] = destseg;

        // Copy vertex indices of the four vertices forming the joint

        auto &dvp = Side_to_verts[destside];

        // Set the vertex indices for the four vertices forming the front of the new side

        range_for (const unsigned v, xrange(4u))

                nsp->verts[v] = destseg->verts[static_cast<int>(dvp[v])];

        // The other 4 vertices must be created.

        // Their coordinates are determined by the 4 welded vertices and the vector from front

        // to back of the original *newseg.

        // Do lots of hideous matrix stuff, about 3/4 of which could probably be simplified out.

        med_extract_matrix_from_segment(destseg, rotmat);               // get orientation matrix for destseg (orthogonal rotation matrix)

        update_matrix_based_on_side(rotmat,destside);

        const auto rotmat1 = vm_vector_2_matrix(forvec,&upvec,nullptr);

        const auto rotmat4 = vm_matrix_x_matrix(rotmat,rotmat1);                        // this is the desired orientation of the new segment

        med_extract_matrix_from_segment(newseg, rotmat3);               // this is the current orientation of the new segment

        vm_transpose_matrix(rotmat3);                                                           // get the inverse of the current orientation matrix

        vm_matrix_x_matrix(rotmat2,rotmat4,rotmat3);                    // now rotmat2 takes the current segment to the desired orientation

        // Warning -- look at this line!

        vm_transpose_matrix(rotmat2);   // added 12:33 pm, 10/01/93

        // Compute and rotate the center point of the attaching face.

        auto &vcvertptr = Vertices.vcptr;

        const auto &&vc0 = compute_center_point_on_side(vcvertptr, newseg, newside);

        const auto vr = vm_vec_rotate(vc0,rotmat2);

        // Now rotate the free vertices in the segment

        std::array<vertex, 4> tvs;

        range_for (const unsigned v, xrange(4u))

                vm_vec_rotate(tvs[v], vcvertptr(newseg->verts[v + 4]), rotmat2);

        // Now translate the new segment so that the center point of the attaching faces are the same.

        const auto &&vc1 = compute_center_point_on_side(vcvertptr, destseg, destside);

        const auto xlate_vec = vm_vec_sub(vc1,vr);

        // Create and add the 4 new vertices.

        range_for (const unsigned v, xrange(4u))

        {

                vm_vec_add2(tvs[v],xlate_vec);

                nsp->verts[v+4] = med_add_vertex(tvs[v]);

        }

        set_vertex_counts();

        // Now all the vertices are in place.  Create the faces.

        validate_segment(vcvertptr, nsp);

        //      Say to not render at the joint.

//      destseg->sides[destside].render_flag = 0;

//      nsp->sides[newside].render_flag = 0;

        Cursegp = nsp;

        return  0;

}

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

// Attach side newside of newseg to side destside of destseg.

// Copies *newseg into global array Segments, increments Num_segments.

// Forms a weld between the two segments by making the new segment fit to the old segment.

// Updates number of faces per side if necessitated by new vertex coordinates.

//      Updates Cursegp.

// Return value:

//  0 = successful attach

//  1 = No room in Segments[].

//  2 = No room in Vertices[].

//  3 = newside != WFRONT -- for now, the new segment must be attached at its (own) front side

//       4 = already a face attached on side newside

int med_attach_segment(const vmsegptridx_t destseg, const vmsegptr_t newseg, int destside, int newside)

{

        int             rval;

        const auto ocursegp = Cursegp;

        vms_angvec      tang = {0,0,0};

        const auto &&rotmat = vm_angles_2_matrix(tang);

        rval = med_attach_segment_rotated(destseg,newseg,destside,newside,rotmat);

        med_propagate_tmaps_to_segments(ocursegp,Cursegp,0);

        med_propagate_tmaps_to_back_side(Cursegp, Side_opposite[newside],0);

        copy_uvs_seg_to_seg(vmsegptr(&New_segment), Cursegp);

        return rval;

}

}

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

//      Delete a vertex, sort of.

//      Decrement the vertex count.  If the count goes to 0, then the vertex is free (has been deleted).

static void delete_vertex(const unsigned v)

{

        Assert(v < MAX_VERTICES);                       // abort if vertex is not in array Vertices

        auto &LevelSharedVertexState = LevelSharedSegmentState.get_vertex_state();

        auto &Vertex_active = LevelSharedVertexState.get_vertex_active();

        Assert(Vertex_active[v] >= 1);  // abort if trying to delete a non-existent vertex

        Vertex_active[v]--;

}

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

//      Update Num_vertices.

//      This routine should be called by anyone who calls delete_vertex.  It could be called in delete_vertex,

//      but then it would be called much more often than necessary, and it is a slow routine.

static void update_num_vertices(void)

{

        auto &LevelSharedVertexState = LevelSharedSegmentState.get_vertex_state();

        auto &Vertices = LevelSharedVertexState.get_vertices();

        // Now count the number of vertices.

        unsigned n = 0;

        auto &Vertex_active = LevelSharedVertexState.get_vertex_active();

        range_for (const auto v, partial_range(Vertex_active, Vertices.get_count()))

                if (v)

                        ++n;

        LevelSharedVertexState.Num_vertices = n;

}

namespace dsx {

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

//      Set Vertex_active to number of occurrences of each vertex.

//      Set Num_vertices.

void set_vertex_counts(void)

{

        auto &LevelSharedVertexState = LevelSharedSegmentState.get_vertex_state();

        auto &Vertex_active = LevelSharedVertexState.get_vertex_active();

        unsigned Num_vertices = 0;

        Vertex_active = {};