void Select_FitTexture( int nHeight, int nWidth )
{
brush_s* b;
int nFaceCount = g_ptrSelectedFaces.GetSize();
if ( selected_brushes.next == &selected_brushes && nFaceCount == 0 )
return;
for ( b = selected_brushes.next ; b != &selected_brushes ; b = b->next )
{
Brush_FitTexture( b, nHeight, nWidth );
Brush_Build( b );
}
if ( nFaceCount > 0 )
{
for ( int i = 0; i < nFaceCount; i++ )
{
face_s* selFace = reinterpret_cast<face_s*>( g_ptrSelectedFaces.GetAt( i ) );
brush_s* selBrush = reinterpret_cast<brush_s*>( g_ptrSelectedFaceBrushes.GetAt( i ) );
Face_FitTexture( selFace, nHeight, nWidth );
Brush_Build( selBrush );
}
}
Sys_UpdateWindows( W_CAMERA );
}
void SI_FaceList_FitTexture(texdef_to_face_t* si_texdef_face_list, int nHeight, int nWidth)
{
texdef_to_face_t* temp_texdef_face_list;
brushprimit_texdef_t bp;
if (!si_texdef_face_list)
return;
for (temp_texdef_face_list = si_texdef_face_list; temp_texdef_face_list; temp_texdef_face_list = temp_texdef_face_list->next)
{
Face_FitTexture(temp_texdef_face_list->face, nHeight, nWidth);
Brush_Build(temp_texdef_face_list->brush,true,true,false,false);
// Write changes to our working Texdef list
if(g_qeglobals.m_bBrushPrimitMode)
{
ConvertTexMatWithQTexture(&temp_texdef_face_list->face->brushprimit_texdef, QERApp_Shader_ForName( temp_texdef_face_list->face->texdef.GetName() )->getTexture(), &bp, NULL);
TexMatToFakeTexCoords(bp.coords, temp_texdef_face_list->face->texdef.shift, &temp_texdef_face_list->face->texdef.rotate, temp_texdef_face_list->face->texdef.scale);
}
temp_texdef_face_list->texdef = temp_texdef_face_list->face->texdef;
}
Sys_UpdateWindows (W_CAMERA);
}
void Select_FitTexture(int nHeight, int nWidth)
{
brush_t *b;
if(selected_brushes.next == &selected_brushes && selected_face == NULL)
return;
for (b=selected_brushes.next ; b != &selected_brushes ; b=b->next)
{
Brush_FitTexture(b, nHeight, nWidth);
Brush_Build(b);
}
if (selected_face)
{
Face_FitTexture(selected_face, nHeight, nWidth);
Brush_Build(selected_face_brush);
}
Sys_UpdateWindows (W_CAMERA);
}
/*
===========
Drag_Begin
//++timo test three button mouse and three button emulation here ?
===========
*/
void Drag_Begin (int x, int y, int buttons,
vec3_t xaxis, vec3_t yaxis,
vec3_t origin, vec3_t dir)
{
trace_t t;
drag_ok = false;
VectorCopy (vec3_origin, pressdelta);
VectorCopy (vec3_origin, vPressStart);
drag_first = true;
peLink = NULL;
// shift LBUTTON = select entire brush
if (buttons == (MK_LBUTTON | MK_SHIFT) && g_qeglobals.d_select_mode != sel_curvepoint)
{
int nFlag = (static_cast<bool>(::GetAsyncKeyState(VK_MENU))) ? SF_CYCLE : 0;
if (dir[0] == 0 || dir[1] == 0 || dir[2] == 0) // extremely low chance of this happening from camera
Select_Ray (origin, dir, nFlag | SF_ENTITIES_FIRST); // hack for XY
else
Select_Ray (origin, dir, nFlag);
return;
}
// ctrl-shift LBUTTON = select single face
if (buttons == (MK_LBUTTON | MK_CONTROL | MK_SHIFT) && g_qeglobals.d_select_mode != sel_curvepoint)
{
Sys_Printf ("Face Selection?\n");
Select_Deselect (!static_cast<bool>(::GetAsyncKeyState(VK_MENU)));
Select_Ray (origin, dir, SF_SINGLEFACE);
return;
}
// LBUTTON + all other modifiers = manipulate selection
if (buttons & MK_LBUTTON)
{
//
Drag_Setup (x, y, buttons, xaxis, yaxis, origin, dir);
return;
}
// JONATHAN: stuff to add here
int nMouseButton = g_PrefsDlg.m_nMouseButtons == 2 ? MK_RBUTTON : MK_MBUTTON;
// middle button = grab texture
if (buttons == nMouseButton)
{
t = Test_Ray (origin, dir, false);
if (t.face)
{
//++timo clean
#if 0
// g_qeglobals.d_new_brush_bottom_z = t.brush->mins[2];
// g_qeglobals.d_new_brush_top_z = t.brush->maxs[2];
// g_pParentWnd->ActiveXY()->GetViewType()
// cf VIEWTYPE definition: enum VIEWTYPE {YZ, XZ, XY};
// we fit our work zone to the brush
int nViewType = g_pParentWnd->ActiveXY()->GetViewType();
int nDim1 = (nViewType == YZ) ? 1 : 0;
int nDim2 = (nViewType == XY) ? 1 : 2;
g_qeglobals.d_work_min[nDim1] = t.brush->mins[nDim1];
g_qeglobals.d_work_max[nDim1] = t.brush->maxs[nDim1];
g_qeglobals.d_work_min[nDim2] = t.brush->mins[nDim2];
g_qeglobals.d_work_max[nDim2] = t.brush->maxs[nDim2];
#endif
// JONATHAN:: On ALT-Middle mouse
// Fit texture to face
SHORT altdown = (GetKeyState(VK_MENU) & 0x8000);
if (altdown)
{
// Fit Texture to brush face
Face_FitTexture(t.face, 1, 1);
// Build Brush to apply update
Brush_Build(t.brush); //?
// Update Camera View
Sys_UpdateWindows (W_CAMERA);
}
else
{
UpdateWorkzone_ForBrush( t.brush );
// use a local brushprimit_texdef fitted to a default 2x2 texture
brushprimit_texdef_t bp_local;
ConvertTexMatWithQTexture( &t.face->brushprimit_texdef, t.face->d_texture, &bp_local, NULL );
Texture_SetTexture ( &t.face->texdef, &bp_local, false, GETPLUGINTEXDEF(t.face));
UpdateSurfaceDialog();
UpdatePatchInspector();
}
}
else
Sys_Printf ("Did not select a texture\n");
return;
}
// ctrl-middle button = set entire brush to texture
if (buttons == (nMouseButton|MK_CONTROL) )
{
t = Test_Ray (origin, dir, false);
if (t.brush)
{
if (t.brush->brush_faces->texdef.name[0] == '(')
Sys_Printf ("Can't change an entity texture\n");
else
{
Brush_SetTexture (t.brush, &g_qeglobals.d_texturewin.texdef, &g_qeglobals.d_texturewin.brushprimit_texdef, false, static_cast<IPluginTexdef *>( g_qeglobals.d_texturewin.pTexdef ) );
Sys_UpdateWindows (W_ALL);
}
}
else
Sys_Printf ("Didn't hit a btrush\n");
return;
}
// JONATHAN:HERE
// ctrl-shift-middle button = set single face to texture
if (buttons == (nMouseButton|MK_SHIFT|MK_CONTROL) )
{
t = Test_Ray (origin, dir, false);
if (t.brush)
{
if (t.brush->brush_faces->texdef.name[0] == '(')
Sys_Printf ("Can't change an entity texture\n");
else
{
SetFaceTexdef (t.brush, t.face, &g_qeglobals.d_texturewin.texdef, &g_qeglobals.d_texturewin.brushprimit_texdef);
Brush_Build( t.brush );
Sys_UpdateWindows (W_ALL);
}
}
else
Sys_Printf ("Didn't hit a btrush\n");
return;
}
if (buttons == (nMouseButton | MK_SHIFT))
{
Sys_Printf("Set brush face texture info\n");
t = Test_Ray (origin, dir, false);
if (t.brush)
{
if (t.brush->brush_faces->texdef.name[0] == '(')
{
if (t.brush->owner->eclass->nShowFlags & ECLASS_LIGHT)
{
CString strBuff;
qtexture_t* pTex = g_qeglobals.d_texturewin.pShader->getTexture();
if (pTex)
{
vec3_t vColor;
VectorCopy(pTex->color, vColor);
float fLargest = 0.0f;
for (int i = 0; i < 3; i++)
{
if (vColor[i] > fLargest)
fLargest = vColor[i];
}
if (fLargest == 0.0f)
{
vColor[0] = vColor[1] = vColor[2] = 1.0f;
}
else
{
float fScale = 1.0f / fLargest;
for (int i = 0; i < 3; i++)
{
vColor[i] *= fScale;
}
}
strBuff.Format("%f %f %f",pTex->color[0], pTex->color[1], pTex->color[2]);
SetKeyValue(t.brush->owner, "_color", strBuff.GetBuffer(0));
Sys_UpdateWindows (W_ALL);
}
}
else
{
Sys_Printf ("Can't select an entity brush face\n");
}
}
else
{
//strcpy(t.face->texdef.name,g_qeglobals.d_texturewin.texdef.name);
t.face->texdef.SetName(g_qeglobals.d_texturewin.texdef.name);
Brush_Build(t.brush);
Sys_UpdateWindows (W_ALL);
}
}
else
Sys_Printf ("Didn't hit a brush\n");
return;
}
}
void Select_AutoCaulk()
{
/*Sys_Printf*/common->Printf("Caulking...\n");
FacesToCaulk.Clear();
int iSystemBrushesSkipped = 0;
face_t *pSelectedFace;
brush_t *next;
for (brush_t *pSelectedBrush = selected_brushes.next ; pSelectedBrush != &selected_brushes ; pSelectedBrush = next)
{
next = pSelectedBrush->next;
if (pSelectedBrush->owner->eclass->fixedsize)
continue; // apparently this means it's a model, so skip it...
// new check, we can't caulk a brush that has any "system/" faces...
//
bool bSystemFacePresent = false;
for ( pSelectedFace = pSelectedBrush->brush_faces; pSelectedFace; pSelectedFace = pSelectedFace->next)
{
if (!strnicmp(pSelectedFace->d_texture->GetName(),"system/",7))
{
bSystemFacePresent = true;
break;
}
}
if (bSystemFacePresent)
{
iSystemBrushesSkipped++;
continue; // verboten to caulk this.
}
for (int iBrushListToScan = 0; iBrushListToScan<2; iBrushListToScan++)
{
brush_t *snext;
for (brush_t *pScannedBrush = (iBrushListToScan?active_brushes.next:selected_brushes.next); pScannedBrush != (iBrushListToScan?&active_brushes:&selected_brushes) ; pScannedBrush = snext)
{
snext = pScannedBrush->next;
if ( pScannedBrush == pSelectedBrush)
continue;
if (pScannedBrush->owner->eclass->fixedsize || pScannedBrush->pPatch || pScannedBrush->hiddenBrush)
continue;
if (FilterBrush(pScannedBrush))
continue;
// idMaterial stuff no longer support this, not sure what else to do.
// Searching for other occurences of QER_NOCARVE just shows people REMing the code and ignoring ths issue...
//
// if (pScannedBrush->brush_faces->d_texture->bFromShader && (pScannedBrush->brush_faces->d_texture->TestMaterialFlag(QER_NOCARVE)))
// continue;
// basic-reject first to see if brushes can even possibly touch (coplanar counts as touching)
//
int i;
for (i=0 ; i<3 ; i++)
{
if (pSelectedBrush->mins[i] > pScannedBrush->maxs[i] ||
pSelectedBrush->maxs[i] < pScannedBrush->mins[i])
{
break;
}
}
if (i != 3)
continue; // can't be touching
// ok, now for the clever stuff, we need to detect only those faces that are both coplanar and smaller
// or equal to the face they're coplanar with...
//
for (pSelectedFace = pSelectedBrush->brush_faces; pSelectedFace; pSelectedFace = pSelectedFace->next)
{
idWinding *pSelectedWinding = pSelectedFace->face_winding;
if (!pSelectedWinding)
continue; // freed face, probably won't happen here, but who knows with this program?
// SquaredFace_t SelectedSquaredFace;
// WindingToSquaredFace( &SelectedSquaredFace, pSelectedWinding);
for (face_t *pScannedFace = pScannedBrush->brush_faces; pScannedFace; pScannedFace = pScannedFace->next)
{
// don't even try caulking against a system face, because these are often transparent and will leave holes
//
if (!strnicmp(pScannedFace->d_texture->GetName(),"system/",7))
continue;
// and don't try caulking against something inherently transparent...
//
if (pScannedFace->d_texture->TestMaterialFlag(QER_TRANS))
continue;
idWinding *pScannedWinding = pScannedFace->face_winding;
if (!pScannedWinding)
continue; // freed face, probably won't happen here, but who knows with this program?
// SquaredFace_t ScannedSquaredFace;
// WindingToSquaredFace( &ScannedSquaredFace, pScannedWinding);
/* if (VectorCompare(ScannedSquaredFace.v3NormalisedRotationVector, SelectedSquaredFace.v3NormalisedRotationVector)
&&
VectorCompare(ScannedSquaredFace.v3NormalisedElevationVector, SelectedSquaredFace.v3NormalisedElevationVector)
)
*/
{
// brush faces are in parallel planes to each other, so check that their normals
// are opposite, by adding them together and testing for zero...
// (if normals are opposite, then faces can be against/touching each other?)
//
idVec3 v3ZeroTest;
idVec3 v3Zero;v3Zero.Zero(); //static idVec3 v3Zero={0,0,0};
VectorAdd(pSelectedFace->plane.Normal(),pScannedFace->plane.Normal(),v3ZeroTest);
if (v3ZeroTest == v3Zero)
{
// planes are facing each other...
//
// coplanar? (this is some maths of Gil's, which I don't even pretend to understand)
//
float fTotalDist = 0;
for (int _i=0; _i<3; _i++)
{
fTotalDist += fabs( DotProduct(pSelectedFace->plane.Normal(),(*pSelectedWinding)[0])
-
DotProduct(pSelectedFace->plane.Normal(),(*pScannedWinding)[i])
);
}
//OutputDebugString(va("Dist = %g\n",fTotalDist));
if (fTotalDist > 0.01)
continue;
// every point in the selected face must be within (or equal to) the bounds of the
// scanned face...
//
// work out the bounds first...
//
idVec3 v3ScannedBoundsMins, v3ScannedBoundsMaxs;
ClearBounds (v3ScannedBoundsMins, v3ScannedBoundsMaxs);
int iPoint;
for (iPoint=0; iPoint<pScannedWinding->GetNumPoints(); iPoint++)
{
AddPointToBounds( (*pScannedWinding)[iPoint].ToVec3(), v3ScannedBoundsMins, v3ScannedBoundsMaxs);
}
// floor 'em... (or .001 differences mess things up...
//
FloorBounds(v3ScannedBoundsMins, v3ScannedBoundsMaxs);
// now check points from selected face...
//
bool bWithin = true;
for (iPoint=0; iPoint < pSelectedWinding->GetNumPoints(); iPoint++)
{
for (int iXYZ=0; iXYZ<3; iXYZ++)
{
float f = floor((*pSelectedWinding)[iPoint][iXYZ] + 0.5);
if (!
(
f >= v3ScannedBoundsMins[iXYZ]
&&
f <= v3ScannedBoundsMaxs[iXYZ]
)
)
{
bWithin = false;
}
}
}
if (bWithin)
{
PairBrushFace_t PairBrushFace;
PairBrushFace.pFace = pSelectedFace;
PairBrushFace.pBrush= pSelectedBrush;
FacesToCaulk.Append(PairBrushFace);
}
}
}
}
}
}
}
}
// apply caulk...
//
int iFacesCaulked = 0;
if (FacesToCaulk.Num())
{
LPCSTR psCaulkName = "textures/common/caulk";
const idMaterial *pCaulk = Texture_ForName(psCaulkName);
if (pCaulk)
{
//
// and call some other junk that Radiant wants so so we can use it later...
//
texdef_t tex;
memset (&tex, 0, sizeof(tex));
tex.scale[0] = 1;
tex.scale[1] = 1;
//tex.flags = pCaulk->flags; // field missing in Q4
//tex.value = pCaulk->value; // ditto
//tex.contents = pCaulk->contents; // ditto
tex.SetName( pCaulk->GetName() );
//Texture_SetTexture (&tex);
for (int iListEntry = 0; iListEntry < FacesToCaulk.Num(); iListEntry++)
{
PairBrushFace_t &PairBrushFace = FacesToCaulk[iListEntry];
face_t *pFace = PairBrushFace.pFace;
brush_t*pBrush= PairBrushFace.pBrush;
pFace->d_texture = pCaulk;
pFace->texdef = tex;
Face_FitTexture(pFace, 1, 1); // this doesn't work here for some reason... duh.
Brush_Build(pBrush);
iFacesCaulked++;
}
}
else
{
/*Sys_Printf*/common->Printf(" Unable to locate caulk texture at: \"%s\"!\n",psCaulkName);
}
}
/*Sys_Printf*/common->Printf("( %d faces caulked )\n",iFacesCaulked);
if (iSystemBrushesSkipped)
{
/*Sys_Printf*/common->Printf("( %d system-faced brushes skipped )\n",iSystemBrushesSkipped);
}
Sys_UpdateWindows (W_ALL);
}
