more eol-style
[xonotic/netradiant.git] / contrib / bobtoolz / shapes.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
21 #include "StdAfx.h"
22
23 #include "shapes.h"
24
25 #include "DPlane.h"
26
27 #include "misc.h"
28 #include "funchandlers.h"
29
30 //#include "dialogs-gtk.h"
31
32 /************************
33         Cube Diagram
34 ************************/
35
36 /*
37
38                 7 ----- 5
39             /|    /|
40            / |   / |
41           /  |  /  |
42         4 ----- 6  |
43          |  2|_|___|8
44          |  /  |   /
45          | /   |  /       ----> WEST, definitely
46          |/    | /
47         1|_____|/3
48
49 */
50
51 /************************
52         Global Variables
53 ************************/
54
55 vec3_t  g_Origin = {0.0f, 0.0f, 0.0f};
56
57 extern bool bFacesAll[];
58
59 /************************
60         Helper Functions
61 ************************/
62
63 float Deg2Rad(float angle)
64 {
65         return (float)(angle*Q_PI/180);
66 }
67
68 void AddFaceWithTexture(brush_t* brush, vec3_t va, vec3_t vb, vec3_t vc, const char* texture, bool detail)
69 {
70         _QERFaceData faceData;
71         FillDefaultTexture(&faceData, va, vb, vc, texture);
72         if(detail)
73                 faceData.m_nContents |= FACE_DETAIL;
74         
75         g_FuncTable.m_pfnAddFaceData(brush, &faceData);
76 }
77
78 void AddFaceWithTextureScaled(brush_t* brush, vec3_t va, vec3_t vb, vec3_t vc, 
79                                                           const char* texture, bool bVertScale, bool bHorScale, 
80                                                           float minX, float minY, float maxX, float maxY)
81 {
82         g_ShadersTable.m_pfnShader_ForName(texture); // need to call frist to load?
83
84         qtexture_t* pqtTexInfo;
85
86   // TTimo: there used to be a call to pfnHasShader here
87   //   this was not necessary. In Radiant everything is shader.
88   //   If a texture doesn't have a shader script, a default shader object is used.
89   // The IShader object was leaking also
90         // collect texture info: sizes, etc
91         IShader* i = g_ShadersTable.m_pfnShader_ForName(texture);
92   pqtTexInfo = i->getTexture(); // shader width/height doesn't come out properly
93
94         if(pqtTexInfo)
95         {
96                 float scale[2] = {0.5f, 0.5f};
97                 float shift[2] = {0, 0};
98
99                 if(bHorScale)
100                 {
101                         int texWidth = pqtTexInfo->width;
102                         float width = maxX - minX;
103
104                         scale[0] = width/texWidth;
105                         shift[0] = -(float)((int)maxX%(int)width)/scale[0];
106                 }
107
108                 if(bVertScale)
109                 {
110                         int texHeight = pqtTexInfo->height;
111                         float height = maxY - minY;
112
113                         scale[1] = height/texHeight;
114                         shift[1] = (float)((int)minY%(int)height)/scale[1];
115                 }
116
117                 _QERFaceData addFace;
118                 FillDefaultTexture(&addFace, va, vb, vc, texture);
119                 addFace.m_fScale[0] = scale[0];
120                 addFace.m_fScale[1] = scale[1];
121                 addFace.m_fShift[0] = shift[0];
122                 addFace.m_fShift[1] = shift[1];
123
124                 g_FuncTable.m_pfnAddFaceData(brush, &addFace);
125         }
126         else
127         {
128                 // shouldn't even get here, as default missing texture should be returned if
129                 // texture doesn't exist, but just in case
130                 AddFaceWithTexture(brush, va, vb, vc, texture, FALSE);
131                 Sys_ERROR("BobToolz::Invalid Texture Name-> %s", texture);
132         }
133   // the IShader is not kept referenced, DecRef it
134   i->DecRef();
135 }
136
137 /************************
138         --Main Functions--
139 ************************/
140
141 void Build_Wedge(int dir, vec3_t min, vec3_t max, bool bUp)
142 {
143         brush_t* newBrush = (brush_t*)g_FuncTable.m_pfnCreateBrushHandle();
144
145         vec3_t v1, v2, v3, v5, v6, v7, v8;
146         VectorCopy(min, v1);
147         VectorCopy(min, v2);
148         VectorCopy(min, v3);
149         VectorCopy(max, v5);
150         VectorCopy(max, v6);
151         VectorCopy(max, v7);
152         VectorCopy(max, v8);
153
154         v2[0] = max[0];
155         v3[1] = max[1];
156
157         v6[0] = min[0];
158         v7[1] = min[1];
159         v8[2] = min[2];
160
161         if(bUp)
162         {
163
164                 if(dir != MOVE_EAST)
165                         AddFaceWithTexture(newBrush, v1, v3, v6, "textures/common/caulk", FALSE);
166
167                 if(dir != MOVE_WEST)
168                         AddFaceWithTexture(newBrush, v7, v5, v8, "textures/common/caulk", FALSE);
169
170                 if(dir != MOVE_NORTH)
171                         AddFaceWithTexture(newBrush, v1, v7, v2, "textures/common/caulk", FALSE);
172
173                 if(dir != MOVE_SOUTH)
174                         AddFaceWithTexture(newBrush, v3, v8, v6, "textures/common/caulk", FALSE);
175
176                 AddFaceWithTexture(newBrush, v1, v2, v3, "textures/common/caulk", FALSE);
177
178                 if(dir == MOVE_EAST)
179                         AddFaceWithTexture(newBrush, v1, v3, v5, "textures/common/caulk", FALSE);
180
181                 if(dir == MOVE_WEST)
182                         AddFaceWithTexture(newBrush, v2, v6, v8, "textures/common/caulk", FALSE);
183
184                 if(dir == MOVE_NORTH)
185                         AddFaceWithTexture(newBrush, v1, v6, v5, "textures/common/caulk", FALSE);
186
187                 if(dir == MOVE_SOUTH)
188                         AddFaceWithTexture(newBrush, v7, v3, v8, "textures/common/caulk", FALSE);
189         }
190         else
191         {
192                 if(dir != MOVE_WEST)
193                         AddFaceWithTexture(newBrush, v7, v5, v8, "textures/common/caulk", FALSE);
194
195                 if(dir != MOVE_EAST)
196                         AddFaceWithTexture(newBrush, v1, v3, v6, "textures/common/caulk", FALSE);
197
198                 if(dir != MOVE_NORTH)
199                         AddFaceWithTexture(newBrush, v3, v8, v6, "textures/common/caulk", FALSE);
200
201                 if(dir != MOVE_SOUTH)
202                         AddFaceWithTexture(newBrush, v1, v7, v2, "textures/common/caulk", FALSE);
203
204                 
205                 AddFaceWithTexture(newBrush, v6, v5, v7, "textures/common/caulk", FALSE);
206
207                 if(dir == MOVE_WEST)
208                         AddFaceWithTexture(newBrush, v1, v5, v3, "textures/common/caulk", FALSE);
209
210                 if(dir == MOVE_EAST)
211                         AddFaceWithTexture(newBrush, v2, v8, v6, "textures/common/caulk", FALSE);
212
213                 if(dir == MOVE_NORTH)
214                         AddFaceWithTexture(newBrush, v1, v5, v6, "textures/common/caulk", FALSE);
215
216                 if(dir == MOVE_SOUTH)
217                         AddFaceWithTexture(newBrush, v7, v8, v3, "textures/common/caulk", FALSE);
218         }
219
220         g_FuncTable.m_pfnCommitBrushHandle(newBrush);
221 }
222
223 //-----------------------------------------------------------------------------------
224 //-----------------------------------------------------------------------------------
225
226 void Build_StairStep_Wedge(int dir, vec3_t min, vec3_t max, const char* mainTexture, const char* riserTexture, bool detail)
227 {
228         brush_t* newBrush = (brush_t*)g_FuncTable.m_pfnCreateBrushHandle();
229
230         //----- Build Outer Bounds ---------
231
232         vec3_t v1, v2, v3, v5, v6, v7, v8;
233         VectorCopy(min, v1);
234         VectorCopy(min, v2);
235         VectorCopy(min, v3);
236         VectorCopy(max, v5);
237         VectorCopy(max, v6);
238         VectorCopy(max, v7);
239         VectorCopy(max, v8);
240
241         v2[0] = max[0];
242         v3[1] = max[1];
243
244         v6[0] = min[0];
245         v7[1] = min[1];
246
247         v8[2] = min[2];
248         //v8 needed this time, becoz of sloping faces (2-4-6-8)
249
250         //----------------------------------
251
252         AddFaceWithTexture(newBrush, v6, v5, v7, mainTexture, detail);
253
254         if(dir != MOVE_EAST)
255         {
256                 if(dir == MOVE_WEST)
257                         AddFaceWithTexture(newBrush, v5, v2, v7, riserTexture, detail);
258                 else
259                         AddFaceWithTexture(newBrush, v5, v2, v7, "textures/common/caulk", detail);
260         }
261
262         if(dir != MOVE_WEST)
263         {
264                 if(dir == MOVE_EAST)
265                         AddFaceWithTexture(newBrush, v1, v3, v6, riserTexture, detail);
266                 else
267                         AddFaceWithTexture(newBrush, v1, v3, v6, "textures/common/caulk", detail);
268         }
269
270         if(dir != MOVE_NORTH)
271         {
272                 if(dir == MOVE_SOUTH)
273                         AddFaceWithTexture(newBrush, v3, v5, v6, riserTexture, detail);
274                 else
275                         AddFaceWithTexture(newBrush, v3, v5, v6, "textures/common/caulk", detail);
276         }
277
278         if(dir != MOVE_SOUTH)
279         {
280                 if(dir == MOVE_NORTH)
281                         AddFaceWithTexture(newBrush, v1, v7, v2, riserTexture, detail);
282                 else
283                         AddFaceWithTexture(newBrush, v1, v7, v2, "textures/common/caulk", detail);
284         }
285
286                 
287         if(dir == MOVE_EAST)
288                 AddFaceWithTexture(newBrush, v1, v5, v3, "textures/common/caulk", detail);
289
290         if(dir == MOVE_WEST)
291                 AddFaceWithTexture(newBrush, v2, v8, v6, "textures/common/caulk", detail);
292
293         if(dir == MOVE_NORTH)
294                 AddFaceWithTexture(newBrush, v1, v5, v6, "textures/common/caulk", detail);
295
296         if(dir == MOVE_SOUTH)
297                 AddFaceWithTexture(newBrush, v7, v8, v3, "textures/common/caulk", detail);
298
299         g_FuncTable.m_pfnCommitBrushHandle(newBrush);
300 }
301
302 //-----------------------------------------------------------------------------------
303 //-----------------------------------------------------------------------------------
304
305 // internal use only, to get a box without finishing construction
306 brush_t* Build_Get_BoundingCube_Selective(vec3_t min, vec3_t max, char* texture, bool* useFaces)
307 {
308         brush_t* newBrush = (brush_t*)g_FuncTable.m_pfnCreateBrushHandle();
309
310         //----- Build Outer Bounds ---------
311
312         vec3_t v1, v2, v3, v5, v6, v7;
313         VectorCopy(min, v1);
314         VectorCopy(min, v2);
315         VectorCopy(min, v3);
316         VectorCopy(max, v5);
317         VectorCopy(max, v6);
318         VectorCopy(max, v7);
319
320         v2[0] = max[0];
321         v3[1] = max[1];
322
323         v6[0] = min[0];
324         v7[1] = min[1];
325
326         //----------------------------------
327
328         //----- Add Six Cube Faces ---------
329
330         if(useFaces[0])
331                 AddFaceWithTexture(newBrush, v1, v2, v3, texture, FALSE);
332         if(useFaces[1])
333                 AddFaceWithTexture(newBrush, v1, v3, v6, texture, FALSE);
334         if(useFaces[2])
335                 AddFaceWithTexture(newBrush, v1, v7, v2, texture, FALSE);
336
337         if(useFaces[3])
338                 AddFaceWithTexture(newBrush, v5, v6, v3, texture, FALSE);
339         if(useFaces[4])
340                 AddFaceWithTexture(newBrush, v5, v2, v7, texture, FALSE);
341         if(useFaces[5])
342                 AddFaceWithTexture(newBrush, v5, v7, v6, texture, FALSE);
343
344         //----------------------------------
345
346         return newBrush;
347 }
348
349 brush_t* Build_Get_BoundingCube(vec3_t min, vec3_t max, char* texture)
350 {
351         return Build_Get_BoundingCube_Selective(min, max, texture, bFacesAll);
352 }
353
354 //-----------------------------------------------------------------------------------
355 //-----------------------------------------------------------------------------------
356
357 void Build_StairStep(vec3_t min, vec3_t max, const char* mainTexture, const char* riserTexture, int direction)
358 {
359         brush_t* newBrush = (brush_t*)g_FuncTable.m_pfnCreateBrushHandle();
360
361         //----- Build Outer Bounds ---------
362
363         vec3_t v1, v2, v3, v5, v6, v7;
364         VectorCopy(min, v1);
365         VectorCopy(min, v2);
366         VectorCopy(min, v3);
367         VectorCopy(max, v5);
368         VectorCopy(max, v6);
369         VectorCopy(max, v7);
370
371         v2[0] = max[0];
372         v3[1] = max[1];
373
374         v6[0] = min[0];
375         v7[1] = min[1];
376
377         //----------------------------------
378
379         AddFaceWithTexture(newBrush, v6, v5, v7, mainTexture, FALSE);
380         // top gets current texture
381
382
383         if(direction == MOVE_EAST)
384                 AddFaceWithTexture(newBrush, v1, v3, v6, riserTexture, FALSE);
385         else
386                 AddFaceWithTexture(newBrush, v1, v3, v6, "textures/common/caulk", FALSE);
387         // west facing side, etc...
388
389         
390         if(direction == MOVE_NORTH)
391                 AddFaceWithTexture(newBrush, v1, v7, v2, riserTexture, FALSE);
392         else
393                 AddFaceWithTexture(newBrush, v1, v7, v2, "textures/common/caulk", FALSE);
394
395         if(direction == MOVE_SOUTH)
396                 AddFaceWithTexture(newBrush, v3, v5, v6, riserTexture, FALSE);
397         else
398                 AddFaceWithTexture(newBrush, v3, v5, v6, "textures/common/caulk", FALSE);
399         
400         if(direction == MOVE_WEST)
401                 AddFaceWithTexture(newBrush, v7, v5, v2, riserTexture, FALSE);
402         else
403                 AddFaceWithTexture(newBrush, v7, v5, v2, "textures/common/caulk", FALSE);
404
405
406         AddFaceWithTexture(newBrush, v1, v2, v3, "textures/common/caulk", FALSE);
407         // base is caulked
408
409         g_FuncTable.m_pfnCommitBrushHandle(newBrush);
410         // finish brush
411 }
412
413 //-----------------------------------------------------------------------------------
414 //-----------------------------------------------------------------------------------
415
416 void BuildDoorsX2(vec3_t min, vec3_t max, 
417                                   bool bSclMainHor, bool bSclMainVert, 
418                                   bool bSclTrimHor, bool bSclTrimVert,
419                                   const char* mainTexture, const char* trimTexture,
420                                   int direction)
421 {
422         int xy;
423         if(direction == 0)
424                 xy = 0;
425         else
426                 xy = 1;
427
428         //----- Build Outer Bounds ---------
429
430         vec3_t v1, v2, v3, v5, v6, v7, ve_1, ve_2, ve_3;
431         VectorCopy(min, v1);
432         VectorCopy(min, v2);
433         VectorCopy(min, v3);
434         VectorCopy(max, v5);
435         VectorCopy(max, v6);
436         VectorCopy(max, v7);
437
438         v2[0] = max[0];
439         v3[1] = max[1];
440
441         v6[0] = min[0];
442         v7[1] = min[1];
443
444         float width = (max[xy] - min[xy])/2;
445         
446         if(direction == 0)
447         {
448                 VectorCopy(v1, ve_1);
449                 VectorCopy(v3, ve_2);
450                 VectorCopy(v6, ve_3);
451         }
452         else
453         {
454                 VectorCopy(v7, ve_1);
455                 VectorCopy(v1, ve_2);
456                 VectorCopy(v2, ve_3);
457         }
458
459         ve_1[xy] += width;
460         ve_2[xy] += width;
461         ve_3[xy] += width;
462
463         //----------------------------------
464
465         brush_t* newBrush1 = (brush_t*)g_FuncTable.m_pfnCreateBrushHandle();
466         brush_t* newBrush2 = (brush_t*)g_FuncTable.m_pfnCreateBrushHandle();
467
468         AddFaceWithTexture(newBrush1, v1, v2, v3, "textures/common/caulk", FALSE);
469         AddFaceWithTexture(newBrush1, v5, v7, v6, "textures/common/caulk", FALSE);
470
471         AddFaceWithTexture(newBrush2, v1, v2, v3, "textures/common/caulk", FALSE);
472         AddFaceWithTexture(newBrush2, v5, v7, v6, "textures/common/caulk", FALSE);
473
474         if(direction == 0)
475         {
476                 AddFaceWithTexture(newBrush1, v1, v3, v6, "textures/common/caulk", FALSE);
477                 AddFaceWithTexture(newBrush2, v5, v2, v7, "textures/common/caulk", FALSE);
478         }
479         else
480         {
481                 AddFaceWithTexture(newBrush1, v1, v7, v2, "textures/common/caulk", FALSE);
482                 AddFaceWithTexture(newBrush2, v5, v6, v3, "textures/common/caulk", FALSE);
483         }
484
485         if(direction == 0)
486         {
487                 AddFaceWithTextureScaled(newBrush1, v1, v7, v2, mainTexture, bSclMainVert, bSclMainHor,
488                         min[0], min[2], max[0], max[2]);
489                 AddFaceWithTextureScaled(newBrush1, v5, v6, v3, mainTexture, bSclMainVert, bSclMainHor,
490                         max[0], min[2], min[0], max[2]);
491
492                 
493                 AddFaceWithTextureScaled(newBrush2, v1, v7, v2, mainTexture, bSclMainVert, bSclMainHor,
494                         min[0], min[2], max[0], max[2]);
495                 AddFaceWithTextureScaled(newBrush2, v5, v6, v3, mainTexture, bSclMainVert, bSclMainHor,
496                         max[0], min[2], min[0], max[2]);        // flip max/min to reverse tex dir
497
498
499         
500                 AddFaceWithTextureScaled(newBrush1, ve_3, ve_2, ve_1, trimTexture, bSclTrimVert, bSclTrimHor,
501                         min[1], min[2], max[1], max[2]);
502
503                 AddFaceWithTextureScaled(newBrush2, ve_1, ve_2, ve_3, trimTexture, bSclTrimVert, bSclTrimHor,
504                         max[1], min[2], min[1], max[2]);
505         }
506         else
507         {
508                 AddFaceWithTextureScaled(newBrush1, v1, v3, v6, mainTexture, bSclMainVert, bSclMainHor,
509                         min[1], min[2], max[1], max[2]);
510                 AddFaceWithTextureScaled(newBrush1, v5, v2, v7, mainTexture, bSclMainVert, bSclMainHor,
511                         max[1], min[2], min[1], max[2]);
512
513                 
514                 AddFaceWithTextureScaled(newBrush2, v1, v3, v6, mainTexture, bSclMainVert, bSclMainHor,
515                         min[1], min[2], max[1], max[2]);
516                 AddFaceWithTextureScaled(newBrush2, v5, v2, v7, mainTexture, bSclMainVert, bSclMainHor,
517                         max[1], min[2], min[1], max[2]);        // flip max/min to reverse tex dir
518
519
520                 AddFaceWithTextureScaled(newBrush1, ve_1, ve_2, ve_3, trimTexture, bSclTrimVert, bSclTrimHor,
521                         min[0], min[2], max[0], max[2]);
522
523                 AddFaceWithTextureScaled(newBrush2, ve_3, ve_2, ve_1, trimTexture, bSclTrimVert, bSclTrimHor,
524                         max[0], min[2], min[0], max[2]);
525         }
526
527         //----------------------------------
528         
529
530         entity_t* pEDoor1 = (entity_t*)g_FuncTable.m_pfnCreateEntityHandle();
531         entity_t* pEDoor2 = (entity_t*)g_FuncTable.m_pfnCreateEntityHandle();
532
533         epair_t* epDoor11 = GetNextChainItem(NULL, "classname", "func_door");
534         epair_t* epDoor21 = GetNextChainItem(NULL, "classname", "func_door");
535
536         epair_t* epDoor12;
537         epair_t* epDoor22;
538
539         if(direction == 0)
540         {
541                 epDoor12 = GetNextChainItem(epDoor11, "angle", "180");
542                 epDoor22 = GetNextChainItem(epDoor21, "angle", "360");
543         }
544         else
545         {
546                 epDoor12 = GetNextChainItem(epDoor11, "angle", "270");
547                 epDoor22 = GetNextChainItem(epDoor21, "angle", "90");
548         }
549
550         srand((unsigned)time(NULL));
551
552         char teamname[256];
553         sprintf(teamname, "t%i", rand());
554         /*epair_t* epDoor13 = */ GetNextChainItem(epDoor12, "team", teamname);
555         /*epair_t* epDoor23 = */ GetNextChainItem(epDoor22, "team", teamname);
556
557         g_FuncTable.m_pfnCommitBrushHandleToEntity(newBrush1, pEDoor1);
558         g_FuncTable.m_pfnCommitBrushHandleToEntity(newBrush2, pEDoor2);
559
560         g_EntityTable.m_pfnSetEntityKeyValList(pEDoor1, epDoor11);
561         g_EntityTable.m_pfnSetEntityKeyValList(pEDoor2, epDoor21);
562
563         g_FuncTable.m_pfnCommitEntityHandleToMap(pEDoor1);
564         g_FuncTable.m_pfnCommitEntityHandleToMap(pEDoor2);
565
566 //      ResetCurrentTexture();
567 }
568
569 //-----------------------------------------------------------------------------------
570 //-----------------------------------------------------------------------------------
571
572 void MakeBevel(vec3_t vMin, vec3_t vMax)
573 {
574         int nIndex = g_FuncTable.m_pfnCreatePatchHandle();
575     //$ FIXME: m_pfnGetPatchHandle
576   patchMesh_t* pm = g_FuncTable.m_pfnGetPatchData(nIndex);
577
578         pm->height = 3;
579         pm->width = 3;
580
581         vec3_t x_3, y_3, z_3;
582         x_3[0] = vMin[0];       x_3[1] = vMin[0];                               x_3[2] = vMax[0];
583         y_3[0] = vMin[1];       y_3[1] = vMax[1];                               y_3[2] = vMax[1];
584         z_3[0] = vMin[2];       z_3[1] = (vMax[2] + vMin[2])/2; z_3[2] = vMax[2];
585
586 /*      x_3[0] = 0;             x_3[1] = 0;             x_3[2] = 64;
587         y_3[0] = 0;             y_3[1] = 64;    y_3[2] = 64;
588         z_3[0] = 0;             z_3[1] = 32;    z_3[2] = 64;*/
589
590         for(int i = 0; i < 3; i++)
591         {
592                 for(int j = 0; j < 3; j++)
593                 {
594                         pm->ctrl[i][j].xyz[0] = x_3[i];
595                         pm->ctrl[i][j].xyz[1] = y_3[i];
596                         pm->ctrl[i][j].xyz[2] = z_3[j];
597                 }
598         }
599
600
601         g_FuncTable.m_pfnCommitPatchHandleToMap(nIndex, pm, "textures/common/caulk");
602 }
603
604 void BuildCornerStairs(vec3_t vMin, vec3_t vMax, int nSteps, const char* mainTexture, const char* riserTex)
605 {
606         vec3_t* topPoints = new vec3_t[nSteps+1];
607         vec3_t* botPoints = new vec3_t[nSteps+1];
608
609         bool bFacesUse[6] = {TRUE, TRUE, FALSE, TRUE, FALSE, FALSE};
610
611         vec3_t centre;
612         VectorCopy(vMin, centre);
613         centre[0] = vMax[0];
614
615         int height = (int)(vMax[2] - vMin[2]) / nSteps;
616
617         vec3_t vTop, vBot;
618         VectorCopy(vMax, vTop);
619         VectorCopy(vMin, vBot);
620         vTop[2] = vMin[2] + height;
621
622   int i;
623         for(i = 0; i <= nSteps; i++)
624         {
625                 VectorCopy(centre, topPoints[i]);
626                 VectorCopy(centre, botPoints[i]);
627                 
628                 topPoints[i][2] = vMax[2];
629                 botPoints[i][2] = vMin[2];
630
631                 topPoints[i][0] -= 10 * sinf( Q_PI * i / ( 2 * nSteps ) );
632                 topPoints[i][1] += 10 * cosf( Q_PI * i / ( 2 * nSteps ) );
633
634                 botPoints[i][0] = topPoints[i][0];
635                 botPoints[i][1] = topPoints[i][1];
636         }
637
638         vec3_t tp[3];
639         for(int j = 0; j < 3; j++)
640                 VectorCopy(topPoints[j], tp[j]);
641
642         for(i = 0; i < nSteps; i++)
643         {
644                 brush_t* brush = Build_Get_BoundingCube_Selective(vBot, vTop, "textures/common/caulk", bFacesUse);
645
646                 for(int j = 0; j < 3; j++)
647                         tp[j][2] = vTop[2];
648
649                 AddFaceWithTexture(brush, tp[2], tp[1], tp[0], mainTexture, FALSE);
650
651                 AddFaceWithTexture(brush, centre, botPoints[i+1], topPoints[i+1], "textures/common/caulk", FALSE);
652                 AddFaceWithTexture(brush, centre, topPoints[i], botPoints[i], riserTex, FALSE);
653
654                 g_FuncTable.m_pfnCommitBrushHandle(brush);
655
656                 vTop[2] += height;
657                 vBot[2] += height;
658         }
659
660         delete[] topPoints;
661         delete[] botPoints;
662
663         vMin[2] += height;
664         vMax[2] += height;
665         MakeBevel(vMin, vMax);
666 }