mirror of
https://github.com/dhewm/dhewm3.git
synced 2024-11-24 13:21:41 +00:00
1624 lines
44 KiB
C++
1624 lines
44 KiB
C++
/*
|
|
===========================================================================
|
|
|
|
Doom 3 GPL Source Code
|
|
Copyright (C) 1999-2011 id Software LLC, a ZeniMax Media company.
|
|
|
|
This file is part of the Doom 3 GPL Source Code (?Doom 3 Source Code?).
|
|
|
|
Doom 3 Source Code 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.
|
|
|
|
Doom 3 Source Code 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 Doom 3 Source Code. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
In addition, the Doom 3 Source Code is also subject to certain additional terms. You should have received a copy of these additional terms immediately following the terms and conditions of the GNU General Public License which accompanied the Doom 3 Source Code. If not, please request a copy in writing from id Software at the address below.
|
|
|
|
If you have questions concerning this license or the applicable additional terms, you may contact in writing id Software LLC, c/o ZeniMax Media Inc., Suite 120, Rockville, Maryland 20850 USA.
|
|
|
|
===========================================================================
|
|
*/
|
|
|
|
#include "../../idlib/precompiled.h"
|
|
#pragma hdrstop
|
|
|
|
#include "qe3.h"
|
|
|
|
int mapModified; // for quit confirmation (0 = clean, 1 = unsaved,
|
|
|
|
// 2 = autosaved, but not regular saved)
|
|
char currentmap[1024];
|
|
|
|
brush_t active_brushes; // brushes currently being displayed
|
|
brush_t selected_brushes; // highlighted
|
|
|
|
face_t *selected_face;
|
|
brush_t *selected_face_brush;
|
|
|
|
brush_t filtered_brushes; // brushes that have been filtered or regioned
|
|
|
|
entity_t entities; // head/tail of doubly linked list
|
|
|
|
entity_t *world_entity = NULL; // "classname" "worldspawn" !
|
|
|
|
void AddRegionBrushes(void);
|
|
void RemoveRegionBrushes(void);
|
|
|
|
/*
|
|
=======================================================================================================================
|
|
=======================================================================================================================
|
|
*/
|
|
void DupLists() {
|
|
DWORD dw = GetTickCount();
|
|
}
|
|
|
|
/*
|
|
* Cross map selection saving this could mess this up if you have only part of a
|
|
* complex entity selected...
|
|
*/
|
|
brush_t between_brushes;
|
|
entity_t between_entities;
|
|
|
|
bool g_bRestoreBetween = false;
|
|
|
|
/*
|
|
=======================================================================================================================
|
|
=======================================================================================================================
|
|
*/
|
|
void Map_SaveBetween(void) {
|
|
if (g_pParentWnd->ActiveXY()) {
|
|
g_bRestoreBetween = true;
|
|
g_pParentWnd->ActiveXY()->Copy();
|
|
}
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
/*
|
|
=======================================================================================================================
|
|
=======================================================================================================================
|
|
*/
|
|
void Map_RestoreBetween(void) {
|
|
if (g_pParentWnd->ActiveXY() && g_bRestoreBetween) {
|
|
g_pParentWnd->ActiveXY()->Paste();
|
|
}
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
/*
|
|
=======================================================================================================================
|
|
=======================================================================================================================
|
|
*/
|
|
bool CheckForTinyBrush(brush_t *b, int n, float fSize) {
|
|
bool bTiny = false;
|
|
for (int i = 0; i < 3; i++) {
|
|
if (b->maxs[i] - b->mins[i] < fSize) {
|
|
bTiny = true;
|
|
}
|
|
}
|
|
|
|
if (bTiny) {
|
|
common->Printf("Possible problem brush (too small) #%i ", n);
|
|
}
|
|
|
|
return bTiny;
|
|
}
|
|
|
|
/*
|
|
=======================================================================================================================
|
|
=======================================================================================================================
|
|
*/
|
|
void Map_BuildBrushData(void) {
|
|
brush_t *b, *next;
|
|
|
|
if (active_brushes.next == NULL) {
|
|
return;
|
|
}
|
|
|
|
Sys_BeginWait(); // this could take a while
|
|
|
|
int n = 0;
|
|
for (b = active_brushes.next; b != NULL && b != &active_brushes; b = next) {
|
|
next = b->next;
|
|
Brush_Build(b, true, false, false);
|
|
if (!b->brush_faces || (g_PrefsDlg.m_bCleanTiny && CheckForTinyBrush(b, n++, g_PrefsDlg.m_fTinySize))) {
|
|
Brush_Free(b);
|
|
common->Printf("Removed degenerate brush\n");
|
|
}
|
|
}
|
|
|
|
Sys_EndWait();
|
|
}
|
|
|
|
/*
|
|
=======================================================================================================================
|
|
=======================================================================================================================
|
|
*/
|
|
entity_t *Map_FindClass(char *cname) {
|
|
entity_t *ent;
|
|
|
|
for (ent = entities.next; ent != &entities; ent = ent->next) {
|
|
if (!strcmp(cname, ValueForKey(ent, "classname"))) {
|
|
return ent;
|
|
}
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
/*
|
|
=======================================================================================================================
|
|
=======================================================================================================================
|
|
*/
|
|
int Map_GetUniqueEntityID(const char *prefix, const char *eclass) {
|
|
entity_t *ent;
|
|
int id = 0;
|
|
for (ent = entities.next; ent != &entities; ent = ent->next) {
|
|
if (!strcmp(eclass, ValueForKey(ent, "classname"))) {
|
|
const char *name = ValueForKey(ent, "name");
|
|
if (name && name[0]) {
|
|
const char *buf;
|
|
if (prefix && *prefix) {
|
|
buf = va("%s_%s_", prefix, eclass);
|
|
} else {
|
|
buf = va("%s_", eclass);
|
|
}
|
|
int len = strlen(buf);
|
|
if ( idStr::Cmpn(name, buf, len) == 0 ) {
|
|
int j = atoi(name + len);
|
|
if (j > id) {
|
|
id = j;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return id + 1;
|
|
}
|
|
|
|
/*
|
|
=======================================================================================================================
|
|
=======================================================================================================================
|
|
*/
|
|
bool Entity_NameIsUnique(const char *name) {
|
|
entity_t *ent;
|
|
if (name == NULL) {
|
|
return false;
|
|
}
|
|
|
|
for (ent = entities.next; ent != &entities; ent = ent->next) {
|
|
const char *testName = ValueForKey(ent, "name");
|
|
if (testName) {
|
|
if ( idStr::Icmp(name, testName) == 0 ) {
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
=======================================================================================================================
|
|
Map_Free
|
|
=======================================================================================================================
|
|
*/
|
|
void Map_Free(void) {
|
|
g_bRestoreBetween = false;
|
|
if (selected_brushes.next && (selected_brushes.next != &selected_brushes)) {
|
|
if (g_pParentWnd->MessageBox("Copy selection?", "", MB_YESNO) == IDYES) {
|
|
Map_SaveBetween();
|
|
}
|
|
}
|
|
|
|
// clear all the render and sound system data
|
|
g_qeglobals.rw->InitFromMap( NULL );
|
|
g_qeglobals.sw->ClearAllSoundEmitters();
|
|
|
|
Texture_ClearInuse();
|
|
Pointfile_Clear();
|
|
strcpy(currentmap, "unnamed.map");
|
|
Sys_SetTitle(currentmap);
|
|
g_qeglobals.d_num_entities = 0;
|
|
|
|
if (!active_brushes.next) { // first map
|
|
active_brushes.prev = active_brushes.next = &active_brushes;
|
|
selected_brushes.prev = selected_brushes.next = &selected_brushes;
|
|
filtered_brushes.prev = filtered_brushes.next = &filtered_brushes;
|
|
|
|
entities.prev = entities.next = &entities;
|
|
}
|
|
else {
|
|
while (active_brushes.next != &active_brushes) {
|
|
Brush_Free(active_brushes.next, false);
|
|
}
|
|
|
|
while (selected_brushes.next != &selected_brushes) {
|
|
Brush_Free(selected_brushes.next, false);
|
|
}
|
|
|
|
while (filtered_brushes.next != &filtered_brushes) {
|
|
Brush_Free(filtered_brushes.next, false);
|
|
}
|
|
|
|
while (entities.next != &entities) {
|
|
Entity_Free(entities.next);
|
|
}
|
|
}
|
|
|
|
if (world_entity) {
|
|
Entity_Free(world_entity);
|
|
}
|
|
|
|
world_entity = NULL;
|
|
}
|
|
|
|
/*
|
|
=======================================================================================================================
|
|
=======================================================================================================================
|
|
*/
|
|
entity_t *AngledEntity() {
|
|
entity_t *ent = Map_FindClass("info_player_start");
|
|
if (!ent) {
|
|
ent = Map_FindClass("info_player_deathmatch");
|
|
}
|
|
|
|
if (!ent) {
|
|
ent = Map_FindClass("info_player_deathmatch");
|
|
}
|
|
|
|
if (!ent) {
|
|
ent = Map_FindClass("team_CTF_redplayer");
|
|
}
|
|
|
|
if (!ent) {
|
|
ent = Map_FindClass("team_CTF_blueplayer");
|
|
}
|
|
|
|
if (!ent) {
|
|
ent = Map_FindClass("team_CTF_redspawn");
|
|
}
|
|
|
|
if (!ent) {
|
|
ent = Map_FindClass("team_CTF_bluespawn");
|
|
}
|
|
|
|
return ent;
|
|
}
|
|
|
|
|
|
brush_t *BrushFromMapPatch(idMapPatch *mappatch, idVec3 origin) {
|
|
patchMesh_t *pm = MakeNewPatch(mappatch->GetWidth(), mappatch->GetHeight());
|
|
pm->d_texture = Texture_ForName(mappatch->GetMaterial());
|
|
for (int i = 0; i < mappatch->GetWidth(); i++) {
|
|
for (int j = 0; j < mappatch->GetHeight(); j++) {
|
|
pm->ctrl(i, j).xyz = (*mappatch)[j * mappatch->GetWidth() + i].xyz + origin;
|
|
pm->ctrl(i, j).st = (*mappatch)[j * mappatch->GetWidth() + i].st;
|
|
}
|
|
}
|
|
pm->horzSubdivisions = mappatch->GetHorzSubdivisions();
|
|
pm->vertSubdivisions = mappatch->GetVertSubdivisions();
|
|
pm->explicitSubdivisions = mappatch->GetExplicitlySubdivided();
|
|
if (mappatch->epairs.GetNumKeyVals()) {
|
|
pm->epairs = new idDict;
|
|
*pm->epairs = mappatch->epairs;
|
|
}
|
|
brush_t *b = AddBrushForPatch(pm, false);
|
|
return b;
|
|
}
|
|
|
|
brush_t *BrushFromMapBrush(idMapBrush *mapbrush, idVec3 origin) {
|
|
brush_t *b = NULL;
|
|
if (mapbrush) {
|
|
b = Brush_Alloc();
|
|
int count = mapbrush->GetNumSides();
|
|
for (int i = 0; i < count; i++) {
|
|
idMapBrushSide *side = mapbrush->GetSide(i);
|
|
face_t *f = Face_Alloc();
|
|
f->next = NULL;
|
|
if (!b->brush_faces) {
|
|
b->brush_faces = f;
|
|
}
|
|
else {
|
|
face_t *scan;
|
|
for (scan = b->brush_faces; scan->next; scan = scan->next) {
|
|
;
|
|
}
|
|
scan->next = f;
|
|
}
|
|
f->plane = side->GetPlane();
|
|
f->originalPlane = f->plane;
|
|
f->dirty = false;
|
|
|
|
idWinding w;
|
|
w.BaseForPlane(f->plane);
|
|
|
|
for (int j = 0; j < 3; j++) {
|
|
f->planepts[j].x = w[j].x + origin.x;
|
|
f->planepts[j].y = w[j].y + origin.y;
|
|
f->planepts[j].z = w[j].z + origin.z;
|
|
}
|
|
|
|
idVec3 mat[2];
|
|
side->GetTextureMatrix(mat[0], mat[1]);
|
|
f->brushprimit_texdef.coords[0][0] = mat[0][0];
|
|
f->brushprimit_texdef.coords[0][1] = mat[0][1];
|
|
f->brushprimit_texdef.coords[0][2] = mat[0][2];
|
|
f->brushprimit_texdef.coords[1][0] = mat[1][0];
|
|
f->brushprimit_texdef.coords[1][1] = mat[1][1];
|
|
f->brushprimit_texdef.coords[1][2] = mat[1][2];
|
|
|
|
f->texdef.SetName(side->GetMaterial());
|
|
}
|
|
}
|
|
return b;
|
|
}
|
|
|
|
entity_t *EntityFromMapEntity(idMapEntity *mapent, CWaitDlg *dlg) {
|
|
entity_t *ent = NULL;
|
|
if (mapent) {
|
|
ent = Entity_New();
|
|
ent->brushes.onext = ent->brushes.oprev = &ent->brushes;
|
|
ent->origin.Zero();
|
|
ent->epairs = mapent->epairs;
|
|
GetVectorForKey(ent, "origin", ent->origin);
|
|
int count = mapent->GetNumPrimitives();
|
|
long lastUpdate = 0;
|
|
idStr status;
|
|
for (int i = 0; i < count; i++) {
|
|
idMapPrimitive *prim = mapent->GetPrimitive(i);
|
|
if (prim) {
|
|
// update 20 times a second
|
|
if ( (GetTickCount() - lastUpdate) > 50 ) {
|
|
lastUpdate = GetTickCount();
|
|
if (prim->GetType() == idMapPrimitive::TYPE_BRUSH) {
|
|
sprintf(status, "Reading primitive %i (brush)", i);
|
|
} else if (prim->GetType() == idMapPrimitive::TYPE_PATCH) {
|
|
sprintf(status, "Reading primitive %i (patch)", i);
|
|
}
|
|
dlg->SetText(status, true);
|
|
}
|
|
if ( dlg->CancelPressed() ) {
|
|
return ent;
|
|
}
|
|
|
|
brush_t *b = NULL;
|
|
if (prim->GetType() == idMapPrimitive::TYPE_BRUSH) {
|
|
idMapBrush *mapbrush = reinterpret_cast<idMapBrush*>(prim);
|
|
b = BrushFromMapBrush(mapbrush, ent->origin);
|
|
} else if (prim->GetType() == idMapPrimitive::TYPE_PATCH) {
|
|
idMapPatch *mappatch = reinterpret_cast<idMapPatch*>(prim);
|
|
b = BrushFromMapPatch(mappatch, ent->origin);
|
|
}
|
|
if (b) {
|
|
b->owner = ent;
|
|
// add to the end of the entity chain
|
|
b->onext = &ent->brushes;
|
|
b->oprev = ent->brushes.oprev;
|
|
ent->brushes.oprev->onext = b;
|
|
ent->brushes.oprev = b;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return ent;
|
|
}
|
|
|
|
extern entity_t *Entity_PostParse(entity_t *ent, brush_t *pList);
|
|
/*
|
|
=======================================================================================================================
|
|
Map_LoadFile
|
|
=======================================================================================================================
|
|
*/
|
|
void Map_LoadFile(const char *filename) {
|
|
entity_t *ent;
|
|
CWaitDlg dlg;
|
|
idStr fileStr, status;
|
|
idMapFile mapfile;
|
|
|
|
Sys_BeginWait();
|
|
Select_Deselect();
|
|
|
|
dlg.AllowCancel( true );
|
|
idStr( filename ).ExtractFileName( fileStr );
|
|
sprintf( status, "Loading %s...", fileStr.c_str() );
|
|
dlg.SetWindowText( status );
|
|
sprintf( status, "Reading file %s...", fileStr.c_str() );
|
|
dlg.SetText( status );
|
|
|
|
// SetInspectorMode(W_CONSOLE);
|
|
fileStr = filename;
|
|
fileStr.BackSlashesToSlashes();
|
|
|
|
common->Printf( "Map_LoadFile: %s\n", fileStr.c_str() );
|
|
|
|
Map_Free();
|
|
|
|
g_qeglobals.d_parsed_brushes = 0;
|
|
strcpy( currentmap, filename );
|
|
|
|
if(mapfile.Parse(filename, true, true)) {
|
|
g_qeglobals.bNeedConvert = false;
|
|
g_qeglobals.bOldBrushes = false;
|
|
g_qeglobals.bPrimitBrushes = false;
|
|
g_qeglobals.mapVersion = 1.0;
|
|
|
|
long lastUpdate = 0;
|
|
int count = mapfile.GetNumEntities();
|
|
for (int i = 0; i < count; i++) {
|
|
idMapEntity *mapent = mapfile.GetEntity(i);
|
|
if (mapent) {
|
|
idStr classname = mapent->epairs.GetString("classname");
|
|
// Update 20 times a second
|
|
if ( (GetTickCount() - lastUpdate) > 50 ) {
|
|
lastUpdate = GetTickCount();
|
|
sprintf(status, "Loading entity %i (%s)...", i, classname.c_str());
|
|
dlg.SetText(status);
|
|
}
|
|
if ( dlg.CancelPressed() ) {
|
|
Sys_Status("Map load cancelled.\n");
|
|
Map_New();
|
|
return;
|
|
}
|
|
if (classname == "worldspawn") {
|
|
world_entity = EntityFromMapEntity(mapent, &dlg);
|
|
Entity_PostParse(world_entity, &active_brushes);
|
|
} else {
|
|
ent = EntityFromMapEntity(mapent, &dlg);
|
|
Entity_PostParse(ent, &active_brushes);
|
|
Entity_Name(ent, true);
|
|
// add the entity to the end of the entity list
|
|
ent->next = &entities;
|
|
ent->prev = entities.prev;
|
|
entities.prev->next = ent;
|
|
entities.prev = ent;
|
|
g_qeglobals.d_num_entities++;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!world_entity) {
|
|
Sys_Status("No worldspawn in map.\n");
|
|
Map_New();
|
|
return;
|
|
}
|
|
|
|
common->Printf("--- LoadMapFile ---\n");
|
|
common->Printf("%s\n", fileStr.c_str());
|
|
|
|
common->Printf("%5i brushes\n", g_qeglobals.d_parsed_brushes);
|
|
common->Printf("%5i entities\n", g_qeglobals.d_num_entities);
|
|
|
|
dlg.SetText("Restoring Between");
|
|
Map_RestoreBetween();
|
|
|
|
dlg.SetText("Building Brush Data");
|
|
common->Printf("Map_BuildAllDisplayLists\n");
|
|
Map_BuildBrushData();
|
|
|
|
//
|
|
// reset the "need conversion" flag conversion to the good format done in
|
|
// Map_BuildBrushData
|
|
//
|
|
g_qeglobals.bNeedConvert = false;
|
|
|
|
// move the view to a start position
|
|
ent = AngledEntity();
|
|
|
|
g_pParentWnd->GetCamera()->Camera().angles[PITCH] = 0;
|
|
|
|
if (ent) {
|
|
GetVectorForKey(ent, "origin", g_pParentWnd->GetCamera()->Camera().origin);
|
|
GetVectorForKey(ent, "origin", g_pParentWnd->GetXYWnd()->GetOrigin());
|
|
g_pParentWnd->GetCamera()->Camera().angles[YAW] = FloatForKey(ent, "angle");
|
|
}
|
|
else {
|
|
g_pParentWnd->GetCamera()->Camera().angles[YAW] = 0;
|
|
VectorCopy(vec3_origin, g_pParentWnd->GetCamera()->Camera().origin);
|
|
VectorCopy(vec3_origin, g_pParentWnd->GetXYWnd()->GetOrigin());
|
|
}
|
|
|
|
Map_RegionOff();
|
|
|
|
mapModified = 0;
|
|
|
|
if (GetFileAttributes(filename) & FILE_ATTRIBUTE_READONLY) {
|
|
fileStr += " (read only) ";
|
|
}
|
|
Sys_SetTitle(fileStr);
|
|
|
|
Texture_ShowInuse();
|
|
|
|
if (g_pParentWnd->GetCamera()->GetRenderMode()) {
|
|
g_pParentWnd->GetCamera()->BuildRendererState();
|
|
}
|
|
|
|
Sys_EndWait();
|
|
Sys_UpdateWindows(W_ALL);
|
|
}
|
|
|
|
|
|
void Map_VerifyCurrentMap(const char *map) {
|
|
if ( idStr::Icmp( map, currentmap ) != 0 ) {
|
|
Map_LoadFile( map );
|
|
}
|
|
}
|
|
|
|
idMapPrimitive *BrushToMapPrimitive( const brush_t *b, const idVec3 &origin ) {
|
|
if ( b->pPatch ) {
|
|
idMapPatch *patch = new idMapPatch( b->pPatch->width * 6, b->pPatch->height * 6 );
|
|
patch->SetSize( b->pPatch->width, b->pPatch->height );
|
|
for ( int i = 0; i < b->pPatch->width; i++ ) {
|
|
for ( int j = 0; j < b->pPatch->height; j++ ) {
|
|
(*patch)[j*patch->GetWidth()+i].xyz = b->pPatch->ctrl(i, j).xyz - origin;
|
|
(*patch)[j*patch->GetWidth()+i].st = b->pPatch->ctrl(i, j).st;
|
|
}
|
|
}
|
|
patch->SetExplicitlySubdivided( b->pPatch->explicitSubdivisions );
|
|
if ( b->pPatch->explicitSubdivisions ) {
|
|
patch->SetHorzSubdivisions( b->pPatch->horzSubdivisions );
|
|
patch->SetVertSubdivisions( b->pPatch->vertSubdivisions );
|
|
}
|
|
patch->SetMaterial( b->pPatch->d_texture->GetName() );
|
|
if ( b->pPatch->epairs ) {
|
|
patch->epairs = *b->pPatch->epairs;
|
|
}
|
|
return patch;
|
|
}
|
|
else {
|
|
idMapBrush *mapbrush = new idMapBrush;
|
|
for ( face_t *f = b->brush_faces; f; f = f->next ) {
|
|
idMapBrushSide *side = new idMapBrushSide;
|
|
|
|
idPlane plane;
|
|
if ( f->dirty ) {
|
|
f->planepts[0] -= origin;
|
|
f->planepts[1] -= origin;
|
|
f->planepts[2] -= origin;
|
|
plane.FromPoints( f->planepts[0], f->planepts[1], f->planepts[2], false );
|
|
f->planepts[0] += origin;
|
|
f->planepts[1] += origin;
|
|
f->planepts[2] += origin;
|
|
} else {
|
|
plane = f->originalPlane;
|
|
}
|
|
side->SetPlane( plane );
|
|
side->SetMaterial( f->d_texture->GetName() );
|
|
idVec3 mat[2];
|
|
mat[0][0] = f->brushprimit_texdef.coords[0][0];
|
|
mat[0][1] = f->brushprimit_texdef.coords[0][1];
|
|
mat[0][2] = f->brushprimit_texdef.coords[0][2];
|
|
mat[1][0] = f->brushprimit_texdef.coords[1][0];
|
|
mat[1][1] = f->brushprimit_texdef.coords[1][1];
|
|
mat[1][2] = f->brushprimit_texdef.coords[1][2];
|
|
side->SetTextureMatrix(mat);
|
|
mapbrush->AddSide(side);
|
|
mapbrush->epairs = b->epairs;
|
|
}
|
|
return mapbrush;
|
|
}
|
|
}
|
|
|
|
idMapEntity *EntityToMapEntity(entity_t *e, bool use_region, CWaitDlg *dlg) {
|
|
idMapEntity *mapent = new idMapEntity;
|
|
mapent->epairs = e->epairs;
|
|
idStr status;
|
|
int count = 0;
|
|
long lastUpdate = 0;
|
|
if ( !EntityHasModel( e ) ) {
|
|
for ( brush_t *b = e->brushes.onext; b != &e->brushes; b = b->onext ) {
|
|
count++;
|
|
if ( e->eclass->fixedsize && !b->entityModel ) {
|
|
continue;
|
|
}
|
|
if ( !use_region || !Map_IsBrushFiltered( b ) ) {
|
|
// Update 20 times a second
|
|
if ( GetTickCount() - lastUpdate > 50 ) {
|
|
lastUpdate = GetTickCount();
|
|
if ( b->pPatch ) {
|
|
sprintf( status, "Adding primitive %i (patch)", count );
|
|
dlg->SetText( status, true );
|
|
} else {
|
|
sprintf( status, "Adding primitive %i (brush)", count );
|
|
dlg->SetText( status, true );
|
|
}
|
|
}
|
|
idMapPrimitive *prim = BrushToMapPrimitive( b, e->origin );
|
|
if ( prim ) {
|
|
mapent->AddPrimitive( prim );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return mapent;
|
|
}
|
|
|
|
/*
|
|
=======================================================================================================================
|
|
Map_SaveFile
|
|
=======================================================================================================================
|
|
*/
|
|
bool Map_SaveFile(const char *filename, bool use_region, bool autosave) {
|
|
entity_t *e, *next;
|
|
idStr temp;
|
|
int count;
|
|
brush_t *b;
|
|
idStr status;
|
|
|
|
int len = strlen(filename);
|
|
WIN32_FIND_DATA FileData;
|
|
if (FindFirstFile(filename, &FileData) != INVALID_HANDLE_VALUE) {
|
|
// the file exists;
|
|
if (len > 0 && GetFileAttributes(filename) & FILE_ATTRIBUTE_READONLY) {
|
|
g_pParentWnd->MessageBox("File is read only", "Read Only", MB_OK);
|
|
return false;
|
|
}
|
|
}
|
|
|
|
if (filename == NULL || len == 0 || (filename && stricmp(filename, "unnamed.map") == 0)) {
|
|
CFileDialog dlgSave(FALSE,"map",NULL,OFN_HIDEREADONLY | OFN_OVERWRITEPROMPT,"Map Files (*.map)|*.map||",AfxGetMainWnd());
|
|
if (dlgSave.DoModal() == IDOK) {
|
|
filename = dlgSave.m_ofn.lpstrFile;
|
|
strcpy(currentmap, filename);
|
|
}
|
|
else {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
MEMORYSTATUSEX statex;
|
|
statex.dwLength = sizeof (statex);
|
|
GlobalMemoryStatusEx (&statex);
|
|
if ( statex.dwMemoryLoad > 95 ) {
|
|
g_pParentWnd->MessageBox("Physical memory is over 95% utilized. Consider saving and restarting", "Memory");
|
|
}
|
|
|
|
CWaitDlg dlg;
|
|
Pointfile_Clear();
|
|
|
|
temp = filename;
|
|
temp.BackSlashesToSlashes();
|
|
|
|
if ( !use_region ) {
|
|
idStr backup;
|
|
backup = temp;
|
|
backup.StripFileExtension();
|
|
backup.SetFileExtension( ".bak" );
|
|
if ( _unlink(backup) != 0 && errno != 2 ) { // errno 2 means the file doesn't exist, which we don't care about
|
|
g_pParentWnd->MessageBox( va("Unable to delete %s: %s", backup.c_str(), strerror(errno) ), "File Error" );
|
|
}
|
|
|
|
if ( rename(filename, backup) != 0 ) {
|
|
g_pParentWnd->MessageBox( va("Unable to rename %s to %s: %s", filename, backup.c_str(), strerror(errno) ), "File Error" );
|
|
}
|
|
}
|
|
|
|
common->Printf("Map_SaveFile: %s\n", filename);
|
|
|
|
idStr mapFile;
|
|
bool localFile = (strstr(filename, ":") != NULL);
|
|
if (autosave || localFile) {
|
|
mapFile = filename;
|
|
} else {
|
|
mapFile = fileSystem->OSPathToRelativePath( filename );
|
|
}
|
|
|
|
if (use_region) {
|
|
AddRegionBrushes();
|
|
}
|
|
|
|
idMapFile map;
|
|
world_entity->origin.Zero();
|
|
idMapEntity *mapentity = EntityToMapEntity(world_entity, use_region, &dlg);
|
|
dlg.SetText("Saving worldspawn...");
|
|
map.AddEntity(mapentity);
|
|
|
|
if ( use_region ) {
|
|
idStr buf;
|
|
sprintf( buf, "{\n\"classname\" \"info_player_start\"\n\"origin\"\t \"%i %i %i\"\n\"angle\"\t \"%i\"\n}\n",
|
|
(int)g_pParentWnd->GetCamera()->Camera().origin[0],
|
|
(int)g_pParentWnd->GetCamera()->Camera().origin[1],
|
|
(int)g_pParentWnd->GetCamera()->Camera().origin[2],
|
|
(int)g_pParentWnd->GetCamera()->Camera().angles[YAW] );
|
|
idLexer src( LEXFL_NOSTRINGCONCAT | LEXFL_NOSTRINGESCAPECHARS | LEXFL_ALLOWPATHNAMES );
|
|
src.LoadMemory( buf, buf.Length(), "regionbuf" );
|
|
idMapEntity *playerstart = idMapEntity::Parse( src );
|
|
map.AddEntity( playerstart );
|
|
}
|
|
|
|
count = -1;
|
|
for ( e = entities.next; e != &entities; e = next ) {
|
|
count++;
|
|
next = e->next;
|
|
if (e->brushes.onext == &e->brushes) {
|
|
Entity_Free(e); // no brushes left, so remove it
|
|
}
|
|
else {
|
|
if (use_region) {
|
|
for (b = e->brushes.onext; b != &e->brushes; b = b->onext) {
|
|
if (!Map_IsBrushFiltered(b)) {
|
|
break; // got one
|
|
}
|
|
}
|
|
|
|
if (b == &e->brushes) {
|
|
continue; // nothing visible
|
|
}
|
|
|
|
}
|
|
idVec3 origin;
|
|
if (!GetVectorForKey(e, "origin", origin)) {
|
|
idStr text;
|
|
VectorSubtract(e->brushes.onext->mins, e->eclass->mins, origin);
|
|
sprintf(text, "%i %i %i", (int)origin[0], (int)origin[1], (int)origin[2]);
|
|
SetKeyValue(e, "origin", text);
|
|
}
|
|
|
|
if (use_region && !idStr::Icmp(ValueForKey(e, "classname"), "info_player_start")) {
|
|
continue;
|
|
}
|
|
|
|
idStr classname = e->epairs.GetString("classname");
|
|
sprintf(status, "Saving entity %i (%s)...", count, classname.c_str());
|
|
dlg.SetText(status);
|
|
|
|
map.AddEntity(EntityToMapEntity(e, use_region, &dlg));
|
|
count++;
|
|
}
|
|
}
|
|
|
|
mapFile.StripFileExtension();
|
|
idStr mapExt = (use_region) ? ".reg" : ".map";
|
|
sprintf(status, "Writing file %s.%s...", mapFile.c_str(), mapExt.c_str());
|
|
dlg.SetText(status);
|
|
map.Write(mapFile, mapExt, !(autosave || localFile));
|
|
mapModified = 0;
|
|
|
|
if (use_region) {
|
|
RemoveRegionBrushes();
|
|
}
|
|
|
|
if (!strstr(temp, "autosave")) {
|
|
Sys_SetTitle(temp);
|
|
}
|
|
|
|
Sys_Status("Saved.\n", 0);
|
|
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
=======================================================================================================================
|
|
Map_New
|
|
=======================================================================================================================
|
|
*/
|
|
void Map_New(void) {
|
|
common->Printf("Map_New\n");
|
|
Map_Free();
|
|
|
|
Patch_Cleanup();
|
|
g_Inspectors->entityDlg.SetEditEntity ( NULL );
|
|
|
|
world_entity = Entity_New();
|
|
world_entity->brushes.onext = world_entity->brushes.oprev = &world_entity->brushes;
|
|
SetKeyValue(world_entity, "classname", "worldspawn");
|
|
world_entity->eclass = Eclass_ForName("worldspawn", true);
|
|
|
|
g_pParentWnd->GetCamera()->Camera().angles[YAW] = 0;
|
|
g_pParentWnd->GetCamera()->Camera().angles[PITCH] = 0;
|
|
VectorCopy(vec3_origin, g_pParentWnd->GetCamera()->Camera().origin);
|
|
g_pParentWnd->GetCamera()->Camera().origin[2] = 48;
|
|
VectorCopy(vec3_origin, g_pParentWnd->GetXYWnd()->GetOrigin());
|
|
|
|
Map_RestoreBetween();
|
|
|
|
Sys_UpdateWindows(W_ALL);
|
|
mapModified = 0;
|
|
|
|
g_qeglobals.mapVersion = MAP_VERSION;
|
|
|
|
}
|
|
|
|
|
|
bool region_active;
|
|
idVec3 region_mins(MIN_WORLD_COORD, MIN_WORLD_COORD, MIN_WORLD_COORD);
|
|
idVec3 region_maxs(MAX_WORLD_COORD, MAX_WORLD_COORD, MAX_WORLD_COORD);
|
|
|
|
brush_t *region_sides[6];
|
|
|
|
/*
|
|
=======================================================================================================================
|
|
AddRegionBrushes a regioned map will have temp walls put up at the region boundary
|
|
=======================================================================================================================
|
|
*/
|
|
void AddRegionBrushes(void) {
|
|
idVec3 mins, maxs;
|
|
int i;
|
|
texdef_t td;
|
|
|
|
if (!region_active) {
|
|
return;
|
|
}
|
|
|
|
memset(&td, 0, sizeof(td));
|
|
td = g_qeglobals.d_texturewin.texdef;
|
|
|
|
// strcpy (td.name, "REGION");
|
|
td.SetName("textures/REGION");
|
|
|
|
const int REGION_WIDTH = 1024;
|
|
|
|
|
|
mins[0] = region_mins[0] - REGION_WIDTH;
|
|
maxs[0] = region_mins[0] + 1;
|
|
mins[1] = region_mins[1] - REGION_WIDTH;
|
|
maxs[1] = region_maxs[1] + REGION_WIDTH;
|
|
mins[2] = MIN_WORLD_COORD;
|
|
maxs[2] = MAX_WORLD_COORD;
|
|
region_sides[0] = Brush_Create(mins, maxs, &td);
|
|
|
|
|
|
mins[0] = region_maxs[0] - 1;
|
|
maxs[0] = region_maxs[0] + REGION_WIDTH;
|
|
region_sides[1] = Brush_Create(mins, maxs, &td);
|
|
|
|
mins[0] = region_mins[0] - REGION_WIDTH;
|
|
maxs[0] = region_maxs[0] + REGION_WIDTH;
|
|
mins[1] = region_mins[1] - REGION_WIDTH;
|
|
maxs[1] = region_mins[1] + 1;
|
|
region_sides[2] = Brush_Create(mins, maxs, &td);
|
|
|
|
mins[1] = region_maxs[1] - 1;
|
|
maxs[1] = region_maxs[1] + REGION_WIDTH;
|
|
region_sides[3] = Brush_Create(mins, maxs, &td);
|
|
|
|
mins = region_mins;
|
|
maxs = region_maxs;
|
|
maxs[2] = mins[2] + REGION_WIDTH;
|
|
region_sides[4] = Brush_Create(mins, maxs, &td);
|
|
|
|
mins = region_mins;
|
|
maxs = region_maxs;
|
|
mins[2] = maxs[2] - REGION_WIDTH;
|
|
region_sides[5] = Brush_Create(mins, maxs, &td);
|
|
|
|
for (i = 0; i < 6; i++) {
|
|
Brush_AddToList(region_sides[i], &selected_brushes);
|
|
Entity_LinkBrush(world_entity, region_sides[i]);
|
|
Brush_Build(region_sides[i]);
|
|
}
|
|
}
|
|
|
|
/*
|
|
=======================================================================================================================
|
|
=======================================================================================================================
|
|
*/
|
|
void RemoveRegionBrushes(void) {
|
|
int i;
|
|
|
|
if (!region_active) {
|
|
return;
|
|
}
|
|
|
|
for (i = 0; i < 6; i++) {
|
|
Brush_Free(region_sides[i]);
|
|
}
|
|
}
|
|
|
|
/*
|
|
=======================================================================================================================
|
|
=======================================================================================================================
|
|
*/
|
|
bool Map_IsBrushFiltered(brush_t *b) {
|
|
int i;
|
|
|
|
if (!region_active) {
|
|
return false;
|
|
}
|
|
|
|
for (i = 0; i < 3; i++) {
|
|
if (b->mins[i] > region_maxs[i]) {
|
|
return true;
|
|
}
|
|
|
|
if (b->maxs[i] < region_mins[i]) {
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
/*
|
|
=======================================================================================================================
|
|
Map_RegionOff Other filtering options may still be on
|
|
=======================================================================================================================
|
|
*/
|
|
void Map_RegionOff(void) {
|
|
brush_t *b, *next;
|
|
int i;
|
|
|
|
region_active = false;
|
|
for (i = 0; i < 3; i++) {
|
|
region_maxs[i] = MAX_WORLD_COORD; // 4096;
|
|
region_mins[i] = MIN_WORLD_COORD; // -4096;
|
|
}
|
|
|
|
for (b = filtered_brushes.next; b != &filtered_brushes; b = next) {
|
|
next = b->next;
|
|
if (Map_IsBrushFiltered(b)) {
|
|
continue; // still filtered
|
|
}
|
|
|
|
Brush_RemoveFromList(b);
|
|
if (active_brushes.next == NULL || active_brushes.prev == NULL) {
|
|
active_brushes.next = &active_brushes;
|
|
active_brushes.prev = &active_brushes;
|
|
}
|
|
|
|
Brush_AddToList(b, &active_brushes);
|
|
}
|
|
|
|
Sys_UpdateWindows(W_ALL);
|
|
}
|
|
|
|
/*
|
|
=======================================================================================================================
|
|
=======================================================================================================================
|
|
*/
|
|
void Map_ApplyRegion(void) {
|
|
brush_t *b, *next;
|
|
|
|
region_active = true;
|
|
for (b = active_brushes.next; b != &active_brushes; b = next) {
|
|
next = b->next;
|
|
if (!Map_IsBrushFiltered(b)) {
|
|
continue; // still filtered
|
|
}
|
|
|
|
Brush_RemoveFromList(b);
|
|
Brush_AddToList(b, &filtered_brushes);
|
|
}
|
|
|
|
Sys_UpdateWindows(W_ALL);
|
|
}
|
|
|
|
/*
|
|
=======================================================================================================================
|
|
Map_RegionSelectedBrushes
|
|
=======================================================================================================================
|
|
*/
|
|
void Map_RegionSelectedBrushes(void) {
|
|
Map_RegionOff();
|
|
|
|
if (selected_brushes.next == &selected_brushes) { // nothing selected
|
|
Sys_Status("Tried to region with no selection...\n");
|
|
return;
|
|
}
|
|
|
|
region_active = true;
|
|
Select_GetBounds(region_mins, region_maxs);
|
|
|
|
// move the entire active_brushes list to filtered_brushes
|
|
filtered_brushes.next = active_brushes.next;
|
|
filtered_brushes.prev = active_brushes.prev;
|
|
filtered_brushes.next->prev = &filtered_brushes;
|
|
filtered_brushes.prev->next = &filtered_brushes;
|
|
|
|
Patch_Deselect();
|
|
// move the entire selected_brushes list to active_brushes
|
|
active_brushes.next = selected_brushes.next;
|
|
active_brushes.prev = selected_brushes.prev;
|
|
active_brushes.next->prev = &active_brushes;
|
|
active_brushes.prev->next = &active_brushes;
|
|
|
|
// clear selected_brushes
|
|
selected_brushes.next = selected_brushes.prev = &selected_brushes;
|
|
|
|
Sys_UpdateWindows(W_ALL);
|
|
}
|
|
|
|
/*
|
|
=======================================================================================================================
|
|
Map_RegionXY
|
|
=======================================================================================================================
|
|
*/
|
|
void Map_RegionXY(void) {
|
|
Map_RegionOff();
|
|
|
|
region_mins[0] = g_pParentWnd->GetXYWnd()->GetOrigin()[0] -
|
|
0.5 *
|
|
g_pParentWnd->GetXYWnd()->Width() /
|
|
g_pParentWnd->GetXYWnd()->Scale();
|
|
region_maxs[0] = g_pParentWnd->GetXYWnd()->GetOrigin()[0] +
|
|
0.5 *
|
|
g_pParentWnd->GetXYWnd()->Width() /
|
|
g_pParentWnd->GetXYWnd()->Scale();
|
|
region_mins[1] = g_pParentWnd->GetXYWnd()->GetOrigin()[1] -
|
|
0.5 *
|
|
g_pParentWnd->GetXYWnd()->Height() /
|
|
g_pParentWnd->GetXYWnd()->Scale();
|
|
region_maxs[1] = g_pParentWnd->GetXYWnd()->GetOrigin()[1] +
|
|
0.5 *
|
|
g_pParentWnd->GetXYWnd()->Height() /
|
|
g_pParentWnd->GetXYWnd()->Scale();
|
|
region_mins[2] = MIN_WORLD_COORD;
|
|
region_maxs[2] = MAX_WORLD_COORD;
|
|
Map_ApplyRegion();
|
|
}
|
|
|
|
/*
|
|
=======================================================================================================================
|
|
Map_RegionTallBrush
|
|
=======================================================================================================================
|
|
*/
|
|
void Map_RegionTallBrush(void) {
|
|
brush_t *b;
|
|
|
|
if (!QE_SingleBrush()) {
|
|
return;
|
|
}
|
|
|
|
b = selected_brushes.next;
|
|
|
|
Map_RegionOff();
|
|
|
|
VectorCopy(b->mins, region_mins);
|
|
VectorCopy(b->maxs, region_maxs);
|
|
region_mins[2] = MIN_WORLD_COORD;
|
|
region_maxs[2] = MAX_WORLD_COORD;
|
|
|
|
Select_Delete();
|
|
Map_ApplyRegion();
|
|
}
|
|
|
|
/*
|
|
=======================================================================================================================
|
|
Map_RegionBrush
|
|
=======================================================================================================================
|
|
*/
|
|
void Map_RegionBrush(void) {
|
|
brush_t *b;
|
|
|
|
if (!QE_SingleBrush()) {
|
|
return;
|
|
}
|
|
|
|
b = selected_brushes.next;
|
|
|
|
Map_RegionOff();
|
|
|
|
VectorCopy(b->mins, region_mins);
|
|
VectorCopy(b->maxs, region_maxs);
|
|
|
|
Select_Delete();
|
|
Map_ApplyRegion();
|
|
}
|
|
|
|
/*
|
|
=======================================================================================================================
|
|
=======================================================================================================================
|
|
*/
|
|
void UniqueTargetName(idStr &rStr) {
|
|
// make a unique target value
|
|
int maxtarg = 0;
|
|
for (entity_t * e = entities.next; e != &entities; e = e->next) {
|
|
const char *tn = ValueForKey(e, "name");
|
|
if (tn && tn[0]) {
|
|
int targetnum = atoi(tn + 1);
|
|
if (targetnum > maxtarg) {
|
|
maxtarg = targetnum;
|
|
}
|
|
}
|
|
else {
|
|
tn = ValueForKey(e, "target");
|
|
if (tn && tn[0]) {
|
|
int targetnum = atoi(tn + 1);
|
|
if (targetnum > maxtarg) {
|
|
maxtarg = targetnum;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
sprintf(rStr, "t%i", maxtarg + 1);
|
|
}
|
|
|
|
//
|
|
// =======================================================================================================================
|
|
// Map_ImportFile Timo 09/01/99:: called by CXYWnd::Paste & Map_ImportFile if Map_ImportFile ( prefab ), the buffer
|
|
// may contain brushes in old format ( conversion needed )
|
|
// =======================================================================================================================
|
|
//
|
|
void Map_ImportBuffer(char *buf, bool renameEntities) {
|
|
entity_t *ent;
|
|
brush_t *b = NULL;
|
|
CPtrArray ptrs;
|
|
|
|
Select_Deselect();
|
|
|
|
Undo_Start("import buffer");
|
|
|
|
g_qeglobals.d_parsed_brushes = 0;
|
|
if (buf) {
|
|
CMapStringToString mapStr;
|
|
StartTokenParsing(buf);
|
|
g_qeglobals.d_num_entities = 0;
|
|
|
|
//
|
|
// Timo will be used in Entity_Parse to detect if a conversion between brush
|
|
// formats is needed
|
|
//
|
|
g_qeglobals.bNeedConvert = false;
|
|
g_qeglobals.bOldBrushes = false;
|
|
g_qeglobals.bPrimitBrushes = false;
|
|
g_qeglobals.mapVersion = 1.0;
|
|
|
|
if (GetToken(true)) {
|
|
if (stricmp(token, "Version") == 0) {
|
|
GetToken(false);
|
|
g_qeglobals.mapVersion = atof(token);
|
|
common->Printf("Map version: %1.2f\n", g_qeglobals.mapVersion);
|
|
} else {
|
|
UngetToken();
|
|
}
|
|
}
|
|
|
|
idDict RemappedNames; // since I can't use "map <string, string>"... sigh. So much for STL...
|
|
|
|
while (1) {
|
|
//
|
|
// use the selected brushes list as it's handy ent = Entity_Parse (false,
|
|
// &selected_brushes);
|
|
//
|
|
ent = Entity_Parse(false, &active_brushes);
|
|
if (!ent) {
|
|
break;
|
|
}
|
|
|
|
// end entity for undo
|
|
Undo_EndEntity(ent);
|
|
|
|
// end brushes for undo
|
|
for (b = ent->brushes.onext; b && b != &ent->brushes; b = b->onext) {
|
|
Undo_EndBrush(b);
|
|
}
|
|
|
|
if (!strcmp(ValueForKey(ent, "classname"), "worldspawn")) {
|
|
// world brushes need to be added to the current world entity
|
|
b = ent->brushes.onext;
|
|
while (b && b != &ent->brushes) {
|
|
brush_t *bNext = b->onext;
|
|
Entity_UnlinkBrush(b);
|
|
Entity_LinkBrush(world_entity, b);
|
|
ptrs.Add(b);
|
|
b = bNext;
|
|
}
|
|
}
|
|
else {
|
|
// the following bit remaps conflicting target/targetname key/value pairs
|
|
CString str = ValueForKey(ent, "target");
|
|
CString strKey;
|
|
CString strTarget("");
|
|
if (str.GetLength() > 0) {
|
|
if (FindEntity("target", str.GetBuffer(0))) {
|
|
if (!mapStr.Lookup(str, strKey)) {
|
|
idStr key;
|
|
UniqueTargetName(key);
|
|
strKey = key;
|
|
mapStr.SetAt(str, strKey);
|
|
}
|
|
|
|
strTarget = strKey;
|
|
SetKeyValue(ent, "target", strTarget.GetBuffer(0));
|
|
}
|
|
}
|
|
|
|
/*
|
|
* str = ValueForKey(ent, "name"); if (str.GetLength() > 0) { if
|
|
* (FindEntity("name", str.GetBuffer(0))) { if (!mapStr.Lookup(str, strKey)) {
|
|
* UniqueTargetName(strKey); mapStr.SetAt(str, strKey); } Entity_SetName(ent,
|
|
* strKey.GetBuffer(0)); } }
|
|
*/
|
|
CString cstrNameOld = ValueForKey(ent, "name");
|
|
Entity_Name(ent, renameEntities);
|
|
CString cstrNameNew = ValueForKey(ent, "name");
|
|
if (cstrNameOld != cstrNameNew)
|
|
{
|
|
RemappedNames.Set(cstrNameOld, cstrNameNew);
|
|
}
|
|
//
|
|
// if (strTarget.GetLength() > 0) SetKeyValue(ent, "target",
|
|
// strTarget.GetBuffer(0));
|
|
// add the entity to the end of the entity list
|
|
//
|
|
ent->next = &entities;
|
|
ent->prev = entities.prev;
|
|
entities.prev->next = ent;
|
|
entities.prev = ent;
|
|
g_qeglobals.d_num_entities++;
|
|
|
|
for (b = ent->brushes.onext; b != &ent->brushes; b = b->onext) {
|
|
ptrs.Add(b);
|
|
}
|
|
}
|
|
}
|
|
|
|
// now iterate through the remapped names, and see if there are any target-connections that need remaking...
|
|
//
|
|
// (I could probably write this in half the size with STL, but WTF, work with what we have...)
|
|
//
|
|
int iNumKeyVals = RemappedNames.GetNumKeyVals();
|
|
for (int iKeyVal=0; iKeyVal < iNumKeyVals; iKeyVal++)
|
|
{
|
|
const idKeyValue *pKeyVal = RemappedNames.GetKeyVal( iKeyVal );
|
|
|
|
LPCSTR psOldName = pKeyVal->GetKey().c_str();
|
|
LPCSTR psNewName = pKeyVal->GetValue().c_str();
|
|
|
|
entity_t *pEntOld = FindEntity("name", psOldName); // original ent we cloned from
|
|
entity_t *pEntNew = FindEntity("name", psNewName); // cloned ent
|
|
|
|
if (pEntOld && pEntNew)
|
|
{
|
|
CString cstrTargetNameOld = ValueForKey(pEntOld, "target");
|
|
if (!cstrTargetNameOld.IsEmpty())
|
|
{
|
|
// ok, this ent was targeted at another ent, so it's clone needs updating to point to
|
|
// the clone of that target, so...
|
|
//
|
|
entity_t *pEntOldTarget = FindEntity("name", cstrTargetNameOld);
|
|
if ( pEntOldTarget )
|
|
{
|
|
LPCSTR psNewTargetName = RemappedNames.GetString( cstrTargetNameOld );
|
|
if (psNewTargetName && psNewTargetName[0])
|
|
{
|
|
SetKeyValue(pEntNew, "target", psNewTargetName);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// ::ShowWindow(g_qeglobals.d_hwndEntity, FALSE);
|
|
// ::LockWindowUpdate(g_qeglobals.d_hwndEntity);
|
|
//
|
|
g_bScreenUpdates = false;
|
|
for (int i = 0; i < ptrs.GetSize(); i++) {
|
|
Brush_Build(reinterpret_cast < brush_t * > (ptrs[i]), true, false);
|
|
Select_Brush(reinterpret_cast < brush_t * > (ptrs[i]), true, false);
|
|
}
|
|
|
|
// ::LockWindowUpdate(NULL);
|
|
g_bScreenUpdates = true;
|
|
|
|
ptrs.RemoveAll();
|
|
|
|
//
|
|
// reset the "need conversion" flag conversion to the good format done in
|
|
// Map_BuildBrushData
|
|
//
|
|
g_qeglobals.bNeedConvert = false;
|
|
|
|
Sys_UpdateWindows(W_ALL);
|
|
|
|
// Sys_MarkMapModified();
|
|
mapModified = 1;
|
|
|
|
Undo_End();
|
|
}
|
|
|
|
//
|
|
// =======================================================================================================================
|
|
// Map_ImportFile
|
|
// =======================================================================================================================
|
|
//
|
|
void Map_ImportFile(char *fileName) {
|
|
char *buf;
|
|
idStr temp;
|
|
Sys_BeginWait();
|
|
temp = fileName;
|
|
temp.BackSlashesToSlashes();
|
|
if (LoadFile( temp, (void **) &buf) != -1) {
|
|
Map_ImportBuffer(buf);
|
|
Mem_Free( buf );
|
|
Map_BuildBrushData();
|
|
}
|
|
|
|
Sys_UpdateWindows(W_ALL);
|
|
mapModified = 1;
|
|
Sys_EndWait();
|
|
}
|
|
|
|
//
|
|
// =======================================================================================================================
|
|
// Map_SaveSelected Saves selected world brushes and whole entities with partial/full selections
|
|
// =======================================================================================================================
|
|
//
|
|
void Map_SaveSelected(char *fileName) {
|
|
entity_t *e, *next;
|
|
FILE *f;
|
|
idStr temp;
|
|
int count;
|
|
|
|
temp = fileName;
|
|
temp.BackSlashesToSlashes();
|
|
f = fopen(temp, "w");
|
|
|
|
if ( !f ) {
|
|
common->Printf( "ERROR!!!! Couldn't open %s\n", temp.c_str() );
|
|
return;
|
|
}
|
|
|
|
// write version
|
|
g_qeglobals.mapVersion = MAP_VERSION;
|
|
fprintf( f, "Version %1.2f\n", MAP_VERSION );
|
|
|
|
// write world entity second
|
|
world_entity->origin.Zero();
|
|
Entity_WriteSelected( world_entity, f );
|
|
|
|
// then write all other ents
|
|
count = 1;
|
|
for ( e = entities.next; e != &entities; e = next ) {
|
|
fprintf( f, "// entity %i\n", count );
|
|
count++;
|
|
Entity_WriteSelected( e, f );
|
|
next = e->next;
|
|
}
|
|
|
|
fclose( f );
|
|
}
|
|
|
|
//
|
|
// =======================================================================================================================
|
|
// Map_SaveSelected Saves selected world brushes and whole entities with partial/full selections
|
|
// =======================================================================================================================
|
|
//
|
|
void Map_SaveSelected(CMemFile *pMemFile, CMemFile *pPatchFile) {
|
|
entity_t *e, *next;
|
|
int count;
|
|
CString strTemp;
|
|
|
|
// write version
|
|
g_qeglobals.mapVersion = MAP_VERSION;
|
|
MemFile_fprintf(pMemFile, "Version %1.2f\n", MAP_VERSION);
|
|
|
|
// write world entity first
|
|
world_entity->origin.Zero();
|
|
Entity_WriteSelected(world_entity, pMemFile);
|
|
|
|
// then write all other ents
|
|
count = 1;
|
|
for (e = entities.next; e != &entities; e = next) {
|
|
MemFile_fprintf(pMemFile, "// entity %i\n", count);
|
|
count++;
|
|
Entity_WriteSelected(e, pMemFile);
|
|
next = e->next;
|
|
}
|
|
|
|
// if (pPatchFile) Patch_WriteFile(pPatchFile);
|
|
}
|
|
|
|
/*
|
|
=======================================================================================================================
|
|
=======================================================================================================================
|
|
*/
|
|
|
|
/*
|
|
================
|
|
WriteFileString
|
|
================
|
|
*/
|
|
bool WriteFileString( FILE *fp, char *string, ... ) {
|
|
long i;
|
|
unsigned long u;
|
|
double f;
|
|
char *str;
|
|
idStr buf;
|
|
va_list argPtr;
|
|
|
|
va_start( argPtr, string );
|
|
|
|
while( *string ) {
|
|
switch( *string ) {
|
|
case '%':
|
|
string++;
|
|
while ( (*string >= '0' && *string <= '9') ||
|
|
*string == '.' || *string == '-' || *string == '+' || *string == '#') {
|
|
string++;
|
|
}
|
|
switch( *string ) {
|
|
case 'f':
|
|
case 'e':
|
|
case 'E':
|
|
case 'g':
|
|
case 'G':
|
|
f = va_arg( argPtr, double );
|
|
sprintf( buf, "%1.10f", f );
|
|
buf.StripTrailing( '0' );
|
|
buf.StripTrailing( '.' );
|
|
fprintf( fp, "%s", buf.c_str() );
|
|
break;
|
|
case 'd':
|
|
case 'i':
|
|
i = va_arg( argPtr, long );
|
|
fprintf( fp, "%d", i );
|
|
break;
|
|
case 'u':
|
|
u = va_arg( argPtr, unsigned long );
|
|
fprintf( fp, "%u", u );
|
|
break;
|
|
case 'o':
|
|
u = va_arg( argPtr, unsigned long );
|
|
fprintf( fp, "%o", u );
|
|
break;
|
|
case 'x':
|
|
u = va_arg( argPtr, unsigned long );
|
|
fprintf( fp, "%x", u );
|
|
break;
|
|
case 'X':
|
|
u = va_arg( argPtr, unsigned long );
|
|
fprintf( fp, "%X", u );
|
|
break;
|
|
case 'c':
|
|
i = va_arg( argPtr, long );
|
|
fprintf( fp, "%c", (char) i );
|
|
break;
|
|
case 's':
|
|
str = va_arg( argPtr, char * );
|
|
fprintf( fp, "%s", str );
|
|
break;
|
|
case '%':
|
|
fprintf( fp, "%%" );
|
|
break;
|
|
default:
|
|
common->Error( "WriteFileString: invalid %%%c", *string );
|
|
break;
|
|
}
|
|
string++;
|
|
break;
|
|
case '\\':
|
|
string++;
|
|
switch( *string ) {
|
|
case 't':
|
|
fprintf( fp, "\t" );
|
|
break;
|
|
case 'n':
|
|
fprintf( fp, "\n" );
|
|
default:
|
|
common->Error( "WriteFileString: unknown escape character \'%c\'", *string );
|
|
break;
|
|
}
|
|
string++;
|
|
break;
|
|
default:
|
|
fprintf( fp, "%c", *string );
|
|
string++;
|
|
break;
|
|
}
|
|
}
|
|
|
|
va_end( argPtr );
|
|
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
================
|
|
MemFile_fprintf
|
|
================
|
|
*/
|
|
void MemFile_fprintf( CMemFile *pMemFile, const char *string, ... ) {
|
|
char Buffer[4096];
|
|
long i;
|
|
unsigned long u;
|
|
double f;
|
|
char *str;
|
|
idStr buf, out;
|
|
va_list argPtr;
|
|
|
|
char *buff = Buffer;
|
|
|
|
va_start( argPtr, string );
|
|
|
|
while( *string ) {
|
|
switch( *string ) {
|
|
case '%':
|
|
string++;
|
|
while ( (*string >= '0' && *string <= '9') ||
|
|
*string == '.' || *string == '-' || *string == '+' || *string == '#') {
|
|
string++;
|
|
}
|
|
switch( *string ) {
|
|
case 'f':
|
|
case 'e':
|
|
case 'E':
|
|
case 'g':
|
|
case 'G':
|
|
f = va_arg( argPtr, double );
|
|
sprintf( buf, "%1.10f", f );
|
|
buf.StripTrailing( '0' );
|
|
buf.StripTrailing( '.' );
|
|
sprintf( buff, "%s", buf.c_str() );
|
|
break;
|
|
case 'd':
|
|
case 'i':
|
|
i = va_arg( argPtr, long );
|
|
sprintf( buff, "%d", i );
|
|
break;
|
|
case 'u':
|
|
u = va_arg( argPtr, unsigned long );
|
|
sprintf( buff, "%u", u );
|
|
break;
|
|
case 'o':
|
|
u = va_arg( argPtr, unsigned long );
|
|
sprintf( buff, "%o", u );
|
|
break;
|
|
case 'x':
|
|
u = va_arg( argPtr, unsigned long );
|
|
sprintf( buff, "%x", u );
|
|
break;
|
|
case 'X':
|
|
u = va_arg( argPtr, unsigned long );
|
|
sprintf( buff, "%X", u );
|
|
break;
|
|
case 'c':
|
|
i = va_arg( argPtr, long );
|
|
sprintf( buff, "%c", (char) i );
|
|
break;
|
|
case 's':
|
|
str = va_arg( argPtr, char * );
|
|
sprintf( buff, "%s", str );
|
|
break;
|
|
case '%':
|
|
sprintf( buff, "%%" );
|
|
break;
|
|
default:
|
|
common->Error( "MemFile_fprintf: invalid %%%c", *string );
|
|
break;
|
|
}
|
|
string++;
|
|
break;
|
|
case '\\':
|
|
string++;
|
|
switch( *string ) {
|
|
case 't':
|
|
sprintf( buff, "\t" );
|
|
break;
|
|
case 'n':
|
|
sprintf( buff, "\n" );
|
|
default:
|
|
common->Error( "MemFile_fprintf: unknown escape character \'%c\'", *string );
|
|
break;
|
|
}
|
|
string++;
|
|
break;
|
|
default:
|
|
sprintf( buff, "%c", *string );
|
|
string++;
|
|
break;
|
|
}
|
|
|
|
buff = Buffer + strlen(Buffer);
|
|
}
|
|
|
|
va_end( argPtr );
|
|
|
|
out = Buffer;
|
|
pMemFile->Write( out.c_str(), out.Length() );
|
|
}
|