enable size display by default
[xonotic/netradiant.git] / contrib / bobtoolz / funchandlers-GTK.cpp
1 /*
2 BobToolz plugin for GtkRadiant
3 Copyright (C) 2001 Gordon Biggans
4
5 This library is free software; you can redistribute it and/or
6 modify it under the terms of the GNU Lesser General Public
7 License as published by the Free Software Foundation; either
8 version 2.1 of the License, or (at your option) any later version.
9
10 This library is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13 Lesser General Public License for more details.
14
15 You should have received a copy of the GNU Lesser General Public
16 License along with this library; if not, write to the Free Software
17 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
18 */
19
20 #include "funchandlers.h"
21
22 #ifdef WIN32
23 #pragma warning(disable : 4786)
24 #endif
25
26 #include "dialogs/dialogs-gtk.h"
27
28 #include <list>
29 #include "str.h"
30
31 #include "DPoint.h"
32 #include "DPlane.h"
33 #include "DBrush.h"
34 #include "DEPair.h"
35 #include "DPatch.h"
36 #include "DEntity.h"
37 #include "DShape.h"
38 #include "DBobView.h"
39 #include "DVisDrawer.h"
40 #include "DTrainDrawer.h"
41
42 #include "misc.h"
43 #include "ScriptParser.h"
44 #include "DTreePlanter.h"
45
46 #include "shapes.h"
47 #include "lists.h"
48 #include "visfind.h"
49
50 #include "iundo.h"
51
52 #include <vector>
53 #include <list>
54 #include <map>
55 #include <algorithm>
56
57 #include "scenelib.h"
58
59 // for autocaulk
60 std::list<Str> exclusionList;           // whole brush exclusion
61 std::list<Str> exclusionList_Face;      // single face exclusion
62
63 bool el1Loaded =                false;
64 bool el2Loaded =                false;
65 bool clrLst1Loaded =    false;
66 bool clrLst2Loaded =    false;
67
68 DBobView*               g_PathView =            NULL;
69 DVisDrawer*             g_VisView =                     NULL;
70 DTrainDrawer*   g_TrainView =           NULL;
71 DTreePlanter*   g_TreePlanter =         NULL;
72 // -------------
73
74 //========================//
75 //    Helper Functions    //
76 //========================//
77
78 void LoadLists()
79 {
80         char buffer[256];
81
82         if(!el1Loaded)
83                 el1Loaded = LoadExclusionList(GetFilename(buffer, "bt/bt-el1.txt"), &exclusionList);
84         if(!el2Loaded)
85                 el2Loaded = LoadExclusionList(GetFilename(buffer, "bt/bt-el2.txt"), &exclusionList_Face);
86 }
87
88
89 //========================//
90 //     Main Functions     //
91 //========================//
92
93 void DoIntersect()
94 {
95   UndoableCommand undo("bobToolz.intersect");
96         IntersectRS rs;
97
98         if(DoIntersectBox(&rs) == eIDCANCEL)
99                 return;
100
101         if(rs.nBrushOptions == BRUSH_OPT_SELECTED)
102         {
103                 if( GlobalSelectionSystem().countSelected() < 2 )
104                 {
105                         DoMessageBox("Invalid number of brushes selected, choose at least 2", "Error", eMB_OK);
106                         return; 
107                 }
108         }
109
110         DEntity world;
111
112         switch(rs.nBrushOptions)
113         {
114         case BRUSH_OPT_SELECTED:
115                 {
116                         world.LoadSelectedBrushes();
117                         break;
118                 }
119         case BRUSH_OPT_WHOLE_MAP:
120                 {
121                         world.LoadFromEntity(GlobalRadiant().getMapWorldEntity(), false);
122                         break;
123                 }
124         }
125
126         world.RemoveNonCheckBrushes(&exclusionList, rs.bUseDetail);
127
128         bool* pbSelectList;
129         if(rs.bDuplicateOnly)
130                 pbSelectList = world.BuildDuplicateList();
131         else
132                 pbSelectList = world.BuildIntersectList();
133
134         world.SelectBrushes(pbSelectList);
135
136         delete[] pbSelectList;
137 }
138
139 void DoPolygonsTB()
140 {
141   DoPolygons();
142 }
143
144 void DoPolygons()
145 {
146   UndoableCommand undo("bobToolz.polygons");
147         // ensure we have something selected
148         if( GlobalSelectionSystem().countSelected() != 1 )
149         {
150                 DoMessageBox("Invalid number of brushes selected, choose 1 only", "Error", eMB_OK);
151                 return; 
152         }
153
154         PolygonRS rs;
155
156         // ask user for type, size, etc....
157         if(DoPolygonBox(&rs) == eIDOK)
158         {
159                 DShape poly;
160
161     vec3_t vMin, vMax;
162
163     {
164       scene::Instance& instance = GlobalSelectionSystem().ultimateSelected();
165       VectorSubtract(instance.worldAABB().origin, instance.worldAABB().extents, vMin);
166       VectorAdd(instance.worldAABB().origin, instance.worldAABB().extents, vMax);
167
168       Path_deleteTop(instance.path());
169     }
170
171                 if(rs.bInverse)
172                         poly.BuildInversePrism(vMin, vMax, rs.nSides, rs.bAlignTop);
173                 else
174                 {
175                         if(rs.bUseBorder)
176                                 poly.BuildBorderedPrism(vMin, vMax, rs.nSides, rs.nBorderWidth, rs.bAlignTop);
177                         else
178                                 poly.BuildRegularPrism(vMin, vMax, rs.nSides, rs.bAlignTop);
179
180                 }
181
182                 poly.Commit();
183         }
184 }
185
186 void DoFixBrushes()
187 {
188   UndoableCommand undo("bobToolz.fixBrushes");
189         DMap world;
190         world.LoadAll();
191
192         int count = world.FixBrushes();
193         
194         globalOutputStream() << count << " invalid/duplicate planes removed\n";
195 }
196
197 void DoResetTextures()
198 {
199   UndoableCommand undo("bobToolz.resetTextures");
200         static ResetTextureRS rs;
201
202   const char* texName;
203         if(1/*g_SelectedFaceTable.m_pfnGetSelectedFaceCount() != 1*/)
204   {
205     texName = NULL;
206   }
207   else
208   {
209     texName = GetCurrentTexture();
210           strcpy(rs.textureName, GetCurrentTexture());
211   }
212
213   EMessageBoxReturn ret;
214         if((ret = DoResetTextureBox(&rs)) == eIDCANCEL)
215                 return;  
216
217   if(rs.bResetTextureName)
218     texName = rs.textureName;
219
220   if(ret == eIDOK)
221   {
222           DEntity world;
223           world.LoadSelectedBrushes();
224           world.ResetTextures(texName,              rs.fScale,      rs.fShift,      rs.rotation, rs.newTextureName, 
225                         rs.bResetTextureName, rs.bResetScale, rs.bResetShift, rs.bResetRotation, true);
226   }
227   else
228   {
229           DMap world;
230     world.LoadAll(true);
231     world.ResetTextures(texName,              rs.fScale,      rs.fShift,      rs.rotation, rs.newTextureName, 
232                         rs.bResetTextureName, rs.bResetScale, rs.bResetShift, rs.bResetRotation);
233   }
234 }
235
236 void DoBuildStairs()
237 {
238   UndoableCommand undo("bobToolz.buildStairs");
239         BuildStairsRS rs;
240
241         strcpy(rs.mainTexture, GetCurrentTexture());
242
243         // ensure we have something selected
244         if( GlobalSelectionSystem().countSelected() != 1 )
245         {
246                 DoMessageBox("Invalid number of brushes selected, choose 1 only", "Error", eMB_OK);
247                 return; 
248         }
249
250         // ask user for type, size, etc....
251         if(DoBuildStairsBox(&rs) == eIDOK)
252         {
253     vec3_t vMin, vMax;
254
255     {
256       scene::Instance& instance = GlobalSelectionSystem().ultimateSelected();
257       VectorSubtract(instance.worldAABB().origin, instance.worldAABB().extents, vMin);
258       VectorAdd(instance.worldAABB().origin, instance.worldAABB().extents, vMax);
259     }
260
261                 // calc brush size
262                 vec3_t size;
263                 VectorSubtract(vMax, vMin, size);
264
265                 if(((int)size[2] % rs.stairHeight) != 0)
266                 {
267                         // stairs must fit evenly into brush
268                         DoMessageBox("Invalid stair height\nHeight of block must be divisable by stair height", "Error", eMB_OK);
269                 }
270                 else
271                 {
272       {
273         scene::Instance& instance = GlobalSelectionSystem().ultimateSelected();
274         Path_deleteTop(instance.path());
275       }
276                                                 
277                         // Get Step Count
278                         int numSteps = (int)size[2] / rs.stairHeight;
279                         
280                         if(rs.style == STYLE_CORNER)
281                         {
282                                 BuildCornerStairs(vMin, vMax, numSteps, rs.mainTexture, rs.riserTexture);
283                         }
284                         else
285                         {
286
287                                 // Get Step Dimensions
288                                 float stairHeight = (float)rs.stairHeight;
289                                 float stairWidth;
290                                 if((rs.direction == MOVE_EAST) || (rs.direction == MOVE_WEST))
291                                         stairWidth = (size[0])/numSteps;
292                                 else
293                                         stairWidth = (size[1])/numSteps;
294
295
296                                 // Build Base For Stair (bob's style)
297                                 if(rs.style == STYLE_BOB)
298                                         Build_Wedge(rs.direction, vMin, vMax, true);
299
300
301                                 // Set First Step Starting Position
302                                 vMax[2] = vMin[2] + stairHeight;
303                                 SetInitialStairPos(rs.direction, vMin, vMax, stairWidth);
304
305
306                                 // Build The Steps
307                                 for(int i = 0; i < numSteps; i++)
308                                 {
309                                         if(rs.style == STYLE_BOB)
310                                                 Build_StairStep_Wedge(rs.direction, vMin, vMax, rs.mainTexture, rs.riserTexture, rs.bUseDetail);
311                                         else if(rs.style == STYLE_ORIGINAL)
312                                                 Build_StairStep(vMin, vMax, rs.mainTexture, rs.riserTexture, rs.direction);
313
314                                         // get step into next position
315                                         MoveBlock(rs.direction, vMin, vMax, stairWidth);
316                                         vMax[2] += stairHeight;
317                                         if(rs.style == STYLE_BOB)
318                                                 vMin[2] += stairHeight; // wedge bottom must be raised
319                                 }
320                         }
321                 }
322         }
323 }
324
325 void DoBuildDoors()
326 {
327   UndoableCommand undo("bobToolz.buildDoors");
328         // ensure we have something selected
329         if( GlobalSelectionSystem().countSelected() != 1 )
330         {
331                 DoMessageBox("Invalid number of brushes selected, choose 1 only", "Error", eMB_OK);
332                 return; 
333         }
334
335   DoorRS rs;
336         strcpy(rs.mainTexture, GetCurrentTexture());
337
338         if(DoDoorsBox(&rs) == eIDOK)
339         {
340     vec3_t vMin, vMax;
341
342     {
343       scene::Instance& instance = GlobalSelectionSystem().ultimateSelected();
344       VectorSubtract(instance.worldAABB().origin, instance.worldAABB().extents, vMin);
345       VectorAdd(instance.worldAABB().origin, instance.worldAABB().extents, vMax);
346       Path_deleteTop(instance.path());
347     }
348
349                 BuildDoorsX2(vMin, vMax, 
350                         rs.bScaleMainH, rs.bScaleMainV,
351                         rs.bScaleTrimH, rs.bScaleTrimV,
352                         rs.mainTexture, rs.trimTexture,
353                         rs.nOrientation);       // shapes.cpp
354         }
355 }
356
357 void DoPathPlotter()
358 {
359   UndoableCommand undo("bobToolz.pathPlotter");
360         PathPlotterRS rs;
361         EMessageBoxReturn ret = DoPathPlotterBox(&rs);
362         if(ret == eIDCANCEL)
363                 return;
364         if(ret == eIDNO)
365         {
366                 if(g_PathView)
367                         delete g_PathView;
368                 return;
369         }
370
371         // ensure we have something selected
372         if( GlobalSelectionSystem().countSelected() != 1 )
373         {
374                 DoMessageBox("Invalid number of brushes selected, choose 1 only", "Error", eMB_OK);
375                 return; 
376         }
377
378   Entity* entity = Node_getEntity(GlobalSelectionSystem().ultimateSelected().path().top());
379   if(entity != 0)
380   {
381     DBobView_setEntity(*entity, rs.fMultiplier, rs.nPoints, rs.fGravity, rs.bNoUpdate, rs.bShowExtra);
382   }
383 }
384
385 void DoPitBuilder()
386 {
387   UndoableCommand undo("bobToolz.pitBuilder");
388         // ensure we have something selected
389         if( GlobalSelectionSystem().countSelected() != 1 )
390         {
391                 DoMessageBox("Invalid number of brushes selected, choose 1 only", "Error", eMB_OK);
392                 return; 
393         }
394
395   vec3_t vMin, vMax;
396
397   scene::Instance& instance = GlobalSelectionSystem().ultimateSelected();
398   VectorSubtract(instance.worldAABB().origin, instance.worldAABB().extents, vMin);
399   VectorAdd(instance.worldAABB().origin, instance.worldAABB().extents, vMax);
400
401         DShape pit;
402
403         if(pit.BuildPit(vMin, vMax))
404         {
405                 pit.Commit();
406
407     Path_deleteTop(instance.path());
408         }
409         else
410                 DoMessageBox("Failed To Make Pit\nTry Making The Brush Bigger", "Error", eMB_OK);
411 }
412
413 void DoMergePatches()
414 {
415   UndoableCommand undo("bobToolz.mergePatch");
416   patch_merge_t merge_info;
417   DPatch mrgPatches[2];
418   int i;
419
420         // ensure we have something selected
421         if( GlobalSelectionSystem().countSelected() != 2 )
422         {
423                 DoMessageBox("Invalid number of patches selected, choose 2 only", "Error", eMB_OK);
424                 return; 
425         }
426
427   scene::Instance* patches[2];
428   patches[0] = &GlobalSelectionSystem().ultimateSelected();
429   patches[1] = &GlobalSelectionSystem().penultimateSelected();
430
431   for (i = 0; i < 2; i++)
432   {
433     if (!Node_isPatch(patches[i]->path().top()))
434     {
435       DoMessageBox("You must select ONLY patches", "Error", eMB_OK);
436       return; 
437     }
438
439     mrgPatches[i].LoadFromPatch(*patches[i]);
440   }
441
442   /*  mrgPatches[0].Transpose();
443       mrgPatches[0].RemoveFromRadiant();
444       mrgPatches[0].BuildInRadiant();*/
445
446   merge_info = mrgPatches[0].IsMergable(&mrgPatches[1]);
447
448   if (merge_info.mergable)
449   {
450     globalOutputStream() << merge_info.pos1 << " " <<  merge_info.pos2;
451
452     globalOutputStream() << "Patches Mergable\n";
453     DPatch* newPatch = mrgPatches[0].MergePatches(merge_info, &mrgPatches[0], &mrgPatches[1]);
454
455     /*                mrgPatches[0].RemoveFromRadiant();
456     mrgPatches[0].BuildInRadiant();
457     
458       mrgPatches[1].RemoveFromRadiant();
459       mrgPatches[1].BuildInRadiant();
460       
461         
462     delete newPatch;*/
463
464     if (!newPatch)
465     {
466     } else
467     {
468       Path_deleteTop(patches[0]->path());
469       Path_deleteTop(patches[1]->path());
470
471       newPatch->BuildInRadiant();
472       delete newPatch;
473     }
474   }
475   else
476   {
477     globalOutputStream() << "bobToolz.mergePatch: the selected patches are not mergable\n";
478   }
479 }
480
481 void DoSplitPatch() {
482   UndoableCommand undo("bobToolz.splitPatch");
483
484         DPatch patch;
485
486         // ensure we have something selected
487         if( GlobalSelectionSystem().countSelected() != 1 )
488         {
489                 DoMessageBox("Invalid number of patches selected, choose 1 only", "Error", eMB_OK);
490                 return; 
491         }
492
493   scene::Instance& instance = GlobalSelectionSystem().ultimateSelected();
494
495         if( !Node_isPatch(instance.path().top()) ) {
496                 DoMessageBox("You must select ONLY patches", "Error", eMB_OK);
497                 return; 
498         }
499
500         patch.LoadFromPatch(instance);
501
502         std::list<DPatch> patchList = patch.Split();
503         for(std::list<DPatch>::iterator patches = patchList.begin(); patches != patchList.end(); patches++) {
504                 (*patches).BuildInRadiant();
505         }
506
507         Path_deleteTop(instance.path());
508 }
509
510 void DoSplitPatchCols() {
511         UndoableCommand undo("bobToolz.splitPatchCols");
512         
513         DPatch patch;
514         
515         // ensure we have something selected
516         if( GlobalSelectionSystem().countSelected() != 1 )
517         {
518                 DoMessageBox("Invalid number of patches selected, choose 1 only", "Error", eMB_OK);
519                 return; 
520         }
521         
522         scene::Instance& instance = GlobalSelectionSystem().ultimateSelected();
523         
524         if( !Node_isPatch(instance.path().top()) ) {
525                 DoMessageBox("You must select ONLY patches", "Error", eMB_OK);
526                 return; 
527         }
528         
529         patch.LoadFromPatch(instance);
530         
531         std::list<DPatch> patchList = patch.SplitCols();
532         for(std::list<DPatch>::iterator patches = patchList.begin(); patches != patchList.end(); patches++) {
533                 (*patches).BuildInRadiant();
534         }
535         
536         Path_deleteTop(instance.path());
537 }
538
539 void DoSplitPatchRows() {
540         UndoableCommand undo("bobToolz.splitPatchRows");
541         
542         DPatch patch;
543         
544         // ensure we have something selected
545         if( GlobalSelectionSystem().countSelected() != 1 )
546         {
547                 DoMessageBox("Invalid number of patches selected, choose 1 only", "Error", eMB_OK);
548                 return; 
549         }
550         
551         scene::Instance& instance = GlobalSelectionSystem().ultimateSelected();
552         
553         if( !Node_isPatch(instance.path().top()) ) {
554                 DoMessageBox("You must select ONLY patches", "Error", eMB_OK);
555                 return; 
556         }
557         
558         patch.LoadFromPatch(instance);
559         
560         std::list<DPatch> patchList = patch.SplitRows();
561         for(std::list<DPatch>::iterator patches = patchList.begin(); patches != patchList.end(); patches++) {
562                 (*patches).BuildInRadiant();
563         }
564         
565         Path_deleteTop(instance.path());
566 }
567
568 void DoVisAnalyse()
569 {
570         char filename[1024];
571
572         if( GlobalSelectionSystem().countSelected() == 0 )
573         {
574                 if(g_VisView) 
575                 {
576                         delete g_VisView;
577                         return;
578                 }
579         }
580
581         // ensure we have something selected
582         if( GlobalSelectionSystem().countSelected() != 1 )
583         {
584                 DoMessageBox("Invalid number of objects selected, choose 1 only", "Error", eMB_OK);
585                 return; 
586         }
587
588   scene::Instance& brush = GlobalSelectionSystem().ultimateSelected();
589
590         DBrush orgBrush;
591         orgBrush.LoadFromBrush(brush, false);
592
593         orgBrush.BuildBounds();
594         vec3_t origin;
595         origin[0] = (orgBrush.bbox_max[0] + orgBrush.bbox_min[0])/2.f;
596         origin[1] = (orgBrush.bbox_max[1] + orgBrush.bbox_min[1])/2.f;
597         origin[2] = (orgBrush.bbox_max[2] + orgBrush.bbox_min[2])/2.f;
598
599
600   const char* rad_filename = GlobalRadiant().getMapName();
601         if(!rad_filename)
602         {
603                 DoMessageBox("An Error Occurred While Trying\n To Get The Map Filename", "Error", eMB_OK);
604                 return;
605         }
606
607         strcpy(filename, rad_filename);
608                 
609         char* ext = strrchr(filename, '.')+1;
610         strcpy(ext, "bsp");// rename the extension
611
612         std::list<DWinding*> *pointList = BuildTrace(filename, origin);
613
614         if(!g_VisView)
615         {
616                 g_VisView = new DVisDrawer;
617         }
618         
619         g_VisView->SetList(pointList);
620 }
621
622 void DoTrainPathPlot() {
623         if(g_TrainView) {
624                 delete g_TrainView;
625                 g_TrainView = NULL;
626         }
627
628         g_TrainView = new DTrainDrawer();
629 }
630
631 void DoCaulkSelection() {
632   UndoableCommand undo("bobToolz.caulkSelection");
633         DEntity world;
634         
635         float fScale[2] = { 0.5f, 0.5f };
636         float fShift[2] = { 0.0f, 0.0f };
637
638         int bResetScale[2] = { false, false };
639         int bResetShift[2] = { false, false };
640
641         world.LoadSelectedBrushes();
642         world.LoadSelectedPatches();
643         world.ResetTextures( NULL, fScale, fShift, 0, "textures/common/caulk", true, bResetScale, bResetShift, false, true );
644 }
645
646 void DoTreePlanter() {
647   UndoableCommand undo("bobToolz.treePlanter");
648         if(g_TreePlanter) {
649                 delete g_TreePlanter;
650                 g_TreePlanter = NULL;
651                 return;
652         }
653
654         g_TreePlanter = new DTreePlanter();
655 }
656
657 void DoDropEnts() {
658   UndoableCommand undo("bobToolz.dropEntities");
659         if(g_TreePlanter) {
660                 g_TreePlanter->DropEntsToGround();
661         }
662 }
663
664 void DoMakeChain() {
665   UndoableCommand undo("bobToolz.makeChain");
666         DTreePlanter pl;
667         pl.MakeChain();
668 }
669
670 typedef DPoint* pntTripple[3];
671
672 bool bFacesNoTop[6] = {true, true, true, true, true, false};
673
674 void DoFlipTerrain() {
675   UndoableCommand undo("bobToolz.flipTerrain");
676         vec3_t vUp = { 0.f, 0.f, 1.f };
677   int i;
678
679         // ensure we have something selected
680         if( GlobalSelectionSystem().countSelected() != 2 )
681         {
682                 DoMessageBox("Invalid number of objects selected, choose 2 only", "Error", eMB_OK);
683                 return; 
684         }
685
686   scene::Instance* brushes[2];
687         brushes[0] = &GlobalSelectionSystem().ultimateSelected();
688         brushes[1] = &GlobalSelectionSystem().penultimateSelected();
689
690         DBrush Brushes[2];
691         DPlane* Planes[2];
692         pntTripple Points[2];
693         for( i = 0; i < 2; i++ ) {
694                 Brushes[i].LoadFromBrush( *brushes[i], false );
695                 if(!(Planes[i] = Brushes[i].FindPlaneWithClosestNormal( vUp )) || Brushes[i].FindPointsForPlane( Planes[i], Points[i], 3 ) != 3) {
696                         DoMessageBox("Error", "Error", eMB_OK);
697                         return;
698                 }
699         }
700
701         vec3_t mins1, mins2, maxs1, maxs2;
702         Brushes[0].GetBounds( mins1, maxs1 );
703         Brushes[1].GetBounds( mins2, maxs2 );
704
705
706
707         int dontmatch[2] = { -1, -1 };
708         bool found = false;
709         for( i = 0; i < 3; i++ ) {
710                 for( int j = 0; j < 3 && !found; j++ ) {
711                         if(VectorCompare( (Points[0])[i]->_pnt, (Points[1])[j]->_pnt )) {
712                                 found = true;
713                                 break;
714                         }
715                 }
716                 if(!found) {
717                         dontmatch[0] = i;
718                         break;
719                 }
720                 found = false;
721         }
722         if(dontmatch[0] == -1) {
723                 DoMessageBox("Error", "Error", eMB_OK);
724                 return;
725         }
726
727         for( i = 0; i < 3; i++ ) {
728                 for( int j = 0; j < 3 && !found; j++ ) {
729                         if(VectorCompare( (Points[1])[i]->_pnt, (Points[0])[j]->_pnt )) {
730                                 found = true;
731                                 break;
732                         }
733                 }
734                 if(!found) {
735                         dontmatch[1] = i;
736                         break;
737                 }
738                 found = false;
739         }
740         if(dontmatch[1] == -1) {
741                 DoMessageBox("Error", "Error", eMB_OK);
742                 return;
743         }
744
745         vec3_t plnpnts1[3];
746         vec3_t plnpnts2[3];
747         vec3_t plnpntsshr[3];
748
749         VectorCopy( (Points[0])[dontmatch[0]]->_pnt, plnpnts1[0] );
750         for( i = 0; i < 3; i++ ) {
751                 if( dontmatch[0] != i ) {
752                         VectorCopy( (Points[0])[i]->_pnt, plnpnts1[1] );
753                         break;
754                 }
755         }
756         VectorCopy( (Points[1])[dontmatch[1]]->_pnt, plnpnts1[2] );
757
758         VectorCopy( (Points[1])[dontmatch[1]]->_pnt, plnpnts2[0] );
759         for( i = 0; i < 3; i++ ) {
760                 if( dontmatch[1] != i && !VectorCompare( (Points[1])[i]->_pnt, plnpnts1[1] )) {
761                         VectorCopy( (Points[1])[i]->_pnt, plnpnts2[1] );
762                         break;
763                 }
764         }
765         VectorCopy( (Points[0])[dontmatch[0]]->_pnt, plnpnts2[2] );
766
767         VectorCopy( (Points[0])[dontmatch[0]]->_pnt, plnpntsshr[0] );
768         VectorCopy( (Points[1])[dontmatch[1]]->_pnt, plnpntsshr[1] );
769         if( (Points[1])[dontmatch[1]]->_pnt[2] < (Points[0])[dontmatch[0]]->_pnt[2] ) {
770                 VectorCopy( (Points[1])[dontmatch[1]]->_pnt, plnpntsshr[2] );
771         } else {
772                 VectorCopy( (Points[0])[dontmatch[0]]->_pnt, plnpntsshr[2] );
773         }
774         plnpntsshr[2][2] -= 16;
775
776         for( i = 0; i < 3; i++ ) {
777                 if( mins2[i] < mins1[i] ) {
778                         mins1[i] = mins2[i];
779                 }
780                 if( maxs2[i] > maxs1[i] ) {
781                         maxs1[i] = maxs2[i];
782                 }
783         }
784
785         DBrush* newBrushes[2];
786         newBrushes[0] = DShape::GetBoundingCube_Ext( mins1, maxs1, "textures/common/caulk", bFacesAll, true);
787         newBrushes[1] = DShape::GetBoundingCube_Ext( mins1, maxs1, "textures/common/caulk", bFacesAll, true);
788
789         vec3_t normal;
790         MakeNormal( plnpnts1[0], plnpnts1[1], plnpnts1[2], normal );
791         if( normal[2] >= 0 ) {
792                 newBrushes[0]->AddFace( plnpnts1[0], plnpnts1[1], plnpnts1[2], "textures/common/terrain", true );
793         } else {
794                 newBrushes[0]->AddFace( plnpnts1[2], plnpnts1[1], plnpnts1[0], "textures/common/terrain", true );
795         }
796
797         MakeNormal( plnpnts2[0], plnpnts2[1], plnpnts2[2], normal );
798         if( normal[2] >= 0 ) {
799                 newBrushes[1]->AddFace( plnpnts2[0], plnpnts2[1], plnpnts2[2], "textures/common/terrain", true );
800         } else {
801                 newBrushes[1]->AddFace( plnpnts2[2], plnpnts2[1], plnpnts2[0], "textures/common/terrain", true );
802         }
803
804         vec3_t vec;
805         MakeNormal( plnpntsshr[0], plnpntsshr[1], plnpntsshr[2], normal );      
806         
807         VectorSubtract( plnpnts1[2], plnpnts1[1], vec );
808         if( DotProduct( vec, normal ) >= 0 ) {
809                 newBrushes[0]->AddFace( plnpntsshr[0], plnpntsshr[1], plnpntsshr[2], "textures/common/caulk", true );
810         } else {
811                 newBrushes[0]->AddFace( plnpntsshr[2], plnpntsshr[1], plnpntsshr[0], "textures/common/caulk", true );
812         }
813
814         VectorSubtract( plnpnts2[2], plnpnts2[1], vec );
815         if( DotProduct( vec, normal ) >= 0 ) {
816                 newBrushes[1]->AddFace( plnpntsshr[0], plnpntsshr[1], plnpntsshr[2], "textures/common/caulk", true );
817         } else {
818                 newBrushes[1]->AddFace( plnpntsshr[2], plnpntsshr[1], plnpntsshr[0], "textures/common/caulk", true );
819         }
820
821         for( i = 0; i < 2; i++ ) {
822                 newBrushes[i]->RemoveRedundantPlanes();
823                 newBrushes[i]->BuildInRadiant( false, NULL, brushes[i]->path().parent().get_pointer() );
824                 Path_deleteTop(brushes[i]->path());
825                 delete newBrushes[i];
826         }
827
828 }