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.

*/

/*

 *

 * group functions

 *

 */

#include <stdio.h>

#include <string.h>

#include "gr.h"

#include "ui.h"

#include "inferno.h"

#include "segment.h"

#include "editor/editor.h"

#include "editor/esegment.h"

#include "editor/medmisc.h"

#include "dxxerror.h"

#include "gamemine.h"

#include "physfsx.h"

#include "gameseg.h"

#include "bm.h"                         // For MAX_TEXTURES.

#include "textures.h"

#include "hash.h"

#include "fuelcen.h"

#include "kdefs.h"

#include "fwd-wall.h"

#include "medwall.h"

#include "dxxsconf.h"

#include "compiler-range_for.h"

#include "d_enumerate.h"

#include "d_range.h"

#include "partial_range.h"

#include "segiter.h"

static void validate_selected_segments(void);

struct group_top_fileinfo {

        int     fileinfo_version;

        int     fileinfo_sizeof;

} group_top_fileinfo;    // Should be same as first two fields below...

struct group_fileinfo {

        int     fileinfo_version;

        int     fileinfo_sizeof;

        int     header_offset;                  // Stuff common to game & editor

        int     header_size;

        int     editor_offset;                          // Editor specific stuff

        int     editor_size;

        int     vertex_offset;

        int     vertex_howmany;

        int     vertex_sizeof;

        int     segment_offset;

        int     segment_howmany;

        int     segment_sizeof;

        int     texture_offset;

        uint32_t texture_howmany;

        int     texture_sizeof;

} group_fileinfo;

struct group_header {

        int     num_vertices;

        int     num_segments;

} group_header;

struct group_editor {

        int     current_seg;

        int     newsegment_offset;

        int     newsegment_size;

        int     Groupsegp;

        int     Groupside;

} group_editor;

std::array<group, MAX_GROUPS+1> GroupList;

std::array<segment *, MAX_GROUPS+1> Groupsegp;

std::array<int, MAX_GROUPS+1> Groupside;

std::array<int, MAX_GROUPS+1> Group_orientation;

int             current_group=-1;

unsigned num_groups;

// -- void swap_negate_columns(vms_matrix *rotmat, int col1, int col2)

// -- {

// --   fix     col1_1,col1_2,col1_3;

// --   fix     col2_1,col2_2,col2_3;

// -- 

// --   switch (col1) {

// --           case 0:

// --                   col1_1 = rotmat->m1;

// --                   col1_2 = rotmat->m2;

// --                   col1_3 = rotmat->m3;

// --                   break;

// -- 

// --           case 1:

// --                   col1_1 = rotmat->m4;

// --                   col1_2 = rotmat->m5;

// --                   col1_3 = rotmat->m6;

// --                   break;

// -- 

// --           case 2:

// --                   col1_1 = rotmat->m7;

// --                   col1_2 = rotmat->m8;

// --                   col1_3 = rotmat->m9;

// --                   break;

// --   }

// -- 

// --   switch (col2) {

// --           case 0:

// --                   col2_1 = rotmat->m1;

// --                   col2_2 = rotmat->m2;

// --                   col2_3 = rotmat->m3;

// --                   break;

// -- 

// --           case 1:

// --                   col2_1 = rotmat->m4;

// --                   col2_2 = rotmat->m5;

// --                   col2_3 = rotmat->m6;

// --                   break;

// -- 

// --           case 2:

// --                   col2_1 = rotmat->m7;

// --                   col2_2 = rotmat->m8;

// --                   col2_3 = rotmat->m9;

// --                   break;

// --   }

// -- 

// --   switch (col2) {

// --           case 0:

// --                   rotmat->m1 = -col1_1;

// --                   rotmat->m2 = -col1_2;

// --                   rotmat->m3 = -col1_3;

// --                   break;

// -- 

// --           case 1:

// --                   rotmat->m4 = -col1_1;

// --                   rotmat->m5 = -col1_2;

// --                   rotmat->m6 = -col1_3;

// --                   break;

// -- 

// --           case 2:

// --                   rotmat->m7 = -col1_1;

// --                   rotmat->m8 = -col1_2;

// --                   rotmat->m9 = -col1_3;

// --                   break;

// --   }

// -- 

// --   switch (col1) {

// --           case 0:

// --                   rotmat->m1 = -col2_1;

// --                   rotmat->m2 = -col2_2;

// --                   rotmat->m3 = -col2_3;

// --                   break;

// -- 

// --           case 1:

// --                   rotmat->m4 = -col2_1;

// --                   rotmat->m5 = -col2_2;

// --                   rotmat->m6 = -col2_3;

// --                   break;

// -- 

// --           case 2:

// --                   rotmat->m7 = -col2_1;

// --                   rotmat->m8 = -col2_2;

// --                   rotmat->m9 = -col2_3;

// --                   break;

// --   }

// -- 

// -- }

// -- 

// -- void swap_negate_rows(vms_matrix *rotmat, int row1, int row2)

// -- {

// --   fix     row1_1,row1_2,row1_3;

// --   fix     row2_1,row2_2,row2_3;

// -- 

// --   switch (row1) {

// --           case 0:

// --                   row1_1 = rotmat->m1;

// --                   row1_2 = rotmat->m4;

// --                   row1_3 = rotmat->m7;

// --                   break;

// -- 

// --           case 1:

// --                   row1_1 = rotmat->m2;

// --                   row1_2 = rotmat->m5;

// --                   row1_3 = rotmat->m8;

// --                   break;

// -- 

// --           case 2:

// --                   row1_1 = rotmat->m3;

// --                   row1_2 = rotmat->m6;

// --                   row1_3 = rotmat->m9;

// --                   break;

// --   }

// -- 

// --   switch (row2) {

// --           case 0:

// --                   row2_1 = rotmat->m1;

// --                   row2_2 = rotmat->m4;

// --                   row2_3 = rotmat->m7;

// --                   break;

// -- 

// --           case 1:

// --                   row2_1 = rotmat->m2;

// --                   row2_2 = rotmat->m5;

// --                   row2_3 = rotmat->m8;

// --                   break;

// -- 

// --           case 2:

// --                   row2_1 = rotmat->m3;

// --                   row2_2 = rotmat->m6;

// --                   row2_3 = rotmat->m9;

// --                   break;

// --   }

// -- 

// --   switch (row2) {

// --           case 0:

// --                   rotmat->m1 = -row1_1;

// --                   rotmat->m4 = -row1_2;

// --                   rotmat->m7 = -row1_3;

// --                   break;

// -- 

// --           case 1:

// --                   rotmat->m2 = -row1_1;

// --                   rotmat->m5 = -row1_2;

// --                   rotmat->m8 = -row1_3;

// --                   break;

// -- 

// --           case 2:

// --                   rotmat->m3 = -row1_1;

// --                   rotmat->m6 = -row1_2;

// --                   rotmat->m9 = -row1_3;

// --                   break;

// --   }

// -- 

// --   switch (row1) {

// --           case 0:

// --                   rotmat->m1 = -row2_1;

// --                   rotmat->m4 = -row2_2;

// --                   rotmat->m7 = -row2_3;

// --                   break;

// -- 

// --           case 1:

// --                   rotmat->m2 = -row2_1;

// --                   rotmat->m5 = -row2_2;

// --                   rotmat->m8 = -row2_3;

// --                   break;

// -- 

// --           case 2:

// --                   rotmat->m3 = -row2_1;

// --                   rotmat->m6 = -row2_2;

// --                   rotmat->m9 = -row2_3;

// --                   break;

// --   }

// -- 

// -- }

// -- 

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

// -- void      side_based_matrix(vms_matrix *rotmat,int destside)

// -- {

// --   vms_angvec      rotvec;

// --   vms_matrix      r1,rtemp;

// -- 

// --   switch (destside) {

// --           case WLEFT:

// -- //                        swap_negate_columns(rotmat,1,2);

// -- //                        swap_negate_rows(rotmat,1,2);

// --                   break;

// -- 

// --           case WTOP:

// --                   break;

// -- 

// --           case WRIGHT:

// -- //                        swap_negate_columns(rotmat,1,2);

// -- //                        swap_negate_rows(rotmat,1,2);

// --                   break;

// -- 

// --           case WBOTTOM:

// --                   break;

// -- 

// --           case WFRONT:

// --                   break;

// -- 

// --           case WBACK:

// --                   break;

// --   }

// -- 

// -- }

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

//      Rotate a group about a point.

//      The segments in the group are indicated (by segment number) in group_seglist.  There are group_size segments.

//      The point about which the groups is rotated is the center of first_seg:first_side.

//      delta_flag:

//              0       absolute rotation, destination specified in terms of base_seg:base_side, used in moving or copying a group

//              1       relative rotation, destination specified relative to current orientation of first_seg:first_side

//      Note: The group must exist in the mine, consisting of actual points in the world.  If any points in the

//                      segments in the group are shared by segments not in the group, those points will get rotated and the

//                      segments not in the group will have their shapes modified.

//      Return value:

//              0       group rotated

//              1       unable to rotate group

static void med_create_group_rotation_matrix(vms_matrix &result_mat, int delta_flag, const vcsegptr_t first_seg, int first_side, const vcsegptr_t base_seg, int base_side, const vms_matrix &orient_matrix, int orientation)

{

        vms_matrix      rotmat2,rotmat,rotmat3,rotmat4;

        vms_angvec      pbh = {0,0,0};

        //      Determine whether this rotation is a delta rotation, meaning to just rotate in place, or an absolute rotation,

        //      which means that the destination rotation is specified, not as a delta, but as an absolute

        if (delta_flag) {

                //      Create rotation matrix describing rotation.

                med_extract_matrix_from_segment(first_seg, rotmat4);            // get rotation matrix describing current orientation of first seg

                update_matrix_based_on_side(rotmat4, first_side);

                rotmat3 = vm_transposed_matrix(orient_matrix);

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

                vm_transpose_matrix(rotmat4);

                vm_matrix_x_matrix(rotmat2,vm_desired_orientation,rotmat4);                     // this is the desired orientation of the new segment

        } else {

                //      Create rotation matrix describing rotation.

                med_extract_matrix_from_segment(base_seg, rotmat);              // get rotation matrix describing desired orientation

                update_matrix_based_on_side(rotmat, base_side);                         // modify rotation matrix for desired side

                //      If the new segment is to be attached without rotation, then its orientation is the same as the base_segment

                vm_matrix_x_matrix(rotmat4,rotmat,orient_matrix);                       // this is the desired orientation of the new segment

                pbh.b = orientation*16384;

                vm_angles_2_matrix(rotmat3,pbh);

                rotmat4 = rotmat = vm_matrix_x_matrix(rotmat4, rotmat3);

                med_extract_matrix_from_segment(first_seg, rotmat3);            // get rotation matrix describing current orientation of first seg

                // It is curious that the following statement has no analogue in the med_attach_segment_rotated code.

                //      Perhaps it is because segments are always attached at their front side.  If the back side is the side

                //      passed to the function, then the matrix is not modified, which might suggest that what you need to do below

                //      is use Side_opposite[first_side].

                update_matrix_based_on_side(rotmat3, Side_opposite[first_side]);                                // modify rotation matrix for desired side

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

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

        }

        result_mat = rotmat2;

}

static inline vms_matrix med_create_group_rotation_matrix(int delta_flag, const vcsegptr_t first_seg, int first_side, const vcsegptr_t base_seg, int base_side, const vms_matrix &orient_matrix, int orientation)

{

        vms_matrix result_mat;

        return med_create_group_rotation_matrix(result_mat, delta_flag, first_seg, first_side, base_seg, base_side, orient_matrix, orientation), result_mat;

}

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

// Rotate all vertices and objects in group.

static void med_rotate_group(const vms_matrix &rotmat, group::segment_array_type_t &group_seglist, const vcsegptr_t first_seg, int first_side)

{

        auto &LevelSharedVertexState = LevelSharedSegmentState.get_vertex_state();

        auto &Objects = LevelUniqueObjectState.Objects;

        auto &Vertices = LevelSharedVertexState.get_vertices();

        auto &vmobjptridx = Objects.vmptridx;

        std::array<int8_t, MAX_VERTICES> vertex_list;

        auto &vcvertptr = Vertices.vcptr;

        auto &vmvertptridx = Vertices.vmptridx;

        const auto &&rotate_center = compute_center_point_on_side(vcvertptr, first_seg, first_side);

        //      Create list of points to rotate.

        vertex_list = {};

        range_for (const auto &gs, group_seglist)

        {

                auto &sp = *vmsegptr(gs);

                range_for (const auto v, sp.verts)

                        vertex_list[v] = 1;

                //      Rotate center of all objects in group.

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

                {

                        const auto tv1 = vm_vec_sub(objp->pos,rotate_center);

                        const auto tv = vm_vec_rotate(tv1,rotmat);

                        vm_vec_add(objp->pos, tv, rotate_center);

                }                      

        }

        // Do the pre-rotation xlate, do the rotation, do the post-rotation xlate

        range_for (auto &&v, vmvertptridx)

                if (vertex_list[v]) {

                        const auto &&tv1 = vm_vec_sub(*v, rotate_center);

                        const auto tv = vm_vec_rotate(tv1,rotmat);

                        vm_vec_add(*v, tv, rotate_center);

                }

}

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

static void cgl_aux(const vmsegptridx_t segp, group::segment_array_type_t &seglistp, selected_segment_array_t *ignore_list, visited_segment_bitarray_t &visited)

{

        if (ignore_list)

                if (ignore_list->contains(segp))

                        return;

        if (!visited[segp]) {

                visited[segp] = true;

                seglistp.emplace_back(segp);

                range_for (const auto c, segp->children)

                        if (IS_CHILD(c))

                                cgl_aux(segp.absolute_sibling(c), seglistp, ignore_list, visited);

        }

}

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

//      Sets Been_visited[n] if n is reachable from segp

static void create_group_list(const vmsegptridx_t segp, group::segment_array_type_t &seglistp, selected_segment_array_t *ignore_list)

{

        visited_segment_bitarray_t visited;

        cgl_aux(segp, seglistp, ignore_list, visited);

}

#define MXS MAX_SEGMENTS

#define MXV MAX_VERTICES

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

static void duplicate_group(std::array<uint8_t, MAX_VERTICES> &vertex_ids, group::segment_array_type_t &segments)

{

        auto &LevelSharedVertexState = LevelSharedSegmentState.get_vertex_state();

        auto &Objects = LevelUniqueObjectState.Objects;

        auto &Vertices = LevelSharedVertexState.get_vertices();

        auto &vmobjptridx = Objects.vmptridx;

        group::segment_array_type_t new_segments;

        std::array<int, MAX_VERTICES> new_vertex_ids;           // If new_vertex_ids[v] != -1, then vertex v has been remapped to new_vertex_ids[v]

        //      duplicate vertices

        new_vertex_ids.fill(-1);

        //      duplicate vertices

        auto &vcvertptridx = Vertices.vcptridx;

        range_for (auto &&v, vcvertptridx)

        {

                if (vertex_ids[v])

                {

                        new_vertex_ids[v] = med_create_duplicate_vertex(*v);

                }

        }

        //      duplicate segments

        range_for(const auto &gs, segments)

        {

                const auto &&segp = vmsegptr(gs);

                const auto &&new_segment_id = med_create_duplicate_segment(Segments, segp);

                new_segments.emplace_back(new_segment_id);

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

                {

                        if (objp->type != OBJ_PLAYER) {

                                const auto &&new_obj_id = obj_create_copy(objp, vmsegptridx(new_segment_id));

                                (void)new_obj_id; // FIXME!

                        }

                }

        }

        //      Now, for each segment in segment_ids, correct its children numbers by translating through new_segment_ids

        //      and correct its vertex numbers by translating through new_vertex_ids

        range_for(const auto &gs, new_segments)

        {

                auto &sp = *vmsegptr(gs);

                range_for (auto &seg, sp.children)

                {

                        if (IS_CHILD(seg)) {

                                group::segment_array_type_t::iterator inew = new_segments.begin();

                                range_for (const auto i, segments)

                                {

                                        if (seg == i)

                                        {

                                                seg = *inew;

                                                break;

                                        }

                                        ++inew;

                                }

                        }

                }       // end for (sidenum=0...

                //      Now fixup vertex ids

                range_for (auto &v, sp.verts)

                {

                        if (vertex_ids[v]) {

                                v = new_vertex_ids[v];

                        }

                }

        }       // end for (s=0...

        //      Now, copy new_segment_ids into segment_ids

        segments = new_segments;

        //      Now, copy new_vertex_ids into vertex_ids

        vertex_ids = {};

        range_for (auto &v, new_vertex_ids)

                if (v != -1)

                        vertex_ids[v] = 1;

}

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

static int in_group(segnum_t segnum, int group_num)

{

        range_for(const auto& s, GroupList[group_num].segments)

                if (segnum == s)

                        return 1;

        return 0;

}

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

//      Copy a group of segments.

//      The group is defined as all segments accessible from group_seg.

//      The group is copied so group_seg:group_side is incident upon base_seg:base_side.

//      group_seg and its vertices are bashed to coincide with base_seg.

//      If any vertex of base_seg is contained in a segment that is reachable from group_seg, then errror.

static int med_copy_group(int delta_flag, const vmsegptridx_t base_seg, int base_side, vcsegptr_t group_seg, int group_side, const vms_matrix &orient_matrix)

{

        auto &LevelSharedVertexState = LevelSharedSegmentState.get_vertex_state();

        auto &Objects = LevelUniqueObjectState.Objects;

        auto &Vertices = LevelSharedVertexState.get_vertices();

        auto &vmobjptridx = Objects.vmptridx;

        int                     x;

        int                     new_current_group;

        if (IS_CHILD(base_seg->children[base_side])) {

                editor_status("Error -- unable to copy group, base_seg:base_side must be free.");

                return 1;

        }

        if (num_groups == MAX_GROUPS) {

                x = ui_messagebox( -2, -2, 2, "Warning: You have reached the MAXIMUM group number limit. Continue?", "No", "Yes" );

                if (x==1)

                        return 0;

        }

        if (num_groups < MAX_GROUPS) {

                num_groups++;

                new_current_group = num_groups-1;

        } else

                new_current_group = 0;

        Assert(current_group >= 0);

        // Find groupsegp index

        auto gb = GroupList[current_group].segments.begin();

        auto ge = GroupList[current_group].segments.end();

        auto gp = Groupsegp[current_group];

        auto gi = std::find_if(gb, ge, [gp](const segnum_t segnum){ return vcsegptr(segnum) == gp; });

        int gs_index = (gi == ge) ? 0 : std::distance(gb, gi);

        GroupList[new_current_group] = GroupList[current_group];

        //      Make a list of all vertices in group.

        std::array<uint8_t, MAX_VERTICES> in_vertex_list{};

        if (group_seg == &New_segment)

                range_for (auto &v, group_seg->verts)

                        in_vertex_list[v] = 1;

        else {

                range_for(const auto &gs, GroupList[new_current_group].segments)

                        range_for (auto &v, vmsegptr(gs)->verts)

                                in_vertex_list[v] = 1;

        }

        // Given a list of vertex indices (indicated by !0 in in_vertex_list) and segment indices (in list GroupList[current_group].segments, there

        //      are GroupList[current_group].num_segments segments), copy all segments and vertices

        //      Return updated lists of vertices and segments in in_vertex_list and GroupList[current_group].segments

        duplicate_group(in_vertex_list, GroupList[new_current_group].segments);

        //group_seg = &Segments[GroupList[new_current_group].segments[0]];                                      // connecting segment in group has been changed, so update group_seg

        {

                const auto &&gs = vmsegptr(GroupList[new_current_group].segments[gs_index]);

                group_seg = gs;

                Groupsegp[new_current_group] = gs;

        }

        Groupside[new_current_group] = Groupside[current_group];

        range_for(const auto &gs, GroupList[new_current_group].segments)

        {

                auto &s = *vmsegptr(gs);

                s.group = new_current_group;

                s.special = SEGMENT_IS_NOTHING;

                s.matcen_num = -1;

        }

        auto &vcvertptr = Vertices.vcptr;

        // Breaking connections between segments in the current group and segments not in the group.

        range_for(const auto &gs, GroupList[new_current_group].segments)

        {

                const auto &&segp = base_seg.absolute_sibling(gs);

                range_for (const auto &&es, enumerate(segp->children))

                        if (IS_CHILD(es.value))

                        {

                                if (!in_group(es.value, new_current_group))

                                {

                                        es.value = segment_none;

                                        validate_segment_side(vcvertptr, segp, es.idx);                                 // we have converted a connection to a side so validate the segment

                                }

                        }

        }

        copy_uvs_seg_to_seg(vmsegptr(&New_segment), group_seg);

        //      Now do the copy

        //      First, xlate all vertices so center of group_seg:group_side is at origin

        const auto &&srcv = compute_center_point_on_side(vcvertptr, group_seg, group_side);

        auto &vmvertptridx = Vertices.vmptridx;

        range_for (auto &&v, vmvertptridx)

                if (in_vertex_list[v])

                        vm_vec_sub2(*v, srcv);

        //      Now, translate all object positions.

        range_for(const auto &segnum, GroupList[new_current_group].segments)

        {

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

                        vm_vec_sub2(objp->pos, srcv);

        }

        //      Now, rotate segments in group so orientation of group_seg is same as base_seg.

        const auto rotmat = med_create_group_rotation_matrix(delta_flag, group_seg, group_side, base_seg, base_side, orient_matrix, 0);

        med_rotate_group(rotmat, GroupList[new_current_group].segments, group_seg, group_side);

        //      Now xlate all vertices so group_seg:group_side shares center point with base_seg:base_side

        const auto &&destv = compute_center_point_on_side(vcvertptr, base_seg, base_side);

        range_for (auto &&v, vmvertptridx)

                if (in_vertex_list[v])

                        vm_vec_add2(*v, destv);

        //      Now, xlate all object positions.

        range_for(const auto &segnum, GroupList[new_current_group].segments)

        {

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

                        vm_vec_add2(objp->pos, destv);

        }

        //      Now, copy all walls (ie, doors, illusionary, etc.) into the new group.

        copy_group_walls(current_group, new_current_group);

        current_group = new_current_group;

        //      Now, form joint on connecting sides.

        med_form_joint(base_seg,base_side,vmsegptridx(Groupsegp[current_group]),Groupside[new_current_group]);

        validate_selected_segments();

        med_combine_duplicate_vertices(in_vertex_list);

        return 0;

}

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

//      Move a group of segments.

//      The group is defined as all segments accessible from group_seg.

//      The group is moved so group_seg:group_side is incident upon base_seg:base_side.

//      group_seg and its vertices are bashed to coincide with base_seg.

//      If any vertex of base_seg is contained in a segment that is reachable from group_seg, then errror.

static int med_move_group(int delta_flag, const vmsegptridx_t base_seg, int base_side, const vmsegptridx_t group_seg, int group_side, const vms_matrix &orient_matrix, int orientation)

{

        auto &LevelSharedVertexState = LevelSharedSegmentState.get_vertex_state();

        auto &Objects = LevelUniqueObjectState.Objects;

        auto &Vertices = LevelSharedVertexState.get_vertices();

        auto &vmobjptridx = Objects.vmptridx;

        if (IS_CHILD(base_seg->children[base_side]))

                if (base_seg->children[base_side] != group_seg) {

                        editor_status("Error -- unable to move group, base_seg:base_side must be free or point to group_seg.");

                        return 1;

        }

//      // See if any vertices in base_seg are contained in any vertex in group_list

//      for (v=0; v<MAX_VERTICES_PER_SEGMENT; v++)

//              for (s=0; s<GroupList[current_group].num_segments; s++)

//                      for (vv=0; vv<MAX_VERTICES_PER_SEGMENT; vv++)

//                              if (Segments[GroupList[current_group].segments[s]].verts[vv] == base_seg->verts[v]) {

//                                      editor_status("Error -- unable to move group, it shares a vertex with destination segment.");

//                                      return 1;

//                              }

        std::array<uint8_t, MAX_VERTICES> in_vertex_list{};

        std::array<int8_t, MAX_VERTICES> out_vertex_list{};

        //      Make a list of all vertices in group.

        range_for(const auto &gs, GroupList[current_group].segments)

                range_for (auto &v, vmsegptr(gs)->verts)

                        in_vertex_list[v] = 1;

        //      For all segments which are not in GroupList[current_group].segments, mark all their vertices in the out list.

        range_for (const auto &&segp, vmsegptridx)

        {

                if (!GroupList[current_group].segments.contains(segp))

                        {

                                range_for (auto &v, segp->verts)

                                        out_vertex_list[v] = 1;

                        }

        }

        //      Now, for all vertices present in both the in (part of group segment) and out (part of non-group segment)

        // create an extra copy of the vertex so we can just move the ones in the in list.

        //      Can't use Highest_vertex_index as loop termination because it gets increased by med_create_duplicate_vertex.

        auto &vcvertptr = Vertices.vcptr;

        auto &vmvertptridx = Vertices.vmptridx;

        range_for (auto &&v, vmvertptridx)

                if (in_vertex_list[v])

                        if (out_vertex_list[v]) {

                                const auto new_vertex_id = med_create_duplicate_vertex(*v);

                                in_vertex_list[v] = 0;

                                in_vertex_list[new_vertex_id] = 1;

                                // Create a new vertex and assign all occurrences of vertex v in IN list to new vertex number.

                                range_for(const auto &gs, GroupList[current_group].segments)

                                {

                                        auto &sp = *vmsegptr(gs);

                                        range_for (auto &vv, sp.verts)

                                                if (vv == v)

                                                        vv = new_vertex_id;

                                }

                        }

        range_for(const auto &gs, GroupList[current_group].segments)

                vmsegptr(gs)->group = current_group;

        // Breaking connections between segments in the group and segments not in the group.

        range_for(const auto &gs, GroupList[current_group].segments)

                {

                const auto &&segp = base_seg.absolute_sibling(gs);

                range_for (const auto &&es0, enumerate(segp->children))

                        if (IS_CHILD(es0.value))

                                {

                                const auto &&csegp = base_seg.absolute_sibling(es0.value);

                                if (csegp->group != current_group)

                                        {

                                        range_for (const auto &&es1, enumerate(csegp->children))

                                                if (IS_CHILD(es1.value))

                                                        {

                                                        auto &dsegp = *vmsegptr(es1.value);

                                                        if (dsegp.group == current_group)

                                                                {

                                                                es1.value = segment_none;

                                                                validate_segment_side(vcvertptr, csegp, es1.idx);                                       // we have converted a connection to a side so validate the segment

                                                                }

                                                        }

                                        es0.value = segment_none;

                                        validate_segment_side(vcvertptr, segp, es0.idx);                                        // we have converted a connection to a side so validate the segment

                                        }

                                }

                }

        copy_uvs_seg_to_seg(vmsegptr(&New_segment), vcsegptr(Groupsegp[current_group]));

        //      Now do the move

        //      First, xlate all vertices so center of group_seg:group_side is at origin

        const auto &&srcv = compute_center_point_on_side(vcvertptr, group_seg, group_side);

        range_for (auto &&v, vmvertptridx)

                if (in_vertex_list[v])

                        vm_vec_sub2(*v, srcv);

        //      Now, move all object positions.

        range_for(const auto &segnum, GroupList[current_group].segments)

        {

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

                        vm_vec_sub2(objp->pos, srcv);

        }

        //      Now, rotate segments in group so orientation of group_seg is same as base_seg.

        const auto rotmat = med_create_group_rotation_matrix(delta_flag, group_seg, group_side, base_seg, base_side, orient_matrix, orientation);

        med_rotate_group(rotmat, GroupList[current_group].segments, group_seg, group_side);

        //      Now xlate all vertices so group_seg:group_side shares center point with base_seg:base_side

        const auto &&destv = compute_center_point_on_side(vcvertptr, base_seg, base_side);

        range_for (auto &&v, vmvertptridx)

                if (in_vertex_list[v])

                        vm_vec_add2(*v, destv);

        //      Now, rotate all object positions.

        range_for(const auto &segnum, GroupList[current_group].segments)

        {

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

                        vm_vec_add2(objp->pos, destv);

        }

        //      Now, form joint on connecting sides.

        med_form_joint(base_seg,base_side,group_seg,group_side);

        validate_selected_segments();

        med_combine_duplicate_vertices(in_vertex_list);

        return 0;

}

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

static segnum_t place_new_segment_in_world(void)

{

        auto &LevelSharedVertexState = LevelSharedSegmentState.get_vertex_state();

        auto &Vertices = LevelSharedVertexState.get_vertices();

        const auto &&segnum = Segments.vmptridx(get_free_segment_number(Segments));

        auto &seg = *segnum;

        seg = New_segment;

        auto &vcvertptr = Vertices.vcptr;

        range_for (const unsigned v, xrange(MAX_VERTICES_PER_SEGMENT))

                seg.verts[v] = med_create_duplicate_vertex(vcvertptr(New_segment.verts[v]));

        return segnum;

}

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

//      Attach segment in the new-fangled way, which is by using the CopyGroup code.

static int AttachSegmentNewAng(const vms_angvec &pbh)

{

        auto &LevelSharedVertexState = LevelSharedSegmentState.get_vertex_state();

        auto &Vertices = LevelSharedVertexState.get_vertices();

        GroupList[current_group].segments.clear();

        const auto newseg = place_new_segment_in_world();

        GroupList[current_group].segments.emplace_back(newseg);

        const auto &&nsegp = vmsegptridx(newseg);

        if (!med_move_group(1, Cursegp, Curside, nsegp, AttachSide, vm_angles_2_matrix(pbh),0))