/*
* Descent 3
* Copyright (C) 2024 Parallax Software
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program.  If not, see <http://www.gnu.org/licenses/>.

--- HISTORICAL COMMENTS FOLLOW ---

 * $Logfile: /DescentIII/Main/editor/HRoom.cpp $
 * $Revision: 1.1.1.1 $
 * $Date: 2003-08-26 03:57:38 $
 * $Author: kevinb $
 *
 * Code to implement room functions
 *
 * $Log: not supported by cvs2svn $
 *
 * 106   9/15/99 1:56p Matt
 * Added the option to allow rooms or groups placed on the terrain to
 * either align with the terrain or with gravity.
 *
 * 105   9/07/99 12:10p Matt
 * Added a function to propagate a texture to all adjacent coplanar faces
 * in a room.
 *
 * 104   8/30/99 1:00p Gwar
 * use the "true" center of faces for determining attach points in room
 * connecting functions
 *
 * 103   8/19/99 6:57p Gwar
 * call ned_FindSharedEdge in CombineFaces to see if we can't combine
 * because of a flipped normal
 *
 * 102   8/17/99 7:11p Gwar
 *
 * 101   8/17/99 12:08p Gwar
 * don't set World_changed in functions that can be called from palette
 * rooms
 *
 * 100   8/12/99 12:08a Gwar
 * NEWEDITOR: texture, door and object memory management; and call SetPrim
 * when changing Curroomp, which now force unmarks everything in current
 * room view
 *
 * 99    7/04/99 4:55p Gwar
 * changes for texture management in NEWEDITOR
 *
 * 98    5/08/99 6:39p Matt
 * Added a function to delete a face and all faces connected to it.
 *
 * 97    5/04/99 12:32p Matt
 * Fixed stupid bug and stupider bug.
 *
 * 96    4/30/99 6:52p Matt
 * Added a function to merge an object's geometry into a room.
 *
 * 95    4/28/99 12:51a Matt
 * Added some funtions to edit face geometry.
 *
 * 94    4/25/99 2:38p Gwar
 * brought in HRoom.cpp and RoomUVs.cpp, and several misc game functions
 * were added to globals.cpp to make it possible
 *
 * 93    4/19/99 12:10a Matt
 * Added a menu item to delete a vertex from a face.
 *
 * 92    4/18/99 11:26p Matt
 * Restored point-to-plane check to FixCracks().  This check is necessary
 * because the point-to-edge check assumes that the points are all in the
 * same plane, and will not work if they are not.
 *
 * 91    4/07/99 4:39p Matt
 * In link to new external room, copy the textures from the old faces to
 * the new faces.
 *
 * 90    4/07/99 1:50p Matt
 * Took point-in-plane check out of fix level cracks, because it prevented
 * tjoints from being fixed for some non-planar faces.
 *
 * 89    4/06/99 3:48p Matt
 * Allow combining of rooms with rendered portals.
 *
 * 88    4/06/99 10:23a Matt
 *
 * 87    4/01/99 2:55p Matt
 * Fixed triangulate face code to deal with colinear points
 *
 * 86    4/01/99 1:25p Matt
 * Fixed bug in MatchPortalFaces when checking for match and a colinear
 * point was found.
 *
 * 85    3/31/99 12:58p Matt
 * Added snap-point-to-face
 *
 * 84    3/30/99 8:03p Matt
 * Deleted commented-out code
 *
 * 83    3/30/99 8:01p Matt
 * Took out normals-are-same check when combining adjacent faces.  It was
 * the wrong way to check the faces (the right way (in the D3 editor, that
 * is) is to check for point in the plane) and we were only using it as a
 * first-pass check anyway.
 *
 * 82    3/30/99 6:25p Matt
 * Use new error system for combine faces function.
 *
 * 81    3/29/99 6:46p Matt
 * When combining faces, use FaceIsPlanar() so the face will pass mine
 * verification.
 *
 * 80    3/27/99 5:01p Matt
 * Fixed stupid bug in build bridge code, that assigned UVs to all faces
 * instead of one face, causing an Int3 sometimes for faces that hadn't
 * yet had normals computed.
 *
 * 79    3/27/99 4:45p Matt
 * Fixed a surprising fundamental flaw in the polygon clip code.
 *
 * 78    3/23/99 5:12p Matt
 * Added function to combine rooms.
 *
 * 77    2/27/99 3:47p Mark
 * Place room on terrain was improperly clearing out the placed door.
 * (MattT on Mark's machine)
 *
 * 76    1/29/99 12:48p Matt
 * Rewrote the doorway system
 *
 * 75    1/21/99 11:34a Matt
 * Got rid of portal triggers.  Since we don't have multi-face portals, a
 * face trigger works fine for a portal.  Also fixed a few editor/trigger
 * bugs.
 *
 * 74    12/23/98 6:32p Matt
 * Changed, slightly, the process of creating a new face
 *
 * 73    12/23/98 10:53a Matt
 * Added functions to create a face
 *
 * 72    10/07/98 12:48p Matt
 * Added some extra error checking to prevent doubly-formed portals.
 *
 * 71    10/03/98 8:31p Matt
 * Added Join Rooms Exact function.
 *
 * 70    9/25/98 5:25p Matt
 * Don't try to fix cracks in unused rooms.
 *
 * 69    9/24/98 5:00p Matt
 * Improved error checking for running out of rooms.
 *
 * 68    9/16/98 10:02a Matt
 * Fixed serval bugs, in JoinAllOverlappingFaces() and MatchPortalFaces().
 *
 * 67    9/11/98 4:46p Matt
 * Don't allow combining of portal faces, pending code to do the combine
 * correctly.
 *
 * 66    9/10/98 6:38p Matt
 * Deal with error joining faces after smooth bridge.
 *
 * 65    9/09/98 4:07p Matt
 * Added Smooth Bridge function
 *
 * 64    9/08/98 3:25p Matt
 * Changed an error message.
 *
 * 63    9/08/98 12:05p Jason
 * moved doorway.h out of room.h
 *
 * 62    9/07/98 10:58p Matt
 * Added snap point to point.
 *
 * 61    9/07/98 8:14p Matt
 * Don't delete colinear points (& thus form t-joints) when combining
 * faces, and deal properly with combining faces that share multiple
 * edges.
 *
 * 60    9/04/98 3:34p Matt
 * Added groovy vertex snap code
 *
 * 59    9/04/98 12:29p Matt
 * Added marked edge & vertex in the editor
 *
 * 58    9/04/98 11:34a Matt
 * Fixed small bug in portal matching code, that caused one point on the
 * portals not to be set exactly the same.
 *
 * 57    9/03/98 5:29p Matt
 * Added code to fix cracks in levels.
 *
 * 56    9/02/98 5:57p Matt
 * Added code to make faces match exactly when forming a portal.  This
 * should get rid of all remaining cracking problems.
 *
 * 55    9/02/98 4:07p Matt
 * Fixed one kind of cracking:  after clip, make sure old points that
 * more-or-less line up are exactly the same.
 *
 * 54    9/02/98 2:29p Matt
 * Added code to prevent t-joints from being formed when joining rooms
 *
 * 53    9/01/98 12:04p Matt
 * Ripped out multi-face portal code
 *
 * 52    8/28/98 6:21p Matt
 * Added a function to flip a face.
 *
 * 51    8/24/98 3:02p Matt
 * Gave the user the option, when joining rooms, of extruding straight out
 * or toward the center of the base face.
 *
 * 50    7/01/98 7:53p Matt
 * Added code to allow forcing of join even when the two rooms stick
 * through each other.
 *
 * 49    6/25/98 7:15p Matt
 * Added a function to delete a pair of portals.
 *
 * 48    6/23/98 2:45p Matt
 * Added option when propagating to all faces in a room to only do so to
 * ones with the same texture.
 *
 * 47    6/08/98 12:28p Matt
 * Added a function to triangulate a face
 *
 * 46    5/22/98 4:47p Matt
 * Added menu item to propagate a texture to all the faces in a room.
 *
 * 45    4/27/98 6:41p Matt
 * Added code to join all adjacent faces between two rooms
 *
 * 44    4/17/98 6:25p Matt
 * In CheckFaceToPlane(), store the distance in a variable so it can be
 * looked at in the debugger.
 *
 * 43    4/17/98 6:23p Matt
 * Added code to make sure that the two faces of a portal have the same
 * number of vertices, but commented it out for now.  See the note in the
 * code.
 *
 * 42    4/16/98 11:50a Matt
 * Made snap code work for placed groups.
 *
 * 41    4/07/98 4:19p Matt
 * Fixed (I hope) a problem joining faces that matched perfectly.
 *
 * 40    4/02/98 12:23p Jason
 * trimmed some fat from our structures
 *
 * 39    4/01/98 5:55p Matt
 * Partially re-wrote JoinRooms() to allow creation of adjacent portals.
 *
 * 38    2/18/98 2:26a Matt
 * Fixed typo
 *
 * 37    2/16/98 2:53p Matt
 * Deal with small floating-point precision problem.
 *
 * 36    2/16/98 1:27p Matt
 * Added function to snap the placed room to a vertex/edge on the base
 * room/face
 *
 * 35    2/11/98 12:38p Matt
 * Added epsilon to point-to-plane check
 *
 * 34    2/08/98 6:02p Matt
 * Use groovy new vm_MatrixMulTMatrix() function
 *
 * 33    2/04/98 6:23p Matt
 * Changed object room number to indicate a terrain cell via a flag.  Got
 * rid of the object flag which used to indicate terrain.
 *
 * 32    1/30/98 1:27p Matt
 * Orthogonalize after computing rotation matrix for placed rooms (fixed
 * probem of bad matrix making rooms bigger).
 *
 * 31    1/21/98 12:40p Matt
 * When attaching a room to the ground, delete the room's attach face
 *
 * 30    1/21/98 12:32p Matt
 * Revamped viewer system
 *
 * 29    1/20/98 4:43p Matt
 * Fixed up the bridge and join functions
 *
 * 28    1/15/98 7:34p Matt
 * Revamped error checking when computing face normals
 *
 * 27    11/17/97 7:39p Sean
 * Changed join epsilon, and took out a return from a bogus error message
 * (Matt on Sean's machine)
 *
 * 26    11/06/97 6:47p Sean
 * FROM JASON: Changed <Highest_room_index to <=
 *
 * 25    11/05/97 7:13p Matt
 * Added join rooms function
 *
 * 24    10/03/97 3:38p Matt
 * Added place and attach code for rooms on the terrain
 *
 * 23    10/01/97 7:51p Matt
 * Added code for external rooms
 *
 * 22    9/29/97 12:09p Jason
 * added functionality to doorway system
 *
 * 21    9/26/97 6:01p Matt
 * Fixed delete room code so that Curroomp is never NULL
 *
 * 20    9/24/97 3:22p Matt
 * Added Drop Room function
 *
 * 19    9/15/97 5:56p Matt
 * Changed message (& fixed handling) when user tries to delete a room
 * attached to the terrain.
 *
 * 18    9/12/97 9:01p Craig
 * Fixed orientation of door object (Matt on Craig's machine)
 *
 * 17    9/12/97 5:38p Jason
 * got doors working
 *
 * 16    9/11/97 5:38p Jason
 * initial door coding for room engine
 *
 * 15    9/06/97 3:18p Matt
 * Use LinkRoomsSimple() when adding, attaching, & bridging
 * Reset Curportal when switch rooms
 *
 * 14    9/04/97 4:39p Matt
 * Added includes needed as a result of removing includes from d3edit.h
 *
 * 13    9/02/97 2:26p Matt
 * Made ComputePlacedRoomMatrix() deal w/ placed rooms or groups
 * Made polygon clipper deal with points on the the edge of the clip
 * polygon
 *
 * 12    8/29/97 5:43p Matt
 * Moved some funcs to erooms.cpp, and fixed some stuff for selected rooms
 *
 * 11    8/27/97 10:30a Matt
 * Fixed bogosity assigning UVs to faces in add room
 *
 * 10    8/22/97 9:30a Matt
 * When adding a room, make the new room the current room, and make the
 * face opposite the connection the current one.  That way you can add
 * several times in a row to create a long tunnel.
 *
 * 9     8/21/97 6:01p Matt
 * Added combine faces & delete room functions
 *
 * 8     8/19/97 1:01p Matt
 * Added error check for facing not overlapping when attaching rooms
 *
 * 7     8/18/97 6:59p Matt
 * Implemented Place Room/Attach room system
 *
 * 6     8/05/97 10:47a Matt
 * Added some error checking, and fixed a bug
 *
 * 5     8/04/97 7:38p Matt
 * Don't add a room if there's already a room at the face
 *
 * 4     8/04/97 12:46p Matt
 * Added BuildBridge() and SetMarkedRoom()
 *
 *
 * 3     8/01/97 6:15p Matt
 * Added code to attach rooms
 *
 * 2     7/22/97 10:33a Matt
 * Added AddRoom()
 *
 * 1     7/21/97 4:48p Matt
 *
 * $NoKeywords: $
 */

#include <stdlib.h>

#include "HRoom.h"

#ifndef NEWEDITOR
#include "d3edit.h"
#else
#include "..\neweditor\globals.h"
#include "..\neweditor\ned_geometry.h"
#endif

#include "erooms.h"
#include "RoomUVs.h"
#include "HView.h"
#include "SelectedRoom.h"
#include "group.h"
#include "door.h"
#include "doorway.h"
#include "terrain.h"
#include "HTexture.h"
#include "trigger.h"

// Make the Marked room/face the current room/face
void SetMarkedRoom() {
  Markedroomp = Curroomp;
  Markedface = Curface;
  Markededge = Curedge;
  Markedvert = Curvert;

  State_changed = 1;

  EditorStatus("Marked room:face set to %d:%d", ROOMNUM(Markedroomp), Markedface);
}

// Select next face on current room
void SelectNextFace() {
  if (++Curface >= Curroomp->num_faces)
    Curface = 0;
  State_changed = 1;
}

// Select previous face on current room
void SelectPrevFace() {
  if (--Curface < 0)
    Curface = Curroomp->num_faces - 1;
  State_changed = 1;
}

#define DEFAULT_ROOM_LENGTH 20.0

// Adds a room at the current room/face.  The room is created by extuding out from the current face
void AddRoom() {
  room *rp;
  face *cfp;
  int cnv, nfaces;
  vector room_delta;
  int i;

  // Get values from current room & face
  cfp = &Curroomp->faces[Curface]; // pointer to current face
  cnv = cfp->num_verts;            // number of verts in current face

  // Check for portal already here
  if (cfp->portal_num != -1) {
    OutrageMessageBox("Can't add room: There is already a connection at the current room:face.");
    return;
  }

  // Get values for new room
  nfaces = cnv + 2;

  // Get a pointer to our room
  rp = CreateNewRoom(cnv * 2, nfaces, 0);
  if (rp == NULL) {
    OutrageMessageBox("Cannot add room: No free rooms.");
    return;
  }

  // Compute delta vector
  room_delta = cfp->normal * -DEFAULT_ROOM_LENGTH;

  // Set the vertices for the room
  for (i = 0; i < cnv; i++) {
    rp->verts[i] = Curroomp->verts[cfp->face_verts[cnv - 1 - i]];
    rp->verts[cnv + i] = rp->verts[i] + room_delta;
  }

  // Set the faces for the room
  InitRoomFace(&rp->faces[0], cnv);
  for (i = 0; i < cnv; i++)
    rp->faces[0].face_verts[i] = i;

  InitRoomFace(&rp->faces[1], cnv);
  for (i = 0; i < cnv; i++)
    rp->faces[1].face_verts[i] = cnv * 2 - 1 - i;

  for (i = 0; i < nfaces - 2; i++) {
    InitRoomFace(&rp->faces[i + 2], 4);
    rp->faces[i + 2].face_verts[0] = i;
    rp->faces[i + 2].face_verts[1] = i + cnv;
    rp->faces[i + 2].face_verts[2] = ((i + 1) % cnv) + cnv;
    rp->faces[i + 2].face_verts[3] = (i + 1) % cnv;
  }

#ifndef NEWEDITOR
  // Set normals & textures for each face
  for (i = 0; i < nfaces; i++) {
    if (!ComputeFaceNormal(rp, i))
      Int3(); // Bad!  Get Matt!

    // Assign arbitrary texture map
    rp->faces[i].tmap = i + 1;
  }
#else
  int texnum = Editor_state.GetCurrentTexture();

  // Set normals & textures for each face
  for (i = 0; i < nfaces; i++) {
    if (!ComputeFaceNormal(rp, i))
      Int3(); // Bad!  Get Matt!

    // Apply texture
    HTextureApplyToRoomFace(rp, i, texnum);
  }
#endif

  // Set UVs for all the faces
  AssignDefaultUVsToRoom(rp);

  // Form the portals between the rooms
  LinkRoomsSimple(Rooms, ROOMNUM(Curroomp), Curface, ROOMNUM(rp), 0);

  // Make the new room the current room
#ifndef NEWEDITOR
  Curroomp = rp;
  Curface = 1;
  Curedge = Curvert = 0;
  Curportal = -1;
#else
  theApp.m_pLevelWnd->SetPrim(rp, 1, -1, 0, 0);
#endif

  // Set the flag
  World_changed = 1;
}

// Computes the orientation matrix for the placed room
void ComputePlacedRoomMatrix() {
  room *placedroomp;
  int placedface;
  matrix srcmat;
  vector t;

  if (Placed_room != -1) {
    placedroomp = &Rooms[Placed_room];
    placedface = Placed_room_face;
  } else {
    ASSERT(Placed_group != NULL);
    placedroomp = &Placed_group->rooms[Placed_group->attachroom];
    placedface = Placed_group->attachface;
  }

  // Compute source and destination matrices
  t = -placedroomp->faces[placedface].normal;
  vm_VectorToMatrix(&srcmat, &t, NULL, NULL);
  vm_VectorAngleToMatrix(&Placed_room_orient, &Placed_room_orient.fvec, Placed_room_angle);

  mprintf(0, "srcmat: %f %f %f\n", vm_GetMagnitude(&srcmat.fvec), vm_GetMagnitude(&srcmat.rvec),
          vm_GetMagnitude(&srcmat.uvec));
  mprintf(0, "orient: %f %f %f\n", vm_GetMagnitude(&Placed_room_orient.fvec), vm_GetMagnitude(&Placed_room_orient.rvec),
          vm_GetMagnitude(&Placed_room_orient.uvec));

  // Make sure the matrices are ok
  vm_Orthogonalize(&srcmat);
  vm_Orthogonalize(&Placed_room_orient);

  // Compute matrix to rotate src -> dest
  vm_MatrixMulTMatrix(&Placed_room_rotmat, &srcmat, &Placed_room_orient);

  mprintf(0, "rotmat: %f %f %f\n", vm_GetMagnitude(&Placed_room_rotmat.fvec), vm_GetMagnitude(&Placed_room_rotmat.rvec),
          vm_GetMagnitude(&Placed_room_rotmat.uvec));

  // Make sure the matrix is ok
  vm_Orthogonalize(&Placed_room_rotmat);
}

// Place a room for orientation before attachment
// Parameters:	baseroomp - pointer to the room in the mine to which the new room will be attached
//					baseface - the face on baseroomp to attach to
//					placed_room - the number of the room to be attached
//					placed_room_face the face on placed_room that's attached
void PlaceRoom(room *baseroomp, int baseface, int placed_room, int placed_room_face, int placed_room_door) {
  // Clear the placed group if one exists
  Placed_group = NULL;

  ASSERT(baseroomp->faces[baseface].portal_num == -1);

  room *placedroomp = &Rooms[placed_room];

  // Set globals
  Placed_room = placed_room;
  Placed_room_face = placed_room_face;
  Placed_room_orient.fvec = baseroomp->faces[baseface].normal;
  Placed_room_angle = 0;
  Placed_baseroomp = baseroomp;
  Placed_baseface = baseface;
  Placed_door = placed_room_door;

  // Compute attach points on each face
#ifndef NEWEDITOR
  ComputeCenterPointOnFace(&Placed_room_attachpoint, baseroomp, baseface);
  ComputeCenterPointOnFace(&Placed_room_origin, placedroomp, placed_room_face);
#else
  ComputeFaceBoundingCircle(&Placed_room_attachpoint, baseroomp, baseface);
  ComputeFaceBoundingCircle(&Placed_room_origin, placedroomp, placed_room_face);
#endif

  // Compute initial orientation matrix
  ComputePlacedRoomMatrix();

  // Set the flag
  State_changed = 1;
}

// Lined up a placed room.  Moves the placed room so the closest vert to basevert lines up exactly,
// and the edge from basevert to basevert+1 lines up with the corresponding edge on the placed room.
void SnapRoom(int basevert) {
  vector basecenter, attcenter;
  room *baseroomp, *attroomp;
  face *bfp, *afp;
  vector *bvp;
  int baseface, attface;
  vector baseedge, attedge;

  // Get values for the attach room
  if (Placed_room != -1) {
    attroomp = &Rooms[Placed_room];
    attface = Placed_room_face;
  } else {
    ASSERT(Placed_group != NULL);
    attroomp = &Placed_group->rooms[Placed_group->attachroom];
    attface = Placed_group->attachface;
  }

  // Set some vars
  baseroomp = Placed_baseroomp;
  baseface = Placed_baseface;
  attcenter = Placed_room_origin;
  basecenter = Placed_room_attachpoint;
  bfp = &baseroomp->faces[baseface];
  afp = &attroomp->faces[attface];
  bvp = &baseroomp->verts[bfp->face_verts[basevert]];

  // Find matching vert in attach face
  float closest_dist = FLT_MAX;
  int closest_v;
  for (int v = 0; v < afp->num_verts; v++) {
    vector rotvert;
    float dist;

    rotvert = ((attroomp->verts[afp->face_verts[v]] - attcenter) * Placed_room_rotmat) + basecenter;
    dist = vm_VectorDistance(bvp, &rotvert);

    if (dist < closest_dist) {
      closest_dist = dist;
      closest_v = v;
    }
  }

  // Compute edge vector in base room
  vm_GetNormalizedDir(&baseedge, &baseroomp->verts[bfp->face_verts[(basevert + 1) % bfp->num_verts]], bvp);

  // Compute edge vector in attach room
  vector v0 = ((attroomp->verts[afp->face_verts[closest_v]] - attcenter) * Placed_room_rotmat) + basecenter;
  vector v1 = ((attroomp->verts[afp->face_verts[(closest_v + afp->num_verts - 1) % afp->num_verts]] - attcenter) *
               Placed_room_rotmat) +
              basecenter;
  vm_GetNormalizedDir(&attedge, &v1, &v0);

  // Get angle between two edge vectors
  double dot = baseedge * attedge;
  if (dot > 1.0)
    dot = 1.0;
  double ac = acos(dot);
  float delta_ang = 32768.0 * ac / PI;

  // Get sign of angle
  vector checkv;
  vm_CrossProduct(&checkv, &baseedge, &attedge);
  if ((bfp->normal * checkv) > 0)
    delta_ang = -delta_ang;

  // Update placed room angle
  Placed_room_angle += delta_ang;
  while (Placed_room_angle < 0)
    Placed_room_angle += 65536;

  // Regenerate matrix
  ComputePlacedRoomMatrix();

  // Move the room to line up the points
  v0 = ((attroomp->verts[afp->face_verts[closest_v]] - attcenter) * Placed_room_rotmat) + basecenter;
  Placed_room_attachpoint += *bvp - v0;

  // Update view
  State_changed = 1;
}

// Attach an already-placed room
void AttachRoom() {
  vector basecenter, attcenter;
  room *baseroomp, *attroomp, *newroomp;
  int baseface, attface;

  ASSERT(Placed_room != -1);

  // Set some vars
  baseroomp = Placed_baseroomp;
  baseface = Placed_baseface;
  attroomp = &Rooms[Placed_room];
  attface = Placed_room_face;
  attcenter = Placed_room_origin;
  basecenter = Placed_room_attachpoint;

  // Get the new room
  newroomp = CreateNewRoom(attroomp->num_verts, attroomp->num_faces, 0);
  if (newroomp == NULL) {
    OutrageMessageBox("Cannot attach room: No free rooms.");
    return;
  }

  // Rotate verts, copying into new room
  for (int i = 0; i < attroomp->num_verts; i++)
    newroomp->verts[i] = ((attroomp->verts[i] - attcenter) * Placed_room_rotmat) + basecenter;

  // Copy faces to new room
  for (i = 0; i < attroomp->num_faces; i++) {
    CopyFace(&newroomp->faces[i], &attroomp->faces[i]);
#ifdef NEWEDITOR
    LevelTexIncrementTexture(attroomp->faces[i].tmap);
#endif
  }

  // Recompute normals for the faces
  if (!ResetRoomFaceNormals(newroomp))
    Int3(); // Get Matt

  // Copy other values for this room
  newroomp->flags = attroomp->flags;
  newroomp->num_portals = 0;

  // Check for terrain or mine room
  if (baseroomp == NULL) { // a terrain room

    // Flag this as an external room
    newroomp->flags |= RF_EXTERNAL;

    // Delete the attach face, which should now be facing the ground
    DeleteRoomFace(newroomp, attface);
  } else { // a mine room

    // Clip the connecting faces against each other
    if (!ClipFacePair(newroomp, attface, baseroomp, baseface)) {
      OutrageMessageBox("Error making portal -- faces probably don't overlap.");
      FreeRoom(newroomp);
      return;
    }

    // Make the two faces match exactly
    MatchPortalFaces(baseroomp, baseface, newroomp, attface);

    // Create the portals between the rooms
    LinkRoomsSimple(Rooms, ROOMNUM(baseroomp), baseface, ROOMNUM(newroomp), attface);

    // If there is a door, place it!
    if (Placed_door != -1) {
      vector room_center;
      matrix orient = ~Placed_room_rotmat;
      vector doorcenter = {0, 0, 0};

      FreeRoom(&Rooms[Placed_room]);

      room_center = ((doorcenter - attcenter) * Placed_room_rotmat) + basecenter;

      ObjCreate(OBJ_DOOR, Placed_door, newroomp - Rooms, &room_center, &orient);

      doorway *dp = DoorwayAdd(newroomp, Placed_door);

#ifdef NEWEDITOR
      LevelDoorIncrementDoorway(Placed_door);
#endif

      Placed_door = -1;
    }
  }

  // Un-place the now-attached room
  Placed_room = -1;

  // Flag the world as changed
  World_changed = 1;
}

// structure for keeping track of vertices inserted in edges (from clipping)
struct edge_insert {
  int v0, v1; // the edge that got the new vert
  int new_v;  // the new vertex
};

// List of vertices inserted in edges.  Used only during clipping.
edge_insert Edge_inserts[MAX_VERTS_PER_FACE];
int Num_edge_inserts;

// Add an insert to the edge list
void AddEdgeInsert(int v0, int v1, int new_v) {
  Edge_inserts[Num_edge_inserts].v0 = v0;
  Edge_inserts[Num_edge_inserts].v1 = v1;
  Edge_inserts[Num_edge_inserts].new_v = new_v;
  Num_edge_inserts++;
}

// Clip a polygon against one edge of another polygon
// Fills inbuf and maybe outbuf with new polygons, and writes any new verts to the vertices array
// Parameters:	nv - the number of verts in the polygon to be clipped
//					vertnums - pointer to list of vertex numbers in the polygon
//					vertices - list of vertices referred to in vertnums
//					v0,v1 - the edge we're clipping against
//					normal - the surface normal of the polygon
//					inbuf - the clipped polygon is written to this buffer
//					inv - the number of verts in inbuf is written here
//					outbuf - the new polygon created by the part of the input polygon that was
//clipped away 					onv - the number of verys in outbuf 					num_vertices - pointer to the number of verts in the vertices array
void ClipAgainstEdge(int nv, int16_t *vertnums, vertex *vertices, int *num_vertices, vector *v0, vector *v1,
                     vector *normal, int16_t *inbuf, int *inv, int16_t *outbuf, int *onv) {
  int i, prev, next, check;
  int16_t *ip = inbuf, *op = outbuf;
  vertex *curv, *prevv, *nextv;
  int inside_points = 0, outside_points = 0; // real inside/outside points, distinct from edge points

  for (i = 0, prev = nv - 1, next = 1; i < nv; i++) {

    curv = &vertices[vertnums[i]];

    // Find out where point lies
    check = CheckPointAgainstEdge(&curv->vec, v0, v1, normal);
    if (check == 0) { // Current vertex is on edge

      // Add to both inside & outside lists
      *op++ = vertnums[i];
      *ip++ = vertnums[i];
    } else if (check == -1) { // Current vertex is outside
      int check2;

      prevv = &vertices[vertnums[prev]];
      nextv = &vertices[vertnums[next]];

      // Clip edge w/ previous vertex
      check2 = CheckPointAgainstEdge(&prevv->vec, v0, v1, normal);
      if (check2 == 1) { // prev inside, so clip
        ClipEdge(normal, prevv, curv, v0, v1, &vertices[*num_vertices]);
        AddEdgeInsert(vertnums[prev], vertnums[i], *num_vertices);
        *op++ = *ip++ = (*num_vertices)++;
      }

      // Add current vertex to outside polygon
      *op++ = vertnums[i];
      outside_points++;

      // Clip edge w/ next vertex
      check2 = CheckPointAgainstEdge(&nextv->vec, v0, v1, normal);
      if (check2 == 1) { // next inside, so clip
        ClipEdge(normal, curv, nextv, v0, v1, &vertices[*num_vertices]);
        AddEdgeInsert(vertnums[i], vertnums[next], *num_vertices);
        *op++ = *ip++ = (*num_vertices)++;
      }
    } else { // Current vertex is inside
      ASSERT(check == 1);

      // Add current vertex to inside polygon
      *ip++ = vertnums[i];
      inside_points++;
    }

    prev = i;
    if (++next == nv)
      next = 0;
  }

  // Set number of verts for return.  If no real inside or outside points, then don't count edge points
  *inv = inside_points ? (ip - inbuf) : 0;
  *onv = outside_points ? (op - outbuf) : 0;
}

// Adds a new vertex to all instances of a given edge
void AddVertToAllEdges(room *rp, int v0, int v1, int new_v) {
  face *fp;
  int f, v;

  for (f = 0, fp = rp->faces; f < rp->num_faces; f++, fp++) {
    for (v = 0; v < fp->num_verts; v++) {
      if (((fp->face_verts[v] == v0) && (fp->face_verts[(v + 1) % fp->num_verts] == v1)) ||
          ((fp->face_verts[v] == v1) && (fp->face_verts[(v + 1) % fp->num_verts] == v0)))
        AddVertToFace(rp, f, new_v, v);
    }
  }
}

// Adds a new point to all instances of a given edge
// First adds the point to the room (or finds it there), then calls AddVertToAllEdges()
void AddPointToAllEdges(room *rp, int v0, int v1, vector *new_v) {
  int newvertnum = RoomAddVertices(rp, 1);

  rp->verts[newvertnum] = *new_v;

  AddVertToAllEdges(rp, v0, v1, newvertnum);
}

// Clips a face against another.  Produces one polygon that is the intersection of the two input
// faces, and zero or more extra polygons, which are parts of the input face outside the clipping face.
// The input face is replaced by the clipped face, and new faces (formed by the parts of the input
// face outside the clip-against face) are added to the end of the room's facelist.
// This routine assumes that part or all of the being-clipped face is inside the clip-against face
// Parameters:	arp - the room with the face that is being changed
//					afacenum - the face being changed
//					brp - the room with the face we're clipping against
//					bfacenum - the face we're clipping against
// Returns:		true if the clip was ok, false if there was an error
bool ClipFace(room *arp, int afacenum, room *brp, int bfacenum) {
  face *afp = &arp->faces[afacenum];
  face *bfp = &brp->faces[bfacenum];
  int edgenum;
  int16_t vbuf0[MAX_VERTS_PER_FACE], vbuf1[MAX_VERTS_PER_FACE];
  int16_t newface_verts[MAX_VERTS_PER_FACE][MAX_VERTS_PER_FACE];
  int newface_nvs[MAX_VERTS_PER_FACE];
  vertex newverts[MAX_VERTS_PER_FACE];
  int newvertnums[MAX_VERTS_PER_FACE];
  int num_newverts;
  int num_newfaces = 0;
  int16_t *src, *dest;
  int nv;
  int i;

  // Init some stuff
  nv = afp->num_verts;
  src = vbuf0;
  dest = vbuf1;

  Num_edge_inserts = 0;

  // copy our vertices into one buffer
  for (i = 0; i < nv; i++) {
    newverts[i].vec = arp->verts[afp->face_verts[i]];
    newverts[i].uvl = afp->face_uvls[i];
    newvertnums[i] = afp->face_verts[i];
    src[i] = i;
  }
  num_newverts = nv;

  // Clip our polygon against each edge
  for (edgenum = 0; edgenum < bfp->num_verts; edgenum++) {
    vector *v0, *v1;
    int16_t *outbuf = newface_verts[num_newfaces];
    int *onv = &newface_nvs[num_newfaces];

    v0 = &brp->verts[bfp->face_verts[(bfp->num_verts - edgenum) % bfp->num_verts]];
    v1 = &brp->verts[bfp->face_verts[bfp->num_verts - edgenum - 1]];

    ClipAgainstEdge(nv, src, newverts, &num_newverts, v0, v1, &afp->normal, dest, &nv, outbuf, onv);

    if (nv <= 2) // no new face -- faces must not overlap
      return 0;

    src = dest;
    dest = (src == vbuf0) ? vbuf1 : vbuf0;

    if (newface_nvs[num_newfaces]) // is there a new face?
      num_newfaces++;              //..yes, increment counter
  }

  // Now we have the clipped face and the other new faces
  // Replace the old face, and add the new faces
  int first_new_vert, first_new_face;
  face *fp;

  // Allocate space for the new verts
  first_new_vert = RoomAddVertices(arp, num_newverts - afp->num_verts);

  // Copy new vertices into room & get real vert numbers
  for (i = 0; i < num_newverts - afp->num_verts; i++) {
    arp->verts[first_new_vert + i] = newverts[afp->num_verts + i].vec;
    newvertnums[afp->num_verts + i] = first_new_vert + i;
  }

  // Replace the input face with the clipped face
  ReInitRoomFace(afp, nv);
  for (i = 0; i < nv; i++) {
    afp->face_verts[i] = newvertnums[src[i]];
    afp->face_uvls[i] = newverts[src[i]].uvl;
  }
  if (!ComputeFaceNormal(arp, afacenum))
    Int3(); // Get Matt

  // Allocate space for the new faces
  first_new_face = RoomAddFaces(arp, num_newfaces);

  // Copy data for new faces (the outside faces)
  for (i = 0; i < num_newfaces; i++) {
    fp = &arp->faces[first_new_face + i];
    InitRoomFace(fp, newface_nvs[i]);
    for (int j = 0; j < newface_nvs[i]; j++) {
      fp->face_verts[j] = newvertnums[newface_verts[i][j]];
      fp->face_uvls[j] = newverts[newface_verts[i][j]].uvl;
    }
    if (!ComputeFaceNormal(arp, first_new_face + i))
      Int3(); // Get Matt
#ifndef NEWEDITOR
    fp->tmap = arp->faces[afacenum].tmap;
#else
    // Apply texture
    HTextureApplyToRoomFace(arp, first_new_face + i, arp->faces[afacenum].tmap);
#endif
    CopyFaceFlags(fp, &arp->faces[afacenum]);
  }

  // Add new verts to edges
  for (i = 0; i < Num_edge_inserts; i++) {
    int v0, v1, new_v;
    v0 = newvertnums[Edge_inserts[i].v0];
    v1 = newvertnums[Edge_inserts[i].v1];
    new_v = newvertnums[Edge_inserts[i].new_v];

    AddVertToAllEdges(arp, v0, v1, new_v);
  }

  // Done!
  return 1;
}

// Adds a point to a face
// Parameters:	rp,facenum - the face we're adding the point to
//					vertindex - the position in the face's vertex list at which to add the point
//					vp - the point to add
void AddPointToFace(room *rp, int facenum, int vertindex, vector *vp) {
  face *fp = &rp->faces[facenum];
  int old_verts[MAX_VERTS_PER_FACE];
  roomUVL old_uvls[MAX_VERTS_PER_FACE];
  int t;

  // Add the new point to the room
  int newvertnum = RoomAddVertices(rp, 1);
  rp->verts[newvertnum] = *vp;

  // Make copy of old verts
  for (t = 0; t < fp->num_verts; t++) {
    old_verts[t] = fp->face_verts[t];
    old_uvls[t] = fp->face_uvls[t];
  }

  // Allocate for new verts
  ReInitRoomFace(fp, fp->num_verts + 1);

  // Copy old verts
  for (t = 0; t < vertindex; t++) {
    fp->face_verts[t] = old_verts[t];
    fp->face_uvls[t] = old_uvls[t];
  }
  fp->face_verts[t++] = newvertnum;
  // fp0->face_uvls[t] = ??
  for (; t < fp->num_verts; t++) {
    fp->face_verts[t] = old_verts[t - 1];
    fp->face_uvls[t] = old_uvls[t - 1];
  }
}

// Deletes a point from a face
// Parameters:	rp,facenum - the face we're deleting the point from
//					vertindex - the vertex to delete
void DeletePointFromFace(room *rp, int facenum, int vertindex) {
  face *fp = &rp->faces[facenum];
  int old_verts[MAX_VERTS_PER_FACE];
  roomUVL old_uvls[MAX_VERTS_PER_FACE];
  int t;

  // Make copy of old verts
  for (t = 0; t < fp->num_verts; t++) {
    old_verts[t] = fp->face_verts[t];
    old_uvls[t] = fp->face_uvls[t];
  }

  // Allocate for new verts
  ReInitRoomFace(fp, fp->num_verts - 1);

  // Copy old verts
  for (t = 0; t < vertindex; t++) {
    fp->face_verts[t] = old_verts[t];
    fp->face_uvls[t] = old_uvls[t];
  }
  for (; t < fp->num_verts; t++) {
    fp->face_verts[t] = old_verts[t + 1];
    fp->face_uvls[t] = old_uvls[t + 1];
  }

#ifndef NEWEDITOR
  World_changed = 1;
#endif
}

// Takes two faces which are going to be made into a portal and makes them match exactly
// Alternatively, checks if the two faces can be matched
// After this function the two faces will have exactly the same vertices
// Parameters:	rp0,facenum0 - one of the faces
//					rp1,facenum1 - the other face
//					check_only - if set, doesn't change anything; just checks the faces
// Returns the number of points added to the faces
// If just_checking set, returns true if faces match, else false
int MatchPortalFaces(room *rp0, int facenum0, room *rp1, int facenum1, bool check_only) {
  face *fp0 = &rp0->faces[facenum0];
  face *fp1 = &rp1->faces[facenum1];
  vector *v0, *v1, *prev_v0, *prev_v1;
  int n0, n1, i, j, prev_vn0, prev_vn1, max_nv;
  int points_added = 0;

check_faces:;

  // First, find one point in common
  for (i = 0; i < fp0->num_verts; i++) {
    for (j = 0; j < fp1->num_verts; j++)
      if (PointsAreSame(&rp0->verts[fp0->face_verts[i]], &rp1->verts[fp1->face_verts[j]]))
        break;
    if (j < fp1->num_verts)
      break;
  }
  if (i >= fp0->num_verts) {
    if (!check_only)
      Int3(); // Counldn't find common point!  This is very bad.  Get Matt.
    return 0; // no match
  }

  prev_vn0 = fp0->face_verts[i];
  prev_vn1 = fp1->face_verts[j];
  prev_v0 = &rp0->verts[prev_vn0];
  prev_v1 = &rp1->verts[prev_vn1];

  // Make starting points identical
  if (!check_only)
    *prev_v0 = *prev_v1;

  // Use the larger number of vert
  max_nv = __max(fp0->num_verts, fp1->num_verts);

  // Trace through faces, adding points where needed
  for (n0 = n1 = 1; n0 < max_nv && n1 < max_nv; n0++, n1++) {
    int vn0, vn1;

  recheck:;

    vn0 = fp0->face_verts[(i + n0) % fp0->num_verts];
    vn1 = fp1->face_verts[(j - n1 + fp1->num_verts) % fp1->num_verts];

    v0 = &rp0->verts[vn0];
    v1 = &rp1->verts[vn1];

    if (PointsAreSame(v0, v1)) { // Points are at least very close.
      if (!check_only)
        *v0 = *v1; // Make the points identical
    } else {       // The points are not the same, so we check for an extra (colinear) point

      float d0, d1;

      // One of these points should lie along the edge of the other. Find which is which
      d0 = vm_VectorDistance(v0, prev_v0);
      d1 = vm_VectorDistance(v1, prev_v1);

      if (d0 > d1) { // Point 1 is presumably on the edge prev_v0 -> v0

        // Make sure the point is actually on the edge
        if (CheckPointAgainstEdge(v1, prev_v0, v0, &fp0->normal)) {
          if (check_only)
            return 0;
          Int3(); // point isn't on edge!  Bad!  Get Matt!
        } else {
          if (!check_only) {

            // Add the point
            AddPointToAllEdges(rp0, prev_vn0, vn0, v1);
            points_added++;
          } else {
            n1++; // skip edge point & resume checking
            goto recheck;
          }
        }
      } else { // Point 0 is presumably on the edge prev_v1 -> v1

        // Make sure the point is actually on the edge
        if (CheckPointAgainstEdge(v0, prev_v1, v1, &fp1->normal)) {
          if (check_only)
            return 0;
          Int3(); // point isn't on edge!  Bad!  Get Matt!
        } else {

          if (!check_only) {
            // Add the point
            AddPointToAllEdges(rp1, prev_vn1, vn1, v0);
            points_added++;
          } else {
            n0++; // skip edge point & resume checking
            goto recheck;
          }
        }
      }

      // Start check again
      if (!check_only)
        goto check_faces;
    }

    prev_vn0 = vn0;
    prev_vn1 = vn1;

    prev_v0 = v0;
    prev_v1 = v1;
  }

  if (check_only)
    return 1; // no errors found, so faces ok

  ASSERT(fp0->num_verts == fp1->num_verts); // Get Matt!

  return points_added;
}

// Clips a pair of faces against each other.
// Produces one polygon in each face that is the intersection of the two input faces,
// and zero or more extra polygons, which are parts of the input faces outside the clipping faces.
// The input faces are replaced by the clipped faces, and new faces (formed by the parts of the input
// face outside the clip-against face) are added to the end of the room's facelist.
// This routine assumes that part or all of the being-clipped face is inside the clip-against face
// Parameters:	rp0,face0 - the first room:face
//					rp1,face1 - the second room:face
// Returns:		true if the clip was ok, false if there was an error
bool ClipFacePair(room *rp0, int face0, room *rp1, int face1) {
  // Clip each face aginst the other
  return (ClipFace(rp0, face0, rp1, face1) && ClipFace(rp1, face1, rp0, face0));
}

// Creates a new bridge room connecting two rooms
// Parameters:	attroomp,attface - one end of the new room
//					baseroom,baseface - the other end of the new room
// The new room is created by extruding from attroom/attface
void BuildBridge(room *attroomp, int attface, room *baseroomp, int baseface) {
  room *newroomp;
  face *afp, *bfp;
  int nv, nfaces;
  vector delta_vec, bc, ac;
  vector *basevert; // a vertex on the base face
  int i;
  float cos, dist;

  // Check that the two faces don't already have portals
  if (attroomp->faces[attface].portal_num != -1) {
    OutrageMessageBox("Cannot build bridge: There is already a portal at %d:%d", ROOMNUM(attroomp), attface);
    return;
  }
  if (baseroomp->faces[baseface].portal_num != -1) {
    OutrageMessageBox("Cannot build bridge: There is already a portal at %d:%d", ROOMNUM(baseroomp), baseface);
    return;
  }

  // Get values from current room & face
  afp = &attroomp->faces[attface];   // pointer to attach face
  bfp = &baseroomp->faces[baseface]; // pointer to base face
  nv = afp->num_verts;               // number of verts in attach face
  nfaces = nv + 2;                   // number of faces in new room

  // Make sure all points on each face are on the front of the other face
  vector tnorm = -afp->normal;
  int t = CheckFaceToPlane(baseroomp, baseface, &attroomp->verts[afp->face_verts[0]], &tnorm);
  if (t != -1) {
    OutrageMessageBox("Can't build bridge: Vertex %d on %d:%d is behind %d:%d", t, ROOMNUM(baseroomp), baseface,
                      ROOMNUM(attroomp), attface);
    return;
  }
  tnorm = -bfp->normal;
  t = CheckFaceToPlane(attroomp, attface, &baseroomp->verts[bfp->face_verts[0]], &tnorm);
  if (t != -1) {
    OutrageMessageBox("Can't build bridge: Vertex %d on %d:%d is behind %d:%d", t, ROOMNUM(attroomp), attface,
                      ROOMNUM(baseroomp), baseface);
    return;
  }

  // Compute normalized vector from attach face to base face
#ifndef NEWEDITOR
  ComputeCenterPointOnFace(&bc, baseroomp, baseface);
  ComputeCenterPointOnFace(&ac, attroomp, attface);
#else
  ComputeFaceBoundingCircle(&bc, baseroomp, baseface);
  ComputeFaceBoundingCircle(&ac, attroomp, attface);
#endif
  dist = vm_GetNormalizedDir(&delta_vec, &bc, &ac);

  // Compute the cosine of the angle between our vector and the normal of the base face
  cos = delta_vec * bfp->normal;

  // Get a pointer to a vertex on the base face
  basevert = &baseroomp->verts[bfp->face_verts[0]];

  // Get a pointer to our room
  newroomp = CreateNewRoom(nv * 2, nfaces, 0);
  if (newroomp == NULL) {
    OutrageMessageBox("Cannot build bridge: No free rooms.");
    return;
  }

  // Create new vertices in the plane of the base face
  for (i = 0; i < nv; i++) {
    float dist;

    // Copy from att face to new room
    newroomp->verts[i] = attroomp->verts[afp->face_verts[nv - 1 - i]];

    // Get distance from base face to this vertex
    dist = ((*basevert - newroomp->verts[i]) * bfp->normal) / cos;

    // Get the new vert
    newroomp->verts[nv + i] = newroomp->verts[i] + (delta_vec * dist);
  }

  // Set the faces for the room
  InitRoomFace(&newroomp->faces[0], nv);
  for (i = 0; i < nv; i++)
    newroomp->faces[0].face_verts[i] = i;

  InitRoomFace(&newroomp->faces[1], nv);
  for (i = 0; i < nv; i++)
    newroomp->faces[1].face_verts[i] = nv * 2 - 1 - i;

  for (i = 0; i < nfaces - 2; i++) {
    InitRoomFace(&newroomp->faces[i + 2], 4);
    newroomp->faces[i + 2].face_verts[0] = i;
    newroomp->faces[i + 2].face_verts[1] = i + nv;
    newroomp->faces[i + 2].face_verts[2] = ((i + 1) % nv) + nv;
    newroomp->faces[i + 2].face_verts[3] = (i + 1) % nv;
  }

  // Set normals
  if (!ResetRoomFaceNormals(newroomp))
    Int3(); // Get Matt

    // Set textures
#ifndef NEWEDITOR
  for (i = 0; i < nfaces; i++)
    newroomp->faces[i].tmap = i + 1;
#else
  int texnum = Editor_state.GetCurrentTexture();
  // Apply texture
  for (i = 0; i < nfaces; i++)
    HTextureApplyToRoomFace(newroomp, i, texnum);
#endif

  // Assign UVs
  AssignDefaultUVsToRoom(newroomp);

  // Connect the new room to the attach room
  LinkRoomsSimple(Rooms, ROOMNUM(attroomp), attface, ROOMNUM(newroomp), 0);

  // Clip the connecting faces against each other
  t = ClipFacePair(newroomp, 1, baseroomp, baseface);
  ASSERT(t != 0);

  // Make the two faces match exactly
  MatchPortalFaces(baseroomp, baseface, newroomp, 1);

  // Connect the new room to the base room
  LinkRoomsSimple(Rooms, ROOMNUM(baseroomp), baseface, ROOMNUM(newroomp), 1);

  // Set Changed flag
  World_changed = 1;
}

#define JOIN_EPSILON 0.01

// Connects two rooms by changing the shape of one room to attach to the other
// Pretty similar to BuildBridge(), but doesn't create a new room
// Parameters:	attroomp,attface - one end of the new room
//					baseroom,baseface - the other end of the new room
void JoinRooms(room *attroomp, int attface, room *baseroomp, int baseface) {
  face *afp, *bfp;
  int nv, nfaces, t;
  vector delta_vec;
  vector *basevert; // a vertex on the base face
  int i;
  float cos;
  vector save_verts[MAX_VERTS_PER_FACE]; // save verts for face in case we bail

  // Check that the two faces don't already have portals
  if (attroomp->faces[attface].portal_num != -1) {
    OutrageMessageBox("Cannot join: There is already a portal at %d:%d", ROOMNUM(attroomp), attface);
    return;
  }
  if (baseroomp->faces[baseface].portal_num != -1) {
    OutrageMessageBox("Cannot join: There is already a portal at %d:%d", ROOMNUM(baseroomp), baseface);
    return;
  }

  // Get values from current room & face
  afp = &attroomp->faces[attface];   // pointer to attach face
  bfp = &baseroomp->faces[baseface]; // pointer to base face
  nv = afp->num_verts;               // number of verts in attach face
  nfaces = nv + 2;                   // number of faces in new room

  // Get a pointer to a vertex on the base face
  basevert = &baseroomp->verts[bfp->face_verts[0]];

  // Make sure all points on the attach face are on the front of the base face
  // We could probably take this check out and catch the problem when we're moving the points
  vector tnorm = -bfp->normal;
  t = CheckFaceToPlane(attroomp, attface, basevert, &tnorm);
  if (t != -1) {
    if (OutrageMessageBox(
            MBOX_YESNO,
            "One or more points on the attach face are behind the base face.\nDo you still want to join?") != IDYES) {
      EditorStatus("Join aborted.");
      return;
    }
  }

  // Make a list of all verts in the attach room that are in a portal
  int portal_list[MAX_VERTS_PER_ROOM];
  int num_portal_verts;
  num_portal_verts = BuildListOfPortalVerts(attroomp, portal_list);

  // Save old verts
  for (i = 0; i < nv; i++)
    save_verts[i] = attroomp->verts[afp->face_verts[i]];

  int answer = OutrageMessageBox(MBOX_YESNO, "Do you want to connect to the center of the base face?\n\n"
                                             "Answer NO to extrude straight from the current face.");

  // Compute normalized vector from attach face to base face.
  // This is the direction in which we will move the attach face
  if (answer == IDYES) { // extrude toward the center of the base face
    vector bc, ac;
#ifndef NEWEDITOR
    ComputeCenterPointOnFace(&bc, baseroomp, baseface);
    ComputeCenterPointOnFace(&ac, attroomp, attface);
#else
    ComputeFaceBoundingCircle(&bc, baseroomp, baseface);
    ComputeFaceBoundingCircle(&ac, attroomp, attface);
#endif
    vm_GetNormalizedDir(&delta_vec, &bc, &ac);
  } else { // extrude straight from attach face
    delta_vec = afp->normal;
  }

  // Compute the cosine of the angle between our vector and the normal of the base face
  cos = delta_vec * bfp->normal;

  // If cos is zero, two center points are the same, so no move
  if (fabs(cos) < JOIN_EPSILON)
    goto no_move_points;

  // Move the verts on the attach face to lie in the plane as the base face
  for (i = 0; i < nv; i++) {
    vector *vp = &attroomp->verts[afp->face_verts[i]];
    float dist;

    // Get distance from base face to this vertex
    dist = ((*basevert - *vp) * bfp->normal) / cos;

    // If we're moving the point, make sure it's not part of a portal
    if (fabs(dist) > POINT_TO_PLANE_EPSILON) {

      // Look through list of portal verts for this vert
      for (t = 0; t < num_portal_verts; t++)
        if (portal_list[t] == afp->face_verts[i]) { // Vert is in a portal.  Abort!
          OutrageMessageBox("Can't form joint because vertex %d on %d:%d is shared with a portal.\n\nTry doing the "
                            "join the other way, or using the Bridge function.",
                            i, ROOMNUM(attroomp), attface);
          goto abort_join;
        }

      // Move the vert
      *vp += (delta_vec * dist);
    }
  }

  // Recompute the normals in the room
  if (!ResetRoomFaceNormals(attroomp))
    Int3(); // Get Matt

  // What about the uvs for the faces that changed?

no_move_points:;

  // Clip the connecting faces against each other
  if (!ClipFacePair(attroomp, attface, baseroomp, baseface)) {
    OutrageMessageBox("Error making portal -- faces probably don't overlap.");

  abort_join:;

    // Restore old verts
    for (i = 0; i < nv; i++)
      attroomp->verts[afp->face_verts[i]] = save_verts[i];

    // Recompute the normals in the room
    if (!ResetRoomFaceNormals(attroomp))
      Int3(); // Get Matt

    return;
  }

  // Make the two faces match exactly
  MatchPortalFaces(baseroomp, baseface, attroomp, attface);

  // Create the portals between the rooms
  LinkRoomsSimple(Rooms, ROOMNUM(baseroomp), baseface, ROOMNUM(attroomp), attface);

  // Set Changed flag
  World_changed = 1;
}

// Connects two rooms if they already match up exactly
// Parameters:	attroomp,attface - one end of the new room
//					baseroom,baseface - the other end of the new room
void JoinRoomsExact(room *attroomp, int attface, room *baseroomp, int baseface) {
  // Check that the two faces don't already have portals
  if (attroomp->faces[attface].portal_num != -1) {
    OutrageMessageBox("Cannot join: There is already a portal at %d:%d", ROOMNUM(attroomp), attface);
    return;
  }
  if (baseroomp->faces[baseface].portal_num != -1) {
    OutrageMessageBox("Cannot join: There is already a portal at %d:%d", ROOMNUM(baseroomp), baseface);
    return;
  }

  // Check if we can do an exact match
  if (!MatchPortalFaces(baseroomp, baseface, attroomp, attface, 1)) {
    OutrageMessageBox("Cannot do exact join: These faces do not match");
    return;
  }

  // Make the two faces match exactly
  MatchPortalFaces(baseroomp, baseface, attroomp, attface);

  // Create the portals between the rooms
  LinkRoomsSimple(Rooms, ROOMNUM(baseroomp), baseface, ROOMNUM(attroomp), attface);

  // Set Changed flag
  World_changed = 1;
}

bool FaceIsPlanar(int nv, int16_t *face_verts, vector *normal, vector *verts);

// Combine two faces, if they can be combined
// Parameters:	rp - the room the faces are in
//					face0,face1 - the two faces
// Returns:		true if the faces were combined, else false
// Note: The UV coordinates of the new face are derrived from face0
bool CombineFaces(room *rp, int face0, int face1) {
  face *fp0 = &rp->faces[face0], *fp1 = &rp->faces[face1];
  int nv0 = fp0->num_verts, nv1 = fp1->num_verts;
  int v0, v1;
  int16_t vertlist[MAX_VERTS_PER_FACE];
  roomUVL uvllist[MAX_VERTS_PER_FACE];
  int i, nv;
  int first0, first1, n0, n1;

  ASSERT(face0 != face1);

  // Check for portals
  if ((fp0->portal_num != -1) || (fp1->portal_num != -1)) {
#ifndef NEWEDITOR
    SetErrorMessage(
        "You cannot combine portal faces.\n\nMattT will add this functionality if you need it.  Bug him about it.");
#else
    SetErrorMessage("You cannot combine portal faces.");
#endif
    return 0;
  }

  // Make sure faces share an edge
  if (!FindSharedEdge(fp0, fp1, &v0, &v1)) {
#ifdef NEWEDITOR
    if (ned_FindSharedEdge(fp0, fp1, &v0, &v1))
      SetErrorMessage("The face normals point in opposite directions.");
    else
#endif
      SetErrorMessage("The faces do not share an edge.");
    return 0;
  }

  // Get indices for first & last points in each face.  One shared point is copied with each face.
  first0 = v0 + 1;
  n0 = nv0 - 1;
  first1 = v1 + 1;
  n1 = nv1 - 1;

  // See if faces share additional edges
  while (1) { // check forward on face0, backward on face1
    int check0 = (first0 + 1) % nv0, check1 = (first1 + n1 - 1) % nv1;

    if (fp0->face_verts[check0] != fp1->face_verts[check1])
      break;

    first0++;
    n0--;
    n1--;
  }
  while (1) { // check forward on face1, backward on face0
    int check1 = (first1 + 1) % nv1, check0 = (first0 + n0 - 1) % nv0;

    if (fp0->face_verts[check0] != fp1->face_verts[check1])
      break;

    first1++;
    n1--;
    n0--;
  }

  // Build list of verts for new face
  nv = 0;
  for (i = 0; i < n0; i++) { // Add points from first face
    vertlist[nv] = fp0->face_verts[(first0 + i) % nv0];
    uvllist[nv] = fp0->face_uvls[(first0 + i) % nv0];
    nv++;
  }
  for (i = 0; i < n1; i++) { // Add points from second face
    vertlist[nv] = fp1->face_verts[(first1 + i) % nv1];
    uvllist[nv] = fp1->face_uvls[(first1 + i) % nv1];
    nv++;
  }

  // Calculate new normal
  vector new_normal;
  ComputeNormal(&new_normal, nv, vertlist, rp->verts);

  // Check if new face is planar
  if (!FaceIsPlanar(nv, vertlist, &new_normal, rp->verts)) {
    SetErrorMessage("The new face would not be planar.");
    return 0;
  }

  // Check if new face is convex
  int t;
  if ((t = CheckFaceConcavity(nv, vertlist, &new_normal, rp->verts)) != -1) {
    SetErrorMessage("The new face would be concave (at vertex %d).", vertlist[t]);
    return 0;
  }

  // Reset face0 for new verts
  ReInitRoomFace(fp0, nv);

  // Copy into new face
  for (i = 0; i < nv; i++) {
    fp0->face_verts[i] = vertlist[i];
    fp0->face_uvls[i] = uvllist[i];
  }

  // Set new normal
  fp0->normal = new_normal;

  // Reassign uvls in face
  AssignUVsToFace(rp, face0, &fp0->face_uvls[0], &fp0->face_uvls[1], 0, 1);

  // Delete the old face
  DeleteRoomFace(rp, face1);

  // Set flag
  World_changed = 1;

  // Everything's ok
  return 1;
}

// Deletes the given room from the mine
void DeleteRoomFromMine(room *rp) {
  int i, p;

  // See if this room is linked to the terrain
  for (p = 0; p < rp->num_portals; p++) {
    portal *pp = &rp->portals[p];
    if (pp->croom == -1) {
      OutrageMessageBox("You can't delete a room that attaches to the terrain.  Detach the room before deleting.");
      return;
    }
  }

  // Check if player or viewer object in this room
  for (i = rp->objects; i != -1; i = Objects[i].next) {

    // Is this the player object?
    if (i == OBJNUM(Player_object)) {
      OutrageMessageBox("You can't delete the room with the player in it.");
      return;
    }

#ifndef NEWEDITOR
    // Is this the viewer object?
    if (i == OBJNUM(Viewer_object)) { // Try to find another viewer
      int objnum = FindNextViewerObject(Viewer_object->id + 1, -1);
      if (objnum == OBJNUM(Viewer_object)) {
        OutrageMessageBox("You can't delete the room with the only viewer in it.");
        return;
      } else
        SelectNextViewer();
    }
#endif
  }

  //	count the number of rooms used. if only one, don't delete it.
  for (i = 0; i <= Highest_room_index; i++)
    if (Rooms[i].used && (i != ROOMNUM(rp)))
      break;
  if (i > Highest_room_index) {
    OutrageMessageBox("You can't delete the only room in the mine.");
    return;
  }

  // If this is current room, set new current room
  if (rp == Curroomp) {
    room *newroomp = NULL;

    // Look for connected room
    for (p = 0; p < rp->num_portals; p++)
      if (rp->portals[p].croom != -1) {
        newroomp = &Rooms[rp->portals[0].croom];
        break;
      }

    // If didn't find connected room, look for any room
    if (newroomp == NULL) {
      for (i = 0; i <= Highest_room_index; i++) {
        if (Rooms[i].used && (i != ROOMNUM(rp))) {
          newroomp = &Rooms[i];
          break;
        }
      }
    }

    ASSERT(newroomp != NULL);

#ifndef NEWEDITOR
    Curroomp = newroomp;
    Curface = Curedge = Curvert = 0;
    Curportal = -1;
#else
    theApp.m_pLevelWnd->SetPrim(newroomp, 0, -1, 0, 0);
#endif

    EditorStatus("Current room set to %d.", ROOMNUM(Curroomp));
  }

  // Delete connections
  while (rp->num_portals) {
    portal *pp = &rp->portals[0];
    ASSERT(pp->croom != -1);
    DeleteRoomPortal(&Rooms[pp->croom], pp->cportal);
    DeleteRoomPortal(rp, 0);
  }

  // If this is marked room, clear marked room
  if (Markedroomp == rp)
    Markedroomp = NULL;

  // Free the objects in this room
  for (i = rp->objects; i != -1; i = Objects[i].next) {
#ifdef NEWEDITOR
    if (IS_GENERIC(Objects[i].type))
      LevelObjDecrementObject(Objects[i].id);
    else if (Objects[i].type == OBJ_DOOR) {
      ASSERT(rp->flags & RF_DOOR);
      LevelDoorDecrementDoorway(Objects[i].id);
    }
#endif
    ObjDelete(i);
  }

#ifdef NEWEDITOR
  // Unmark the textures in this room
  for (i = 0; i < rp->num_faces; i++)
    LevelTexDecrementTexture(rp->faces[i].tmap);
#endif

  // Delete any triggers in this room
  face *fp;
  for (i = 0, fp = rp->faces; i < rp->num_faces; fp++, i++)
    if (fp->flags & FF_HAS_TRIGGER)
      DeleteTrigger(ROOMNUM(rp), i);

  // Remove this room from the selected list (if there)
  RemoveRoomFromSelectedList(ROOMNUM(rp));

  // Free up the room
  FreeRoom(rp);
}

#define DROP_ROOM_OFFSET 20.0

// Places a room a short distance from the specified room & face
// The new room is not attached to anything
// Parameters:	baseroomp,baseface - the new room is dropped off of this face
//					droproom_num - the room to be dropped
void DropRoom(room *baseroomp, int baseface, int droproom_num) {
  int roomnum;
  room *newroomp;
  vector oldcenter, facecenter, newcenter, offset;
  float rad;

  // Create a new room
  roomnum = GetFreeRoom(0);
  if (roomnum == -1) {
    OutrageMessageBox("Cannot drop room: No free rooms.");
    return;
  }
  newroomp = &Rooms[roomnum];

  // Copy data to new room
  CopyRoom(newroomp, &Rooms[droproom_num]);

  // Compute offset
  rad = ComputeRoomBoundingSphere(&oldcenter, newroomp);
#ifndef NEWEDITOR
  ComputeCenterPointOnFace(&facecenter, baseroomp, baseface);
#else
  ComputeFaceBoundingCircle(&facecenter, baseroomp, baseface);
#endif
  newcenter = facecenter - (baseroomp->faces[baseface].normal * (rad + DROP_ROOM_OFFSET));
  offset = newcenter - oldcenter;

  // Add in offset to all the points
  for (int i = 0; i < newroomp->num_verts; i++)
    newroomp->verts[i] += offset;

    // Set current room to new room
#ifndef NEWEDITOR
  Curroomp = newroomp;
  Curface = Curedge = Curvert = 0;
  Curportal = -1;
#else
  theApp.m_pLevelWnd->SetPrim(newroomp, 0, -1, 0, 0);
#endif

  // We're done
  World_changed = 1;
}

// Place a room on the terrain for orientation before attachment
// Parameters:	cellnum - the cell where the room is being placed
//					placed_room - the number of the room to be attached
//					placed_room_face the face on placed_room that's attached
void PlaceExternalRoom(int cellnum, int placed_room, int placed_room_face, bool align_to_terrain) {
  room *placedroomp = &Rooms[placed_room];

  // Clear the placed group if one exists
  Placed_group = NULL;

  // Clear the placed door if one exists
  if (Placed_door != -1) {
    ASSERT(Placed_room != -1);
    FreeRoom(&Rooms[Placed_room]);
    Placed_door = Placed_door = -1;
  }

  // Set globals
  Placed_room = placed_room;
  Placed_room_face = placed_room_face;
  Placed_room_angle = 0;
  Placed_baseroomp = NULL;

  if (align_to_terrain)
    Placed_room_orient.fvec = TerrainNormals[MAX_TERRAIN_LOD - 1][cellnum].normal1;
  else
    Placed_room_orient.fvec = Identity_matrix.uvec;

  // Compute attach point on terrain
  ComputeTerrainSegmentCenter(&Placed_room_attachpoint, cellnum);

  // Compute attach points on each face
#ifndef NEWEDITOR
  ComputeCenterPointOnFace(&Placed_room_origin, placedroomp, placed_room_face);
#else
  ComputeFaceBoundingCircle(&Placed_room_origin, placedroomp, placed_room_face);
#endif

  // Compute initial orientation matrix
  ComputePlacedRoomMatrix();

  // Set the flag
  State_changed = 1;
}

// Find all the matching faces between two rooms and join them
// Returns the number of new portals created
int JoinAllMatchingFaces(room *rp0, room *rp1) {
  face *fp0, *fp1;
  int f0, f1;
  int join_count = 0;

  // Check each face in room 0 against each in room 1
  for (f0 = 0, fp0 = rp0->faces; f0 < rp0->num_faces; f0++, fp0++) {

    // Check if face 0 is already part of portal
    if (fp0->portal_num != -1)
      continue;

    // Check current face against all faces in room 1
    for (f1 = 0, fp1 = rp1->faces; f1 < rp1->num_faces; f1++, fp1++) {

      // Check if face 1 is already part of portal
      if (fp1->portal_num != -1)
        continue;

      // First check if faces have same number of verts
      // This used to check if the normals were the same, but I decided that was bad. -MT, 3/30/99
      if ((fp0->num_verts == fp1->num_verts)) {
        int i, j, n;

        // Find one point in common
        for (i = 0; i < fp0->num_verts; i++) {
          for (j = 0; j < fp1->num_verts; j++)
            if (PointsAreSame(&rp0->verts[fp0->face_verts[i]], &rp1->verts[fp1->face_verts[j]]))
              break;
          if (j < fp1->num_verts)
            break;
        }
        if (i >= fp0->num_verts) // Couldn't find a match
          continue;              //..so go on to next face

        // Trace through verts in faces, making sure they match
        for (n = 1; n < fp0->num_verts; n++) {
          vector *v0, *v1;

          v0 = &rp0->verts[fp0->face_verts[(i + n) % fp0->num_verts]];
          v1 = &rp1->verts[fp1->face_verts[(j - n + fp1->num_verts) % fp1->num_verts]];

          if (!PointsAreSame(v0, v1)) // Found mismatch
            break;

          *v0 = *v1; // make points *exactly* the same
        }
        if (n < fp0->num_verts) // Found a mismatch
          continue;             //..so go on to next face

        // Found extact match, so join
        LinkRoomsSimple(Rooms, ROOMNUM(rp0), f0, ROOMNUM(rp1), f1);

        // Increment count
        join_count++;
      }
    }
  }

  return join_count;
}

// Find all the overlapping faces between two rooms and join them
// Returns the number of new portals created
int JoinAllOverlappingFaces(room *rp0, room *rp1) {
  face *fp0, *fp1;
  int f0, f1;
  int join_count = 0;

  // Check each face in room 0 against each in room 1
  for (f0 = 0, fp0 = rp0->faces; f0 < rp0->num_faces; f0++, fp0++) {

    // Check if face 0 is already part of portal
    if (fp0->portal_num != -1)
      continue;

    // Check current face against all faces in room 1
    for (f1 = 0, fp1 = rp1->faces; f1 < rp1->num_faces; f1++, fp1++) {

      // Check if face 1 is already part of portal
      if (fp1->portal_num != -1)
        continue;

      // This used to check if normals the same, but I decided that was bad. -MT, 3/30/99
      {
        int i;
        vector *planepoint, *norm;

        // Normals are same, so check if points are all in the same plane
        planepoint = &rp1->verts[fp1->face_verts[0]];
        norm = &fp1->normal;
        for (i = 0; i < fp0->num_verts; i++)
          if (CheckPointToPlane(&rp0->verts[fp0->face_verts[i]], planepoint, norm))
            break;
        if (i < fp0->num_verts)
          continue;

        planepoint = &rp0->verts[fp0->face_verts[0]];
        norm = &fp0->normal;
        for (i = 0; i < fp1->num_verts; i++)
          if (CheckPointToPlane(&rp1->verts[fp1->face_verts[i]], planepoint, norm))
            break;
        if (i < fp1->num_verts)
          continue;

        // Clip the connecting faces against each other
        if (ClipFacePair(rp0, f0, rp1, f1)) {

          // Make the two faces match exactly
          MatchPortalFaces(rp0, f0, rp1, f1);

          // Create the portals between the rooms
          LinkRoomsSimple(Rooms, ROOMNUM(rp0), f0, ROOMNUM(rp1), f1);

          // Reset face pointer, which may have been changed by the clip
          fp0 = &rp0->faces[f0];

          // Increment count
          join_count++;

          // Stop checking this face, since we've formed a portal for it
          break;
        } else { // it's kind of bad if the clip fails, but we have to live with it

          // Reset face pointers, which may have been changed by the clip
          fp0 = &rp0->faces[f0];
          fp1 = &rp1->faces[f1];
        }
      }
    }
  }

  return join_count;
}

// Find all the adjacent faces between two rooms and join them
void JoinAllAdjacentFaces(room *rp0, room *rp1) {
  int join_count;
  int answer;

  answer = OutrageMessageBox(MBOX_YESNOCANCEL, "Do you want to include non-matching faces?\n\n"
                                               "Selecting YES means faces will be joined if they overlap.\n"
                                               "Selecting NO means faces much match exactly.");

  if (answer == IDCANCEL)
    return;

  if (answer == IDYES)
    join_count = JoinAllOverlappingFaces(rp0, rp1);
  else
    join_count = JoinAllMatchingFaces(rp0, rp1);

  World_changed = 1;

  OutrageMessageBox("%d new portals created.\n", join_count);
}

int FindNeighbor(room *rp, int facenum, int edgenum) {
  face *fp = &rp->faces[facenum];
  int v0, v1, f, v;

  v0 = fp->face_verts[edgenum];
  v1 = fp->face_verts[(edgenum + 1) % fp->num_verts];

  for (f = 0, fp = rp->faces; f < rp->num_faces; f++, fp++)
    for (v = 0; v < fp->num_verts; v++)
      if ((fp->face_verts[v] == v1) && (fp->face_verts[(v + 1) % fp->num_verts] == v0))
        return f;

  return -1;
}

void PropagateFromFace(room *rp, int facenum, uint8_t *face_flags, bool matching_faces_only) {
  face *fp = &rp->faces[facenum];

  face_flags[facenum] = 1;

  for (int v = 0; v < fp->num_verts; v++) {
    int t;

    t = FindNeighbor(rp, facenum, v);

    if ((t != -1) && !face_flags[t])
      if (!matching_faces_only || (rp->faces[t].tmap == fp->tmap)) {
        HTexturePropagateToFace(rp, t, rp, facenum);
        PropagateFromFace(rp, t, face_flags, matching_faces_only);
      }
  }
}

// Propagate a texture from one face to all the faces in the room
// If matching_faces_only is set, only propagate if the face has the same texture
void PropagateToAllFaces(room *rp, int facenum, bool matching_faces_only) {
  uint8_t face_flags[MAX_FACES_PER_ROOM];

  // Clear flags
  for (int i = 0; i < rp->num_faces; i++)
    face_flags[i] = 0;

  // Start recursive function
  PropagateFromFace(rp, facenum, face_flags, matching_faces_only);

  // Set flag
  World_changed = 1;
}

// Splits a face unto triangles, by fanning
// Parameters:	rp,facenum - the face to triangulate
//					vertnum - the vert that is the base of the fan
void TriangulateFace(room *rp, int facenum, int vertnum) {
  face *fp = &rp->faces[facenum], *nfp;
  int num_new_faces, first_new_face, i;

  if (fp->num_verts == 3) {
    OutrageMessageBox("Face %d has three verts and cannot be split.", facenum);
    return;
  }

  if (fp->portal_num != -1) {
    OutrageMessageBox("You cannot split a face that's part of a portal.");
    return;
  }

  if (fp->flags & (FF_HAS_TRIGGER + FF_FLOATING_TRIG)) {
    OutrageMessageBox("You cannot split a face that has a trigger.");
    return;
  }

  // Add new faces
  num_new_faces = fp->num_verts - 2;
  first_new_face = RoomAddFaces(rp, num_new_faces);

  // Reset pointer to our old face
  fp = &rp->faces[facenum];

  // Set up each face
  for (i = 0, nfp = &rp->faces[first_new_face]; i < num_new_faces; i++, nfp++) {
    InitRoomFace(nfp, 3);

    // Set verts & uvls for this face
    nfp->face_verts[0] = fp->face_verts[vertnum];
    nfp->face_uvls[0] = fp->face_uvls[vertnum];
    for (int v = 1; v < 3; v++) {
      nfp->face_verts[v] = fp->face_verts[(vertnum + i + v) % fp->num_verts];
      nfp->face_uvls[v] = fp->face_uvls[(vertnum + i + v) % fp->num_verts];
    }

    // Copy other data for this face
    CopyFaceFlags(nfp, fp);
#ifndef NEWEDITOR
    nfp->tmap = fp->tmap;
#else
    // Apply texture
    HTextureApplyToRoomFace(rp, first_new_face + i, nfp->tmap);
#endif
    nfp->light_multiple = fp->light_multiple;

    // Compute the normal for this face
    ComputeFaceNormal(rp, first_new_face + i);
  }

  // Delete original face
  DeleteRoomFace(rp, facenum);

  // Check for degenerate faces (caused by colinear points) and merge with adjacent faces
  first_new_face--; // original face deleted, causing shift
  bool ok;
  do { // Check first face
    ok = ComputeFaceNormal(rp, first_new_face);
    if (!ok) {
      face *fp = &rp->faces[first_new_face];
      ASSERT(first_new_face < rp->num_faces - 1);
      AddVertToFace(rp, first_new_face, rp->faces[first_new_face + 1].face_verts[2], fp->num_verts - 1);
      rp->faces[first_new_face].face_uvls[rp->faces[first_new_face].num_verts - 1] =
          rp->faces[first_new_face + 1].face_uvls[2];
      DeleteRoomFace(rp, first_new_face + 1);
      num_new_faces--;
    }
  } while (!ok);
  do { // Check last face
    ok = ComputeFaceNormal(rp, rp->num_faces - 1);
    if (!ok) {
      face *fp = &rp->faces[rp->num_faces - 2];
      ASSERT(first_new_face < rp->num_faces - 1);
      AddVertToFace(rp, rp->num_faces - 1, rp->faces[rp->num_faces - 2].face_verts[1], 0);
      rp->faces[rp->num_faces - 1].face_uvls[1] = rp->faces[rp->num_faces - 2].face_uvls[1];
      DeleteRoomFace(rp, rp->num_faces - 2);
      num_new_faces--;
    }
  } while (!ok);

  // We're done
  EditorStatus("Face %d replace by %d new faces", facenum, num_new_faces);
#ifndef NEWEDITOR
  World_changed = 1;
#endif
}

// Deletes the connection between two rooms.  Deletes both portals.
void DeletePortalPair(room *rp, int portalnum) {
  int roomnum = ROOMNUM(rp);
  portal *pp = &rp->portals[portalnum];
  int croom = pp->croom, cportal = pp->cportal;

  // Make sure the connecting portal points back to this portal
  if ((Rooms[croom].portals[cportal].croom != roomnum) || (Rooms[croom].portals[cportal].cportal != portalnum)) {
    OutrageMessageBox("Cannot delete this portal: the connecting portal does not point back at it.\n");
    return;
  }

  // Check all the faces in this portal to make sure they point back to the portal
  if (rp->faces[pp->portal_face].portal_num != portalnum) {
    OutrageMessageBox("Cannot delete this portal: its face does not point back at it.");
    return;
  }

  DeleteRoomPortal(rp, portalnum);
  DeleteRoomPortal(&Rooms[croom], cportal);

  EditorStatus("Deleted room %d portal %d and room %d portal %d", roomnum, portalnum, croom, cportal);

  World_changed = 1;
}

// Flips a face
void FlipFace(room *rp, int facenum) {
  face *fp = &rp->faces[facenum];

  ASSERT(fp->portal_num == -1);

  for (int i = 0; i < fp->num_verts / 2; i++) {
    int v = fp->face_verts[i];
    fp->face_verts[i] = fp->face_verts[fp->num_verts - 1 - i];
    fp->face_verts[fp->num_verts - 1 - i] = v;

    roomUVL uvl = fp->face_uvls[i];
    fp->face_uvls[i] = fp->face_uvls[fp->num_verts - 1 - i];
    fp->face_uvls[fp->num_verts - 1 - i] = uvl;
  }

  // Get new normal
  if (!ComputeFaceNormal(rp, facenum))
    Int3(); // Bad!  Get Matt!

#ifndef NEWEDITOR
  World_changed = 1;
  EditorStatus("Room %d face %d flipped.", ROOMNUM(rp), facenum);
#else
  if (ROOMNUM(rp) < MAX_ROOMS)
    EditorStatus("Room %d face %d flipped.", ROOMNUM(rp), facenum);
  else
    EditorStatus("Face %d flipped.", facenum);
#endif
}

// Attempt to fix the cracks in a level
void FixCracks() {
  int r, p, f, f2, v, v2;
  room *rp;
  face *fp, *fp2;
  int possible_tjoints = 0, tjoints_fixed = 0;
  int points_added = 0;
  int points_are_same_count = 0;

  if (OutrageMessageBox(MBOX_YESNO, "This function is somewhat dangerous.\n\n"
                                    "You should be sure to save your level beforehand, and you should check the "
                                    "results very carefully afterwards.\n\n"
                                    "Continue?") != IDYES)
    return;

  // First fix gaps at portals
  for (r = 0, rp = Rooms; r <= Highest_room_index; r++, rp++) {
    if (rp->used) {
      for (p = 0; p < rp->num_portals; p++) {
        portal *pp = &rp->portals[p];
        points_added +=
            MatchPortalFaces(rp, pp->portal_face, &Rooms[pp->croom], Rooms[pp->croom].portals[pp->cportal].portal_face);
      }
    }
  }

  // Now search for and fix t-joints
  for (r = 0, rp = Rooms; r <= Highest_room_index; r++, rp++) {
    if (rp->used)
      for (f = 0, fp = rp->faces; f < rp->num_faces; f++, fp++) {
        // if (fp->portal_num == -1)
        { // don't check portal faces
        recheck_face:;
          for (v = 0; v < fp->num_verts; v++) {
            int vv0 = fp->face_verts[v], vv1 = fp->face_verts[(v + 1) % fp->num_verts];
            for (f2 = 0, fp2 = rp->faces; f2 < rp->num_faces; f2++, fp2++) {
              if (f2 != f) {
                for (v2 = 0; v2 < fp2->num_verts; v2++) {
                  int tt0 = fp2->face_verts[v2], tt1 = fp2->face_verts[(v2 + 1) % fp2->num_verts];

                  if ((vv0 == tt1) && (vv1 == tt0))
                    break; // found one, so stop
                }
                if (v2 < fp2->num_verts)
                  break;
              }
            }
            if (f2 == rp->num_faces) { // didn't find a match
              // mprintf(0,"Couldn't find shared edge for %d:%d edge %d\n",r,f,v);
              possible_tjoints++;

              // Look for vert on this edge
              for (f2 = 0, fp2 = rp->faces; f2 < rp->num_faces; f2++, fp2++) {
                if (f2 != f) {
                  for (v2 = 0; v2 < fp2->num_verts; v2++) {
                    int tt0 = fp2->face_verts[v2], tt1 = fp2->face_verts[(v2 + 1) % fp2->num_verts];

                    if (vv0 == tt1) { // one point maches; check if next is on the edge
                      // if (PointsAreColinear(&rp->verts[vv0],&rp->verts[tt0],&rp->verts[vv1])) {

                      if (PointsAreSame(&rp->verts[tt0], &rp->verts[vv0]))
                        points_are_same_count++;
                      if (PointsAreSame(&rp->verts[tt0], &rp->verts[vv1]))
                        points_are_same_count++;

                      if (CheckPointToPlane(&rp->verts[tt0], &rp->verts[vv0], &fp->normal) == 0) {
                        if (CheckPointAgainstEdge(&rp->verts[tt0], &rp->verts[vv0], &rp->verts[vv1], &fp->normal) ==
                            0) {
                          // make sure the new point is actually between the two edge points
                          float edge_len = vm_VectorDistance(&rp->verts[vv1], &rp->verts[vv0]);
                          float d0 = vm_VectorDistance(&rp->verts[tt0], &rp->verts[vv0]);
                          float d1 = vm_VectorDistance(&rp->verts[tt0], &rp->verts[vv1]);
                          if ((d0 < edge_len) && (d1 < edge_len)) {
                            mprintf(0, "Adding %d to edge %d of %d:%d (from face %d)\n", tt0, v, r, f, f2);
                            AddVertToFace(rp, f, tt0, v);
                            tjoints_fixed++;
                            goto recheck_face;
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
  }

  // Fix portals again because points may have been added when fixing t-joints
  for (r = 0, rp = Rooms; r <= Highest_room_index; r++, rp++) {
    if (rp->used) {
      for (p = 0; p < rp->num_portals; p++) {
        portal *pp = &rp->portals[p];
        points_added +=
            MatchPortalFaces(rp, pp->portal_face, &Rooms[pp->croom], Rooms[pp->croom].portals[pp->cportal].portal_face);
      }
    }
  }

  mprintf(0, "%d possible t-joints\n", possible_tjoints);
  mprintf(0, "points_are_same_count = %d\n", points_are_same_count);

  OutrageMessageBox("Level fix results:\n\n"
                    "    %d points added to portals\n"
                    "    %d T-joints fixed",
                    points_added, tjoints_fixed);

  World_changed = 1;
}

// Variables for undoing a snap
int Snap_roomnum = -1;
int Snap_vertnum;
vector Snap_old_point, Snap_new_point;

// Moves a vertex to lie on a specified edge
void SnapPointToEdge(room *rp, int vertnum, vector *v0, vector *v1) {
  vector *vp = &rp->verts[vertnum];
  vector edge_vec, edge_normal;
  float d;

  // Save info for undo
  Snap_roomnum = ROOMNUM(rp);
  Snap_vertnum = vertnum;
  Snap_old_point = *vp;

  // Calculate new point
  edge_normal = edge_vec = *v1 - *v0;
  vm_NormalizeVector(&edge_normal);
  d = vm_DistToPlane(vp, &edge_normal, v0);
  *vp = *v0 + edge_normal * d;

  // Set the point
  Snap_new_point = *vp;

  // Done
  EditorStatus("Room %d point %d snapped.", Snap_roomnum, Snap_vertnum);
  World_changed = 1;
}

// Moves a vertex to be conincident with another vertex
void SnapPointToPoint(room *rp, int vertnum, room *snapto_rp, int snapto_vertnum) {
  vector *vp = &rp->verts[vertnum];

  // Save info for undo
  Snap_roomnum = ROOMNUM(rp);
  Snap_vertnum = vertnum;
  Snap_old_point = *vp;

  *vp = snapto_rp->verts[snapto_vertnum];

  // Set the point
  Snap_new_point = *vp;

  // Done
  EditorStatus("Room %d point %d snapped.", Snap_roomnum, Snap_vertnum);
  World_changed = 1;
}

// Moves a vertex to lie on a specified plane
void SnapPointToFace(room *rp, int vertnum, vector *v0, vector *normal) {
  vector *vp = &rp->verts[vertnum];
  float d;

  // Save info for undo
  Snap_roomnum = ROOMNUM(rp);
  Snap_vertnum = vertnum;
  Snap_old_point = *vp;

  // Calculate new point
  d = vm_DistToPlane(vp, normal, v0);
  *vp -= *normal * d;

  // Set the point
  Snap_new_point = *vp;

  // Done
  EditorStatus("Room %d point %d snapped.", Snap_roomnum, Snap_vertnum);
  World_changed = 1;
}

// Undoes the most recently-performed snap
void UndoSnap() {
  if (Snap_roomnum == -1)
    return;

  if ((Snap_roomnum <= Highest_room_index) && Rooms[Snap_roomnum].used) {
    vector *vp = &Rooms[Snap_roomnum].verts[Snap_vertnum];

    if ((vp->x == Snap_new_point.x) && (vp->y == Snap_new_point.y) && (vp->z == Snap_new_point.z)) {
      *vp = Snap_old_point;
      World_changed = 1;
      return;
    }
  }

  OutrageMessageBox("Cannot Undo: The snapped point has changed since the snap.");
  Snap_roomnum = -1;
}

// Gets the angle between two vectors in the range 0..1
// Parameters:	base - the start of both vectors
//					v0,v1 - the end points of the two vectors
//					normal - the surface normal of the face these verts lie in
// Returns the cosine of the angle between <base,v0> and <base,v1>
float GetAngle(vector *base, vector *v0, vector *v1, vector *normal) {
  vector edge0, edge1, cross;
  float dot;

  vm_GetNormalizedDir(&edge0, v0, base);
  vm_GetNormalizedDir(&edge1, v1, base);

  dot = edge0 * edge1;
  cross = edge0 ^ edge1;

  if (cross * *normal > 0)
    return 0.25 - dot / 4.0;
  else
    return 0.75 + dot / 4.0;
}

// Connects two rooms in a pleasing way
void BuildSmoothBridge(room *rp0, int facenum0, room *rp1, int facenum1) {
  room *rp;
  int nv0, nv1, nverts, nfaces;
  int i;
  vector tverts[MAX_VERTS_PER_FACE];

  // Get values from current faces
  face *fp0 = &rp0->faces[facenum0];
  face *fp1 = &rp1->faces[facenum1];
  nv0 = fp0->num_verts;
  nv1 = fp1->num_verts;

  // Check for portal already here
  if (fp0->portal_num != -1) {
    OutrageMessageBox("Cannot build bridge: There is already a connection at %d:%d.", ROOMNUM(rp0), facenum0);
    return;
  }
  if (fp1->portal_num != -1) {
    OutrageMessageBox("Cannot build bridge: There is already a connection at %d:%d.", ROOMNUM(rp1), facenum1);
    return;
  }

  // Get values for new room
  nverts = nv0 + nv1;
  nfaces = nverts + 2;

  // Get a pointer to our room
  rp = CreateNewRoom(nverts, nfaces);
  if (rp == NULL) {
    OutrageMessageBox("Cannot build bridge: No free rooms.");
    return;
  }

  // Set the vertices for the room
  for (i = 0; i < nv0; i++)
    rp->verts[i] = rp0->verts[fp0->face_verts[i]];
  for (i = 0; i < nv1; i++)
    rp->verts[nv0 + i] = rp1->verts[fp1->face_verts[nv1 - 1 - i]];

  // Create the connecting faces

  // Compute normalized vector from attach face to base face
  vector c0, c1, delta_vec;
#ifndef NEWEDITOR
  ComputeCenterPointOnFace(&c0, rp0, facenum0);
  ComputeCenterPointOnFace(&c1, rp1, facenum1);
#else
  ComputeFaceBoundingCircle(&c0, rp0, facenum0);
  ComputeFaceBoundingCircle(&c1, rp1, facenum1);
#endif
  vm_GetNormalizedDir(&delta_vec, &c1, &c0);

  // Compute the cosine of the angle between our vector and the normal of the base face
  float cos = delta_vec * fp1->normal;

  // Get a pointer to a vertex on face1
  vector *vp = &rp->verts[nv0];

  // Project the verts from end face0 into end face1
  for (i = 0; i < nv0; i++) {

    // Get distance from base face to this vertex
    float dist = ((*vp - rp->verts[i]) * fp1->normal) / cos;

    // Get the new vert
    tverts[i] = rp->verts[i] + (delta_vec * dist);
  }

  // Find closest face0 point to point 0 of face1
  int smallest_i = -1;
  float smallest_angle = 1.0;
  vector tnorm = -fp1->normal;
  for (i = 0; i < nv0; i++) {
    float angle = GetAngle(&c1, &rp->verts[nv0], &tverts[i], &tnorm);
    if (angle > 0.5)
      angle = 1.0 - angle; // we want closest in either direction
    if (angle < smallest_angle) {
      smallest_i = i;
      smallest_angle = angle;
    }
  }
  ASSERT(smallest_i != -1);

  // Generate new faces
  int prev1 = 0, // set up the previous edge
      prev0 = smallest_i;
  for (i = 0; i < nverts; i++) {
    float angle0, angle1;

    face *fp = &rp->faces[i];

    InitRoomFace(fp, 3);

    fp->face_verts[0] = nv0 + prev1;
    fp->face_verts[1] = prev0;

    if (i == nverts - 1) { // special case for last edge
      if ((rp->faces[0].face_verts[0] != fp->face_verts[0]) && (rp->faces[0].face_verts[0] != fp->face_verts[1]))
        fp->face_verts[2] = rp->faces[0].face_verts[0];
      else {
        ASSERT((rp->faces[0].face_verts[1] != fp->face_verts[0]) && (rp->faces[0].face_verts[0] != fp->face_verts[1]));
        fp->face_verts[2] = rp->faces[0].face_verts[1];
      }
      break;
    }

    // Pick point for third vert
    angle1 = GetAngle(&c1, &rp->verts[nv0 + prev1], &rp->verts[nv0 + (prev1 + 1) % nv1], &tnorm);
    angle0 = GetAngle(&c1, &rp->verts[nv0 + prev1], &tverts[(prev0 + 1) % nv0], &tnorm);

    if (angle1 < angle0) {
      prev1 = (prev1 + 1) % nv1;
      fp->face_verts[2] = nv0 + prev1;
    } else
      prev0 = fp->face_verts[2] = (prev0 + 1) % nv0;
  }

  // Set the two end faces for the room
  InitRoomFace(&rp->faces[nfaces - 2], fp0->num_verts);
  for (i = 0; i < fp0->num_verts; i++)
    rp->faces[nfaces - 2].face_verts[i] = nv0 - 1 - i;

  InitRoomFace(&rp->faces[nfaces - 1], fp1->num_verts);
  for (i = 0; i < fp1->num_verts; i++)
    rp->faces[nfaces - 1].face_verts[i] = fp0->num_verts + i;

  // Set normals & textures for each face
  for (i = 0; i < nfaces; i++) {
    if (!ComputeFaceNormal(rp, i))
      Int3(); // Bad!  Get Matt!
  }

  // Attempt to combine faces
  for (i = 0; i < nfaces - 2; i++) {
    int t = (i + 1) % (nfaces - 2);

    // Try compbining the faces
    if (CombineFaces(rp, i, t)) {
      i--; // check this face again
      nfaces--;
    }
  }

  // Set textures for each face
#ifndef NEWEDITOR
  for (i = 0; i < nfaces; i++)
    rp->faces[i].tmap = i + 1;
#else
  int texnum = Editor_state.GetCurrentTexture();
  for (i = 0; i < nfaces; i++) {
    // Apply texture
    HTextureApplyToRoomFace(rp, i, texnum);
  }
#endif

  // Set UVs for all the faces
  AssignDefaultUVsToRoom(rp);

  // Form the portals between the rooms
  LinkRoomsSimple(Rooms, ROOMNUM(rp0), facenum0, ROOMNUM(rp), nfaces - 2);
  LinkRoomsSimple(Rooms, ROOMNUM(rp1), facenum1, ROOMNUM(rp), nfaces - 1);

  // Make the new room the current room
#ifndef NEWEDITOR
  Curroomp = rp;
  Curface = nfaces - 2;
  Curedge = Curvert = 0;
  Curportal = -1;
#else
  theApp.m_pLevelWnd->SetPrim(rp, nfaces - 2, -1, 0, 0);
#endif

  // Set the flag
  World_changed = 1;
}

int16_t New_face_verts[MAX_VERTS_PER_FACE];
int New_face_num_verts = -1;
room *New_face_roomp;

void AddNewFaceVert() {
  if (Curroomp != New_face_roomp) {
    OutrageMessageBox("All points in the new face must be in the same room");
    return;
  }

  if (New_face_num_verts == -1) {
    OutrageMessageBox("You must start a new face before adding to it");
    return;
  }

  New_face_verts[New_face_num_verts++] = Curroomp->faces[Curface].face_verts[Curvert];

  EditorStatus("Added %d as vert #%d in new face", Curroomp->faces[Curface].face_verts[Curvert], New_face_num_verts);
}

void StartNewFace() {
  New_face_roomp = Curroomp;
  New_face_num_verts = 0;

  AddNewFaceVert();

  EditorStatus("Starting new face with vertex %d", Curroomp->faces[Curface].face_verts[Curvert]);
}

void EndNewFace() {
  AddNewFaceVert();

  if (New_face_num_verts == -1) {
    OutrageMessageBox("You must start a new face before ending it");
    return;
  }

  if (New_face_num_verts < 3) {
    OutrageMessageBox("A face must have at least three vertices");
    return;
  }

  int facenum;

  facenum = RoomAddFaces(Curroomp, 1);

  face *fp = &Curroomp->faces[facenum];

  InitRoomFace(fp, New_face_num_verts);

  for (int i = 0; i < New_face_num_verts; i++)
    fp->face_verts[i] = New_face_verts[i];

#ifndef NEWEDITOR
  fp->tmap = 0;
#else
  int texnum = Editor_state.GetCurrentTexture();
  // Apply texture
  HTextureApplyToRoomFace(Curroomp, facenum, texnum);
#endif

  ComputeFaceNormal(Curroomp, facenum);
  AssignDefaultUVsToRoomFace(Curroomp, facenum);

  EditorStatus("New face %d created", facenum);

  New_face_num_verts = -1;

  World_changed = 1;
}

void ObjRelink(int objnum, int newroomnum);
int RemoveDuplicatePoints(room *rp);
trigger *FindTrigger(int roomnum, int facenum);

// Combine the two rooms. base_rp stays, att_rp goes away
// Returns true if combine sucessful, false if can't join
bool CombineRooms(room *base_rp, room *att_rp) {
  int i;
  face *fp;
  bool connected = 0, rendered_portals = 0;

  // Make sure these rooms share a portal
  for (i = 0; i < base_rp->num_portals; i++) {
    if (base_rp->portals[i].croom == ROOMNUM(att_rp)) {
      connected = 1;
      if ((base_rp->faces[base_rp->portals[i].portal_face].flags & FF_HAS_TRIGGER) ||
          (att_rp->faces[att_rp->portals[base_rp->portals[i].cportal].portal_face].flags & FF_HAS_TRIGGER)) {
        OutrageMessageBox("Cannot combine rooms: a portal connecting them has a trigger.");
        return 0;
      }
      if ((base_rp->portals[i].flags & PF_RENDER_FACES) ||
          (att_rp->portals[base_rp->portals[i].cportal].flags & PF_RENDER_FACES)) {
        rendered_portals = 1;
      }
    }
  }

  if (!connected) {
    OutrageMessageBox("Cannot combine rooms: the rooms are not connected.");
    return 0;
  }

  if (rendered_portals) {
    if (OutrageMessageBox(
            MBOX_YESNO,
            "One or more of the portals connecting these rooms has the Render Faces flag set.  "
            "The rendered face will remain in the room after combine.\n\nDo you still want to combine?") != IDYES)
      return 0;
  }

  // Check for doors
  if (base_rp->doorway_data || att_rp->doorway_data) {
    OutrageMessageBox("Cannot combine rooms: one room is a door.");
    return 0;
  }

  // Allocate new verts & faces
  int first_new_vert = RoomAddVertices(base_rp, att_rp->num_verts);
  int first_new_face = RoomAddFaces(base_rp, att_rp->num_faces);

  // Copy verts to base room
  for (i = 0; i < att_rp->num_verts; i++)
    base_rp->verts[first_new_vert + i] = att_rp->verts[i];

  // Copy faces to base room
  for (i = 0, fp = &base_rp->faces[first_new_face]; i < att_rp->num_faces; fp++, i++) {

    // Copy the face
    CopyFace(fp, &att_rp->faces[i]);
    fp->flags = att_rp->faces[i].flags;

    // Update the vertices
    for (int v = 0; v < fp->num_verts; v++)
      fp->face_verts[v] += first_new_vert;

    // Move triggers from attach to base room
    if (att_rp->faces[i].flags & FF_HAS_TRIGGER) {
      trigger *tp = FindTrigger(ROOMNUM(att_rp), i);
      tp->roomnum = ROOMNUM(base_rp);
      tp->facenum += first_new_face;
    }
  }

  // Deal with attach room's portals
  for (i = 0; i < att_rp->num_portals; i++) {
    int facenum, croom, cface, flags, cflags;

    facenum = att_rp->portals[i].portal_face + first_new_face;
    flags = att_rp->portals[i].flags;
    croom = att_rp->portals[i].croom;
    cface = Rooms[croom].portals[att_rp->portals[i].cportal].portal_face;
    cflags = Rooms[croom].portals[att_rp->portals[i].cportal].flags;

    // Delete old portal from attach room
    DeletePortalPair(att_rp, i);

    // If this portal attaches to the base room, mark the portal faces for deletion
    if (croom == ROOMNUM(base_rp)) {
      if (!(flags & PF_RENDER_FACES))
        base_rp->faces[facenum].tmap = -1; //-1 means to delete the face
      if (!(cflags & PF_RENDER_FACES))
        base_rp->faces[cface].tmap = -1; //-1 means to delete the face
    } else {                             // Attaches to third room, so make attachment to base room
      LinkRooms(Rooms, ROOMNUM(base_rp), facenum, croom, cface);
      portal *pp = &base_rp->portals[base_rp->num_portals - 1];
      pp->flags |= (flags & (PF_RENDER_FACES + PF_RENDERED_FLYTHROUGH));
      Rooms[pp->croom].portals[pp->cportal].flags |= (cflags * (PF_RENDER_FACES + PF_RENDERED_FLYTHROUGH));
    }

    i--; // adjust for new portal numbering
  }

  // Delete obsolete faces
  for (i = 0; i < base_rp->num_faces; i++)
    if (base_rp->faces[i].tmap == -1) {
      DeleteRoomFace(base_rp, i);
      i--;
    }

  // Link objects to new room
  while (att_rp->objects != -1)
    ObjRelink(att_rp->objects, ROOMNUM(base_rp));

  // Delete the old room
  DeleteRoomFromMine(att_rp);

  // Get rid of duplicate verts
  RemoveDuplicatePoints(base_rp);

  // Done!
  World_changed = 1;
  return 1;
}

// Creates a an external room and links the specified faces to it
// Parameters:	rp - the room to connect to the new room
//					nfaces - how many faces connect to the new room (this becomes the number of
//portals) 					facenums - the list of faces to connect
void LinkToExternalRoom(room *rp, int nfaces, int *facenums) {
  int vert_xlate[MAX_VERTS_PER_ROOM];
  int v, i, nverts = 0;

  for (i = 0; i < rp->num_verts; i++)
    vert_xlate[i] = -1;

  for (i = 0; i < nfaces; i++) {
    face *fp = &rp->faces[facenums[i]];

    for (v = 0; v < fp->num_verts; v++) {
      int vertnum = fp->face_verts[v];
      if (vert_xlate[vertnum] == -1)
        vert_xlate[vertnum] = nverts++;
    }
  }

  room *newrp = CreateNewRoom(nverts, nfaces);

  newrp->flags |= RF_EXTERNAL;

  for (i = 0; i < rp->num_verts; i++) {
    if (vert_xlate[i] != -1)
      newrp->verts[vert_xlate[i]] = rp->verts[i];
  }

  for (i = 0; i < nfaces; i++) {
    face *newfp = &newrp->faces[i], *fp = &rp->faces[facenums[i]];

    InitRoomFace(newfp, fp->num_verts);

    for (v = 0; v < fp->num_verts; v++)
      newfp->face_verts[v] = vert_xlate[fp->face_verts[fp->num_verts - v - 1]];

#ifndef NEWEDITOR
    newfp->tmap = fp->tmap;
#else
    // Apply texture
    HTextureApplyToRoomFace(newrp, i, newfp->tmap);
#endif

    if (!ComputeFaceNormal(newrp, i))
      Int3();

    LinkRooms(Rooms, ROOMNUM(rp), facenums[i], ROOMNUM(newrp), i);
  }

  AssignDefaultUVsToRoom(newrp);

  World_changed = 1;
}

extern bool Disable_editor_rendering;

// Splits a face into two pieces
// Parameters:	rp,facenum - the face to split
//					v0,v1 - the two verts that will form the new edge
void SplitFace(room *rp, int facenum, int v0, int v1) {
  face *fp = &rp->faces[facenum], *nfp;
  int first_new_face, i;

  if (v0 == v1) {
    OutrageMessageBox("You cannot split a face using the same point twice.");
    return;
  }

  if (v1 < v0) {
    int t = v1;
    v1 = v0;
    v0 = t;
  }

  if (v1 == (v0 + 1) % fp->num_verts) {
    OutrageMessageBox("You cannot split a face using two adjacent points.");
    return;
  }

  if (fp->num_verts == 3) {
    OutrageMessageBox("Face %d has three verts and cannot be split.", facenum);
    return;
  }

  if (fp->portal_num != -1) {
    OutrageMessageBox("You cannot split a face that's part of a portal.");
    return;
  }

  if (fp->flags & (FF_HAS_TRIGGER + FF_FLOATING_TRIG)) {
    OutrageMessageBox("You cannot split a face that has a trigger.");
    return;
  }

  Disable_editor_rendering = 1;

  // Add new faces
  first_new_face = RoomAddFaces(rp, 2);

  // Reset pointer to our old face
  fp = &rp->faces[facenum];

  // Set up each face
  bool ok[2];
  for (i = 0, nfp = &rp->faces[first_new_face]; i < 2; i++, nfp++) {
    int nv, startv;

    if (i == 0) {
      nv = v1 - v0 + 1;
      startv = v0;
    } else {
      nv = fp->num_verts - (v1 - v0) + 1;
      startv = v1;
    }

    InitRoomFace(nfp, nv);

    // Set verts & uvls for this face
    for (int v = 0; v < nv; v++) {
      nfp->face_verts[v] = fp->face_verts[(startv + v) % fp->num_verts];
      nfp->face_uvls[v] = fp->face_uvls[(startv + v) % fp->num_verts];
    }

    // Copy other data for this face
    CopyFaceFlags(nfp, fp);
#ifndef NEWEDITOR
    nfp->tmap = fp->tmap;
#else
    // Apply texture
    HTextureApplyToRoomFace(rp, first_new_face + i, fp->tmap);
#endif
    nfp->light_multiple = fp->light_multiple;

    // Compute the normal for this face
    ok[i] = ComputeFaceNormal(rp, first_new_face + i);
  }

  // Bail if either face is degenerate
  if (!ok[0] || !ok[1]) {
    OutrageMessageBox("Cannot form face here: one new face is degenerate.");
    DeleteRoomFace(rp, first_new_face);
    DeleteRoomFace(rp, first_new_face + 1);
    Disable_editor_rendering = 0;
    return;
  }

  // Delete original face
  DeleteRoomFace(rp, facenum);

  // We're done
  EditorStatus("Face %d replaced by new faces %d & %d", facenum, first_new_face - 1, first_new_face);

  Disable_editor_rendering = 0;

#ifndef NEWEDITOR
  World_changed = 1;
#endif
}

// Adds a point to an edge
void SplitEdge(room *rp, int facenum, int edgenum, float position) {
  face *fp = &rp->faces[facenum];
  int vert1 = (edgenum + 1) % fp->num_verts;
  vector *v0, *v1, newv;

  v0 = &rp->verts[fp->face_verts[edgenum]];
  v1 = &rp->verts[fp->face_verts[vert1]];

  newv = *v0 + (*v1 - *v0) * position;

  AddPointToAllEdges(rp, fp->face_verts[edgenum], fp->face_verts[vert1], &newv);

  World_changed = 1;
}

#define MIN_NORMAL_MAG 0.035

int FindConnectedFace(room *rp, int facenum, int edgenum, int startface);

// Deletes a vertex from an face
// Only deletes if the two adjacent edges are colinear, and there isn't a T-joint at this point
void DeleteVert(room *rp, int facenum, int vertnum) {
  face *fp = &rp->faces[facenum];
  vector normal;
  float mag;
  int f0, f1;
  int prev_vertnum = (vertnum + fp->num_verts - 1) % fp->num_verts;

  mag = vm_GetNormal(&normal, &rp->verts[fp->face_verts[prev_vertnum]], &rp->verts[fp->face_verts[vertnum]],
                     &rp->verts[fp->face_verts[(vertnum + 1) % fp->num_verts]]);

  if (mag >= MIN_NORMAL_MAG) {
    OutrageMessageBox("Can't remove point: edges aren't colinear.");
    return;
  }

  // Make sure there isn't a t-joint at this face
  f0 = FindConnectedFace(rp, facenum, prev_vertnum, 0);
  f1 = FindConnectedFace(rp, facenum, vertnum, 0);
  if ((f0 != -1) && (f1 != -1) && (f0 != f1)) {
    OutrageMessageBox("Can't delete vertex: apparent T-joint with faces %d & %d\n", f0, f1);
    return;
  }

  // Delete the point on our passed face
  DeletePointFromFace(rp, facenum, vertnum);

  // Delete the point on the connected face
  face *fp2 = &rp->faces[f0];
  for (int v2 = 0; v2 < fp2->num_verts; v2++)
    if (fp2->face_verts[v2] == fp->face_verts[vertnum])
      break;
  ASSERT(v2 < fp2->num_verts);
  DeletePointFromFace(rp, f0, v2);

#ifndef NEWEDITOR
  World_changed = 1;
#endif
}

// Moves a vertex along its two adjacent edges
// Only moves if the two adjacent edges are colinear
void MoveVert(room *rp, int facenum, int vertnum, float new_position) {
  face *fp = &rp->faces[facenum];
  vector normal;
  float mag;
  int prev_vertnum = (vertnum + fp->num_verts - 1) % fp->num_verts;
  int next_vertnum = (vertnum + 1) % fp->num_verts;
  vector *v0, *v1, newv;

  mag = vm_GetNormal(&normal, &rp->verts[fp->face_verts[prev_vertnum]], &rp->verts[fp->face_verts[vertnum]],
                     &rp->verts[fp->face_verts[next_vertnum]]);

  if (mag >= MIN_NORMAL_MAG) {
    OutrageMessageBox("Can't move point: edges aren't colinear.");
    return;
  }

  v0 = &rp->verts[fp->face_verts[prev_vertnum]];
  v1 = &rp->verts[fp->face_verts[next_vertnum]];

  newv = *v0 + (*v1 - *v0) * new_position;

  rp->verts[fp->face_verts[vertnum]] = newv;

  World_changed = 1;
}

#include "polymodel.h"

// Incorporates the geometry from the specified object into the specified room.  Deletes the object.
// Returns true if worked, false if some error
bool MergeObjectIntoRoom(room *rp, int objnum) {
  object *objp = &Objects[objnum];
  ASSERT(objp->render_type == RT_POLYOBJ);

  poly_model *pm = GetPolymodelPointer(objp->rtype.pobj_info.model_num);

  if (pm->n_models > 1) {
#ifndef NEWEDITOR
    OutrageMessageBox("Cannot merge: Only supported for objects with one submodel.\n\nIf you really need this "
                      "functions for objects with multiple submodles, talk to MattT.");
#else
    OutrageMessageBox("Cannot merge: Only supported for objects with one submodel.");
#endif
    return 0;
  }
  if (!pm->n_ground) {
    OutrageMessageBox("Cannot merge: The object must have a ground plane to merge.");
    return 0;
  }
  if (OBJECT_OUTSIDE(objp)) {
    OutrageMessageBox("Cannot merge: The object is outside.");
    return 0;
  }
  if (objp->roomnum != ROOMNUM(rp)) {
    OutrageMessageBox("Cannot merge: The object is not in the specified room.");
    return 0;
  }

  // Get points to model data
  bsp_info *sm = &pm->submodel[0];

  // Add verts to room
  int first_new_vert = RoomAddVertices(rp, sm->nverts);

  // Rotate the points and copy them to the room
  matrix rotmat = ~objp->orient;
  for (int i = 0; i < sm->nverts; i++) {
    rp->verts[first_new_vert + i] = objp->pos + sm->verts[i] * rotmat;
  }

  // Add faces to the room
  int first_new_face = RoomAddFaces(rp, sm->num_faces);

  // Copy the faces
  for (i = 0; i < sm->num_faces; i++) {
    polyface *pfp = &sm->faces[i];
    face *fp = &rp->faces[first_new_face + i];

    InitRoomFace(fp, pfp->nverts);

    for (int v = 0; v < fp->num_verts; v++) {
      fp->face_verts[v] = first_new_vert + pfp->vertnums[v];
      fp->face_uvls[v].u = pfp->u[v];
      fp->face_uvls[v].v = pfp->v[v];
    }

#ifndef NEWEDITOR
    fp->tmap = pm->textures[pfp->texnum];
#else
    // Apply texture
    HTextureApplyToRoomFace(rp, first_new_face + i, pm->textures[pfp->texnum]);
#endif

    if (!ComputeFaceNormal(rp, first_new_face + i))
      Int3(); // Bad!  Get Matt!
  }

  // Kill the object
  ObjDelete(objnum);

  // Done!
  World_changed = 1;
  return 1;
}

void MarkFaceForDeletion(room *rp, int facenum) {
  face *fp = &rp->faces[facenum];

  // Mark this face
  fp->tmap = -1;

  // Find connect faces
  for (int e = 0; e < fp->num_verts; e++) {
    int t = -1;

    while ((t = FindConnectedFace(rp, facenum, e, t + 1)) != -1) {
      if (rp->faces[t].tmap != -1)
        MarkFaceForDeletion(rp, t);
    }
  }
}

// Delete all the faces connected to the specified face
void DeleteAllConnectedFaces(room *rp, int facenum) {
  // Make sure no faces using tmap of -1
  for (int f = 0; f < rp->num_faces; f++)
    ASSERT(rp->faces[f].tmap != -1);

  // Do recursive marking
  MarkFaceForDeletion(rp, facenum);

  // Now delete the faces
  for (f = 0; f < rp->num_faces;) {

    if (rp->faces[f].tmap == -1)
      DeleteRoomFace(rp, f);
    else
      f++;
  }

  // Done
  World_changed = 1;
}

// returns the number of faces changed
int PropagateToConnectedFacesSub(room *rp, int facenum, bool *face_checked) {
  int n_changed = 0;

  face_checked[facenum] = 1;

  face *fp = &rp->faces[facenum];

  for (int e = 0; e < fp->num_verts; e++) {
    int t = -1;

    do {

      t = FindConnectedFace(rp, facenum, e, t + 1);

      if ((t != -1) && !face_checked[t]) {

        if (NormalsAreSame(&fp->normal, &rp->faces[t].normal)) {

          HTexturePropagateToFace(rp, t, rp, facenum);

          n_changed++;

          n_changed += PropagateToConnectedFacesSub(rp, t, face_checked);
        }
      }

    } while (t != -1);
  }

  return n_changed;
}

void PropagateToConnectedFaces(room *rp, int facenum) {
  bool face_checked[MAX_FACES_PER_ROOM];
  int f, n_changed;

  for (f = 0; f < rp->num_faces; f++)
    face_checked[f] = 0;

  face_checked[facenum] = 1;

  n_changed = PropagateToConnectedFacesSub(rp, facenum, face_checked);

  EditorStatus("%d faces were retextured.", n_changed);

  if (n_changed)
    World_changed = 1;
}