merge branch work back into trunk
[xonotic/netradiant.git] / radiant / select.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 // select.c
23 #include "stdafx.h"
24 #include <assert.h>
25 #include "filters.h"
26
27 // externs
28 CPtrArray g_SelectedFaces;
29 CPtrArray g_SelectedFaceBrushes;
30 CPtrArray& g_ptrSelectedFaces = g_SelectedFaces;
31 CPtrArray& g_ptrSelectedFaceBrushes = g_SelectedFaceBrushes;
32
33 /*
34 ===========
35 Test_Ray
36 ===========
37 */
38 #define DIST_START      999999
39 trace_t Test_Ray (vec3_t origin, vec3_t dir, int flags)
40 {
41         brush_t *brush;
42         face_t  *face;
43         float   dist;
44         trace_t t;
45
46         memset (&t, 0, sizeof(t));
47         t.dist = DIST_START;
48
49         if (flags & SF_CYCLE)
50         {
51                 CPtrArray array;
52                 brush_t *pToSelect = (selected_brushes.next != &selected_brushes) ? selected_brushes.next : NULL;
53                 Select_Deselect();
54
55                 // go through active brushes and accumulate all "hit" brushes
56                 for (brush = active_brushes.next ; brush != &active_brushes ; brush=brush->next)
57                 {
58                         //if ( (flags & SF_ENTITIES_FIRST) && brush->owner == world_entity)
59                         //  continue;
60
61                         if (brush->bFiltered)
62                                 continue;
63
64                         if (!g_PrefsDlg.m_bSelectCurves && brush->patchBrush)
65                                 continue;
66
67                         if (!g_PrefsDlg.m_bSelectModels && (brush->owner->eclass->nShowFlags & ECLASS_MISCMODEL))
68                                 continue;
69
70                         //if (!g_bShowPatchBounds && brush->patchBrush)
71                         //  continue;
72
73                         face = Brush_Ray (origin, dir, brush, &dist, flags);
74
75                         if (face)
76                                 array.Add(brush);
77                 }
78
79                 int nSize = array.GetSize();
80                 if (nSize > 0)
81                 {
82                         bool bFound = false;
83                         for (int i = 0; i < nSize; i++)
84                         {
85                                 brush_t *b = reinterpret_cast<brush_t*>(array.GetAt(i));
86                                 // did we hit the last one selected yet ?
87                                 if (b == pToSelect)
88                                 {
89                                         // yes we want to select the next one in the list
90                                         int n = (i > 0) ? i-1 : nSize-1;
91                                         pToSelect = reinterpret_cast<brush_t*>(array.GetAt(n));
92                                         bFound = true;
93                                         break;
94                                 }
95                         }
96                         if (!bFound)
97                                 pToSelect = reinterpret_cast<brush_t*>(array.GetAt(0));
98                 }
99                 if (pToSelect)
100                 {
101                         face = Brush_Ray (origin, dir, pToSelect, &dist, flags);
102                         t.dist = dist;
103                         t.brush = pToSelect;
104                         t.face = face;
105                         t.selected = false;
106                         return t;
107                 }
108         }
109
110         if (! (flags & SF_SELECTED_ONLY) )
111   {
112                 for (brush = active_brushes.next ; brush != &active_brushes ; brush=brush->next)
113                 {
114       if ( (flags & SF_ENTITIES_FIRST) && (brush->owner == world_entity || !brush->owner->eclass->fixedsize))
115                                 continue;
116
117                         if (brush->bFiltered)
118                                 continue;
119
120       if (!g_PrefsDlg.m_bSelectCurves && brush->patchBrush)
121         continue;
122
123                         if (!g_PrefsDlg.m_bSelectModels && (brush->owner->eclass->nShowFlags & ECLASS_MISCMODEL))
124                                 continue;
125
126       //if (!g_bShowPatchBounds && brush->patchBrush)
127       //  continue;
128
129                         face = Brush_Ray (origin, dir, brush, &dist, flags);
130                         if (face && dist > 0 && dist < t.dist)
131                         {
132                                 t.dist = dist;
133                                 t.brush = brush;
134                                 t.face = face;
135                                 t.selected = false;
136                         }
137                 }
138   }
139
140
141         for (brush = selected_brushes.next ; brush != &selected_brushes ; brush=brush->next)
142         {
143                 if ( (flags & SF_ENTITIES_FIRST) && (brush->owner == world_entity || !brush->owner->eclass->fixedsize))
144                         continue;
145
146                 if (brush->bFiltered)
147                         continue;
148
149     if (!g_PrefsDlg.m_bSelectCurves && brush->patchBrush)
150       continue;
151
152           if (!g_PrefsDlg.m_bSelectModels && (brush->owner->eclass->nShowFlags & ECLASS_MISCMODEL))
153                         continue;
154
155                 face = Brush_Ray (origin, dir, brush, &dist, flags);
156                 if (dist > 0 && dist < t.dist)
157                 {
158                         t.dist = dist;
159                         t.brush = brush;
160                         t.face = face;
161                         t.selected = true;
162                 }
163         }
164
165         // if entites first, but didn't find any, check regular
166
167         if ( (flags & SF_ENTITIES_FIRST) && t.brush == NULL)
168                 return Test_Ray (origin, dir, flags & ~SF_ENTITIES_FIRST);
169
170         return t;
171
172 }
173
174
175 /*
176 ============
177 Select_Brush
178
179 ============
180 */
181 void Select_Brush (brush_t *brush, bool bComplete, bool bStatus)
182 {
183         brush_t *b;
184         entity_t        *e;
185
186   g_ptrSelectedFaces.RemoveAll();
187   g_ptrSelectedFaceBrushes.RemoveAll();
188         if (g_qeglobals.d_select_count < 2)
189                 g_qeglobals.d_select_order[g_qeglobals.d_select_count] = brush;
190         g_qeglobals.d_select_count++;
191
192         e = brush->owner;
193         if (e)
194         {
195                 // select complete entity on first click
196                 if (e != world_entity && bComplete == true)
197                 {
198                         for (b=selected_brushes.next ; b != &selected_brushes ; b=b->next)
199                                 if (b->owner == e)
200                                         goto singleselect;
201                         for (b=e->brushes.onext ; b != &e->brushes ; b=b->onext)
202                         {
203                                 if( b == brush ) // make sure we add the actual selected brush last, mainly for cycle select
204                                         continue;
205                                 Brush_RemoveFromList (b);
206                                 Brush_AddToList (b, &selected_brushes);
207                         }
208                         Brush_RemoveFromList (brush);
209                         Brush_AddToList (brush, &selected_brushes);
210                 }
211                 else
212                 {
213                 singleselect:
214                         Brush_RemoveFromList (brush);
215                         Brush_AddToList (brush, &selected_brushes);
216                         UpdatePatchInspector();
217                 }
218
219                 if (e->eclass)
220                 {
221                         UpdateEntitySel(brush->owner->eclass);
222                 }
223
224         UpdateSurfaceDialog();
225         }
226
227   if (bStatus)
228   {
229     vec3_t vMin, vMax, vSize;
230           Select_GetBounds (vMin, vMax);
231     VectorSubtract(vMax, vMin, vSize);
232     CString strStatus;
233     strStatus.Format("Selection X:: %.1f  Y:: %.1f  Z:: %.1f", vSize[0], vSize[1], vSize[2]);
234     g_pParentWnd->SetStatusText(2, strStatus);
235   }
236 }
237
238 /*
239 =============
240 Select_FaceInSelectedBrushes
241 =============
242 */
243 bool Select_FaceInSelectedBrushes( face_t *face )
244 {
245   brush_t *brush;
246   face_t  *tface;
247
248   for(brush = selected_brushes.next; brush != &selected_brushes; brush = brush->next)
249   {
250     for(tface = brush->brush_faces; tface; tface = tface->next)
251     {
252       if(tface == face)
253       {
254         return true;
255       }
256     }
257   }
258
259         return false;
260 }
261
262 /*
263 ============
264 Select_Ray
265
266 If the origin is inside a brush, that brush will be ignored.
267 ============
268 */
269 void Select_Ray (vec3_t origin, vec3_t dir, int flags)
270 {
271         trace_t t;
272         face_t  *tface;
273   bool    bOk;
274   static  trace_t lastTrace = {
275     NULL,       //      brush
276     NULL,       //      face
277     0,          //      dist
278     false       //      selected
279   };
280
281         t = Test_Ray (origin, dir, flags);
282         if (!t.brush)
283                 return;
284
285   if (flags & SF_SINGLEFACE)
286   {
287     if( flags & SF_DRAG )
288     {
289       if ( t.brush == lastTrace.brush && t.face == lastTrace.face )
290         return;
291                 }
292     lastTrace = t;
293
294     if(Select_FaceInSelectedBrushes(t.face))
295     {
296       // Deselect the brush
297       Brush_RemoveFromList (t.brush);
298       Brush_AddToList (t.brush, &active_brushes);
299       UpdatePatchInspector();
300
301       // Select all of the brush's faces except the one we are pointing at
302       for( tface = t.brush->brush_faces; tface; tface = tface->next )
303       {
304         if( tface == t.face )
305           continue;
306
307         bOk = true;
308         // NOTE: keep the size check in the loop, we remove stuff inside
309         for (int i = 0; i < g_SelectedFaces.GetSize(); i++)
310         {
311           if (tface == reinterpret_cast<face_t*>(g_SelectedFaces.GetAt(i)))
312                                                 bOk = false;
313         }
314
315         if(bOk)
316         {
317           g_SelectedFaces.Add(tface);
318           g_SelectedFaceBrushes.Add(t.brush);
319         }
320       }
321       g_qeglobals.d_select_mode = sel_facets_off;
322     }
323     else
324     {
325       bOk = true;
326       // NOTE: keep the size check in the loop, we remove stuff inside
327       for (int i = 0; i < g_SelectedFaces.GetSize(); i++)
328       {
329         if (t.face == reinterpret_cast<face_t*>(g_SelectedFaces.GetAt(i)))
330         {
331           bOk = false;
332           if( flags & SF_DRAG_ON )
333             continue;
334
335           g_qeglobals.d_select_mode = sel_facets_off;
336           // need to remove i'th entry
337           g_SelectedFaces.RemoveAt(i, 1);
338           g_SelectedFaceBrushes.RemoveAt(i, 1);
339         }
340       }
341
342       if (bOk && !(flags & SF_DRAG_OFF))
343       {
344         g_SelectedFaces.Add(t.face);
345         g_SelectedFaceBrushes.Add(t.brush);
346         g_qeglobals.d_select_mode = sel_facets_on;
347       }
348     }
349     UpdateSurfaceDialog();
350     Sys_UpdateWindows (W_ALL);
351     //g_qeglobals.d_select_mode = sel_brush;
352     // Texture_SetTexture requires a brushprimit_texdef fitted to the default width=2 height=2 texture
353     brushprimit_texdef_t brushprimit_texdef;
354     ConvertTexMatWithQTexture ( &t.face->brushprimit_texdef, t.face->d_texture, &brushprimit_texdef, NULL );
355     Texture_SetTexture ( &t.face->texdef, &brushprimit_texdef, false, NULL, false );
356     return;
357   }
358
359         // move the brush to the other list
360   if (t.selected)
361   {
362     if( flags & SF_DRAG_ON )
363       return;
364
365     g_qeglobals.d_select_mode = sel_brush_off;
366     Brush_RemoveFromList (t.brush);
367     Brush_AddToList (t.brush, &active_brushes);
368
369     UpdatePatchInspector();
370   }
371   else
372   {
373     if( flags & SF_DRAG_OFF )
374       return;
375
376     g_qeglobals.d_select_mode = sel_brush_on;
377     Select_Brush (t.brush, g_PrefsDlg.m_nCamDragMultiSelect == 1 ? Sys_AltDown () : !Sys_AltDown ());
378   }
379   UpdateSurfaceDialog();
380   Sys_UpdateWindows (W_ALL);
381 }
382
383
384 void Select_Delete (void)
385 {
386   brush_t *brush;
387   entity_t *e;
388
389   g_ptrSelectedFaces.RemoveAll();
390   g_ptrSelectedFaceBrushes.RemoveAll();
391
392   g_qeglobals.d_select_mode = sel_brush;
393
394   g_qeglobals.d_select_count = 0;
395   g_qeglobals.d_num_move_points = 0;
396   while (selected_brushes.next != &selected_brushes)
397   {
398     brush = selected_brushes.next;
399     if (brush->patchBrush)
400     {
401       Patch_Delete(brush->pPatch);
402     }
403     e = brush->owner;
404     Brush_Free (brush);
405     // remove if no brushes
406     if (e != world_entity && e->brushes.onext == &e->brushes)
407       Entity_Free(e);
408   }
409
410   Sys_MarkMapModified ();
411   UpdateSurfaceDialog();
412   Sys_UpdateWindows (W_ALL);
413 }
414
415 // update the workzone to a given brush
416 void UpdateWorkzone_ForBrush( brush_t* b )
417 {
418   VectorCopy( b->mins, g_qeglobals.d_work_min );
419   VectorCopy( b->maxs, g_qeglobals.d_work_max );
420   //++timo clean
421 #if 0
422         // will update the workzone to the given brush
423         // g_pParentWnd->ActiveXY()->GetViewType()
424         // cf VIEWTYPE defintion: enum VIEWTYPE {YZ, XZ, XY};
425         // we fit our work zone to the last brush on the list (b)
426         int nViewType = g_pParentWnd->ActiveXY()->GetViewType();
427   int nDim1 = (nViewType == YZ) ? 1 : 0;
428   int nDim2 = (nViewType == XY) ? 1 : 2;
429         g_qeglobals.d_work_min[nDim1] = b->mins[nDim1];
430         g_qeglobals.d_work_max[nDim1] = b->maxs[nDim1];
431         g_qeglobals.d_work_min[nDim2] = b->mins[nDim2];
432         g_qeglobals.d_work_max[nDim2] = b->maxs[nDim2];
433 #endif
434 }
435
436 // here to filter new brushes once unselected
437 extern void PerformFiltering();
438
439 void Select_Deselect (bool bDeselectFaces)
440 {
441         brush_t *b;
442
443   Patch_Deselect();
444
445   g_pParentWnd->ActiveXY()->UndoClear();
446
447   g_qeglobals.d_workcount++;
448         g_qeglobals.d_select_count = 0;
449         g_qeglobals.d_num_move_points = 0;
450         b = selected_brushes.next;
451
452         if (b == &selected_brushes)
453         {
454                 if (bDeselectFaces)
455                 {
456                         g_ptrSelectedFaces.RemoveAll();
457       g_ptrSelectedFaceBrushes.RemoveAll();
458                 }
459     PerformFiltering();
460                 UpdateSurfaceDialog();
461                 Sys_UpdateWindows (W_ALL);
462                 return;
463         }
464
465   if (bDeselectFaces)
466   {
467         g_ptrSelectedFaces.RemoveAll();
468     g_ptrSelectedFaceBrushes.RemoveAll();
469   }
470
471         g_qeglobals.d_select_mode = sel_brush;
472
473         UpdateWorkzone_ForBrush(b);
474
475         selected_brushes.next->prev = &active_brushes;
476         selected_brushes.prev->next = active_brushes.next;
477         active_brushes.next->prev = selected_brushes.prev;
478         active_brushes.next = selected_brushes.next;
479         selected_brushes.prev = selected_brushes.next = &selected_brushes;
480
481   // filter newly created stuff once it's unselected
482   PerformFiltering();
483         UpdateSurfaceDialog();
484         Sys_UpdateWindows (W_ALL);
485 }
486
487 /*
488 ============
489 Select_Move
490 ============
491 */
492 /*! Moves the currently selected brush/patch
493     \param delta How far to move the selection (x,y,z)
494     \param bSnap If the move should snap to grid points
495 */
496 void Select_Move (vec3_t delta, bool bSnap)
497 {
498         brush_t *b;
499
500   // actually move the selected brushes
501   for (b = selected_brushes.next ; b != &selected_brushes ; b=b->next)
502     Brush_Move (b, delta, bSnap);
503
504   vec3_t vMin, vMax;
505         Select_GetBounds (vMin, vMax);
506   CString strStatus;
507   strStatus.Format("Origin X:: %.1f  Y:: %.1f  Z:: %.1f", vMin[0], vMax[1], vMax[2]);
508   g_pParentWnd->SetStatusText(2, strStatus);
509
510   //Sys_UpdateWindows (W_ALL);
511 }
512
513 /*
514 =================
515 Select_NudgeVerts
516 =================
517 */
518 /*! Moves the currently selected brush/patch vertices
519     \param delta How far to move the vertices (x,y,z)
520     \param bSnap If the move should snap to grid points
521 */
522 void Select_NudgePoint(vec3_t delta, qboolean bSnap)
523 {
524   if (g_qeglobals.d_select_mode == sel_vertex)
525   {
526     // move selected verts
527     brush_t *b;
528     vec3_t end;
529     qboolean success = true;
530     for (b = selected_brushes.next; b != &selected_brushes; b = b->next)
531     {
532       success &= (qboolean)Brush_MoveVertex(b, g_qeglobals.d_move_points[0], delta, end, bSnap);
533     }
534     if (success)
535       VectorCopy(end, g_qeglobals.d_move_points[0]);
536   }
537   else if (g_qeglobals.d_select_mode == sel_curvepoint)
538   {
539     // move selected patch control points
540     Patch_UpdateSelected(delta);
541   }
542 }
543
544 /*
545 ============
546 Select_Clone
547
548 Creates an exact duplicate of the selection in place, then moves
549 the selected brushes off of their old positions
550 ============
551 */
552 void Select_Clone (void)
553 {
554   g_bScreenUpdates = false;
555   g_pParentWnd->Copy();
556   Select_Deselect();
557   g_pParentWnd->Paste();
558   g_pParentWnd->NudgeSelection(2, g_qeglobals.d_gridsize);
559   g_pParentWnd->NudgeSelection(3, g_qeglobals.d_gridsize);
560   Undo_Start("clone");
561   Undo_EndBrushList(&selected_brushes);
562   Undo_End();
563   g_bScreenUpdates = true;
564   Sys_UpdateWindows(W_ALL);
565 }
566
567 //++timo clean
568 #if 0
569 /*
570 ============
571 Select_SetTexture
572 Timo : bFitScale to compute scale on the plane and counteract plane / axial plane snapping
573 Timo :  brush primitive texturing
574                 the brushprimit_texdef given must be understood as a qtexture_t width=2 height=2 ( HiRes )
575 Timo :  texture plugin, added an IPluginTexdef* parameter
576                 must be casted to an IPluginTexdef!
577                 if not NULL, get ->Copy() of it into each face or brush ( and remember to hook )
578                 if NULL, means we have no information, ask for a default
579 TTimo - shader code cleanup
580   added IShader* parameter
581 ============
582 */
583 void WINAPI Select_SetTexture2 (IShader* pShader, texdef_t *texdef, brushprimit_texdef_t *brushprimit_texdef, bool bFitScale, void* pPlugTexdef )
584 {
585         brush_t *b;
586         int nCount = g_ptrSelectedFaces.GetSize();
587         if (nCount > 0)
588         {
589                 Undo_Start("set face textures");
590                 ASSERT(g_ptrSelectedFaces.GetSize() == g_ptrSelectedFaceBrushes.GetSize());
591                 for (int i = 0; i < nCount; i++)
592                 {
593                         face_t *selFace = reinterpret_cast<face_t*>(g_ptrSelectedFaces.GetAt(i));
594                         brush_t *selBrush = reinterpret_cast<brush_t*>(g_ptrSelectedFaceBrushes.GetAt(i));
595                         Undo_AddBrush(selBrush);
596                         //++timo TODO: propagate the IShader* ..
597                         SetFaceTexdef (selFace, texdef, brushprimit_texdef, bFitScale, static_cast<IPluginTexdef *>(pPlugTexdef) );
598                         Brush_Build(selBrush, bFitScale);
599                         Undo_EndBrush(selBrush);
600                 }
601                 Undo_End();
602         }
603         else if (selected_brushes.next != &selected_brushes)
604         {
605                 Undo_Start("set brush textures");
606                 for (b=selected_brushes.next ; b != &selected_brushes ; b=b->next)
607                         if (!b->owner->eclass->fixedsize)
608                         {
609                                 Undo_AddBrush(b);
610                                 Brush_SetTexture2 (b, pShader, texdef, brushprimit_texdef, bFitScale, static_cast<IPluginTexdef *>(pPlugTexdef) );
611                                 Undo_EndBrush(b);
612                         }
613                 Undo_End();
614         }
615         Sys_UpdateWindows (W_ALL);
616 }
617 #endif
618
619 /*
620 ============
621 Select_SetTexture
622 Timo : bFitScale to compute scale on the plane and counteract plane / axial plane snapping
623 Timo :  brush primitive texturing
624                 the brushprimit_texdef given must be understood as a qtexture_t width=2 height=2 ( HiRes )
625 Timo :  texture plugin, added an IPluginTexdef* parameter
626                 must be casted to an IPluginTexdef!
627                 if not NULL, get ->Copy() of it into each face or brush ( and remember to hook )
628                 if NULL, means we have no information, ask for a default
629 ============
630 */
631 void WINAPI Select_SetTexture (texdef_t *texdef, brushprimit_texdef_t *brushprimit_texdef, bool bFitScale, void* pPlugTexdef )
632 {
633   /*
634 #ifdef _DEBUG
635   static int count = 0;
636 #endif
637   */
638         brush_t *b;
639   /*
640 #ifdef _DEBUG
641   count++;
642   Sys_Printf("count: %d\n", count);
643   if(count==4)
644     Sys_Printf("break!\n");
645 #endif
646   */
647         int nCount = g_ptrSelectedFaces.GetSize();
648         if (nCount > 0)
649         {
650                 Undo_Start("set face textures");
651                 assert(g_ptrSelectedFaces.GetSize() == g_ptrSelectedFaceBrushes.GetSize());
652                 for (int i = 0; i < nCount; i++)
653                 {
654                         face_t *selFace = reinterpret_cast<face_t*>(g_ptrSelectedFaces.GetAt(i));
655                         brush_t *selBrush = reinterpret_cast<brush_t*>(g_ptrSelectedFaceBrushes.GetAt(i));
656                         Undo_AddBrush(selBrush);
657                         SetFaceTexdef (selFace, texdef, brushprimit_texdef, bFitScale, static_cast<IPluginTexdef *>(pPlugTexdef) );
658                         Brush_Build(selBrush, bFitScale);
659                         Undo_EndBrush(selBrush);
660                 }
661                 Undo_End();
662         }
663         else if (selected_brushes.next != &selected_brushes)
664         {
665                 Undo_Start("set brush textures");
666                 for (b=selected_brushes.next ; b != &selected_brushes ; b=b->next)
667                         if (!b->owner->eclass->fixedsize)
668                         {
669                                 Undo_AddBrush(b);
670                                 Brush_SetTexture (b, texdef, brushprimit_texdef, bFitScale, static_cast<IPluginTexdef *>(pPlugTexdef) );
671                                 Undo_EndBrush(b);
672                         }
673                 Undo_End();
674         }
675         //++timo FIXME: not necessary in every cases, write a message defering / move one level up
676         Sys_UpdateWindows (W_ALL);
677 }
678
679
680 /*
681 ================================================================
682
683   TRANSFORMATIONS
684
685 ================================================================
686 */
687
688 void Select_GetBounds (vec3_t mins, vec3_t maxs)
689 {
690         brush_t *b;
691         int             i;
692
693         for (i=0 ; i<3 ; i++)
694         {
695                 mins[i] = 99999;
696                 maxs[i] = -99999;
697         }
698
699         for (b=selected_brushes.next ; b != &selected_brushes ; b=b->next)
700         {
701                 if (b->owner->eclass->fixedsize)
702                 {
703                         for (i=0 ; i<3 ; i++)
704                         {
705                                 if (b->owner->origin[i] < mins[i])
706                                         mins[i] = b->owner->origin[i];
707                                 if (b->owner->origin[i] > maxs[i])
708                                         maxs[i] = b->owner->origin[i];
709                         }
710                 }
711                 else
712                 {
713                         for (i=0 ; i<3 ; i++)
714                         {
715                                 if (b->mins[i] < mins[i])
716                                         mins[i] = b->mins[i];
717                                 if (b->maxs[i] > maxs[i])
718                                         maxs[i] = b->maxs[i];
719                         }
720                 }
721         }
722 }
723
724 void Select_GetTrueMid (vec3_t mid)
725 {
726         vec3_t  mins, maxs;
727         Select_GetBounds (mins, maxs);
728
729   for (int i=0 ; i<3 ; i++)
730     mid[i] = (mins[i] + ((maxs[i] - mins[i]) / 2));
731 }
732
733 void Select_GetMid (vec3_t mid)
734 {
735         vec3_t  mins, maxs;
736         int             i;
737
738   if (!g_PrefsDlg.m_bSnap)
739   {
740     Select_GetTrueMid(mid);
741     return;
742   }
743
744   Select_GetBounds (mins, maxs);
745
746   for (i=0 ; i<3 ; i++)
747                 mid[i] = g_qeglobals.d_gridsize*floor ( ( (mins[i] + maxs[i])*0.5 )/g_qeglobals.d_gridsize );
748 }
749
750 vec3_t  select_origin;
751 vec3_t  select_matrix[3];
752 qboolean        select_fliporder;
753
754 // FIXME: bApplyBPrimit is supposed to be temporary
755 // TODO: manage Brush_Build calls, too many of them with the texture processing
756 // FIXME: the undo doesn't seem to work correctly on texturing and flip/rotate operations?? this is not supposed to be related to the texture locking code, so what is happening?
757 // FIXME: ApplyMatrix works on flipping operation, b0rks on Rotations (so does the "regular" rotation code??)
758 // FIXME: what is getting called in free rotation mode? that used to work right?
759 void Select_ApplyMatrix (bool bSnap, bool bRotation, int nAxis, float fDeg)//, qboolean bApplyBPrimit)
760 {
761         brush_t *b;
762         face_t  *f;
763         int             i, j;
764         vec3_t  temp, tmporigin;
765
766         for (b=selected_brushes.next ; b != &selected_brushes ; b=b->next)
767         {
768                 if(b->owner->eclass->fixedsize)
769                 {
770                         VectorCopy (b->owner->origin, tmporigin);
771                         // transform the origin point
772                         VectorSubtract (b->owner->origin, select_origin, temp);
773                         for (j=0 ; j<3 ; j++)
774                                 b->owner->origin[j] = DotProduct(temp, select_matrix[j]) + select_origin[j];
775
776       // update the origin key
777       char text[64];
778       sprintf (text, "%i %i %i",
779         (int)b->owner->origin[0], (int)b->owner->origin[1], (int)b->owner->origin[2]);
780       SetKeyValue(b->owner, "origin", text);
781
782       /*\todo remove brush-based bounding box for fixedsize entities */
783       VectorSubtract (b->owner->origin, tmporigin, temp);
784                         for (f=b->brush_faces ; f ; f=f->next)
785                         {
786                                 // move fixedsize bbox to new origin
787                                 for (i=0 ; i<3 ; i++)
788                                         VectorAdd (f->planepts[i], temp, f->planepts[i]);
789                         }
790                         Brush_Build(b, bSnap,true,false,false); // don't filter
791
792                 }
793                 else if (b->patchBrush)
794                 {
795                         if (!bRotation && !((g_qeglobals.d_select_mode == sel_curvepoint && g_qeglobals.d_num_move_points != 0) || g_bPatchBendMode))
796                                 // invert patch if this is a mirroring operation, unless points are selected or bendmode is active
797                                 patchInvert(b->pPatch);
798                         // NOTE: does not clamp points to integers
799                         Patch_ApplyMatrix(b->pPatch, select_origin, select_matrix, false);
800                 }
801                 else
802                 {
803                         for (f=b->brush_faces ; f ; f=f->next)
804                         {
805                                 // FIXME: only in BP mode!
806                                 // if we are using Brush Primitives texturing, we need to compute the texture matrix after the geometric transformation
807                                 // (with the default texturing you don't need to compute anything for flipping and mirroring operations)
808                                 //      if (bApplyBPrimit) {
809                                 //        ApplyMatrix_BrushPrimit (f, select_matrix, select_origin, select_fliporder);
810                                 //      }
811                                 for (i=0 ; i<3 ; i++)
812                                 {
813                                         VectorSubtract (f->planepts[i], select_origin, temp);
814                                         for (j=0 ; j<3 ; j++)
815                                                 f->planepts[i][j] = DotProduct(temp, select_matrix[j]) + select_origin[j];
816                                 }
817                                 if (select_fliporder)
818                                 {
819                                         VectorCopy (f->planepts[0], temp);
820                                         VectorCopy (f->planepts[2], f->planepts[0]);
821                                         VectorCopy (temp, f->planepts[2]);
822                                 }
823                         }
824                         Brush_Build(b, bSnap,true,false,false); // don't filter
825                 }
826         }
827 }
828
829 void ProjectOnPlane(vec3_t& normal,float dist,vec3_t& ez, vec3_t& p)
830 {
831         if (fabs(ez[0]) == 1)
832                 p[0] = (dist - normal[1] * p[1] - normal[2] * p[2]) / normal[0];
833         else if (fabs(ez[1]) == 1)
834                 p[1] = (dist - normal[0] * p[0] - normal[2] * p[2]) / normal[1];
835         else
836                 p[2] = (dist - normal[0] * p[0] - normal[1] * p[1]) / normal[2];
837 }
838
839 void Back(vec3_t& dir, vec3_t& p)
840 {
841         if (fabs(dir[0]) == 1)
842                 p[0] = 0;
843         else if (fabs(dir[1]) == 1)
844                 p[1] = 0;
845         else p[2] = 0;
846 }
847
848
849
850 // using scale[0] and scale[1]
851 void ComputeScale(vec3_t& rex, vec3_t& rey, vec3_t& p, face_t* f)
852 {
853         float px = DotProduct(rex, p);
854         float py = DotProduct(rey, p);
855         px *= f->texdef.scale[0];
856         py *= f->texdef.scale[1];
857   vec3_t aux;
858   VectorCopy(rex, aux);
859   VectorScale(aux, px, aux);
860   VectorCopy(aux, p);
861   VectorCopy(rey, aux);
862   VectorScale(aux, py, aux);
863   VectorAdd(p, aux, p);
864 }
865
866 void ComputeAbsolute(face_t* f, vec3_t& p1, vec3_t& p2, vec3_t& p3)
867 {
868         vec3_t ex,ey,ez;                // local axis base
869
870 #ifdef _DEBUG
871         if (g_qeglobals.m_bBrushPrimitMode)
872                 Sys_Printf("Warning : illegal call of ComputeAbsolute in brush primitive mode\n");
873 #endif
874
875   // compute first local axis base
876   TextureAxisFromPlane(&f->plane, ex, ey);
877   CrossProduct(ex, ey, ez);
878
879         vec3_t aux;
880   VectorCopy(ex, aux);
881   VectorScale(aux, -f->texdef.shift[0], aux);
882   VectorCopy(aux, p1);
883   VectorCopy(ey, aux);
884   VectorScale(aux, -f->texdef.shift[1], aux);
885   VectorAdd(p1, aux, p1);
886   VectorCopy(p1, p2);
887   VectorAdd(p2, ex, p2);
888   VectorCopy(p1, p3);
889   VectorAdd(p3, ey, p3);
890   VectorCopy(ez, aux);
891   VectorScale(aux, -f->texdef.rotate, aux);
892   VectorRotate(p1, aux, p1);
893   VectorRotate(p2, aux, p2);
894   VectorRotate(p3, aux, p3);
895         // computing rotated local axis base
896         vec3_t rex,rey;
897   VectorCopy(ex, rex);
898   VectorRotate(rex, aux, rex);
899   VectorCopy(ey, rey);
900   VectorRotate(rey, aux, rey);
901
902   ComputeScale(rex,rey,p1,f);
903         ComputeScale(rex,rey,p2,f);
904         ComputeScale(rex,rey,p3,f);
905
906         // project on normal plane
907         // along ez
908         // assumes plane normal is normalized
909         ProjectOnPlane(f->plane.normal,f->plane.dist,ez,p1);
910         ProjectOnPlane(f->plane.normal,f->plane.dist,ez,p2);
911         ProjectOnPlane(f->plane.normal,f->plane.dist,ez,p3);
912 };
913
914
915 void AbsoluteToLocal(plane_t normal2, face_t* f, vec3_t& p1, vec3_t& p2, vec3_t& p3)
916 {
917         vec3_t ex,ey,ez;
918
919 #ifdef _DEBUG
920         if (g_qeglobals.m_bBrushPrimitMode)
921                 Sys_Printf("Warning : illegal call of AbsoluteToLocal in brush primitive mode\n");
922 #endif
923
924         // computing new local axis base
925   TextureAxisFromPlane(&normal2, ex, ey);
926   CrossProduct(ex, ey, ez);
927
928   // projecting back on (ex,ey)
929         Back(ez,p1);
930         Back(ez,p2);
931         Back(ez,p3);
932
933         vec3_t aux;
934         // rotation
935   VectorCopy(p2, aux);
936   VectorSubtract(aux, p1,aux);
937
938         float x = DotProduct(aux,ex);
939         float y = DotProduct(aux,ey);
940   f->texdef.rotate = 180 * atan2(y,x) / Q_PI;
941
942         vec3_t rex,rey;
943         // computing rotated local axis base
944   VectorCopy(ez, aux);
945   VectorScale(aux, f->texdef.rotate, aux);
946   VectorCopy(ex, rex);
947   VectorRotate(rex, aux, rex);
948   VectorCopy(ey, rey);
949   VectorRotate(rey, aux, rey);
950
951         // scale
952   VectorCopy(p2, aux);
953   VectorSubtract(aux, p1, aux);
954   f->texdef.scale[0] = DotProduct(aux, rex);
955   VectorCopy(p3, aux);
956   VectorSubtract(aux, p1, aux);
957   f->texdef.scale[1] = DotProduct(aux, rey);
958
959         // shift
960         // only using p1
961         x = DotProduct(rex,p1);
962         y = DotProduct(rey,p1);
963         x /= f->texdef.scale[0];
964         y /= f->texdef.scale[1];
965
966   VectorCopy(rex, p1);
967   VectorScale(p1, x, p1);
968   VectorCopy(rey, aux);
969   VectorScale(aux, y, aux);
970   VectorAdd(p1, aux, p1);
971   VectorCopy(ez, aux);
972   VectorScale(aux, -f->texdef.rotate, aux);
973   VectorRotate(p1, aux, p1);
974         f->texdef.shift[0] = -DotProduct(p1, ex);
975         f->texdef.shift[1] = -DotProduct(p1, ey);
976
977         // stored rot is good considering local axis base
978         // change it if necessary
979         f->texdef.rotate = -f->texdef.rotate;
980
981   Clamp(f->texdef.shift[0], f->d_texture->width);
982   Clamp(f->texdef.shift[1], f->d_texture->height);
983   Clamp(f->texdef.rotate, 360);
984
985 }
986
987 void RotateFaceTexture(face_t* f, int nAxis, float fDeg)
988 {
989         vec3_t p1,p2,p3, rota;
990         p1[0] = p1[1] = p1[2] = 0;
991         VectorCopy(p1, p2);
992         VectorCopy(p1, p3);
993         VectorCopy(p1, rota);
994         ComputeAbsolute(f, p1, p2, p3);
995
996         rota[nAxis] = fDeg;
997         VectorRotateOrigin (p1, rota, select_origin, p1);
998         VectorRotateOrigin (p2, rota, select_origin, p2);
999         VectorRotateOrigin (p3, rota, select_origin, p3);
1000
1001         plane_t normal2;
1002         vec3_t vNormal;
1003         vNormal[0] = f->plane.normal[0];
1004         vNormal[1] = f->plane.normal[1];
1005         vNormal[2] = f->plane.normal[2];
1006         VectorRotate(vNormal, rota, vNormal);
1007         normal2.normal[0] = vNormal[0];
1008         normal2.normal[1] = vNormal[1];
1009         normal2.normal[2] = vNormal[2];
1010         AbsoluteToLocal(normal2, f, p1, p2 ,p3);
1011
1012 }
1013
1014 void RotateTextures(int nAxis, float fDeg, vec3_t vOrigin)
1015 {
1016         for (brush_t* b=selected_brushes.next ; b != &selected_brushes ; b=b->next)
1017         {
1018                 for (face_t* f=b->brush_faces ; f ; f=f->next)
1019                 {
1020                         if (g_qeglobals.m_bBrushPrimitMode)
1021                                 RotateFaceTexture_BrushPrimit (f, nAxis, fDeg, vOrigin);
1022                         else
1023                                 RotateFaceTexture (f, nAxis, fDeg);
1024                 }
1025                 Brush_Build(b, false,true,false,false); // don't filter
1026         }
1027 }
1028
1029 void Select_ApplyMatrix_BrushPrimit()
1030 {
1031   #ifdef _DEBUG
1032   if (!g_qeglobals.m_bBrushPrimitMode) {
1033     Sys_FPrintf(SYS_ERR,"ERROR: Select_ApplyMatrix_BrushPrimit called in non-BP mode\n");
1034   }
1035   #endif
1036         for (brush_t* b=selected_brushes.next ; b != &selected_brushes ; b=b->next)
1037         {
1038                 for (face_t* f=b->brush_faces ; f ; f=f->next)
1039                 {
1040       ApplyMatrix_BrushPrimit (f, select_matrix, select_origin);
1041     }
1042   }
1043 }
1044
1045 void Select_FlipAxis (int axis)
1046 {
1047         int             i;
1048
1049         Select_GetMid (select_origin);
1050         for (i=0 ; i<3 ; i++)
1051         {
1052                 VectorCopy (vec3_origin, select_matrix[i]);
1053                 select_matrix[i][i] = 1;
1054         }
1055         select_matrix[axis][axis] = -1;
1056         select_fliporder = true;
1057
1058   // texture locking
1059   if (g_PrefsDlg.m_bRotateLock) {
1060     // axis flipping inverts space orientation, we have to use a general texture locking algorithm instead of the RotateFaceTexture
1061     if (g_qeglobals.m_bBrushPrimitMode) {
1062       Select_ApplyMatrix_BrushPrimit();
1063     }
1064     else
1065     {
1066       // there's never been flip locking for non BP mode, this would be tricky to write and there's not much interest for it with the coming of BP format
1067       // what could be done is converting regular to BP, locking, then back to regular :)
1068       Sys_FPrintf(SYS_WRN, "WARNING: regular texturing doesn't have texture lock on flipping operations\n");
1069     }
1070   }
1071   // geometric transformation
1072         Select_ApplyMatrix (true, false, 0, 0);
1073         Sys_UpdateWindows (W_ALL);
1074 }
1075
1076
1077 void Select_Scale(float x, float y, float z)
1078 {
1079   Select_GetMid (select_origin);
1080         for (brush_t* b=selected_brushes.next ; b != &selected_brushes ; b=b->next)
1081         {
1082     // ignore fixedsize entities
1083     if(b->owner->eclass->fixedsize) continue;
1084                 for (face_t* f=b->brush_faces ; f ; f=f->next)
1085                 {
1086                         for (int i=0 ; i<3 ; i++)
1087                         {
1088         f->planepts[i][0] -= select_origin[0];
1089         f->planepts[i][1] -= select_origin[1];
1090         f->planepts[i][2] -= select_origin[2];
1091         f->planepts[i][0] *= x;
1092         f->planepts[i][1] *= y;
1093         f->planepts[i][2] *= z;
1094
1095         f->planepts[i][0] += select_origin[0];
1096         f->planepts[i][1] += select_origin[1];
1097         f->planepts[i][2] += select_origin[2];
1098                         }
1099                 }
1100                 Brush_Build(b, false,true,false,false); // don't filter
1101     if (b->patchBrush)
1102     {
1103       vec3_t v;
1104       v[0] = x;
1105       v[1] = y;
1106       v[2] = z;
1107       Patch_Scale(b->pPatch, select_origin, v);
1108     }
1109         }
1110 }
1111
1112 void Select_RotateAxis (int axis, float deg, bool bPaint, bool bMouse)
1113 {
1114         int             i;
1115         vec_t   c, s;
1116
1117         if (deg == 0)
1118   {
1119                 return;
1120   }
1121
1122   if (bMouse)
1123   {
1124     VectorCopy(g_pParentWnd->ActiveXY()->RotateOrigin(), select_origin);
1125   }
1126   else
1127   {
1128           Select_GetMid (select_origin);
1129   }
1130
1131   /*
1132   if(axis == 2)
1133   {
1134     vec3_t rotation;
1135     VectorSet(rotation, 0, 0, 360 - deg);
1136     for(brush_t *b = selected_brushes.next; b != &selected_brushes; b = b->next)
1137       if(b->owner->model.pEdit)
1138         b->owner->model.pEdit->Rotate(select_origin, rotation);
1139   }
1140   */
1141
1142         select_fliporder = false;
1143
1144   // the "90" degrees algorithm is mostly used on axis rotate as a speedup and possibly avoiding rounding errors as much as possible
1145   // previous implementation was doing an indirect-oriented rotation over the plane whereas the general algo below was doing a direct-oriented rotation
1146   // this was confusing the texture locking algorithms, fixed it to be direct-oriented (side consequence is that the axis rotate toolbar button rotates the other way now)
1147   // NOTE: previous algo was using vec3_origin in the matrix computation..
1148   //   I don't see what an origin does in linear transformations (3x3 matrixes always relate to a (0,0,0) origin)
1149   //   in Radiant it's initialized as (0,0,0) and never set to another value
1150   //   so I got rid of it when it's not used for initialisation tasks (and even if it's not (0,0,0) it should not matter
1151         if (deg == 90)
1152         {
1153                 c = 0;
1154                 s = 1;
1155         }
1156         else
1157         {
1158     c = cos(deg * Q_PI / 180.0);
1159     s = sin(deg * Q_PI / 180.0);
1160         }
1161
1162         for (i=0 ; i<3 ; i++)
1163         {
1164                 VectorCopy (vec3_origin, select_matrix[i]);
1165                 select_matrix[i][i] = 1;
1166         }
1167
1168         switch (axis)
1169         {
1170         case 0:
1171                 select_matrix[1][1] = c;
1172                 select_matrix[1][2] = s;
1173                 select_matrix[2][1] = -s;
1174                 select_matrix[2][2] = c;
1175                 break;
1176         case 1:
1177                 select_matrix[0][0] = c;
1178                 select_matrix[0][2] = s;
1179                 select_matrix[2][0] = -s;
1180                 select_matrix[2][2] = c;
1181                 break;
1182         case 2:
1183                 select_matrix[0][0] = c;
1184                 select_matrix[0][1] = s;
1185                 select_matrix[1][0] = -s;
1186                 select_matrix[1][1] = c;
1187                 break;
1188         }
1189
1190
1191   // texture locking
1192         if (g_PrefsDlg.m_bRotateLock)
1193   {
1194                 // Terrible hack, reversing input rotation angle to correct
1195                 // texture rotation direction for X and Z axes.
1196                 // RotateTextures needs to be changed to fix this properly?
1197                 if (axis == 1)
1198                         RotateTextures(axis, deg, select_origin);
1199                 else
1200                         RotateTextures(axis, deg * -1, select_origin);
1201   }
1202   // geometric transformation
1203         Select_ApplyMatrix(!bMouse, true, axis, deg);//, false);
1204
1205         if (bPaint)
1206                 Sys_UpdateWindows (W_ALL);
1207 }
1208
1209 /*
1210 ================================================================
1211
1212 GROUP SELECTIONS
1213
1214 ================================================================
1215 */
1216
1217 void Select_RealCompleteTall(vec3_t mins, vec3_t maxs)
1218 {
1219         brush_t *b, *next;
1220
1221   int nDim1 = (g_pParentWnd->ActiveXY()->GetViewType() == YZ) ? 1 : 0;
1222   int nDim2 = (g_pParentWnd->ActiveXY()->GetViewType() == XY) ? 1 : 2;
1223
1224   g_qeglobals.d_select_mode = sel_brush;
1225
1226         for (b=active_brushes.next ; b != &active_brushes ; b=next)
1227         {
1228                 next = b->next;
1229
1230                 if (b->bFiltered)
1231                         continue;
1232
1233                 if ( (b->maxs[nDim1] > maxs[nDim1] || b->mins[nDim1] < mins[nDim1])
1234                         || (b->maxs[nDim2] > maxs[nDim2] || b->mins[nDim2] < mins[nDim2]) )
1235                         continue;
1236
1237                 Brush_RemoveFromList (b);
1238                 Brush_AddToList (b, &selected_brushes);
1239         }
1240 }
1241
1242 void Select_CompleteTall (void)
1243 {
1244   vec3_t mins, maxs;
1245
1246   if (!QE_SingleBrush ())
1247     return;
1248
1249   Undo_Start ("select complete tall");
1250   Undo_AddBrushList (&selected_brushes);
1251   Undo_End();
1252
1253   VectorCopy (selected_brushes.next->mins, mins);
1254   VectorCopy (selected_brushes.next->maxs, maxs);
1255   Select_Delete ();
1256
1257   Select_RealCompleteTall(mins, maxs);
1258   Sys_UpdateWindows (W_ALL);
1259 }
1260
1261 void Select_PartialTall (void)
1262 {
1263         brush_t *b, *next;
1264         vec3_t  mins, maxs;
1265
1266         if (!QE_SingleBrush ())
1267                 return;
1268
1269   Undo_Start ("select complete tall");
1270   Undo_AddBrushList (&selected_brushes);
1271   Undo_End();
1272
1273         g_qeglobals.d_select_mode = sel_brush;
1274
1275         VectorCopy (selected_brushes.next->mins, mins);
1276         VectorCopy (selected_brushes.next->maxs, maxs);
1277         Select_Delete ();
1278
1279   int nDim1 = (g_pParentWnd->ActiveXY()->GetViewType() == YZ) ? 1 : 0;
1280   int nDim2 = (g_pParentWnd->ActiveXY()->GetViewType() == XY) ? 1 : 2;
1281
1282         for (b=active_brushes.next ; b != &active_brushes ; b=next)
1283         {
1284                 next = b->next;
1285
1286                 if (b->bFiltered)
1287                         continue;
1288
1289                 if ( (b->mins[nDim1] > maxs[nDim1] || b->maxs[nDim1] < mins[nDim1])
1290                         || (b->mins[nDim2] > maxs[nDim2] || b->maxs[nDim2] < mins[nDim2]) )
1291                         continue;
1292
1293
1294                 Brush_RemoveFromList (b);
1295                 Brush_AddToList (b, &selected_brushes);
1296         }
1297
1298         Sys_UpdateWindows (W_ALL);
1299 }
1300
1301 void Select_Touching (void)
1302 {
1303         brush_t *b, *next;
1304         int             i;
1305         vec3_t  mins, maxs;
1306
1307         if (!QE_SingleBrush ())
1308                 return;
1309
1310         g_qeglobals.d_select_mode = sel_brush;
1311
1312         VectorCopy (selected_brushes.next->mins, mins);
1313         VectorCopy (selected_brushes.next->maxs, maxs);
1314
1315         for (b=active_brushes.next ; b != &active_brushes ; b=next)
1316         {
1317                 next = b->next;
1318
1319                 if (b->bFiltered)
1320                         continue;
1321
1322                 for (i=0 ; i<3 ; i++)
1323                         if (b->mins[i] > maxs[i]+1 || b->maxs[i] < mins[i]-1)
1324                                 break;
1325
1326                 if (i == 3)
1327                 {
1328                         Brush_RemoveFromList (b);
1329                         Brush_AddToList (b, &selected_brushes);
1330                 }
1331         }
1332
1333         Sys_UpdateWindows (W_ALL);
1334 }
1335
1336 void Select_Inside (void)
1337 {
1338         brush_t *b, *next;
1339         int             i;
1340         vec3_t  mins, maxs;
1341
1342         if (!QE_SingleBrush ())
1343                 return;
1344
1345   Undo_Start ("select inside");
1346   Undo_AddBrushList (&selected_brushes);
1347   Undo_End();
1348
1349         g_qeglobals.d_select_mode = sel_brush;
1350
1351         VectorCopy (selected_brushes.next->mins, mins);
1352         VectorCopy (selected_brushes.next->maxs, maxs);
1353         Select_Delete ();
1354
1355         for (b=active_brushes.next ; b != &active_brushes ; b=next)
1356         {
1357                 next = b->next;
1358
1359                 if (b->bFiltered)
1360                         continue;
1361
1362                 for (i=0 ; i<3 ; i++)
1363                         if (b->maxs[i] > maxs[i] || b->mins[i] < mins[i])
1364                                 break;
1365                 if (i == 3)
1366                 {
1367                         Brush_RemoveFromList (b);
1368                         Brush_AddToList (b, &selected_brushes);
1369                 }
1370         }
1371
1372         Sys_UpdateWindows (W_ALL);
1373 }
1374
1375 void Select_SelectGroup(entity_t* group)
1376 {
1377         brush_t*  b;
1378         //brush_t*  next;
1379
1380         Undo_Start ("select func group");
1381         Undo_AddBrushList (&selected_brushes);
1382         Undo_End();
1383
1384         Select_Deselect();
1385
1386         b = &group->brushes;
1387
1388         do
1389         {
1390                 b = b->onext;
1391                 Brush_RemoveFromList(b);
1392                 Brush_AddToList(b, &selected_brushes);
1393         } while( b->onext != &group->brushes );
1394
1395         Sys_UpdateWindows (W_ALL);
1396 }
1397
1398
1399 void Select_Ungroup(void)
1400 {
1401         int numselectedgroups;
1402         entity_t        *e;
1403         brush_t         *b,* sb;
1404
1405         numselectedgroups = 0;
1406         for (sb = selected_brushes.next; sb != &selected_brushes; sb = sb->next)
1407         {
1408                 e = sb->owner;
1409
1410                 if (e == world_entity || e->eclass->fixedsize)
1411                 {
1412                         continue;
1413                 }
1414
1415                 for (b = e->brushes.onext; b != &e->brushes; b = e->brushes.onext)
1416                 {
1417                         Entity_UnlinkBrush (b);
1418                         Entity_LinkBrush (world_entity, b);
1419                 }
1420                 Entity_Free (e);
1421                 numselectedgroups++;
1422         }
1423
1424         if (numselectedgroups <= 0)
1425         {
1426                 Sys_Printf("No grouped entities selected.\n");
1427                 return;
1428         }
1429         Sys_Printf("Ungrouped %d entit%s.\n", numselectedgroups, (numselectedgroups == 1)?"y":"ies");
1430         Sys_UpdateWindows (W_ALL);
1431 }
1432
1433 /*!
1434 group selected brushes into specified entity
1435 if an entity is empty afterwards, destroy it
1436 */
1437 void Select_GroupEntity(entity_t* group)
1438 {
1439   entity_t* e;
1440   brush_t *b;
1441
1442   if(group->eclass->fixedsize)
1443   {
1444     Sys_FPrintf (SYS_ERR, "Select_GroupEntity: can't group anything to a fixedsize entity\n");
1445     return;
1446   }
1447
1448   for (b = selected_brushes.next; b != &selected_brushes; b = b->next)
1449   {
1450     if(b->owner->eclass->fixedsize) continue;
1451     e = b->owner;
1452     Entity_UnlinkBrush(b);
1453     Entity_LinkBrush(group, b);
1454     if(e != world_entity && e->brushes.onext == &e->brushes)
1455     {
1456       Undo_AddEntity(e);
1457       Entity_Free(e);
1458     }
1459   }
1460 }
1461
1462 /*!
1463 merge all selected entities together into the first one selected
1464 NOTE: makes use of order of selected_brushes list
1465 can be used to move world brushes in an entity, or to merge several ents together
1466 NOTE: didn't devise a strategy on the epairs, we merge into the first entity and use those
1467 */
1468 void Select_MergeEntity()
1469 {
1470   entity_t* e = NULL;
1471   brush_t* b;
1472   for (b = selected_brushes.next; b != &selected_brushes; b = b->next)
1473   {
1474     if(!b->owner->eclass->fixedsize)
1475     {
1476       e = b->owner;
1477       break;
1478     }
1479   }
1480
1481   if(e != NULL)
1482   {
1483     Select_GroupEntity(e);
1484
1485     int count = 0;
1486     for(b = e->brushes.onext; b != &e->brushes; b=b->onext)
1487     {
1488       //Brush_RemoveFromList (b);
1489           //Brush_AddToList(b, &active_brushes);
1490       count++;
1491     }
1492     Sys_Printf ("Merged %d brushes into %s entity\n", count, ValueForKey (e, "classname"));
1493   }
1494 }
1495
1496 /*
1497 ====================
1498 Select_Seperate
1499 ====================
1500 */
1501 void Select_Seperate( void ) {
1502   Select_GroupEntity( world_entity );
1503 }
1504
1505 /*
1506 ====================
1507 Select_MakeStructural
1508 ====================
1509 */
1510 void Select_MakeStructural (void)
1511 {
1512         brush_t *b;
1513         face_t  *f;
1514
1515         for (b=selected_brushes.next ; b != &selected_brushes ; b=b->next)
1516         {
1517                 for (f=b->brush_faces ; f ; f=f->next)
1518                         f->texdef.contents &= ~CONTENTS_DETAIL;
1519                 b->bFiltered = FilterBrush(b);
1520         }
1521         Select_Deselect ();
1522         Sys_UpdateWindows (W_ALL);
1523 }
1524
1525 void Select_MakeDetail (void)
1526 {
1527         brush_t *b;
1528         face_t  *f;
1529
1530         for (b=selected_brushes.next ; b != &selected_brushes ; b=b->next)
1531         {
1532                 for (f=b->brush_faces ; f ; f=f->next)
1533                         f->texdef.contents |= CONTENTS_DETAIL;
1534                 b->bFiltered = FilterBrush(b);
1535         }
1536         Select_Deselect ();
1537         Sys_UpdateWindows (W_ALL);
1538 }
1539
1540 // brush primitive texture adjustments, use the camera view to map adjustments
1541 // ShiftTextureRelative_BrushPrimit ( s , t ) will shift relative to the texture
1542 void ShiftTextureRelative_Camera(face_t *f, int x, int y)
1543 {
1544   vec3_t vecS, vecT;
1545   vec_t XY[2]; // the values we are going to send for translation
1546   vec_t sgn[2]; // +1 or -1
1547   int axis[2];
1548   CamWnd* pCam;
1549
1550   // get the two relative texture axes for the current texturing
1551   BrushPrimit_GetRelativeAxes(f, vecS, vecT);
1552
1553   // center point of the face, project it on the camera space
1554   vec3_t C;
1555   VectorClear(C);
1556   int i;
1557   for (i=0; i<f->face_winding->numpoints; i++)
1558   {
1559     VectorAdd(C,f->face_winding->points[i],C);
1560   }
1561   VectorScale(C,1.0/f->face_winding->numpoints,C);
1562
1563   pCam = g_pParentWnd->GetCamWnd();
1564   pCam->MatchViewAxes(C, vecS, axis[0], sgn[0]);
1565   pCam->MatchViewAxes(C, vecT, axis[1], sgn[1]);
1566
1567   // this happens when the two directions can't be mapped on two different directions on the screen
1568   // then the move will occur against a single axis
1569   // (i.e. the user is not positioned well enough to send understandable shift commands)
1570   // NOTE: in most cases this warning is not very relevant because the user would use one of the two axes
1571   // for which the solution is easy (the other one being unknown)
1572   // so this warning could be removed
1573   if (axis[0] == axis[1])
1574     Sys_FPrintf(SYS_WRN, "Warning: degenerate in ShiftTextureRelative_Camera\n");
1575
1576   // compute the X Y geometric increments
1577   // those geometric increments will be applied along the texture axes (the ones we computed above)
1578   XY[0] = 0;
1579   XY[1] = 0;
1580   if (x!=0)
1581   {
1582     // moving right/left
1583     XY[axis[0]] += sgn[0]*x;
1584   }
1585   if (y!=0)
1586   {
1587     XY[axis[1]] += sgn[1]*y;
1588   }
1589   // we worked out a move along vecS vecT, and we now it's geometric amplitude
1590   // apply it
1591   ShiftTextureRelative_BrushPrimit(f, XY[0], XY[1]);
1592 }
1593
1594 void Select_ShiftTexture(int x, int y)
1595 {
1596         brush_t         *b;
1597         face_t          *f;
1598
1599   int nFaceCount = g_ptrSelectedFaces.GetSize();
1600
1601         if(selected_brushes.next == &selected_brushes && nFaceCount == 0)
1602                 return;
1603
1604         for (b=selected_brushes.next ; b != &selected_brushes ; b=b->next)
1605         {
1606                 for (f=b->brush_faces ; f ; f=f->next)
1607                 {
1608                         if (g_qeglobals.m_bBrushPrimitMode)
1609                         {
1610         ShiftTextureRelative_Camera( f, x, y );
1611                         }
1612                         else
1613                         {
1614                                 f->texdef.shift[0] += x;
1615                                 f->texdef.shift[1] += y;
1616                         }
1617                 }
1618                 Brush_Build(b,true,true,false,false); // don't filter
1619                 if (b->patchBrush)
1620                 {
1621                         Patch_ShiftTexture(b->pPatch, x, y);
1622                 }
1623         }
1624
1625         if (nFaceCount > 0)
1626         {
1627     for (int i = 0; i < nFaceCount; i++)
1628     {
1629       face_t *selFace = reinterpret_cast<face_t*>(g_ptrSelectedFaces.GetAt(i));
1630       brush_t *selBrush = reinterpret_cast<brush_t*>(g_ptrSelectedFaceBrushes.GetAt(i));
1631                 if (g_qeglobals.m_bBrushPrimitMode)
1632                 {
1633         ShiftTextureRelative_Camera( selFace, x, y );
1634       }
1635                 else
1636                 {
1637                         selFace->texdef.shift[0] += x;
1638                           selFace->texdef.shift[1] += y;
1639                 }
1640                 Brush_Build(selBrush,true,true,false,false); // don't filter
1641     }
1642         }
1643
1644         Sys_UpdateWindows (W_CAMERA);
1645 }
1646
1647 //  setting float as input
1648 void Select_ScaleTexture(float x, float y)
1649 {
1650         brush_t         *b;
1651         face_t          *f;
1652
1653   int nFaceCount = g_ptrSelectedFaces.GetSize();
1654
1655   if(selected_brushes.next == &selected_brushes && nFaceCount == 0)
1656         {
1657                 return;
1658         }
1659
1660         for (b=selected_brushes.next ; b != &selected_brushes ; b=b->next)
1661         {
1662                 for (f=b->brush_faces ; f ; f=f->next)
1663                 {
1664                         if (g_qeglobals.m_bBrushPrimitMode)
1665                         {
1666                                 // apply same scale as the spinner button of the surface inspector
1667                                 float   shift[2];
1668                                 float   rotate;
1669                                 float   scale[2];
1670                                 brushprimit_texdef_t bp;
1671                                 // compute normalized texture matrix
1672                                 ConvertTexMatWithQTexture( &f->brushprimit_texdef, f->d_texture, &bp, NULL );
1673                                 // compute fake shift scale rot
1674                                 TexMatToFakeTexCoords( bp.coords, shift, &rotate, scale );
1675                                 // update
1676                                 scale[0]+=static_cast<float>(x)*0.1;
1677                                 scale[1]+=static_cast<float>(y)*0.1;
1678                                 // compute new normalized texture matrix
1679                                 FakeTexCoordsToTexMat( shift, rotate, scale, bp.coords );
1680                                 // apply to face texture matrix
1681                                 ConvertTexMatWithQTexture( &bp, NULL, &f->brushprimit_texdef, f->d_texture );
1682                         }
1683                         else
1684                         {
1685                                 f->texdef.scale[0] += x;
1686                                 f->texdef.scale[1] += y;
1687                         }
1688                 }
1689                 Brush_Build(b,true,true,false,false); // don't filter
1690                 if (b->patchBrush)
1691                 {
1692                         Patch_ScaleTexture(b->pPatch, x, y);
1693                 }
1694         }
1695
1696         if (nFaceCount > 0)
1697         {
1698     for (int i = 0; i < nFaceCount; i++)
1699     {
1700       face_t *selFace = reinterpret_cast<face_t*>(g_ptrSelectedFaces.GetAt(i));
1701       brush_t *selBrush = reinterpret_cast<brush_t*>(g_ptrSelectedFaceBrushes.GetAt(i));
1702                   if (g_qeglobals.m_bBrushPrimitMode)
1703                   {
1704                           float shift[2];
1705                           float rotate;
1706                           float scale[2];
1707                           brushprimit_texdef_t bp;
1708                           ConvertTexMatWithQTexture( &selFace->brushprimit_texdef, selFace->d_texture, &bp, NULL );
1709                           TexMatToFakeTexCoords( bp.coords, shift, &rotate, scale );
1710                           scale[0]+=static_cast<float>(x)*0.1;
1711                           scale[1]+=static_cast<float>(y)*0.1;
1712                           FakeTexCoordsToTexMat( shift, rotate, scale, bp.coords );
1713                           ConvertTexMatWithQTexture( &bp, NULL, &selFace->brushprimit_texdef, selFace->d_texture );
1714                   }
1715                   else
1716                   {
1717                           selFace->texdef.scale[0] += x;
1718                           selFace->texdef.scale[1] += y;
1719                   }
1720                   Brush_Build(selBrush,true,true,false,false); // don't filter
1721     }
1722         }
1723
1724         Sys_UpdateWindows (W_CAMERA);
1725 }
1726
1727 void Select_RotateTexture(int amt)
1728 {
1729         brush_t         *b;
1730         face_t          *f;
1731
1732   int nFaceCount = g_ptrSelectedFaces.GetSize();
1733
1734   if(selected_brushes.next == &selected_brushes && nFaceCount == 0)
1735         {
1736                 return;
1737         }
1738
1739         for (b=selected_brushes.next ; b != &selected_brushes ; b=b->next)
1740         {
1741                 for (f=b->brush_faces ; f ; f=f->next)
1742                 {
1743                         if (g_qeglobals.m_bBrushPrimitMode)
1744                         {
1745                                 // apply same scale as the spinner button of the surface inspector
1746                                 float   shift[2];
1747                                 float   rotate;
1748                                 float   scale[2];
1749                                 brushprimit_texdef_t bp;
1750                                 // compute normalized texture matrix
1751                                 ConvertTexMatWithQTexture( &f->brushprimit_texdef, f->d_texture, &bp, NULL );
1752                                 // compute fake shift scale rot
1753                                 TexMatToFakeTexCoords( bp.coords, shift, &rotate, scale );
1754                                 // update
1755                                 rotate += amt;
1756                                 // compute new normalized texture matrix
1757                                 FakeTexCoordsToTexMat( shift, rotate, scale, bp.coords );
1758                                 // apply to face texture matrix
1759                                 ConvertTexMatWithQTexture( &bp, NULL, &f->brushprimit_texdef, f->d_texture );
1760                         }
1761                         else
1762                         {
1763                                 f->texdef.rotate += amt;
1764                                 f->texdef.rotate = static_cast<int>(f->texdef.rotate) % 360;
1765                         }
1766                 }
1767                 Brush_Build(b,true,true,false,false); // don't filter
1768                 if (b->patchBrush)
1769                 {
1770                         //Patch_RotateTexture(b->nPatchID, amt);
1771                         Patch_RotateTexture(b->pPatch, amt);
1772                 }
1773         }
1774
1775         if (nFaceCount > 0)
1776         {
1777     for (int i = 0; i < nFaceCount; i++)
1778     {
1779       face_t *selFace = reinterpret_cast<face_t*>(g_ptrSelectedFaces.GetAt(i));
1780       brush_t *selBrush = reinterpret_cast<brush_t*>(g_ptrSelectedFaceBrushes.GetAt(i));
1781                   if (g_qeglobals.m_bBrushPrimitMode)
1782                   {
1783                           float shift[2];
1784                           float rotate;
1785                           float scale[2];
1786                           brushprimit_texdef_t bp;
1787                           ConvertTexMatWithQTexture( &selFace->brushprimit_texdef, selFace->d_texture, &bp, NULL );
1788                           TexMatToFakeTexCoords( bp.coords, shift, &rotate, scale );
1789                           rotate += amt;
1790                           FakeTexCoordsToTexMat( shift, rotate, scale, bp.coords );
1791                           ConvertTexMatWithQTexture( &bp, NULL, &selFace->brushprimit_texdef, selFace->d_texture );
1792                   }
1793                   else
1794                   {
1795                           selFace->texdef.rotate += amt;
1796                           selFace->texdef.rotate = static_cast<int>(selFace->texdef.rotate) % 360;
1797                   }
1798                   Brush_Build(selBrush,true,true,false,false); // don't filter
1799     }
1800         }
1801
1802         Sys_UpdateWindows (W_CAMERA);
1803 }
1804
1805 // TTimo modified to handle shader architecture:
1806 // expects shader names at input, comparison relies on shader names .. texture names no longer relevant
1807 void FindReplaceTextures(const char* pFind, const char* pReplace, bool bSelected, bool bForce, bool bSelectMatchingFaces)
1808 {
1809   if (strchr(pFind, ' ') || strchr(pReplace, ' '))
1810   {
1811     Sys_FPrintf(SYS_WRN, "FindReplaceTextures: '%s' or '%s' have spaces, aborted\n", pFind, pReplace);
1812     return;
1813   }
1814
1815         brush_t* pList = (bSelected) ? &selected_brushes : &active_brushes;
1816         if (!bSelected)
1817                 Select_Deselect();
1818
1819   //++timo BP mode: replacing a texture in BP mode is not that easy, you need to recompute the texture matrix
1820   // if the size of the replacing texture differs, otherwise you get wrong scaling
1821   if (g_qeglobals.m_bBrushPrimitMode)
1822     Sys_Printf("TODO: finalize find/replace code for brush primitives");
1823
1824   CPtrArray mFaces;
1825   for (brush_t* pBrush = pList->next ; pBrush != pList; pBrush = pBrush->next)
1826   {
1827     if (!bSelectMatchingFaces && pBrush->patchBrush)
1828     {
1829       Patch_FindReplaceTexture(pBrush, pFind, pReplace, bForce);
1830     }
1831
1832     bool found = false; //spog
1833     for (face_t* pFace = pBrush->brush_faces; pFace; pFace = pFace->next)
1834     {
1835       if(bForce || strcmpi(pFace->pShader->getName(), pFind) == 0)
1836       {
1837         if (!bSelectMatchingFaces) {
1838           pFace->pShader->DecRef();
1839           pFace->pShader = QERApp_Shader_ForName( pReplace );
1840           pFace->pShader->IncRef();
1841           pFace->d_texture = pFace->pShader->getTexture();
1842           pFace->texdef.SetName(pReplace);
1843           found = true;
1844         } else if (bSelectMatchingFaces) {
1845           mFaces.Add(pFace);
1846         }
1847       }
1848     }
1849
1850     if (found) // spog - speed increase, only build brushes that changed
1851       Brush_Build(pBrush);
1852
1853   }
1854
1855   if (bSelectMatchingFaces) {
1856     if (bSelected)
1857       Select_Deselect();
1858
1859     int nSize = mFaces.GetSize();
1860     for (int i = 0; i < nSize; i++) {
1861       g_SelectedFaces.Add(reinterpret_cast<face_t *>(mFaces.GetAt(i)));
1862     }
1863   }
1864
1865   Sys_UpdateWindows (W_CAMERA);
1866 }
1867
1868 void Select_AllOfType()
1869 {
1870         brush_t *b, *next;
1871         entity_t        *e;
1872   // if no brush selected, we will select based on texture
1873   //   the first selected face's texture if any, or the current texture
1874   // if a brush is selected, we will select entities (first non-worldspawn owner in selected brushes)
1875         if (selected_brushes.next == &selected_brushes)
1876         {
1877
1878     CString strName;
1879     if (g_ptrSelectedFaces.GetSize() == 0)
1880     {
1881       strName = g_qeglobals.d_texturewin.texdef.GetName();
1882     }
1883     else
1884     {
1885       face_t *selFace = reinterpret_cast<face_t*>(g_ptrSelectedFaces.GetAt(0));
1886       strName = selFace->texdef.GetName();
1887     }
1888
1889     Sys_Printf("Selecting all brushes with the texture %s\n", strName.GetBuffer());
1890
1891     Select_Deselect();
1892           for (b=active_brushes.next ; b != &active_brushes ; b=next)
1893     {
1894                   next = b->next;
1895
1896       if (b->bFiltered)
1897             continue;
1898
1899       if (b->patchBrush)
1900       {
1901         if (strcmpi(strName, b->pPatch->pShader->getName()) == 0)
1902         {
1903                             Brush_RemoveFromList (b);
1904                             Brush_AddToList (b, &selected_brushes);
1905         }
1906       }
1907       else
1908       {
1909         for (face_t* pFace = b->brush_faces; pFace; pFace = pFace->next)
1910         {
1911           if (strcmpi(strName, pFace->texdef.GetName()) == 0)
1912           {
1913                               Brush_RemoveFromList (b);
1914                               Brush_AddToList (b, &selected_brushes);
1915           }
1916         }
1917       }
1918     }
1919     Sys_UpdateWindows(W_ALL);
1920     return;
1921   }
1922
1923
1924   b = selected_brushes.next;
1925         e = b->owner;
1926
1927   if (e != NULL)
1928   {
1929     if (e != world_entity)
1930     {
1931       CString strName = e->eclass->name;
1932       CString strKey, strVal;
1933       bool bCriteria = GetSelectAllCriteria(strKey, strVal);
1934       Sys_Printf("Selecting all %s entities\n", strName.GetBuffer());
1935       Select_Deselect();
1936
1937             for (b=active_brushes.next ; b != &active_brushes ; b=next)
1938         {
1939                     next = b->next;
1940
1941                         if (b->bFiltered)
1942                         continue;
1943
1944         e = b->owner;
1945         if (e != NULL)
1946         {
1947           if (strcmpi(e->eclass->name, strName) == 0)
1948           {
1949             bool doIt = true;
1950             if (bCriteria) {
1951               CString str = ValueForKey (e, strKey);
1952               if (str.CompareNoCase(strVal) != 0) {
1953                 doIt = false;
1954               }
1955             }
1956             if (doIt) {
1957                         Brush_RemoveFromList (b);
1958                         Brush_AddToList (b, &selected_brushes);
1959             }
1960           }
1961         }
1962       }
1963     }
1964   }
1965         Sys_UpdateWindows (W_ALL);
1966
1967 }
1968
1969 void Select_Reselect()
1970 {
1971   Select_Brush(selected_brushes.next);
1972   Sys_UpdateWindows (W_ALL);
1973 }
1974
1975
1976 void Select_FitTexture(int nHeight, int nWidth)
1977 {
1978         brush_t         *b;
1979
1980   int nFaceCount = g_ptrSelectedFaces.GetSize();
1981
1982   if(selected_brushes.next == &selected_brushes && nFaceCount == 0)
1983                 return;
1984
1985   for (b=selected_brushes.next ; b != &selected_brushes ; b=b->next)
1986         {
1987     Brush_FitTexture(b, nHeight, nWidth);
1988                 Brush_Build(b,true,true,false,false); // don't filter
1989         }
1990
1991         if (nFaceCount > 0)
1992         {
1993     for (int i = 0; i < nFaceCount; i++)
1994     {
1995       face_t *selFace = reinterpret_cast<face_t*>(g_ptrSelectedFaces.GetAt(i));
1996       brush_t *selBrush = reinterpret_cast<brush_t*>(g_ptrSelectedFaceBrushes.GetAt(i));
1997       Face_FitTexture(selFace, nHeight, nWidth);
1998                 Brush_Build(selBrush,true,true,false,false); // don't filter
1999     }
2000         }
2001
2002         Sys_UpdateWindows (W_CAMERA);
2003 }
2004
2005 void Select_Hide()
2006 {
2007   for (brush_t* b=selected_brushes.next ; b && b != &selected_brushes ; b=b->next)
2008   {
2009         b->hiddenBrush = true;
2010     b->bFiltered = true;
2011   }
2012   Sys_UpdateWindows (W_ALL);
2013 }
2014
2015 void Select_ShowAllHidden()
2016 {
2017   brush_t* b;
2018   for (b=selected_brushes.next ; b && b != &selected_brushes ; b=b->next)
2019   {
2020         if (b->hiddenBrush)
2021         {
2022                 b->hiddenBrush = false;
2023                 b->bFiltered = FilterBrush(b);
2024         }
2025   }
2026   for (b=active_brushes.next ; b && b != &active_brushes ; b=b->next)
2027   {
2028         if (b->hiddenBrush)
2029         {
2030                 b->hiddenBrush = false;
2031                 b->bFiltered = FilterBrush(b);
2032         }
2033   }
2034   Sys_UpdateWindows (W_ALL);
2035 }
2036
2037
2038 /*
2039 ============
2040 Select_Invert
2041 ============
2042 */
2043 void Select_Invert(void)
2044 {
2045   brush_t *next, *prev, *b;
2046
2047   Sys_Printf("inverting selection...\n");
2048
2049   next = active_brushes.next;
2050   prev = active_brushes.prev;
2051   if (selected_brushes.next != &selected_brushes)
2052   {
2053     active_brushes.next = selected_brushes.next;
2054     active_brushes.prev = selected_brushes.prev;
2055     active_brushes.next->prev = &active_brushes;
2056     active_brushes.prev->next = &active_brushes;
2057   }
2058   else
2059   {
2060     active_brushes.next = &active_brushes;
2061     active_brushes.prev = &active_brushes;
2062   }
2063   if (next != &active_brushes)
2064   {
2065     selected_brushes.next = next;
2066     selected_brushes.prev = prev;
2067     selected_brushes.next->prev = &selected_brushes;
2068     selected_brushes.prev->next = &selected_brushes;
2069   }
2070   else
2071   {
2072     selected_brushes.next = &selected_brushes;
2073     selected_brushes.prev = &selected_brushes;
2074   }
2075
2076   // now check if any hidden brush is selected
2077   for (b = selected_brushes.next; b != &selected_brushes; )
2078   {
2079         if (b->patchBrush)
2080                 b->pPatch->bSelected = true;
2081
2082     if (b->bFiltered)
2083     {
2084       brush_t *pb = b;
2085                         b = b->next;
2086       Brush_RemoveFromList (pb);
2087       Brush_AddToList (pb, &active_brushes);
2088     }
2089     else b = b->next;
2090
2091   }
2092
2093   for (b = active_brushes.next; b != &active_brushes; b = b->next)
2094   {
2095           if (b->patchBrush)
2096     {
2097                   b->pPatch->bSelected = false;
2098     }
2099   }
2100
2101   // since invert selection only works at the brush level,
2102   // set g_qeglobals.d_select_mode accordingly
2103   g_qeglobals.d_select_mode = sel_brush;
2104
2105   // since invert selection only works at the brush level,
2106   // set g_qeglobals.d_select_mode accordingly
2107   g_qeglobals.d_select_mode = sel_brush;
2108
2109   Sys_UpdateWindows(W_ALL);
2110
2111   Sys_Printf("done.\n");
2112 }
2113
2114 #ifdef ENABLE_GROUPS
2115 /*
2116 ===========
2117 Select_Name
2118 ===========
2119 */
2120 void Select_Name(const char *pName)
2121 {
2122         if (g_qeglobals.m_bBrushPrimitMode)
2123   {
2124           for (brush_t* b=selected_brushes.next ; b && b != &selected_brushes ; b=b->next)
2125           {
2126       Brush_SetEpair(b, "Name", pName);
2127           }
2128   }
2129 }
2130
2131 /*
2132 =================
2133 Select_AddToGroup
2134 add selected brushes to a group, update the tree
2135 =================
2136 */
2137 void Select_AddToGroup(const char *pName)
2138 {
2139         if (g_qeglobals.m_bBrushPrimitMode)
2140   {
2141           for (brush_t* b=selected_brushes.next ; b && b != &selected_brushes ; b=b->next)
2142           {
2143       Brush_SetEpair(b, "group", pName);
2144                         Group_AddToProperGroup(b);
2145           }
2146   }
2147 }
2148 #endif