2 Copyright (C) 1999-2007 id Software, Inc. and contributors.
\r
3 For a list of contributors, see the accompanying CONTRIBUTORS file.
\r
5 This file is part of GtkRadiant.
\r
7 GtkRadiant is free software; you can redistribute it and/or modify
\r
8 it under the terms of the GNU General Public License as published by
\r
9 the Free Software Foundation; either version 2 of the License, or
\r
10 (at your option) any later version.
\r
12 GtkRadiant is distributed in the hope that it will be useful,
\r
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
\r
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
\r
15 GNU General Public License for more details.
\r
17 You should have received a copy of the GNU General Public License
\r
18 along with GtkRadiant; if not, write to the Free Software
\r
19 Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
\r
23 // Preliminary patch stuff
\r
28 #include "gtkmisc.h"
\r
30 #include "gtkr_list.h"
\r
33 extern void MemFile_fprintf(MemStream* pMemFile, const char* pText, ...);
\r
34 extern face_t *Face_Alloc( void );
\r
35 extern void DrawAlternatePoint(vec3_t v, float scale);
\r
37 void _Write3DMatrix (FILE *f, int y, int x, int z, float *m);
\r
38 void _Write3DMatrix (MemStream *f, int y, int x, int z, float *m);
\r
40 void Patch_InitialiseLODPointers(patchMesh_t *p)
\r
43 int rowcount = ((MAX_PATCH_WIDTH-1)/2) * MAX_PATCH_HEIGHT;
\r
44 for (i=0; i<rowcount; i++)
\r
45 p->rowLOD[i] = NULL;
\r
46 int colcount = ((MAX_PATCH_HEIGHT-1)/2) * MAX_PATCH_WIDTH;
\r
47 for (i=0; i<colcount; i++)
\r
48 p->colLOD[i] = NULL;
\r
51 patchMesh_t* Patch_Alloc()
\r
53 patchMesh_t *pPatch = (patchMesh_t *)malloc(sizeof(patchMesh_t));
\r
54 pPatch->pShader = NULL;
\r
55 pPatch->pSymbiot = NULL; // Hydra: added missing initialiser.
\r
56 // spog - initialise patch LOD pointers
\r
57 Patch_InitialiseLODPointers(pPatch);
\r
58 pPatch->drawLists = NULL;
\r
59 pPatch->bDirty = true;
\r
60 pPatch->nListID = -1;
\r
61 pPatch->bSelected = false;
\r
62 pPatch->bOverlay = false;
\r
63 pPatch->bDirty = true;
\r
64 pPatch->LODUpdated = false;
\r
67 for (i=0; i<(((MAX_PATCH_WIDTH-1)-1)/2); i++)
\r
68 pPatch->rowDirty[i] = false;
\r
69 for (i=0; i<(((MAX_PATCH_HEIGHT-1)-1)/2); i++)
\r
70 pPatch->colDirty[i] = false;
\r
75 patchMesh_t* MakeNewPatch()
\r
77 patchMesh_t *pm = reinterpret_cast<patchMesh_t*>(qmalloc(sizeof(patchMesh_t)));
\r
79 // spog - initialise patch LOD pointers
\r
80 Patch_InitialiseLODPointers(pm);
\r
81 pm->drawLists = NULL;
\r
87 // FIXME: this needs to be dynamic
\r
88 //#define MAX_PATCH_MESHES 4096
\r
89 //patchMesh_t patchMeshes[MAX_PATCH_MESHES];
\r
90 //int numPatchMeshes = 0;
\r
92 // used for a save spot
\r
93 patchMesh_t patchSave;
\r
95 // Tracks the selected patch for point manipulation/update. FIXME: Need to revert back to a generalized
\r
97 //--int g_nSelectedPatch = -1;
\r
99 // HACK: for tracking which view generated the click
\r
100 // as we dont want to deselect a point on a same point
\r
101 // click if it is from a different view
\r
102 int g_nPatchClickedView = -1;
\r
103 bool g_bSameView = false;
\r
105 //typedef enum XFormType { TRANSLATE, SCALE, ROTATE };
\r
109 bool g_bPatchShowBounds = true;
\r
110 bool g_bPatchWireFrame = false;
\r
111 bool g_bPatchWeld = true;
\r
112 bool g_bPatchDrillDown = true;
\r
113 //bool g_bPatchInsertMode = false;
\r
114 bool g_bPatchBendMode = false;
\r
115 int g_nPatchBendState = -1;
\r
116 int g_nPatchInsertState = -1;
\r
117 int g_nBendOriginIndex = 0;
\r
118 vec3_t g_vBendOrigin;
\r
120 bool g_bPatchAxisOnRow = true;
\r
121 int g_nPatchAxisIndex = 0;
\r
122 bool g_bPatchLowerEdge = true;
\r
124 vec3_t g_vCycleCapNormal;
\r
125 // cycles when we use Patch_CycleCapSelected
\r
126 VIEWTYPE g_nCycleCapIndex = XY;
\r
131 BEND_SELECT_ROTATION = 0,
\r
132 BEND_SELECT_ORIGIN,
\r
138 const char *g_pBendStateMsg[] =
\r
140 "Use TAB to cycle through available bend axis. Press ENTER when the desired one is highlighted.",
\r
141 "Use TAB to cycle through available rotation axis. This will LOCK around that point. You may also use Shift + Middle Click to select an arbitrary point. Press ENTER when the desired one is highlighted",
\r
142 "Use TAB to choose which side to bend. Press ENTER when the desired one is highlighted.",
\r
143 "Use the MOUSE to bend the patch. It uses the same ui rules as Free Rotation. Press ENTER to accept the bend, press ESC to abandon it and exit Bend mode",
\r
150 INSERT_SELECT_EDGE = 0,
\r
154 const char* g_pInsertStateMsg[] =
\r
156 "Use TAB to cycle through available rows/columns for insertion/deletion. Press INS to insert at the highlight, DEL to remove the pair"
\r
160 float *g_InversePoints[1024];
\r
162 const float fFullBright = 1.0;
\r
163 const float fLowerLimit = .50;
\r
164 const float fDec = .05f;
\r
165 void _SetColor(face_t* f, float fColor[3])
\r
168 fColor[0] = f->d_color[0];
\r
169 fColor[1] = f->d_color[1];
\r
170 fColor[2] = f->d_color[2];
\r
171 qglColor3fv(fColor);
\r
175 void _DecColor(float fColor[3])
\r
179 fColor[1] -= fDec ;
\r
181 for (int i = 0; i < 3; i++)
\r
183 if (fColor[i] <= fLowerLimit)
\r
185 fColor[0] = fFullBright;
\r
186 fColor[1] = fFullBright;
\r
187 fColor[2] = fFullBright;
\r
191 qglColor3fv(fColor);
\r
194 vec_t __VectorNormalize (vec3_t in, vec3_t out)
\r
196 vec_t length, ilength;
\r
198 length = sqrt (in[0]*in[0] + in[1]*in[1] + in[2]*in[2]);
\r
205 ilength = 1.0/length;
\r
206 out[0] = in[0]*ilength;
\r
207 out[1] = in[1]*ilength;
\r
208 out[2] = in[2]*ilength;
\r
214 void Patch_SetType(patchMesh_t *p, int nType)
\r
216 p->type = (p->type & PATCH_STYLEMASK) | nType;
\r
219 void Patch_SetStyle(patchMesh_t *p, int nStyle)
\r
221 p->type = (p->type & PATCH_TYPEMASK) | nStyle;
\r
229 int Patch_MemorySize(patchMesh_t *p)
\r
231 // return _msize(p);
\r
238 InterpolateInteriorPoints
\r
241 void InterpolateInteriorPoints( patchMesh_t *p )
\r
246 for ( i = 0 ; i < p->width ; i += 2 )
\r
249 next = ( i == p->width - 1 ) ? 1 : ( i + 1 ) % p->width;
\r
250 prev = ( i == 0 ) ? p->width - 2 : i - 1;
\r
255 next = ( i + 1 ) % p->width;
\r
256 prev = p->width - 2; // joined wrap case
\r
258 else if ( i == p->width - 1 )
\r
265 next = ( i + 1 ) % p->width;
\r
270 for ( j = 0 ; j < p->height ; j++ )
\r
272 for ( k = 0 ; k < 3 ; k++ )
\r
274 p->ctrl[i][j].xyz[k] = ( p->ctrl[next][j].xyz[k] + p->ctrl[prev][j].xyz[k] ) * 0.5;
\r
286 int neighbors[8][2] = {
\r
287 {0,1}, {1,1}, {1,0}, {1,-1}, {0,-1}, {-1,-1}, {-1,0}, {-1,1}
\r
290 void Patch_MeshNormals(patchMesh_t *in )
\r
300 vec3_t around[8], temp;
\r
302 qboolean wrapWidth, wrapHeight;
\r
306 for ( i = 0 ; i < in->height ; i++ )
\r
309 VectorSubtract( in->ctrl[0][i].xyz,
\r
310 in->ctrl[in->width-1][i].xyz, delta );
\r
311 len = VectorLength( delta );
\r
317 if ( i == in->height )
\r
322 wrapHeight = false;
\r
323 for ( i = 0 ; i < in->width ; i++ )
\r
325 VectorSubtract( in->ctrl[i][0].xyz,
\r
326 in->ctrl[i][in->height-1].xyz, delta );
\r
327 len = VectorLength( delta );
\r
333 if ( i == in->width)
\r
339 for ( i = 0 ; i < in->width ; i++ )
\r
341 for ( j = 0 ; j < in->height ; j++ )
\r
344 //--dv = reinterpret_cast<drawVert_t*>(in.ctrl[j*in.width+i]);
\r
345 dv = &in->ctrl[i][j];
\r
346 VectorCopy( dv->xyz, base );
\r
347 for ( k = 0 ; k < 8 ; k++ )
\r
349 VectorClear( around[k] );
\r
352 for ( dist = 1 ; dist <= 3 ; dist++ )
\r
354 x = i + neighbors[k][0] * dist;
\r
355 y = j + neighbors[k][1] * dist;
\r
360 x = in->width - 1 + x;
\r
362 else if ( x >= in->width )
\r
364 x = 1 + x - in->width;
\r
371 y = in->height - 1 + y;
\r
373 else if ( y >= in->height )
\r
375 y = 1 + y - in->height;
\r
379 if ( x < 0 || x >= in->width || y < 0 || y >= in->height )
\r
381 break; // edge of patch
\r
383 //--VectorSubtract( in.ctrl[y*in.width+x]->xyz, base, temp );
\r
384 VectorSubtract( in->ctrl[x][y].xyz, base, temp );
\r
385 if ( __VectorNormalize( temp, temp ) == 0 )
\r
387 continue; // degenerate edge, get more dist
\r
392 VectorCopy( temp, around[k] );
\r
393 break; // good edge
\r
398 VectorClear( sum );
\r
399 for ( k = 0 ; k < 8 ; k++ )
\r
401 if ( !good[k] || !good[(k+1)&7] )
\r
403 continue; // didn't get two points
\r
405 CrossProduct( around[(k+1)&7], around[k], normal );
\r
406 if ( __VectorNormalize( normal, normal ) == 0 )
\r
410 VectorAdd( normal, sum, sum );
\r
415 //printf("bad normal\n");
\r
419 __VectorNormalize( sum, dv->normal );
\r
432 void Patch_CalcBounds(patchMesh_t *p, vec3_t& vMin, vec3_t& vMax)
\r
434 vMin[0] = vMin[1] = vMin[2] = 99999;
\r
435 vMax[0] = vMax[1] = vMax[2] = -99999;
\r
438 for (int w = 0; w < p->width; w++)
\r
440 for (int h = 0; h < p->height; h++)
\r
442 for (int j = 0; j < 3; j++)
\r
444 float f = p->ctrl[w][h].xyz[j];
\r
459 void Brush_RebuildBrush(brush_t *b, vec3_t vMins, vec3_t vMaxs)
\r
463 // Rebuilds a brush
\r
470 for (j = 0; j < 3; j++)
\r
472 if ((int)vMins[j] == (int)vMaxs[j])
\r
480 for (f=b->brush_faces ; f ; f=next)
\r
484 texdef = f->texdef;
\r
488 b->brush_faces = NULL;
\r
490 // left the last face so we can use its texdef
\r
492 for (i=0 ; i<3 ; i++)
\r
493 if (vMaxs[i] < vMins[i])
\r
494 Error ("Brush_RebuildBrush: backwards");
\r
496 pts[0][0][0] = vMins[0];
\r
497 pts[0][0][1] = vMins[1];
\r
499 pts[1][0][0] = vMins[0];
\r
500 pts[1][0][1] = vMaxs[1];
\r
502 pts[2][0][0] = vMaxs[0];
\r
503 pts[2][0][1] = vMaxs[1];
\r
505 pts[3][0][0] = vMaxs[0];
\r
506 pts[3][0][1] = vMins[1];
\r
508 for (i=0 ; i<4 ; i++)
\r
510 pts[i][0][2] = vMins[2];
\r
511 pts[i][1][0] = pts[i][0][0];
\r
512 pts[i][1][1] = pts[i][0][1];
\r
513 pts[i][1][2] = vMaxs[2];
\r
516 for (i=0 ; i<4 ; i++)
\r
519 f->texdef = texdef;
\r
520 f->texdef.flags &= ~SURF_KEEP;
\r
521 f->texdef.contents &= ~CONTENTS_KEEP;
\r
522 // f->texdef.flags |= SURF_PATCH;
\r
523 f->next = b->brush_faces;
\r
524 b->brush_faces = f;
\r
527 VectorCopy (pts[j][1], f->planepts[0]);
\r
528 VectorCopy (pts[i][1], f->planepts[1]);
\r
529 VectorCopy (pts[i][0], f->planepts[2]);
\r
533 f->texdef = texdef;
\r
534 f->texdef.flags &= ~SURF_KEEP;
\r
535 f->texdef.contents &= ~CONTENTS_KEEP;
\r
536 // f->texdef.flags |= SURF_PATCH;
\r
537 f->next = b->brush_faces;
\r
538 b->brush_faces = f;
\r
540 VectorCopy (pts[0][1], f->planepts[0]);
\r
541 VectorCopy (pts[1][1], f->planepts[1]);
\r
542 VectorCopy (pts[2][1], f->planepts[2]);
\r
545 f->texdef = texdef;
\r
546 f->texdef.flags &= ~SURF_KEEP;
\r
547 f->texdef.contents &= ~CONTENTS_KEEP;
\r
548 // f->texdef.flags |= SURF_PATCH;
\r
549 f->next = b->brush_faces;
\r
550 b->brush_faces = f;
\r
552 VectorCopy (pts[2][0], f->planepts[0]);
\r
553 VectorCopy (pts[1][0], f->planepts[1]);
\r
554 VectorCopy (pts[0][0], f->planepts[2]);
\r
559 void WINAPI Patch_Rebuild(patchMesh_t *p)
\r
562 Patch_CalcBounds(p, vMin, vMax);
\r
563 Brush_RebuildBrush(p->pSymbiot, vMin, vMax);
\r
571 adds a patch brush and ties it to this patch id
\r
573 brush_t* AddBrushForPatch(patchMesh_t *pm, bool bLinkToWorld )
\r
575 // find the farthest points in x,y,z
\r
577 Patch_CalcBounds(pm, vMin, vMax);
\r
579 for (int j = 0; j < 3; j++)
\r
581 if (vMin[j] == vMax[j])
\r
588 brush_t *b = Brush_Create(vMin, vMax, &g_qeglobals.d_texturewin.texdef);
\r
590 // FIXME: this entire type of linkage needs to be fixed
\r
591 b->patchBrush = true;
\r
594 pm->bSelected = false;
\r
595 pm->bOverlay = false;
\r
601 Brush_AddToList (b, &active_brushes);
\r
602 Entity_LinkBrush (world_entity, b);
\r
609 void Patch_SetPointIntensities(int n)
\r
612 patchMesh_t *p = patchMeshes[n];
\r
613 for (int i = 0; i < p->width; i++)
\r
615 for (int j = 0; j < p->height; j++)
\r
623 // very approximate widths and heights
\r
630 float Patch_Width(patchMesh_t *p)
\r
633 for (int i = 0; i < p->width-1; i++)
\r
636 VectorSubtract(p->ctrl[i][0].xyz, p->ctrl[i+1][0].xyz, vTemp);
\r
637 f += VectorLength(vTemp);
\r
642 float Patch_WidthDistanceTo(patchMesh_t *p, int j)
\r
645 for (int i = 0; i < j; i++)
\r
648 VectorSubtract(p->ctrl[i][0].xyz, p->ctrl[i+1][0].xyz, vTemp);
\r
649 f += VectorLength(vTemp);
\r
661 float Patch_Height(patchMesh_t *p)
\r
664 for (int i = 0; i < p->height-1; i++)
\r
667 VectorSubtract(p->ctrl[0][i].xyz, p->ctrl[0][i+1].xyz, vTemp);
\r
668 f += VectorLength(vTemp);
\r
673 float Patch_HeightDistanceTo(patchMesh_t *p, int j)
\r
676 for (int i = p->height-1; i > j; i--)
\r
679 VectorSubtract(p->ctrl[0][i].xyz, p->ctrl[0][i-1].xyz, vTemp); // reverse order for T coords
\r
680 f += VectorLength(vTemp);
\r
691 texture = TotalTexture * LengthToThisControlPoint / TotalControlPointLength
\r
693 dist( this control point to first control point ) / dist ( last control pt to first)
\r
695 void WINAPI Patch_Naturalize(patchMesh_t *p)
\r
697 int nWidth = (int)(p->d_texture->width * g_pGameDescription->mTextureDefaultScale);
\r
698 int nHeight = (int)(p->d_texture->height * g_pGameDescription->mTextureDefaultScale);
\r
699 float fPWidth = Patch_Width(p);
\r
700 float fPHeight = Patch_Height(p);
\r
701 float xAccum = 0.0f;
\r
703 for ( int i = 0; i < p->width ; i++ )
\r
705 float yAccum = 0.0f;
\r
706 for ( int j = p->height-1; j >= 0 ; j-- )
\r
708 p->ctrl[i][j].st[0] = (fPWidth / nWidth) * xAccum / fPWidth;
\r
709 p->ctrl[i][j].st[1] = (fPHeight / nHeight) * yAccum / fPHeight;
\r
710 yAccum = Patch_HeightDistanceTo(p,j-1);
\r
711 //p->ctrl[i][j][3] = (fPWidth / nWidth) * (float)i / (p->width - 1);
\r
712 //p->ctrl[i][j][4] = (fPHeight/ nHeight) * (float)j / (p->height - 1);
\r
714 xAccum = Patch_WidthDistanceTo(p,i+1);
\r
722 VectorCopy(p->ctrl[1][0], p->ctrl[1][1]);
\r
727 VectorCopy(p->ctrl[3][0], p->ctrl[4][1]);
\r
728 VectorCopy(p->ctrl[2][0], p->ctrl[3][1]);
\r
729 VectorCopy(p->ctrl[2][0], p->ctrl[2][1]);
\r
730 VectorCopy(p->ctrl[2][0], p->ctrl[1][1]);
\r
731 VectorCopy(p->ctrl[1][0], p->ctrl[0][1]);
\r
732 VectorCopy(p->ctrl[1][0], p->ctrl[0][2]);
\r
733 VectorCopy(p->ctrl[1][0], p->ctrl[1][2]);
\r
734 VectorCopy(p->ctrl[2][0], p->ctrl[2][2]);
\r
735 VectorCopy(p->ctrl[3][0], p->ctrl[3][2]);
\r
736 VectorCopy(p->ctrl[3][0], p->ctrl[4][2]);
\r
740 int Index3By[][2] =
\r
759 int Index5By[][2] =
\r
781 int Interior3By[][2] =
\r
786 int Interior5By[][2] =
\r
799 int Interior3ByCount = sizeof(Interior3By) / sizeof(int[2]);
\r
800 int Interior5ByCount = sizeof(Interior5By) / sizeof(int[2]);
\r
802 extern int Plane_FromPoints(vec3_t p1, vec3_t p2, vec3_t p3, plane_t *plane);
\r
803 // the bFaceCycle only means we are going through a patch cycling loop
\r
804 // then we rely on g_vCycleCapNormal to compute the cap
\r
806 void Patch_CapTexture(patchMesh_t *p, bool bFaceCycle = false)
\r
808 vec3_t vProjection, vX, vY;
\r
809 qtexture_t *texture = p->pShader->getTexture();
\r
810 plane_t Plane1, Plane2, Plane3;
\r
814 VectorCopy (g_vCycleCapNormal, vProjection);
\r
818 VectorClear ( vProjection );
\r
820 // find normal for plane from first 3 corner points
\r
821 if (!Plane_FromPoints(p->ctrl[0][0].xyz,p->ctrl[0][p->height-1].xyz,p->ctrl[p->width-1][p->height-1].xyz,&Plane1))
\r
823 VectorClear ( Plane3.normal );
\r
827 // find normal for plane from next 3 corner points
\r
828 if (!Plane_FromPoints(p->ctrl[p->width-1][p->height-1].xyz,p->ctrl[p->width-1][0].xyz,p->ctrl[0][0].xyz,&Plane2))
\r
832 VectorCopy ( Plane1.normal, Plane3.normal );
\r
833 Plane3.dist = Plane1.dist;
\r
840 // find average plane for all 4 corner points
\r
842 for (int n = 0; n <= 2; n++)
\r
844 Plane3.normal[n] = (Plane1.normal[n] + Plane2.normal[n]) / 2;
\r
846 Plane3.dist = (Plane1.dist + Plane2.dist) / 2;
\r
850 VectorCopy ( Plane2.normal, Plane3.normal );
\r
851 Plane3.dist = Plane2.dist;
\r
855 // get best axis for projection from average plane
\r
856 //Sys_Printf("surface normal1: (%f,%f,%f)\n",Plane1.normal[0],Plane1.normal[1],Plane1.normal[0]);
\r
857 //Sys_Printf("surface normal2: (%f,%f,%f)\n",Plane2.normal[0],Plane2.normal[1],Plane2.normal[0]);
\r
858 //Sys_Printf("surface normal3: (%f,%f,%f)\n",Plane3.normal[0],Plane3.normal[1],Plane3.normal[0]);
\r
859 TextureAxisFromPlane(&Plane3, vX, vY);
\r
862 for (int w = 0; w < p->width; w++)
\r
864 for (int h = 0; h < p->height; h++)
\r
866 if (vProjection[2] == 1.0f || (vX[0] == 1.0f && vY[1] == -1.0f))
\r
868 p->ctrl[w][h].st[0] = p->ctrl[w][h].xyz[0] / (texture->width * g_pGameDescription->mTextureDefaultScale);
\r
869 p->ctrl[w][h].st[1] = p->ctrl[w][h].xyz[1] / (texture->height * g_pGameDescription->mTextureDefaultScale) * -1;
\r
871 else if (vProjection[0] == 1.0f || (vX[1] == 1.0f && vY[2] == -1.0f))
\r
873 p->ctrl[w][h].st[0] = p->ctrl[w][h].xyz[1] / (texture->width * g_pGameDescription->mTextureDefaultScale);
\r
874 p->ctrl[w][h].st[1] = p->ctrl[w][h].xyz[2] / (texture->height * g_pGameDescription->mTextureDefaultScale) * -1;
\r
876 else if (vProjection[1] == 1.0f || (vX[0] == 1.0f && vY[2] == -1.0f))
\r
878 p->ctrl[w][h].st[0] = p->ctrl[w][h].xyz[0] / (texture->width * g_pGameDescription->mTextureDefaultScale);
\r
879 p->ctrl[w][h].st[1] = p->ctrl[w][h].xyz[2] / (texture->height * g_pGameDescription->mTextureDefaultScale) * -1;
\r
881 //Sys_Printf("(%i,%i) (%f,%f,%f) (%f,%f) %f\n",w,h,
\r
882 // p->ctrl[w][h].xyz[0],p->ctrl[w][h].xyz[1],p->ctrl[w][h].xyz[2],
\r
883 // p->ctrl[w][h].st[0],p->ctrl[w][h].st[1],p->ctrl[w][h].normal);
\r
886 // make sure it will rebuild
\r
890 void FillPatch(patchMesh_t *p, vec3_t v)
\r
892 for (int i = 0; i < p->width; i++)
\r
894 for (int j = 0; j < p->height; j++)
\r
896 VectorCopy(v, p->ctrl[i][j].xyz);
\r
901 // temporarily moved function to allow use in Cap() and CapSpecial()
\r
902 void patchInvert(patchMesh_t *p)
\r
904 drawVert_t vertTemp;
\r
906 for ( int i = 0 ; i < p->width ; i++ )
\r
908 for (int j = 0; j < p->height / 2; j++)
\r
910 memcpy(&vertTemp, &p->ctrl[i][p->height - 1- j], sizeof (drawVert_t));
\r
911 memcpy(&p->ctrl[i][p->height - 1 - j], &p->ctrl[i][j], sizeof(drawVert_t));
\r
912 memcpy(&p->ctrl[i][j], &vertTemp, sizeof(drawVert_t));
\r
917 brush_t* Cap(patchMesh_t *pParent, bool bByColumn, bool bFirst)
\r
924 bool bSmall = true;
\r
925 // make a generic patch
\r
926 if (pParent->width <= 9)
\r
928 b = Patch_GenericMesh(3, 3, 2, false);
\r
932 b = Patch_GenericMesh(5, 5, 2, false);
\r
938 Sys_Printf("Unable to cap. You may need to ungroup the patch.\n");
\r
943 p->type |= PATCH_CAP;
\r
945 vMin[0] = vMin[1] = vMin[2] = 9999;
\r
946 vMax[0] = vMax[1] = vMax[2] = -9999;
\r
948 // we seam the column edge, FIXME: this might need to be able to seem either edge
\r
950 int nSize = (bByColumn) ? pParent->width : pParent->height;
\r
951 int nIndex = (bFirst) ? 0 : (bByColumn) ? pParent->height-1 : pParent->width-1;
\r
953 FillPatch(p, pParent->ctrl[0][nIndex].xyz);
\r
955 for (i = 0; i < nSize; i++)
\r
961 VectorCopy(pParent->ctrl[i][nIndex].xyz, p->ctrl[Index3By[i][0]][Index3By[i][1]].xyz);
\r
965 VectorCopy(pParent->ctrl[i][nIndex].xyz, p->ctrl[Index5By[i][0]][Index5By[i][1]].xyz);
\r
972 VectorCopy(pParent->ctrl[nIndex][i].xyz, p->ctrl[Index3By[i][0]][Index3By[i][1]].xyz);
\r
976 VectorCopy(pParent->ctrl[nIndex][i].xyz, p->ctrl[Index5By[i][0]][Index5By[i][1]].xyz);
\r
980 for (j = 0; j < 3; j++)
\r
982 float f = (bSmall) ? p->ctrl[Index3By[i][0]][Index3By[i][1]].xyz[j] : p->ctrl[Index5By[i][0]][Index5By[i][1]].xyz[j];
\r
991 for (j = 0; j < 3; j++)
\r
993 vTemp[j] = vMin[j] + fabs((vMax[j] - vMin[j]) * 0.5);
\r
995 int nCount = (bSmall) ? Interior3ByCount : Interior5ByCount;
\r
996 for (j = 0; j < nCount; j++)
\r
1000 VectorCopy(vTemp, p->ctrl[Interior3By[j][0]][Interior3By[j][1]].xyz);
\r
1004 VectorCopy(vTemp, p->ctrl[Interior5By[j][0]][Interior5By[j][1]].xyz);
\r
1012 drawVert_t vertTemp;
\r
1013 for (i = 0; i < p->width; i++)
\r
1015 for (j = 0; j < p->height / 2; j++)
\r
1017 memcpy(&vertTemp, &p->ctrl[i][p->height - 1- j], sizeof (drawVert_t));
\r
1018 memcpy(&p->ctrl[i][p->height - 1 - j], &p->ctrl[i][j], sizeof(drawVert_t));
\r
1019 memcpy(&p->ctrl[i][j], &vertTemp, sizeof(drawVert_t));
\r
1026 Patch_CapTexture(p);
\r
1027 return p->pSymbiot;
\r
1030 brush_t* CapSpecial(patchMesh_t *pParent, int nType, bool bFirst)
\r
1035 vec3_t vMin, vMax, vTemp;
\r
1038 if (nType == IENDCAP)
\r
1039 b = Patch_GenericMesh(5, 3, 2, false);
\r
1041 b = Patch_GenericMesh(3, 3, 2, false);
\r
1045 Sys_Printf("Unable to cap. Make sure you ungroup before re-capping.");
\r
1050 p->type |= PATCH_CAP;
\r
1052 vMin[0] = vMin[1] = vMin[2] = 9999;
\r
1053 vMax[0] = vMax[1] = vMax[2] = -9999;
\r
1055 // int nSize = pParent->width;
\r
1056 int nIndex = (bFirst) ? 0 : pParent->height-1;
\r
1058 // parent bounds are used for some things
\r
1059 Patch_CalcBounds(pParent, vMin, vMax);
\r
1061 for (j = 0; j < 3; j++)
\r
1063 vTemp[j] = vMin[j] + fabs((vMax[j] - vMin[j]) * 0.5);
\r
1066 if (nType == IBEVEL)
\r
1068 VectorCopy(pParent->ctrl[0][nIndex].xyz, p->ctrl[0][0].xyz);
\r
1069 VectorCopy(pParent->ctrl[2][nIndex].xyz, p->ctrl[0][2].xyz);
\r
1070 VectorCopy(pParent->ctrl[1][nIndex].xyz, p->ctrl[0][1].xyz);
\r
1071 VectorCopy(pParent->ctrl[1][nIndex].xyz, p->ctrl[2][2].xyz);
\r
1072 VectorCopy(pParent->ctrl[1][nIndex].xyz, p->ctrl[1][0].xyz);
\r
1073 VectorCopy(pParent->ctrl[1][nIndex].xyz, p->ctrl[1][1].xyz);
\r
1074 VectorCopy(pParent->ctrl[1][nIndex].xyz, p->ctrl[1][2].xyz);
\r
1075 VectorCopy(pParent->ctrl[1][nIndex].xyz, p->ctrl[2][0].xyz);
\r
1076 VectorCopy(pParent->ctrl[1][nIndex].xyz, p->ctrl[2][1].xyz);
\r
1078 else if (nType == BEVEL)
\r
1080 vec3_t p1, p2, p3, p4; //, temp, dir;
\r
1082 VectorCopy(pParent->ctrl[0][nIndex].xyz, p3);
\r
1083 VectorCopy(pParent->ctrl[1][nIndex].xyz, p1);
\r
1084 VectorCopy(pParent->ctrl[2][nIndex].xyz, p2);
\r
1086 //Sys_Printf("CapSpecial() p1: %f %f %f\n",p1[0],p1[1],p1[2]);
\r
1087 //Sys_Printf("CapSpecial() p2: %f %f %f\n",p2[0],p2[1],p2[2]);
\r
1088 //Sys_Printf("CapSpecial() p3: %f %f %f\n",p3[0],p3[1],p3[2]);
\r
1090 VectorSubtract(p2, p1, p4);
\r
1091 VectorAdd(p3, p4, p4);
\r
1092 // spog - use opposite-point-on-parallelogram to find p4
\r
1094 VectorSubtract(p3, p2, dir);
\r
1095 VectorNormalize(dir);
\r
1096 VectorSubtract(p1, p2, temp);
\r
1097 vec_t dist = _DotProduct(temp, dir);
\r
1098 VectorScale(dir, dist, temp);
\r
1099 VectorAdd(p2, temp, temp);
\r
1100 VectorSubtract(temp, p1, temp);
\r
1101 VectorScale(temp, 2, temp);
\r
1102 VectorAdd(p1, temp, p4);
\r
1105 //Sys_Printf("CapSpecial() p1: %f %f %f\n",p1[0],p1[1],p1[2]);
\r
1106 //Sys_Printf("CapSpecial() p2: %f %f %f\n",p2[0],p2[1],p2[2]);
\r
1107 //Sys_Printf("CapSpecial() p3: %f %f %f\n",p3[0],p3[1],p3[2]);
\r
1108 //Sys_Printf("CapSpecial() p4: %f %f %f\n",p4[0],p4[1],p4[2]);
\r
1110 VectorCopy(p4, p->ctrl[0][0].xyz);
\r
1111 VectorCopy(p4, p->ctrl[1][0].xyz);
\r
1112 VectorCopy(p4, p->ctrl[0][1].xyz);
\r
1113 VectorCopy(p4, p->ctrl[1][1].xyz);
\r
1114 VectorCopy(p4, p->ctrl[0][2].xyz);
\r
1115 VectorCopy(p4, p->ctrl[1][2].xyz);
\r
1116 VectorCopy(p2, p->ctrl[2][0].xyz);
\r
1117 VectorCopy(p1, p->ctrl[2][1].xyz);
\r
1118 VectorCopy(p3, p->ctrl[2][2].xyz);
\r
1121 else if (nType == ENDCAP)
\r
1123 VectorAdd(pParent->ctrl[4][nIndex].xyz, pParent->ctrl[0][nIndex].xyz, vTemp);
\r
1124 VectorScale(vTemp, 0.5, vTemp);
\r
1125 VectorCopy(pParent->ctrl[0][nIndex].xyz, p->ctrl[0][0].xyz);
\r
1126 VectorCopy(vTemp, p->ctrl[1][0].xyz);
\r
1127 VectorCopy(pParent->ctrl[4][nIndex].xyz, p->ctrl[2][0].xyz);
\r
1129 VectorCopy(pParent->ctrl[2][nIndex].xyz, p->ctrl[0][2].xyz);
\r
1130 VectorCopy(pParent->ctrl[2][nIndex].xyz, p->ctrl[1][2].xyz);
\r
1131 VectorCopy(pParent->ctrl[2][nIndex].xyz, p->ctrl[2][2].xyz);
\r
1132 VectorCopy(pParent->ctrl[2][nIndex].xyz, p->ctrl[1][1].xyz);
\r
1134 VectorCopy(pParent->ctrl[1][nIndex].xyz, p->ctrl[0][1].xyz);
\r
1135 VectorCopy(pParent->ctrl[3][nIndex].xyz, p->ctrl[2][1].xyz);
\r
1139 VectorCopy(pParent->ctrl[4][nIndex].xyz, p->ctrl[0][0].xyz);
\r
1140 VectorCopy(pParent->ctrl[3][nIndex].xyz, p->ctrl[1][0].xyz);
\r
1141 VectorCopy(pParent->ctrl[2][nIndex].xyz, p->ctrl[2][0].xyz);
\r
1142 VectorCopy(pParent->ctrl[1][nIndex].xyz, p->ctrl[3][0].xyz);
\r
1143 VectorCopy(pParent->ctrl[0][nIndex].xyz, p->ctrl[4][0].xyz);
\r
1145 VectorCopy(pParent->ctrl[3][nIndex].xyz, p->ctrl[0][1].xyz);
\r
1146 VectorCopy(pParent->ctrl[3][nIndex].xyz, p->ctrl[1][1].xyz);
\r
1147 VectorCopy(pParent->ctrl[2][nIndex].xyz, p->ctrl[2][1].xyz);
\r
1148 VectorCopy(pParent->ctrl[1][nIndex].xyz, p->ctrl[3][1].xyz);
\r
1149 VectorCopy(pParent->ctrl[1][nIndex].xyz, p->ctrl[4][1].xyz);
\r
1151 VectorCopy(pParent->ctrl[3][nIndex].xyz, p->ctrl[0][2].xyz);
\r
1152 VectorCopy(pParent->ctrl[3][nIndex].xyz, p->ctrl[1][2].xyz);
\r
1153 VectorCopy(pParent->ctrl[2][nIndex].xyz, p->ctrl[2][2].xyz);
\r
1154 VectorCopy(pParent->ctrl[1][nIndex].xyz, p->ctrl[3][2].xyz);
\r
1155 VectorCopy(pParent->ctrl[1][nIndex].xyz, p->ctrl[4][2].xyz);
\r
1161 drawVert_t vertTemp;
\r
1162 for (i = 0; i < p->width; i++)
\r
1164 for (j = 0; j < p->height / 2; j++)
\r
1166 memcpy(&vertTemp, &p->ctrl[i][p->height - 1- j], sizeof (drawVert_t));
\r
1167 memcpy(&p->ctrl[i][p->height - 1 - j], &p->ctrl[i][j], sizeof(drawVert_t));
\r
1168 memcpy(&p->ctrl[i][j], &vertTemp, sizeof(drawVert_t));
\r
1173 //--Patch_CalcBounds(p, vMin, vMax);
\r
1174 //--Brush_RebuildBrush(p->pSymbiot, vMin, vMax);
\r
1176 Patch_CapTexture(p);
\r
1177 return p->pSymbiot;
\r
1180 void Patch_CapCurrent()
\r
1182 patchMesh_t *pParent = NULL;
\r
1184 brush_t *pCap = NULL;
\r
1185 b[0] = b[1] = b[2] = b[3] = NULL;
\r
1187 bool b_GroupResult = TRUE;
\r
1189 if (!QE_SingleBrush(true))
\r
1191 Sys_Printf("Patch_CapCurrent: you must have a single patch selected\n");
\r
1196 for (brush_t *pb = selected_brushes.next ; pb != NULL && pb != &selected_brushes ; pb = pb->next)
\r
1198 if (pb->patchBrush)
\r
1200 pParent = pb->pPatch;
\r
1201 // decide which if any ends we are going to cap
\r
1202 // if any of these compares hit, it is a closed patch and as such
\r
1203 // the generic capping will work.. if we do not find a closed edge
\r
1204 // then we need to ask which kind of cap to add
\r
1205 if (VectorCompare(pParent->ctrl[0][0].xyz, pParent->ctrl[pParent->width-1][0].xyz))
\r
1207 pCap = Cap(pParent, true, false);
\r
1210 b[nIndex++] = pCap;
\r
1213 if (VectorCompare(pParent->ctrl[0][pParent->height-1].xyz, pParent->ctrl[pParent->width-1][pParent->height-1].xyz))
\r
1215 pCap = Cap(pParent, true, true);
\r
1218 b[nIndex++] = pCap;
\r
1221 if (VectorCompare(pParent->ctrl[0][0].xyz, pParent->ctrl[0][pParent->height-1].xyz))
\r
1223 pCap = Cap(pParent, false, false);
\r
1226 b[nIndex++] = pCap;
\r
1229 if (VectorCompare(pParent->ctrl[pParent->width-1][0].xyz, pParent->ctrl[pParent->width-1][pParent->height-1].xyz))
\r
1231 pCap = Cap(pParent, false, true);
\r
1234 b[nIndex++] = pCap;
\r
1242 // if we did not cap anything with the above tests
\r
1247 if (DoCapDlg (&type, &b_GroupResult) == IDOK)
\r
1249 b[nIndex++] = CapSpecial(pParent, type, false);
\r
1250 b[nIndex++] = CapSpecial(pParent, type, true);
\r
1256 while (nIndex > 0)
\r
1261 Select_Brush(b[nIndex]);
\r
1264 // Gef: Added toggle for capped patch func_group
\r
1265 if(b_GroupResult) {
\r
1266 entity_t *e = Entity_Alloc();
\r
1267 SetKeyValue(e, "classname", "func_group");
\r
1268 SetKeyValue(e, "type", "patchCapped");
\r
1269 Select_GroupEntity(e);
\r
1270 Entity_AddToList(e, &entities);
\r
1281 void Patch_BrushToMesh(bool bCone, bool bBevel, bool bEndcap, bool bSquare, int nHeight)
\r
1287 if (!QE_SingleBrush())
\r
1290 b = selected_brushes.next;
\r
1292 p = MakeNewPatch();
\r
1294 p->d_texture = b->brush_faces->d_texture;
\r
1295 p->pShader = b->brush_faces->pShader;
\r
1297 p->height = nHeight;
\r
1299 p->type = PATCH_CYLINDER;
\r
1300 if (bBevel & !bSquare)
\r
1302 p->type = PATCH_BEVEL;
\r
1304 int nStep = (int)((b->maxs[2] - b->mins[2]) / (p->height-1));
\r
1305 int nStart = (int)(b->mins[2]);
\r
1306 for (i = 0; i < p->height; i++)
\r
1308 p->ctrl[0][i].xyz[0] = b->mins[0];
\r
1309 p->ctrl[0][i].xyz[1] = b->mins[1];
\r
1310 p->ctrl[0][i].xyz[2] = nStart;
\r
1312 p->ctrl[1][i].xyz[0] = b->maxs[0];
\r
1313 p->ctrl[1][i].xyz[1] = b->mins[1];
\r
1314 p->ctrl[1][i].xyz[2] = nStart;
\r
1316 p->ctrl[2][i].xyz[0] = b->maxs[0];
\r
1317 p->ctrl[2][i].xyz[1] = b->maxs[1];
\r
1318 p->ctrl[2][i].xyz[2] = nStart;
\r
1322 else if (bEndcap & !bSquare)
\r
1324 p->type = PATCH_ENDCAP;
\r
1326 int nStep = (int)((b->maxs[2] - b->mins[2]) / (p->height-1));
\r
1327 int nStart = (int)(b->mins[2]);
\r
1328 for (i = 0; i < p->height; i++)
\r
1330 p->ctrl[0][i].xyz[0] = b->mins[0];
\r
1331 p->ctrl[0][i].xyz[1] = b->mins[1];
\r
1332 p->ctrl[0][i].xyz[2] = nStart;
\r
1334 p->ctrl[1][i].xyz[0] = b->mins[0];
\r
1335 p->ctrl[1][i].xyz[1] = b->maxs[1];
\r
1336 p->ctrl[1][i].xyz[2] = nStart;
\r
1338 p->ctrl[2][i].xyz[0] = b->mins[0] + ((b->maxs[0] - b->mins[0]) * 0.5);
\r
1339 p->ctrl[2][i].xyz[1] = b->maxs[1];
\r
1340 p->ctrl[2][i].xyz[2] = nStart;
\r
1342 p->ctrl[3][i].xyz[0] = b->maxs[0];
\r
1343 p->ctrl[3][i].xyz[1] = b->maxs[1];
\r
1344 p->ctrl[3][i].xyz[2] = nStart;
\r
1346 p->ctrl[4][i].xyz[0] = b->maxs[0];
\r
1347 p->ctrl[4][i].xyz[1] = b->mins[1];
\r
1348 p->ctrl[4][i].xyz[2] = nStart;
\r
1355 p->ctrl[1][0].xyz[0] = b->mins[0];
\r
1356 p->ctrl[1][0].xyz[1] = b->mins[1];
\r
1358 p->ctrl[3][0].xyz[0] = b->maxs[0];
\r
1359 p->ctrl[3][0].xyz[1] = b->mins[1];
\r
1361 p->ctrl[5][0].xyz[0] = b->maxs[0];
\r
1362 p->ctrl[5][0].xyz[1] = b->maxs[1];
\r
1364 p->ctrl[7][0].xyz[0] = b->mins[0];
\r
1365 p->ctrl[7][0].xyz[1] = b->maxs[1];
\r
1367 for ( i = 1 ; i < p->width - 1 ; i += 2 )
\r
1370 p->ctrl[i][0].xyz[2] = b->mins[2];
\r
1372 VectorCopy( p->ctrl[i][0].xyz, p->ctrl[i][2].xyz );
\r
1374 p->ctrl[i][2].xyz[2] = b->maxs[2];
\r
1376 p->ctrl[i][1].xyz[0] = ( p->ctrl[i][0].xyz[0] + p->ctrl[i][2].xyz[0] ) * 0.5;
\r
1377 p->ctrl[i][1].xyz[1] = ( p->ctrl[i][0].xyz[1] + p->ctrl[i][2].xyz[1] ) * 0.5;
\r
1378 p->ctrl[i][1].xyz[2] = ( p->ctrl[i][0].xyz[2] + p->ctrl[i][2].xyz[2] ) * 0.5;
\r
1380 InterpolateInteriorPoints( p );
\r
1384 if (bBevel || bEndcap)
\r
1388 for (i = 0; i < p->height; i++)
\r
1390 VectorCopy(p->ctrl[1][i].xyz, p->ctrl[2][i].xyz);
\r
1391 VectorCopy(p->ctrl[7][i].xyz, p->ctrl[6][i].xyz);
\r
1396 for (i = 0; i < p->height; i++)
\r
1398 VectorCopy(p->ctrl[5][i].xyz, p->ctrl[4][i].xyz);
\r
1399 VectorCopy(p->ctrl[1][i].xyz, p->ctrl[2][i].xyz);
\r
1400 VectorCopy(p->ctrl[7][i].xyz, p->ctrl[6][i].xyz);
\r
1401 VectorCopy(p->ctrl[8][i].xyz, p->ctrl[7][i].xyz);
\r
1407 for (i = 0; i < p->width-1; i ++)
\r
1409 for (j = 0; j < p->height; j++)
\r
1411 VectorCopy(p->ctrl[i+1][j].xyz, p->ctrl[i][j].xyz);
\r
1414 for (j = 0; j < p->height; j++)
\r
1416 VectorCopy(p->ctrl[0][j].xyz, p->ctrl[8][j].xyz);
\r
1423 Patch_Naturalize(p);
\r
1427 p->type = PATCH_CONE;
\r
1428 float xc = (b->maxs[0] + b->mins[0]) * 0.5;
\r
1429 float yc = (b->maxs[1] + b->mins[1]) * 0.5;
\r
1431 for ( i = 0 ; i < p->width ; i ++)
\r
1433 p->ctrl[i][2].xyz[0] = xc;
\r
1434 p->ctrl[i][2].xyz[1] = yc;
\r
1438 b = AddBrushForPatch(p);
\r
1446 ==================
\r
1448 ==================
\r
1450 brush_t* Patch_GenericMesh(int nWidth, int nHeight, int nOrientation, bool bDeleteSource, bool bOverride)
\r
1454 if (nHeight < 3 || nHeight > 15 || nWidth < 3 || nWidth > 15)
\r
1456 Sys_Printf("Invalid patch width or height.\n");
\r
1460 if (! bOverride && !QE_SingleBrush())
\r
1462 Sys_Printf("Error: you must have a single brush selected\n");
\r
1466 patchMesh_t* p = MakeNewPatch();
\r
1467 p->pShader = g_qeglobals.d_texturewin.pShader;
\r
1468 p->d_texture = g_qeglobals.d_texturewin.pShader->getTexture();
\r
1470 p->width = nWidth;
\r
1471 p->height = nHeight;
\r
1472 p->type = PATCH_GENERIC;
\r
1476 if (nOrientation == 0)
\r
1481 else if (nOrientation == 1)
\r
1486 brush_t *b = selected_brushes.next;
\r
1487 // set the workzone to this brush, use it later to create the patch points
\r
1488 UpdateWorkzone_ForBrush( b );
\r
1490 int xStep = (int)(b->mins[nFirst]);
\r
1491 float xAdj = fabs((b->maxs[nFirst] - b->mins[nFirst]) / (nWidth - 1));
\r
1492 float yAdj = fabs((b->maxs[nSecond] - b->mins[nSecond]) / (nHeight - 1));
\r
1494 for (i = 0; i < nWidth; i++)
\r
1496 int yStep = (int)(b->mins[nSecond]);
\r
1497 for (j = 0; j < nHeight; j++)
\r
1499 p->ctrl[i][j].xyz[nFirst] = xStep;
\r
1500 p->ctrl[i][j].xyz[nSecond] = yStep;
\r
1501 // create patch based on workzone
\r
1502 p->ctrl[i][j].xyz[nOrientation] = g_qeglobals.d_work_max[nOrientation];
\r
1503 yStep += (int)yAdj;
\r
1505 xStep += (int)xAdj;
\r
1508 Patch_Naturalize(p);
\r
1510 b = AddBrushForPatch(p);
\r
1511 if (bDeleteSource)
\r
1518 //g_qeglobals.d_select_mode = sel_curvepoint;
\r
1522 ==================
\r
1524 ==================
\r
1526 int PointInMoveList(float *pf)
\r
1528 for (int i = 0; i < g_qeglobals.d_num_move_points; i++)
\r
1530 if (pf == &g_qeglobals.d_move_points[i][0])
\r
1537 ==================
\r
1538 PointValueInMoveList
\r
1539 ==================
\r
1541 int PointValueInMoveList(vec3_t v)
\r
1543 for (int i = 0; i < g_qeglobals.d_num_move_points; i++)
\r
1545 if (VectorCompare(v, g_qeglobals.d_move_points[i]))
\r
1553 ==================
\r
1554 RemovePointFromMoveList
\r
1555 ==================
\r
1557 void RemovePointFromMoveList(vec3_t v)
\r
1560 while ( (n = PointValueInMoveList(v)) >= 0)
\r
1562 for (int i = n; i < g_qeglobals.d_num_move_points-1; i++)
\r
1564 g_qeglobals.d_move_points[i] = g_qeglobals.d_move_points[i+1];
\r
1566 g_qeglobals.d_num_move_points--;
\r
1571 ==================
\r
1573 ==================
\r
1575 bool ColumnSelected(patchMesh_t* p, int nCol)
\r
1577 for (int i = 0; i < p->height; i++)
\r
1579 if (PointInMoveList(p->ctrl[nCol][i].xyz) == -1)
\r
1586 ==================
\r
1588 ==================
\r
1590 void AddPoint(patchMesh_t* p, vec3_t v, bool bWeldOrDrill = true)
\r
1592 int nDim1 = (g_pParentWnd->ActiveXY()->GetViewType() == YZ) ? 1 : 0;
\r
1593 int nDim2 = (g_pParentWnd->ActiveXY()->GetViewType() == XY) ? 1 : 2;
\r
1594 g_qeglobals.d_move_points[g_qeglobals.d_num_move_points++] = v;
\r
1595 if ((g_bPatchWeld || g_bPatchDrillDown) && bWeldOrDrill)
\r
1597 for ( int i = 0 ; i < p->width ; i++ )
\r
1599 for ( int j = 0 ; j < p->height ; j++ )
\r
1603 if ( VectorCompare(v, p->ctrl[i][j].xyz)
\r
1604 && PointInMoveList(p->ctrl[i][j].xyz) == -1)
\r
1606 g_qeglobals.d_move_points[g_qeglobals.d_num_move_points++] = p->ctrl[i][j].xyz;
\r
1610 if (g_bPatchDrillDown && g_nPatchClickedView != W_CAMERA)
\r
1612 if ( (fabs(v[nDim1] - p->ctrl[i][j].xyz[nDim1]) <= EQUAL_EPSILON)
\r
1613 &&(fabs(v[nDim2] - p->ctrl[i][j].xyz[nDim2]) <= EQUAL_EPSILON))
\r
1615 if (PointInMoveList(p->ctrl[i][j].xyz) == -1)
\r
1617 g_qeglobals.d_move_points[g_qeglobals.d_num_move_points++] = p->ctrl[i][j].xyz;
\r
1628 ==================
\r
1630 ==================
\r
1632 void SelectRow(patchMesh_t* p, int nRow, bool bMulti)
\r
1635 g_qeglobals.d_num_move_points = 0;
\r
1636 for (int i = 0; i < p->width; i++)
\r
1638 AddPoint(p, p->ctrl[i][nRow].xyz, false);
\r
1640 //Sys_Printf("Selected Row %d\n", nRow);
\r
1644 ==================
\r
1646 ==================
\r
1648 void SelectColumn(patchMesh_t* p, int nCol, bool bMulti)
\r
1651 g_qeglobals.d_num_move_points = 0;
\r
1652 for (int i = 0; i < p->height; i++)
\r
1654 AddPoint(p, p->ctrl[nCol][i].xyz, false);
\r
1656 //Sys_Printf("Selected Col %d\n", nCol);
\r
1661 ==================
\r
1663 ==================
\r
1665 void AddPatchMovePoint(vec3_t v, bool bMulti, bool bFull)
\r
1667 if (!g_bSameView && !bMulti && !bFull)
\r
1669 g_bSameView = true;
\r
1670 //return; // was causing odd behaviour on patch vertex selection
\r
1673 for (brush_t *pb = selected_brushes.next ; pb != &selected_brushes ; pb = pb->next)
\r
1675 if (pb->patchBrush)
\r
1677 patchMesh_t* p = pb->pPatch;
\r
1678 for ( int i = 0 ; i < p->width ; i++ )
\r
1680 for ( int j = 0 ; j < p->height ; j++ )
\r
1682 if (VectorCompare(v, p->ctrl[i][j].xyz))
\r
1684 if (PointInMoveList(p->ctrl[i][j].xyz) == -1)
\r
1686 if (bFull) // if we want the full row/col this is on
\r
1688 SelectColumn(p, i, bMulti);
\r
1693 g_qeglobals.d_num_move_points = 0;
\r
1694 AddPoint(p, p->ctrl[i][j].xyz);
\r
1695 //Sys_Printf("Selected col:row %d:%d\n", i, j);
\r
1704 if (ColumnSelected(p, i))
\r
1706 SelectRow(p, j, bMulti);
\r
1710 SelectColumn(p, i, bMulti);
\r
1716 // g_qeglobals.d_num_move_points = 0;
\r
1717 // AddPoint(p, p->ctrl[i][j].xyz);
\r
1719 if (bMulti)// if (g_bSameView) // this is not having desired effect
\r
1721 RemovePointFromMoveList(v);
\r
1733 ==================
\r
1734 Patch_UpdateSelected
\r
1735 ==================
\r
1737 void Patch_UpdateSelected(vec3_t vMove)
\r
1740 for (i=0 ; i < g_qeglobals.d_num_move_points ; i++)
\r
1742 VectorAdd (g_qeglobals.d_move_points[i], vMove, g_qeglobals.d_move_points[i]);
\r
1743 if (g_qeglobals.d_num_move_points == 1)
\r
1748 //--patchMesh_t* p = &patchMeshes[g_nSelectedPatch];
\r
1749 for (brush_t *pb = selected_brushes.next ; pb != &selected_brushes ; pb = pb->next)
\r
1751 if (pb->patchBrush)
\r
1753 patchMesh_t* p = pb->pPatch;
\r
1755 #if 0 //moving to SelectCurvePointByRay
\r
1756 g_qeglobals.d_numpoints = 0;
\r
1757 for (i = 0 ; i < p->width ; i++ )
\r
1759 for ( j = 0 ; j < p->height ; j++ )
\r
1761 VectorCopy (p->ctrl[i][j].xyz, g_qeglobals.d_points[g_qeglobals.d_numpoints]);
\r
1762 if (g_qeglobals.d_numpoints < MAX_POINTS-1)
\r
1764 g_qeglobals.d_numpoints++;
\r
1769 vec3_t vMin, vMax;
\r
1770 Patch_CalcBounds(p, vMin, vMax);
\r
1771 Brush_RebuildBrush(p->pSymbiot, vMin, vMax);
\r
1774 //Brush_Free(p->pSymbiot);
\r
1775 //Select_Brush(AddBrushForPatch(g_nSelectedPatch));
\r
1785 void SampleSinglePatch (float ctrl[3][3][5], float u, float v, float out[5]) {
\r
1786 float vCtrl[3][5];
\r
1790 // find the control points for the v coordinate
\r
1791 for (vPoint = 0 ; vPoint < 3 ; vPoint++)
\r
1793 for (axis = 0 ; axis < 5 ; axis++)
\r
1798 a = ctrl[0][vPoint][axis];
\r
1799 b = ctrl[1][vPoint][axis];
\r
1800 c = ctrl[2][vPoint][axis];
\r
1801 qA = a - 2 * b + c;
\r
1802 qB = 2 * b - 2 * a;
\r
1805 vCtrl[vPoint][axis] = qA * u * u + qB * u + qC;
\r
1809 // interpolate the v value
\r
1810 for (axis = 0 ; axis < 5 ; axis++)
\r
1815 a = vCtrl[0][axis];
\r
1816 b = vCtrl[1][axis];
\r
1817 c = vCtrl[2][axis];
\r
1818 qA = a - 2 * b + c;
\r
1819 qB = 2 * b - 2 * a;
\r
1822 out[axis] = qA * v * v + qB * v + qC;
\r
1826 //spog - Curve LOD stuff starts
\r
1828 float ShadeForNormal(vec3_t normal)
\r
1838 // quick diffuse shading
\r
1839 f = DotProduct(L, normal);
\r
1841 // range 0.5 to 1.0
\r
1843 //if (f < 0.0f) f = 0.0f;
\r
1850 void ShadeVertex (drawVert_t &p)
\r
1852 p.lightmap[0] = ShadeForNormal(p.normal);
\r
1856 void Patch_DrawNormals(patchMesh_t *patch)
\r
1861 qglBegin (GL_LINES);
\r
1862 for (col=0; col<patch->width; col++)
\r
1864 for (row=0; row<patch->height; row++)
\r
1866 VectorAdd(patch->ctrl[col][row].xyz, patch->ctrl[col][row].normal, vNormal);
\r
1867 qglVertex3fv (patch->ctrl[col][row].xyz);
\r
1868 qglVertex3fv (vNormal);
\r
1875 // take an array of three drawVerts, and the addresses of three more drawVerts
\r
1876 // interpolate new XYZST values from the three drawVerts, these are:
\r
1877 // the left sub-control-point, the right sub-control-point and the midpoint of the curve respectively
\r
1878 // store these values in the drawVerts passed to the function
\r
1879 void Patch_CurveSplit(drawVert_t *vCurve[3], drawVert_t &pLeft, drawVert_t &pRight, drawVert_t &pMid, float u)
\r
1884 drawVert_t v1, v2, v3;
\r
1887 for (i=0; i<3; i++)
\r
1890 v1.xyz[i] = vCurve[1]->xyz[i] - vCurve[0]->xyz[i];
\r
1891 v2.xyz[i] = vCurve[2]->xyz[i] - vCurve[1]->xyz[i];
\r
1894 pLeft.xyz[i] = vCurve[0]->xyz[i] + v1.xyz[i];
\r
1895 pRight.xyz[i] = vCurve[1]->xyz[i] + v2.xyz[i];
\r
1897 v3.xyz[i] = pRight.xyz[i] - pLeft.xyz[i];
\r
1899 pMid.xyz[i] = pLeft.xyz[i] + v3.xyz[i];
\r
1901 // normal (weighted average) // no, that's b0rked
\r
1902 //a = 1 / u; // total
\r
1903 //b = u * a; // component 2
\r
1904 //a = u - b; // component 1
\r
1905 //pMid.normal[i] = u * ((vCurve[0]->normal[i] * b) + (vCurve[2]->normal[i] * a));
\r
1907 if (i==2) continue;
\r
1910 v1.st[i] = vCurve[1]->st[i] - vCurve[0]->st[i];
\r
1911 v2.st[i] = vCurve[2]->st[i] - vCurve[1]->st[i];
\r
1914 pLeft.st[i] = vCurve[0]->st[i] + v1.st[i];
\r
1915 pRight.st[i] = vCurve[1]->st[i] + v2.st[i];
\r
1917 v3.st[i] = pRight.st[i] - pLeft.st[i];
\r
1919 pMid.st[i] = pLeft.st[i] + v3.st[i];
\r
1923 // take an array of three points, return an index representing the curvature of those three points
\r
1924 // return zero if the curve is a straight line, unless the midpoint is not between the endpoints
\r
1925 float Patch_CurveIndex(vec3_t vCurve[])
\r
1927 vec3_t vTemp, v1, v2, v3, vClear;
\r
1929 float width, angle;
\r
1932 VectorClear(vClear);
\r
1934 VectorSubtract(vCurve[2], vCurve[0], vTemp);
\r
1935 VectorSubtract(vCurve[1], vCurve[0], v1);
\r
1936 VectorSubtract(vCurve[2], vCurve[1], v2);
\r
1938 if (VectorCompare(v1, vClear) || VectorCompare(vTemp, v1)) // return 0 if 1->2 == 0 or 1->2 == 1->3
\r
1941 VectorNormalize(v1, v1);
\r
1942 VectorNormalize(v2, v2);
\r
1943 if (VectorCompare(v1, v2))
\r
1946 VectorCopy(vTemp, v3);
\r
1947 width = VectorNormalize(v3, v3);
\r
1949 if (VectorCompare(v1, v3) && VectorCompare(v2, v3))
\r
1952 dot = DotProduct(v1, v2);
\r
1954 angle = acos(dot) / Q_PI;
\r
1956 index = width * angle;
\r
1962 // create a new tree root, give it the coordinate values of the drawVert
\r
1963 // return a pointer to the new tree root
\r
1964 BTNode_t *BTree_Create(drawVert_t info)
\r
1966 BTNode_t *BTree = new BTNode_t;
\r
1967 BTree->left = BTree->right = NULL;
\r
1968 VectorCopy(info.xyz, BTree->info.xyz);
\r
1969 VectorCopy(info.xyz, BTree->vMid.xyz);
\r
1970 for (int i=0; i<2; i++)
\r
1972 BTree->info.st[i] = info.st[i];
\r
1973 BTree->vMid.st[i] = info.st[i];
\r
1978 // take ownership of the subtree
\r
1979 // delete the entire subtree
\r
1980 // return a NULL pointer
\r
1981 BTNode_t *BTree_Delete(BTNode_t *pBT)
\r
1985 BTree_Delete(pBT->left);
\r
1986 BTree_Delete(pBT->right);
\r
1992 // NOT currently used
\r
1993 BTNode_t *BTree_Clear(BTNode_t *pBT, bool bFirst = true)
\r
1997 BTree_Clear(pBT->left, false);
\r
1998 BTree_Clear(pBT->right, false);
\r
1999 if (!bFirst) delete pBT;
\r
2004 // take a pointer to the last item added to the list (this can also be a NULL pointer)
\r
2005 // take a pointer to the root of a subtree, and the patch points to the left and right of it
\r
2006 // add a new item to the subtree list, and add the subtree and its adjacent points to the new item
\r
2007 // return a pointer to the last item added to the subtree list
\r
2008 BTreeList_t *BTree_AddToList(BTreeList_t *pBTList, BTNode_t *pBT, drawVert_t &pLeft, drawVert_t &pRight)
\r
2010 BTreeList_t *newBTList = new BTreeList_t;
\r
2011 newBTList->next = pBTList;
\r
2012 newBTList->pBT = pBT;
\r
2013 VectorCopy(pLeft.xyz, newBTList->vLeft.xyz);
\r
2014 VectorCopy(pRight.xyz, newBTList->vRight.xyz);
\r
2015 VectorCopy(pLeft.normal, newBTList->vLeft.normal);
\r
2016 VectorCopy(pRight.normal, newBTList->vRight.normal);
\r
2017 for (int i=0; i<2; i++)
\r
2019 newBTList->vLeft.st[i] = pLeft.st[i];
\r
2020 newBTList->vRight.st[i] = pRight.st[i];
\r
2025 // NOT currently used, subtrees are now stored on the patch
\r
2026 // take ownership of the subtree list
\r
2027 // delete the entire list and the subtrees it points to
\r
2028 // return a NULL pointer
\r
2029 BTreeList_t *BTree_DeleteList(BTreeList_t *pBTList)
\r
2031 if (pBTList != NULL)
\r
2033 BTree_DeleteList(pBTList->next);
\r
2034 pBTList->pBT = BTree_Delete(pBTList->pBT);
\r
2040 // take ownership of the subtree list
\r
2041 // delete the entire subtree list, but not the subtrees themselves
\r
2042 // return a NULL pointer
\r
2043 BTreeList_t *BTree_DeletePointerList(BTreeList_t *pBTList)
\r
2045 if (pBTList != NULL)
\r
2047 BTree_DeletePointerList(pBTList->next);
\r
2053 // take a pointer to the last item added to the list of subtree lists
\r
2054 // add a subtree list to the list
\r
2055 // return a pointer to the last item added
\r
2056 BTListList_t *BTree_AddListToList(BTListList_t *pBTListList, BTreeList_t *pBTList)
\r
2058 BTListList_t *newBTListList = new BTListList_t;
\r
2059 newBTListList->next = pBTListList;
\r
2060 newBTListList->list = pBTList;
\r
2061 return newBTListList;
\r
2065 // take ownership of the list of subtree lists
\r
2066 // delete the entire list of lists, but not the subtrees themselves
\r
2067 // return a NULL pointer
\r
2068 BTListList_t *BTree_DeleteListFromList(BTListList_t *pBTListList)
\r
2070 if (pBTListList != NULL)
\r
2072 BTree_DeleteListFromList(pBTListList->next);
\r
2073 pBTListList->list = BTree_DeletePointerList(pBTListList->list);
\r
2074 delete pBTListList;
\r
2079 // take a pointer to the last item in the list
\r
2080 // add a NULL linker subtree to the list, setting the "flipped" flag using the left curvepoint normal .. er.. hacky?
\r
2081 BTreeList_t *BTree_AddLinkToList(BTreeList_t *pBTList, bool bFlipped = false)
\r
2083 BTreeList_t *linkBTList = new BTreeList_t;
\r
2084 linkBTList->pBT = NULL;
\r
2085 linkBTList->next = pBTList;
\r
2086 linkBTList->vLeft.normal[0] = (bFlipped) ? 1.0f : 0.0f;
\r
2087 return linkBTList;
\r
2091 // take an array of three points and the address of a vector
\r
2092 // store midpoint of the bezier curve formed by the three points, in the vector
\r
2093 void Patch_BezierInterpolate(vec3_t vCurve[], vec3_t &pMid)
\r
2097 VectorSubtract(vCurve[2], vCurve[0], vTemp); // Start->End
\r
2098 for (i=0; i<3; i++)
\r
2100 VectorAdd(vCurve[0], vTemp, vTemp); // midpoint of Start->End
\r
2102 VectorSubtract(vTemp, vCurve[1], vTemp); // Mid->(midpoint of Start->End)
\r
2103 for (i=0; i<3; i++)
\r
2105 VectorAdd(vCurve[1], vTemp, pMid); // midpoint of Mid->(midpoint of Start->End)
\r
2109 // take a pointer to the list of subtrees, and a threshold value
\r
2110 // generate REAL surface curvature for the subtree curves, using bezier interpolation
\r
2111 // if any of the real curves has an index greater than the threshold, return true
\r
2112 bool Patch_MostCurvedRow(BTreeList_t *pBTList, int threshold)
\r
2115 float index;//, bestindex = 0;
\r
2120 for (p = pBTList; p != NULL; p = p->next->next)
\r
2123 VectorCopy(p->vLeft.xyz, vCurve[0]);
\r
2124 VectorCopy(p->pBT->info.xyz, vCurve[1]);
\r
2125 VectorCopy(p->vRight.xyz, vCurve[2]);
\r
2127 index = Patch_CurveIndex(vCurve);
\r
2128 if (index > threshold)
\r
2131 if (p->next == NULL)
\r
2134 if (p->next->pBT == NULL) continue;
\r
2136 VectorCopy(p->vLeft.xyz, vCurve[0]);
\r
2137 VectorCopy(p->next->vLeft.xyz, vCurve[1]);
\r
2138 VectorCopy(p->next->next->vLeft.xyz, vCurve[2]);
\r
2139 Patch_BezierInterpolate(vCurve, vRow[0]);
\r
2141 VectorCopy(p->pBT->info.xyz, vCurve[0]);
\r
2142 VectorCopy(p->next->pBT->info.xyz, vCurve[1]);
\r
2143 VectorCopy(p->next->next->pBT->info.xyz, vCurve[2]);
\r
2144 Patch_BezierInterpolate(vCurve, vRow[1]);
\r
2146 VectorCopy(p->vRight.xyz, vCurve[0]);
\r
2147 VectorCopy(p->next->vRight.xyz, vCurve[1]);
\r
2148 VectorCopy(p->next->next->vRight.xyz, vCurve[2]);
\r
2149 Patch_BezierInterpolate(vCurve, vRow[2]);
\r
2151 index = Patch_CurveIndex(vRow);
\r
2152 if (index > threshold)
\r
2159 // take a pointer to a list of subtrees.. each subtree in the list is a 3-point bezier curve formed by two endpoints owned by the list, and a midpoint subtree node owned by a patch.
\r
2160 // if any of the subtrees are curved above a threshold, create a left and right subsubtree for each subtree in the list.
\r
2161 // if a NULL linker subtree is found, check for an orientation flip - ie. an inverted LOD-match - and create a NULL subsubtree with the same orientation flip
\r
2162 // this effectively generates trees for multiple patches at the same time.. the subtrees are always owned by their respective patches though
\r
2163 void BTree_ListCurveRecurse(BTreeList_t *pBTList)
\r
2166 BTreeList_t *leftBTList, *rightBTList;
\r
2167 //drawVert_t pLeft, pRight, pMid;
\r
2168 drawVert_t *vCurve[3];
\r
2171 bool bFlipped = false;
\r
2173 if (g_PrefsDlg.m_nSubdivisions >= 1)
\r
2174 threshold = g_PrefsDlg.m_nSubdivisions;
\r
2176 leftBTList = rightBTList = NULL;
\r
2178 if (Patch_MostCurvedRow(pBTList, threshold)) // split all subtrees in list if any subtree is above threshold
\r
2180 //Sys_Printf("| ");
\r
2181 // traverse nodes in list
\r
2182 for (p = pBTList; p != NULL; p=p->next)
\r
2184 if (p->pBT == NULL)
\r
2186 leftBTList = BTree_AddLinkToList(leftBTList, (p->vLeft.normal[0] == 1.0f));
\r
2187 rightBTList = BTree_AddLinkToList(rightBTList, (p->vLeft.normal[0] == 1.0f));
\r
2188 if (p->vLeft.normal[0] == 1.0f) bFlipped = (!bFlipped) ? true : false; // switch bFlipped if true
\r
2192 // create left node for this subtree
\r
2193 BTNode_t *newLeft = new BTNode_t;
\r
2194 p->pBT->left = newLeft;
\r
2195 newLeft->left = newLeft->right = NULL;
\r
2197 // create right node for this subtree
\r
2198 BTNode_t *newRight = new BTNode_t;
\r
2199 p->pBT->right = newRight;
\r
2200 newRight->left = newRight->right = NULL;
\r
2202 // split this node
\r
2203 vCurve[0] = &p->vLeft;
\r
2204 vCurve[1] = &p->pBT->info;
\r
2205 vCurve[2] = &p->vRight;
\r
2206 Patch_CurveSplit(vCurve, newLeft->info, newRight->info, p->pBT->vMid, 0.5);
\r
2208 memcpy(&newLeft->vMid, &newLeft->info, sizeof(drawVert_t));
\r
2209 memcpy(&newRight->vMid, &newRight->info, sizeof(drawVert_t));
\r
2214 // add new left subtree to left subtree list
\r
2215 leftBTList = BTree_AddToList(leftBTList, newLeft, p->vLeft, p->pBT->vMid);
\r
2217 // add new right subtree to right subtree list
\r
2218 rightBTList = BTree_AddToList(rightBTList, newRight, p->pBT->vMid, p->vRight);
\r
2222 // add new left subtree to right subtree list
\r
2223 rightBTList = BTree_AddToList(rightBTList, newLeft, p->vLeft, p->pBT->vMid);
\r
2225 // add new right subtree to left subtree list
\r
2226 leftBTList = BTree_AddToList(leftBTList, newRight, p->pBT->vMid, p->vRight);
\r
2230 // continue tree left
\r
2231 BTree_ListCurveRecurse(leftBTList);
\r
2232 leftBTList = BTree_DeletePointerList(leftBTList);
\r
2234 // continue tree right
\r
2235 BTree_ListCurveRecurse(rightBTList);
\r
2236 rightBTList = BTree_DeletePointerList(rightBTList);
\r
2240 // take mins and maxs values from two brushes
\r
2241 // return true if they intersect on every axis
\r
2242 bool TouchingAABBs(vec3_t mins1, vec3_t maxs1, vec3_t mins2, vec3_t maxs2)
\r
2245 vec3_t v1, v2, p1, p2, T;
\r
2246 for (int i=0; i<3; i++)
\r
2248 v1[i] = maxs1[i] - mins1[i];
\r
2249 v2[i] = maxs2[i] - mins2[i];
\r
2252 p1[i] = mins1[i] + v1[i];
\r
2253 p2[i] = mins2[i] + v2[i];
\r
2254 // p1 == origin of aabb1
\r
2255 // p2 == origin of aabb1
\r
2256 // v1 == displacement of aabb1
\r
2257 // v1 == displacement of aabb2
\r
2258 T[i] = p2[i] - p1[i]; // T == vector from aabb1 to aabb2
\r
2259 if ( fabs(T[i]) > (fabs(v1[i]) + fabs(v2[i])) )
\r
2265 // take a pointer to the last item added to pBTList, a pointer to the patch, a row index (start) and a column index
\r
2266 // generate a row of row-curve tree roots, owned by the patch and add the entire column of row-curves to the list, using the row index to decide the order to add
\r
2267 // return a pointer to the last item added to the list
\r
2268 BTreeList_t *Patch_CreateBTListForRows(BTreeList_t *pBTList, patchMesh_t *patch, int start, int col)
\r
2271 patch->colDirty[(col-1)/2] = true;
\r
2275 for (row=0; row<patch->height; row++)
\r
2277 pos = (((col-1)/2)*patch->height)+row;
\r
2278 patch->rowLOD[pos] = BTree_Delete(patch->rowLOD[pos]);
\r
2279 patch->rowLOD[pos] = BTree_Create(patch->ctrl[col][row]);
\r
2280 pBTList = BTree_AddToList(pBTList, patch->rowLOD[pos], patch->ctrl[col-1][row], patch->ctrl[col+1][row]);
\r
2285 for (row=patch->height-1; row>=0; row--)
\r
2287 pos = (((col-1)/2)*patch->height)+row;
\r
2288 patch->rowLOD[pos] = BTree_Delete(patch->rowLOD[pos]);
\r
2289 patch->rowLOD[pos] = BTree_Create(patch->ctrl[col][row]);
\r
2290 pBTList = BTree_AddToList(pBTList, patch->rowLOD[pos], patch->ctrl[col-1][row], patch->ctrl[col+1][row]);
\r
2296 // take a pointer to the last item added to pBTList, a pointer to the patch, a row index and a column index (start)
\r
2297 // generate a row of column-curve tree roots, owned by the patch and add the entire row of column-curves to the list, using the column index to decide the order to add
\r
2298 // return a pointer to the last item added to the list
\r
2299 BTreeList_t *Patch_CreateBTListForCols(BTreeList_t *pBTList, patchMesh_t *patch, int row, int start)
\r
2302 patch->rowDirty[(row-1)/2] = true;
\r
2306 for (col=0; col<patch->width; col++)
\r
2308 pos = (((row-1)/2)*patch->width)+col;
\r
2309 patch->colLOD[pos] = BTree_Delete(patch->colLOD[pos]);
\r
2310 patch->colLOD[pos] = BTree_Create(patch->ctrl[col][row]);
\r
2311 pBTList = BTree_AddToList(pBTList, patch->colLOD[pos], patch->ctrl[col][row-1], patch->ctrl[col][row+1]);
\r
2316 for (col=patch->width-1; col>=0; col--)
\r
2318 pos = (((row-1)/2)*patch->width)+col;
\r
2319 patch->colLOD[pos] = BTree_Delete(patch->colLOD[pos]);
\r
2320 patch->colLOD[pos] = BTree_Create(patch->ctrl[col][row]);
\r
2321 pBTList = BTree_AddToList(pBTList, patch->colLOD[pos], patch->ctrl[col][row-1], patch->ctrl[col][row+1]);
\r
2328 bool BTree_IsInList(BTreeList_t *pBTList, BTNode_t *pBT)
\r
2331 if (pBTList == NULL) return false;
\r
2333 for (p=pBTList; p != NULL; p=p->next)
\r
2335 if (p->pBT != NULL)
\r
2337 if (p->pBT == pBT)
\r
2344 int Patch_DegenCurve(vec3_t &start, vec3_t &mid, vec3_t &end)
\r
2346 if (VectorCompare(start, mid) || VectorCompare(end, mid))
\r
2348 if (VectorCompare(start, end)) return 2;
\r
2354 // take a pointer to the last item added to the list, and a pointer to a patch (this patch is the owner of the three drawverts)
\r
2355 // take the addresses of three drawVerts, and compare them with the edges of all patches that touch the patch
\r
2356 // if they match an edge, add the tree roots for that section of the matched patch to the list, and recurse for the opposite edge of that patch section. Also, set the matched patch Dirty, so that its drawlists will be rebuilt
\r
2357 // return a pointer to the last item added
\r
2358 BTreeList_t *Patch_FindLODMatches(patchMesh_t *patch, BTreeList_t *pBTList, drawVert_t &pMid, drawVert_t &pLeft, drawVert_t &pRight)
\r
2360 brush_t *pb, *brushlist;
\r
2361 int row, col, i;//, pos;
\r
2362 vec3_t vTemp, v1, v2;//, vClear;
\r
2363 bool bAlreadyAdded;
\r
2365 //Sys_Printf("Patch_FindLODMatches: called\n");
\r
2367 if (VectorCompare(pMid.xyz, pLeft.xyz) && VectorCompare(pMid.xyz, pRight.xyz))
\r
2370 //VectorClear(vClear);
\r
2371 VectorSubtract(pRight.xyz, pLeft.xyz, vTemp);
\r
2372 VectorSubtract(pMid.xyz, pLeft.xyz, v1);
\r
2373 VectorSubtract(pRight.xyz, pMid.xyz, v2);
\r
2375 //if (VectorCompare(v1, vClear) || VectorCompare(vTemp, v1)) // return null if 1->2 == 0 or 1->2 == 1->3
\r
2376 // return pBTList;
\r
2378 VectorNormalize(v1, v1);
\r
2379 VectorNormalize(v2, v2);
\r
2380 if (VectorCompare(v1, v2))
\r
2383 VectorNormalize(vTemp, vTemp);
\r
2384 if (VectorCompare(v1, vTemp) && VectorCompare(v2, vTemp))
\r
2387 brushlist = &active_brushes;
\r
2388 for (i=0; i<2; i++)
\r
2390 for (pb = brushlist->next; pb != brushlist; pb=pb->next)
\r
2392 if (!pb->patchBrush || pb->pPatch == patch)
\r
2395 // ignore this patch if its AABB does not touch the subject patch
\r
2396 if (!TouchingAABBs(patch->pSymbiot->maxs, patch->pSymbiot->mins, pb->maxs, pb->mins))
\r
2399 // all columns of curves
\r
2400 for (col=1; col<pb->pPatch->width; col+=2)
\r
2402 if (pb->pPatch->colDirty[(col-1)/2]) continue;
\r
2404 bAlreadyAdded = false;
\r
2406 // top and bottom curves of this column
\r
2407 for (row=0; row<pb->pPatch->height; row+=pb->pPatch->height-1)
\r
2409 if (bAlreadyAdded)
\r
2411 //if (!BTree_IsInList(pBTList, pb->pPatch->rowLOD[(((col-1)/2)*patch->height)+row]))
\r
2413 // ignore this curve if it shares no mid ctrl point with the test curve
\r
2414 if (!VectorCompare (pb->pPatch->ctrl[col][row].xyz, pMid.xyz))
\r
2416 // ignore this curve if it is degenerate
\r
2417 if (VectorCompare (pb->pPatch->ctrl[col][row].xyz, pb->pPatch->ctrl[col-1][row].xyz) || VectorCompare (pb->pPatch->ctrl[col][row].xyz, pb->pPatch->ctrl[col+1][row].xyz))
\r
2419 // if curve matches the test curve directly
\r
2420 if (VectorCompare (pb->pPatch->ctrl[col-1][row].xyz, pLeft.xyz) && VectorCompare (pb->pPatch->ctrl[col+1][row].xyz, pRight.xyz))
\r
2422 // add a blank link as separator
\r
2423 pBTList = BTree_AddLinkToList(pBTList);
\r
2424 // add this entire column, if top, top-to-bottom, else bottom to top
\r
2425 pBTList = Patch_CreateBTListForRows(pBTList, pb->pPatch, row, col);
\r
2426 // continue checking from last curve added to list
\r
2427 pBTList = Patch_FindLODMatches(pb->pPatch, pBTList, pBTList->pBT->info, pBTList->vLeft, pBTList->vRight);
\r
2429 pb->pPatch->LODUpdated = true;
\r
2430 bAlreadyAdded = true;
\r
2432 // if curve matches test curve but flipped
\r
2433 else if (VectorCompare (pb->pPatch->ctrl[col-1][row].xyz, pRight.xyz) && VectorCompare (pb->pPatch->ctrl[col+1][row].xyz, pLeft.xyz))
\r
2435 pBTList = BTree_AddLinkToList(pBTList, true); // flip
\r
2436 pBTList = Patch_CreateBTListForRows(pBTList, pb->pPatch, row, col);
\r
2437 pBTList = Patch_FindLODMatches(pb->pPatch, pBTList, pBTList->pBT->info, pBTList->vLeft, pBTList->vRight);
\r
2438 pb->pPatch->LODUpdated = true;
\r
2439 bAlreadyAdded = true;
\r
2444 // all rows of curves
\r
2445 for (row=1; row<pb->pPatch->height; row+=2)
\r
2447 if (pb->pPatch->rowDirty[(row-1)/2]) continue;
\r
2449 bAlreadyAdded = false;
\r
2451 for (col=0; col<pb->pPatch->width; col+=pb->pPatch->width-1)
\r
2453 if (bAlreadyAdded)
\r
2455 //if (BTree_IsInList(pBTList, pb->pPatch->colLOD[(((row-1)/2)*patch->width)+col]))
\r
2457 if (!VectorCompare (pb->pPatch->ctrl[col][row].xyz, pMid.xyz))
\r
2459 if (VectorCompare (pb->pPatch->ctrl[col][row].xyz, pb->pPatch->ctrl[col][row-1].xyz) || VectorCompare (pb->pPatch->ctrl[col][row].xyz, pb->pPatch->ctrl[col][row+1].xyz))
\r
2461 if (VectorCompare (pb->pPatch->ctrl[col][row-1].xyz, pLeft.xyz) && VectorCompare (pb->pPatch->ctrl[col][row+1].xyz, pRight.xyz))
\r
2463 pBTList = BTree_AddLinkToList(pBTList);
\r
2464 pBTList = Patch_CreateBTListForCols(pBTList, pb->pPatch, row, col);
\r
2465 pBTList = Patch_FindLODMatches(pb->pPatch, pBTList, pBTList->pBT->info, pBTList->vLeft, pBTList->vRight);
\r
2466 pb->pPatch->LODUpdated = true;
\r
2467 bAlreadyAdded = true;
\r
2469 else if (VectorCompare (pb->pPatch->ctrl[col][row-1].xyz, pRight.xyz) && VectorCompare (pb->pPatch->ctrl[col][row+1].xyz, pLeft.xyz))
\r
2471 pBTList = BTree_AddLinkToList(pBTList, true); // flip
\r
2472 pBTList = Patch_CreateBTListForCols(pBTList, pb->pPatch, row, col);
\r
2473 pBTList = Patch_FindLODMatches(pb->pPatch, pBTList, pBTList->pBT->info, pBTList->vLeft, pBTList->vRight);
\r
2474 pb->pPatch->LODUpdated = true;
\r
2475 bAlreadyAdded = true;
\r
2480 brushlist = &selected_brushes;
\r
2485 // take a pointer to a patch
\r
2486 // create tree roots for all the rows and columns of curves in the patch, the patch takes ownership of these new tree roots
\r
2487 // generate lists of pointers to all the trees in all the patches in the map which need to match the LOD of trees owned by this patch
\r
2488 // store all the lists in a list of lists
\r
2489 // recursively generate the rest of every tree in each list in the list
\r
2490 void Patch_CreateLODTrees(patchMesh_t *patch)
\r
2492 BTreeList_t *pBTList;
\r
2493 int col, row, pos;//, rowcount, colcount;
\r
2494 BTListList_t *pLists;
\r
2496 //Sys_Printf("Patch_CreateMatchedLODTrees: called\n");
\r
2498 BTListList_t *LODLists;
\r
2503 patch->bDirty = false;
\r
2504 patch->LODUpdated = true;
\r
2506 for(col=1; col<patch->width; col+=2)
\r
2508 if (patch->colDirty[(col-1)/2]) continue;
\r
2509 else patch->colDirty[(col-1)/2] = true;
\r
2511 // create list for rows of current patch
\r
2512 for(row=0; row<patch->height; row++)
\r
2514 pos = (((col-1)/2)*patch->height)+row;
\r
2515 patch->rowLOD[pos] = BTree_Delete(patch->rowLOD[pos]);
\r
2516 patch->rowLOD[pos] = BTree_Create(patch->ctrl[col][row]);
\r
2517 pBTList = BTree_AddToList(pBTList, patch->rowLOD[pos], patch->ctrl[col-1][row], patch->ctrl[col+1][row]);
\r
2520 //create connection list for first row
\r
2521 pBTList = Patch_FindLODMatches(patch, pBTList, patch->ctrl[col][0], patch->ctrl[col-1][0], patch->ctrl[col+1][0]);
\r
2522 //create connection list for last row
\r
2523 pBTList = Patch_FindLODMatches(patch, pBTList, patch->ctrl[col][row-1], patch->ctrl[col-1][row-1], patch->ctrl[col+1][row-1]);
\r
2525 LODLists = BTree_AddListToList(LODLists, pBTList);
\r
2530 for(row=1; row<patch->height; row+=2)
\r
2532 if (patch->rowDirty[(row-1)/2]) continue;
\r
2533 else patch->rowDirty[(row-1)/2] = true;
\r
2535 // create list for cols of current patch
\r
2536 for(col=0; col<patch->width; col++)
\r
2538 pos = (((row-1)/2)*patch->width)+col;
\r
2539 patch->colLOD[pos] = BTree_Delete(patch->colLOD[pos]);
\r
2540 patch->colLOD[pos] = BTree_Create(patch->ctrl[col][row]);
\r
2541 pBTList = BTree_AddToList(pBTList, patch->colLOD[pos], patch->ctrl[col][row-1], patch->ctrl[col][row+1]);
\r
2544 //create connection list for first col
\r
2545 pBTList = Patch_FindLODMatches(patch, pBTList, patch->ctrl[0][row], patch->ctrl[0][row-1], patch->ctrl[0][row+1]);
\r
2546 //create connection list for last col
\r
2547 pBTList = Patch_FindLODMatches(patch, pBTList, patch->ctrl[col-1][row], patch->ctrl[col-1][row-1], patch->ctrl[col-1][row+1]);
\r
2549 LODLists = BTree_AddListToList(LODLists, pBTList);
\r
2553 for (pLists = LODLists; pLists != NULL; pLists=pLists->next)
\r
2554 BTree_ListCurveRecurse(pLists->list);
\r
2555 LODLists = BTree_DeleteListFromList(LODLists);
\r
2558 int Patch_GetCVTangent(vec3_t &v1, vec3_t &p1, vec3_t &p2, vec3_t &p3)
\r
2560 if (VectorCompare(p1, p2))
\r
2562 if (VectorCompare(p1, p3))
\r
2566 else VectorSubtract(p3, p1, v1);
\r
2569 else VectorSubtract(p2, p1, v1);
\r
2573 void Patch_CVNormal(vec3_t ctrl[3][3], vec3_t &normal)
\r
2575 vec3_t v1, v2, vTemp1, vTemp2;
\r
2578 a = Patch_GetCVTangent(v1, ctrl[0][0], ctrl[1][0], ctrl[2][0]);
\r
2579 b = Patch_GetCVTangent(v2, ctrl[0][0], ctrl[0][1], ctrl[0][2]);
\r
2581 //Sys_Printf("p1: (%1.1f %1.1f %1.1f) p2: (%1.1f %1.1f %1.1f) p2: (%1.1f %1.1f %1.1f)\n",
\r
2582 // ctrl[0][0][0], ctrl[0][0][1], ctrl[0][0][2], ctrl[0][2][0], ctrl[0][2][1], ctrl[0][2][2], ctrl[2][0][0], ctrl[2][0][1], ctrl[2][0][2]);
\r
2586 a = Patch_GetCVTangent(v1, ctrl[0][0], ctrl[1][1], ctrl[1][2]);
\r
2590 b = Patch_GetCVTangent(v2, ctrl[0][0], ctrl[1][1], ctrl[2][1]);
\r
2595 a = Patch_GetCVTangent(v1, ctrl[0][0], ctrl[2][1], ctrl[2][2]);
\r
2599 b = Patch_GetCVTangent(v2, ctrl[0][0], ctrl[1][2], ctrl[2][2]);
\r
2602 CrossProduct(v1, v2, normal);
\r
2605 if (normal[0] == 0.0f && normal[1] == 0.0f && normal[2] == 0.0f)
\r
2607 // more degenerate cases
\r
2611 if (VectorCompare(ctrl[0][0], ctrl[2][0])) // endcap left
\r
2613 if (VectorCompare(ctrl[0][2], ctrl[1][2]))
\r
2615 VectorSubtract(ctrl[2][2], ctrl[0][0], v2);
\r
2617 else if (VectorCompare(ctrl[1][2], ctrl[2][2]))
\r
2619 VectorSubtract(ctrl[0][2], ctrl[0][0], v2);
\r
2622 a = Patch_DegenCurve(ctrl[0][2], ctrl[1][2], ctrl[2][2]);
\r
2625 VectorCopy(ctrl[0][2], vCurve[0]);
\r
2626 VectorCopy(ctrl[1][2], vCurve[1]);
\r
2627 VectorCopy(ctrl[2][2], vCurve[2]);
\r
2628 Patch_BezierInterpolate(vCurve, pMid);
\r
2629 VectorSubtract(pMid, ctrl[0][0], v1);
\r
2634 else if (VectorCompare(ctrl[0][0], ctrl[0][2])) // endcap right
\r
2637 if (VectorCompare(ctrl[2][0], ctrl[2][1]))
\r
2639 VectorSubtract(ctrl[2][2], ctrl[0][0], v2);
\r
2641 else if (VectorCompare(ctrl[2][1], ctrl[2][2]))
\r
2643 VectorSubtract(ctrl[2][0], ctrl[0][0], v2);
\r
2647 b = Patch_DegenCurve(ctrl[2][0], ctrl[2][1], ctrl[2][2]);
\r
2650 VectorCopy(ctrl[2][0], vCurve[0]);
\r
2651 VectorCopy(ctrl[2][1], vCurve[1]);
\r
2652 VectorCopy(ctrl[2][2], vCurve[2]);
\r
2653 Patch_BezierInterpolate(vCurve, pMid);
\r
2654 VectorSubtract(pMid, ctrl[0][0], v2);
\r
2659 if (VectorCompare(ctrl[0][0], ctrl[2][0])) // bottom degen
\r
2661 Patch_GetCVTangent(v1, ctrl[0][0], ctrl[2][1], ctrl[2][2]);
\r
2663 else if (VectorCompare(ctrl[0][0], ctrl[0][2])) // left degen
\r
2665 Patch_GetCVTangent(v2, ctrl[0][0], ctrl[1][2], ctrl[2][2]);
\r
2667 else if (VectorCompare(ctrl[0][2], ctrl[2][2])) // top degen
\r
2669 VectorSubtract(ctrl[2][0], ctrl[0][0], v1);
\r
2671 else if (VectorCompare(ctrl[2][0], ctrl[2][2])) // right degen
\r
2673 VectorSubtract(ctrl[0][2], ctrl[0][0], v2);
\r
2675 else // tangents parallel
\r
2677 VectorCopy(v1, vTemp1);
\r
2678 VectorCopy(v2, vTemp2);
\r
2679 VectorNormalize(vTemp1, vTemp1);
\r
2680 VectorNormalize(vTemp2, vTemp2);
\r
2681 if (VectorCompare(vTemp1, vTemp2)) // parallel same way
\r
2683 VectorSubtract(ctrl[2][0], ctrl[0][0], vTemp1);
\r
2684 VectorNormalize(vTemp1, vTemp1);
\r
2685 if (VectorCompare(vTemp1, vTemp2))
\r
2687 VectorSubtract(ctrl[0][2], ctrl[0][0], v2);
\r
2691 VectorCopy(vTemp1, v1);
\r
2694 else // parallel opposite way
\r
2696 VectorCopy(ctrl[2][0], vCurve[0]);
\r
2697 VectorCopy(ctrl[1][1], vCurve[1]);
\r
2698 VectorCopy(ctrl[0][2], vCurve[2]);
\r
2699 Patch_BezierInterpolate(vCurve, pMid);
\r
2700 VectorSubtract(pMid, ctrl[0][0], v2);
\r
2704 CrossProduct(v1, v2, normal);
\r
2708 void Patch_CalcCVNormals(patchMesh_t *patch)
\r
2710 int row, col, i, j, n;
\r
2711 vec3_t ctrl[3][3];
\r
2712 vec3_t normals[4];
\r
2714 for (col=0; col<patch->width; col+=2)
\r
2716 for (row=0; row<patch->height; row+=2)
\r
2719 if (col+1 != patch->width && row+1 != patch->height)
\r
2721 for (i=0; i<3; i++)
\r
2722 for (j=0; j<3; j++)
\r
2723 VectorCopy (patch->ctrl[col+i][row+j].xyz, ctrl[i][j]);
\r
2725 Patch_CVNormal(ctrl, normals[n]);
\r
2726 VectorNormalize(normals[n], normals[n]);
\r
2730 if (col-1 >= 0 && row-1 >= 0)
\r
2732 for (i=0; i<3; i++)
\r
2733 for (j=0; j<3; j++)
\r
2734 VectorCopy (patch->ctrl[col-i][row-j].xyz, ctrl[i][j]);
\r
2736 Patch_CVNormal(ctrl, normals[n]);
\r
2737 VectorNormalize(normals[n], normals[n]);
\r
2740 if (col-1 >= 0 && row+1 != patch->height)
\r
2742 for (i=0; i<3; i++)
\r
2743 for (j=0; j<3; j++)
\r
2744 VectorCopy (patch->ctrl[col-i][row+j].xyz, ctrl[j][i]);
\r
2746 Patch_CVNormal(ctrl, normals[n]);
\r
2747 VectorNormalize(normals[n], normals[n]);
\r
2750 if (col+1 != patch->width && row-1 >= 0)
\r
2752 for (i=0; i<3; i++)
\r
2753 for (j=0; j<3; j++)
\r
2754 VectorCopy (patch->ctrl[col+i][row-j].xyz, ctrl[j][i]);
\r
2756 Patch_CVNormal(ctrl, normals[n]);
\r
2757 VectorNormalize(normals[n], normals[n]);
\r
2761 for (i=0; i<3; i++)
\r
2763 if (n == 1) patch->ctrl[col][row].normal[i] = normals[0][i];
\r
2764 if (n == 2) patch->ctrl[col][row].normal[i] = (normals[0][i] + normals[1][i]) / n;
\r
2765 //if (n == 3) patch->ctrl[col][row].normal[i] = (normals[0][i] + normals[1][i] + normals[2][i]) / n;
\r
2766 if (n == 4) patch->ctrl[col][row].normal[i] = (normals[0][i] + normals[1][i] + normals[2][i] + normals[3][i]) / n;
\r
2768 VectorNormalize(patch->ctrl[col][row].normal, patch->ctrl[col][row].normal);
\r
2769 //if (!g_PrefsDlg.m_bGLLighting)
\r
2770 // ShadeVertex(patch->ctrl[col][row]);
\r
2776 void BTree_SetNormals(BTNode_t *pBT, vec3_t &normal)
\r
2780 if (pBT->left != NULL && pBT->right != NULL)
\r
2782 VectorCopy(normal, pBT->vMid.normal);
\r
2783 //if (!g_PrefsDlg.m_bGLLighting)
\r
2784 // ShadeVertex(pBT->vMid);
\r
2786 BTree_SetNormals(pBT->left, normal);
\r
2787 BTree_SetNormals(pBT->right, normal);
\r
2792 void NormalFromPoints(vec3_t p1, vec3_t p2, vec3_t p3, vec3_t &normal, bool flip = false)
\r
2798 VectorSubtract(p2, p3, v1); //p3->p2
\r
2799 VectorSubtract(p1, p2, v2); //p2->p1
\r
2803 VectorSubtract(p2, p1, v1); //p1->p2
\r
2804 VectorSubtract(p3, p2, v2); //p2->p3
\r
2806 CrossProduct(v1, v2, normal);
\r
2810 void BTree_GenerateNormals(BTNode_t *pBTMid, BTNode_t *pBTLeft, BTNode_t *pBTRight, bool avg, bool flat, bool nomid, bool noleft, bool noright, /*bool endcap, vec3_t &n1, vec3_t &n2,*/ bool flip)
\r
2812 if (pBTMid != NULL)
\r
2814 if (pBTMid->left != NULL && pBTMid->right != NULL)
\r
2818 if (noleft) // left curve is degenerate
\r
2820 if (nomid) // mid curve is degenerate
\r
2822 NormalFromPoints(pBTRight->right->info.xyz, pBTRight->vMid.xyz, pBTMid->vMid.xyz, normal, flip);
\r
2823 NormalFromPoints(pBTRight->right->info.xyz, pBTRight->vMid.xyz, pBTMid->vMid.xyz, pBTRight->vMid.normal, flip);
\r
2825 //else if (endcap)
\r
2827 // VectorCopy(n1, normal);
\r
2828 // NormalFromPoints(pBTRight->right->info.xyz, pBTRight->vMid.xyz, pBTMid->vMid.xyz, pBTRight->vMid.normal, flip);
\r
2832 NormalFromPoints(pBTMid->left->info.xyz, pBTLeft->vMid.xyz, pBTMid->vMid.xyz, normal, flip);
\r
2833 NormalFromPoints(pBTRight->right->info.xyz, pBTRight->vMid.xyz, pBTMid->vMid.xyz, pBTRight->vMid.normal, flip);
\r
2836 else if (noright) // right curve is degenerate
\r
2838 if (nomid) // mid curve is degenerate
\r
2840 NormalFromPoints(pBTLeft->left->info.xyz, pBTLeft->vMid.xyz, pBTMid->vMid.xyz, normal, flip);
\r
2841 NormalFromPoints(pBTLeft->left->info.xyz, pBTLeft->vMid.xyz, pBTMid->vMid.xyz, pBTRight->vMid.normal, flip);
\r
2843 //else if (endcap)
\r
2845 // NormalFromPoints(pBTLeft->left->info.xyz, pBTLeft->vMid.xyz, pBTMid->vMid.xyz, normal, flip);
\r
2846 // VectorCopy(n2, pBTRight->vMid.normal);
\r
2850 NormalFromPoints(pBTLeft->left->info.xyz, pBTLeft->vMid.xyz, pBTMid->vMid.xyz, normal, flip);
\r
2851 NormalFromPoints(pBTMid->right->info.xyz, pBTRight->vMid.xyz, pBTMid->vMid.xyz, pBTRight->vMid.normal, flip);
\r
2856 if (flat) // all curves are semi-degenerate (flat) or degenerate
\r
2858 NormalFromPoints(pBTLeft->left->info.xyz, pBTLeft->vMid.xyz, pBTRight->vMid.xyz, normal, flip);
\r
2859 NormalFromPoints(pBTRight->right->info.xyz, pBTRight->vMid.xyz, pBTLeft->vMid.xyz, pBTRight->vMid.normal, flip);
\r
2863 NormalFromPoints(pBTLeft->left->info.xyz, pBTLeft->vMid.xyz, pBTMid->vMid.xyz, normal, flip);
\r
2864 NormalFromPoints(pBTRight->right->info.xyz, pBTRight->vMid.xyz, pBTMid->vMid.xyz, pBTRight->vMid.normal, flip);
\r
2868 VectorNormalize(normal, normal);
\r
2870 for (int i=0; i<3; i++)
\r
2871 pBTLeft->vMid.normal[i] = (normal[i] + pBTLeft->vMid.normal[i]) / 2.0f;
\r
2872 else VectorCopy(normal, pBTLeft->vMid.normal);
\r
2874 VectorNormalize(pBTLeft->vMid.normal, pBTLeft->vMid.normal);
\r
2875 VectorNormalize(pBTRight->vMid.normal, pBTRight->vMid.normal);
\r
2878 BTree_GenerateNormals(pBTMid->left, pBTLeft->left, pBTRight->left, avg, flat, nomid, noleft, noright, /*endcap, n1, n2,*/ flip);
\r
2879 BTree_GenerateNormals(pBTMid->right, pBTLeft->right, pBTRight->right, avg, flat, nomid, noleft, noright, /*endcap, n1, n2,*/ flip);
\r
2885 void Patch_GenerateLODNormals(patchMesh_t *patch)
\r
2887 int col, row, rowpos, colpos, i;
\r
2888 BTNode_t *tree[2][3];
\r
2890 bool rowAvg, colAvg;
\r
2892 for(col=0; col+2<patch->width; col+=2)
\r
2894 for(row=0; row+2<patch->height; row+=2)
\r
2896 if (!patch->colDirty[col/2] && !patch->rowDirty[row/2]) continue;
\r
2898 rowpos = ((col/2)*patch->height)+row;
\r
2899 colpos = ((row/2)*patch->width)+col;
\r
2901 if (row==0) rowAvg = false;
\r
2902 else rowAvg = true;
\r
2903 if (col==0) colAvg = false;
\r
2904 else colAvg = true;
\r
2906 for (i=0; i<3; i++)
\r
2908 tree[0][i] = patch->rowLOD[rowpos+i];
\r
2909 tree[1][i] = patch->colLOD[colpos+i];
\r
2911 degen[0][i] = Patch_DegenCurve(patch->ctrl[col][row+i].xyz, patch->ctrl[col+1][row+i].xyz, patch->ctrl[col+2][row+i].xyz);
\r
2912 degen[1][i] = Patch_DegenCurve(patch->ctrl[col+i][row].xyz, patch->ctrl[col+i][row+1].xyz, patch->ctrl[col+i][row+2].xyz);
\r
2915 BTree_GenerateNormals(tree[0][1], tree[0][0], tree[0][2], rowAvg, (degen[1][0] && degen[1][1] && degen[1][2]), degen[0][1] == 2, degen[0][0] == 2, degen[0][2] == 2, /*degen[1][1], patch->ctrl[col][row].normal, patch->ctrl[col][row+2].normal,*/ false);
\r
2916 BTree_GenerateNormals(tree[1][1], tree[1][0], tree[1][2], colAvg, (degen[0][0] && degen[0][1] && degen[0][2]), degen[1][1] == 2, degen[1][0] == 2, degen[1][2] == 2, /*degen[0][1], patch->ctrl[col][row].normal, patch->ctrl[col+2][row].normal,*/ true);
\r
2922 void Patch_ClearLODFlags(patchMesh_t *p)
\r
2926 for (i=0;i<(p->width-1)/2; i++)
\r
2927 p->colDirty[i] = false;
\r
2929 for (i=0;i<(p->height-1)/2; i++)
\r
2930 p->rowDirty[i] = false;
\r
2933 // reset the lodDirty flags owned by all patches in the map
\r
2934 // create new LOD trees for all dirty patches, matched with all other patches in the map
\r
2935 void Patch_LODMatchAll()
\r
2937 brush_t *pb, *brushlist;
\r
2940 // create LOD tree roots and LOD tree lists for all patches that are dirty
\r
2942 brushlist = &active_brushes;
\r
2943 for (i=0; i<2; i++)
\r
2945 for (pb = brushlist->next; pb && (pb != brushlist); pb=pb->next)
\r
2947 // create lod for selected patches when patches are filtered
\r
2948 if (pb->bFiltered && (pb->patchBrush && !pb->pPatch->bSelected))
\r
2950 if (!pb->patchBrush)
\r
2952 if (!pb->pPatch->bDirty)
\r
2955 Patch_CalcCVNormals(pb->pPatch);
\r
2956 Patch_CreateLODTrees(pb->pPatch);
\r
2958 brushlist = &selected_brushes;
\r
2961 brushlist = &active_brushes;
\r
2962 for (i=0; i<2; i++)
\r
2964 for (pb = brushlist->next; pb && (pb != brushlist); pb=pb->next)
\r
2966 if (!pb->patchBrush)
\r
2969 if (pb->pPatch->LODUpdated)
\r
2970 Patch_GenerateLODNormals(pb->pPatch);
\r
2972 Patch_ClearLODFlags(pb->pPatch);
\r
2974 brushlist = &selected_brushes;
\r
2979 void Vertex_TransformTexture(drawVert_t *pVert, float fx, float fy, transformtype xform)
\r
2984 pVert->st[0] += fx;
\r
2985 pVert->st[1] += fy;
\r
2988 pVert->st[0] *= fx;
\r
2989 pVert->st[1] *= fy;
\r
2992 float x = pVert->st[0];
\r
2993 float y = pVert->st[1];
\r
2994 pVert->st[0] = x * fx - y * fy;
\r
2995 pVert->st[1] = y * fx + x * fy;
\r
2999 void BTree_TransformTexture(BTNode_t *pBT, float fx, float fy, transformtype xform)
\r
3002 { // PreOrder traversal
\r
3003 Vertex_TransformTexture(&pBT->info, fx, fy, xform);
\r
3004 Vertex_TransformTexture(&pBT->vMid, fx, fy, xform);
\r
3005 BTree_TransformTexture(pBT->left, fx, fy, xform);
\r
3006 BTree_TransformTexture(pBT->right, fx, fy, xform);
\r
3010 void Patch_TransformLODTexture(patchMesh_t *p, float fx, float fy, transformtype xform)
\r
3014 for(col=1; col<p->width; col+=2)
\r
3015 for(row=0; row<p->height; row++)
\r
3016 BTree_TransformTexture(p->rowLOD[(((col-1)/2)*p->height)+row], fx, fy, xform);
\r
3018 for(row=1; row<p->height; row+=2)
\r
3019 for(col=0; col<p->width; col++)
\r
3020 BTree_TransformTexture(p->colLOD[(((row-1)/2)*p->width)+col], fx, fy, xform);
\r
3023 void Patch_AddBTreeToDrawListInOrder(list<drawVert_t> *drawList, BTNode_t *pBT)
\r
3025 if (pBT != NULL) //traverse InOrder
\r
3027 Patch_AddBTreeToDrawListInOrder(drawList, pBT->left);
\r
3028 if (pBT->left != NULL && pBT->right != NULL)
\r
3029 drawList->push_back(pBT->vMid);
\r
3030 Patch_AddBTreeToDrawListInOrder(drawList, pBT->right);
\r
3034 void Patch_InterpolateListFromRowBT(list<drawVert_t> *drawList, BTNode_t *rowBT, BTNode_t *rowBTLeft, drawVert_t *vCurve[], float u, float n, float v)
\r
3036 if (rowBT != NULL)
\r
3038 Patch_InterpolateListFromRowBT(drawList, rowBT->left, rowBTLeft->left, vCurve, u-n, n*0.5f, v);
\r
3039 if (rowBT->left != NULL && rowBT->right != NULL)
\r
3042 drawVert_t newVert, vTemp1, vTemp2;
\r
3043 Patch_CurveSplit(vCurve, vTemp1, vTemp2, newVert, u);
\r
3044 for (int i=0; i<3; i++)
\r
3046 v1[i] = rowBT->vMid.xyz[i] - rowBTLeft->vMid.xyz[i]; // left -> mid
\r
3047 v1[i] = rowBTLeft->vMid.xyz[i] + (v1[i] * v);
\r
3048 v1[i] = newVert.xyz[i] - v1[i];
\r
3050 VectorSubtract(vTemp1.xyz, newVert.xyz, v2);
\r
3051 CrossProduct(v1, v2, newVert.normal);
\r
3052 VectorNormalize(newVert.normal, newVert.normal);
\r
3053 //if (!g_PrefsDlg.m_bGLLighting)
\r
3054 // ShadeVertex(newVert);
\r
3055 drawList->push_back(newVert);
\r
3057 Patch_InterpolateListFromRowBT(drawList, rowBT->right, rowBTLeft->right, vCurve, u+n, n*0.5f, v);
\r
3061 void Patch_TraverseColBTInOrder(list<list<drawVert_t>*>::iterator& iter, BTNode_t *colBTLeft, BTNode_t *colBT, BTNode_t *colBTRight, BTNode_t *rowBT, BTNode_t *rowBTLeft, float v, float n)
\r
3063 if (colBT != NULL)
\r
3065 //traverse subtree In Order
\r
3066 Patch_TraverseColBTInOrder(iter, colBTLeft->left, colBT->left, colBTRight->left, rowBT, rowBTLeft, v-n, n*0.5f);
\r
3067 if (colBT->left != NULL && colBT->right != NULL)
\r
3069 drawVert_t *vCurve[3];
\r
3070 vCurve[0] = &colBTLeft->vMid;
\r
3071 vCurve[1] = &colBT->vMid;
\r
3072 vCurve[2] = &colBTRight->vMid;
\r
3073 Patch_InterpolateListFromRowBT((*iter), rowBT, rowBTLeft, vCurve, 0.5f, 0.25f, v);
\r
3075 (*iter)->push_back(colBTRight->vMid);
\r
3078 Patch_TraverseColBTInOrder(iter, colBTLeft->right, colBT->right, colBTRight->right, rowBT, rowBTLeft, v+n, n*0.5f);
\r
3083 void Patch_StartDrawLists(list<list<drawVert_t>*> *drawLists, BTNode_t *colBT)
\r
3085 if (colBT != NULL)
\r
3087 //traverse subtree In Order
\r
3088 Patch_StartDrawLists(drawLists, colBT->left);
\r
3089 if (colBT->left != NULL && colBT->right != NULL)
\r
3091 list<drawVert_t> *newList = new list<drawVert_t>;
\r
3092 drawLists->push_back(newList); // add empty list to back
\r
3093 drawLists->back()->push_back(colBT->vMid);
\r
3095 Patch_StartDrawLists(drawLists, colBT->right);
\r
3099 typedef list<drawVert_t> drawList_t;
\r
3100 typedef list<list<drawVert_t>*> drawLists_t;
\r
3102 void Patch_CreateDrawLists(patchMesh_t *patch)
\r
3104 int col, row, colpos, rowpos;
\r
3106 drawLists_t *drawLists = new drawLists_t;
\r
3108 drawLists_t::iterator iter1, iter2;
\r
3110 for (row=0; row<patch->height; row+=2)
\r
3112 colpos = (row/2)*patch->width;
\r
3113 drawList_t *newList = new drawList_t;
\r
3114 drawLists->push_back(newList); // add a new empty list to back
\r
3115 drawLists->back()->push_back(patch->ctrl[0][row]); // fill list at back
\r
3117 if (row+1 == patch->height)
\r
3119 Patch_StartDrawLists(drawLists, patch->colLOD[colpos]);
\r
3122 iter1 = drawLists->begin();
\r
3123 for (row=0; row<patch->height; row+=2)
\r
3126 for (col=0; col+1<patch->width; col+=2)
\r
3129 colpos = ((row/2)*patch->width)+col;
\r
3130 rowpos = ((col/2)*patch->height)+row;
\r
3132 Patch_AddBTreeToDrawListInOrder((*iter1), patch->rowLOD[rowpos]);
\r
3133 (*iter1)->push_back(patch->ctrl[col+2][row]);
\r
3135 if (row+1 == patch->height)
\r
3140 Patch_TraverseColBTInOrder(iter1, patch->colLOD[colpos], patch->colLOD[colpos+1], patch->colLOD[colpos+2], patch->rowLOD[rowpos+1], patch->rowLOD[rowpos], 0.5, 0.25);
\r
3144 patch->drawLists = drawLists;
\r
3148 void Patch_DeleteDrawLists(patchMesh_t *patch)
\r
3150 drawLists_t *drawLists;
\r
3151 drawLists_t::iterator iter;
\r
3153 if (patch->drawLists == NULL)
\r
3156 drawLists = (drawLists_t *)patch->drawLists;
\r
3158 for (iter=drawLists->begin(); iter != drawLists->end(); iter++)
\r
3164 patch->drawLists = NULL;
\r
3168 void Patch_DrawLODPatchMesh(patchMesh_t *patch)
\r
3170 drawLists_t *drawLists;
\r
3172 drawLists_t::iterator iterLists, iterListsNext;
\r
3173 drawList_t::iterator iterList, iterListNext;
\r
3175 //int nGLState = g_pParentWnd->GetCamera()->Camera()->draw_glstate;
\r
3177 if (patch->drawLists == NULL)
\r
3180 drawLists = (drawLists_t *)patch->drawLists;
\r
3182 iterListsNext=drawLists->begin();
\r
3184 for (iterLists=drawLists->begin(); iterLists != drawLists->end() && iterListsNext != drawLists->end(); iterLists++, iterListsNext++)
\r
3186 // traverse two drawlists at once to draw a strip
\r
3187 //if (nGLState & DRAW_GL_LINE)
\r
3188 qglBegin(GL_QUAD_STRIP);
\r
3190 // qglBegin(GL_TRIANGLE_STRIP);
\r
3191 for (iterList=(*iterLists)->begin(), iterListNext=(*iterListsNext)->begin(); iterList != (*iterLists)->end() && iterListNext != (*iterListsNext)->end(); iterList++, iterListNext++)
\r
3193 //if (g_PrefsDlg.m_bGLLighting)
\r
3194 qglNormal3fv((*iterList).normal);
\r
3195 //else if (bShade && !g_PrefsDlg.m_bDisplayLists)
\r
3196 // qglColor3f((*iterList).lightmap[0], (*iterList).lightmap[0], (*iterList).lightmap[0]);
\r
3198 qglTexCoord2fv((*iterList).st);
\r
3199 qglVertex3fv((*iterList).xyz);
\r
3201 //if (g_PrefsDlg.m_bGLLighting)
\r
3202 qglNormal3fv((*iterListNext).normal);
\r
3203 //else if (bShade && !g_PrefsDlg.m_bDisplayLists)
\r
3204 // qglColor3f((*iterListNext).lightmap[0], (*iterListNext).lightmap[0], (*iterListNext).lightmap[0]);
\r
3206 qglTexCoord2fv((*iterListNext).st);
\r
3207 qglVertex3fv((*iterListNext).xyz);
\r
3214 for (iterLists=drawLists->begin(); iterLists != drawLists->end(); iterLists++)
\r
3216 qglBegin (GL_LINES); // draw normals
\r
3217 //qglColor3f(1,1,1);
\r
3218 for (iterList=(*iterLists)->begin(); iterList != (*iterLists)->end(); iterList++)
\r
3220 VectorAdd((*iterList).xyz, (*iterList).normal, vNormal);
\r
3221 qglVertex3fv ((*iterList).xyz);
\r
3222 qglVertex3fv (vNormal);
\r
3227 Patch_DrawNormals(patch);
\r
3234 // fast memory-efficient ray-triangle intersection - MollerTrumbore97
\r
3236 #define EPSILON 0.000001
\r
3237 #define CROSS(dest,v1,v2) {dest[0]=v1[1]*v2[2]-v1[2]*v2[1];dest[1]=v1[2]*v2[0]-v1[0]*v2[2];dest[2]=v1[0]*v2[1]-v1[1]*v2[0];}
\r
3238 #define DOT(v1,v2) (v1[0]*v2[0]+v1[1]*v2[1]+v1[2]*v2[2])
\r
3239 #define SUB(dest,v1,v2) {dest[0]=v1[0]-v2[0];dest[1]=v1[1]-v2[1];dest[2]=v1[2]-v2[2];}
\r
3241 int intersect_triangle(float orig[3], float dir[3],
\r
3242 float vert0[3], float vert1[3], float vert2[3],
\r
3243 double *t, double *u, double *v)
\r
3245 double edge1[3], edge2[3], tvec[3], pvec[3], qvec[3];
\r
3246 double det,inv_det;
\r
3248 // find vectors for two edges sharing vert0
\r
3249 SUB(edge1, vert1, vert0);
\r
3250 SUB(edge2, vert2, vert0);
\r
3252 // begin calculating determinant - also used to calculate U parameter
\r
3253 CROSS(pvec, dir, edge2);
\r
3255 // if determinant is near zero, ray lies in plane of triangle
\r
3256 det = DOT(edge1, pvec);
\r
3258 #ifdef TEST_CULL // define TEST_CULL if culling is desired
\r
3259 if (det < EPSILON)
\r
3262 // calculate distance from vert0 to ray origin
\r
3263 SUB(tvec, orig, vert0);
\r
3265 // calculate U parameter and test bounds
\r
3266 *u = DOT(tvec, pvec);
\r
3267 if (*u < 0.0 || *u > det)
\r
3270 // prepare to test V parameter
\r
3271 CROSS(qvec, tvec, edge1);
\r
3273 // calculate V parameter and test bounds
\r
3274 *v = DOT(dir, qvec);
\r
3275 if (*v < 0.0 || *u + *v > det)
\r
3278 // calculate t, scale parameters, ray intersects triangle
\r
3279 *t = DOT(edge2, qvec);
\r
3280 inv_det = 1.0 / det;
\r
3284 #else // the non-culling branch
\r
3285 if (det > -EPSILON && det < EPSILON)
\r
3287 inv_det = 1.0 / det;
\r
3289 // calculate distance from vert0 to ray origin
\r
3290 SUB(tvec, orig, vert0);
\r
3292 // calculate U parameter and test bounds
\r
3293 *u = DOT(tvec, pvec) * inv_det;
\r
3294 if (*u < 0.0 || *u > 1.0)
\r
3297 // prepare to test V parameter
\r
3298 CROSS(qvec, tvec, edge1);
\r
3300 // calculate V parameter and test bounds
\r
3301 *v = DOT(dir, qvec) * inv_det;
\r
3302 if (*v < 0.0 || *u + *v > 1.0)
\r
3305 // calculate t, ray intersects triangle
\r
3306 *t = DOT(edge2, qvec) * inv_det;
\r
3312 int Triangle_Ray(float orig[3], float dir[3], bool bCullBack,
\r
3313 float vert0[3], float vert1[3], float vert2[3],
\r
3314 double *t, double *u, double *v)
\r
3316 float edge1[3], edge2[3], tvec[3], pvec[3], qvec[3];
\r
3317 double det,inv_det;
\r
3319 /* find vectors for two edges sharing vert0 */
\r
3320 VectorSubtract(vert1, vert0, edge1);
\r
3321 VectorSubtract(vert2, vert0, edge2);
\r
3323 /* begin calculating determinant - also used to calculate U parameter */
\r
3324 CrossProduct(dir, edge2, pvec);
\r
3326 /* if determinant is near zero, ray lies in plane of triangle */
\r
3327 det = DotProduct(edge1, pvec);
\r
3331 if (det < 0.000001)
\r
3334 // calculate distance from vert0 to ray origin
\r
3335 VectorSubtract(orig, vert0, tvec);
\r
3337 // calculate U parameter and test bounds
\r
3338 *u = DotProduct(tvec, pvec);
\r
3339 if (*u < 0.0 || *u > det)
\r
3342 // prepare to test V parameter
\r
3343 CrossProduct(tvec, edge1, qvec);
\r
3345 // calculate V parameter and test bounds
\r
3346 *v = DotProduct(dir, qvec);
\r
3347 if (*v < 0.0 || *u + *v > det)
\r
3350 // calculate t, scale parameters, ray intersects triangle
\r
3351 *t = DotProduct(edge2, qvec);
\r
3352 inv_det = 1.0 / det;
\r
3359 /* the non-culling branch */
\r
3360 if (det > -0.000001 && det < 0.000001)
\r
3362 inv_det = 1.0 / det;
\r
3364 /* calculate distance from vert0 to ray origin */
\r
3365 VectorSubtract(orig, vert0, tvec);
\r
3367 /* calculate U parameter and test bounds */
\r
3368 *u = DotProduct(tvec, pvec) * inv_det;
\r
3369 if (*u < 0.0 || *u > 1.0)
\r
3372 /* prepare to test V parameter */
\r
3373 CrossProduct(tvec, edge1, qvec);
\r
3375 /* calculate V parameter and test bounds */
\r
3376 *v = DotProduct(dir, qvec) * inv_det;
\r
3377 if (*v < 0.0 || *u + *v > 1.0)
\r
3380 /* calculate t, ray intersects triangle */
\r
3381 *t = DotProduct(edge2, qvec) * inv_det;
\r
3386 bool Patch_Ray(patchMesh_t *patch, vec3_t origin, vec3_t dir, double *t, double *u, double *v)
\r
3388 drawLists_t *drawLists;
\r
3390 drawLists_t::iterator iterLists, iterListsNext;
\r
3391 drawList_t::iterator i1, i2, i3, i4;
\r
3393 // vec3_t tris[2][3];
\r
3394 bool bIntersect = false;
\r
3395 float tBest = FLT_MAX;
\r
3397 if (patch->drawLists == NULL)
\r
3400 drawLists = (drawLists_t *)patch->drawLists;
\r
3402 iterListsNext=drawLists->begin();
\r
3404 for (iterLists=drawLists->begin(); iterLists != drawLists->end() && iterListsNext != drawLists->end(); iterLists++, iterListsNext++)
\r
3406 // traverse two drawlists at once with two iterators each to triangulate
\r
3407 i1 = i3 = (*iterLists)->begin();
\r
3408 i2 = i4 = (*iterListsNext)->begin();
\r
3411 while (i3 != (*iterLists)->end() && i4 != (*iterListsNext)->end())
\r
3413 if (Triangle_Ray(origin, dir, false, (*i1).xyz, (*i2).xyz, (*i3).xyz, t, u, v))
\r
3415 bIntersect = true;
\r
3419 if (Triangle_Ray(origin, dir, false, (*i3).xyz, (*i4).xyz, (*i2).xyz, t, u, v))
\r
3421 bIntersect = true;
\r
3443 // spog - curve LOD stuff ends
\r
3450 void DrawPatchMesh(patchMesh_t *pm)
\r
3452 if (g_PrefsDlg.m_bDisplayLists)
\r
3454 if (pm->bDirty || pm->nListID <= 0 || pm->LODUpdated)
\r
3456 if (pm->nListID <= 0)
\r
3457 pm->nListID = qglGenLists(1);
\r
3458 if (pm->nListID > 0)
\r
3460 qglNewList(pm->nListID, GL_COMPILE_AND_EXECUTE);
\r
3463 Patch_DeleteDrawLists(pm);
\r
3464 Patch_CreateDrawLists(pm);
\r
3466 Patch_DrawLODPatchMesh(pm);
\r
3468 if (pm->nListID > 0)
\r
3473 pm->bDirty = false;
\r
3474 pm->LODUpdated = false;
\r
3478 qglCallList(pm->nListID);
\r
3483 if (pm->bDirty || pm->LODUpdated)
\r
3485 Patch_DeleteDrawLists(pm);
\r
3486 Patch_CreateDrawLists(pm);
\r
3487 pm->bDirty = false;
\r
3488 pm->LODUpdated = false;
\r
3490 Patch_DrawLODPatchMesh(pm);
\r
3499 void DrawPatchControls(patchMesh_t *pm)
\r
3502 bool bSelectedPoints[MAX_PATCH_WIDTH][MAX_PATCH_HEIGHT];
\r
3504 bool bOverlay = pm->bOverlay;
\r
3507 if (g_bPatchBendMode)
\r
3510 if (g_bPatchAxisOnRow)
\r
3512 qglColor3f(1, 0, 1);
\r
3513 if(!g_PrefsDlg.m_bGlPtWorkaround)
\r
3515 qglBegin(GL_POINTS);
\r
3516 for (i = 0; i < pm->width; i++)
\r
3518 qglVertex3fv(pm->ctrl[i][g_nPatchAxisIndex].xyz);
\r
3524 qglLineWidth(2.0);
\r
3525 qglBegin(GL_LINES);
\r
3526 for(i = 0; i < pm->width; i++)
\r
3528 DrawAlternatePoint(pm->ctrl[i][g_nPatchAxisIndex].xyz, 0);
\r
3531 qglLineWidth(1.0);
\r
3534 if (g_nPatchBendState == BEND_SELECT_EDGE || g_nPatchBendState == BEND_BENDIT || g_nPatchBendState == BEND_SELECT_ORIGIN)
\r
3536 if(!g_PrefsDlg.m_bGlPtWorkaround)
\r
3538 qglColor3f(0, 0, 1);
\r
3539 qglBegin(GL_POINTS);
\r
3540 if (g_nPatchBendState == BEND_SELECT_ORIGIN)
\r
3542 qglVertex3fv(g_vBendOrigin);
\r
3546 for (i = 0; i < pm->width; i++)
\r
3548 if (g_bPatchLowerEdge)
\r
3550 for (j = 0; j < g_nPatchAxisIndex; j++)
\r
3551 qglVertex3fv(pm->ctrl[i][j].xyz);
\r
3555 for (j = pm->height-1; j > g_nPatchAxisIndex; j--)
\r
3556 qglVertex3fv(pm->ctrl[i][j].xyz);
\r
3563 qglColor3f(0, 0, 1);
\r
3564 qglLineWidth(2.0);
\r
3565 qglBegin(GL_LINES);
\r
3566 if(g_nPatchBendState == BEND_SELECT_ORIGIN)
\r
3568 DrawAlternatePoint(g_vBendOrigin, 0);
\r
3572 for(i = 0; i < pm->width; i++)
\r
3574 if(g_bPatchLowerEdge)
\r
3576 for(j = 0; j < g_nPatchAxisIndex; j++)
\r
3578 DrawAlternatePoint(pm->ctrl[i][j].xyz, 0);
\r
3583 for (j = pm->height-1; j > g_nPatchAxisIndex; j--)
\r
3585 DrawAlternatePoint(pm->ctrl[i][j].xyz, 0);
\r
3591 qglLineWidth(1.0);
\r
3597 if(!g_PrefsDlg.m_bGlPtWorkaround)
\r
3599 qglColor3f(1, 0, 1);
\r
3600 qglBegin(GL_POINTS);
\r
3601 for (i = 0; i < pm->height; i++)
\r
3603 qglVertex3fv(pm->ctrl[g_nPatchAxisIndex][i].xyz);
\r
3608 qglColor3f(1, 0, 1);
\r
3609 qglLineWidth(2.0);
\r
3610 qglBegin(GL_LINES);
\r
3611 for(i = 0; i < pm->height; i++)
\r
3613 DrawAlternatePoint(pm->ctrl[g_nPatchAxisIndex][i].xyz, 0);
\r
3616 qglLineWidth(1.0);
\r
3619 if (g_nPatchBendState == BEND_SELECT_EDGE || g_nPatchBendState == BEND_BENDIT || g_nPatchBendState == BEND_SELECT_ORIGIN)
\r
3621 if(!g_PrefsDlg.m_bGlPtWorkaround)
\r
3623 qglColor3f(0, 0, 1);
\r
3624 qglBegin(GL_POINTS);
\r
3625 for (i = 0; i < pm->height; i++)
\r
3627 if (g_nPatchBendState == BEND_SELECT_ORIGIN)
\r
3629 qglVertex3fv(pm->ctrl[g_nBendOriginIndex][i].xyz);
\r
3633 if (g_bPatchLowerEdge)
\r
3635 for (j = 0; j < g_nPatchAxisIndex; j++)
\r
3636 qglVertex3fv(pm->ctrl[j][i].xyz);
\r
3640 for (j = pm->width-1; j > g_nPatchAxisIndex; j--)
\r
3641 qglVertex3fv(pm->ctrl[j][i].xyz);
\r
3648 qglColor3f(0, 0, 1);
\r
3649 qglLineWidth(2.0);
\r
3650 qglBegin(GL_LINES);
\r
3651 for(i = 0; i < pm->height; i++)
\r
3653 if(g_nPatchBendState == BEND_SELECT_ORIGIN)
\r
3655 DrawAlternatePoint(pm->ctrl[g_nBendOriginIndex][i].xyz, 0);
\r
3659 if(g_bPatchLowerEdge)
\r
3661 for(j = 0; j < g_nPatchAxisIndex; j++)
\r
3663 DrawAlternatePoint(pm->ctrl[j][i].xyz, 0);
\r
3668 for(j = pm->width-1; j > g_nPatchAxisIndex; j--)
\r
3670 DrawAlternatePoint(pm->ctrl[j][i].xyz, 0);
\r
3676 qglLineWidth(1.0);
\r
3683 //qglDisable(GL_TEXTURE_2D); // stops point colours being multiplied by texture colour..
\r
3684 //draw CV lattice - could be made optional
\r
3685 //qglDisable( GL_CULL_FACE );
\r
3686 // qglPolygonMode (GL_FRONT_AND_BACK, GL_LINE);
\r
3687 qglEnable (GL_POLYGON_OFFSET_LINE);
\r
3688 if (g_PrefsDlg.m_bNoStipple == FALSE)
\r
3689 qglDisable (GL_LINE_STIPPLE);
\r
3691 qglColor3f(1.0f, 0.75f, 0.0f);
\r
3692 for ( i = 0 ; i+1 < pm->width ; i++ )
\r
3694 qglBegin(GL_QUAD_STRIP);
\r
3695 for ( j = 0 ; j < pm->height ; j++ )
\r
3697 qglVertex3fv(pm->ctrl[i][j].xyz);
\r
3698 qglVertex3fv(pm->ctrl[i+1][j].xyz);
\r
3702 qglDisable (GL_POLYGON_OFFSET_LINE);
\r
3703 //if (g_PrefsDlg.m_bNoStipple == FALSE)
\r
3704 // qglEnable (GL_LINE_STIPPLE);
\r
3706 // draw selection handles
\r
3707 if(!g_PrefsDlg.m_bGlPtWorkaround)
\r
3710 qglBegin(GL_POINTS);
\r
3711 for ( i = 0 ; i < pm->width ; i++ )
\r
3713 for ( j = 0 ; j < pm->height ; j++ )
\r
3715 if (PointInMoveList(pm->ctrl[i][j].xyz) != -1)
\r
3717 bSelectedPoints[i][j] = true;
\r
3721 bSelectedPoints[i][j] = false;
\r
3722 if (i & 0x01 || j & 0x01)
\r
3723 qglColor3f(1, 0, 1);
\r
3725 qglColor3f(0, 1, 0);
\r
3727 qglVertex3fv(pm->ctrl[i][j].xyz);
\r
3731 qglColor3f(0, 0, 1);
\r
3732 for ( i = 0 ; i < pm->width ; i++ )
\r
3734 for ( j = 0 ; j < pm->height ; j++ )
\r
3736 if (bSelectedPoints[i][j])
\r
3737 qglVertex3fv(pm->ctrl[i][j].xyz);
\r
3744 qglLineWidth(2.0);
\r
3745 qglBegin(GL_LINES);
\r
3746 for(i = 0; i < pm->width; i++)
\r
3748 for(j = 0; j < pm->height; j++)
\r
3750 if(PointInMoveList(pm->ctrl[i][j].xyz) != -1)
\r
3752 bSelectedPoints[i][j] = true;
\r
3756 bSelectedPoints[i][j] = false;
\r
3757 if(i & 0x01 || j & 0x01)
\r
3758 qglColor3f(1, 0, 1);
\r
3760 qglColor3f(0, 1, 0);
\r
3763 DrawAlternatePoint(pm->ctrl[i][j].xyz, 0);
\r
3767 qglColor3f(0, 0, 1);
\r
3768 for(i = 0; i < pm->width; i++)
\r
3770 for(j = 0; j < pm->height; j++)
\r
3772 if(bSelectedPoints[i][j])
\r
3775 DrawAlternatePoint(pm->ctrl[i][j].xyz, 0);
\r
3780 qglLineWidth(1.0);
\r
3785 if(!g_PrefsDlg.m_bGlPtWorkaround)
\r
3788 qglBegin(GL_POINTS);
\r
3789 for ( i = 0 ; i < pm->width ; i++ )
\r
3791 for ( j = 0 ; j < pm->height ; j++ )
\r
3793 if (i & 0x01 || j & 0x01)
\r
3794 qglColor3f(1, 0, 1);
\r
3796 qglColor3f(0, 1, 0);
\r
3797 qglVertex3fv(pm->ctrl[i][j].xyz);
\r
3804 qglLineWidth(2.0);
\r
3805 qglBegin(GL_LINES);
\r
3806 for ( i = 0 ; i < pm->width ; i++ )
\r
3808 for ( j = 0 ; j < pm->height ; j++ )
\r
3810 if (i & 0x01 || j & 0x01)
\r
3811 qglColor3f(1, 0, 1);
\r
3813 qglColor3f(0, 1, 0);
\r
3815 DrawAlternatePoint(pm->ctrl[i][j].xyz, 0);
\r
3819 qglLineWidth(1.0);
\r
3826 ==================
\r
3828 ==================
\r
3830 void Patch_DrawXY(patchMesh_t *pm)
\r
3832 qglPolygonMode (GL_FRONT_AND_BACK, GL_LINE);
\r
3834 if (pm->bSelected)
\r
3836 qglColor3fv(g_qeglobals.d_savedinfo.colors[COLOR_SELBRUSHES]);
\r
3837 if (g_PrefsDlg.m_bNoStipple == FALSE)
\r
3838 qglEnable (GL_LINE_STIPPLE);
\r
3842 DrawPatchMesh(pm);
\r
3844 if ( (pm->bSelected && (g_qeglobals.d_select_mode == sel_curvepoint
\r
3845 || g_qeglobals.d_select_mode == sel_area
\r
3846 || g_bPatchBendMode))
\r
3848 DrawPatchControls(pm);
\r
3852 ==================
\r
3854 ==================
\r
3856 void Patch_DrawCam(patchMesh_t *pm)
\r
3858 qglPushAttrib(GL_ALL_ATTRIB_BITS); // save the current state
\r
3860 if (g_bPatchWireFrame)
\r
3862 qglDisable( GL_CULL_FACE );
\r
3863 qglPolygonMode (GL_FRONT_AND_BACK, GL_LINE);
\r
3864 qglDisable(GL_TEXTURE_2D);
\r
3865 if (g_PrefsDlg.m_bGLLighting)
\r
3866 qglDisable(GL_LIGHTING);
\r
3868 DrawPatchMesh(pm);
\r
3870 //if (g_PrefsDlg.m_bGLLighting)
\r
3871 // qglEnable(GL_LIGHTING);
\r
3872 //qglEnable( GL_CULL_FACE );
\r
3876 qglDisable(GL_CULL_FACE);
\r
3877 qglBindTexture (GL_TEXTURE_2D, pm->d_texture->texture_number);
\r
3878 qglPolygonMode (GL_FRONT, GL_FILL);
\r
3879 qglPolygonMode (GL_BACK, GL_LINE);
\r
3881 if (pm->pShader->getTrans() < 1.0f)
\r
3883 qglEnable(GL_BLEND);
\r
3884 qglBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
\r
3885 qglColor4f(pm->d_texture->color[0], pm->d_texture->color[1], pm->d_texture->color[2], pm->pShader->getTrans());
\r
3888 DrawPatchMesh(pm); // both sides
\r
3891 qglPopAttrib(); // restore saved state
\r
3894 void ConvexHullForSection( float section[2][4][7] ) {
\r
3897 void BrushesForSection( float section[2][4][7] ) {
\r
3905 void Patch_BuildPoints (brush_t *b)
\r
3908 b->patchBrush = false;
\r
3909 for (f=b->brush_faces ; f ; f=f->next)
\r
3911 if (f->texdef.flags & SURF_PATCH)
\r
3913 b->patchBrush = true;
\r
3914 //vec3_t vMin, vMax;
\r
3915 //Patch_CalcBounds(&patchMeshes[b->nPatchID], vMin, vMax);
\r
3916 //VectorCopy(vMin, b->mins);
\r
3917 //VectorCopy(vMax, b->maxs);
\r
3924 ==================
\r
3926 ==================
\r
3928 void Patch_Move(patchMesh_t *pm, const vec3_t vMove, bool bRebuild)
\r
3930 pm->bDirty = true;
\r
3931 for (int w = 0; w < pm->width; w++)
\r
3933 for (int h = 0; h < pm->height; h++)
\r
3935 VectorAdd(pm->ctrl[w][h].xyz, vMove, pm->ctrl[w][h].xyz);
\r
3938 // bRebuild is never true
\r
3941 vec3_t vMin, vMax;
\r
3942 Patch_CalcBounds(pm, vMin, vMax);
\r
3943 //Brush_RebuildBrush(patchMeshes[n].pSymbiot, vMin, vMax);
\r
3945 UpdatePatchInspector();
\r
3950 ==================
\r
3952 ==================
\r
3954 void Patch_ApplyMatrix(patchMesh_t *p, const vec3_t vOrigin, const vec3_t vMatrix[3], bool bSnap)
\r
3958 for (int w = 0; w < p->width; w++)
\r
3960 for (int h = 0; h < p->height; h++)
\r
3962 if (((g_qeglobals.d_select_mode == sel_curvepoint && g_qeglobals.d_num_move_points != 0) || g_bPatchBendMode)
\r
3963 && PointInMoveList(p->ctrl[w][h].xyz) == -1) // snap selected points only, if selected
\r
3965 VectorSubtract (p->ctrl[w][h].xyz, vOrigin, vTemp);
\r
3966 for (int j = 0; j < 3; j++)
\r
3968 p->ctrl[w][h].xyz[j] = DotProduct(vTemp, vMatrix[j]) + vOrigin[j];
\r
3971 p->ctrl[w][h].xyz[j] = floor(p->ctrl[w][h].xyz[j] + 0.5);
\r
3976 vec3_t vMin, vMax;
\r
3977 Patch_CalcBounds(p, vMin, vMax);
\r
3978 Brush_RebuildBrush(p->pSymbiot, vMin, vMax);
\r
3982 ==================
\r
3984 ==================
\r
3986 void Patch_EditPatch()
\r
3988 //--patchMesh_t* p = &patchMeshes[n];
\r
3989 g_qeglobals.d_numpoints = 0;
\r
3990 g_qeglobals.d_num_move_points = 0;
\r
3992 for (brush_t *pb = selected_brushes.next ; pb != &selected_brushes ; pb = pb->next)
\r
3994 if (pb->patchBrush)
\r
3996 patchMesh_t* p = pb->pPatch;
\r
3997 for ( int i = 0 ; i < p->width ; i++ )
\r
3999 for ( int j = 0 ; j < p->height ; j++ )
\r
4001 VectorCopy (p->ctrl[i][j].xyz, g_qeglobals.d_points[g_qeglobals.d_numpoints]);
\r
4002 if (g_qeglobals.d_numpoints < MAX_POINTS-1)
\r
4004 g_qeglobals.d_numpoints++;
\r
4010 g_qeglobals.d_select_mode = sel_curvepoint;
\r
4011 //--g_nSelectedPatch = n;
\r
4017 ==================
\r
4019 ==================
\r
4021 //FIXME: need all sorts of asserts throughout a lot of this crap
\r
4022 void Patch_Deselect()
\r
4024 //--g_nSelectedPatch = -1;
\r
4025 g_qeglobals.d_select_mode = sel_brush;
\r
4027 for (brush_t *b = selected_brushes.next ; b != &selected_brushes ; b=b->next)
\r
4029 if (b->patchBrush)
\r
4031 b->pPatch->bSelected = false;
\r
4035 //for (int i = 0; i < numPatchMeshes; i++)
\r
4036 // patchMeshes[i].bSelected = false;
\r
4038 if (g_bPatchBendMode)
\r
4039 Patch_BendToggle();
\r
4040 // if (g_bPatchInsertMode)
\r
4041 // Patch_InsDelToggle();
\r
4046 ==================
\r
4048 ==================
\r
4050 void Patch_Select(patchMesh_t *p)
\r
4052 // maintained for point manip.. which i need to fix as this
\r
4053 // is pf error prone
\r
4054 //--g_nSelectedPatch = n;
\r
4055 p->bSelected = true;
\r
4060 ==================
\r
4062 ==================
\r
4064 void Patch_Deselect(patchMesh_t *p)
\r
4066 p->bSelected = false;
\r
4071 ==================
\r
4073 ==================
\r
4075 extern BTNode_t *BTree_Delete(BTNode_t *pBT);
\r
4076 extern BTListList_t *BTree_DeleteListFromList(BTListList_t *pBTListList);
\r
4078 void Patch_Delete(patchMesh_t *p)
\r
4080 if (p->pSymbiot) // Hydra - added a check to prevent access violations.
\r
4082 p->pSymbiot->pPatch = NULL;
\r
4083 p->pSymbiot->patchBrush = false;
\r
4086 // spog - free dynamically allocated memory used by LODs
\r
4087 int rowcount = ((MAX_PATCH_WIDTH-1)/2) * MAX_PATCH_HEIGHT;
\r
4088 int colcount = ((MAX_PATCH_HEIGHT-1)/2) * MAX_PATCH_WIDTH;
\r
4090 for (i=0; i<rowcount; i++)
\r
4091 p->rowLOD[i] = BTree_Delete(p->rowLOD[i]);
\r
4092 for (i=0; i<colcount; i++)
\r
4093 p->colLOD[i] = BTree_Delete(p->colLOD[i]);
\r
4095 // delete display list associated with patch
\r
4096 if (p->nListID != -1)
\r
4097 qglDeleteLists (p->nListID, 1); // list#, number of lists
\r
4099 // delete LOD drawLists
\r
4100 Patch_DeleteDrawLists(p);
\r
4107 UpdatePatchInspector();
\r
4112 ==================
\r
4114 ==================
\r
4116 void Patch_Scale(patchMesh_t *p, const vec3_t vOrigin, const vec3_t vAmt, bool bRebuild)
\r
4119 for (int w = 0; w < p->width; w++)
\r
4121 for (int h = 0; h < p->height; h++)
\r
4123 if (g_qeglobals.d_select_mode == sel_curvepoint && PointInMoveList(p->ctrl[w][h].xyz) == -1)
\r
4125 for (int i=0 ; i<3 ; i++)
\r
4127 p->ctrl[w][h].xyz[i] -= vOrigin[i];
\r
4128 p->ctrl[w][h].xyz[i] *= vAmt[i];
\r
4129 p->ctrl[w][h].xyz[i] += vOrigin[i];
\r
4135 vec3_t vMin, vMax;
\r
4136 Patch_CalcBounds(p, vMin, vMax);
\r
4137 Brush_RebuildBrush(p->pSymbiot, vMin, vMax);
\r
4139 UpdatePatchInspector();
\r
4144 ==================
\r
4146 ==================
\r
4148 void Patch_SetView(int n)
\r
4150 g_bSameView = (n == g_nPatchClickedView);
\r
4151 g_nPatchClickedView = n;
\r
4156 ==================
\r
4158 ==================
\r
4160 // FIXME: need array validation throughout
\r
4161 void Patch_SetTexture(patchMesh_t *p, texdef_t *tex_def, IPluginTexdef* pPlugTexdef)
\r
4163 // NOTE: I don't know for sure if this happens
\r
4165 p->pShader->DecRef();
\r
4166 p->pShader = QERApp_Shader_ForName(tex_def->GetName());
\r
4167 p->pShader->IncRef();
\r
4168 p->d_texture = p->pShader->getTexture();
\r
4170 UpdatePatchInspector();
\r
4175 ==================
\r
4177 ==================
\r
4179 bool Patch_DragScale(patchMesh_t *p, vec3_t vAmt, vec3_t vMove)
\r
4181 vec3_t vMin, vMax, vScale, vTemp, vMid;
\r
4184 Patch_CalcBounds(p, vMin, vMax);
\r
4186 VectorSubtract(vMax, vMin, vTemp);
\r
4188 // if we are scaling in the same dimension the patch has no depth
\r
4189 for (i = 0; i < 3; i ++)
\r
4191 if (vTemp[i] == 0 && vMove[i] != 0)
\r
4193 //Patch_Move(n, vMove, true);
\r
4198 for (i=0 ; i<3 ; i++)
\r
4199 vMid[i] = (vMin[i] + ((vMax[i] - vMin[i]) / 2));
\r
4201 for (i = 0; i < 3; i++)
\r
4205 vScale[i] = 1.0 + vAmt[i] / vTemp[i];
\r
4213 Patch_Scale(p, vMid, vScale, false);
\r
4215 VectorSubtract(vMax, vMin, vTemp);
\r
4217 Patch_CalcBounds(p, vMin, vMax);
\r
4219 VectorSubtract(vMax, vMin, vMid);
\r
4221 VectorSubtract(vMid, vTemp, vTemp);
\r
4223 VectorScale(vTemp, 0.5, vTemp);
\r
4225 // abs of both should always be equal
\r
4226 if (!VectorCompare(vMove, vAmt))
\r
4228 for (i = 0; i < 3; i++)
\r
4230 if (vMove[i] != vAmt[i])
\r
4231 vTemp[i] = -(vTemp[i]);
\r
4235 Patch_Move(p, vTemp);
\r
4240 ==================
\r
4241 Patch_InsertColumn
\r
4242 ==================
\r
4244 void Patch_InsertColumn(patchMesh_t *p, bool bAdd)
\r
4246 int w, h, i, width;
\r
4250 if (p->width + 2 >= MAX_PATCH_WIDTH)
\r
4253 // check for selected column points
\r
4254 for (h = 0; h < p->height; h++)
\r
4256 for (w = 1; w < p->width; w+=2)
\r
4257 if (PointInMoveList(p->ctrl[w][h].xyz) != -1)
\r
4261 for (w = 0; w < p->width; w+=2)
\r
4262 if (PointInMoveList(p->ctrl[w][h].xyz) != -1)
\r
4268 if (w >= p->width)
\r
4270 if (bAdd) w=p->width-1;
\r
4273 else if (w==0) w=2;
\r
4274 else if (w%2) w++;
\r
4276 // add columns at w
\r
4277 for (h = 0; h < p->height; h++)
\r
4279 for (width = p->width-1; width > w; width--)
\r
4280 memcpy(&p->ctrl[width+2][h],&p->ctrl[width][h], sizeof(drawVert_t));
\r
4282 // set two new column points
\r
4283 memcpy(&p->ctrl[w+2][h],&p->ctrl[w][h], sizeof(drawVert_t));
\r
4284 memcpy(&p->ctrl[w+1][h],&p->ctrl[w-1][h], sizeof(drawVert_t));
\r
4286 for (i=0; i<3; i++) // xyz
\r
4288 vTemp[i] = p->ctrl[w][h].xyz[i] - p->ctrl[w-1][h].xyz[i];
\r
4289 p->ctrl[w+1][h].xyz[i] = p->ctrl[w+1][h].xyz[i] + (vTemp[i] / 2);
\r
4291 vTemp[i] = p->ctrl[w-2][h].xyz[i] - p->ctrl[w-1][h].xyz[i];
\r
4292 p->ctrl[w-1][h].xyz[i] = p->ctrl[w-1][h].xyz[i] + (vTemp[i] / 2);
\r
4294 vTemp[i] = p->ctrl[w+1][h].xyz[i] - p->ctrl[w-1][h].xyz[i];
\r
4295 p->ctrl[w][h].xyz[i] = p->ctrl[w-1][h].xyz[i] + (vTemp[i] / 2);
\r
4297 for (i=0; i<2; i++) // st
\r
4299 stTemp[i] = p->ctrl[w][h].st[i] - p->ctrl[w-1][h].st[i];
\r
4300 p->ctrl[w+1][h].st[i] = p->ctrl[w+1][h].st[i] + (stTemp[i] / 2);
\r
4302 stTemp[i] = p->ctrl[w-2][h].st[i] - p->ctrl[w-1][h].st[i];
\r
4303 p->ctrl[w-1][h].st[i] = p->ctrl[w-1][h].st[i] + (stTemp[i] / 2);
\r
4305 stTemp[i] = p->ctrl[w+1][h].st[i] - p->ctrl[w-1][h].st[i];
\r
4306 p->ctrl[w][h].st[i] = p->ctrl[w-1][h].st[i] + (stTemp[i] / 2);
\r
4311 // deselect all points to keep things neat
\r
4312 if (g_qeglobals.d_select_mode == sel_curvepoint)
\r
4313 Patch_EditPatch();
\r
4315 UpdatePatchInspector();
\r
4319 ==================
\r
4321 ==================
\r
4324 void Patch_InsertRow(patchMesh_t *p, bool bAdd)
\r
4326 int h, w, i, height;
\r
4330 if (p->height + 2 >= MAX_PATCH_HEIGHT)
\r
4333 // check for selected row points
\r
4334 for (w = 0; w < p->width; w++)
\r
4336 for (h = 1; h < p->height; h+=2)
\r
4337 if (PointInMoveList(p->ctrl[w][h].xyz) != -1)
\r
4339 if (h < p->height)
\r
4341 for (h = 0; h < p->height; h+=2)
\r
4342 if (PointInMoveList(p->ctrl[w][h].xyz) != -1)
\r
4344 if (h < p->height)
\r
4347 if (h >= p->height)
\r
4349 if (bAdd) h=p->height-1;
\r
4352 else if (h==0) h=2;
\r
4353 else if (h%2) h++;
\r
4356 for (w = 0; w < p->width; w++)
\r
4358 for (height = p->height-1; height > h; height--)
\r
4359 memcpy(&p->ctrl[w][height+2],&p->ctrl[w][height], sizeof(drawVert_t));
\r
4361 // set two new row points
\r
4362 memcpy(&p->ctrl[w][h+2],&p->ctrl[w][h], sizeof(drawVert_t));
\r
4363 memcpy(&p->ctrl[w][h+1],&p->ctrl[w][h-1], sizeof(drawVert_t));
\r
4365 for (i=0; i<3; i++) // xyz
\r
4367 vTemp[i] = p->ctrl[w][h].xyz[i] - p->ctrl[w][h-1].xyz[i];
\r
4368 p->ctrl[w][h+1].xyz[i] = p->ctrl[w][h+1].xyz[i] + (vTemp[i] / 2);
\r
4370 vTemp[i] = p->ctrl[w][h-2].xyz[i] - p->ctrl[w][h-1].xyz[i];
\r
4371 p->ctrl[w][h-1].xyz[i] = p->ctrl[w][h-1].xyz[i] + (vTemp[i] / 2);
\r
4373 vTemp[i] = p->ctrl[w][h+1].xyz[i] - p->ctrl[w][h-1].xyz[i];
\r
4374 p->ctrl[w][h].xyz[i] = p->ctrl[w][h-1].xyz[i] + (vTemp[i] / 2);
\r
4376 for (i=0; i<2; i++) // st
\r
4378 stTemp[i] = p->ctrl[w][h].st[i] - p->ctrl[w][h-1].st[i];
\r
4379 p->ctrl[w][h+1].st[i] = p->ctrl[w][h+1].st[i] + (stTemp[i] / 2);
\r
4381 stTemp[i] = p->ctrl[w][h-2].st[i] - p->ctrl[w][h-1].st[i];
\r
4382 p->ctrl[w][h-1].st[i] = p->ctrl[w][h-1].st[i] + (stTemp[i] / 2);
\r
4384 stTemp[i] = p->ctrl[w][h+1].st[i] - p->ctrl[w][h-1].st[i];
\r
4385 p->ctrl[w][h].st[i] = p->ctrl[w][h-1].st[i] + (stTemp[i] / 2);
\r
4390 // deselect all points to keep things neat
\r
4391 if (g_qeglobals.d_select_mode == sel_curvepoint)
\r
4392 Patch_EditPatch();
\r
4394 UpdatePatchInspector();
\r
4398 ==================
\r
4400 ==================
\r
4402 void Patch_RemoveRow(patchMesh_t *p, bool bFirst)
\r
4404 int w, h, i, height;
\r
4407 bool bExtrapolate = true;
\r
4409 if (p->height <= MIN_PATCH_HEIGHT)
\r
4412 for (w = 0; w < p->width; w++)
\r
4414 for (h = 0; h < p->height; h+=2)
\r
4415 if (PointInMoveList(p->ctrl[w][h].xyz) != -1)
\r
4417 if (h < p->height)
\r
4419 for (h = 1; h < p->height; h+=2)
\r
4420 if (PointInMoveList(p->ctrl[w][h].xyz) != -1)
\r
4422 if (h < p->height)
\r
4426 if (h >= p->height)
\r
4428 bExtrapolate = false;
\r
4429 if (bFirst) h=p->height-3;
\r
4432 else if (h <= 0) h=2;
\r
4433 else if (h > p->height-3) h = p->height-3;
\r
4434 else if (h%2) h++;
\r
4438 for (w = 0; w < p->width; w++)
\r
4442 for (i = 0; i < 3; i++) // xyz
\r
4444 vTemp[i] = p->ctrl[w][h+2].xyz[i] - p->ctrl[w][h-2].xyz[i];
\r
4445 p->ctrl[w][h-1].xyz[i] = p->ctrl[w][h-2].xyz[i] + (vTemp[i] / 2);
\r
4447 vTemp[i] = p->ctrl[w][h].xyz[i] - p->ctrl[w][h-1].xyz[i];
\r
4448 p->ctrl[w][h-1].xyz[i] = p->ctrl[w][h-1].xyz[i] + (vTemp[i] * 2);
\r
4451 for (i = 0; i < 2; i++) // st
\r
4453 stTemp[i] = p->ctrl[w][h+2].st[i] - p->ctrl[w][h-2].st[i];
\r
4454 p->ctrl[w][h-1].st[i] = p->ctrl[w][h-2].st[i] + (stTemp[i] / 2);
\r
4456 stTemp[i] = p->ctrl[w][h].st[i] - p->ctrl[w][h-1].st[i];
\r
4457 p->ctrl[w][h-1].st[i] = p->ctrl[w][h-1].st[i] + (stTemp[i] * 2);
\r
4466 for (height = h; height < p->height; height++)
\r
4467 memcpy(&p->ctrl[w][height], &p->ctrl[w][height+2], sizeof(drawVert_t));
\r
4469 // deselect all points to keep things neat
\r
4470 if (g_qeglobals.d_select_mode == sel_curvepoint)
\r
4471 Patch_EditPatch();
\r
4473 UpdatePatchInspector();
\r
4477 ==================
\r
4478 Patch_RemoveColumn
\r
4479 ==================
\r
4481 void Patch_RemoveColumn(patchMesh_t *p, bool bFirst)
\r
4483 int w, h, i, width;
\r
4486 bool bExtrapolate = true;
\r
4488 if (p->width <= MIN_PATCH_WIDTH)
\r
4491 for (h = 0; h < p->height; h++)
\r
4493 for (w = 0; w < p->width; w+=2)
\r
4494 if (PointInMoveList(p->ctrl[w][h].xyz) != -1)
\r
4498 for (w = 1; w < p->width; w+=2)
\r
4499 if (PointInMoveList(p->ctrl[w][h].xyz) != -1)
\r
4505 if (w >= p->width)
\r
4507 bExtrapolate = false;
\r
4508 if (bFirst) w=p->width-3;
\r
4511 else if (w<=0) w=2;
\r
4512 else if (w > p->width-3) w = p->width-3;
\r
4513 else if (w%2) w++;
\r
4517 for (h = 0; h < p->height; h++)
\r
4521 for (i = 0; i < 3; i++) // xyz
\r
4523 vTemp[i] = p->ctrl[w+2][h].xyz[i] - p->ctrl[w-2][h].xyz[i];
\r
4524 p->ctrl[w-1][h].xyz[i] = p->ctrl[w-2][h].xyz[i] + (vTemp[i] / 2);
\r
4526 vTemp[i] = p->ctrl[w][h].xyz[i] - p->ctrl[w-1][h].xyz[i];
\r
4527 p->ctrl[w-1][h].xyz[i] = p->ctrl[w-1][h].xyz[i] + (vTemp[i] * 2);
\r
4530 for (i = 0; i < 2; i++) // st
\r
4532 stTemp[i] = p->ctrl[w+2][h].st[i] - p->ctrl[w-2][h].st[i];
\r
4533 p->ctrl[w-1][h].st[i] = p->ctrl[w-2][h].st[i] + (stTemp[i] / 2);
\r
4535 stTemp[i] = p->ctrl[w][h].st[i] - p->ctrl[w-1][h].st[i];
\r
4536 p->ctrl[w-1][h].st[i] = p->ctrl[w-1][h].st[i] + (stTemp[i] * 2);
\r
4546 for (width = w; width < p->width; width++)
\r
4547 memcpy(&p->ctrl[width][h], &p->ctrl[width+2][h], sizeof(drawVert_t));
\r
4549 // deselect all points to keep things neat
\r
4550 if (g_qeglobals.d_select_mode == sel_curvepoint)
\r
4551 Patch_EditPatch();
\r
4553 UpdatePatchInspector();
\r
4557 ==================
\r
4558 Patch_AdjustColumns
\r
4559 ==================
\r
4562 void Patch_AdjustColumns(patchMesh_t *p, int nCols)
\r
4564 vec3_t vTemp, vTemp2;
\r
4567 if (nCols & 0x01 || p->width + nCols < 3 || p->width + nCols > MAX_PATCH_WIDTH)
\r
4570 // add in column adjustment
\r
4571 p->width += nCols;
\r
4573 for (h = 0; h < p->height; h++)
\r
4575 // for each column, we need to evenly disperse p->width number
\r
4576 // of points across the old bounds
\r
4578 // calc total distance to interpolate
\r
4579 VectorSubtract(p->ctrl[p->width - 1 - nCols][h].xyz, p->ctrl[0][h].xyz, vTemp);
\r
4581 // amount per cycle
\r
4582 for (i = 0; i < 3; i ++)
\r
4584 vTemp2[i] = vTemp[i] / (p->width - 1);
\r
4588 for (w = 0; w < p->width-1; w++)
\r
4590 VectorAdd(p->ctrl[w][h].xyz, vTemp2, p->ctrl[w+1][h].xyz);
\r
4594 for ( w = 0 ; w < p->width ; w++ )
\r
4596 for ( h = 0 ; h < p->height ; h++ )
\r
4598 p->ctrl[w][h].st[0] = 4 * (float)w / (p->width - 1);
\r
4599 p->ctrl[w][h].st[1] = 4 * (float)h / (p->height - 1);
\r
4602 UpdatePatchInspector();
\r
4607 ==================
\r
4609 ==================
\r
4612 void Patch_AdjustRows(patchMesh_t *p, int nRows)
\r
4614 vec3_t vTemp, vTemp2;
\r
4617 if (nRows & 0x01 || p->height + nRows < 3 || p->height + nRows > MAX_PATCH_HEIGHT)
\r
4620 // add in column adjustment
\r
4621 p->height += nRows;
\r
4623 for (w = 0; w < p->width; w++)
\r
4625 // for each row, we need to evenly disperse p->height number
\r
4626 // of points across the old bounds
\r
4628 // calc total distance to interpolate
\r
4629 VectorSubtract(p->ctrl[w][p->height - 1 - nRows].xyz, p->ctrl[w][0].xyz, vTemp);
\r
4631 //vTemp[0] = vTemp[1] = vTemp[2] = 0;
\r
4632 //for (h = 0; h < p->height - nRows; h ++)
\r
4634 // VectorAdd(vTemp, p->ctrl[w][h], vTemp);
\r
4637 // amount per cycle
\r
4638 for (i = 0; i < 3; i ++)
\r
4640 vTemp2[i] = vTemp[i] / (p->height - 1);
\r
4644 for (h = 0; h < p->height-1; h++)
\r
4646 VectorAdd(p->ctrl[w][h].xyz, vTemp2, p->ctrl[w][h+1].xyz);
\r
4650 for ( w = 0 ; w < p->width ; w++ )
\r
4652 for ( h = 0 ; h < p->height ; h++ )
\r
4654 p->ctrl[w][h].st[0] = 4 * (float)w / (p->width - 1);
\r
4655 p->ctrl[w][h].st[1] = 4 * (float)h / (p->height - 1);
\r
4658 UpdatePatchInspector();
\r
4663 ==================
\r
4664 Patch_DisperseRows
\r
4665 ==================
\r
4668 void Patch_DisperseRows()
\r
4670 vec3_t vTemp, vTemp2;
\r
4674 for (brush_t *pb = selected_brushes.next ; pb != &selected_brushes ; pb = pb->next)
\r
4676 if (pb->patchBrush)
\r
4678 patchMesh_t *p = pb->pPatch;
\r
4680 for (w = 0; w < p->width; w++)
\r
4682 // for each row, we need to evenly disperse p->height number
\r
4683 // of points across the old bounds
\r
4685 // calc total distance to interpolate
\r
4686 VectorSubtract(p->ctrl[w][p->height - 1].xyz, p->ctrl[w][0].xyz, vTemp);
\r
4688 //vTemp[0] = vTemp[1] = vTemp[2] = 0;
\r
4689 //for (h = 0; h < p->height - nRows; h ++)
\r
4691 // VectorAdd(vTemp, p->ctrl[w][h], vTemp);
\r
4694 // amount per cycle
\r
4695 for (i = 0; i < 3; i ++)
\r
4697 vTemp2[i] = vTemp[i] / (p->height - 1);
\r
4701 for (h = 0; h < p->height-1; h++)
\r
4703 VectorAdd(p->ctrl[w][h].xyz, vTemp2, p->ctrl[w][h+1].xyz);
\r
4705 Patch_Naturalize(p);
\r
4710 UpdatePatchInspector();
\r
4714 ==================
\r
4715 Patch_DisperseIntermediateRows
\r
4716 ==================
\r
4719 void Patch_DisperseIntermediateRows()
\r
4721 vec3_t vTemp, vTemp2;
\r
4725 for (brush_t *pb = selected_brushes.next ; pb != &selected_brushes ; pb = pb->next)
\r
4727 if (pb->patchBrush)
\r
4729 patchMesh_t *p = pb->pPatch;
\r
4731 for (w = 0; w < p->width; w++)
\r
4734 for (h = 0; h < p->height; h+=2)
\r
4736 // calc distance to interpolate
\r
4737 VectorSubtract(p->ctrl[w][h+2].xyz, p->ctrl[w][h].xyz, vTemp);
\r
4740 for (i = 0; i < 3; i ++)
\r
4742 vTemp2[i] = vTemp[i] / 2;
\r
4745 // move control points
\r
4746 VectorAdd(p->ctrl[w][h].xyz, vTemp2, p->ctrl[w][h+1].xyz);
\r
4751 UpdatePatchInspector();
\r
4755 ==================
\r
4756 Patch_DisperseIntermediateColumns
\r
4757 ==================
\r
4759 void Patch_DisperseIntermediateColumns()
\r
4761 vec3_t vTemp, vTemp2;
\r
4765 for (brush_t *pb = selected_brushes.next ; pb != &selected_brushes ; pb = pb->next)
\r
4767 if (pb->patchBrush)
\r
4769 patchMesh_t *p = pb->pPatch;
\r
4771 for (h = 0; h < p->height; h++)
\r
4774 for (w = 0; w < p->width; w+=2)
\r
4776 // calc distance to interpolate
\r
4777 VectorSubtract(p->ctrl[w+2][h].xyz, p->ctrl[w][h].xyz, vTemp);
\r
4780 for (i = 0; i < 3; i ++)
\r
4782 vTemp2[i] = vTemp[i] / 2;
\r
4785 // move control points
\r
4786 VectorAdd(p->ctrl[w][h].xyz, vTemp2, p->ctrl[w+1][h].xyz);
\r
4791 UpdatePatchInspector();
\r
4797 ==================
\r
4798 Patch_AdjustSelected
\r
4799 ==================
\r
4801 void Patch_AdjustSelected(bool bInsert, bool bColumn, bool bFlag)
\r
4803 bool bUpdate = false;
\r
4804 for (brush_t* pb = selected_brushes.next ; pb != &selected_brushes ; pb = pb->next)
\r
4806 if (pb->patchBrush)
\r
4812 Patch_InsertColumn(pb->pPatch, bFlag);
\r
4816 Patch_InsertRow(pb->pPatch, bFlag);
\r
4823 Patch_RemoveColumn(pb->pPatch, bFlag);
\r
4827 Patch_RemoveRow(pb->pPatch, bFlag);
\r
4831 vec3_t vMin, vMax;
\r
4832 patchMesh_t *p = pb->pPatch;
\r
4833 Patch_CalcBounds(p, vMin, vMax);
\r
4834 Brush_RebuildBrush(p->pSymbiot, vMin, vMax);
\r
4835 pb->pPatch->bDirty = true; // rebuild LOD trees and their normals
\r
4840 Sys_UpdateWindows(W_ALL);
\r
4846 ==================
\r
4847 Patch_AdjustSelectedRowCols
\r
4848 ==================
\r
4851 void Patch_AdjustSelectedRowCols(int nRows, int nCols)
\r
4853 for (brush_t* pb = selected_brushes.next ; pb != &selected_brushes ; pb = pb->next)
\r
4855 if (pb->patchBrush)
\r
4857 Patch_InsertColumn(pb->pPatch, false);
\r
4860 Patch_AdjustRows(pb->pPatch, nRows);
\r
4865 Patch_AdjustColumns(pb->pPatch, nCols);
\r
4869 UpdatePatchInspector();
\r
4876 temporary stuff, detect potential problems when saving the texture name
\r
4877 will correct the patch on the fly if problem detected
\r
4881 \todo performance issue with CheckName calls
\r
4882 don't call this too much, only when absolutely necessary
\r
4883 strategies that call here too much are known to be slow
\r
4884 patch 84 to bug 253 adds an additionnal check for textures/
\r
4886 void CheckName( patchMesh_t *p, char *pname )
\r
4888 if(strncmp(p->pShader->getName(), "textures/", 9) != 0)
\r
4889 p->pShader = QERApp_Shader_ForName(SHADER_NOT_FOUND);
\r
4891 // some manage to get long filename textures (with spaces) in their maps
\r
4892 if (strchr( p->pShader->getName(), ' ' ))
\r
4895 sprintf( Msg1, "Can't save texture with spaces in name. Rename %s\nNOTE: This message may popup several times .. once for each buggy face detected.", p->pShader->getName() );
\r
4896 Sys_Printf("%s\n", Msg1 );
\r
4897 gtk_MessageBox(g_pParentWnd->m_pWidget, Msg1, "Error saving map", MB_OK );
\r
4898 strcpy( pname, SHADER_NOT_FOUND );
\r
4899 p->pShader = QERApp_Shader_ForName(SHADER_NOT_FOUND);
\r
4900 p->d_texture = p->pShader->getTexture();
\r
4903 strcpy( pname, p->pShader->getName()+9 ); // remove "textures/"
\r
4907 ==================
\r
4909 ==================
\r
4911 void Patch_Write (patchMesh_t *p, MemStream *file)
\r
4915 MemFile_fprintf(file, " {\n patchDef2\n {\n");
\r
4917 CheckName( p, pname );
\r
4918 MemFile_fprintf(file, " %s\n", pname );
\r
4919 MemFile_fprintf(file, " ( %i %i %i %i %i ) \n", p->width, p->height, p->contents, p->flags, p->value);
\r
4922 float ctrl[MAX_PATCH_WIDTH][MAX_PATCH_HEIGHT][5];
\r
4925 for (w = 0; w < p->width; w++)
\r
4927 for (h = 0; h < p->height; h++)
\r
4929 ctrl[w][h][0] = p->ctrl[w][h].xyz[0];
\r
4930 ctrl[w][h][1] = p->ctrl[w][h].xyz[1];
\r
4931 ctrl[w][h][2] = p->ctrl[w][h].xyz[2];
\r
4932 ctrl[w][h][3] = p->ctrl[w][h].st[0];
\r
4933 ctrl[w][h][4] = p->ctrl[w][h].st[1];
\r
4937 _Write3DMatrix(file, p->width, p->height, 5, reinterpret_cast<float*>(&ctrl));
\r
4939 if (g_qeglobals.m_bBrushPrimitMode)
\r
4943 for (epair_t *ep = p->epairs ; ep ; ep=ep->next)
\r
4945 MemFile_fprintf (file, "\"%s\" \"%s\"\n", ep->key, ep->value);
\r
4950 MemFile_fprintf(file, " }\n }\n");
\r
4953 void Patch_Write (patchMesh_t *p, FILE *file)
\r
4957 fprintf(file, " {\n patchDef2\n {\n");
\r
4959 CheckName( p, pname );
\r
4960 fprintf(file, " %s\n", pname );
\r
4961 fprintf(file, " ( %i %i %i %i %i ) \n", p->width, p->height, p->contents, p->flags, p->value);
\r
4964 float ctrl[MAX_PATCH_WIDTH][MAX_PATCH_HEIGHT][5];
\r
4967 for (w = 0; w < p->width; w++)
\r
4969 for (h = 0; h < p->height; h++)
\r
4971 ctrl[w][h][0] = p->ctrl[w][h].xyz[0];
\r
4972 ctrl[w][h][1] = p->ctrl[w][h].xyz[1];
\r
4973 ctrl[w][h][2] = p->ctrl[w][h].xyz[2];
\r
4974 ctrl[w][h][3] = p->ctrl[w][h].st[0];
\r
4975 ctrl[w][h][4] = p->ctrl[w][h].st[1];
\r
4979 _Write3DMatrix(file, p->width, p->height, 5, reinterpret_cast<float*>(&ctrl));
\r
4981 if (g_qeglobals.m_bBrushPrimitMode)
\r
4985 for (epair_t *ep = p->epairs ; ep ; ep=ep->next)
\r
4987 fprintf (file, "\"%s\" \"%s\"\n", ep->key, ep->value);
\r
4992 fprintf(file, " }\n }\n");
\r
4997 ==================
\r
4998 Patch_RotateTexture
\r
4999 ==================
\r
5001 void Patch_RotateTexture(patchMesh_t *p, float fAngle)
\r
5004 float c = cos(fAngle * Q_PI / 180);
\r
5005 float s = sin(fAngle * Q_PI / 180);
\r
5007 Patch_TransformLODTexture(p, c, s, ROTATE);
\r
5009 for (int w = 0; w < p->width; w++)
\r
5011 for (int h = 0; h < p->height; h++)
\r
5013 //if (g_qeglobals.d_select_mode == sel_curvepoint && PointInMoveList(p->ctrl[w][h].xyz) == -1)
\r
5016 float x = p->ctrl[w][h].st[0];
\r
5017 float y = p->ctrl[w][h].st[1];
\r
5018 p->ctrl[w][h].st[0] = x * c - y * s;
\r
5019 p->ctrl[w][h].st[1] = y * c + x * s;
\r
5026 ==================
\r
5027 Patch_ScaleTexture
\r
5028 ==================
\r
5030 void Patch_ScaleTexture(patchMesh_t *p, float fx, float fy, bool bFixup)
\r
5033 // this hack turns scales into 1.1 or 0.9
\r
5036 fx = (fx == 0) ? 1.0 : (fx > 0) ? 0.9 : 1.10;
\r
5037 fy = (fy == 0) ? 1.0 : (fy > 0) ? 0.9 : 1.10;
\r
5047 for (int w = 0; w < p->width; w++)
\r
5049 for (int h = 0; h < p->height; h++)
\r
5051 if (g_qeglobals.d_select_mode == sel_curvepoint && PointInMoveList(p->ctrl[w][h].xyz) == -1)
\r
5054 p->ctrl[w][h].st[0] *= fx;
\r
5055 p->ctrl[w][h].st[1] *= fy;
\r
5058 if (g_qeglobals.d_select_mode == sel_curvepoint)
\r
5061 Patch_LODMatchAll();
\r
5065 Patch_TransformLODTexture(p, fx, fy, SCALE);
\r
5066 p->LODUpdated = true;
\r
5072 ==================
\r
5073 Patch_ShiftTexture
\r
5074 shift a texture given a pixel count
\r
5075 ==================
\r
5077 void Patch_ShiftTexture(patchMesh_t *p, float fx, float fy)
\r
5080 pTex = p->pShader->getTexture();
\r
5081 fx = -1 * fx / pTex->width;
\r
5082 fy = fy / pTex->height;
\r
5083 Patch_ShiftTextureST(p, fx, fy);
\r
5087 ====================
\r
5088 Patch_ShiftTextureST
\r
5089 shift a patch texture given an ST increment
\r
5090 ====================
\r
5092 void Patch_ShiftTextureST(patchMesh_t *p, float fx, float fy)
\r
5095 // NOTE: when called by Patch_ShiftTexture this warning may be bogus
\r
5096 if ((ABS(fx) >= 1) || (ABS(fy) >= 1))
\r
5097 Sys_Printf("WARNING: increments exceed 1 in Patch_ShiftTextureST\n");
\r
5099 for (int w = 0; w < p->width; w++)
\r
5101 for (int h = 0; h < p->height; h++)
\r
5103 if (g_qeglobals.d_select_mode == sel_curvepoint && PointInMoveList(p->ctrl[w][h].xyz) == -1)
\r
5106 p->ctrl[w][h].st[0] += fx;
\r
5107 p->ctrl[w][h].st[1] += fy;
\r
5110 if (g_qeglobals.d_select_mode == sel_curvepoint)
\r
5113 Patch_LODMatchAll();
\r
5117 Patch_TransformLODTexture(p, fx, fy, TRANSLATE);
\r
5118 p->LODUpdated = true;
\r
5123 ==================
\r
5124 Patch_ToggleInverted
\r
5125 ==================
\r
5127 void Patch_ToggleInverted()
\r
5129 bool bUpdate = false;
\r
5131 for (brush_t *pb = selected_brushes.next ; pb != &selected_brushes ; pb = pb->next)
\r
5133 if (pb->patchBrush)
\r
5136 patchInvert(pb->pPatch);
\r
5142 Sys_UpdateWindows(W_ALL);
\r
5144 UpdatePatchInspector();
\r
5148 ==================
\r
5149 Patch_ToggleInverted
\r
5150 ==================
\r
5152 void Patch_InvertTexture(bool bY)
\r
5154 bool bUpdate = false;
\r
5157 for (brush_t *pb = selected_brushes.next ; pb != &selected_brushes ; pb = pb->next)
\r
5159 if (pb->patchBrush)
\r
5162 patchMesh_t *p = pb->pPatch;
\r
5166 for ( int i = 0 ; i < p->height ; i++ )
\r
5168 for (int j = 0; j < p->width / 2; j++)
\r
5170 memcpy(fTemp, &p->ctrl[p->width - 1- j][i].st[0], sizeof (float[2]));
\r
5171 memcpy(&p->ctrl[p->width - 1- j][i].st[0], &p->ctrl[j][i].st[0], sizeof(float[2]));
\r
5172 memcpy(&p->ctrl[j][i].st[0], fTemp, sizeof(float[2]));
\r
5178 for ( int i = 0 ; i < p->width ; i++ )
\r
5180 for (int j = 0; j < p->height / 2; j++)
\r
5182 memcpy(fTemp, &p->ctrl[i][p->height - 1- j].st[0], sizeof (float[2]));
\r
5183 memcpy(&p->ctrl[i][p->height - 1 - j].st[0], &p->ctrl[i][j].st[0], sizeof(float[2]));
\r
5184 memcpy(&p->ctrl[i][j].st[0], fTemp, sizeof(float[2]));
\r
5193 Sys_UpdateWindows(W_ALL);
\r
5195 UpdatePatchInspector();
\r
5202 ==================
\r
5204 ==================
\r
5205 Saves patch ctrl info (originally to deal with a
\r
5206 cancel in the surface dialog
\r
5208 void Patch_Save(patchMesh_t *p)
\r
5210 patchSave.width = p->width;
\r
5211 patchSave.height = p->height;
\r
5212 memcpy(patchSave.ctrl, p->ctrl, sizeof(p->ctrl));
\r
5217 ==================
\r
5219 ==================
\r
5221 void Patch_Restore(patchMesh_t *p)
\r
5223 p->width = patchSave.width;
\r
5224 p->height = patchSave.height;
\r
5225 memcpy(p->ctrl, patchSave.ctrl, sizeof(p->ctrl));
\r
5228 void Patch_ResetTexturing(float fx, float fy)
\r
5230 for (brush_t* pb = selected_brushes.next ; pb != &selected_brushes ; pb = pb->next)
\r
5232 if (pb->patchBrush)
\r
5234 patchMesh_t *p = pb->pPatch;
\r
5236 for ( int i = 0 ; i < p->width ; i++ )
\r
5238 for ( int j = 0 ; j < p->height ; j++ )
\r
5240 p->ctrl[i][j].st[0] = fx * (float)i / (p->width - 1);
\r
5241 p->ctrl[i][j].st[1] = 1 - fy * (float)j / (p->height - 1);
\r
5248 // NOTE TTimo stub!
\r
5249 void Patch_FitTexturing()
\r
5251 Patch_ResetTexturing(1.0f, 1.0f);
\r
5254 void Patch_SetTextureInfo(texdef_t *pt)
\r
5256 for (brush_t *pb = selected_brushes.next ; pb != &selected_brushes ; pb = pb->next)
\r
5258 if (pb->patchBrush)
\r
5261 Patch_RotateTexture(pb->pPatch, pt->rotate);
\r
5263 if (pt->shift[0] || pt->shift[1])
\r
5264 Patch_ShiftTexture(pb->pPatch, pt->shift[0], pt->shift[1]);
\r
5266 if (pt->scale[0] || pt->scale[1])
\r
5267 Patch_ScaleTexture(pb->pPatch, pt->scale[0], pt->scale[1], false);
\r
5269 patchMesh_t *p = pb->pPatch;
\r
5270 p->contents = pt->contents;
\r
5271 p->flags = pt->flags;
\r
5272 p->value = pt->value;
\r
5277 bool OnlyPatchesSelected()
\r
5279 if (g_ptrSelectedFaces.GetSize() > 0 || selected_brushes.next == &selected_brushes)
\r
5281 for (brush_t *pb = selected_brushes.next ; pb != &selected_brushes ; pb = pb->next)
\r
5283 if (!pb->patchBrush)
\r
5291 bool AnyPatchesSelected()
\r
5293 if (g_ptrSelectedFaces.GetSize() > 0 || selected_brushes.next == &selected_brushes)
\r
5295 for (brush_t *pb = selected_brushes.next ; pb != &selected_brushes ; pb = pb->next)
\r
5297 if (pb->patchBrush)
\r
5305 patchMesh_t* SinglePatchSelected()
\r
5307 if (selected_brushes.next->patchBrush)
\r
5309 return selected_brushes.next->pPatch;
\r
5314 void Patch_BendToggle()
\r
5316 if (g_bPatchBendMode)
\r
5318 g_bPatchBendMode = false;
\r
5320 g_pParentWnd->UpdatePatchToolbarButtons() ;
\r
5324 brush_t* b = selected_brushes.next;
\r
5326 if (!QE_SingleBrush(true) || !b->patchBrush)
\r
5328 Sys_Printf("Patch_BendToggle: you must have a single patch selected\n");
\r
5332 Patch_Save(b->pPatch);
\r
5333 g_bPatchBendMode = true;
\r
5334 g_nPatchBendState = BEND_SELECT_ROTATION;
\r
5335 g_bPatchAxisOnRow = true;
\r
5336 g_nPatchAxisIndex = 1;
\r
5337 ShowInfoDialog(g_pBendStateMsg[BEND_SELECT_ROTATION]);
\r
5340 void Patch_BendHandleTAB()
\r
5342 if (!g_bPatchBendMode)
\r
5347 brush_t* b = selected_brushes.next;
\r
5348 if (!QE_SingleBrush() || !b->patchBrush)
\r
5350 Patch_BendToggle();
\r
5351 Sys_Printf("No patch to bend!");
\r
5355 patchMesh_t *p = b->pPatch;
\r
5357 bool bShift = Sys_ShiftDown ();
\r
5359 if (g_nPatchBendState == BEND_SELECT_ROTATION)
\r
5361 // only able to deal with odd numbered rows/cols
\r
5362 g_nPatchAxisIndex += (bShift) ? -2 : 2;
\r
5363 if (g_bPatchAxisOnRow)
\r
5365 if ((bShift) ? g_nPatchAxisIndex <= 0 : g_nPatchAxisIndex >= p->height)
\r
5367 g_bPatchAxisOnRow = false;
\r
5368 g_nPatchAxisIndex = (bShift) ? p->width-1 : 1;
\r
5373 if ((bShift) ? g_nPatchAxisIndex <= 0 : g_nPatchAxisIndex >= p->width)
\r
5375 g_bPatchAxisOnRow = true;
\r
5376 g_nPatchAxisIndex = (bShift) ? p->height-1 : 1;
\r
5381 if (g_nPatchBendState == BEND_SELECT_ORIGIN)
\r
5383 g_nBendOriginIndex += (bShift) ? -1 : 1;
\r
5384 if (g_bPatchAxisOnRow)
\r
5388 if (g_nBendOriginIndex < 0)
\r
5389 g_nBendOriginIndex = p->width-1;
\r
5393 if (g_nBendOriginIndex > p->width-1)
\r
5394 g_nBendOriginIndex = 0;
\r
5396 VectorCopy(p->ctrl[g_nBendOriginIndex][g_nPatchAxisIndex].xyz, g_vBendOrigin);
\r
5402 if (g_nBendOriginIndex < 0)
\r
5403 g_nBendOriginIndex = p->height-1;
\r
5407 if (g_nBendOriginIndex > p->height-1)
\r
5408 g_nBendOriginIndex = 0;
\r
5410 VectorCopy(p->ctrl[g_nPatchAxisIndex][g_nBendOriginIndex].xyz, g_vBendOrigin);
\r
5414 if (g_nPatchBendState == BEND_SELECT_EDGE)
\r
5416 g_bPatchLowerEdge ^= 1;
\r
5418 Sys_UpdateWindows(W_ALL);
\r
5421 void Patch_BendHandleENTER()
\r
5423 if (!g_bPatchBendMode)
\r
5428 if (g_nPatchBendState < BEND_BENDIT)
\r
5430 g_nPatchBendState++;
\r
5431 ShowInfoDialog(g_pBendStateMsg[g_nPatchBendState]);
\r
5432 if (g_nPatchBendState == BEND_SELECT_ORIGIN)
\r
5434 g_vBendOrigin[0] = g_vBendOrigin[1] = g_vBendOrigin[2] = 0;
\r
5435 g_nBendOriginIndex = 0;
\r
5436 Patch_BendHandleTAB();
\r
5439 if (g_nPatchBendState == BEND_SELECT_EDGE)
\r
5441 g_bPatchLowerEdge = true;
\r
5444 if (g_nPatchBendState == BEND_BENDIT)
\r
5446 // basically we go into rotation mode, set the axis to the center of the
\r
5452 Patch_BendToggle();
\r
5454 Sys_UpdateWindows(W_ALL);
\r
5459 void Patch_BendHandleESC()
\r
5461 if (!g_bPatchBendMode)
\r
5465 Patch_BendToggle();
\r
5466 brush_t* b = selected_brushes.next;
\r
5467 if (QE_SingleBrush() && b->patchBrush)
\r
5469 Patch_Restore(b->pPatch);
\r
5471 Sys_UpdateWindows(W_ALL);
\r
5474 void Patch_SetBendRotateOrigin(patchMesh_t *p)
\r
5477 int nType = g_pParentWnd->ActiveXY()->GetViewType();
\r
5478 int nDim3 = (nType == XY) ? 2 : (nType == YZ) ? 0 : 1;
\r
5480 g_vBendOrigin[nDim3] = 0;
\r
5481 VectorCopy(g_vBendOrigin, g_pParentWnd->ActiveXY()->RotateOrigin());
\r
5484 int nDim1 = (g_pParentWnd->ActiveXY()->GetViewType() == YZ) ? 1 : 0;
\r
5485 int nDim2 = (g_pParentWnd->ActiveXY()->GetViewType() == XY) ? 1 : 2;
\r
5487 float fxLo, fyLo, fxHi, fyHi;
\r
5488 fxLo = fyLo = 9999;
\r
5489 fxHi = fyHi = -9999;
\r
5491 if (g_bPatchAxisOnRow)
\r
5493 for (int i = 0; i < p->width; i++)
\r
5495 if (p->ctrl[i][g_nPatchAxisIndex].xyz[nDim1] < fxLo)
\r
5496 fxLo = p->ctrl[i][g_nPatchAxisIndex].xyz[nDim1];
\r
5498 if (p->ctrl[i][g_nPatchAxisIndex].xyz[nDim1] > fxHi)
\r
5499 fxHi = p->ctrl[i][g_nPatchAxisIndex].xyz[nDim1];
\r
5501 if (p->ctrl[i][g_nPatchAxisIndex].xyz[nDim2] < fyLo)
\r
5502 fyLo = p->ctrl[i][g_nPatchAxisIndex].xyz[nDim2];
\r
5504 if (p->ctrl[i][g_nPatchAxisIndex].xyz[nDim2] > fyHi)
\r
5505 fyHi = p->ctrl[i][g_nPatchAxisIndex].xyz[nDim2];
\r
5510 for (int i = 0; i < p->height; i++)
\r
5512 if (p->ctrl[g_nPatchAxisIndex][i].xyz[nDim1] < fxLo)
\r
5513 fxLo = p->ctrl[g_nPatchAxisIndex][i].xyz[nDim1];
\r
5515 if (p->ctrl[g_nPatchAxisIndex][i].xyz[nDim1] > fxHi)
\r
5516 fxHi = p->ctrl[g_nPatchAxisIndex][i].xyz[nDim1];
\r
5518 if (p->ctrl[g_nPatchAxisIndex][i].xyz[nDim2] < fyLo)
\r
5519 fyLo = p->ctrl[g_nPatchAxisIndex][i].xyz[nDim2];
\r
5521 if (p->ctrl[g_nPatchAxisIndex][i].xyz[nDim2] > fyHi)
\r
5522 fyHi = p->ctrl[g_nPatchAxisIndex][i].xyz[nDim2];
\r
5526 g_pParentWnd->ActiveXY()->RotateOrigin()[0] = g_pParentWnd->ActiveXY()->RotateOrigin()[1] = g_pParentWnd->ActiveXY()->RotateOrigin()[2] = 0.0;
\r
5527 g_pParentWnd->ActiveXY()->RotateOrigin()[nDim1] = (fxLo + fxHi) * 0.5;
\r
5528 g_pParentWnd->ActiveXY()->RotateOrigin()[nDim2] = (fyLo + fyHi) * 0.5;
\r
5532 // also sets the rotational origin
\r
5533 void Patch_SelectBendAxis()
\r
5535 brush_t* b = selected_brushes.next;
\r
5536 if (!QE_SingleBrush() || !b->patchBrush)
\r
5538 // should not ever happen
\r
5539 Patch_BendToggle();
\r
5543 patchMesh_t *p = b->pPatch;
\r
5544 if (g_bPatchAxisOnRow)
\r
5546 SelectRow(p, g_nPatchAxisIndex, false);
\r
5550 SelectColumn(p, g_nPatchAxisIndex, false);
\r
5553 //FIXME: this only needs to be set once...
\r
5554 Patch_SetBendRotateOrigin(p);
\r
5558 void Patch_SelectBendNormal()
\r
5560 brush_t* b = selected_brushes.next;
\r
5561 if (!QE_SingleBrush() || !b->patchBrush)
\r
5563 // should not ever happen
\r
5564 Patch_BendToggle();
\r
5568 patchMesh_t *p = b->pPatch;
\r
5570 g_qeglobals.d_num_move_points = 0;
\r
5571 if (g_bPatchAxisOnRow)
\r
5573 if (g_bPatchLowerEdge)
\r
5575 for (int j = 0; j < g_nPatchAxisIndex; j++)
\r
5576 SelectRow(p, j, true);
\r
5580 for (int j = p->height-1; j > g_nPatchAxisIndex; j--)
\r
5581 SelectRow(p, j, true);
\r
5586 if (g_bPatchLowerEdge)
\r
5588 for (int j = 0; j < g_nPatchAxisIndex; j++)
\r
5589 SelectColumn(p, j, true);
\r
5593 for (int j = p->width-1; j > g_nPatchAxisIndex; j--)
\r
5594 SelectColumn(p, j, true);
\r
5597 Patch_SetBendRotateOrigin(p);
\r
5603 void Patch_InsDelToggle()
\r
5605 if (g_bPatchInsertMode)
\r
5607 g_bPatchInsertMode = false;
\r
5609 g_pParentWnd->UpdatePatchToolbarButtons() ;
\r
5613 brush_t* b = selected_brushes.next;
\r
5615 if (!QE_SingleBrush(true) || !b->patchBrush)
\r
5617 Sys_Printf("Patch_InsDelToggle: you must have a single patch selected\n");
\r
5621 Patch_Save(b->pPatch);
\r
5622 g_bPatchInsertMode = true;
\r
5623 g_nPatchInsertState = INSERT_SELECT_EDGE;
\r
5624 g_bPatchAxisOnRow = true;
\r
5625 g_nPatchAxisIndex = 0;
\r
5626 ShowInfoDialog(g_pInsertStateMsg[INSERT_SELECT_EDGE]);
\r
5630 void Patch_InsDelESC()
\r
5632 if (!g_bPatchInsertMode)
\r
5636 Patch_InsDelToggle();
\r
5637 Sys_UpdateWindows(W_ALL);
\r
5641 void Patch_InsDelHandleENTER()
\r
5645 void Patch_InsDelHandleTAB()
\r
5647 if (!g_bPatchInsertMode)
\r
5649 Patch_InsDelToggle();
\r
5653 brush_t* b = selected_brushes.next;
\r
5654 if (!QE_SingleBrush() || !b->patchBrush)
\r
5656 Patch_BendToggle();
\r
5657 Sys_Printf("No patch to bend!");
\r
5661 patchMesh_t *p = b->pPatch;
\r
5663 // only able to deal with odd numbered rows/cols
\r
5664 g_nPatchAxisIndex += 2;
\r
5665 if (g_bPatchAxisOnRow)
\r
5667 if (g_nPatchAxisIndex >= p->height-1)
\r
5669 g_bPatchAxisOnRow = false;
\r
5670 g_nPatchAxisIndex = 0;
\r
5675 if (g_nPatchAxisIndex >= p->width-1)
\r
5677 g_bPatchAxisOnRow = true;
\r
5678 g_nPatchAxisIndex = 0;
\r
5681 Sys_UpdateWindows(W_ALL);
\r
5686 void _Write1DMatrix (FILE *f, int x, float *m) {
\r
5689 fprintf (f, "( ");
\r
5690 for (i = 0 ; i < x ; i++) {
\r
5691 if (m[i] == (int)m[i] ) {
\r
5692 fprintf (f, "%i ", (int)m[i]);
\r
5694 fprintf (f, "%f ", m[i]);
\r
5700 void _Write2DMatrix (FILE *f, int y, int x, float *m) {
\r
5703 fprintf (f, "( ");
\r
5704 for (i = 0 ; i < y ; i++) {
\r
5705 _Write1DMatrix (f, x, m + i*x);
\r
5708 fprintf (f, ")\n");
\r
5712 void _Write3DMatrix (FILE *f, int z, int y, int x, float *m) {
\r
5715 fprintf (f, "(\n");
\r
5716 for (i = 0 ; i < z ; i++) {
\r
5717 _Write2DMatrix (f, y, x, m + i*(x*MAX_PATCH_HEIGHT) );
\r
5719 fprintf (f, ")\n");
\r
5722 void _Write1DMatrix (MemStream *f, int x, float *m) {
\r
5725 MemFile_fprintf (f, "( ");
\r
5726 for (i = 0 ; i < x ; i++) {
\r
5727 if (m[i] == (int)m[i] ) {
\r
5728 MemFile_fprintf (f, "%i ", (int)m[i]);
\r
5730 MemFile_fprintf (f, "%f ", m[i]);
\r
5733 MemFile_fprintf (f, ")");
\r
5736 void _Write2DMatrix (MemStream *f, int y, int x, float *m) {
\r
5739 MemFile_fprintf (f, "( ");
\r
5740 for (i = 0 ; i < y ; i++) {
\r
5741 _Write1DMatrix (f, x, m + i*x);
\r
5742 MemFile_fprintf (f, " ");
\r
5744 MemFile_fprintf (f, ")\n");
\r
5748 void _Write3DMatrix (MemStream *f, int z, int y, int x, float *m) {
\r
5751 MemFile_fprintf (f, "(\n");
\r
5752 for (i = 0 ; i < z ; i++) {
\r
5753 _Write2DMatrix (f, y, x, m + i*(x*MAX_PATCH_HEIGHT) );
\r
5755 MemFile_fprintf (f, ")\n");
\r
5758 // NOTE: why the hell is this called Naturalize?
\r
5759 // we dispatch either to Patch+Naturalize or Patch_CapTexture..
\r
5760 void Patch_NaturalizeSelected(bool bCap)
\r
5762 for (brush_t *pb = selected_brushes.next ; pb != &selected_brushes ; pb = pb->next)
\r
5764 if (pb->patchBrush)
\r
5767 Patch_CapTexture(pb->pPatch);//, bCycleCap);
\r
5769 Patch_Naturalize(pb->pPatch);
\r
5774 // go through the selected patches and call Patch_CapTexture
\r
5775 // deal with cycling
\r
5776 void Patch_CycleCapSelected()
\r
5778 // compute the g_vCycleCapNormal according to g_nCycleCapIndex
\r
5779 VectorClear (g_vCycleCapNormal);
\r
5780 g_vCycleCapNormal[g_nCycleCapIndex] = 1.0f; // cf VIEWTYPE defintion: enum VIEWTYPE {YZ, XZ, XY};
\r
5781 for (brush_t *pb = selected_brushes.next ; pb != &selected_brushes ; pb = pb->next)
\r
5783 if (pb->patchBrush)
\r
5785 Patch_CapTexture(pb->pPatch, true);
\r
5788 switch (g_nCycleCapIndex)
\r
5791 g_nCycleCapIndex = XZ;
\r
5794 g_nCycleCapIndex = XY;
\r
5797 g_nCycleCapIndex = YZ;
\r
5802 bool within(vec3_t vTest, vec3_t vTL, vec3_t vBR)
\r
5804 int nDim1 = (g_pParentWnd->ActiveXY()->GetViewType() == YZ) ? 1 : 0;
\r
5805 int nDim2 = (g_pParentWnd->ActiveXY()->GetViewType() == XY) ? 1 : 2;
\r
5806 if ((vTest[nDim1] > vTL[nDim1] && vTest[nDim1] < vBR[nDim1]) ||
\r
5807 (vTest[nDim1] < vTL[nDim1] && vTest[nDim1] > vBR[nDim1]))
\r
5809 if ((vTest[nDim2] > vTL[nDim2] && vTest[nDim2] < vBR[nDim2]) ||
\r
5810 (vTest[nDim2] < vTL[nDim2] && vTest[nDim2] > vBR[nDim2]))
\r
5817 void Patch_SelectAreaPoints(bool bMulti)
\r
5820 g_qeglobals.d_num_move_points = 0;
\r
5822 if( g_nPatchClickedView == W_CAMERA ) {
\r
5823 // Clip against a pyramid
\r
5824 // Create our 5 normals (that are pointing to the inside)
\r
5825 camera_t *m_pCamera = g_pParentWnd->GetCamWnd()->Camera();
\r
5827 float r[2], u[2], hh, hw;
\r
5829 vec_t corners[2][2];
\r
5833 VectorCopy( m_pCamera->vpn, norm[0] ); // only points in front of the camera
\r
5835 // get our rectangle
\r
5836 corners[0][0] = MIN( g_qeglobals.d_vAreaTL[0], g_qeglobals.d_vAreaBR[0] );
\r
5837 corners[0][1] = MAX( g_qeglobals.d_vAreaTL[1], g_qeglobals.d_vAreaBR[1] );
\r
5838 corners[1][0] = MAX( g_qeglobals.d_vAreaTL[0], g_qeglobals.d_vAreaBR[0] );
\r
5839 corners[1][1] = MIN( g_qeglobals.d_vAreaTL[1], g_qeglobals.d_vAreaBR[1] );
\r
5841 // calculate our four ray vectors
\r
5842 hh = m_pCamera->height/2;
\r
5843 hw = m_pCamera->width/2;
\r
5844 u[0] = (float)(corners[0][1] - hh) / (hw);
\r
5845 r[0] = (float)(corners[0][0] - hw) / (hw);
\r
5846 u[1] = (float)(corners[1][1] - hh) / (hw);
\r
5847 r[1] = (float)(corners[1][0] - hw) / (hw);
\r
5849 for (idx=0 ; idx<3; idx++)
\r
5850 ray[0][idx] = m_pCamera->vpn[idx] + m_pCamera->vright[idx] * r[0] + m_pCamera->vup[idx] * u[0];
\r
5851 for (idx=0 ; idx<3; idx++)
\r
5852 ray[1][idx] = m_pCamera->vpn[idx] + m_pCamera->vright[idx] * r[1] + m_pCamera->vup[idx] * u[0];
\r
5853 for (idx=0 ; idx<3; idx++)
\r
5854 ray[2][idx] = m_pCamera->vpn[idx] + m_pCamera->vright[idx] * r[1] + m_pCamera->vup[idx] * u[1];
\r
5855 for (idx=0 ; idx<3; idx++)
\r
5856 ray[3][idx] = m_pCamera->vpn[idx] + m_pCamera->vright[idx] * r[0] + m_pCamera->vup[idx] * u[1];
\r
5858 // Create our four other directions from these
\r
5859 CrossProduct( ray[0], ray[1], norm[1] ); VectorNormalize( norm[1], norm[1] );
\r
5860 CrossProduct( ray[1], ray[2], norm[2] ); VectorNormalize( norm[2], norm[2] );
\r
5861 CrossProduct( ray[2], ray[3], norm[3] ); VectorNormalize( norm[3], norm[3] );
\r
5862 CrossProduct( ray[3], ray[0], norm[4] ); VectorNormalize( norm[4], norm[4] );
\r
5865 for (brush_t *pb = selected_brushes.next ; pb != &selected_brushes ; pb = pb->next)
\r
5867 if (pb->patchBrush)
\r
5869 patchMesh_t *p = pb->pPatch;
\r
5870 for (int i = 0; i < p->width; i++)
\r
5872 for (int j = 0; j < p->height; j++)
\r
5874 VectorSubtract( m_pCamera->origin, p->ctrl[i][j].xyz, check );
\r
5875 VectorNormalize( check, check );
\r
5876 for (idx=0 ; idx<5; idx++)
\r
5878 if (DotProduct(check, norm[idx])>=0)
\r
5881 if (idx == 5) // all test were good
\r
5883 if (bMulti && PointInMoveList(p->ctrl[i][j].xyz) != -1)
\r
5884 RemovePointFromMoveList(p->ctrl[i][j].xyz);
\r
5886 g_qeglobals.d_move_points[g_qeglobals.d_num_move_points++] = p->ctrl[i][j].xyz;
\r
5894 // Simple 2D clipping
\r
5895 for (brush_t *pb = selected_brushes.next ; pb != &selected_brushes ; pb = pb->next)
\r
5897 if (pb->patchBrush)
\r
5899 patchMesh_t *p = pb->pPatch;
\r
5900 for (int i = 0; i < p->width; i++)
\r
5902 for (int j = 0; j < p->height; j++)
\r
5904 if (within(p->ctrl[i][j].xyz, g_qeglobals.d_vAreaTL, g_qeglobals.d_vAreaBR))
\r
5906 if (bMulti && PointInMoveList(p->ctrl[i][j].xyz) != -1)
\r
5907 RemovePointFromMoveList(p->ctrl[i][j].xyz);
\r
5909 g_qeglobals.d_move_points[g_qeglobals.d_num_move_points++] = p->ctrl[i][j].xyz;
\r
5917 g_nPatchClickedView = -1;
\r
5920 // TTimo: return the shader name for a patch
\r
5921 const char* Patch_GetTextureName()
\r
5923 brush_t* b = selected_brushes.next;
\r
5924 if (b->patchBrush)
\r
5926 patchMesh_t *p = b->pPatch;
\r
5927 return p->pShader->getName();
\r
5932 patchMesh_t* Patch_Duplicate(patchMesh_t *pFrom)
\r
5934 patchMesh_t* p = MakeNewPatch();
\r
5935 memcpy(p, pFrom , sizeof(patchMesh_t));
\r
5937 // spog - initialise patch LOD pointers (again)
\r
5938 Patch_InitialiseLODPointers(p);
\r
5939 p->drawLists = NULL;
\r
5941 p->bSelected = false;
\r
5943 p->bOverlay = false;
\r
5945 AddBrushForPatch(p);
\r
5951 void Patch_Thicken(int nAmount, bool bSeam, qboolean bGroupResult)
\r
5955 patchMesh_t *pSeam;
\r
5956 vec3_t vMin, vMax;
\r
5957 CPtrArray brushes;
\r
5959 nAmount = -nAmount;
\r
5962 if (!QE_SingleBrush())
\r
5964 Sys_Printf("Cannot thicken multiple patches. Please select a single patch.\n");
\r
5968 for (brush_t *pb = selected_brushes.next ; pb != &selected_brushes ; pb = pb->next)
\r
5970 if (pb->patchBrush)
\r
5972 patchMesh_t *p = pb->pPatch;
\r
5973 Patch_MeshNormals(p);
\r
5974 patchMesh_t *pNew = Patch_Duplicate(p);
\r
5975 for (i = 0; i < p->width; i++)
\r
5977 for (j = 0; j < p->height; j++)
\r
5979 VectorMA (p->ctrl[i][j].xyz, nAmount, p->ctrl[i][j].normal, pNew->ctrl[i][j].xyz);
\r
5983 Patch_Rebuild(pNew);
\r
5984 pNew->type |= PATCH_THICK;
\r
5985 brushes.Add(pNew->pSymbiot);
\r
5990 // FIXME: this should detect if any edges of the patch are closed and act appropriately
\r
5992 if (!(p->type & PATCH_CYLINDER))
\r
5994 b = Patch_GenericMesh(3, p->height, 2, false, true);
\r
5995 pSeam = b->pPatch;
\r
5996 pSeam->type |= PATCH_SEAM;
\r
5997 for (i = 0; i < p->height; i++)
\r
5999 VectorCopy(p->ctrl[0][i].xyz, pSeam->ctrl[0][i].xyz);
\r
6000 VectorCopy(pNew->ctrl[0][i].xyz, pSeam->ctrl[2][i].xyz);
\r
6001 VectorAdd(pSeam->ctrl[0][i].xyz, pSeam->ctrl[2][i].xyz, pSeam->ctrl[1][i].xyz);
\r
6002 VectorScale(pSeam->ctrl[1][i].xyz, 0.5, pSeam->ctrl[1][i].xyz);
\r
6006 Patch_CalcBounds(pSeam, vMin, vMax);
\r
6007 Brush_RebuildBrush(pSeam->pSymbiot, vMin, vMax);
\r
6008 //--Patch_CapTexture(pSeam);
\r
6009 Patch_Naturalize(pSeam);
\r
6010 patchInvert(pSeam);
\r
6014 b = Patch_GenericMesh(3, p->height, 2, false, true);
\r
6015 pSeam = b->pPatch;
\r
6016 pSeam->type |= PATCH_SEAM;
\r
6017 for (i = 0; i < p->height; i++)
\r
6019 VectorCopy(p->ctrl[w][i].xyz, pSeam->ctrl[0][i].xyz);
\r
6020 VectorCopy(pNew->ctrl[w][i].xyz, pSeam->ctrl[2][i].xyz);
\r
6021 VectorAdd(pSeam->ctrl[0][i].xyz, pSeam->ctrl[2][i].xyz, pSeam->ctrl[1][i].xyz);
\r
6022 VectorScale(pSeam->ctrl[1][i].xyz, 0.5, pSeam->ctrl[1][i].xyz);
\r
6024 Patch_CalcBounds(pSeam, vMin, vMax);
\r
6025 Brush_RebuildBrush(pSeam->pSymbiot, vMin, vMax);
\r
6026 //--Patch_CapTexture(pSeam);
\r
6027 Patch_Naturalize(pSeam);
\r
6032 // otherwise we will add one per end
\r
6033 b = Patch_GenericMesh(p->width, 3, 2, false, true);
\r
6034 pSeam = b->pPatch;
\r
6035 pSeam->type |= PATCH_SEAM;
\r
6036 for (i = 0; i < p->width; i++)
\r
6038 VectorCopy(p->ctrl[i][0].xyz, pSeam->ctrl[i][0].xyz);
\r
6039 VectorCopy(pNew->ctrl[i][0].xyz, pSeam->ctrl[i][2].xyz);
\r
6040 VectorAdd(pSeam->ctrl[i][0].xyz, pSeam->ctrl[i][2].xyz, pSeam->ctrl[i][1].xyz);
\r
6041 VectorScale(pSeam->ctrl[i][1].xyz, 0.5, pSeam->ctrl[i][1].xyz);
\r
6045 Patch_CalcBounds(pSeam, vMin, vMax);
\r
6046 Brush_RebuildBrush(pSeam->pSymbiot, vMin, vMax);
\r
6047 //--Patch_CapTexture(pSeam);
\r
6048 Patch_Naturalize(pSeam);
\r
6049 patchInvert(pSeam);
\r
6052 h = p->height - 1;
\r
6053 b = Patch_GenericMesh(p->width, 3, 2, false, true);
\r
6054 pSeam = b->pPatch;
\r
6055 pSeam->type |= PATCH_SEAM;
\r
6056 for (i = 0; i < p->width; i++)
\r
6058 VectorCopy(p->ctrl[i][h].xyz, pSeam->ctrl[i][0].xyz);
\r
6059 VectorCopy(pNew->ctrl[i][h].xyz, pSeam->ctrl[i][2].xyz);
\r
6060 VectorAdd(pSeam->ctrl[i][0].xyz, pSeam->ctrl[i][2].xyz, pSeam->ctrl[i][1].xyz);
\r
6061 VectorScale(pSeam->ctrl[i][1].xyz, 0.5, pSeam->ctrl[i][1].xyz);
\r
6063 Patch_CalcBounds(pSeam, vMin, vMax);
\r
6064 Brush_RebuildBrush(pSeam->pSymbiot, vMin, vMax);
\r
6065 //--Patch_CapTexture(pSeam);
\r
6066 Patch_Naturalize(pSeam);
\r
6070 patchInvert(pNew);
\r
6074 for (i = 0; i < brushes.GetSize(); i++)
\r
6076 Select_Brush(reinterpret_cast<brush_t*>(brushes.GetAt(i)));
\r
6081 entity_t *e = Entity_Alloc();
\r
6082 SetKeyValue(e, "classname", "func_group");
\r
6083 SetKeyValue(e, "type", "patchThick");
\r
6084 Select_GroupEntity(e);
\r
6085 Entity_AddToList(e, &entities);
\r
6088 UpdatePatchInspector();
\r
6093 lets get another list together as far as necessities..
\r
6095 *snapping stuff to the grid (i will only snap movements by the mouse to the grid.. snapping the rotational bend stuff will fubar everything)
\r
6097 capping bevels/endcaps
\r
6101 texture fix for caps
\r
6111 void Patch_SetOverlays()
\r
6113 for (brush_t *pb = selected_brushes.next ; pb != &selected_brushes ; pb = pb->next)
\r
6115 if (pb->patchBrush)
\r
6117 pb->pPatch->bOverlay = true;
\r
6124 void Patch_ClearOverlays()
\r
6127 for (pb = selected_brushes.next ; pb != &selected_brushes ; pb = pb->next)
\r
6129 if (pb->patchBrush)
\r
6131 pb->pPatch->bOverlay = false;
\r
6135 for (pb = active_brushes.next ; pb != &active_brushes ; pb = pb->next)
\r
6137 if (pb->patchBrush)
\r
6139 pb->pPatch->bOverlay = false;
\r
6145 // FIXME: spog - er, someone forgot to finish their patch point freezing feature?
\r
6146 // freezes selected vertices
\r
6147 void Patch_Freeze()
\r
6150 for (pb = selected_brushes.next ; pb != &selected_brushes ; pb = pb->next)
\r
6152 if (pb->patchBrush)
\r
6154 pb->pPatch->bOverlay = false;
\r
6158 for (pb = active_brushes.next ; pb != &active_brushes ; pb = pb->next)
\r
6160 if (pb->patchBrush)
\r
6162 pb->pPatch->bOverlay = false;
\r
6168 void Patch_UnFreeze(bool bAll)
\r
6172 void Patch_Transpose()
\r
6176 for (brush_t *pb = selected_brushes.next ; pb != &selected_brushes ; pb = pb->next)
\r
6178 if (pb->patchBrush)
\r
6180 patchMesh_t *p = pb->pPatch;
\r
6182 if ( p->width > p->height )
\r
6184 for ( i = 0 ; i < p->height ; i++ )
\r
6186 for ( j = i + 1 ; j < p->width ; j++ )
\r
6188 if ( j < p->height )
\r
6191 memcpy(&dv,&p->ctrl[j][i],sizeof(drawVert_t));
\r
6192 memcpy(&p->ctrl[j][i],&p->ctrl[i][j], sizeof(drawVert_t));
\r
6193 memcpy(&p->ctrl[i][j],&dv, sizeof(drawVert_t));
\r
6198 memcpy(&p->ctrl[i][j],&p->ctrl[j][i], sizeof(drawVert_t));
\r
6205 for ( i = 0 ; i < p->width ; i++ )
\r
6207 for ( j = i + 1 ; j < p->height ; j++ )
\r
6209 if ( j < p->width )
\r
6212 memcpy(&dv,&p->ctrl[i][j], sizeof(drawVert_t));
\r
6213 memcpy(&p->ctrl[i][j],&p->ctrl[j][i], sizeof(drawVert_t));
\r
6214 memcpy(&p->ctrl[j][i],&dv, sizeof(drawVert_t));
\r
6219 memcpy(&p->ctrl[j][i],&p->ctrl[i][j], sizeof(drawVert_t));
\r
6226 p->width = p->height;
\r
6236 void Patch_SnapToGrid(patchMesh_t *p)
\r
6240 // if patch points selected, snap only selected points
\r
6241 if (g_qeglobals.d_select_mode == sel_curvepoint && g_qeglobals.d_num_move_points != 0)
\r
6242 for (i=0; i<g_qeglobals.d_num_move_points; i++)
\r
6243 for (j = 0; j < 3; j++)
\r
6244 g_qeglobals.d_move_points[i][j] = floor(g_qeglobals.d_move_points[i][j] / g_qeglobals.d_gridsize + 0.5) * g_qeglobals.d_gridsize;
\r
6246 // else snap all patch points
\r
6248 for (i = 0; i < p->width; i++)
\r
6249 for (j = 0; j < p->height; j++)
\r
6250 for (k = 0; k < 3; k++)
\r
6251 p->ctrl[i][j].xyz[k] = floor(p->ctrl[i][j].xyz[k] / g_qeglobals.d_gridsize + 0.5) * g_qeglobals.d_gridsize;
\r
6253 vec3_t vMin, vMax;
\r
6254 Patch_CalcBounds(p, vMin, vMax);
\r
6255 Brush_RebuildBrush(p->pSymbiot, vMin, vMax);
\r
6259 void Patch_FindReplaceTexture(brush_t *pb, const char *pFind, const char *pReplace, bool bForce)
\r
6261 if (pb->patchBrush)
\r
6263 patchMesh_t *p = pb->pPatch;
\r
6264 if (bForce || strcmpi(p->pShader->getName(), pFind) == 0)
\r
6266 p->pShader->DecRef();
\r
6267 p->pShader = QERApp_Shader_ForName(pReplace);
\r
6268 p->d_texture = p->pShader->getTexture();
\r
6273 /* uncomment if necessary, currently not used
\r
6274 void Patch_FromTriangle(vec5_t vx, vec5_t vy, vec5_t vz)
\r
6276 patchMesh_t* p = MakeNewPatch();
\r
6277 p->pShader = g_qeglobals.d_texturewin.pShader;
\r
6278 p->d_texture = g_qeglobals.d_texturewin.pShader->getTexture();
\r
6281 p->type = PATCH_TRIANGLE;
\r
6287 // 1 0 goes to mid of x and z
\r
6288 // 1 1 goes to mid of x y and z
\r
6289 // 1 2 goes to mid of x and y
\r
6292 // 2 1 goes to mid of y and z
\r
6300 for (j = 0; j < 3; j++)
\r
6302 _Vector5Add(vx, vz, vMidXZ);
\r
6303 _Vector5Scale(vMidXZ, 0.5, vMidXZ);
\r
6304 //vMidXZ[j] = vx[j] + abs((vx[j] - vz[j]) * 0.5);
\r
6307 for (j = 0; j < 3; j++)
\r
6309 _Vector5Add(vx, vy, vMidXY);
\r
6310 _Vector5Scale(vMidXY, 0.5, vMidXY);
\r
6311 //vMidXY[j] = vx[j] + abs((vx[j] - vy[j]) * 0.5);
\r
6314 for (j = 0; j < 3; j++)
\r
6316 _Vector5Add(vy, vz, vMidYZ);
\r
6317 _Vector5Scale(vMidYZ, 0.5, vMidYZ);
\r
6318 //vMidYZ[j] = vy[j] + abs((vy[j] - vz[j]) * 0.5);
\r
6321 _Vector53Copy(vx, p->ctrl[0][0].xyz);
\r
6322 _Vector53Copy(vx, p->ctrl[0][1].xyz);
\r
6323 _Vector53Copy(vx, p->ctrl[0][2].xyz);
\r
6324 p->ctrl[0][0].st[0] = vx[3];
\r
6325 p->ctrl[0][0].st[1] = vx[4];
\r
6326 p->ctrl[0][1].st[0] = vx[3];
\r
6327 p->ctrl[0][1].st[1] = vx[4];
\r
6328 p->ctrl[0][2].st[0] = vx[3];
\r
6329 p->ctrl[0][2].st[1] = vx[4];
\r
6331 _Vector53Copy(vMidXY, p->ctrl[1][0].xyz);
\r
6332 _Vector53Copy(vx, p->ctrl[1][1].xyz);
\r
6333 _Vector53Copy(vMidXZ, p->ctrl[1][2].xyz);
\r
6334 p->ctrl[1][0].st[0] = vMidXY[3];
\r
6335 p->ctrl[1][0].st[1] = vMidXY[4];
\r
6336 p->ctrl[1][1].st[0] = vx[3];
\r
6337 p->ctrl[1][1].st[1] = vx[4];
\r
6338 p->ctrl[1][2].st[0] = vMidXZ[3];
\r
6339 p->ctrl[1][2].st[1] = vMidXZ[4];
\r
6341 _Vector53Copy(vy, p->ctrl[2][0].xyz);
\r
6342 _Vector53Copy(vMidYZ, p->ctrl[2][1].xyz);
\r
6343 _Vector53Copy(vz, p->ctrl[2][2].xyz);
\r
6344 p->ctrl[2][0].st[0] = vy[3];
\r
6345 p->ctrl[2][0].st[1] = vy[4];
\r
6346 p->ctrl[2][1].st[0] = vMidYZ[3];
\r
6347 p->ctrl[2][1].st[1] = vMidYZ[4];
\r
6348 p->ctrl[2][2].st[0] = vz[3];
\r
6349 p->ctrl[2][2].st[1] = vz[4];
\r
6352 //Patch_Naturalize(p);
\r
6355 AddBrushForPatch(p);
\r
6360 #ifdef ENABLE_GROUPS
\r
6364 sets an epair for the given patch
\r
6367 void Patch_SetEpair(patchMesh_t *p, const char *pKey, const char *pValue)
\r
6369 if (g_qeglobals.m_bBrushPrimitMode)
\r
6371 SetKeyValue(p->epairs, pKey, pValue);
\r
6380 const char* Patch_GetKeyValue(patchMesh_t *p, const char *pKey)
\r
6382 if (g_qeglobals.m_bBrushPrimitMode)
\r
6384 return ValueForKey(p->epairs, pKey);
\r
6391 //Real nitpicky, but could you make CTRL-S save the current map with the current name? (ie: File/Save)
\r
6394 When reading in textures, please check for the presence of a file called "textures.link" or something, which contains one line such as;
\r
6396 g:\quake3\baseq3\textures\common
\r
6398 So that, when I'm reading in, lets say, my \eerie directory, it goes through and adds my textures to the palette, along with everything in common.
\r
6400 Don't forget to add "Finer texture alignment" to the list. I'd like to be able to move in 0.1 increments using the Shift-Arrow Keys.
\r
6402 No. Sometimes textures are drawn the wrong way on patches. We'd like the ability to flip a texture. Like the way X/Y scale -1 used to worked.
\r
6404 1) Easier way of deleting rows, columns
\r
6405 2) Fine tuning of textures on patches (X/Y shifts other than with the surface dialog)
\r
6406 2) Patch matrix transposition
\r
6408 1) Actually, bump texture flipping on patches to the top of the list of things to do.
\r
6409 2) When you select a patch, and hit S, it should read in the selected patch texture. Should not work if you multiselect patches and hit S
\r
6410 3) Brandon has a wierd anomoly. He fine-tunes a patch with caps. It looks fine when the patch is selected, but as soon as he escapes out, it reverts to it's pre-tuned state. When he selects the patch again, it looks tuned
\r
6413 *1) Flipping textures on patches
\r
6414 *2) When you select a patch, and hit S, it should read in the selected patch texture. Should not work if you multiselect patches and hit S
\r
6415 3) Easier way of deleting rows columns
\r
6417 5) Patch matrix transposition
\r
6418 6) Inverted cylinder capping
\r
6422 Have a new feature request. "Compute Bounding Box" for mapobjects (md3 files). This would be used for misc_mapobject (essentially, drop in 3DS Max models into our maps)
\r
6424 Ok, Feature Request. Load and draw MD3's in the Camera view with proper bounding boxes. This should be off misc_model
\r
6426 Feature Addition: View/Hide Hint Brushes -- This should be a specific case.
\r
projects / xonotic / netradiant.git / blob