/* * 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 . --- HISTORICAL COMMENTS FOLLOW --- * $Logfile: /DescentIII/Main/editor/Erooms.cpp $ * $Revision: 1.1.1.1 $ * $Date: 2003-08-26 03:57:38 $ * $Author: kevinb $ * * Functions to create, delete, etc. rooms * * $Log: not supported by cvs2svn $ * * 167 10/14/99 4:21p Matt * Added code to remove duplicate faces from a room. * * 166 9/30/99 5:02p Matt * Automatically normalize face UV values when a level is verified. * * 165 9/07/99 4:36p Gwar * disabled deletion of only the face verts of a face in DeleteRoomFace * (it now deletes all unused verts, like before) * * 164 8/30/99 1:50p Gwar * stupid me forgot a semicolon * * 163 8/30/99 1:23p Gwar * In DeleteRoomFace, added a way to delete only verts that were in the * deleted face * * 162 8/17/99 6:11p Gwar * handle NEWEDITOR texture management in CopyRoom * * 161 8/15/99 3:10a Gwar * decrement Curface in DeleteRoomFace if Curface is the last face in the * room * * 160 8/13/99 4:52p Gwar * fixed a stupid bug from my last checkin * * 159 8/13/99 4:43p Gwar * decrement Markedface in DeleteRoomFace if Markedface is the last face * in the room * * 158 7/17/99 1:36a Gwar * fixed a string formatting bug in a call to OutrageMessageBox * * 157 7/14/99 9:07a Gwar * added a parameter to AllocLoadRoom * * 156 7/06/99 10:22a Gwar * removed and #ifdef NEWEDITOR for this build... * * 155 7/04/99 4:55p Gwar * changes for texture management in NEWEDITOR * * 154 7/03/99 5:50p Gwar * minor changes for NEWEDITOR * * 153 7/02/99 2:17p Gwar * added a parameter to AllocLoadRoom to disable centering on origin * * 152 5/05/99 5:03a Gwar * renamed ned_GameTextures array to GameTextures in new editor to make * game code happy; 3D texture view still does not display textures * * 151 5/05/99 3:02a Gwar * added a parameter to DeleteRoomFace (by permission) * * 150 4/30/99 2:21p Jason * changes to verify level completeness * * 149 4/27/99 3:36p Jason * fixed terrain occlusion bug * * 148 4/26/99 11:11a Chris * Updated Bnode system * * 147 4/25/99 10:16p Matt * Added soundsource check to verify mine. * * 146 4/25/99 9:02p Chris * Improving the Bnode system * * 145 4/21/99 10:20p Matt * Don't compute shells for external rooms in mine verify. * * 144 4/21/99 5:15a Gwar * added support for paletted rooms (ORFs) into new editor * * 143 4/20/99 8:19p Matt * Added an assert. * * 142 4/15/99 3:10p Matt * Took out Int3() in FindSharedEdge(), and took out some mrpintf()s in * the shell calculation. * * 141 4/12/99 10:43a Jason * checked in so code would compile * * 140 4/10/99 5:38p Matt * Commented out some code that wouldn't compile. * * 139 4/08/99 5:46p Jason * added texture finding option * * 138 4/08/99 3:15p Matt * Don't compute a shell for external rooms. * * 137 4/08/99 12:45p Jason * don't count lights or non renderable portal faces in the level * * 136 4/07/99 2:22p Jason * warned designers if they have over 60 128s in their level * * 135 4/07/99 12:43p Jason * added texture counting to verify level * * 134 4/07/99 11:24a Jason * verify level now checks terrain occlusion and boa * * 133 4/06/99 5:10p Matt * Base room shell on all portals in the room, not just the first one. * * 132 4/05/99 11:17a Matt * Added code to list all the objects in the levels. * * 131 4/01/99 9:42a Matt * Added code to compute room shells, and made verify level do it. * * 130 3/31/99 11:34a Matt * Got rid of unused forcefield checkbox on room tab * * 129 3/31/99 11:33a Matt * Make note of non-planar faces that are portals. * * 128 3/30/99 7:57p Matt * Added prototype and moved a function to be inline in the header. * * 127 3/30/99 7:20p Matt * Deleted PointsAreColinear(), since it was never used and worked the * wrong way. * * 126 3/29/99 6:45p Matt * Changed concavity tolerance from 0.005 to 0.05. * Added verify code to check for concave faces and degenerate faces. * Added code to fix degenerate faces. * * 125 3/24/99 5:53p Jason * added per room ambience settings * * 124 3/23/99 1:41p Jason * fixed concave normal bug * * 123 3/11/99 5:12p Matt * Added some error messages for the new verify level checks * * 122 3/11/99 4:58p Matt * Fixed extra-stupid malloc bug * * 121 3/11/99 3:20p Matt * Added checks for T-joints and mismatched portals to verify level. * * 120 2/19/99 1:24p Matt * Moved ComputerCenterRoomOnFace() from editor to main * * 119 2/18/99 12:32p Jason * added room multiplier * * 118 2/11/99 1:44p Matt * Fix up triggers when deleting a face * * 117 2/03/99 1:10p Matt * Changed the paletted room current faces to be stored in a seperate * array, instead of in the room structure. * * 116 1/29/99 12:48p Matt * Rewrote the doorway system * * 115 1/25/99 7:39p Luke * Added comment to tell me when ROOMFILE_VERSION changes (so I can change * RoomView) * * 114 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. * * 113 12/22/98 2:03p Matt * Added room names, and made rooms not compress so that room numbers are * suitable for persistant uses. * * 112 12/09/98 3:12p Jason * save/load light multiples with faces * * 111 12/07/98 12:00p Sean * Adjusted co-planar epsilon * * 110 11/17/98 5:58p Sean * Changed concavity tolerance from 0.0001 to 0.0005 (MattT on Sean's * machine) * * 109 11/03/98 6:20p Matt * Changed the concavity check to not be dependent on the length of the * edges being checked. * * 108 11/02/98 6:15p Chris * Room AABBs get saved with the level and the sort_face and dec_sort_face * list s have been removed * * 107 11/01/98 1:58a Jeff * converted the vsprintf calls to use the Pvsprintf, which is a safe * vsprintf, no buffer overflows allowed * * 106 10/08/98 8:16p Matt * Made AssignDefaultUVsToRoom() call AssignDefaultUVsToRoomFace() * * 105 10/08/98 4:23p Kevin * Changed code to comply with memory library usage. Always use mem_malloc * , mem_free and mem_strdup * * 104 10/07/98 12:48p Matt * Added some extra error checking to prevent doubly-formed portals. * * 103 10/03/98 8:05p Matt * Changed the way CheckIfFaceIsPlanar() works (& renamed it to * FaceIsPlanar()) and added planar check to VerifyMine() & VerifyRoom() * * 102 9/29/98 4:00p Matt * Fix selected room list when compressing the mine. * * 101 9/28/98 10:55a Jason * fixed some bugs that VC6 caught * * 100 9/24/98 5:00p Matt * Improved error checking for running out of rooms. * * 99 9/14/98 12:18p Matt * Took out mprintf() that was slowing down room importing. * * 98 9/10/98 6:37p Matt * Increased concavity check tolerance (from 0.002 to 0.003) to fix * problem forming smooth bridge on Dan's level 9. * * 97 9/09/98 9:10p Matt * In verify & fix functions, don't process non-used rooms. * * 96 9/08/98 6:12p Matt * Added code to check for and fix duplicate and unused points. * * 95 9/08/98 12:54p Matt * Changed CONCAVITY_TOLERANCE from 0.0000000001 to 0.002 to fix a problem * Sean was having joining faces. * * 94 9/08/98 12:53p Matt * Added duplicate point check to level verify * * 93 9/08/98 12:05p Jason * moved doorway.h out of room.h * * 92 9/03/98 1:23p Matt * Made AddVertToFace() compute alpha, u2, & v2 values for the new point. * * 91 9/02/98 5:56p Matt * Changed comment * * 90 9/02/98 4:20p Matt * Cleaned up some linking code now that we don't have multi-face portals. * * 89 9/02/98 2:28p Matt * New function to add a vertex to a face. * * 88 9/01/98 12:04p Matt * Ripped out multi-face portal code * * 87 8/31/98 4:37p Matt * Added improved room & mine error checking. * * 86 8/14/98 4:46p Matt * Fix doorways when compressing the mine * * 85 8/11/98 12:46p Matt * Temporary fix for forming portals between faces with different numbers * of vertices. * * 84 7/21/98 4:25p Chris * Fixed a bug with the new AABB stuff * * 83 7/21/98 2:14p Chris * Some FVI speedups - not done * * 82 7/17/98 9:56a Chris * Intermediate checkin * * 81 7/16/98 8:29p Chris * Partial implementation of the new collide code * * 80 6/26/98 12:30p Matt * In PointsAreSame(), check for the middle point being the same as either * of the end points. * * 79 6/25/98 7:15p Matt * Added code to check for errors in portal linkage * * 78 6/19/98 12:22p Jason * fixed special faces bug * * 77 6/08/98 12:27p Matt * Added function to copy from one face to another the flags that should * be inherited. * * 76 6/02/98 6:03p Jason * added specular lightmaps * * 75 5/25/98 3:46p Jason * added better light glows * * 74 5/22/98 3:28p Jason * added specular lighting * * 73 5/04/98 12:27p Matt * Fixed misspelling * * 72 4/27/98 6:41p Matt * Cleaned up epsilons some more, and moved some code here from hroom.cpp. * * 71 4/21/98 4:05p Jason * made copyface take into accound light multiples * * 70 4/21/98 2:44p Matt * Added code to check a level, but haven't finished or made it available * yet. * * 69 4/16/98 3:33p Matt * Cleaned up epsilon values, again. * * 68 4/16/98 12:59p Matt * Changed point-to-edge epsilon, and took out Int3s's * * 67 4/16/98 10:41a Matt * Added FindSharedEdgeAcrossRooms() * * 66 4/15/98 4:57p Matt * Fixed massive stupidity in the way I computed if a point was outside an * edge for polygon:polygon clipping. * * 65 4/02/98 12:23p Jason * trimmed some fat from our structures * * 64 3/31/98 3:49p Jason * added memory lib * * 63 3/18/98 4:31p Chris * Speed up fvi and fixed some bugs * * 62 3/16/98 5:50p Chris * Added sorted face lists for fvi * * 61 2/24/98 1:54p Jason * added much stricter concavity testing * * 60 2/23/98 4:25p Jason * got rid of stupid compiler warning * * 59 2/22/98 3:02p Jason * changed concavity tolerance in CheckIfFaceIsPlanar * * 58 2/19/98 2:20p Jason * fixed lightmap combining to eliminate tjoint problems * * 57 2/16/98 1:07p Matt * Changed assert to int3 * * 56 2/12/98 9:10p Matt * Adjusted epsilon when clipping rooms. * * 55 2/11/98 4:03p Matt * When loading a room, center it at the origin * * 54 2/11/98 12:38p Matt * Fixed small bug in DeleteRoomVert() * * 53 2/10/98 3:50p Jason * added pulsing walls * * 52 2/08/98 6:03p Matt * When copying a face, don't copy the has_trigger flag * * 51 1/20/98 4:05p Matt * Move BuildListOfPortalVerts() from roomkeypaddialog.cpp to erooms.cpp * * 50 1/16/98 11:53a Matt * Relaxed low-precision normal check, and added mprintfs with info on * problem normals * * 49 1/15/98 7:34p Matt * Revamped error checking when computing face normals * * 48 1/12/98 5:05p Luke * Code was using wrong constant when searching palette rooms (MattT on * Luke's machine) * * 47 12/30/97 3:33p Jason * fixed stupid variable bug * * 46 11/24/97 1:30a Jason * first attempt at adding shadows * * 45 11/17/97 7:37p Sean * Increased point edge epsilon (Matt on Sean's machine) * * 44 11/11/97 6:45p Matt * Adjusted epsilon value for edge clip * * 43 11/04/97 7:30p Matt * Dealt with yet more precision problems in room clip * * 42 10/30/97 6:31p Jason * fixed potential lightmap bugs * * 41 10/29/97 12:36p Matt * Dealt with some precision problems in clipper * * 40 10/13/97 5:08p Matt * Moved ComputeRoomBoundingSphere() & CreateRoomObjects() from editor to * main * * * 39 10/01/97 7:51p Matt * Added code for external rooms * * 38 9/24/97 3:20p Matt * Added ComputeRoomMinMax() * * 37 9/19/97 2:52p Jason * changes to fix lightmap seam problem * * 36 9/17/97 11:52a Samir * BIG SEGMENT RIPOUT * * 35 9/16/97 4:27p Matt * Got rid of static_light & changed fields in the room struct * * 34 9/15/97 2:21p Matt * Remap triggers when compress mine. (Also deleted some segment engine * code.) * * 33 9/15/97 11:03a Jason * fixed bug with alpha * * 32 9/12/97 2:27p Matt * Added code to delete any unused vertices when deleting a face * * 31 9/10/97 3:02p Matt * Moved GetIJ() from erooms.cpp to room.cpp * * 30 9/09/97 10:25a Matt * Clip alpha values when clipping edge * * 29 9/03/97 2:00p Jason * made LIGHTMAP_SPACING #define for controlling spacing of lightmap * elements * * 28 9/02/97 5:17p Jason * changes for dynamic lighting * * 27 9/02/97 2:28p Matt * Changed PointOutsideEdge() to the more generally-useful * CheckPointAgainstEdge() * Made CopyFace() clear the portal number * * 26 9/02/97 11:47a Jason * Got alpha per vertex working * * 25 9/02/97 11:01a Matt * Moved assert() * * 24 8/29/97 5:44p Matt * Moved a couple functions from hroom.cpp, and added a couple more useful * functions. * * 23 8/28/97 12:31p Jason * added hi-res lightmaps for radiosity * * 22 8/22/97 1:02p Matt * Got CompressMine() working for rooms * * 21 8/21/97 5:56p Matt * Added a bunch of useful functions, and make CheckFaceConcavity() more * generally useful. * * 20 8/18/97 11:47a Sean * FROM JASON: Recompute normals on LoadRoom * * 19 8/04/97 6:46p Jason * added code for a lightmap system * * 18 8/01/97 6:11p Matt * Added several functions that I needed for attach room code * * 17 8/01/97 4:41p Jason * made FixConcaveFaces reset all room normals as an extra precaution * * 16 8/01/97 12:50p Jason * added code to support scaling of rooms/faces/edges * * 15 7/31/97 3:31p Jason * added functions to rotate portal rooms * * 14 7/29/97 1:54p Matt * Added some generally useful room/face functions * * 13 7/21/97 12:14p Matt * Fixed stupid bug in concavity check * * 12 7/18/97 5:36p Jason * save changed paletted rooms on exit * * 11 7/18/97 4:37p Matt * Added function CheckFaceConcavity() * * * * $NoKeywords: $ */ #include #include #include #ifndef NEWEDITOR #include "d3edit.h" #else #include "..\neweditor\stdafx.h" #include "..\neweditor\neweditor.h" #include "..\neweditor\globals.h" #include "..\neweditor\ned_geometry.h" #endif #include "erooms.h" #include "room.h" #include "gametexture.h" #include "terrain.h" #include "special_face.h" #include "lighting.h" #include "trigger.h" #include "mem.h" #include "doorway.h" #ifndef NEWEDITOR #include "editor_lighting.h" #endif #include "boa.h" #include "bnode.h" //List of current faces for the palette rooms int Current_faces[MAX_PALETTE_ROOMS]; //Returns a free room number, & marks it no longer free. Returns -1 if none free. //If palette_room is true, allocate out of the part of the array for the room palette int GetFreeRoom(bool palette_room) { int roomnum; int start,end; int old_hri = Highest_room_index; if (palette_room) { start = FIRST_PALETTE_ROOM; end = start+MAX_PALETTE_ROOMS; } else { start = 0; end = MAX_ROOMS; } for (roomnum=start;roomnum Highest_room_index) Highest_room_index = roomnum; } else Current_faces[roomnum - FIRST_PALETTE_ROOM] = 0; BNode_RemapTerrainRooms(old_hri, Highest_room_index); return roomnum; } //Allocates a room & initializes it. //Memory is allocated for faces & verts arrays, but the elements are *not* initialized //The number of portals is set to zero. //If palette_room is true, allocate out of the part of the array for the room palette //Returns: pointer to new room, or NULL if no free rooms room *CreateNewRoom(int nverts,int nfaces,bool palette_room) { int roomnum; room *rp; //Get a free room roomnum = GetFreeRoom(palette_room); if (roomnum == -1) return NULL; rp = &Rooms[roomnum]; //Initalize room, allocating memory InitRoom(rp,nverts,nfaces,0); return rp; } // Find the uv associated with a face vertex // This routine works by projecting the face on to its own normals plane // and just treating the face like a 2d surface // Important - vertnum is the index into the face_verts[] array in the face structure, // not an index into the verts[] array of the room structure void GetUVLForRoomPoint (int roomnum,int facenum,int vertnum,roomUVL *uvl) { matrix face_matrix,trans_matrix; vector fvec; vector avg_vert; vector verts[MAX_VERTS_PER_FACE]; vector rot_vert; ASSERT (Rooms[roomnum].used); ASSERT (Rooms[roomnum].faces[facenum].num_verts>=3); // find the center point of this face vm_MakeZero (&avg_vert); for (int i=0;itopmost_y) { topmost_point=i; topmost_y=verts[i].y; } } ASSERT (topmost_point!=-1); // Find right most point int rightmost_point=-1; float rightmost_x=-900000.00f; // a big number for (i=0;irightmost_x) { rightmost_point=i; rightmost_x=verts[i].x; } } ASSERT (rightmost_point!=-1); // Find bottom most point int bottommost_point=-1; float bottommost_y=900000.0f; // a big number for (i=0;iu=(verts[vertnum].x-base_vector.x)/20.0; uvl->v=(base_vector.y-verts[vertnum].y)/20.0; } #define DEFAULT_ALPHA 255 // Goes through each face of the passed room and sets the default uvs void AssignDefaultUVsToRoom (room *rp) { ASSERT (rp->used>=1); for (int i=0;inum_faces;i++) AssignDefaultUVsToRoomFace(rp,i); } // Sets the default UVS for a room face void AssignDefaultUVsToRoomFace (room *rp,int facenum) { ASSERT (rp->used>=1); ASSERT (facenumnum_faces); int t; for (t=0;tfaces[facenum].num_verts;t++) { GetUVLForRoomPoint (ROOMNUM(rp),facenum,t,&rp->faces[facenum].face_uvls[t]); rp->faces[facenum].face_uvls[t].alpha = DEFAULT_ALPHA; } } // Searches thru all rooms for a specific name, returns -1 if not found // or index of room with name int FindRoomName (char *name) { int i; ASSERT (name!=NULL); for (i=FIRST_PALETTE_ROOM;inum_verts;i++) { rp->verts[i].x=cf_ReadFloat (infile); rp->verts[i].y=cf_ReadFloat (infile); rp->verts[i].z=cf_ReadFloat (infile); } break; case ROOM_TEXTURE_CHUNK: if (!initted) { Int3(); // bad format info, get jason done=1; break; } highest_index=cf_ReadInt (infile); for (i=0;inum_faces;i++) { uint8_t light_multiple=4; if (room_version>=4) light_multiple=cf_ReadByte(infile); int nverts = cf_ReadInt (infile); //rp->faces[i].num_verts=cf_ReadInt (infile); //rp->faces[i].face_verts=(int16_t *)mem_malloc (sizeof(int16_t)*rp->faces[i].num_verts); //rp->faces[i].face_uvls=(g3UVL *)mem_malloc (sizeof(g3UVL)*rp->faces[i].num_verts); InitRoomFace(&rp->faces[i],nverts); ASSERT (rp->faces[i].face_verts); ASSERT (rp->faces[i].face_uvls); rp->faces[i].normal.x=cf_ReadFloat (infile); rp->faces[i].normal.y=cf_ReadFloat (infile); rp->faces[i].normal.z=cf_ReadFloat (infile); rp->faces[i].light_multiple=light_multiple; tex_index=cf_ReadShort (infile); tex_index=FindTextureName (texture_names[tex_index]); if (tex_index==-1) // If this texture doesn't exist, bash to error texture rp->faces[i].tmap=0; else rp->faces[i].tmap=tex_index; for (int t=0;tfaces[i].num_verts;t++) { rp->faces[i].face_verts[t]=cf_ReadShort (infile); rp->faces[i].face_uvls[t].u=cf_ReadFloat (infile); rp->faces[i].face_uvls[t].v=cf_ReadFloat (infile); cf_ReadFloat (infile); cf_ReadFloat (infile); cf_ReadFloat (infile); cf_ReadFloat (infile); if (room_version>=1) rp->faces[i].face_uvls[t].alpha=Float_to_ubyte(cf_ReadFloat (infile)); if (room_version<=1) rp->faces[i].face_uvls[t].alpha=255; } } break; case ROOM_END_CHUNK: done=1; break; default: // skip the ones we don't know for (i=0;inum_verts;v++) rp->verts[v] -= center; } //We're done return ROOMNUM(rp); } // Gets next palette room (from n) that has actually been alloced int GetNextRoom (int n) { int i; ASSERT ((n==-1) || ((n>=FIRST_PALETTE_ROOM) && n and . Let's see if we have a concavity dot = (-j0 * i1) + (i0 * j1); dot /= sqrt(i0*i0 + j0*j0) * sqrt(i1*i1 + j1*j1); if (dot > CONCAVITY_TOLERANCE) { //we have a concavity! //mprintf((0,"Concavity check dot = %f\n",dot)); return vn; //..so return this vertex number } } //No concavity found return -1; } //Recompute the surface normals for all the faces in a room //Parameters: rp - pointer to the room //Returns: true if normals computed ok, false if some normals were bad bool ResetRoomFaceNormals(room *rp) { int bad_normals = 0; for (int i=0;inum_faces;i++) if (! ComputeFaceNormal(rp,i)) bad_normals++; if (bad_normals > 0) { mprintf((1,"Warning: Room %d has %d bad or low-precision normals\n",ROOMNUM(rp),bad_normals)); return 0; } else return 1; } //Copies the contents of one face to another. Sets the portal num in the new face to -1. //Parameters: dfp - pointer to the destination face. This face should be uninitialized. // sfp - pointer to the source face void CopyFace(face *dfp,face *sfp) { InitRoomFace(dfp,sfp->num_verts); dfp->flags = sfp->flags; dfp->portal_num = -1; dfp->normal = sfp->normal; dfp->tmap = sfp->tmap; dfp->light_multiple = sfp->light_multiple; // Clear the flags that we don't want transferred over dfp->flags &= ~FF_LIGHTMAP; dfp->flags &= ~FF_HAS_TRIGGER; //Copy vertices and uvls for (int i=0;inum_verts;i++) { dfp->face_verts[i] = sfp->face_verts[i]; dfp->face_uvls[i] = sfp->face_uvls[i]; } } //Checks to see if a face is planar. //See if all the points are within a certain distance of an average point //Returns 1 if face is planar, 0 if not bool FaceIsPlanar(int nv,int16_t *face_verts,vector *normal,vector *verts) { //Triangles are always planar if (nv == 3) return 1; //Get average distance from origin for points on this face float average_d=0; for (int v=0;v POINT_TO_PLANE_EPSILON) return 0; } //Didn't find anything wrong, so face is planar return 1; } // Fixes all the concave/nonplanar faces of facelist of room rp void FixConcaveFaces (room *rp,int *facelist,int facecount) { int i,t,k; face *newfaces; for (i=0;inum_faces; int concave_count=rp->faces[facelist[i]].num_verts; int old_tmap=rp->faces[facelist[i]].tmap; int num_new_faces=concave_count-3; ASSERT (num_new_faces>0); mprintf ((0,"Creating %d new faces from face %d!\n",num_new_faces,facelist[i])); // copy the concave vert indices for later use for (t=0;tfaces[facelist[i]].face_verts[t]; // Allocate memory for our new faces int nfaces=rp->num_faces+num_new_faces; newfaces = (face *) mem_malloc(nfaces * sizeof(face)); ASSERT(newfaces != NULL); // Copy all the faces into our new array for (t=0;tnum_faces;t++) { if (t!=facelist[i]) { int nverts=rp->faces[t].num_verts; newfaces[t].face_verts = (int16_t *) mem_malloc(nverts * sizeof(int16_t)); ASSERT(newfaces[t].face_verts != NULL); newfaces[t].face_uvls = (roomUVL *) mem_malloc(nverts * sizeof(roomUVL)); ASSERT(newfaces[t].face_uvls != NULL); newfaces[t].normal=rp->faces[t].normal; newfaces[t].tmap=rp->faces[t].tmap; newfaces[t].flags=rp->faces[t].flags; newfaces[t].portal_num=rp->faces[t].portal_num; newfaces[t].num_verts=rp->faces[t].num_verts; newfaces[t].special_handle=BAD_SPECIAL_FACE_INDEX; for (k=0;kfaces[t].face_verts[k]; newfaces[t].face_uvls[k]=rp->faces[t].face_uvls[k]; } } else // special case the concave face into a triangle { int nverts=3; newfaces[t].face_verts = (int16_t *) mem_malloc(nverts * sizeof(int16_t)); ASSERT(newfaces[t].face_verts != NULL); newfaces[t].face_uvls = (roomUVL *) mem_malloc(nverts * sizeof(roomUVL)); ASSERT(newfaces[t].face_uvls != NULL); newfaces[t].tmap=rp->faces[t].tmap; newfaces[t].flags=rp->faces[t].flags; newfaces[t].portal_num=rp->faces[t].portal_num; newfaces[t].num_verts=3; newfaces[t].special_handle=BAD_SPECIAL_FACE_INDEX; for (k=0;kfaces[t].face_verts[k]; newfaces[t].face_uvls[k]=rp->faces[t].face_uvls[k]; } // Get new normal if (! ComputeFaceNormal(rp,t)) Int3(); //Bad normal: get Matt or Jason, or ignore. newfaces[t].normal=rp->faces[t].normal; } } // Free up the old list of faces mem_free (rp->faces); rp->faces=newfaces; rp->num_faces=nfaces; if(rp->num_bbf_regions) { for(i = 0; i < rp->num_bbf_regions; i++) { mem_free(rp->bbf_list[i]); } mem_free(rp->bbf_list); mem_free(rp->num_bbf); mem_free(rp->bbf_list_min_xyz); mem_free(rp->bbf_list_max_xyz); mem_free(rp->bbf_list_sector); rp->num_bbf_regions = 0; } // Now build the remaining triangles of our concave face for (t=0;tfaces[old_num_faces+t],3); for (t=0;tfaces[old_num_faces+t].face_verts[0]=concave_verts[0]; rp->faces[old_num_faces+t].face_verts[1]=concave_verts[2+t]; rp->faces[old_num_faces+t].face_verts[2]=concave_verts[3+t]; rp->faces[old_num_faces+t].tmap=old_tmap; if (! ComputeFaceNormal(rp,old_num_faces+t)) Int3(); //Bad normal: get Matt or Jason, or ignore. AssignDefaultUVsToRoomFace (rp,old_num_faces+t); } } } if (! ResetRoomFaceNormals(rp)) Int3(); //Get Matt or Jason } //Changes the number of verts in a face. Frees and reallocates the face_verts & face_uvls arrays. //Leaves all other fields the same void ReInitRoomFace(face *fp,int nverts) { ASSERT(nverts != 0); fp->num_verts = nverts; mem_free(fp->face_verts); mem_free(fp->face_uvls); fp->face_verts = (int16_t *) mem_malloc(nverts * sizeof(*fp->face_verts)); ASSERT(fp->face_verts != NULL); fp->face_uvls = (roomUVL *) mem_malloc(nverts * sizeof(*fp->face_uvls)); ASSERT(fp->face_uvls != NULL); } //Determines if two points are close enough together to be considered the same //Parameters: v0,v1 - the two points //Returns: true if the points are the same or very close; else false bool PointsAreSame(vector *v0,vector *v1) { float d = vm_VectorDistance(v0,v1); return (d < POINT_TO_POINT_EPSILON); } //Check to see if a point is in, in front of, or behind a plane //Parameters: checkpoint - the point to check // planepoint,normal - the plane we're checking against //Returns: 0 if on the plane, -1 if behind, 1 if in front int CheckPointToPlane(vector *checkpoint,vector *planepoint,vector *normal) { float d = (*checkpoint - *planepoint) * *normal; if (d < -POINT_TO_PLANE_EPSILON) return -1; else if (d > POINT_TO_PLANE_EPSILON) return 1; else return 0; } //Check to see if all the points on a face are in front of a plane //Parameters: rp,facenum - the face to check // planepoint,normal - define the plane we're checking against //Returns: the number of the first point found on the back of the plane, or -1 of all on front int CheckFaceToPlane(room *rp,int facenum,vector *planepoint,vector *normal) { face *fp = &rp->faces[facenum]; for (int i=0;inum_verts;i++) if (CheckPointToPlane(&rp->verts[fp->face_verts[i]],planepoint,normal) < 0) return i; return -1; //no points found behind the plane } //Create space for additional vertices in a room. //Allocates a new array of vertices, copies from the old list, and frees the old list //The new vertices are at the end of the list, so none of the old vertices change number //Parameters: rp - the room // n_new_verts - how many vertices are being added to the room //Returns: the number of the first new vertex int RoomAddVertices(room *rp,int num_new_verts) { if (num_new_verts == 0) return 0; vector *newverts = (vector *) mem_malloc((rp->num_verts+num_new_verts) * sizeof(*newverts)); ASSERT(newverts != NULL); for (int i=0;inum_verts;i++) { newverts[i] = rp->verts[i]; } mem_free(rp->verts); rp->verts = newverts; rp->num_verts += num_new_verts; return (rp->num_verts - num_new_verts); } //Create space for additional faces in a room. //Allocates a new faces array, copies from the old list, and frees the old list //The new faces are at the end of the list, so none of the old faces change number //Parameters: rp - the room // num_new_faces - how many faces are being added to the room //Returns: the number of the first new face int RoomAddFaces(room *rp,int num_new_faces) { int i; if (num_new_faces == 0) return 0; face *newfaces = (face *) mem_malloc((rp->num_faces + num_new_faces) * sizeof(*newfaces)); ASSERT(newfaces != NULL); for (i=0;inum_faces;i++) newfaces[i] = rp->faces[i]; mem_free(rp->faces); rp->faces = newfaces; rp->num_faces += num_new_faces; if(rp->num_bbf_regions) { for(i = 0; i < rp->num_bbf_regions; i++) { mem_free(rp->bbf_list[i]); } mem_free(rp->bbf_list); mem_free(rp->num_bbf); mem_free(rp->bbf_list_min_xyz); mem_free(rp->bbf_list_max_xyz); mem_free(rp->bbf_list_sector); rp->num_bbf_regions = 0; } return (rp->num_faces - num_new_faces); } //Check if a point is inside, outside, or on an edge of a polygon //Parameters: checkv - the point to be checked // v1,v0 - the edge to check against. Two sequential verts in a clockwise polygon. // normal - the surface normal of the polygon //Returns: 1 if the point in inside the edge // 0 if the point is on the edge // -1 if the point is outside the edge int CheckPointAgainstEdge(vector *checkv,vector *v0,vector *v1,vector *normal) { int ii,jj; float edge_i,edge_j,check_i,check_j; float *vv0,*vv1,*checkvv; float edge_mag,dot; //Get the vertices for projection GetIJ(normal,&ii,&jj); //Get pointers to elements of our vectors vv0 = (float *) v0; vv1 = (float *) v1; checkvv = (float *) checkv; //Get 2d vector for edge edge_i = vv1[ii] - vv0[ii]; edge_j = vv1[jj] - vv0[jj]; edge_mag = sqrt(edge_i * edge_i + edge_j * edge_j); //Get 2d vector for check point check_i = checkvv[ii] - vv0[ii]; check_j = checkvv[jj] - vv0[jj]; //Now do the dot product to see if the check point is on the front dot = ((-edge_j * check_i) + (edge_i * check_j)) / edge_mag; //Check dot value and return appropriate code if (dot > POINT_TO_EDGE_EPSILON) return -1; else if (dot < -POINT_TO_EDGE_EPSILON) return 1; else return 0; } //Clips on edge of a polygon against another edge //Parameters: normal - defines the plane in which these edgs lie // v0,v1 - the edge to be clipped // v2,v3 - is the edge clipped against // newv - filled in with the intersection point void ClipEdge(vector *normal,vertex *v0,vertex *v1,vector *v2,vector *v3,vertex *newv) { float *vv0,*vv1,*vv2,*vv3; float k; int ii,jj; //Get the vertices for projection GetIJ(normal,&ii,&jj); //Get pointers to elements of our vectors vv0 = (float *) &v0->vec; vv1 = (float *) &v1->vec; vv2 = (float *) v2; vv3 = (float *) v3; k = ((vv2[jj] - vv0[jj]) * (vv3[ii] - vv2[ii]) - (vv2[ii] - vv0[ii]) * (vv3[jj] - vv2[jj])) / ((vv1[jj] - vv0[jj]) * (vv3[ii] - vv2[ii]) - (vv1[ii] - vv0[ii]) * (vv3[jj] - vv2[jj])); //Deal w/ precision problems if (k < 0.0) { ASSERT((vm_VectorDistance(&v1->vec,&v0->vec) * -k) < POINT_TO_EDGE_EPSILON); k = 0.0; } if (k > 1.0) { ASSERT((vm_VectorDistance(&v1->vec,&v0->vec) * (k-1.0)) < POINT_TO_EDGE_EPSILON); k = 1.0; } //Check for valid values of k ASSERT((k >= 0) && (k <= 1.0)); newv->vec = v0->vec + (v1->vec - v0->vec) * k; newv->uvl.u = v0->uvl.u + (v1->uvl.u - v0->uvl.u) * k; newv->uvl.v = v0->uvl.v + (v1->uvl.v - v0->uvl.v) * k; newv->uvl.alpha = v0->uvl.alpha + ((v1->uvl.alpha - v0->uvl.alpha) * k); } //Finds a shared edge, if one exists, between two faces in the same room //Parameters: fp0,fp1 - pointers to the two faces // vn0,vn1 - filled in with the vertex numbers of the edge. These vert numbers are // relative to their own faces. The shared edge is verts on // face 0, and on face 1 //Returns: true if a shared edge was found, else false bool FindSharedEdge(face *fp0,face *fp1,int *vn0,int *vn1) { int i,j,a0,b0,a1,b1; //Go through each edge in first face for (i=0;inum_verts;i++) { //Get edge verts - is edge on first face a0 = fp0->face_verts[i]; b0 = fp0->face_verts[(i+1)%fp0->num_verts]; //Check against second face for (j=0;jnum_verts;j++) { //Get edge verts - is edge on second face a1 = fp1->face_verts[j]; b1 = fp1->face_verts[(j+1)%fp1->num_verts]; //@@if ((a0==a1) && (b0==b1)) //@@ Int3(); //If you hit this, you probably have a duplicate or overlapping face if ((a0==b1) && (b0==a1)) { //found match! *vn0 = i; *vn1 = j; return 1; } } } //Didn't find an edge, so return error return 0; } //Finds a shared edge, if one exists, between two faces in different rooms //Parameters: rp0,rp1 - pointers to the two rooms // face0,face1 - the face numbers in rp0 & rp1, respectively // vn0,vn1 - filled in with the vertex numbers of the edge. These vert numbers are // relative to their own faces. The shared edge is verts on // face 0, and on face 1 //Returns: true if a shared edge was found, else false bool FindSharedEdgeAcrossRooms(room *rp0,int face0,room *rp1,int face1,int *vn0,int *vn1) { int i,j; vector *va0,*vb0,*va1,*vb1; face *fp0,*fp1; //Get pointers to the two faces fp0 = &rp0->faces[face0]; fp1 = &rp1->faces[face1]; //Go through each edge in first face for (i=0;inum_verts;i++) { //Get edge verts - is edge on first face va0 = &rp0->verts[fp0->face_verts[i]]; vb0 = &rp0->verts[fp0->face_verts[(i+1)%fp0->num_verts]]; //Check against second face for (j=0;jnum_verts;j++) { //Get edge verts - is edge on second face va1 = &rp1->verts[fp1->face_verts[j]]; vb1 = &rp1->verts[fp1->face_verts[(j+1)%fp1->num_verts]]; if (PointsAreSame(va0,va1) && PointsAreSame(vb0,vb1)) //this shouldn't happen Int3(); if (PointsAreSame(va0,vb1) && PointsAreSame(vb0,va1)) { //found match! *vn0 = i; *vn1 = j; return 1; } } } //Didn't find an edge, so return error return 0; } //Delete a vertex from a room. Assumes the vertex is unused. //Parameters: rp - pointer to room // vertnum - the vertex to delete void DeleteRoomVert(room *rp,int vertnum) { int f,v; face *fp; vector *newverts; //Remap vertices in faces for (f=0,fp=rp->faces;fnum_faces;f++,fp++) for (v=0;vnum_verts;v++) if (fp->face_verts[v] == vertnum) Int3(); //THIS IS VERY BAD! DELETING A VERTEX STILL IN USE! else if (fp->face_verts[v] > vertnum) fp->face_verts[v]--; //malloc new list newverts = (vector *) mem_malloc(sizeof(*newverts) * (rp->num_verts - 1)); ASSERT(newverts != NULL); //Copy verts to new list for (v=0;vverts[v]; } for (;vnum_verts-1;v++) { newverts[v] = rp->verts[v+1]; } //Delete old list mem_free(rp->verts); //Use new list rp->verts = newverts; //Update count rp->num_verts--; } //Check the vertices in a room & remove unused ones //Parameters: rp - the room to check //Returns: the number of vertices removed int DeleteUnusedRoomVerts(room *rp) { bool vert_used[MAX_VERTS_PER_ROOM]; int f,v; face *fp; int n_deleted=0;; //Init all the flags to unused for (v=0;vnum_verts;v++) vert_used[v] = 0; //Go through all the faces & flag the used verts for (f=0,fp=rp->faces;fnum_faces;f++,fp++) for (v=0;vnum_verts;v++) vert_used[fp->face_verts[v]] = 1; //Now delete the unused verts for (v=rp->num_verts-1;v>=0;v--) if (! vert_used[v]) { DeleteRoomVert(rp,v); n_deleted++; } //Done return n_deleted; } //Delete a face from a room //Parameters: rp - the room the face is in // facenum - the face to be deleted void DeleteRoomFace(room *rp,int facenum,bool delete_unused_verts) { int p,f,i,t; face *newfaces; //Check for trigger on this face if (rp->faces[facenum].flags & FF_HAS_TRIGGER) DeleteTrigger(ROOMNUM(rp),facenum); //Adjust face numbers in portals for (p=0;pnum_portals;p++) { portal *pp = &rp->portals[p]; ASSERT(pp->portal_face != facenum); if (pp->portal_face > facenum) pp->portal_face--; } //Adjust face numbers in triggers for (t=0;troomnum == ROOMNUM(rp)) { ASSERT(tp->facenum != facenum); if (tp->facenum > facenum) tp->facenum--; } } //Allocate new face list newfaces = (face *) mem_malloc(sizeof(*newfaces) * (rp->num_faces-1)); ASSERT(newfaces != NULL); //Copy faces over for (f=0;ffaces[f]; for (f++;fnum_faces;f++) newfaces[f-1] = rp->faces[f]; #ifdef NEWEDITOR // Decrement texture usage if ( ROOMNUM(rp) < MAX_ROOMS ) { LevelTexDecrementTexture(rp->faces[facenum].tmap); //@@RoomTexDecrementTexture(rp->faces[facenum].tmap,m_Textures_in_use,false); } else { // TODO: for room tab, replace second line with first ned_MarkTextureInUse(rp->faces[facenum].tmap,false); //@@RoomTexDecrementTexture(rp->faces[facenum].tmap,m_Textures_in_use); } #endif //Free deleted face memeory FreeRoomFace(&rp->faces[facenum]); //Free old face list mem_free(rp->faces); //Use new face list rp->faces = newfaces; rp->num_faces--; // Adjust the current and marked faces if necessary #ifdef NEWEDITOR if (theApp.m_pLevelWnd != NULL) #endif if (rp == Curroomp) { if (Curface == rp->num_faces) Curface = rp->num_faces-1; else if (Curface > rp->num_faces) Int3(); // this shouldn't be if (Markedface == rp->num_faces) Markedface = rp->num_faces-1; else if (Markedface > rp->num_faces) Int3(); // this shouldn't be } if(rp->num_bbf_regions) { for(i = 0; i < rp->num_bbf_regions; i++) { mem_free(rp->bbf_list[i]); } mem_free(rp->bbf_list); mem_free(rp->num_bbf); mem_free(rp->bbf_list_min_xyz); mem_free(rp->bbf_list_max_xyz); mem_free(rp->bbf_list_sector); rp->num_bbf_regions = 0; } //Get rid of any now-unused verts if (delete_unused_verts) DeleteUnusedRoomVerts(rp); } //Deletes a portal from a room. Does not delete this portal this connects to //Parameters: rp - the room the portal is in // portalnum - the portal to be deleted void DeleteRoomPortal(room *rp,int portalnum) { portal *pp = &rp->portals[portalnum]; face *fp = &rp->faces[pp->portal_face]; portal *newportals; //Clear the portal field of the portal's face ASSERT(fp->portal_num == portalnum); fp->portal_num = -1; //Renumber all portals that come after this one for (int p=portalnum+1;pnum_portals;p++) { portal *tp = &rp->portals[p]; //Renumber the face in this portal ASSERT(rp->faces[tp->portal_face].portal_num == p); rp->faces[tp->portal_face].portal_num--; //Renumber the link back to this portal if (tp->croom != -1) Rooms[tp->croom].portals[tp->cportal].cportal--; } //Alloc new portal list if (rp->num_portals == 1) newportals = NULL; else { newportals = (portal *) mem_malloc(sizeof(*newportals) * (rp->num_portals-1)); ASSERT(newportals != NULL); } //Copy portals over for (p=0;pportals[p]; for (p++;pnum_portals;p++) newportals[p-1] = rp->portals[p]; //Free old portal list mem_free(rp->portals); //Use the new list rp->portals = newportals; rp->num_portals--; } #if 0 //Remove holes in the room list void CompressRooms(void) { int hole,t,high_room; t = Highest_room_index; high_room=Highest_room_index; for (hole=0; hole < t; hole++) if (! Rooms[hole].used) { // found an unused t which is a hole if a used t follows (not necessarily immediately) it. while (! Rooms[t].used) t--; if (t > hole) { room *rp; int objnum; // Ok, hole is the index of a hole, t is the index of a t which follows it. // Copy t into hole, update pointers to it, update Curroomp, Markedroomp if necessary. Rooms[hole] = Rooms[t]; Rooms[t].used = 0; if (Curroomp == &Rooms[t]) Curroomp = &Rooms[hole]; if (Markedroomp == &Rooms[t]) Markedroomp = &Rooms[hole]; //Fix connections rp = &Rooms[hole]; for (int p=0;pnum_portals;p++) { portal *pp = &rp->portals[p]; if (pp->croom == -1) { //a terrain connection for (int l=0;lcroom].portals[pp->cportal].croom == t); Rooms[pp->croom].portals[pp->cportal].croom = hole; } } //Update object room pointers for (objnum = rp->objects; objnum != -1; objnum = Objects[objnum].next) { ASSERT(Objects[objnum].roomnum == t); Objects[objnum].roomnum = hole; } //Fix triggers for (p=0;p hole) } // end if while (! Rooms[Highest_room_index].used) Highest_room_index--; } // Compress mine by getting rid of holes the the room array void CompressMine() { //if (Do_duplicate_vertex_check) { // med_combine_duplicate_vertices(Vertex_active); // Do_duplicate_vertex_check = 0; //} CompressRooms(); } #endif //Copies the contents of one face to another. //Parameters: dfp - pointer to the destination face. This face should be uninitialized. // sfp - pointer to the source face void CopyPortal(face *dfp,face *sfp) { InitRoomFace(dfp,sfp->num_verts); dfp->flags = sfp->flags; dfp->portal_num = sfp->portal_num; dfp->normal = sfp->normal; dfp->tmap = sfp->tmap; for (int i=0;inum_verts;i++) { dfp->face_verts[i] = sfp->face_verts[i]; dfp->face_uvls[i] = sfp->face_uvls[i]; } } //Copies the data from one room into another //Note: Portals are not copied, and the new room will have zero portals //Parameters: destp - the destination room of the copy // srcp - the source room for the copy void CopyRoom(room *destp,room *srcp) { //Initialize the new room InitRoom(destp,srcp->num_verts,srcp->num_faces,0); //Copy over the faces for (int i=0;inum_faces;i++) { CopyFace(&destp->faces[i],&srcp->faces[i]); #ifdef NEWEDITOR LevelTexIncrementTexture(srcp->faces[i].tmap); #endif } //Copy over the verts for (i=0;inum_verts;i++) destp->verts[i] = srcp->verts[i]; //Copy doorway info if (srcp->doorway_data) { destp->doorway_data = (doorway *) mem_malloc(sizeof(*destp->doorway_data)); *destp->doorway_data = *srcp->doorway_data; } //Copy over the rest of the data destp->flags = srcp->flags; // Copy over room lighting Room_multiplier[destp-Rooms]=Room_multiplier[srcp-Rooms]; Room_ambience_r[destp-Rooms]=Room_ambience_r[srcp-Rooms]; Room_ambience_g[destp-Rooms]=Room_ambience_g[srcp-Rooms]; Room_ambience_b[destp-Rooms]=Room_ambience_b[srcp-Rooms]; } //Adds a new portal for this room. Returns the portal number. //Initializes the flags int AddPortal(room *rp) { portal *newlist; int i; newlist = (portal *) mem_malloc(sizeof(*newlist) * (rp->num_portals+1)); //Copy from old list to new list, and free old list if (rp->num_portals) { for (i=0;inum_portals;i++) newlist[i] = rp->portals[i]; mem_free(rp->portals); } //Point at new list rp->portals = newlist; //Init flags rp->portals[rp->num_portals].flags = 0; rp->portals[rp->num_portals].bnode_index = -1; return rp->num_portals++; } //Links two rooms, creating portals in each room //Parameters: roomlist - pointer to the array of rooms // room0,face0 - the room & face numbers of the first room // room1,face1 - the room & face numbers of the second room void LinkRooms(room *roomlist,int room0,int face0,int room1,int face1) { room *rp0,*rp1; int pn0,pn1; int nv0,nv1; //Set some vars rp0 = &roomlist[room0]; rp1 = &roomlist[room1]; nv0 = rp0->faces[face0].num_verts; nv1 = rp1->faces[face1].num_verts; //Make sure no portals already ASSERT(rp0->faces[face0].portal_num == -1); ASSERT(rp1->faces[face1].portal_num == -1); //Check for match if (nv0 != nv1) Int3(); //You must get Matt if you hit this! //Create portals pn0 = AddPortal(rp0); pn1 = AddPortal(rp1); //Link portals rp0->portals[pn0].croom = room1; rp0->portals[pn0].cportal = pn1; rp1->portals[pn1].croom = room0; rp1->portals[pn1].cportal = pn0; //Add faces to portals rp0->portals[pn0].portal_face = face0; rp1->portals[pn1].portal_face = face1; //Mark faces as being part of portals rp0->faces[face0].portal_num = pn0; rp1->faces[face1].portal_num = pn1; } //Finds the min and max x,y,z values of the vertices in a room //Parameters: min,max - filled in with the minimum and maximum x,y, & z values, respectively // rp = the room void ComputeRoomMinMax(vector *min,vector *max,room *rp) { min->x = min->y = min->z = FLT_MAX; max->x = max->y = max->z = -FLT_MAX; for (int i=0;inum_verts;i++) { if (rp->verts[i].x > max->x) max->x = rp->verts[i].x; if (rp->verts[i].y > max->y) max->y = rp->verts[i].y; if (rp->verts[i].z > max->z) max->z = rp->verts[i].z; if (rp->verts[i].x < min->x) min->x = rp->verts[i].x; if (rp->verts[i].y < min->y) min->y = rp->verts[i].y; if (rp->verts[i].z < min->z) min->z = rp->verts[i].z; } } //Builds a list of all the vertices in a room that are part of a portal //Parameters: rp - the room to check // list - filled in with the list of vert numbers. List should be MAX_VERTS_PER_ROOM big //Returns: the number of verts in the list int BuildListOfPortalVerts (room *rp,int *list) { int i,t,j; int count=0; for (i=0;inum_portals;i++) { face *fp = &rp->faces[rp->portals[i].portal_face]; for (t=0;tnum_verts;t++) { int v = fp->face_verts[t]; for (j=0;j= BUF_LEN) OutrageMessageBox("There has been a text buffer overflow in CheckError()."); } //Checks the normals in a room //Returns the number of bad normals int CheckNormals(room *rp) { int errors = 0; for (int f=0;fnum_faces;f++) if (! ComputeFaceNormal(rp,f)) { CheckError("Room %3d face %3d has a bad or low-precision normal\n",ROOMNUM(rp),f); errors++; } return errors; } //Checks for concave faces //Returns the number of concave faces int CheckConcaveFaces(room *rp) { int f; face *fp; int errors = 0; //Go through all the faces for (f=0,fp=rp->faces;fnum_faces;f++,fp++) { int vert = CheckFaceConcavity(fp->num_verts,fp->face_verts,&fp->normal,rp->verts); if (vert != -1) { CheckError("Room %3d face %3d is concave at vertex %d\n",ROOMNUM(rp),f,vert); errors++; } } return errors; } int CheckDegenerateFaces(room *rp) { int errors = 0; int f,v; face *fp; //Go through all the faces for (f=0,fp=rp->faces;fnum_faces;f++,fp++) { for (v=0;vnum_verts;v++) if (fp->face_verts[v] == fp->face_verts[(v+2)%fp->num_verts]) { CheckError("Room %3d face %3d is degenerate\n",ROOMNUM(rp),f); errors++; break; } } return errors; } //Make sure the two faces of a portal match //Returns true if the portal is ok bool CheckPortal(room *rp0,int p0) { int i,j,p1; room *rp1; portal *pp0,*pp1; face *fp0,*fp1; //Get info pp0 = &rp0->portals[p0]; rp1 = &Rooms[pp0->croom]; p1 = pp0->cportal; pp1 = &rp1->portals[p1]; fp0 = &rp0->faces[pp0->portal_face]; fp1 = &rp1->faces[pp1->portal_face]; //Make sure faces have the same number of verts if (fp0->num_verts != fp1->num_verts) { CheckError("Room %d portal %d has a different number of vertices (%d) than room %d portal %d (%d)\n",ROOMNUM(rp0),p0,fp0->num_verts,ROOMNUM(rp1),p1,fp1->num_verts); return 0; } //Find one point in common for (i=0;inum_verts;i++) { for (j=0;jnum_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) { CheckError("Cannot find a single matching point between room %d portal %d and room %d portal %d\n",ROOMNUM(rp0),p0,ROOMNUM(rp1),p1); return 0; } vector *v0,*v1,*prev0,*prev1; int n; //Trace through verts in faces, making sure they match prev0 = &rp0->verts[fp0->face_verts[i]]; prev1 = &rp1->verts[fp1->face_verts[j]]; for (n=1;nnum_verts;n++) { 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)) { CheckError("Vertex %d in room %d portal %d does not match vertex %d in room %d portal %d\n",(i+n) % fp0->num_verts,ROOMNUM(rp0),p0,(j-n+fp1->num_verts) % fp1->num_verts,ROOMNUM(rp1),p1); return 0; } } return 1; } extern void DumpTextToClipboard(char *text); //Checks for bad portal connections //Returns the number of bad portals int CheckPortals(room *rp) { portal *pp; int p; int r=ROOMNUM(rp); int errors=0; for (p=0,pp=rp->portals;pnum_portals;pp++,p++) { //Make sure the connecting portal points back to this portal if ((Rooms[pp->croom].portals[pp->cportal].croom != r) || (Rooms[pp->croom].portals[pp->cportal].cportal != p)) { CheckError("Room %d, portal %d points at room %d portal %d, but the latter points at room %d portal %d\n",r,p,pp->croom,pp->cportal,Rooms[pp->croom].portals[pp->cportal].croom,Rooms[pp->croom].portals[pp->cportal].cportal); errors++; } //Check to make sure the face in this portal points back to it if (rp->faces[pp->portal_face].portal_num != p) { CheckError("Room %d portal %d contains face %d, but that face points at portal %d\n",r,p,pp->portal_face,rp->faces[pp->portal_face].portal_num); errors++; } } return errors; } //Checks if the given face is a duplicate of another face //Returns the face number of which this is a duplicate, or -1 if not a duplicate int CheckForDuplicateFace(room *rp,int facenum) { face *fp0 = &rp->faces[facenum]; int r = ROOMNUM(rp); for (int j=0;jfaces[j]; if (fp0->num_verts == fp1->num_verts) for (int v=0;vnum_verts;v++) //look for a shared vert if (fp1->face_verts[v] == fp0->face_verts[0]) { for (int t=0;tnum_verts;t++) if (fp0->face_verts[t] != fp1->face_verts[(v+t) % fp1->num_verts]) break; if (t == fp0->num_verts) { return j; } break; } } //Didn't find a duplicate return -1; } //Removes all the duplicate faces in a room void RemoveDuplicateFaces(room *rp) { int r = ROOMNUM(rp); int removed = 0; for (int i=0;inum_faces;i++) { int dup = CheckForDuplicateFace(rp,i); if (dup != -1) { DeleteRoomFace(rp,i); mprintf((0,"Removed face %d (duplicate of face %d) from room %d\n",i,dup,r)); removed++; i--; } } if (removed) { OutrageMessageBox("%d duplicate faces have been removed from room %d.",removed,r); World_changed = 1; } else OutrageMessageBox("There are no duplicate faces in room %d.",r); } //Checks for duplicate faces //Returns the number of duplicate faces int CheckDuplicateFaces(room *rp) { int r = ROOMNUM(rp); int errors = 0; for (int i=0;inum_faces;i++) { int dup = CheckForDuplicateFace(rp,i); if (dup != -1) { CheckError("Room %d: face %d is the same as face %d\n",r,i,dup); errors++; } } return errors; } //Checks for non-planar faces //Returns the number of non-planar faces int CheckNonPlanarFaces(room *rp) { int r = ROOMNUM(rp); int errors = 0; for (int f=0;fnum_faces;f++) if (! FaceIsPlanar(rp,f)) { if (rp->faces[f].portal_num != -1) CheckError("Room %d: face %d is not planar. FACE IS PORTAL!\n",r,f); else CheckError("Room %d: face %d is not planar\n",r,f); errors++; } return errors; } //Checks for duplicate points //Returns the number of duplicate points int CheckDuplicatePoints(room *rp) { int r = ROOMNUM(rp); int errors = 0; for (int i=0;inum_verts;i++) for (int j=0;jverts[i],&rp->verts[j])) { float d = vm_VectorDistance(&rp->verts[i],&rp->verts[j]); CheckError("Room %d: vert %3d is the same as vert %3d (d=%.2f)\n",r,i,j,d); errors++; } return errors; } //Find any unused points in a room int CheckUnusedPoints(room *rp) { int r = ROOMNUM(rp); int errors = 0; bool vert_used[MAX_VERTS_PER_ROOM]; int f,v; face *fp; //Init all the flags to unused for (v=0;vnum_verts;v++) vert_used[v] = 0; //Go through all the faces & flag the used verts for (f=0,fp=rp->faces;fnum_faces;f++,fp++) for (v=0;vnum_verts;v++) vert_used[fp->face_verts[v]] = 1; //Now delete the unused verts for (v=0;vnum_verts;v++) if (! vert_used[v]) { CheckError("Room %d: point %d is unused\n",r,v); errors++; } //Done return errors; } //Checks for duplicate points in faces //Returns the number of duplicate face points int CheckDuplicateFacePoints(room *rp) { int r = ROOMNUM(rp); int f,v,errors = 0; face *fp; for (f=0,fp=rp->faces;fnum_faces;f++,fp++) for (v=0;vnum_verts;v++) if (fp->face_verts[v] == fp->face_verts[(v+1)%fp->num_verts]) { CheckError("Room %d, face %d: vert #%d (%d) is the same as #%d\n",r,f,(v+1)%fp->num_verts,fp->face_verts[v],v); errors++; } return errors; } //Returns true if faces match exactly, else false int CheckPortalFaces(room *rp0,int facenum0,room *rp1,int facenum1) { face *fp0 = &rp0->faces[facenum0]; face *fp1 = &rp1->faces[facenum1]; vector *v0,*v1,*prev_v0,*prev_v1; int n,i,j,prev_vn0,prev_vn1; int points_added=0; //First, find one point in common for (i=0;inum_verts;i++) { for (j=0;jnum_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) return 0; prev_vn0 = fp0->face_verts[i]; prev_vn1 = fp1->face_verts[j]; prev_v0 = &rp0->verts[prev_vn0]; prev_v1 = &rp1->verts[prev_vn1]; if (fp0->num_verts != fp1->num_verts) { CheckError("Room %d: portal face %d does not match %d:%d\n",ROOMNUM(rp0),facenum0,ROOMNUM(rp1),facenum1); return 0; } //Trace through faces, adding points where needed for (n=1;nnum_verts;n++) { int vn0,vn1; vn0 = fp0->face_verts[(i+n) % fp0->num_verts]; vn1 = fp1->face_verts[(j-n+fp1->num_verts) % fp1->num_verts]; v0 = &rp0->verts[vn0]; v1 = &rp1->verts[vn1]; if (! PointsAreSame(v0,v1)) { //Points are at least very close. CheckError("Room %d: portal face %d does not match %d:%d\n",ROOMNUM(rp0),facenum0,ROOMNUM(rp1),facenum1); return 0; } prev_vn0 = vn0; prev_vn1 = vn1; prev_v0 = v0; prev_v1 = v1; } return 1; //no errors found, so faces ok } int CheckRoomPortalFaces(room *rp) { int errors = 0; for (int p=0;pnum_portals;p++) { portal *pp = &rp->portals[p]; if (! CheckPortalFaces(rp,pp->portal_face,&Rooms[pp->croom],Rooms[pp->croom].portals[pp->cportal].portal_face)) errors++; } return errors; } //Find t-joints in this room int FindTJoints(room *rp) { int f,f2,v,v2; face *fp,*fp2; int tjoints=0; int points_added=0; //Now search for and fix t-joints for (f=0,fp=rp->faces;fnum_faces;f++,fp++) { for (v=0;vnum_verts;v++) { int vv0 = fp->face_verts[v], vv1 = fp->face_verts[(v+1)%fp->num_verts]; for (f2=0,fp2=rp->faces;f2num_faces;f2++,fp2++) { if (f2 != f) { for (v2=0;v2num_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 //Look for vert on this edge for (f2=0,fp2=rp->faces;f2num_faces;f2++,fp2++) { if (f2 != f) { for (v2=0;v2num_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 (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)) { CheckError("Room %d: face %d edge %d has a T-joint\n",ROOMNUM(rp),f,v); tjoints++; goto next_face; } } } } } } } } } next_face:; } return tjoints; } // Counts the number of unique textures in a level, plus gives names of textures used void CountUniqueTextures () { uint16_t *texture_tracking=(uint16_t *)mem_malloc (MAX_TEXTURES*2); ASSERT (texture_tracking); memset (texture_tracking,0,MAX_TEXTURES*2); for (int i=0;i<=Highest_room_index;i++) { room *rp=&Rooms[i]; if (rp->used==0) continue; for (int t=0;tnum_faces;t++) { face *fp=&rp->faces[t]; if (fp->portal_num!=-1) { if (!(rp->portals[fp->portal_num].flags & PF_RENDER_FACES)) continue; } if (fp->tmap!=-1 && !(GameTextures[fp->tmap].flags & (TF_PROCEDURAL|TF_TEXTURE_64|TF_TEXTURE_32))) { texture_tracking[fp->tmap]++; } } } // Now count totals int total=0,total_with_lights=0; for (i=0;i60) CheckError ("ERROR: YOU HAVE MORE THAT 60 128x128 TEXTURES...YOU *MUST* FIX THIS!\n"); for (i=0;itype == OBJ_SOUNDSOURCE) { ASSERT(objp->control_type == CT_SOUNDSOURCE); total++; if (objp->name) named++; if (objp->ctype.soundsource_info.sound_index == -1) { CheckError("Soundsource object %d (\"%s\") has no sound specified.\n",objnum,objp->name?objp->name:""); quiet++; if (! objp->name) quiet_unnamed++; } } } CheckError("This level has %d soundsource objects; %d have names, %d don't have sounds, and %d have no sounds & no name.\n",total,named,quiet,quiet_unnamed); return quiet; } int BOAGetMineChecksum (); //Get rid of large whole parts of face UV coordinates void NormalizeFaceUVs() { int r; room *rp; for (r=0,rp=Rooms;r <= Highest_room_index;r++,rp++) { if (rp->used) { int f; face *fp; for (f=0,fp=rp->faces;fnum_faces;f++,fp++) { float base_u = floor(fp->face_uvls[0].u); float base_v = floor(fp->face_uvls[0].v); for (int v=0;vnum_verts;v++) { fp->face_uvls[v].u -= base_u; fp->face_uvls[v].v -= base_v; } } } } } //Test the mine for validity void VerifyMine() { int r; room *rp; int errors=0,bad_normals=0,concave_faces=0,degenerate_faces=0,bad_portals=0,duplicate_faces=0,duplicate_points=0,duplicate_face_points=0, unused_points=0,nonplanar_faces=0,mismatched_portals=0,tjoints=0,bad_shells=0,quiet_soundsource_objects=0; error_buf_offset = 0; //Normalize all the UV coordinates in the level NormalizeFaceUVs(); //Check normals, portals, & duplicate faces for (r=0,rp=Rooms;r<=Highest_room_index;r++,rp++) if (rp->used) { bad_normals += CheckNormals(rp); errors += bad_normals; concave_faces += CheckConcaveFaces(rp); errors += concave_faces; degenerate_faces += CheckDegenerateFaces(rp); errors += degenerate_faces; bad_portals += CheckPortals(rp); errors += bad_portals; duplicate_faces += CheckDuplicateFaces(rp); errors += duplicate_faces; nonplanar_faces += CheckNonPlanarFaces(rp); errors += nonplanar_faces; duplicate_points += CheckDuplicatePoints(rp); errors += duplicate_points; duplicate_face_points += CheckDuplicateFacePoints(rp); errors += duplicate_face_points; unused_points += CheckUnusedPoints(rp); errors += unused_points; mismatched_portals += CheckRoomPortalFaces(rp); errors += mismatched_portals; tjoints += FindTJoints(rp); errors += tjoints; if ((rp->num_portals > 0) && !(rp->flags & RF_EXTERNAL)) { int shell_errors = ComputeRoomShell(rp); if (shell_errors) { bad_shells++; errors++; } } } quiet_soundsource_objects = CheckSoundsourceObjects(); errors += quiet_soundsource_objects; CountUniqueTextures (); bool terrain_occluded=false; bool boa_ran=false; bool terrain_volume=false; if (Terrain_occlusion_checksum==(Terrain_checksum+1)) terrain_occluded=true; else errors=1; if (BOAGetMineChecksum()==BOA_vis_checksum) boa_ran=true; else errors=true; // Check to see if dynamic terrain lighting is calculated for (int i=0;iflags = 0; //@@if (sfp->flags & FF_FORCEFIELD) //@@ dfp->flags |= FF_FORCEFIELD; if (sfp->flags & FF_GOALFACE) dfp->flags |= FF_GOALFACE; } //Inserts a vertex into a face //Parameters: rp - the room for this face // facenum - the face to which to add the vertex // new_v - the number of the vertex to add // after_v - the new vert is added *after* this vert (index into face verts) void AddVertToFace(room *rp,int facenum,int new_v,int after_v) { 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;tnum_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<=after_v;t++) { fp->face_verts[t] = old_verts[t]; fp->face_uvls[t] = old_uvls[t]; } //Insert new vert fp->face_verts[t++] = new_v; //Copy rest of new verts for (;tnum_verts;t++) { fp->face_verts[t] = old_verts[t-1]; fp->face_uvls[t] = old_uvls[t-1]; } //Compute the uv values for the new vert vector *v0 = &rp->verts[fp->face_verts[after_v]], *v1 = &rp->verts[fp->face_verts[(after_v+2)%fp->num_verts]], *vn = &rp->verts[fp->face_verts[after_v+1]]; roomUVL *uv0 = &fp->face_uvls[after_v], *uv1 = &fp->face_uvls[(after_v+2)%fp->num_verts]; float k = vm_VectorDistance(vn,v0) / vm_VectorDistance(v1,v0); fp->face_uvls[after_v+1].u = uv0->u + k * (uv1->u - uv0->u); fp->face_uvls[after_v+1].v = uv0->v + k * (uv1->v - uv0->v); fp->face_uvls[after_v+1].u2 = uv0->u2 + k * (uv1->u2 - uv0->u2); fp->face_uvls[after_v+1].v2 = uv0->v2 + k * (uv1->v2 - uv0->v2); fp->face_uvls[after_v+1].alpha = uv0->alpha + k * (uv1->alpha - uv0->alpha); } //Removes the duplicate points in a room //Returns the number removed int RemoveDuplicatePoints(room *rp) { face *fp; int f,v; int n_fixed = 0; for (int i=0;inum_verts;i++) for (int j=0;jverts[i],&rp->verts[j])) { //Replace the higher-numbered point with the lower-numbered in all the faces in this room for (f=0,fp=rp->faces;fnum_faces;f++,fp++) for (v=0;vnum_verts;v++) if (fp->face_verts[v] == i) fp->face_verts[v] = j; //Delete the now-unused vert DeleteRoomVert(rp,i); n_fixed++; i--; //back up, since the point we're checking is now gone break; //don't keep checking for duplicates } return n_fixed; } //Remove duplicate points in faces //Returns the number of duplicate face points removed int RemoveDuplicateFacePoints(room *rp) { int r = ROOMNUM(rp); int f,v,n_fixed=0; face *fp; for (f=0,fp=rp->faces;fnum_faces;f++,fp++) for (v=0;vnum_verts;v++) if (fp->face_verts[v] == fp->face_verts[(v+1)%fp->num_verts]) { int new_verts[MAX_VERTS_PER_FACE]; roomUVL new_uvls[MAX_VERTS_PER_FACE]; for (int t=0;tface_verts[t]; new_uvls[t] = fp->face_uvls[t]; } for (;tnum_verts-1;t++) { new_verts[t] = fp->face_verts[t+1]; new_uvls[t] = fp->face_uvls[t+1]; } ReInitRoomFace(fp,fp->num_verts-1); for (t=0;tnum_verts;t++) { fp->face_verts[t] = new_verts[t]; fp->face_uvls[t] = new_uvls[t]; } n_fixed++; f--; fp--; //recheck this face break; } return n_fixed; } //Removes all the duplicate points in a level void RemoveAllDuplicateAndUnusedPoints() { int r; room *rp; int n_unused=0,n_duplicate=0,n_duplicate_face=0; for (r=0,rp=Rooms;r<=Highest_room_index;r++,rp++) if (rp->used) { n_unused += DeleteUnusedRoomVerts(rp); n_duplicate += RemoveDuplicatePoints(rp); n_duplicate_face += RemoveDuplicateFacePoints(rp); } OutrageMessageBox( " %d Unused points deleted\n" " %d Duplicate points deleted\n" " %d Duplicate face points deleted\n", n_unused,n_duplicate,n_duplicate_face ); if (n_unused || n_duplicate || n_duplicate_face) World_changed = 1; } //Returns the number fixed void FixDegenerateFaces() { int fixed=0,deleted=0; int r,f,v; face *fp; room *rp; for (r=0,rp=Rooms;r<=Highest_room_index;r++,rp++) { if (rp->used) { for (f=0,fp=rp->faces;fnum_faces;f++,fp++) { bool face_fixed = 0; recheck_face:; if (fp->num_verts < 3) { DeleteRoomFace(rp,f); deleted++; face_fixed = 0; //deleted overrides fixed f--; fp = &rp->faces[f]; } else { for (v=0;vnum_verts;v++) { if (fp->face_verts[v] == fp->face_verts[(v+2)%fp->num_verts]) { int16_t tverts[MAX_VERTS_PER_FACE]; roomUVL tuvls[MAX_VERTS_PER_FACE]; for (int i=0;inum_verts-2;i++) { tverts[i] = fp->face_verts[(v+2+i)%fp->num_verts]; tuvls[i] = fp->face_uvls[(v+2+i)%fp->num_verts]; } for (i=0;inum_verts-2;i++) { fp->face_verts[i] = tverts[i]; fp->face_uvls[i] = tuvls[i]; } fp->num_verts -= 2; face_fixed = 1; goto recheck_face; } } } if (face_fixed) fixed++; } } } OutrageMessageBox("%d Degenerate faces fixed\n%d Degenerate faces deleted",fixed,deleted); if (fixed || deleted) World_changed = 1; } //Finda a face that connects to the specified face //Starts looking at startface //Returns the attached facenum, or -1 if found none int FindConnectedFace(room *rp,int facenum,int edgenum,int startface) { face *fp0 = &rp->faces[facenum],*fp1; int a0,b0,a1,b1; int f; //Get edge verts - is edge on first face a0 = fp0->face_verts[edgenum]; b0 = fp0->face_verts[(edgenum+1)%fp0->num_verts]; for (f=startface,fp1=&rp->faces[startface];fnum_faces;f++,fp1++) { if (f == facenum) continue; for (int e=0;enum_verts;e++) { //Get edge verts - is edge on second face a1 = fp1->face_verts[e]; b1 = fp1->face_verts[(e+1)%fp1->num_verts]; //@@if ((a0==a1) && (b0==b1)) //@@ Int3(); //If you hit this, you probably have a duplicate or overlapping face if ((a0==b1) && (b0==a1)) { //found match! return f; } } } return -1; //no match } //Shell flags #define SHELL_NONE 0 #define SHELL_UNCHECKED 1 #define SHELL_CLOSED 2 #define SHELL_ERROR 3 //Finds the shell for the specified room. If the shell is found with no errors, sets //the non-shell flag for those faces not in the shell. If there are errors finding the //shell, all faces have the non-shell flag cleared. //Assumes all portals are part of the shell and starts checking from those faces //Returns the number of shell errors (unconnected edges) in the room. //Writes errors to the error buffer int ComputeRoomShell(room *rp) { uint8_t shell_flags[MAX_FACES_PER_ROOM]; bool done=0; int errors=0; int f; for (f=0;fnum_faces;f++) shell_flags[f] = SHELL_NONE; //Start with the portal faces ASSERT(rp->num_portals > 0); for (int p=0;pnum_portals;p++) shell_flags[rp->portals[p].portal_face] = SHELL_UNCHECKED; //Check all the unchecked faces while (! done) { for (f=0;fnum_faces;f++) { if (shell_flags[f] == SHELL_UNCHECKED) { face *fp = &rp->faces[f]; for (int e=0;enum_verts;e++) { int t = FindConnectedFace(rp,f,e,0); if (t != -1) { int t2; //See if any additional faces t2 = FindConnectedFace(rp,f,e,t+1); if (t2 != -1) { //mprintf((0,"Room %d face %d: Found second connection for edge %d (face %d)\n",ROOMNUM(rp),f,e,t)); //CheckError("Room %d face %d: Found second connection for edge %d (face %d)\n",ROOMNUM(rp),f,e,t); } else { //No double-edge, so add connected face if (shell_flags[t] == SHELL_NONE) shell_flags[t] = SHELL_UNCHECKED; } } else { //mprintf((0,"Room %d face %d: No connection for edge %d\n",ROOMNUM(rp),f,e)); CheckError("Room %d face %d: No connection for edge %d\n",ROOMNUM(rp),f,e); shell_flags[f] = SHELL_ERROR; errors++; } } if (shell_flags[f] == SHELL_UNCHECKED) shell_flags[f] = SHELL_CLOSED; break; } } done = (f == rp->num_faces); } //Clear flags for (f=0;fnum_faces;f++) { ASSERT(shell_flags[f] != SHELL_UNCHECKED); rp->faces[f].flags &= ~FF_NOT_SHELL; } //If no errors, set flags for room if (errors == 0) { for (f=0;fnum_faces;f++) { if (shell_flags[f] == SHELL_NONE) rp->faces[f].flags |= FF_NOT_SHELL; } } return errors; } //Finds shells for all rooms. //Returns the number of rooms with bad shells int ComputeAllRoomShells() { int r,bad_shells=0; room *rp; error_buf_offset = 0; mprintf((0,"Computing room shells...")); for (r=0,rp=Rooms;r<=Highest_room_index;r++,rp++) { if (rp->used && (rp->num_portals > 0) && !(rp->flags & RF_EXTERNAL)) { int errors = ComputeRoomShell(rp); if (errors) bad_shells++; } } mprintf((0,"Done\n")); mprintf((0,"Error buf size = %d\n",strlen(error_buf))); DumpTextToClipboard(error_buf); return bad_shells; } #include "objinfo.h" #include "mission.h" void ListObjectsInLevel(int *object_counts) { int i; object *objp; for (i=0;itype)) object_counts[objp->id]++; } CheckError("\n Robots:\n"); for (i=0;i