apply misc fixes from Markus Fischer and Rambetter
[xonotic/netradiant.git] / radiant / map.cpp
1 /*
2 Copyright (C) 1999-2007 id Software, Inc. and contributors.
3 For a list of contributors, see the accompanying CONTRIBUTORS file.
4
5 This file is part of GtkRadiant.
6
7 GtkRadiant is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
11
12 GtkRadiant is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15 GNU General Public License for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with GtkRadiant; if not, write to the Free Software
19 Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
20 */
21
22 #include "stdafx.h"
23 #include <string.h>
24 #if defined (__linux__) || defined (__APPLE__)
25 #include <unistd.h>
26 #endif
27 #include "preferences.h"
28 #include "mainframe.h"
29 #include "gtkmisc.h"
30 #include "filters.h"
31
32 extern MainFrame* g_pParentWnd;
33
34 int     modified;       // for quit confirmation (0 = clean, 1 = unsaved,
35                                 // 2 = autosaved, but not regular saved)
36
37 char            currentmap[1024];
38
39 brush_t active_brushes;         // brushes currently being displayed
40 brush_t selected_brushes;       // highlighted
41
42 face_t  *selected_face;
43 brush_t *selected_face_brush;
44
45 brush_t filtered_brushes;       // brushes that have been filtered or regioned
46
47 entity_t        entities;               // head/tail of doubly linked list
48
49 entity_t        *world_entity = NULL; // "classname" "worldspawn" !
50
51 void Map_Init()
52 {
53   Map_Free();
54 }
55
56
57 bool  g_bCancel_Map_LoadFile; // Hydra: moved this here
58
59 // TTimo
60 // need that in a variable, will have to tweak depending on the game
61 int g_MaxWorldCoord = 64*1024;
62 int g_MinWorldCoord = -64*1024;
63
64 // the max size we allow on brushes, this is dependant on world coords too
65 // makes more sense to say smaller I think?
66 int g_MaxBrushSize = (g_MaxWorldCoord-1)*2;
67
68 void AddRegionBrushes (void);
69 void RemoveRegionBrushes (void);
70
71 /*
72 =============================================================
73
74   Cross map selection saving
75
76   this could fuck up if you have only part of a complex entity selected...
77 =============================================================
78 */
79
80 brush_t         between_brushes;
81 entity_t        between_entities;
82
83 bool g_bRestoreBetween = false;
84
85 void Map_SaveBetween (void)
86 {
87   if (g_pParentWnd->ActiveXY())
88   {
89     g_bRestoreBetween = true;
90     g_pParentWnd->ActiveXY()->Copy();
91   }
92   return;
93 }
94
95 void Map_RestoreBetween (void)
96 {
97   if (g_pParentWnd->ActiveXY() && g_bRestoreBetween)
98     g_pParentWnd->ActiveXY()->Paste();
99 }
100
101 //============================================================================
102
103 bool CheckForTinyBrush(brush_t* b, int n, float fSize)
104 {
105   bool bTiny = false;
106         for (int i=0 ; i<3 ; i++)
107         {
108     if (b->maxs[i] - b->mins[i] < fSize)
109       bTiny = true;
110   }
111   if (bTiny)
112     Sys_Printf("Possible problem brush (too small) #%i ", n);
113   return bTiny;
114 }
115
116 void Map_BuildBrushData(void)
117 {
118   brush_t *b, *next;
119
120   if (active_brushes.next == NULL)
121     return;
122
123   Sys_BeginWait ();     // this could take a while
124
125   int n = 0;
126   for (b=active_brushes.next ; b != NULL && b != &active_brushes ; b=next)
127   {
128     next = b->next;
129     Brush_Build( b, true, false, false );
130     if (!b->brush_faces || (g_PrefsDlg.m_bCleanTiny && CheckForTinyBrush(b, n++, g_PrefsDlg.m_fTinySize)))
131     {
132       Brush_Free (b);
133       Sys_Printf ("Removed degenerate brush\n");
134     }
135   }
136   Sys_EndWait();
137 }
138
139 entity_t *Map_FindClass (const char *cname)
140 {
141         entity_t        *ent;
142
143         for (ent = entities.next ; ent != &entities ; ent=ent->next)
144         {
145                 if (!strcmp(cname, ValueForKey (ent, "classname")))
146                         return ent;
147         }
148         return NULL;
149 }
150
151 /*
152 ================
153 Map_Free
154 free all map elements, reinitialize the structures that depend on them
155 ================
156 */
157 void Map_Free (void)
158 {
159   g_bRestoreBetween = false;
160   if (selected_brushes.next &&
161       (selected_brushes.next != &selected_brushes))
162     {
163       if (gtk_MessageBox (g_pParentWnd->m_pWidget, "Copy selection?", " ", MB_YESNO) == IDYES)
164         Map_SaveBetween ();
165     }
166
167         QERApp_ActiveShaders_SetInUse( false );
168         Pointfile_Clear ();
169         g_qeglobals.d_num_entities = 0;
170
171         if (!active_brushes.next)
172         {
173           // first map
174           active_brushes.prev = active_brushes.next = &active_brushes;
175           selected_brushes.prev = selected_brushes.next = &selected_brushes;
176           filtered_brushes.prev = filtered_brushes.next = &filtered_brushes;
177           entities.prev = entities.next = &entities;
178         }
179         else
180         {
181           // free selected faces array
182           g_ptrSelectedFaces.RemoveAll();
183           g_ptrSelectedFaceBrushes.RemoveAll();
184                 while (active_brushes.next != &active_brushes)
185                         Brush_Free (active_brushes.next);
186                 while (selected_brushes.next != &selected_brushes)
187                         Brush_Free (selected_brushes.next);
188                 while (filtered_brushes.next != &filtered_brushes)
189                         Brush_Free (filtered_brushes.next);
190                 while (entities.next != &entities)
191                         Entity_Free (entities.next);
192         }
193
194   if (world_entity)
195     Entity_Free(world_entity);
196         world_entity = NULL;
197 }
198
199 entity_t *AngledEntity()
200 {
201   entity_t *ent = Map_FindClass ("info_player_start");
202         if (!ent)
203   {
204                 ent = Map_FindClass ("info_player_deathmatch");
205   }
206   if (!ent)
207   {
208                 ent = Map_FindClass ("info_player_deathmatch");
209   }
210   if (!ent)
211   {
212     ent = Map_FindClass ("team_CTF_redplayer");
213   }
214   if (!ent)
215   {
216     ent = Map_FindClass ("team_CTF_blueplayer");
217   }
218   if (!ent)
219   {
220     ent = Map_FindClass ("team_CTF_redspawn");
221   }
222   if (!ent)
223   {
224     ent = Map_FindClass ("team_CTF_bluespawn");
225   }
226   return ent;
227 }
228
229 //
230 // move the view to a start position
231 //
232 void Map_StartPosition()
233 {
234   entity_t *ent = AngledEntity();
235
236   g_pParentWnd->GetCamWnd()->Camera()->angles[PITCH] = 0;
237   if (ent)
238   {
239     GetVectorForKey (ent, "origin", g_pParentWnd->GetCamWnd()->Camera()->origin);
240     GetVectorForKey (ent, "origin", g_pParentWnd->GetXYWnd()->GetOrigin());
241     g_pParentWnd->GetCamWnd()->Camera()->angles[YAW] = FloatForKey (ent, "angle");
242   }
243   else
244   {
245     g_pParentWnd->GetCamWnd()->Camera()->angles[YAW] = 0;
246     VectorCopy (vec3_origin, g_pParentWnd->GetCamWnd()->Camera()->origin);
247     VectorCopy (vec3_origin, g_pParentWnd->GetXYWnd()->GetOrigin());
248   }
249 }
250
251 void Map_FreeEntities(CPtrArray *ents)
252 {
253   int i, j, num_ents, num_brushes;
254   entity_t* e;
255   CPtrArray* brushes;
256
257   num_ents = ents->GetSize();
258   for(i=0; i<num_ents; i++)
259   {
260     e = (entity_t*)ents->GetAt(i);
261     brushes = (CPtrArray*)e->pData;
262     num_brushes = brushes->GetSize();
263     for(j=0; j<num_brushes; j++)
264       Brush_Free((brush_t*)brushes->GetAt(j));
265     brushes->RemoveAll();
266     delete (CPtrArray*)e->pData;
267     e->pData = NULL;
268     Entity_Free(e);
269   }
270   ents->RemoveAll();
271 }
272
273 /*!\todo Possibly make the import Undo-friendly by calling Undo_End for new brushes and ents */
274 void Map_ImportEntities(CPtrArray *ents, bool bAddSelected = false)
275 {
276   int num_ents, num_brushes;
277   CPtrArray *brushes;
278   vec3_t mins, maxs;
279   entity_t *e;
280   brush_t *b;
281   face_t *f;
282   int i,j;
283
284   GPtrArray *new_ents = g_ptr_array_new();
285
286   g_qeglobals.bPrimitBrushes = false;
287
288   brush_t *pBrushList = (bAddSelected) ? &selected_brushes : &active_brushes;
289
290   bool bDoneBPCheck = false;
291   g_qeglobals.bNeedConvert = false;
292   // HACK: find out if this map file was a BP one
293   // check the first brush in the file that is NOT a patch
294   // this will not be necessary when we allow both formats in the same file
295   num_ents = ents->GetSize();
296   for(i=0; !bDoneBPCheck && i<num_ents; i++)
297   {
298     e = (entity_t*)ents->GetAt(i);
299     brushes = (CPtrArray*)e->pData;
300     num_brushes = brushes->GetSize();
301     for(j=0; !bDoneBPCheck && j<num_brushes; j++)
302     {
303       /*!todo Allow mixing texdef formats per-face. */
304       b = (brush_t *)brushes->GetAt(j);
305       if(b->patchBrush) continue;
306       bDoneBPCheck = true;
307       int BP_param = -1;
308       if(b->bBrushDef && !g_qeglobals.m_bBrushPrimitMode)
309         BP_param = 0;
310       else if(!b->bBrushDef && g_qeglobals.m_bBrushPrimitMode)
311         BP_param = 1;
312
313       if(BP_param != -1)
314       {
315         switch(BP_MessageBox(BP_param))
316         {
317         case 0:
318           Map_FreeEntities(ents);
319           return;
320         case 1:
321           g_qeglobals.bNeedConvert = true;
322           break;
323         case 2:
324           g_qeglobals.bNeedConvert = false;
325           break;
326         }
327       }
328     }
329   }
330
331   // process the entities into the world geometry
332   num_ents = ents->GetSize();
333   for(i=0; i<num_ents; i++)
334   {
335     num_brushes = 0;
336     e = (entity_t*)ents->GetAt(i);
337     brushes = (CPtrArray*)e->pData;
338
339     num_brushes = brushes->GetSize();
340     // link brushes into entity
341     for(j=0; j<num_brushes; j++)
342     {
343       Entity_LinkBrush(e, (brush_t *)brushes->GetAt(j));
344       g_qeglobals.d_parsed_brushes++;
345     }
346     brushes->RemoveAll();
347     delete brushes;
348     e->pData = NULL;
349
350     // set entity origin
351     GetVectorForKey (e, "origin", e->origin);
352     // set entity eclass
353     /*!\todo Make SetKeyValue check for "classname" change and assign appropriate eclass */
354     e->eclass = Eclass_ForName (ValueForKey (e, "classname"),
355       (e->brushes.onext != &e->brushes));
356
357     // go through all parsed brushes and build stuff
358     for(b = e->brushes.onext; b!=&e->brushes; b=b->onext)
359     {
360       for(f = b->brush_faces; f != NULL; f = f->next)
361       {
362         f->pShader = QERApp_Shader_ForName(f->texdef.GetName());
363         f->d_texture = f->pShader->getTexture();
364       }
365
366       // when brushes are in final state, build the planes and windings
367       // NOTE: also converts BP brushes if g_qeglobals.bNeedConvert is true
368       Brush_Build(b);
369     }
370
371 //#define TERRAIN_HACK
372 #undef TERRAIN_HACK
373
374 #ifdef TERRAIN_HACK
375     if ((strcmp(ValueForKey(e, "terrain"),"1") == 0 && strcmp(e->eclass->name,"func_group") == 0))
376     {
377
378       // two aux pointers to the shaders used in the terrain entity
379       // we don't keep refcount on them since they are only temporary
380       // this avoids doing expensive lookups by name for all faces
381       IShader *pTerrainShader, *pCaulk;
382
383       pTerrainShader = NULL;
384       pCaulk = QERApp_Shader_ForName(SHADER_CAULK);
385
386       for(b = e->brushes.onext; b!=&e->brushes; b=b->onext)
387       {
388         if (pTerrainShader == NULL)
389           for(f = b->brush_faces; f != NULL; f = f->next)
390             if (strcmp(f->texdef.GetName(), SHADER_CAULK)!=0)
391               pTerrainShader = f->pShader;
392
393             if (pTerrainShader)
394             {
395               for(f = b->brush_faces; f != NULL; f = f->next)
396               {
397                 if (strcmp(f->texdef.GetName(), SHADER_CAULK)!=0) // not caulk
398                   Face_SetShader(f, pTerrainShader->getName());
399                 else
400                   Face_SetShader(f, pCaulk->getName());
401               }
402             }
403             else
404               Sys_Printf("WARNING: no terrain shader found for brush\n");
405       }
406     }
407 #endif
408
409 #define PATCH_HACK
410 #ifdef PATCH_HACK
411     for(b = e->brushes.onext; b!=&e->brushes; b=b->onext)
412     {
413       // patch hack, to be removed when dependency on brush_faces is removed
414       if (b->patchBrush)
415       {
416         Patch_CalcBounds(b->pPatch, mins, maxs);
417         for (int i=0; i<3; i++)
418         {
419           if ((int)mins[i] == (int)maxs[i])
420           {
421             mins[i] -= 4;
422             maxs[i] += 4;
423           }
424         }
425         Brush_Resize(b, mins, maxs);
426         Brush_Build(b);
427       }
428     }
429 #endif
430     // add brush for fixedsize entity
431     if (e->eclass->fixedsize)
432     {
433       vec3_t mins, maxs;
434       VectorAdd (e->eclass->mins, e->origin, mins);
435       VectorAdd (e->eclass->maxs, e->origin, maxs);
436       b = Brush_Create (mins, maxs, &e->eclass->texdef);
437       Entity_LinkBrush(e, b);
438       Brush_Build(b);
439     }
440
441     for(b = e->brushes.onext; b!=&e->brushes; b=b->onext)
442       Brush_AddToList(b, pBrushList);
443
444     if (strcmp(e->eclass->name, "worldspawn") == 0)
445     {
446       if (world_entity)
447       {
448         while(e->brushes.onext != &e->brushes)
449         {
450           b = e->brushes.onext;
451           Entity_UnlinkBrush(b);
452           Entity_LinkBrush(world_entity, b);
453         }
454         Entity_Free(e);
455       }
456       else
457       {
458         world_entity = e;
459       }
460     }
461     else if (strcmp(e->eclass->name, "group_info") == 0)
462     {
463       // it's a group thing!
464       Group_Add(e);
465       Entity_Free(e);
466     }
467     else
468     {
469       // fix target/targetname collisions
470       if ((g_PrefsDlg.m_bDoTargetFix) && (strcmp(ValueForKey(e, "target"), "") != 0))
471       {
472         GPtrArray *t_ents = g_ptr_array_new();
473         entity_t *e_target;
474         const char *target = ValueForKey(e, "target");
475         qboolean bCollision=FALSE;
476
477         // check the current map entities for an actual collision
478         for (e_target = entities.next; e_target != &entities; e_target = e_target->next)
479         {
480           if(!strcmp(target, ValueForKey(e_target, "target")))
481           {
482             bCollision = TRUE;
483             // make sure the collision is not between two imported entities
484             for(j=0; j<(int)new_ents->len; j++)
485             {
486               if(e_target == g_ptr_array_index(new_ents, j))
487                 bCollision = FALSE;
488             }
489           }
490         }
491
492         // find the matching targeted entity(s)
493         if(bCollision)
494         {
495           for(j=num_ents-1; j>0; j--)
496           {
497             e_target = (entity_t*)ents->GetAt(j);
498             if(e_target != NULL && e_target != e)
499             {
500               const char *targetname = ValueForKey(e_target, "targetname");
501               if( (targetname != NULL) && (strcmp(target, targetname) == 0) )
502                 g_ptr_array_add(t_ents, (gpointer)e_target);
503             }
504           }
505           if(t_ents->len > 0)
506           {
507             // link the first to get a unique target/targetname
508             Entity_Connect(e, (entity_t*)g_ptr_array_index(t_ents,0));
509             // set the targetname of the rest of them manually
510             for(j = 1; j < (int)t_ents->len; j++)
511               SetKeyValue( (entity_t*)g_ptr_array_index(t_ents, j), "targetname", ValueForKey(e, "target") );
512           }
513           g_ptr_array_free(t_ents, FALSE);
514         }
515       }
516
517       // add the entity to the end of the entity list
518       Entity_AddToList(e, &entities);
519       g_qeglobals.d_num_entities++;
520
521       // keep a list of ents added to avoid testing collisions against them
522       g_ptr_array_add(new_ents, (gpointer)e);
523     }
524   }
525   g_ptr_array_free(new_ents, FALSE);
526
527   ents->RemoveAll();
528
529   g_qeglobals.bNeedConvert = false;
530 }
531
532 void Map_Import(IDataStream *in, const char *type, bool bAddSelected)
533 {
534   CPtrArray ents;
535
536   g_pParentWnd->GetSynapseClient().ImportMap(in, &ents, type);
537   Map_ImportEntities(&ents, bAddSelected);
538 }
539
540 /*
541 ================
542 Map_LoadFile
543 ================
544 */
545 void Map_LoadFile (const char *filename)
546 {
547   clock_t start, finish;
548   double elapsed_time;
549   start = clock();
550
551   Sys_BeginWait ();
552   Select_Deselect();
553   /*!
554   \todo FIXME TTimo why is this commented out?
555   stability issues maybe? or duplicate feature?
556   forcing to show the console during map load was a good thing IMO
557   */
558   //SetInspectorMode(W_CONSOLE);
559   Sys_Printf ("Loading map from %s\n", filename );
560
561   Map_Free ();
562   //++timo FIXME: maybe even easier to have Group_Init called from Map_Free?
563   Group_Init();
564   g_qeglobals.d_num_entities = 0;
565   g_qeglobals.d_parsed_brushes = 0;
566
567
568   // cancel the map loading process
569   // used when conversion between standard map format and BP format is required and the user cancels the process
570   g_bCancel_Map_LoadFile = false;
571
572   strcpy (currentmap, filename);
573
574   g_bScreenUpdates = false; // leo: avoid redraws while loading the map (see fenris:1952)
575
576   // prepare to let the map module do the parsing
577   FileStream file;
578   const char* type = strrchr(filename,'.');
579   if(type!=NULL) type++;
580     // NOTE TTimo opening has binary doesn't make a lot of sense
581   // but opening as text confuses the scriptlib parser
582   // this may be a problem if we "rb" and use the XML parser, might have an incompatibility
583   if (file.Open(filename, "rb"))
584     Map_Import(&file, type);
585   else
586     Sys_FPrintf(SYS_ERR, "ERROR: failed to open %s for read\n", filename);
587   file.Close();
588
589   g_bScreenUpdates = true;
590
591   if (g_bCancel_Map_LoadFile)
592   {
593     Sys_Printf("Map_LoadFile canceled\n");
594     Map_New();
595     Sys_EndWait();
596     return;
597   }
598
599   if (!world_entity)
600   {
601     Sys_Printf ("No worldspawn in map.\n");
602     Map_New ();
603     Sys_EndWait();
604     return;
605   }
606   finish = clock();
607   elapsed_time = (double)(finish - start) / CLOCKS_PER_SEC;
608
609   Sys_Printf ("--- LoadMapFile ---\n");
610   Sys_Printf ("%s\n", filename );
611
612   Sys_Printf ("%5i brushes\n",  g_qeglobals.d_parsed_brushes );
613   Sys_Printf ("%5i entities\n", g_qeglobals.d_num_entities);
614   Sys_Printf ("%5.2f second(s) load time\n", elapsed_time );
615
616   Sys_EndWait();
617
618   Map_RestoreBetween ();
619
620   //
621   // move the view to a start position
622   //
623   Map_StartPosition();
624
625   Map_RegionOff ();
626
627   modified = false;
628   Sys_SetTitle (filename);
629
630   Texture_ShowInuse ();
631   QERApp_SortActiveShaders();
632
633   Sys_UpdateWindows (W_ALL);
634 }
635
636 /*!
637 ===========
638 Supporting functions for Map_SaveFile, builds a CPtrArray with the filtered / non filtered brushes
639 ===========
640 */
641 void CleanFilter(entity_t *ent)
642 {
643   if (ent->pData)
644   {
645     delete static_cast<CPtrArray*>(ent->pData);
646     ent->pData = NULL;
647   }
648 }
649
650 /*!
651 filters out the region brushes if necessary
652 returns true if this entity as a whole is out of the region
653 (if all brushes are filtered out, then the entity will be completely dropped .. except if it's worldspawn of course)
654 */
655 bool FilterChildren(entity_t *ent, bool bRegionOnly = false, bool bSelectedOnly = false)
656 {
657   if(ent->brushes.onext == &ent->brushes)
658     return false;
659   // entity without a brush, ignore it... this can be caused by Undo
660
661   // filter fixedsize ents by their eclass bounding box
662   // don't add their brushes
663   if (ent->eclass->fixedsize)
664   {
665     if(bSelectedOnly && !IsBrushSelected(ent->brushes.onext))
666       return false;
667
668     if(bRegionOnly && region_active)
669     {
670       for (int i=0 ; i<3 ; i++)
671             {
672                     if ((ent->origin[i] + ent->eclass->mins[i]) > region_maxs[i])
673                             return false;
674                     if ((ent->origin[i] + ent->eclass->maxs[i]) < region_mins[i])
675                             return false;
676             }
677     }
678   }
679   else
680   {
681     for (brush_t *b = ent->brushes.onext ; b != &ent->brushes ; b=b->onext)
682     {
683       // set flag to use brushprimit_texdef
684       if(g_qeglobals.m_bBrushPrimitMode)
685         b->bBrushDef = true;
686       else
687         b->bBrushDef = false;
688
689       // add brush, unless it's excluded by region
690       if ( !(bRegionOnly && Map_IsBrushFiltered(b)) &&
691            !(bSelectedOnly && !IsBrushSelected(b)) )
692         ((CPtrArray*)ent->pData)->Add(b);
693     }
694
695     if (((CPtrArray*)ent->pData)->GetSize() <= 0)
696       return false;
697   }
698   return true;
699 }
700
701 entity_t *region_startpoint = NULL;
702 void Map_ExportEntities(CPtrArray* ents, bool bRegionOnly = false, bool bSelectedOnly = false)
703 {
704   int i;
705   entity_t *e;
706
707   /*!
708   \todo the entity_t needs to be reworked and asbtracted some more
709
710   keeping the entity_t as the struct providing access to a list of map objects, a list of epairs and various other info?
711   but separating some more the data that belongs to the entity_t and the 'sons' data
712   on a side note, I don't think that doing that with linked list would be a good thing
713
714   for now, we use the blind void* in entity_t casted to a CPtrArray of brush_t* to hand out a list of the brushes for map write
715   the next step is very likely to be a change of the brush_t* to a more abstract object?
716   */
717
718   FilterChildren(world_entity, bRegionOnly, bSelectedOnly);
719   ents->Add(world_entity);
720
721   for (e=entities.next ; e!=&entities ; e=e->next)
722   {
723     // not sure this still happens, probably safe to leave it in
724     if ((!strcmp(ValueForKey (e, "classname"), "worldspawn")) && (e!=world_entity))
725     {
726       Sys_FPrintf(SYS_ERR, "Dropping parasite worldspawn entity\n");
727       continue;
728     }
729
730     // entities which brushes are completely filtered out by regioning are not printed to the map
731     if (FilterChildren(e, bRegionOnly, bSelectedOnly))
732       ents->Add(e);
733   }
734
735   if (bRegionOnly && region_active)
736   {
737     for(i=0; i<6; i++)
738       ((CPtrArray*)world_entity->pData)->Add(region_sides[i]);
739
740     ents->Add(region_startpoint);
741   }
742 }
743
744 void Map_Export(IDataStream *out, const char *type, bool bRegionOnly, bool bSelectedOnly)
745 {
746   entity_t      *e;
747
748   CPtrArray ents;
749
750   if (bRegionOnly && region_active)
751     AddRegionBrushes();
752
753   // create the filters
754   world_entity->pData = new CPtrArray();
755   for(e = entities.next; e != &entities; e = e->next)
756     e->pData = new CPtrArray();
757
758   Map_ExportEntities(&ents, bRegionOnly, bSelectedOnly);
759
760   g_pParentWnd->GetSynapseClient().ExportMap(&ents, out, type);
761
762   // cleanup the filters
763   CleanFilter(world_entity);
764   for (e=entities.next ; e!=&entities ; e=e->next)
765     CleanFilter(e);
766
767   if (bRegionOnly && region_active)
768     RemoveRegionBrushes();
769 }
770
771 const char* filename_get_extension(const char* filename)
772 {
773   const char* type = strrchr(filename,'.');
774   if(type != NULL)
775     return ++type;
776   return "";
777 }
778
779 /*
780 ===========
781 Map_SaveFile
782 \todo FIXME remove the use_region, this is broken .. work with a global flag to set region mode or not
783 ===========
784 */
785 void Map_SaveFile (const char *filename, qboolean use_region )
786 {
787   clock_t start, finish;
788   double elapsed_time;
789   start = clock();
790   Sys_Printf("Saving map to %s\n",filename);
791
792         Pointfile_Clear ();
793
794         if (!use_region)
795         {
796                 char    backup[1024];
797
798                 // rename current to .bak
799                 strcpy (backup, filename);
800                 StripExtension (backup);
801                 strcat (backup, ".bak");
802                 unlink (backup);
803                 rename (filename, backup);
804         }
805
806         Sys_Printf ("Map_SaveFile: %s\n", filename);
807
808   // build the out data stream
809   FileStream file;
810   if (!file.Open(filename,"w"))
811   {
812     Sys_FPrintf(SYS_ERR, "ERROR: couldn't open %s for write\n", filename);
813     return;
814   }
815
816   // extract filetype
817   Map_Export(&file, filename_get_extension(filename), use_region);
818
819   file.Close();
820
821   finish = clock();
822   elapsed_time = (double)(finish - start) / CLOCKS_PER_SEC;
823
824   Sys_Printf ("Saved in %-.2f second(s).\n",elapsed_time);
825         modified = false;
826
827         if ( !strstr( filename, "autosave" ) )
828                 Sys_SetTitle (filename);
829
830         if (!use_region)
831         {
832                 time_t  timer;
833
834                 time (&timer);
835
836     Sys_Beep ();
837
838                 Sys_Status ("Saved.", 0);
839         }
840 }
841
842 /*
843 ===========
844 Map_New
845
846 ===========
847 */
848 void Map_New (void)
849 {
850         Sys_Printf ("Map_New\n");
851         Map_Free ();
852
853         strcpy (currentmap, "unnamed.map");
854         Sys_SetTitle (currentmap);
855
856   world_entity = (entity_s*)qmalloc(sizeof(*world_entity));
857         world_entity->brushes.onext =
858                 world_entity->brushes.oprev = &world_entity->brushes;
859         SetKeyValue (world_entity, "classname", "worldspawn");
860         world_entity->eclass = Eclass_ForName ("worldspawn", true);
861
862         g_pParentWnd->GetCamWnd()->Camera()->angles[YAW] = 0;
863         g_pParentWnd->GetCamWnd()->Camera()->angles[PITCH] = 0;
864         VectorCopy (vec3_origin, g_pParentWnd->GetCamWnd()->Camera()->origin);
865         g_pParentWnd->GetCamWnd()->Camera()->origin[2] = 48;
866         VectorCopy (vec3_origin, g_pParentWnd->GetXYWnd()->GetOrigin());
867
868         Map_RestoreBetween ();
869
870   Group_Init();
871
872         Sys_UpdateWindows (W_ALL);
873         modified = false;
874 }
875
876 /*
877 ===========================================================
878
879   REGION
880
881 ===========================================================
882 */
883 qboolean        region_active;
884 vec3_t  region_mins = {g_MinWorldCoord, g_MinWorldCoord, g_MinWorldCoord};
885 vec3_t  region_maxs = {g_MaxWorldCoord, g_MaxWorldCoord, g_MaxWorldCoord};
886
887 brush_t *region_sides[6];
888
889 /*
890 ===========
891 AddRegionBrushes
892 a regioned map will have temp walls put up at the region boundary
893 \todo TODO TTimo old implementation of region brushes
894   we still add them straight in the worldspawn and take them out after the map is saved
895   with the new implementation we should be able to append them in a temporary manner to the data we pass to the map module
896 ===========
897 */
898 void AddRegionBrushes (void)
899 {
900         vec3_t  mins, maxs;
901         int             i;
902         texdef_t        td;
903
904         if (!region_active)
905   {
906 #ifdef _DEBUG
907     Sys_FPrintf( SYS_WRN, "Unexpected AddRegionBrushes call.\n");
908 #endif
909                 return;
910   }
911
912         memset (&td, 0, sizeof(td));
913         td.SetName(SHADER_NOT_FOUND);
914
915   // set mins
916   VectorSet(mins, region_mins[0]-32, region_mins[1]-32, region_mins[2]-32);
917
918   // vary maxs
919   for(i=0; i<3; i++)
920   {
921     VectorSet(maxs, region_maxs[0]+32, region_maxs[1]+32, region_maxs[2]+32);
922     maxs[i] = region_mins[i];
923     region_sides[i] = Brush_Create (mins, maxs, &td);
924   }
925
926   // set maxs
927   VectorSet(maxs, region_maxs[0]+32, region_maxs[1]+32, region_maxs[2]+32);
928
929   // vary mins
930   for(i=0; i<3; i++)
931   {
932     VectorSet(mins, region_mins[0]-32, region_mins[1]-32, region_mins[2]-32);
933     mins[i] = region_maxs[i];
934     region_sides[i+3] = Brush_Create (mins, maxs, &td);
935   }
936
937
938   // this is a safe check, but it should not really happen anymore
939   vec3_t vOrig;
940   VectorSet(vOrig,
941     (int)g_pParentWnd->GetCamWnd()->Camera()->origin[0],
942     (int)g_pParentWnd->GetCamWnd()->Camera()->origin[1],
943     (int)g_pParentWnd->GetCamWnd()->Camera()->origin[2]);
944
945   for (i=0 ; i<3 ; i++)
946   {
947     if (vOrig[i] > region_maxs[i] || vOrig[i] < region_mins[i])
948     {
949       Sys_FPrintf(SYS_ERR, "Camera is NOT in the region, it's likely that the region won't compile correctly\n");
950     }
951   }
952
953   // write the info_playerstart
954   region_startpoint = Entity_Alloc();
955   SetKeyValue(region_startpoint, "classname", "info_player_start");
956   region_startpoint->eclass = Eclass_ForName ("info_player_start", false);
957   char sTmp[1024];
958   sprintf(sTmp, "%d %d %d", (int)vOrig[0], (int)vOrig[1], (int)vOrig[2]);
959   SetKeyValue(region_startpoint, "origin", sTmp);
960   sprintf(sTmp, "%d", (int)g_pParentWnd->GetCamWnd()->Camera()->angles[YAW]);
961   SetKeyValue(region_startpoint, "angle", sTmp);
962   // empty array of children
963   region_startpoint->pData = new CPtrArray;
964 }
965
966 void RemoveRegionBrushes (void)
967 {
968         int             i;
969
970         if (!region_active)
971                 return;
972         for (i=0 ; i<6 ; i++)
973                 Brush_Free (region_sides[i]);
974
975   CleanFilter(region_startpoint);
976   Entity_Free(region_startpoint);
977 }
978
979 qboolean Map_IsBrushFiltered (brush_t *b)
980 {
981         int             i;
982
983         for (i=0 ; i<3 ; i++)
984         {
985                 if (b->mins[i] > region_maxs[i])
986                         return true;
987                 if (b->maxs[i] < region_mins[i])
988                         return true;
989         }
990         return false;
991 }
992
993 /*
994 ===========
995 Map_RegionOff
996
997 Other filtering options may still be on
998 ===========
999 */
1000 void Map_RegionOff (void)
1001 {
1002         brush_t *b, *next;
1003         int                     i;
1004
1005         region_active = false;
1006         for (i=0 ; i<3 ; i++)
1007         {
1008                 region_maxs[i] = g_MaxWorldCoord-64;
1009                 region_mins[i] = g_MinWorldCoord+64;
1010         }
1011
1012         for (b=filtered_brushes.next ; b != &filtered_brushes ; b=next)
1013         {
1014                 next = b->next;
1015                 if (Map_IsBrushFiltered (b))
1016                         continue;               // still filtered
1017                 Brush_RemoveFromList (b);
1018                 if (active_brushes.next == NULL || active_brushes.prev == NULL)
1019                 {
1020                         active_brushes.next = &active_brushes;
1021                         active_brushes.prev = &active_brushes;
1022                 }
1023                 Brush_AddToList (b, &active_brushes);
1024                 b->bFiltered = FilterBrush(b);
1025         }
1026         Sys_UpdateWindows (W_ALL);
1027 }
1028
1029 void Map_ApplyRegion (void)
1030 {
1031         brush_t *b, *next;
1032
1033         region_active = true;
1034         for (b=active_brushes.next ; b != &active_brushes ; b=next)
1035         {
1036                 next = b->next;
1037                 if (!Map_IsBrushFiltered (b))
1038                         continue;               // still filtered
1039                 Brush_RemoveFromList (b);
1040                 Brush_AddToList (b, &filtered_brushes);
1041         }
1042
1043         Sys_UpdateWindows (W_ALL);
1044 }
1045
1046
1047 /*
1048 ========================
1049 Map_RegionSelectedBrushes
1050 ========================
1051 */
1052 void Map_RegionSelectedBrushes (void)
1053 {
1054         Map_RegionOff ();
1055
1056         if (selected_brushes.next == &selected_brushes)  // nothing selected
1057   {
1058     Sys_Printf("Tried to region with no selection...\n");
1059     return;
1060   }
1061         region_active = true;
1062         Select_GetBounds (region_mins, region_maxs);
1063
1064 #ifdef _DEBUG
1065         if (filtered_brushes.next != &filtered_brushes)
1066                 Sys_Printf("WARNING: filtered_brushes list may not be empty in Map_RegionSelectedBrushes\n");
1067 #endif
1068
1069         if (active_brushes.next == &active_brushes)
1070         {
1071                 // just have an empty filtered_brushes list
1072                 // this happens if you set region after selecting all the brushes in your map (some weird people do that, ask MrE!)
1073                 filtered_brushes.next = filtered_brushes.prev = &filtered_brushes;
1074         }
1075         else
1076         {
1077                 // move the entire active_brushes list to filtered_brushes
1078                 filtered_brushes.next = active_brushes.next;
1079                 filtered_brushes.prev = active_brushes.prev;
1080                 filtered_brushes.next->prev = &filtered_brushes;
1081                 filtered_brushes.prev->next = &filtered_brushes;
1082         }
1083
1084         // move the entire selected_brushes list to active_brushes
1085         active_brushes.next = selected_brushes.next;
1086         active_brushes.prev = selected_brushes.prev;
1087         active_brushes.next->prev = &active_brushes;
1088         active_brushes.prev->next = &active_brushes;
1089
1090         // deselect patches
1091         for (brush_t *b = active_brushes.next; b != &active_brushes; b = b->next)
1092           if (b->patchBrush)
1093             b->pPatch->bSelected = false;
1094
1095         // clear selected_brushes
1096         selected_brushes.next = selected_brushes.prev = &selected_brushes;
1097
1098         Sys_UpdateWindows (W_ALL);
1099 }
1100
1101
1102 /*
1103 ===========
1104 Map_RegionXY
1105 ===========
1106 */
1107 void Map_RegionXY (void)
1108 {
1109         Map_RegionOff ();
1110
1111         region_mins[0] = g_pParentWnd->GetXYWnd()->GetOrigin()[0] - 0.5 * g_pParentWnd->GetXYWnd()->Width() / g_pParentWnd->GetXYWnd()->Scale();
1112         region_maxs[0] = g_pParentWnd->GetXYWnd()->GetOrigin()[0] + 0.5 * g_pParentWnd->GetXYWnd()->Width() / g_pParentWnd->GetXYWnd()->Scale();
1113         region_mins[1] = g_pParentWnd->GetXYWnd()->GetOrigin()[1] - 0.5 * g_pParentWnd->GetXYWnd()->Height() / g_pParentWnd->GetXYWnd()->Scale();
1114         region_maxs[1] = g_pParentWnd->GetXYWnd()->GetOrigin()[1] + 0.5 * g_pParentWnd->GetXYWnd()->Height() / g_pParentWnd->GetXYWnd()->Scale();
1115         region_mins[2] = g_MinWorldCoord+64;
1116         region_maxs[2] = g_MaxWorldCoord-64;
1117         Map_ApplyRegion ();
1118 }
1119
1120 /*
1121 ===========
1122 Map_RegionTallBrush
1123 ===========
1124 */
1125 void Map_RegionTallBrush (void)
1126 {
1127   brush_t *b;
1128
1129   if (!QE_SingleBrush ())
1130     return;
1131
1132   b = selected_brushes.next;
1133
1134   Map_RegionOff ();
1135
1136   VectorCopy (b->mins, region_mins);
1137   VectorCopy (b->maxs, region_maxs);
1138   region_mins[2] = g_MinWorldCoord+64;
1139   region_maxs[2] = g_MaxWorldCoord-64;
1140
1141   Undo_Start("delete");
1142   Undo_AddBrushList(&selected_brushes);
1143   Undo_AddEntity(b->owner);
1144   Select_Delete ();
1145   Undo_EndBrushList(&selected_brushes);
1146   Undo_End();
1147
1148   Map_ApplyRegion ();
1149 }
1150
1151 /*
1152 ===========
1153 Map_RegionBrush
1154 ===========
1155 */
1156 void Map_RegionBrush (void)
1157 {
1158   brush_t *b;
1159
1160   if (!QE_SingleBrush ())
1161     return;
1162
1163   b = selected_brushes.next;
1164
1165   Map_RegionOff ();
1166
1167   VectorCopy (b->mins, region_mins);
1168   VectorCopy (b->maxs, region_maxs);
1169
1170   Undo_Start("delete");
1171   Undo_AddBrushList(&selected_brushes);
1172   Undo_AddEntity(b->owner);
1173   Select_Delete ();
1174   Undo_EndBrushList(&selected_brushes);
1175   Undo_End();
1176
1177   Map_ApplyRegion ();
1178 }
1179
1180 GList *find_string(GList *glist, const char *buf)
1181 {
1182   while (glist)
1183   {
1184     if (strcmp((char *)glist->data, buf) == 0)
1185       break; // this name is in our list already
1186     glist = glist->next;
1187   }
1188   return glist;
1189 }
1190
1191 void Map_ImportBuffer(char *buf)
1192 {
1193   Select_Deselect();
1194
1195   Undo_Start("import buffer");
1196
1197   MemStream stream;
1198
1199   stream.Write(buf, strlen(buf));
1200   Map_Import(&stream, "xmap");
1201   stream.Close();
1202
1203   Sys_UpdateWindows (W_ALL);
1204   Sys_MarkMapModified();
1205
1206   Undo_End();
1207 }
1208
1209
1210 //
1211 //================
1212 //Map_ImportFile
1213 //================
1214 //
1215 void Map_ImportFile (const char *filename)
1216 {
1217   FileStream file;
1218         Sys_BeginWait ();
1219
1220   Sys_Printf("Importing map from %s\n",filename);
1221
1222   const char* type = strrchr(filename,'.');
1223   if(type!=NULL) type++;
1224   /*!\todo Resolve "r" problem in scriptlib" */
1225   if(file.Open(filename, "rb"))
1226     Map_Import(&file, type, true);
1227   else
1228     Sys_FPrintf(SYS_ERR, "ERROR: couldn't open %s for read\n", filename);
1229
1230   file.Close();
1231
1232         Sys_UpdateWindows (W_ALL);
1233         modified = true;
1234         Sys_EndWait();
1235 }
1236
1237 //
1238 //===========
1239 //Map_SaveSelected
1240 //===========
1241 //
1242 // Saves selected world brushes and whole entities with partial/full selections
1243 //
1244 void Map_SaveSelected(const char* filename)
1245 {
1246   FileStream file;
1247
1248   Sys_Printf("Saving selection to %s\n",filename);
1249
1250   const char* type = strrchr(filename,'.');
1251   if(type!=NULL) type++;
1252   if(file.Open(filename, "w"))
1253     Map_Export (&file, type, false, true);
1254   else
1255     Sys_FPrintf(SYS_ERR, "ERROR: failed to open %s for write\n", filename);
1256
1257   file.Close();
1258
1259 }
1260
1261 //
1262 //===========
1263 //Map_SaveSelected
1264 //===========
1265 //
1266 // Saves selected world brushes and whole entities with partial/full selections
1267 //
1268 void Map_SaveSelected (MemStream* pMemFile, MemStream* pPatchFile)
1269 {
1270   Map_Export (pMemFile, "xmap", false, true);
1271
1272  /*
1273         // write world entity first
1274         Entity_WriteSelected(world_entity, pMemFile);
1275
1276         // then write all other ents
1277         count = 1;
1278         for (e=entities.next ; e != &entities ; e=next)
1279         {
1280                 MemFile_fprintf(pMemFile, "// entity %i\n", count);
1281                 count++;
1282                 Entity_WriteSelected(e, pMemFile);
1283                 next = e->next;
1284         }
1285
1286   //if (pPatchFile)
1287   //  Patch_WriteFile(pPatchFile);
1288   */
1289 }
1290
1291
1292 void MemFile_fprintf(MemStream* pMemFile, const char* pText, ...)
1293 {
1294   char Buffer[4096];
1295   va_list args;
1296         va_start (args,pText);
1297   vsprintf(Buffer, pText, args);
1298   pMemFile->Write(Buffer, strlen(Buffer));
1299 }
1300
1301 /*!
1302 ==============
1303 Region_SpawnPoint
1304 push the region spawn point
1305 \todo FIXME TTimo this was in the #1 MAP module implementation (in the core)
1306 not sure it has any use anymore, should prolly drop it
1307 ==============
1308 */
1309 void Region_SpawnPoint(FILE *f)
1310 {
1311   // write the info_player_start, we use the camera position
1312   fprintf (f, "{\n");
1313   fprintf (f, "\"classname\" \"info_player_start\"\n");
1314   fprintf (f, "\"origin\" \"%i %i %i\"\n",
1315     (int)g_pParentWnd->GetCamWnd()->Camera()->origin[0],
1316     (int)g_pParentWnd->GetCamWnd()->Camera()->origin[1],
1317     (int)g_pParentWnd->GetCamWnd()->Camera()->origin[2]);
1318   fprintf (f, "\"angle\" \"%i\"\n", (int)g_pParentWnd->GetCamWnd()->Camera()->angles[YAW]);
1319   fprintf (f, "}\n");
1320 }